Implemented option -reassure

master
Thomas Schmitt 15 years ago
parent ee7308f4ad
commit bd6c15ef71

@ -70,10 +70,10 @@ Command processing
.br
Unlike other filesystems, ISO 9660 is not intended for read-write operation but
rather for being generated in a single sweep and being written to media as a
.B session .
.B session.
.br
The data content of a session is called filesystem
.B image .
The data content of the session is called filesystem
.B image.
.PP
The written image in its session can then be mounted by the operating system
for being used read-only. Linux is able to mount ISO images from block devices,
@ -86,8 +86,11 @@ which allows to add information to the CD and gives the mount programs
of the operating systems the addresses of the entry points of each
session. The mount programs recognize block devices which represent
CD media and will by default mount the image in the last session.
.br
This session usually contains an updated directory tree for the whole media
which governs the data contents in all recorded sessions.
So in the view of the mount program all sessions of a particular media
together form a single filesystem image.
.PP
The multi-session model of the MMC standard applies to CD-R[W], to DVD-R, to
certain states of DVD-RW, and to DVD+R. But it does not apply to overwriteable
@ -118,8 +121,8 @@ drive with the eventual ISO image and ends by command -commit which triggers
writing. A -commit is done automatically when the program ends regularly.
.PP
After -commit a new session begins. A new input drive can only be chosen
as long as the loaded ISO image was not altered. Alteration can be revoked
by command -rollback.
as long as the loaded ISO image was not altered.
Pending alteration can be revoked by command -rollback.
.PP
Writing a session to the target is supposed to be very expensive in terms of
time and of consumed space on appendable or write-once media. Therefore all
@ -133,6 +136,7 @@ useful to store intermediate states and to continue with image manipulations.
.br
Source of an existing ISO image can be any random access readable libburn
drive: optical media with readable data, regular files, block devices.
.br
RockRidge info must be present in existing ISO images and it will be generated
by the program unconditionally.
.PP
@ -262,12 +266,15 @@ Note that in the ISO image you are as powerful as the superuser. Access
permissions of the existing files in the image do not apply to your write
operations. They are intended to be in effect with the read-only mounted image.
.PP
If the iso_rr_path of a newly inserted or renamed file leads to an existing
If the iso_rr_path of a newly inserted file leads to an existing
file object in the ISO image, then the following collision handling happens:
.br
If both objects are directories then they get merged by recursively inserting
the subobjects from filesystem into ISO image.
If other file types collide then the setting of command -overwrite decides.
.br
Renaming of files has similar collision handling, but directories can only
be replaced, not merged.
.PP
The commands in this section alter the ISO image and not the local filesystem.
.TP
@ -515,9 +522,15 @@ Describe terminal to the text pager.
? \fB\-use_readline\fR "on"|"off"
If "on" then use readline for dialog. Else use plain stdin.
.TP
> \fB\-reassure\fR "on"|"off"
If "on" then ask the user for "y" or "n" with any file
before deleting or overwriting it in the ISO image.
\fB\-reassure\fR "on"|"tree"|"off"
If "on" then ask the user for "y" or "n"
before deleting or overwriting any file in the ISO image.
With setting "tree" the reassuring prompt will appear for an eventual
directory only once and not for each file in its whole subtree.
Setting "off" silently kills any kind of image file object.
.br
Note that the prompt appears only in situations where file removal
is not forbidden by option -overwrite.
.TP
.B Drive and media related inquiry actions:
.TP

@ -1815,6 +1815,7 @@ int Xorriso_new(struct XorrisO ** xorriso,char *progname, int flag)
m->bar_is_fresh= 0;
m->pending_option[0]= 0;
m->request_to_abort= 0;
m->request_not_to_ask= 0;
m->idle_time= 0.0;
m->re_failed_at= -1;
m->prepended_wd= 0;
@ -1962,11 +1963,16 @@ int Xorriso_request_confirmation(struct XorrisO *xorriso, int flag)
bit0= important operation going on:
demand confirmation of abort, only abort on @@@
bit1= mark '@' and '@@' by return 4
bit2= accept: i=ignore , r=retry , x=abort
bit2= accept: i|n= ignore | do not remove , r|y= retry | remove , q|x= abort
bit3= @@@ = 'done reading' rather than 'abort'
*/
/* return: <=0 error , 1=go on , 2=abort , 3=redo request, 4=see flag bit1
(5=skip volume) , 6=retry failed operation
/* return: <=0 error
1= go on | do not remove existing file
2= abort
3= redo request for confirmation
4= see flag bit1
(5= skip volume)
6= retry failed operation | remove existing file
*/
{
int ret;
@ -2030,7 +2036,7 @@ klammer_affe:;
xorriso->result_page_length= -xorriso->result_page_length;
if(flag&1) {
sprintf(xorriso->info_text,
"... [@ = page prompt suppression registered. -page disabled temporarily ] ...\n");
"... [@ = prompt suppression registered. Prompting disabled temporarily ] ...\n");
Xorriso_info(xorriso,0);
}
@ -2048,16 +2054,20 @@ klammer_affe:;
return(1);
} else if(flag&4) {
if(strcmp(cpt,"i")==0 || strcmp(cpt,"I")==0 || *cpt==0) {
if(strcmp(cpt,"i")==0 || strcmp(cpt,"I")==0 ||
strcmp(cpt,"n")==0 || strcmp(cpt,"N")==0 ||
*cpt==0) {
return(1);
} else if(strcmp(cpt,"r")==0 || strcmp(cpt,"R")==0) {
} else if(strcmp(cpt,"r")==0 || strcmp(cpt,"R")==0 ||
strcmp(cpt,"y")==0 || strcmp(cpt,"Y")==0) {
return(6);
} else if(strcmp(cpt,"x")==0 || strcmp(cpt,"X")==0) {
} else if(strcmp(cpt,"x")==0 || strcmp(cpt,"X")==0 ||
strcmp(cpt,"q")==0 || strcmp(cpt,"Q")==0) {
goto request_to_abort;
} else {
/* >>> unknown input */
sprintf(xorriso->info_text,
"--- Please enter one of : empty line, i, r, x, @, @@, @@@\n");
"--- Please enter one of : empty line, i,n, r,y, q,x, @, @@, @@@\n");
Xorriso_info(xorriso,0);
return(3);
}
@ -2124,7 +2134,7 @@ int Xorriso_pager(struct XorrisO *xorriso, char *line, int flag)
int ret,linecount;
char info_text[10*SfileadrL];
if(xorriso->result_page_length<=0)
if(xorriso->result_page_length<=0 || xorriso->request_not_to_ask)
return(1);
Xorriso_predict_linecount(xorriso,line,&linecount,0);
if(xorriso->result_line_counter+linecount>xorriso->result_page_length) {
@ -2180,6 +2190,7 @@ int Xorriso_info(struct XorrisO *xorriso, int flag)
/*
bit0= use pager (as with result)
bit1= permission to suppress output
bit2= insist in showing output
*/
{
int ret;
@ -2192,7 +2203,7 @@ int Xorriso_info(struct XorrisO *xorriso, int flag)
if(note_sev==0)
Xorriso__text_to_sev("NOTE", &note_sev, 0);
if(note_sev<xorriso->report_about_severity &&
note_sev<xorriso->abort_on_severity)
note_sev<xorriso->abort_on_severity && !(flag&4))
return(1);
if(flag&1) {
@ -2825,7 +2836,8 @@ int Xorriso_status(struct XorrisO *xorriso, char *filter, FILE *fp, int flag)
Xorriso_status_result(xorriso,filter,fp,flag&2);
is_default= !xorriso->do_reassure;
sprintf(line,"-reassure %s\n",(xorriso->do_reassure ? "on" : "off"));
sprintf(line,"-reassure %s\n",(xorriso->do_reassure == 1 ? "on" :
(xorriso->do_reassure == 2 ? "tree" : "off")));
if(!(is_default && no_defaults))
Xorriso_status_result(xorriso,filter,fp,flag&2);
@ -4553,10 +4565,20 @@ int Xorriso_option_pwdx(struct XorrisO *xorriso, int flag)
}
/* Option -reassure "on"|"off" */
/* Option -reassure "on"|"tree"|"off" */
int Xorriso_option_reassure(struct XorrisO *xorriso, char *mode, int flag)
{
xorriso->do_reassure= !!strcmp(mode, "off");
if(strcmp(mode, "off")==0)
xorriso->do_reassure= 0;
else if(strcmp(mode, "on")==0)
xorriso->do_reassure= 1;
else if(strcmp(mode, "tree")==0)
xorriso->do_reassure= 2;
else {
sprintf(xorriso->info_text, "-reassure: unknown mode '%s'", mode);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
return(0);
}
return(1);
}
@ -4606,12 +4628,14 @@ int Xorriso_option_rmi(struct XorrisO *xorriso, int argc, char **argv,
return(ret);
strcpy(path, eff_path);
ret= Xorriso_rmi(xorriso, path, flag&1);
ret= Xorriso_rmi(xorriso, NULL, path, flag&1);
if(ret<=0)
goto ex;
sprintf(xorriso->info_text, "Removed from ISO image: %s '%s'\n",
(ret>1 ? "subtree" : "file"), path);
Xorriso_info(xorriso, 0);
if(ret<3) {
sprintf(xorriso->info_text, "Removed from ISO image: %s '%s'\n",
(ret>1 ? "subtree" : "file"), path);
Xorriso_info(xorriso, 0);
}
}
ret= 1;
ex:;
@ -4754,7 +4778,7 @@ int Xorriso_option_tell_media_space(struct XorrisO *xorriso, int flag)
"Pending image size larger than free space on media");
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING", 0);
}
sprintf(xorriso->result_line, "Write space : %d\n", media_space);
sprintf(xorriso->result_line, "Media space : %d\n", media_space);
Xorriso_result(xorriso, 0);
sprintf(xorriso->result_line, "Free space : %d\n", free_space);
Xorriso_result(xorriso, 0);
@ -4883,7 +4907,7 @@ return:
next_command:;
xorriso->prepended_wd= 0;
xorriso->request_to_abort= 0;
xorriso->request_to_abort= xorriso->request_not_to_ask= 0;
Xorriso_set_problem_status(xorriso, "", 0);
if((*idx)<argc)
cmd= argv[*idx];

@ -283,7 +283,7 @@ int Xorriso_option_pwdx(struct XorrisO *xorriso, int flag);
int Xorriso_option_report_about(struct XorrisO *xorriso, char *severity,
int flag);
/* Option -reassure "on"|"off" */
/* Option -reassure "on"|"tree"|"off" */
int Xorriso_option_reassure(struct XorrisO *xorriso, char *mode, int flag);
/* Options -rm alias -rmi , and -rm_r aias -rm_ri */

@ -73,7 +73,7 @@ struct XorrisO { /* the global context of xorriso */
gid_t global_gid;
int do_overwrite; /* 0=off, 1=on, 2=nondir */
int do_reassure;
int do_reassure; /* 0=off, 1=on, 2=tree */
char volid[SfileadrL];
@ -151,6 +151,7 @@ struct XorrisO { /* the global context of xorriso */
int bar_is_fresh;
char pending_option[SfileadrL]; /* eventual option entered at page prompt */
int request_to_abort; /* abort a single operation like -ls, not the program */
int request_not_to_ask; /* suppress reassure and pager */
double idle_time;
int re_failed_at; /* mismatch position with structured_search */
int prepended_wd;
@ -179,6 +180,8 @@ int Xorriso_result(struct XorrisO *xorriso, int flag);
int Xorriso_info(struct XorrisO *xorriso, int flag);
int Xorriso_request_confirmation(struct XorrisO *xorriso, int flag);
int Xorriso_prescan_args(struct XorrisO *xorriso, int argc, char **argv,
int flag);

@ -1 +1 @@
#define Xorriso_timestamP "2007.11.06.164029"
#define Xorriso_timestamP "2007.11.07.123744"

@ -43,6 +43,10 @@
#include "xorrisoburn.h"
int Xorriso_pacifier_loop(struct XorrisO *xorriso, struct burn_drive *drive,
int flag);
/* ------------------------------------------------------------------------ */
@ -608,12 +612,12 @@ int Xorriso_add_tree(struct XorrisO *xorriso, struct iso_tree_node_dir *dir,
if(Sfile_str(disk_path, disk_dir_path,0)<=0)
{ret= -1; goto ex;}
if(disk_path[strlen(disk_path)-1]!='/')
if(disk_path[0]==0 || disk_path[strlen(disk_path)-1]!='/')
strcat(disk_path,"/");
name= disk_path+strlen(disk_path);
if(Sfile_str(img_path, img_dir_path, 0)<=0)
{ret= -1; goto ex;}
if(img_path[strlen(img_path)-1]!='/')
if(img_path[0] || img_path[strlen(img_path)-1]!='/')
strcat(img_path,"/");
img_name= img_path+strlen(img_path);
@ -659,9 +663,15 @@ int Xorriso_add_tree(struct XorrisO *xorriso, struct iso_tree_node_dir *dir,
/* handle overwrite situation */;
if(xorriso->do_overwrite==1 ||
(xorriso->do_overwrite==2 && !target_is_dir)) {
ret= Xorriso_rmi(xorriso, img_path, 1);
ret= Xorriso_rmi(xorriso, NULL, img_path, 1|8);
if(ret<=0)
goto was_problem;
if(ret==3) {
sprintf(xorriso->info_text, "User revoked adding of: %s",
Text_shellsafe(disk_path, sfe, 0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
goto was_problem;
}
node= NULL;
} else {
sprintf(xorriso->info_text,
@ -715,7 +725,7 @@ int Xorriso_graft_in(struct XorrisO *xorriso, char *disk_path, char *img_path,
int flag)
{
struct iso_volume *volume;
char path[SfileadrL], *apt, *npt, *cpt;
char path[SfileadrL], *apt, *npt, *cpt, sfe[4*SfileadrL];
struct iso_tree_node_dir *dir;
struct iso_tree_node *node;
int done= 0, is_dir= 0, l, ret, target_is_dir, source_is_dir;
@ -810,9 +820,15 @@ int Xorriso_graft_in(struct XorrisO *xorriso, char *disk_path, char *img_path,
/* handle overwrite situation */;
if(xorriso->do_overwrite==1 ||
(xorriso->do_overwrite==2 && !target_is_dir)) {
ret= Xorriso_rmi(xorriso, path, 1);
ret= Xorriso_rmi(xorriso, NULL, path, 1|8);
if(ret<=0)
return(ret);
if(ret==3) {
sprintf(xorriso->info_text, "User revoked adding of: %s",
Text_shellsafe(disk_path, sfe, 0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
return(0);
}
node= NULL;
goto handle_path_node;
}
@ -1366,50 +1382,103 @@ int Xorriso_node_from_path(struct XorrisO *xorriso, struct iso_volume *volume,
}
/* @param flag bit0= remove whole sub tree: rm -r
/* @param boss_iter If not NULL then this is an iterator suitable for
iso_tree_node_remove_iter() which is then to be used instead
of iso_tree_node_remove().
@param flag bit0= remove whole sub tree: rm -r
bit1= remove empty directory: rmdir
bit2= recursion: do not reassure in mode 2 "tree"
bit3= this is for overwriting and not for plain removal
@return <=0 = error
1 = removed simple node
2 = removed directory or tree
3 = did not remove on user revocation
*/
int Xorriso_rmi(struct XorrisO *xorriso, char *path, int flag)
int Xorriso_rmi(struct XorrisO *xorriso, void *boss_iter,
char *path, int flag)
{
int ret, is_dir= 0;
struct iso_tree_node *victim_node;
struct iso_tree_node_dir *boss_node;
int ret, is_dir= 0, pl, not_removed= 0;
struct iso_tree_node *victim_node, *node;
struct iso_tree_node_dir *boss_node, *root_dir;
struct iso_tree_iter *iter= NULL;
struct iso_volume *volume;
char sfe[4*SfileadrL];
char sfe[4*SfileadrL], sub_path[2*SfileadrL], *sub_name, *name;
ret= Xorriso_get_volume(xorriso, &volume, 0);
if(ret<=0)
return(ret);
goto ex;
if(Xorriso_much_too_long(xorriso, strlen(path), 0)<=0)
return(0);
{ret= 0; goto ex;}
ret= Xorriso_node_from_path(xorriso, volume, path, &victim_node, 0);
if(ret<=0)
return(ret);
goto ex;
root_dir= iso_volume_get_root(volume);
if(((void *) root_dir) == ((void *) victim_node)) {
sprintf(xorriso->info_text, "May not delete root directory");
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
return(0);
}
if(LIBISO_ISDIR(victim_node))
is_dir= 1;
if(!(flag&1)) { /* not rm -r */
if(is_dir) {
if(is_dir) {
if(flag&1) { /* rm -r */
if(xorriso->do_reassure==1 && !xorriso->request_not_to_ask) {
/* Iterate over subordinates and delete them */
/* this might become standard if access permissions get respected */
iter= iso_tree_node_children((struct iso_tree_node_dir *) victim_node);
Xorriso_process_msg_queues(xorriso,0);
pl= strlen(path);
strcpy(sub_path, path);
if(pl==0 || sub_path[pl-1]!='/') {
sub_path[pl++]= '/';
sub_path[pl]= 0;
}
sub_name= sub_path+pl;
while((node= iso_tree_iter_next(iter)) != NULL
&& !xorriso->request_to_abort) {
name= (char *) iso_tree_node_get_name(node);
if(Xorriso_much_too_long(xorriso, pl+1+strlen(name), 0)<=0)
{ret= 0; goto ex;}
strcpy(sub_name, name);
ret= Xorriso_rmi(xorriso, iter, sub_path, (flag&(1|2|8))|4);
if(ret<=0)
goto ex;
if(ret==3)
not_removed= 1;
}
if(not_removed) {
if(!(flag&4)) {
sprintf(xorriso->info_text, "Directory not removed: %s",
Text_shellsafe(path, sfe, 0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
}
ret= 3; goto ex;
}
}
} else {
if(!(flag&2)) { /* not rmdir */
sprintf(xorriso->info_text, "%s in loaded ISO image is a directory",
Text_shellsafe(path, sfe, 0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
return(0);
ret= 0; goto ex;
}
/* >>> check whether directory is empty */;
sprintf(xorriso->info_text,
"Single directory removal not implemented yet");
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
return(0);
iter= iso_tree_node_children((struct iso_tree_node_dir *) victim_node);
Xorriso_process_msg_queues(xorriso,0);
if(iso_tree_iter_next(iter)!=NULL) {
sprintf(xorriso->info_text, "Directory not empty on attempt to delete");
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
ret= 0; goto ex;
}
}
}
if(xorriso->request_to_abort)
{ret= 3; goto ex;}
boss_node= iso_tree_node_get_parent(victim_node);
Xorriso_process_msg_queues(xorriso,0);
if(boss_node==NULL) {
@ -1417,26 +1486,69 @@ int Xorriso_rmi(struct XorrisO *xorriso, char *path, int flag)
"Cannot find parent node of %s in loaded ISO image",
Text_shellsafe(path, sfe, 0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
return(0);
ret= 0; goto ex;
}
if(xorriso->do_reassure) {
/* >>> ask user */;
while((xorriso->do_reassure==1 || (xorriso->do_reassure==2 && !(flag&4)))
&& !xorriso->request_not_to_ask) {
Xorriso_ls_filev(xorriso, 1, &path, (off_t) 0, 1|2); /* ls -l */
if(is_dir)
Xorriso_ls_filev(xorriso, 1, &path, (off_t) 0, 2|4); /* du -s */
if(flag&8)
sprintf(xorriso->info_text,
"File exists. Remove ? n= keep old, y= remove, x= abort, @= stop asking\n");
else
sprintf(xorriso->info_text,
"Remove above file ? n= keep it, y= remove it, x= abort, @= stop asking\n");
Xorriso_info(xorriso, 4);
ret= Xorriso_request_confirmation(xorriso, 1|2|4);
if(ret<=0)
goto ex;
if(xorriso->request_to_abort) {
if(!(flag&4)) {
sprintf(xorriso->info_text,
"Removal operation aborted by user before file: %s",
Text_shellsafe(path, sfe, 0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
}
ret= 3; goto ex;
}
if(ret==3)
continue;
if(ret==6) /* yes */
break;
if(ret==4) { /* yes, do not ask again */
xorriso->request_not_to_ask= 1;
break;
}
if(ret==1) { /* no */
sprintf(xorriso->info_text, "Kept in existing state: %s",
Text_shellsafe(path, sfe, 0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
ret= 3; goto ex;
}
}
ret= iso_tree_node_remove(boss_node, victim_node);
if(boss_iter!=NULL) {
ret= iso_tree_node_remove_iter((struct iso_tree_iter *) boss_iter);
if(ret<0)
ret= -1;
} else
ret= iso_tree_node_remove(boss_node, victim_node);
Xorriso_process_msg_queues(xorriso,0);
if(ret==-1) {
sprintf(xorriso->info_text,
"Internal failure to remove %s from loaded ISO image",
Text_shellsafe(path, sfe, 0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
return(-1);
ret= -1; goto ex;
}
xorriso->volset_change_pending= 1;
return(1+!!is_dir);
ret= 1+!!is_dir;
ex:;
if(iter!=NULL)
iso_tree_iter_free(iter);
return(ret);
}
@ -1620,6 +1732,7 @@ ex:;
/* @param flag bit0= long format
bit1= do not print count of nodes
bit2= du format
*/
int Xorriso_ls_filev(struct XorrisO *xorriso, int filec, char **filev,
@ -1671,7 +1784,7 @@ much_too_long:;
}
}
if(!(flag&4)) {
if(!(flag&(2|4))) {
sprintf(xorriso->info_text, "Valid ISO nodes found: %d\n", filec-was_error);
Xorriso_info(xorriso,0);
if(filec-was_error<=0)
@ -1958,9 +2071,15 @@ int Xorriso_rename(struct XorrisO *xorriso, char *origin, char *dest, int flag)
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
return(0);
} else if(dest_ret>0) {
ret= Xorriso_rmi(xorriso, eff_dest, 0);
ret= Xorriso_rmi(xorriso, NULL, eff_dest, 8);
if(ret<=0)
return(0);
if(ret==3) {
sprintf(xorriso->info_text, "User revoked renaming of: %s",
Text_shellsafe(eff_origin, sfe, 0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
return(0);
}
}
/* Ensure existence of destination directory */

@ -15,7 +15,6 @@
#define Xorrisoburn_includeD yes
struct XorrisO;
struct burn_drive;
int Xorriso_startup_libraries(struct XorrisO *xorriso, int flag);
@ -25,9 +24,6 @@ int Xorriso_give_up_drive(struct XorrisO *xorriso, int flag);
int Xorriso_write_growing(struct XorrisO *xorriso, int flag);
int Xorriso_pacifier_loop(struct XorrisO *xorriso, struct burn_drive *drive,
int flag);
/* @param flag bit0=graft in as empty directory, not as copy from disk
@return <=0 = error , 1 = added simple node , 2 = added directory
*/
@ -49,13 +45,21 @@ int Xorriso_blank_media(struct XorrisO *xorriso, int flag);
int Xorriso_format_media(struct XorrisO *xorriso, int flag);
/* @param flag bit0= remove whole sub tree: rm -r
bit1=remove empty directory: rmdir
/* @param boss_iter Opaque internal handle. Use NULL outside xorrisoburn.c :
If not NULL then this is an iterator suitable for
iso_tree_node_remove_iter() which is then to be used instead
of iso_tree_node_remove().
@param flag bit0= remove whole sub tree: rm -r
bit1= remove empty directory: rmdir
bit2= recursion: do not reassure in mode 2 "tree"
bit3= this is for overwriting and not for plain removal
@return <=0 = error
1 = removed simple node
2 = removed directory or subtree
2 = removed directory or tree
3 = did not remove on user revocation
*/
int Xorriso_rmi(struct XorrisO *xorriso, char *path, int flag);
int Xorriso_rmi(struct XorrisO *xorriso, void *boss_iter,
char *path, int flag);
/* @param flag bit0= long format */
int Xorriso_ls_filev(struct XorrisO *xorriso, int filec, char **filev,

Loading…
Cancel
Save