Implemented option -reassure

test/xorriso.1

@@ -72,7 +72,7 @@ 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.
 .br
-The data content of a session is called filesystem
+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
@@ -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
+as long as the loaded ISO image was not altered.
-by command -rollback.
+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"
+\fB\-reassure\fR "on"|"tree"|"off"
-If "on" then ask the user for "y" or "n" with any file
+If "on" then ask the user for "y" or "n" 
-before deleting or overwriting it in the ISO image.
+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

test/xorriso.c

@@ -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
+/* return: <=0 error
-                       (5=skip volume) , 6=retry failed operation
+           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,13 +4628,15 @@ 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;
+   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:; 
  (*idx)= end_idx;
@@ -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];

test/xorriso.h

@@ -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 */

test/xorriso_private.h

@@ -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);
 

test/xorriso_timestamp.h

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

test/xorrisoburn.c

@@ -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,49 +1382,102 @@ 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;
+ int ret, is_dir= 0, pl, not_removed= 0;
- struct iso_tree_node *victim_node;
+ struct iso_tree_node *victim_node, *node;
- struct iso_tree_node_dir *boss_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(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 */;
+     iter= iso_tree_node_children((struct iso_tree_node_dir *) victim_node);
-
+     Xorriso_process_msg_queues(xorriso,0);
-     sprintf(xorriso->info_text,
+     if(iso_tree_iter_next(iter)!=NULL) {
-             "Single directory removal not implemented yet");
+       sprintf(xorriso->info_text, "Directory not empty on attempt to delete");
        Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
-     return(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);
@@ -1417,15 +1486,54 @@ 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) {
+ while((xorriso->do_reassure==1 || (xorriso->do_reassure==2 && !(flag&4)))
-
+       && !xorriso->request_not_to_ask) {
-   /* >>> ask user */;
+   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;
+   }
  }
 
+ 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) {
@@ -1433,10 +1541,14 @@ int Xorriso_rmi(struct XorrisO *xorriso, char *path, int flag)
            "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 */

test/xorrisoburn.h

@@ -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
+/* @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,