diff --git a/libisoburn/trunk/test/compile_xorriso.sh b/libisoburn/trunk/test/compile_xorriso.sh
index e2012533..9a85d5dc 100755
--- a/libisoburn/trunk/test/compile_xorriso.sh
+++ b/libisoburn/trunk/test/compile_xorriso.sh
@@ -16,6 +16,7 @@ largefile_opts="-D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE=1"
 do_strip=0
 static_opts=
 warn_opts="-Wall"
+nglibisofs=0
 
 for i in "$@"
 do
@@ -38,13 +39,69 @@ do
     echo "  -do_strip         apply program strip to compiled programs."
     echo "  -g                produce debuggable programm."
     echo "  -static           compile with cc option -static."
+    echo "  -nglibisofs       ... will fail at compile time."
+    echo "  -oglibisofs       ... might fail at run time."
     exit 0
+  elif test "$i" = "-nglibisofs"
+  then
+    nglibisofs=1
+    isofs=./nglibisofs-develop/src
+  elif test "$i" = "-oglibisofs"
+  then
+    nglibisofs=0
+    isofs=./libisofs-develop/libisofs
   elif test "$i" = "-static"
   then
     static_opts="-static"
   fi
 done
 
+libisofs=
+if test "$nglibisofs" = 1
+then
+  libisofs="$libisofs $isofs"/buffer.o
+  libisofs="$libisofs $isofs"/builder.o
+  libisofs="$libisofs $isofs"/data_source.o
+  libisofs="$libisofs $isofs"/ecma119.o
+  libisofs="$libisofs $isofs"/ecma119_tree.o
+  libisofs="$libisofs $isofs"/filesrc.o
+  libisofs="$libisofs $isofs"/fs_image.o
+  libisofs="$libisofs $isofs"/fs_local.o
+  libisofs="$libisofs $isofs"/fsource.o
+  libisofs="$libisofs $isofs"/image.o
+  libisofs="$libisofs $isofs"/joliet.o
+  libisofs="$libisofs $isofs"/libiso_msgs.o
+  libisofs="$libisofs $isofs"/messages.o
+  libisofs="$libisofs $isofs"/node.o
+  libisofs="$libisofs $isofs"/rockridge.o
+  libisofs="$libisofs $isofs"/rockridge_read.o
+  libisofs="$libisofs $isofs"/stream.o
+  libisofs="$libisofs $isofs"/tree.o
+  libisofs="$libisofs $isofs"/util.o
+  libisofs="$libisofs $isofs"/util_rbtree.o
+  xorrisoburn_c="ng_xorrisoburn.c"
+else
+  libisofs="$libisofs $isofs"/data_source.o
+  libisofs="$libisofs $isofs"/ecma119.o
+  libisofs="$libisofs $isofs"/ecma119_read.o
+  libisofs="$libisofs $isofs"/ecma119_read_rr.o
+  libisofs="$libisofs $isofs"/ecma119_tree.o
+  libisofs="$libisofs $isofs"/eltorito.o
+  libisofs="$libisofs $isofs"/exclude.o
+  libisofs="$libisofs $isofs"/file.o
+  libisofs="$libisofs $isofs"/file_src.o
+  libisofs="$libisofs $isofs"/hash.o
+  libisofs="$libisofs $isofs"/joliet.o
+  libisofs="$libisofs $isofs"/libiso_msgs.o
+  libisofs="$libisofs $isofs"/messages.o
+  libisofs="$libisofs $isofs"/rockridge.o
+  libisofs="$libisofs $isofs"/susp.o
+  libisofs="$libisofs $isofs"/tree.o
+  libisofs="$libisofs $isofs"/util.o
+  libisofs="$libisofs $isofs"/volume.o
+  xorrisoburn_c="xorrisoburn.c"
+fi
+echo "+ $libisofs"
 
 timestamp="$(date -u '+%Y.%m.%d.%H%M%S')"
 echo "Version timestamp :  $(sed -e 's/#define Xorriso_timestamP "//' -e 's/"$//' "$xorr"/xorriso_timestamp.h)"
@@ -64,7 +121,7 @@ cc -I. -DXorriso_with_maiN -DXorriso_with_regeX -DXorriso_with_readlinE \
   \
   "$xorr"/xorriso.c \
   \
-  "$xorr"/xorrisoburn.c \
+  "$xorr"/"$xorrisoburn_c" \
   \
   "$burn"/async.o \
   "$burn"/debug.o \
@@ -98,24 +155,7 @@ cc -I. -DXorriso_with_maiN -DXorriso_with_regeX -DXorriso_with_readlinE \
   "$isoburn"/data_source.o \
   "$isoburn"/isofs_wrap.o \
   \
-  "$isofs"/data_source.o \
-  "$isofs"/ecma119.o \
-  "$isofs"/ecma119_read.o \
-  "$isofs"/ecma119_read_rr.o \
-  "$isofs"/ecma119_tree.o \
-  "$isofs"/eltorito.o \
-  "$isofs"/exclude.o \
-  "$isofs"/file.o \
-  "$isofs"/file_src.o \
-  "$isofs"/hash.o \
-  "$isofs"/joliet.o \
-  "$isofs"/libiso_msgs.o \
-  "$isofs"/messages.o \
-  "$isofs"/rockridge.o \
-  "$isofs"/susp.o \
-  "$isofs"/tree.o \
-  "$isofs"/util.o \
-  "$isofs"/volume.o \
+  $libisofs \
   \
   -lreadline \
   \
diff --git a/libisoburn/trunk/test/ng_xorrisoburn.c b/libisoburn/trunk/test/ng_xorrisoburn.c
new file mode 100644
index 00000000..1980d03a
--- /dev/null
+++ b/libisoburn/trunk/test/ng_xorrisoburn.c
@@ -0,0 +1,3142 @@
+
+
+/* Adapter to libisoburn, libisofs and libburn for xorriso,
+   a command line oriented batch and dialog tool which creates, loads,
+   manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2008 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2.
+*/
+
+#include <ctype.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <time.h>
+
+
+/* ------------------------------------------------------------------------ */
+
+
+/* The library which does the ISO 9660 / RockRidge manipulations */
+/* >>> NG */
+#include <libisofs/nglibisofs.h>
+
+/* The library which does MMC optical drive operations */
+#include <libburn/libburn.h>
+
+/* The library which enhances overwriteable media with ISO 9660 multi-session
+   capabilities via the method invented by Andy Polyakov for growisofs */
+#include <libisoburn/libisoburn.h>
+
+/* The official xorriso options API. "No shortcuts" */
+#include "xorriso.h"
+
+/* The inner description of XorrisO */
+#include "xorriso_private.h"
+
+/* The inner isofs- and burn-library interface */
+#include "xorrisoburn.h"
+
+
+int Xorriso_pacifier_loop(struct XorrisO *xorriso, struct burn_drive *drive,
+                          int flag);
+
+#define LIBISO_ISDIR(node) (iso_node_get_type(node) == LIBISO_DIR)
+#define LIBISO_ISREG(node) (iso_node_get_type(node) == LIBISO_FILE)
+#define LIBISO_ISLNK(node) (iso_node_get_type(node) == LIBISO_SYMLINK)
+#define LIBISO_ISCHR(node) (iso_node_get_type(node) == LIBISO_SPECIAL && \
+                            S_ISCHR(iso_node_get_mode(node)))
+#define LIBISO_ISBLK(node) (iso_node_get_type(node) == LIBISO_SPECIAL && \
+                            S_ISBLK(iso_node_get_mode(node)))
+#define LIBISO_ISFIFO(node) (iso_node_get_type(node) == LIBISO_SPECIAL && \
+                             S_ISFIFO(iso_node_get_mode(node)))
+#define LIBISO_ISSOCK(node) (iso_node_get_type(node) == LIBISO_SPECIAL && \
+                             S_ISSOCK(iso_node_get_mode(node)))
+
+
+/* ------------------------------------------------------------------------ */
+
+
+int Xorriso_startup_libraries(struct XorrisO *xorriso, int flag)
+{
+ int ret;
+ char *handler_prefix= NULL;
+ char *queue_sev, *print_sev;
+
+ sprintf(xorriso->info_text, "Starting up libraries ...\n");
+ Xorriso_info(xorriso, 0);
+
+ handler_prefix= calloc(strlen(xorriso->progname)+3+1, 1);
+ if(handler_prefix==NULL) {
+   sprintf(xorriso->info_text,
+           "Cannot allocate memory for initializing libraries");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+   return(-1);
+ }
+ ret= isoburn_initialize();
+ if(ret==0) {
+   sprintf(xorriso->info_text, "Cannot initialize libraries");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+   free(handler_prefix);
+   return(0);
+ }
+ xorriso->libs_are_started= 1;
+
+ queue_sev= "DEBUG";
+ if(xorriso->library_msg_direct_print) {
+
+   /* >>> need option for controlling this in XorrisO.
+          See also Xorriso_msgs_submit */;
+
+   print_sev= xorriso->report_about_text;
+ } else
+   print_sev= "NEVER";
+
+/* >>> NG  How to set severities before isoburn_read_volset() ?
+       iso_image_set_msgs_severities() demands an IsoImage
+*/
+/*
+ iso_image_msgs_set_severities(queue_sev, print_sev, "libisofs >>> NG : ");
+*/
+ burn_msgs_set_severities(queue_sev, print_sev, "libburn : ");
+
+ /* ??? >>> do we want united queues ? */
+ /* burn_set_messenger(iso_get_messenger()); */
+
+ sprintf(handler_prefix, "%s : ", xorriso->progname);
+ burn_set_signal_handling(handler_prefix, NULL, 0);
+ 
+ Xorriso_process_msg_queues(xorriso,0);
+ sprintf(xorriso->info_text, "Library startup done.\n");
+ Xorriso_info(xorriso, 0);
+ free(handler_prefix);
+ return(1);
+}
+
+
+/* @param flag bit1= obtain outdrive, else indrive */
+int Xorriso_get_drive_handles(struct XorrisO *xorriso,
+                              struct burn_drive_info **dinfo,
+                              struct burn_drive **drive,
+                              char *attempt, int flag)
+{
+ if(flag&2)
+   *dinfo= (struct burn_drive_info *) xorriso->out_drive_handle;
+ else
+   *dinfo= (struct burn_drive_info *) xorriso->in_drive_handle;
+ if(*dinfo==NULL) {
+   Xorriso_process_msg_queues(xorriso,0);
+   sprintf(xorriso->info_text, "No %s drive aquired %s",
+           (flag&2 ? "output" : "input"), attempt);
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+   return(0);
+ }
+ *drive= (*dinfo)[0].drive;
+ return((*drive)!=NULL);
+}
+
+
+int Xorriso_set_image_severities(struct XorrisO *xorriso, int flag)
+{
+ char *queue_sev, *print_sev;
+
+ if(xorriso->in_volset_handle==NULL)
+   return(0);
+ queue_sev= "DEBUG";
+ if(xorriso->library_msg_direct_print)
+   print_sev= xorriso->report_about_text;
+ else
+   print_sev= "NEVER";
+ iso_image_set_msgs_severities((IsoImage *) xorriso->in_volset_handle,
+                               queue_sev, print_sev, "libisofs >>> NG : ");
+ return(1);
+}
+
+
+int Xorriso_create_empty_iso(struct XorrisO *xorriso, int flag)
+{
+ int ret;
+ IsoImage *volset;
+ struct isoburn_read_opts ropts;
+ struct burn_drive_info *dinfo= NULL;
+ struct burn_drive *drive= NULL;
+
+ if(xorriso->out_drive_handle != NULL) {
+   ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
+                                  "on attempt to attach volset to drive", 2);
+   if(ret<=0)
+     return(ret);
+ }
+ if(xorriso->in_volset_handle!=NULL) {
+   iso_image_unref((IsoImage *) xorriso->in_volset_handle);
+   xorriso->in_volset_handle= NULL;
+   xorriso->volset_change_pending= 0;
+ }
+ memset(&ropts, sizeof(ropts), 0);
+ ropts.pretend_blank= 1;
+ ret= isoburn_read_volset(drive, &ropts, (void **) &volset);
+ Xorriso_process_msg_queues(xorriso,0);
+ if(ret<=0) {
+   sprintf(xorriso->info_text, "Failed to create new empty ISO image object");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+   return(-1);
+ }
+ xorriso->in_volset_handle= (void *) volset;
+ Xorriso_set_image_severities(xorriso, 0);
+ xorriso->volset_change_pending= 0;
+ return(1);
+}
+
+
+/* @param flag bit0=aquire as isoburn input drive
+               bit1=aquire as libburn output drive (as isoburn drive if bit0)
+   @return <=0 failure , 1= ok
+           2=success, but not writeable with bit1
+           3=success, but not blank and not ISO with bit0
+*/
+int Xorriso_aquire_drive(struct XorrisO *xorriso, char *adr, int flag)
+{
+ int ret, hret, not_writeable= 0;
+ struct burn_drive_info *dinfo= NULL, *out_dinfo, *in_dinfo;
+ struct burn_drive *drive, *out_drive, *in_drive;
+ enum burn_disc_status state;
+ IsoImage *volset;
+ struct isoburn_read_opts ropts;
+
+ if((flag&3)==0) { 
+   sprintf(xorriso->info_text, 
+         "XORRISOBURN program error : Xorriso_aquire_drive bit0+bit1 not set");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+   return(0);
+ }
+ ret= Xorriso_give_up_drive(xorriso, (flag&3)|8);
+ if(ret<=0)
+   return(ret);
+
+ if((flag&3)==1 && xorriso->out_drive_handle!=NULL) {
+   ret= Xorriso_get_drive_handles(xorriso, &out_dinfo, &out_drive,
+                         "on attempt to compare new indev with outdev", 2);
+   if(ret<=0)
+     goto ex;
+   ret= burn_drive_equals_adr(out_drive, adr, 1);
+   if(ret==1)
+     dinfo= out_dinfo;
+ } else if((flag&3)==2 && xorriso->in_drive_handle!=NULL) {
+   ret= Xorriso_get_drive_handles(xorriso, &in_dinfo, &in_drive,
+                         "on attempt to compare new indev with outdev", 0);
+   if(ret<=0)
+     goto ex;
+   ret= burn_drive_equals_adr(in_drive, adr, 1);
+   if(ret==1)
+     dinfo= in_dinfo;
+ }
+
+ if(dinfo==NULL) {
+   ret= isoburn_drive_scan_and_grab(&dinfo, adr, 1);
+   Xorriso_process_msg_queues(xorriso,0);
+   if(ret<=0) {
+     sprintf(xorriso->info_text,"Cannot aquire drive '%s'", adr); 
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+     return(0);
+   }
+ }
+ drive= dinfo[0].drive;
+ state= isoburn_disc_get_status(drive);
+ Xorriso_process_msg_queues(xorriso,0);
+
+ if(flag&2) {
+   xorriso->out_drive_handle= dinfo;
+   if(Sfile_str(xorriso->outdev, adr, 0)<=0)
+     return(-1);
+   if(state != BURN_DISC_BLANK && state != BURN_DISC_APPENDABLE) {
+     sprintf(xorriso->info_text, "Disc status unsuitable for writing");
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING", 0);
+     not_writeable= 1;
+   }
+ }
+ if(flag&1) {
+   xorriso->in_drive_handle= dinfo;
+   if(Sfile_str(xorriso->indev, adr, 0)<=0)
+     return(-1);
+ } else if(flag&2) {
+   if(xorriso->in_volset_handle==NULL) {
+     /* No volume loaded: create empty one */
+     ret= Xorriso_create_empty_iso(xorriso, 0);
+     if(ret<=0)
+       return(ret);
+   } else {
+     iso_image_ref((IsoImage *) xorriso->in_volset_handle);
+     ret= isoburn_attach_volset(drive, xorriso->in_volset_handle);
+     if(ret<=0) {
+       sprintf(xorriso->info_text,
+               "Failed to attach ISO image object to outdev");
+       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+       return(-1);
+     }
+   }
+   Xorriso_toc(xorriso, 1|2);
+   return(1+not_writeable);
+ }
+
+ if(xorriso->in_volset_handle!=NULL)
+   iso_image_unref((IsoImage *) xorriso->in_volset_handle);
+ xorriso->in_volset_handle= NULL;
+
+ /* check for invalid state */
+ if(state != BURN_DISC_BLANK && state != BURN_DISC_APPENDABLE &&
+    state != BURN_DISC_FULL) {
+   sprintf(xorriso->info_text,
+           "Disc status not blank and unsuitable for reading");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+   return(0);
+ }
+ /* fill read opts */ 
+ memset(&ropts, sizeof(ropts), 0);
+ ropts.norock= 0;
+ ropts.nojoliet= 0;
+ ropts.preferjoliet= 0;
+ ropts.uid= 0;
+ ropts.gid= 0;
+ ropts.mode= 0555;
+ ropts.pretend_blank= 0;
+
+ if(isoburn_read_volset(drive, &ropts, (void **) &volset) <= 0) {
+   Xorriso_process_msg_queues(xorriso,0);
+   sprintf(xorriso->info_text,"Cannot read ISO image volset");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+   ret= 3; goto ex;
+ }
+ xorriso->in_volset_handle= (void *) volset;
+ Xorriso_set_image_severities(xorriso, 0);
+
+ if(xorriso->out_drive_handle != NULL &&
+    xorriso->out_drive_handle != xorriso->in_drive_handle) {
+   ret= Xorriso_get_drive_handles(xorriso, &out_dinfo, &out_drive,
+                         "on attempt to attach ISO image volset to outdev", 2);
+   if(ret<=0)
+     goto ex;
+   iso_image_ref((IsoImage *) xorriso->in_volset_handle);
+   isoburn_attach_volset(out_drive, xorriso->in_volset_handle);
+ }
+ Xorriso_process_msg_queues(xorriso,0);
+ Xorriso_toc(xorriso, 1);
+ ret= 1+not_writeable;
+ex:
+ if(ret<=0) {
+   hret= Xorriso_give_up_drive(xorriso, flag&3);
+   if(hret<ret)
+     ret= hret;
+ }
+ Xorriso_process_msg_queues(xorriso,0);
+ return(ret);
+}
+
+
+/* @param flag bit0=input drive
+               bit1=output drive
+               bit2=eject
+               bit3=no info message or toc
+*/
+int Xorriso_give_up_drive(struct XorrisO *xorriso, int flag)
+{
+ int in_is_out_too, ret;
+ struct burn_drive_info *dinfo;
+ struct burn_drive *drive;
+ 
+ in_is_out_too= (xorriso->in_drive_handle == xorriso->out_drive_handle);
+   
+ if((flag&1) && xorriso->in_drive_handle != NULL) {
+   Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
+                             "on attempt to give up drive", 0);
+
+   if(!in_is_out_too) {
+     if(drive!=NULL && !in_is_out_too)
+       isoburn_drive_release(drive,!!(flag&4));
+     if(dinfo!=NULL && !in_is_out_too)
+       burn_drive_info_free(dinfo);
+   }
+   xorriso->in_drive_handle= NULL;
+   xorriso->indev[0]= 0;
+
+   if(xorriso->in_volset_handle!=NULL)
+     iso_image_unref((IsoImage *) xorriso->in_volset_handle);
+   xorriso->in_volset_handle= NULL;
+   xorriso->volset_change_pending= 0;
+
+   in_is_out_too= 0;
+ }
+ if((flag&2) && xorriso->out_drive_handle!=NULL) {
+   Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
+                             "on attempt to give drive up", 2);
+   if(!in_is_out_too) {
+     if(drive!=NULL)
+       isoburn_drive_release(drive,!!(flag&4));
+     if(dinfo!=NULL)
+       burn_drive_info_free(dinfo);
+   }
+   xorriso->out_drive_handle= NULL;
+   xorriso->outdev[0]= 0;
+ } else if((flag&1) && xorriso->out_drive_handle!=NULL) {
+   ret= Xorriso_create_empty_iso(xorriso, 0);
+   if(ret<=0)
+     return(ret);
+   if(!(flag&8)) {
+     sprintf(xorriso->info_text,
+             "Only the output drive remains. Created empty ISO image.\n");
+     Xorriso_info(xorriso, 0);
+     Xorriso_toc(xorriso, 1|2);
+   }
+ }
+ Xorriso_process_msg_queues(xorriso,0);
+ return(1);
+}
+
+
+int Xorriso_make_write_options(
+        struct XorrisO *xorriso, struct burn_drive *drive,
+        struct burn_write_opts **burn_options, int flag)
+{
+ *burn_options= burn_write_opts_new(drive);
+ if(*burn_options==NULL) {
+   Xorriso_process_msg_queues(xorriso,0);
+   sprintf(xorriso->info_text,"Cannot allocate option set");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+   return(0);
+ }
+ burn_write_opts_set_simulate(*burn_options, !!xorriso->do_dummy);
+ burn_write_opts_set_multi(*burn_options, !xorriso->do_close);
+ burn_drive_set_speed(drive, xorriso->speed, xorriso->speed);
+ burn_write_opts_set_underrun_proof(*burn_options, 1);
+ return(1);
+}
+
+
+/* @param flag bit0= do not write but only prepare and return size in sectors
+*/
+int Xorriso_write_session(struct XorrisO *xorriso, int flag)
+{
+ int ret, media_space;
+ struct isoburn_source_opts sopts;
+ struct burn_drive_info *dinfo, *source_dinfo;
+ struct burn_drive *drive, *source_drive;
+ struct burn_disc *disc= NULL;
+ struct burn_write_opts *burn_options;
+ off_t readcounter= 0,writecounter= 0;
+ int num_sessions= 0, num_tracks= 0;
+ struct burn_session **sessions;
+ struct burn_track **tracks;
+ enum burn_disc_status s;
+
+ ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
+                                "on attempt to write", 2);
+ if(ret<=0)
+   return(0);
+
+ sopts.level= 2;
+
+/* >>> NG  libisofs control gesture in libisoburn
+ sopts.flags= ECMA119_ROCKRIDGE;
+ if(xorriso->do_joliet)
+   sopts.flags|= ECMA119_JOLIET;
+*/
+
+ sopts.relaxed_constraints= 0;
+ sopts.copy_eltorito= 1;
+ sopts.no_cache_inodes= 0;
+ sopts.sort_files= 1;
+ sopts.default_mode= 1;
+ sopts.replace_dir_mode= xorriso->do_global_mode;
+ sopts.dir_mode= xorriso->global_dir_mode;
+ sopts.replace_file_mode= xorriso->do_global_mode;
+ sopts.file_mode= xorriso->global_file_mode;
+ sopts.replace_uid= (xorriso->do_global_uid);
+ sopts.uid= xorriso->global_uid;
+ sopts.replace_gid= (xorriso->do_global_gid);
+ sopts.gid= xorriso->global_gid;
+ sopts.input_charset= NULL;
+ sopts.ouput_charset= NULL;
+ sopts.fifo_size= xorriso->fs * 2048;
+
+ if(xorriso->out_drive_handle == xorriso->in_drive_handle ||
+    xorriso->in_drive_handle == NULL) {
+   ret= isoburn_prepare_disc(drive, &disc, &sopts);
+ } else {
+   s= isoburn_disc_get_status(drive);
+   if(s!=BURN_DISC_BLANK) {
+     s= burn_disc_get_status(drive);
+     if(s!=BURN_DISC_BLANK)
+       sprintf(xorriso->info_text,
+               "-indev differs from -outdev and -outdev media is not blank");
+     else
+       sprintf(xorriso->info_text,
+        "-indev differs from -outdev and -outdev media holds valid ISO image");
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+     {ret= 0; goto ex;}
+   }
+   ret= Xorriso_get_drive_handles(xorriso, &source_dinfo, &source_drive,
+                                  "on attempt to get source for write", 0);
+   if(ret<=0)
+     goto ex;
+   ret= isoburn_prepare_new_image(source_drive, &disc, &sopts);
+ }
+ if (ret <= 0) {
+   Xorriso_process_msg_queues(xorriso,0);
+   sprintf(xorriso->info_text,"Failed to prepare session write run");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+   {ret= 0; goto ex;}
+ }
+
+ ret= Xorriso_make_write_options(xorriso, drive, &burn_options, 0);
+ if(ret<=0)
+   goto ex;
+
+ ret= burn_disc_get_sectors(disc);
+ if(flag&1)
+   goto ex;
+
+ media_space= burn_disc_available_space(drive, burn_options) / (off_t) 2048;
+ if(media_space < ret) {
+   Xorriso_process_msg_queues(xorriso,0);
+   sprintf(xorriso->info_text,"Image size %ds exceeds free space on media %ds",
+           ret, media_space);
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+   {ret= 0; goto ex;}
+ }
+
+ isoburn_disc_write(burn_options, disc);
+ burn_write_opts_free(burn_options);
+
+ ret= Xorriso_pacifier_loop(xorriso, drive, 0);
+ if(ret<=0)
+   goto ex;
+ if(!isoburn_drive_wrote_well(drive)) {
+   Xorriso_process_msg_queues(xorriso,0);
+   sprintf(xorriso->info_text,
+           "libburn indicates failure with writing.");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+   ret= 0; goto ex;
+ }
+
+ sessions= burn_disc_get_sessions(disc, &num_sessions);
+ if(num_sessions>0) {
+   tracks= burn_session_get_tracks(sessions[0], &num_tracks);
+   if(tracks!=NULL && num_tracks>0) {
+     burn_track_get_counters(tracks[0],&readcounter,&writecounter);
+     sprintf(xorriso->info_text,
+             "ISO image produced: %d sectors. Written to media: %d sectors\n",
+             (int) readcounter/2048, (int) writecounter/2048);
+     Xorriso_info(xorriso, 0);
+   }
+ }
+
+ ret= isoburn_activate_session(drive);
+ Xorriso_process_msg_queues(xorriso,0);
+ if(ret<=0) {
+   sprintf(xorriso->info_text,
+           "Could not write new set of volume descriptors");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+   goto ex;
+ }
+
+ sprintf(xorriso->info_text, "Writing completed sucessfully.\n\n");
+ Xorriso_info(xorriso, 0);
+ ret= 1;
+ex:;
+ if(disc!=NULL)
+   burn_disc_free(disc);
+ Xorriso_process_msg_queues(xorriso,0);
+ return(ret);
+} 
+
+
+int Xorriso_pacifier_loop(struct XorrisO *xorriso, struct burn_drive *drive,
+                          int flag)
+{
+ int ret, size, free_bytes, i;
+ struct burn_progress progress;
+ char *status_text;
+ enum burn_drive_status drive_status;
+ double start_time, current_time;
+
+ start_time= Sfile_microtime(0);
+ while(burn_drive_get_status(drive, NULL) == BURN_DRIVE_SPAWNING)
+   usleep(100002);
+
+ while(1) {
+   drive_status= burn_drive_get_status(drive, &progress);
+   if(drive_status == BURN_DRIVE_IDLE)
+ break;
+    current_time= Sfile_microtime(0);
+   if(drive_status == BURN_DRIVE_WRITING && progress.sectors > 0) {
+     sprintf(xorriso->info_text, "Writing: sector %d of %d",
+             progress.sector, progress.sectors);
+     ret= isoburn_get_fifo_status(drive, &size, &free_bytes, &status_text);
+     if(ret>0 )
+       sprintf(xorriso->info_text+strlen(xorriso->info_text),
+               "  [fifo %s, %2d%% fill]", status_text,
+               (int) (100.0-100.0*((double) free_bytes)/(double) size));
+   } else if(drive_status == BURN_DRIVE_CLOSING_SESSION ||
+             drive_status == BURN_DRIVE_CLOSING_TRACK)
+     sprintf(xorriso->info_text,
+             "Closing track/session. Working since %.f seconds",
+             current_time-start_time);
+   else if(drive_status == BURN_DRIVE_FORMATTING)
+     sprintf(xorriso->info_text, "Formatting. Working since %.f seconds",
+             current_time-start_time);
+   else
+     sprintf(xorriso->info_text,
+             "Thank you for being patient since %.f seconds",
+             current_time-start_time);
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "UPDATE", 0);
+
+   for(i= 0; i<10; i++) {
+     Xorriso_process_msg_queues(xorriso, 0);
+     usleep(100000);
+   }
+ }
+ return(1);
+}
+
+
+int Xorriso_get_volume(struct XorrisO *xorriso, IsoImage **volume,
+                       int flag)
+{
+ if(xorriso->in_volset_handle==NULL) {
+   Xorriso_process_msg_queues(xorriso,0);
+   sprintf(xorriso->info_text,"No volset is loaded.");
+   if(xorriso->indev[0]==0)
+     sprintf(xorriso->info_text+strlen(xorriso->info_text),
+             " No -dev or -indev is selected.");
+   else
+     sprintf(xorriso->info_text+strlen(xorriso->info_text),
+             " Possible program error with drive '%s'.", xorriso->indev);
+
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+   return(0);
+ }
+ *volume= (IsoImage *) xorriso->in_volset_handle;
+ return(*volume != NULL);
+}
+
+
+/* @param eff_path  returns resulting effective path.
+                    Must provide at least SfileadrL bytes of storage.
+   @param flag bit0= do not produce problem events (unless faulty path format)
+               bit1= work purely literally, do not use libisofs
+               bit2= (with bit1) this is an address in the disk world
+   @return -1 = faulty path format, 0 = not found ,
+            1 = found simple node , 2 = found directory
+*/
+int Xorriso_normalize_img_path(struct XorrisO *xorriso, char *wd,
+                               char *img_path, char eff_path[], int flag)
+{
+ int ret, is_dir= 0, done= 0;
+ IsoImage *volume;
+ IsoDir *dir= NULL;
+ IsoNode *node= NULL;
+ char path[SfileadrL], *apt, *npt, sfe[5*SfileadrL], *cpt;
+
+ eff_path[0]= 0;
+ if(img_path[0]==0)
+   return(2); /* root directory */
+
+ if(!(flag&2)) {
+   ret= Xorriso_get_volume(xorriso, &volume, 0);
+   if(ret<=0)
+     return(ret);
+ }
+
+ apt= npt= path;
+ if(img_path[0]!='/') {
+   strcpy(path, wd);
+   ret= Sfile_add_to_path(path, img_path, 0);
+   if(ret<=0)
+     goto much_too_long;
+ } else
+   if(Sfile_str(path, img_path, 0)<=0)
+     return(-1);
+
+ if(path[0]!='/') {
+   sprintf(xorriso->info_text,
+        "Internal error: Unresolvable relative addressing in iso_rr_path '%s'",
+        img_path);
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FATAL", 0);
+   return(-1);
+ } else if(path[1]==0)
+   return(2); /* root directory */
+
+ for(npt= apt; !done; apt= npt+1) {
+   npt= strchr(apt, '/');
+   if(npt==NULL) {
+     npt= apt+strlen(apt);
+     done= 1;
+   } else
+     *npt= 0;
+   if(*apt==0) {
+     *apt= '/';
+     apt++;
+     if(done)
+ break;
+ continue;
+   }
+   if(strcmp(apt,".")==0)
+ continue;
+   if(strcmp(apt,"..")==0) {
+     if(!(flag&2)) {
+       node= (IsoNode *) dir;
+       if(node==NULL) {
+bonked_root:;
+         sprintf(xorriso->info_text,
+                 "Relative addressing in path exceeds root directory: %s",
+                 Text_shellsafe(img_path, sfe, 0));
+         Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+         return(-1);
+       }
+
+       /* >>> NG
+       dir= iso_tree_node_get_parent(node);
+       */
+
+     }
+     /* truncate eff_path */;
+     cpt= strrchr(eff_path, '/');
+     if(cpt==NULL) /* ??? if not flag&2 then this is a bug */
+       goto bonked_root;
+     *cpt= 0;
+ continue;
+   }
+   ret= Sfile_add_to_path(eff_path, apt, 0);
+   if(ret<=0) {
+much_too_long:;
+     sprintf(xorriso->info_text, "Effective path gets much too long (%d)",
+             (int) (strlen(eff_path)+strlen(apt)+1));
+     if(!(flag&1))
+       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+     return(-1);
+   }
+   if(!(flag&2)) {
+     dir= (IsoDir *) node;
+     ret= iso_tree_path_to_node(volume, eff_path, &node);
+     if(ret<=0) {
+         sprintf(xorriso->info_text, "Cannot find in ISO image: %s",
+                 Text_shellsafe(eff_path, sfe, 0));
+         if(!(flag&1))
+           Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+         return(0);
+     }
+
+     if(dir==NULL) /* could be false with  "/dir/.." */
+       /* >>> NG  dir= iso_tree_node_get_parent(node) */ ;
+
+     is_dir= LIBISO_ISDIR(node);
+   }
+ }
+ return(1+!!is_dir);
+}
+
+
+int Xorriso_get_node_by_path(struct XorrisO *xorriso,
+                             char *in_path, char *eff_path,
+                             IsoNode **node, int flag)
+{
+ int ret;
+ char sfe[5*SfileadrL], path[SfileadrL];
+ IsoImage *volume;
+
+ ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, in_path, path, 0);
+ if(ret<=0)
+   return(ret);
+ if(eff_path!=NULL)
+   strcpy(eff_path, path);
+ ret= Xorriso_get_volume(xorriso, &volume, 0);
+ if(ret<=0)
+   return(ret);
+ ret= iso_tree_path_to_node(volume,path,node);
+ if(ret<=0) {
+   sprintf(xorriso->info_text, "Not found in ISO image: %s",
+          Text_shellsafe(path, sfe, 0));
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+   return(0);
+ }
+ return(1);
+}
+
+
+int Xorriso_transfer_properties(struct XorrisO *xorriso, struct stat *stbuf,
+                                IsoNode *node, int flag)
+{
+ iso_node_set_permissions(node, stbuf->st_mode & 07777);
+ iso_node_set_uid(node, stbuf->st_uid);
+ iso_node_set_gid(node, stbuf->st_gid);
+ iso_node_set_atime(node, stbuf->st_atime);
+ iso_node_set_mtime(node, stbuf->st_mtime);
+ iso_node_set_ctime(node, stbuf->st_ctime);
+ return(1);
+}
+
+
+/* @param flag bit0= recursion is active */
+int Xorriso_add_tree(struct XorrisO *xorriso, IsoDir *dir,
+                     char *img_dir_path, char *disk_dir_path,
+                     struct LinkiteM *link_stack, int flag)
+{
+ IsoImage *volume;
+ IsoNode *node;
+ int ret, target_is_dir, source_is_dir, source_is_link, fret, was_failure= 0;
+ int do_not_dive;
+ struct DirseQ *dirseq= NULL;
+ char *name, *img_name, *srcpt;
+ struct stat stbuf, hstbuf;
+ dev_t dir_dev;
+ struct LinkiteM *own_link_stack;
+
+#ifdef Xorriso_fat_local_meM
+ char sfe[5*SfileadrL], sfe2[5*SfileadrL];
+ char disk_path[2*SfileadrL], img_path[2*SfileadrL], link_target[SfileadrL];
+#else /* Xorriso_fat_local_meM */
+
+ char *sfe= NULL, *sfe2= NULL;
+ char *disk_path= NULL, *img_path= NULL, *link_target= NULL;
+
+ /* Avoiding large local memory objects in order to save stack space */
+ sfe= malloc(5*SfileadrL);
+ sfe2= malloc(5*SfileadrL);
+ disk_path= malloc(2*SfileadrL);
+ img_path= malloc(2*SfileadrL);
+ link_target= malloc(SfileadrL);
+ if(sfe==NULL || sfe2==NULL || disk_path==NULL || img_path==NULL ||
+    link_target==NULL) {
+   Xorriso_no_malloc_memory(xorriso, &sfe, 0);
+   {ret= -1; goto ex;}
+ }
+   
+#endif /* ! Xorriso_fat_local_meM */
+
+ own_link_stack= link_stack;
+
+ ret= Xorriso_get_volume(xorriso, &volume, 0);
+ if(ret<=0)
+   goto ex;
+
+ if(lstat(disk_dir_path, &stbuf)==-1)
+   goto cannot_open_dir;
+ dir_dev= stbuf.st_dev;
+ if(S_ISLNK(stbuf.st_mode)) {
+   if(!(xorriso->do_follow_links || (xorriso->do_follow_param && !(flag&1))))
+     {ret= 2; goto ex;}
+   if(stat(disk_dir_path, &stbuf)==-1)
+     goto cannot_open_dir;
+   if(dir_dev != stbuf.st_dev &&
+      !(xorriso->do_follow_mount || (xorriso->do_follow_param && !(flag&1))))
+     {ret= 2; goto ex;}
+ }
+ ret= Dirseq_new(&dirseq, disk_dir_path, 1);
+ if(ret<0) {
+   sprintf(xorriso->info_text,"Failed to create source filesystem iterator");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+   {ret= -1; goto ex;}
+ }
+ if(ret==0) {
+cannot_open_dir:;
+   sprintf(xorriso->info_text,"Cannot open as source directory: %s",
+           Text_shellsafe(disk_dir_path, sfe, 0));
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+   {ret= 0; goto ex;}
+ }
+
+ if(Sfile_str(disk_path, disk_dir_path,0)<=0)
+   {ret= -1; goto ex;}
+ 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[0] || img_path[strlen(img_path)-1]!='/')
+   strcat(img_path,"/");
+ img_name= img_path+strlen(img_path);
+
+ while(1) { /* loop over directory content */
+   Linkitem_reset_stack(&own_link_stack, link_stack, 0);
+   srcpt= disk_path;
+   Xorriso_process_msg_queues(xorriso,0);
+   ret= Dirseq_next_adr(dirseq,name,0);
+   if(ret==0)
+ break;
+   if(ret<0) {
+     sprintf(xorriso->info_text,"Failed to obtain next directory entry");
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+     {ret= -1; goto ex;}
+   }
+   strcpy(img_name, name);
+   if(Xorriso_much_too_long(xorriso, strlen(img_path), 0)<=0)
+     {ret= 0; goto was_problem;}
+   if(Xorriso_much_too_long(xorriso, strlen(srcpt), 0)<=0)
+     {ret= 0; goto was_problem;}
+   if(lstat(srcpt, &stbuf)==-1) {
+cannot_lstat:;
+     sprintf(xorriso->info_text,
+             "Cannot determine attributes of source file %s",
+             Text_shellsafe(srcpt, sfe, 0));
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "SORRY", 0);
+     ret= 0; goto was_problem;
+   }
+   source_is_dir= 0;
+   source_is_link= S_ISLNK(stbuf.st_mode);
+   if(xorriso->do_follow_links && source_is_link) {
+     /* Xorriso_hop_link checks for wide link loops */
+     ret= Xorriso_hop_link(xorriso, srcpt, &own_link_stack, &hstbuf, 0);
+     if(ret<0)
+       goto was_problem;
+     if(ret==1) {
+       ret= Xorriso_resolve_link(xorriso, srcpt, link_target, 0);
+       if(ret<=0)
+         goto was_problem;
+       srcpt= link_target;
+       if(lstat(srcpt, &stbuf)==-1)
+         goto cannot_lstat;
+     } else {
+       if(Xorriso_eval_problem_status(xorriso, 0, 1|2)<0)
+         {ret= 0; goto was_problem;} 
+     }
+   } else if (S_ISLNK(stbuf.st_mode)) {
+     ret= Xorriso_resolve_link(xorriso, srcpt, link_target, 1);
+     if(ret<=0)
+       goto was_problem;
+   }
+   do_not_dive= 0;
+   if(S_ISDIR(stbuf.st_mode)) {
+     source_is_dir= 1;
+     if(dir_dev != stbuf.st_dev && !xorriso->do_follow_mount)
+       do_not_dive= 1;
+   } else if(!(S_ISREG(stbuf.st_mode) || S_ISLNK(stbuf.st_mode))) {
+     sprintf(xorriso->info_text,"Source file %s %s non-supported file type",
+             Text_shellsafe(disk_path, sfe, 0),
+             source_is_link ? "leads to" : "is of");
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+     ret= 0; goto was_problem;
+   }
+
+   /* does a node exist with this name ? */
+   node= NULL;
+   ret= iso_tree_path_to_node(volume, img_path, &node);
+   if(ret>0) {
+     target_is_dir= LIBISO_ISDIR(node);
+     if(!(target_is_dir && source_is_dir)) {
+       Xorriso_process_msg_queues(xorriso,0);
+
+       /* handle overwrite situation */;
+       if(xorriso->do_overwrite==1 ||
+          (xorriso->do_overwrite==2 && !target_is_dir)) {
+         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(img_path, sfe, 0));
+           Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
+           ret= 0; goto was_problem;
+         }
+         node= NULL;
+       } else {
+         sprintf(xorriso->info_text,
+           "While grafting %s : file object exists and may not be overwritten",
+           Text_shellsafe(img_path,sfe,0));
+         Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+         ret= 0; goto was_problem;
+       }
+     }
+   }
+
+   if(node==NULL) {
+     if(S_ISLNK(stbuf.st_mode)) {
+
+       /* ??? NG : A80107 : is this solved now ? */
+       /* <<< One should rather change libisofs so that iso_tree_add_node()
+              adds a disk_link as RR link, if RR is enabled */
+
+       ret= iso_tree_add_new_symlink(dir, img_name, link_target,
+                                      (IsoSymlink **) &node);
+       if(ret>0) {
+         ret= Xorriso_transfer_properties(xorriso, &stbuf, node, 0);
+         if(ret<=0)
+           goto was_problem;
+       } else
+         {ret= 0; goto was_problem;}
+     } else {
+       ret= iso_tree_add_node(volume, dir, srcpt, &node);
+       if(ret<0)
+         goto was_problem;
+     }
+   }
+   if(node==NULL) {
+     Xorriso_process_msg_queues(xorriso,0);
+     sprintf(xorriso->info_text, "Grafting failed:  %s = %s",
+             Text_shellsafe(img_path,sfe,0), Text_shellsafe(disk_path,sfe2,0));
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+     ret=0; goto was_problem;
+   }
+   xorriso->volset_change_pending= 1;
+   if(source_is_dir) {
+     if(do_not_dive) {
+       sprintf(xorriso->info_text, "Did not follow mount point : %s",
+               Text_shellsafe(disk_path, sfe, 0));
+       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
+     } else {
+       ret= Xorriso_add_tree(xorriso, (IsoDir *) node,
+                             img_path, disk_path, own_link_stack, 1);
+     }
+     if(ret<=0)
+       goto was_problem;
+   }
+
+ continue; /* regular bottom of loop */
+was_problem:;
+   was_failure= 1;
+   fret= Xorriso_eval_problem_status(xorriso, ret, 1|2);
+   if(fret<0)
+     goto ex;
+ }
+
+ ret= 1;
+ex:
+
+#ifndef Xorriso_fat_local_meM
+ if(sfe!=NULL)
+   free(sfe);
+ if(sfe2!=NULL)
+   free(sfe2);
+ if(disk_path!=NULL)
+   free(disk_path);
+ if(img_path!=NULL)
+   free(img_path);
+ if(link_target!=NULL)
+   free(link_target);
+#endif /* ! Xorriso_fat_local_meM */
+
+ Xorriso_process_msg_queues(xorriso,0);
+ Linkitem_reset_stack(&own_link_stack, link_stack, 0);
+ Dirseq_destroy(&dirseq, 0);
+ if(ret<=0)
+   return(ret);
+ return(!was_failure);
+}
+
+
+/** @param flag bit0= mkdir: graft in as empty directory, not as copy from disk
+    @return <=0 = error , 1 = added simple node , 2 = added directory */
+int Xorriso_graft_in(struct XorrisO *xorriso, char *disk_path, char *img_path,
+                     int flag)
+{
+ IsoImage *volume;
+ char path[SfileadrL], *apt, *npt, *cpt, sfe[5*SfileadrL], sfe2[5*SfileadrL];
+ IsoDir *dir, *hdir;
+ IsoNode *node;
+ int done= 0, is_dir= 0, l, ret, target_is_dir, source_is_dir;
+ struct stat stbuf;
+
+ for(cpt= img_path; 1; cpt++) {
+/*
+   if(cpt[0]!='/')
+ break;
+*/
+   cpt= strstr(cpt,"/.");
+   if(cpt==NULL)
+ break;
+   if(cpt[2]=='.') {
+     if(cpt[3]=='/' || cpt[3]==0)
+ break;
+   } else if(cpt[2]=='/' || cpt[2]==0)
+ break;
+ }
+ if(cpt!=NULL) {
+   sprintf(xorriso->info_text,
+          "Unsupported relative addressing in iso_rr_path '%s'", img_path);
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "SORRY", 0);
+   return(0);
+ }
+
+ ret= Xorriso_get_volume(xorriso, &volume, 0);
+ if(ret<=0)
+   return(ret);
+
+ strncpy(path, img_path, sizeof(path)-1);
+ path[sizeof(path)-1]= 0;
+ apt= npt= path;
+
+ if(!(flag&1)) {
+   if(xorriso->do_follow_links || xorriso->do_follow_param)
+     ret= stat(disk_path, &stbuf);
+   else
+     ret= lstat(disk_path, &stbuf);
+   if(ret == -1) {
+     Xorriso_process_msg_queues(xorriso,0);
+     sprintf(xorriso->info_text,
+            "Cannot determine attributes of source file '%s'",disk_path);
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "SORRY", 0);
+     return(0);
+   }
+   if(S_ISDIR(stbuf.st_mode))
+     is_dir= 1;
+   else if(!(S_ISREG(stbuf.st_mode) || S_ISLNK(stbuf.st_mode))) {
+     Xorriso_process_msg_queues(xorriso,0);
+     sprintf(xorriso->info_text,
+             "Source file '%s' is of non-supported file type", disk_path);
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+     return(0);
+   } else {
+     l= strlen(img_path);
+     if(l>0)
+       if(img_path[l-1]=='/')
+         l= 0;
+     if(l==0) {
+       sprintf(xorriso->info_text,
+               "Source '%s' is not a directory. Target '%s' would be.",
+               disk_path, img_path);
+       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+       return(0);
+     }
+   }
+ }
+
+ dir= iso_image_get_root(volume);
+ if(dir==NULL) {
+   Xorriso_process_msg_queues(xorriso,0);
+   sprintf(xorriso->info_text,
+           "While grafting '%s' : no root node available", img_path);
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+   return(0);
+ }
+ for(npt= apt; !done; apt= npt+1) {
+   npt= strchr(apt, '/');
+   if(npt==NULL) {
+     npt= apt+strlen(apt);
+     done= 1;
+   } else
+     *npt= 0;
+   if(*apt==0) {
+     *apt= '/';
+     apt++;
+     if(done)
+       goto attach_source;
+ continue;
+   }
+   source_is_dir= (is_dir || (flag&1) || !done);
+   ret= iso_tree_path_to_node(volume, path, &node);
+   if(ret<=0) {
+     node= NULL;
+   } else {
+     target_is_dir= LIBISO_ISDIR(node);
+     if(!(target_is_dir && source_is_dir)) {
+       Xorriso_process_msg_queues(xorriso,0);
+
+       /* handle overwrite situation */;
+       if(xorriso->do_overwrite==1 ||
+          (xorriso->do_overwrite==2 && !target_is_dir)) {
+         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;
+       }
+
+       sprintf(xorriso->info_text,
+              "While grafting '%s' : '%s' exists and may not be overwritten",
+              img_path, path);
+       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+       return(0);
+     }
+     dir= (IsoDir *) node;
+   }
+
+handle_path_node:;
+   if(node==NULL && source_is_dir) { /* make a directory */
+     ret= iso_tree_add_new_dir(dir, apt, &hdir);
+     if(ret<0) {
+       Xorriso_process_msg_queues(xorriso,0);
+       sprintf(xorriso->info_text,
+               "While grafting '%s' : could not insert '%s'", img_path, path);
+       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+       return(0);
+     }
+     dir= hdir;
+     xorriso->volset_change_pending= 1;
+     iso_node_set_ctime((IsoNode *) dir, time(NULL));
+
+     /* >>> copy properties from correspondent directory in disk_path
+            if there is any */;
+
+   }
+   if(done) {
+attach_source:;
+     if(flag&1) {
+       /* directory node was created above */;
+
+     } else if(is_dir) {
+       ret= Xorriso_add_tree(xorriso, dir, img_path, disk_path, NULL, 0);
+       if(ret<=0)
+         return(ret);
+
+     } else {
+       ret= iso_tree_add_node(volume, dir, disk_path, &node);
+       if(ret<0) {
+         Xorriso_process_msg_queues(xorriso,0);
+         sprintf(xorriso->info_text, "Grafting failed:  %s = %s",
+             Text_shellsafe(img_path,sfe,0), Text_shellsafe(disk_path,sfe2,0));
+         Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+         return(0);
+       }
+       xorriso->volset_change_pending= 1;
+       iso_node_set_name(node, apt);
+     }
+   } else
+     *npt= '/';
+ }
+ Xorriso_process_msg_queues(xorriso,0);
+ return(1+!!is_dir);
+}
+
+
+int Xorriso__text_to_sev(char *severity_name, int *severity_number, int flag)
+{
+ int ret= 1;
+
+ if(severity_name[0]==0)
+   *severity_number= 0;
+ else
+   ret= burn_text_to_sev(severity_name, severity_number, 0);
+ return(ret);
+}
+
+
+int Xorriso_process_msg_queues(struct XorrisO *xorriso, int flag)
+{
+ int ret, error_code= 0, os_errno= 0, count= 0, pass, start_pass= 0;
+ char severity[80];
+ IsoImage *volume;
+
+ ret= Xorriso_get_volume(xorriso, &volume, 0);
+ if(ret<=0)
+   start_pass= 1;
+
+ if(!xorriso->libs_are_started)
+   return(1);
+ for(pass= 0; pass< 2; pass++) {
+   while(1) {
+     if(pass==0)
+       ret= iso_image_obtain_msgs(volume, "ALL", &error_code,
+                                  xorriso->info_text, &os_errno, severity);
+     else
+       ret= burn_msgs_obtain("ALL", &error_code, xorriso->info_text, &os_errno,
+                             severity);
+     if(ret<=0)
+   break;
+     Xorriso_msgs_submit(xorriso, error_code, xorriso->info_text, os_errno, 
+                         severity, (pass+1)<<2);
+     count++;
+   }
+ }
+ if(xorriso->library_msg_direct_print && count>0) {
+   sprintf(xorriso->info_text,"   (%d library messages repeated by xorriso)\n",
+           count);
+   Xorriso_info(xorriso, 0);
+ }
+ return(1);
+}
+
+
+/* @param flag bit0=short report form
+               bit1=report about output drive
+*/
+int Xorriso_toc(struct XorrisO *xorriso, int flag)
+{
+ int num_sessions= 0, num_tracks= 0, lba= 0, nwa= -1, pmin, psec, pframe, ret;
+ int track_count= 0, session_no, track_no, profile_no= -1;
+ int last_track_start= 0, last_track_size= -1, num_data= 0, is_data= 0;
+ int is_inout_drive= 0;
+ char profile_name[80],*respt,*devadr;
+ struct burn_disc *disc= NULL;
+ struct burn_session **sessions;
+ struct burn_track **tracks;
+ struct burn_toc_entry toc_entry;
+ struct burn_drive_info *dinfo;
+ struct burn_drive *drive;
+ enum burn_disc_status s;
+ char mem_text[80];
+
+ ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
+                               "on attempt to print Table Of Content", flag&2);
+ if(ret<=0)
+   return(0);
+
+ respt= xorriso->result_line;
+
+ if(strcmp(xorriso->indev, xorriso->outdev)==0)
+   is_inout_drive= 1;
+ if(flag&2)
+   devadr= xorriso->outdev;
+ else
+   devadr= xorriso->indev;
+ sprintf(respt, "Drive current: %s '%s'\n",
+         (is_inout_drive ? "-dev" : (flag&2 ? "-outdev" : "-indev")),
+         devadr);
+ Xorriso_result(xorriso,0);
+ sprintf(respt, "Drive type   : vendor '%s' product '%s' revision '%s'\n",
+        dinfo[0].vendor, dinfo[0].product, dinfo[0].revision);
+ if(!(flag&1))
+   Xorriso_result(xorriso,0);
+ 
+ sprintf(respt, "Media current: ");
+ ret= burn_disc_get_profile(drive, &profile_no, profile_name);
+ if (profile_no > 0 && ret > 0) {
+   if (profile_name[0])
+     sprintf(respt+strlen(respt), "%s\n", profile_name);
+   else
+     sprintf(respt+strlen(respt), "%4.4Xh\n", profile_no);
+ } else
+    sprintf(respt+strlen(respt), "is not recognizable\n");
+ Xorriso_result(xorriso,0);
+
+ sprintf(respt, "Media status : ");
+ s= isoburn_disc_get_status(drive);
+ if (s == BURN_DISC_FULL) {
+   sprintf(respt+strlen(respt), "is written , is closed\n");
+ } else if (s == BURN_DISC_APPENDABLE) {
+   sprintf(respt+strlen(respt), "is written , is appendable\n");
+ } else if (s == BURN_DISC_BLANK) {
+   sprintf(respt+strlen(respt), "is blank\n");
+ } else if (s == BURN_DISC_EMPTY)
+   sprintf(respt+strlen(respt), "is not present\n");
+ else
+   sprintf(respt+strlen(respt), "is not recognizable\n");
+ Xorriso_result(xorriso,0);
+
+ if(s != BURN_DISC_FULL && s != BURN_DISC_APPENDABLE)
+   return(1);
+  
+ if(xorriso->request_to_abort)
+   return(1);
+
+ disc= burn_drive_get_disc(drive);
+ if (disc==NULL) {
+   Xorriso_process_msg_queues(xorriso,0);
+
+#define Xorriso_with_isoburn_get_min_start_bytE 1
+#ifdef Xorriso_with_isoburn_get_min_start_bytE
+   { off_t start_byte= 0;
+     ret= isoburn_get_min_start_byte(drive, &start_byte, 0);
+     nwa= start_byte / 2048;
+   }
+#else
+   ret= isoburn_disc_track_lba_nwa(drive, NULL, 0, &lba, &nwa);
+#endif
+
+   if(ret<=0) {
+     Xorriso_process_msg_queues(xorriso,0);
+     if(flag&1)
+       return(0);
+     sprintf(xorriso->info_text, "Cannot obtain Table Of Content");
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+     return(0);
+   }
+   /* fabricate TOC */
+   sprintf(respt, "Media content: session %2d  ", 1);
+   sprintf(respt+strlen(respt), "track    %2d %s  lba: %9d\n", 1, "data ", 0);
+   if(!(flag&1))
+     Xorriso_result(xorriso,0);
+   last_track_start= lba;
+   sprintf(respt, "Media content: session %2d  ", 1);
+   sprintf(respt+strlen(respt), "leadout            lba: %9d\n", nwa);
+   if(!(flag&1))
+     Xorriso_result(xorriso,0);
+   num_data= last_track_size= nwa;
+   num_sessions= 1;
+ } else {
+   sessions= burn_disc_get_sessions(disc, &num_sessions);
+   for (session_no= 0; session_no<num_sessions && !(xorriso->request_to_abort);
+        session_no++) {
+     tracks = burn_session_get_tracks(sessions[session_no], &num_tracks);
+     if (tracks==NULL)
+   continue;
+     for(track_no= 0; track_no<num_tracks && !(xorriso->request_to_abort);
+         track_no++) {
+       track_count++;
+       is_data= 0;
+       burn_track_get_entry(tracks[track_no], &toc_entry);
+       if (toc_entry.extensions_valid & 1) {
+         /* DVD extension valid */
+         lba= toc_entry.start_lba;
+       } else {
+         lba= burn_msf_to_lba(toc_entry.pmin, toc_entry.psec, toc_entry.pframe);
+       }
+       sprintf(respt, "Media content: session %2d  ", session_no+1);
+       sprintf(respt+strlen(respt), "track    %2d %s  lba: %9d\n",
+               track_count, ((toc_entry.control&7)<4?"audio":"data "), lba);
+       if(!(flag&1))
+         Xorriso_result(xorriso,0);
+       last_track_start= lba;
+       if((toc_entry.control&7)>=4) /* data track */
+         is_data= 1;
+     }
+     burn_session_get_leadout_entry(sessions[session_no], &toc_entry);
+     if (toc_entry.extensions_valid & 1) {
+       lba= toc_entry.start_lba;
+       burn_lba_to_msf(lba, &pmin, &psec, &pframe);
+     } else {
+       lba= burn_msf_to_lba(pmin, psec, pframe);
+       lba= burn_msf_to_lba(toc_entry.pmin, toc_entry.psec, toc_entry.pframe);
+     }
+     sprintf(respt, "Media content: session %2d  ", session_no+1);
+     sprintf(respt+strlen(respt), "leadout            lba: %9d\n", lba);
+     if(!(flag&1))
+       Xorriso_result(xorriso,0);
+     last_track_size= lba - last_track_start;
+     if(is_data)
+       num_data+= last_track_size;
+   }
+ }
+ if(xorriso->request_to_abort)
+   return(1);
+ Sfile_scale(((double) num_data) * 2048.0, mem_text,5,1e4,1);
+ sprintf(respt, "Media summary: %d session%s, %d data blocks, %s\n",
+         num_sessions, (num_sessions==1 ? "" : "s"), num_data, mem_text);
+ Xorriso_result(xorriso,0);
+
+ if (s == BURN_DISC_APPENDABLE && nwa!=0) {
+   ret= isoburn_disc_track_lba_nwa(drive, NULL, 0, &lba, &nwa);
+   if(ret>0) {
+     sprintf(respt, "Media nwa    : %ds\n", nwa);
+     if(!(flag&1))
+       Xorriso_result(xorriso,0);
+   }
+ }
+
+ if (disc!=NULL)
+   burn_disc_free(disc);
+ Xorriso_process_msg_queues(xorriso,0);
+ return(1);
+}
+
+
+int Xorriso_show_devices(struct XorrisO *xorriso, int flag)
+{
+ char adr[BURN_DRIVE_ADR_LEN];
+ int i;
+ struct burn_drive_info *drive_list= NULL;
+ unsigned int drive_count;
+ char *respt, perms[8];
+ struct stat stbuf;
+
+ sprintf(xorriso->info_text, "Beginning to scan for devices ...\n");
+ Xorriso_info(xorriso,0);
+
+ burn_drive_clear_whitelist(); 
+ while(!burn_drive_scan(&drive_list, &drive_count)) {
+   Xorriso_process_msg_queues(xorriso,0);
+   usleep(100000);
+ }
+ Xorriso_process_msg_queues(xorriso,0);
+ if(drive_count <= 0) {
+
+   /* >>> was a drive_list created at all ? */
+   /* >>> must it be freed ? */
+
+   sprintf(xorriso->info_text, "No drives found");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+   return(0);
+ }
+ sprintf(xorriso->info_text, "Full drive scan done\n");
+ Xorriso_info(xorriso,0);
+
+ respt= xorriso->result_line;
+ for(i= 0; i < drive_count && !(xorriso->request_to_abort); i++) {
+   if(burn_drive_get_adr(&(drive_list[i]), adr)<=0)
+     strcpy(adr, "-get_adr_failed-");
+   Xorriso_process_msg_queues(xorriso,0);
+   if(stat(adr,&stbuf)==-1) {
+     sprintf(perms,"errno=%d",errno);
+   } else { 
+     strcpy(perms,"------");
+     if(stbuf.st_mode&S_IRUSR) perms[0]= 'r';
+     if(stbuf.st_mode&S_IWUSR) perms[1]= 'w';
+     if(stbuf.st_mode&S_IRGRP) perms[2]= 'r';
+     if(stbuf.st_mode&S_IWGRP) perms[3]= 'w';
+     if(stbuf.st_mode&S_IROTH) perms[4]= 'r';
+     if(stbuf.st_mode&S_IWOTH) perms[5]= 'w';
+   }
+   sprintf(respt, "%d  -dev '%s' %s :  '%-8.8s' '%s' \n",
+           i, adr, perms, drive_list[i].vendor, drive_list[i].product);
+   Xorriso_result(xorriso,0);
+ }
+ burn_drive_info_free(drive_list);
+ Xorriso_process_msg_queues(xorriso,0);
+ return(1);
+}
+
+
+int Xorriso_tell_media_space(struct XorrisO *xorriso,
+                             int *media_space, int *free_space, int flag)
+{
+ int ret;
+ struct burn_drive_info *dinfo;
+ struct burn_drive *drive;
+ struct burn_write_opts *burn_options;
+
+ (*free_space)= (*media_space)= 0;
+
+ ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
+                                "on attempt to -tell_media_space", 2);
+ if(ret<=0)
+   return(0);
+
+ ret= Xorriso_make_write_options(xorriso, drive, &burn_options, 0);
+ if(ret<=0)
+   return(-1);
+ (*free_space)= (*media_space)=
+                 burn_disc_available_space(drive, burn_options) / (off_t) 2048;
+ burn_write_opts_free(burn_options);
+
+ if(xorriso->volset_change_pending) {
+   ret= Xorriso_write_session(xorriso, 1);
+   if(ret>0)
+     (*free_space)-= ret;
+ }
+ Xorriso_process_msg_queues(xorriso,0);
+ return(1);
+}
+
+
+/* @param flag bit0=fast , bit1=deformat
+   @return 0=failure, did not touch media , -1=failure, altered media
+           1=success, altered media       ,  2=success, did not touch media
+*/
+int Xorriso_blank_media(struct XorrisO *xorriso, int flag)
+{
+ int ret, do_deformat= 0;
+ struct burn_drive_info *dinfo;
+ struct burn_drive *drive;
+ enum burn_disc_status disc_state;
+ struct burn_progress p;
+ double percent = 1.0;
+ int current_profile;
+ char current_profile_name[80];
+ char mode_names[4][80]= {"all", "fast", "deformat", "deformat_quickest"};
+
+ ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
+                                "on attempt to -blank", 2);
+ if(ret<=0)
+   return(0);
+
+ burn_disc_get_profile(drive, &current_profile, current_profile_name);
+
+ /* >>> */;
+
+ disc_state = isoburn_disc_get_status(drive);
+ if(current_profile == 0x13) { /* overwriteable DVD-RW */
+   /* Depending on flag bit1 formatted DVD-RW will get blanked to sequential
+      state or pseudo blanked by invalidating an eventual ISO image. */
+   if(flag&2)
+     do_deformat= 1;
+ } else if(current_profile == 0x14) { /* sequential DVD-RW */
+   if((flag&1) && !(flag&2)) {
+     sprintf(xorriso->info_text,
+             "-blank: DVD-RW present. Mode 'fast' defaulted to mode 'all'.");
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
+     sprintf(xorriso->info_text,
+             "Mode 'deformat_quickest' produces single-session-only media.");
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "HINT", 0);
+     flag&= ~1;
+   }
+ } else if(disc_state == BURN_DISC_BLANK) {
+   sprintf(xorriso->info_text,"Blank media detected. Will leave it untouched");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
+   return 2;
+ } else if(disc_state==BURN_DISC_FULL || disc_state==BURN_DISC_APPENDABLE) {
+   ;
+ } else if(disc_state == BURN_DISC_EMPTY) {
+   sprintf(xorriso->info_text,"No media detected in drive");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+   return 0;
+ } else {
+   sprintf(xorriso->info_text, "Unsuitable drive and media state");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+   return 0;
+ }
+ if(!isoburn_disc_erasable(drive)) {
+   sprintf(xorriso->info_text, "Media is not of erasable type");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+   return 0;
+ }
+ if(xorriso->do_dummy) {
+   sprintf(xorriso->info_text,
+           "-dummy mode prevents blanking of media in mode '%s'.",
+           mode_names[flag&3]);
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
+   return(1);
+ }
+ sprintf(xorriso->info_text, "Beginning to blank media in mode '%s'.\n",
+         mode_names[flag&3]);
+ Xorriso_info(xorriso,0);
+
+ if(do_deformat)
+   burn_disc_erase(drive, (flag&1));
+ else
+   isoburn_disc_erase(drive, (flag&1));
+ usleep(1000000);
+ while (burn_drive_get_status(drive, &p) != BURN_DRIVE_IDLE) {
+   if(p.sectors>0 && p.sector>=0) /* display 1 to 99 percent */
+     percent = 1.0 + ((double) p.sector+1.0) / ((double) p.sectors) * 98.0;
+   sprintf(xorriso->info_text, "Blanking  ( %.1f%% done )", percent);
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "UPDATE", 0);
+   usleep(1000000);
+ }
+ Xorriso_process_msg_queues(xorriso,0);
+ sprintf(xorriso->info_text, "Blanking done\n");
+ Xorriso_info(xorriso,0);
+ return(1);
+}
+
+/* @return 0=failure, did not touch media , -1=failure, altered media
+           1=success, altered media       ,  2=success, did not touch media
+*/
+int Xorriso_format_media(struct XorrisO *xorriso, int flag)
+{
+ int ret, mode_flag= 0;
+ struct burn_drive_info *dinfo;
+ struct burn_drive *drive;
+ int current_profile;
+ char current_profile_name[80];
+
+ ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
+                                "on attempt to -format", 2);
+ if(ret<=0)
+   return(0);
+
+ burn_disc_get_profile(drive, &current_profile, current_profile_name);
+ if(current_profile == 0x14) {
+   ; /* ok DVD-RW sequential */
+ } else if(current_profile == 0x1a) {
+   mode_flag= 2;
+ } else {
+   sprintf(xorriso->info_text,
+          "Can only -format DVD+RW and sequential DVD-RW");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+   sprintf(xorriso->info_text,"Media current: %s (%4.4xh)",
+           current_profile_name, current_profile);
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
+   return 0;
+ }
+
+ if(xorriso->do_dummy) {
+   sprintf(xorriso->info_text, "-dummy mode prevents formatting of media.");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
+   return(1);
+ }
+ sprintf(xorriso->info_text, "Beginning to format media.\n");
+ Xorriso_info(xorriso, 0);
+ burn_disc_format(drive, (off_t) 0, mode_flag);
+
+ ret= Xorriso_pacifier_loop(xorriso, drive, 0);
+ if(ret<=0)
+   return(ret);
+
+ Xorriso_process_msg_queues(xorriso,0);
+ sprintf(xorriso->info_text, "Formatting done\n");
+ Xorriso_info(xorriso,0);
+ return(1);
+}
+
+
+int Xorriso_node_from_path(struct XorrisO *xorriso, IsoImage *volume,
+                           char *path, IsoNode **node, int flag)
+{
+ int ret;
+ char sfe[5*SfileadrL];
+
+ ret= iso_tree_path_to_node(volume, path, node);
+ Xorriso_process_msg_queues(xorriso,0);
+ if(ret<=0) {
+   sprintf(xorriso->info_text, "Cannot find path %s in loaded ISO image",
+           Text_shellsafe(path, sfe, 0));
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+   return(0);
+ }
+ return(1);
+}
+
+
+/* @param boss_iter  If not NULL then this is an iterator suitable for
+               iso_dir_iter_remove()  which is then to be used instead
+               of iso_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, void *boss_iter,
+                char *path, int flag)
+{
+ int ret, is_dir= 0, pl, not_removed= 0, fret;
+ IsoNode *victim_node, *node;
+ IsoDir *boss_node, *root_dir;
+ IsoDirIter *iter= NULL;
+ IsoImage *volume;
+ char *sub_name, *name;
+
+#ifdef Xorriso_fat_local_meM
+ char sfe[5*SfileadrL], sub_path[2*SfileadrL];
+#else
+ char *sfe= NULL, *sub_path= NULL;
+
+ /* Avoiding large local memory objects in order to save stack space */
+ sfe= malloc(5*SfileadrL);
+ sub_path= malloc(2*SfileadrL);
+ if(sfe==NULL || sub_path==NULL) {
+   Xorriso_no_malloc_memory(xorriso, &sfe, 0);
+   {ret= -1; goto ex;}
+ }
+#endif /* ! Xorriso_fat_local_meM */
+
+ ret= Xorriso_get_volume(xorriso, &volume, 0);
+ if(ret<=0)
+   goto ex;
+ 
+ if(Xorriso_much_too_long(xorriso, strlen(path), 0)<=0)
+   {ret= 0; goto ex;}
+ ret= Xorriso_node_from_path(xorriso, volume, path, &victim_node, 0);
+ if(ret<=0)
+   goto ex;
+ root_dir= iso_image_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);
+   {ret= 0; goto ex;}
+ }
+
+ if(LIBISO_ISDIR(victim_node))
+   is_dir= 1;
+ if(!is_dir) {
+   if(flag&2) { /* rmdir */
+     sprintf(xorriso->info_text, "%s in loaded ISO image is not a directory",
+             Text_shellsafe(path, sfe, 0));
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+     ret= 0; goto ex;
+   }
+ } else {
+   if(flag&1) { /* rm -r */
+     if(xorriso->do_reassure==1 && !xorriso->request_not_to_ask) {
+       /* Iterate over subordinates and delete them */
+
+       ret= iso_dir_get_children((IsoDir *) victim_node, &iter);
+       Xorriso_process_msg_queues(xorriso,0);
+       if(ret<0) {
+cannot_create_iter:;
+         sprintf(xorriso->info_text, "Cannot create IsoDirIter object");
+         Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+         ret= -1; goto ex;
+       }
+       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(iso_dir_iter_next(iter, &node) == 1
+             && !xorriso->request_to_abort) {
+         name= (char *) iso_node_get_name(node);
+         if(Xorriso_much_too_long(xorriso, pl+1+strlen(name), 0)<=0)
+           {ret= 0; goto rm_r_problem_handler;}
+         strcpy(sub_name, name);
+         ret= Xorriso_rmi(xorriso, iter, sub_path, (flag&(1|2|8))|4);
+         if(ret==3 || ret<=0 || xorriso->request_to_abort) {
+rm_r_problem_handler:;
+           not_removed= 1;
+           fret= Xorriso_eval_problem_status(xorriso, ret, 1|2);
+           if(fret<0)
+             goto dir_not_removed;
+         }
+       }
+       if(not_removed) {
+dir_not_removed:;
+         sprintf(xorriso->info_text, "Directory not removed: %s",
+                 Text_shellsafe(path, sfe, 0));
+         Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
+         if(ret>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);
+       ret= 0; goto ex;
+     }
+
+     ret= iso_dir_get_children((IsoDir *) victim_node, &iter);
+     Xorriso_process_msg_queues(xorriso,0);
+     if(ret<0)
+       goto cannot_create_iter;
+     if(ret>0) {
+       if(iso_dir_iter_next(iter, &node) == 1) {
+         sprintf(xorriso->info_text,
+                 "Directory not empty on attempt to delete: %s",
+                 Text_shellsafe(path, sfe, 0));
+         Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+         ret= 0; goto ex;
+       }
+     }
+   }
+ }
+
+ if(xorriso->request_to_abort)
+   {ret= 3; goto ex;}
+
+ /* >>> NG
+ boss_node= iso_tree_node_get_parent(victim_node);
+ */
+
+ Xorriso_process_msg_queues(xorriso,0);
+ if(boss_node==NULL) {
+   sprintf(xorriso->info_text,
+           "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);
+   ret= 0; goto ex;
+ }
+
+ while((xorriso->do_reassure==1 || (xorriso->do_reassure==2 && !(flag&4)))
+       && !xorriso->request_not_to_ask) {
+   /* ls -ld */
+   Xorriso_ls_filev(xorriso, xorriso->wdi, 1, &path, (off_t) 0, 1|2|8);
+   if(is_dir) /* du -s */
+     Xorriso_ls_filev(xorriso, xorriso->wdi, 1, &path, (off_t) 0, 2|4);
+   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|16);
+   if(ret<=0)
+     goto ex;
+   if(xorriso->request_to_abort) {
+     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_dir_iter_remove((IsoDirIter *) boss_iter);
+   if(ret<0)
+     ret= -1;
+ } else
+   ret= iso_node_remove(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);
+   ret= -1; goto ex;
+ }
+ xorriso->volset_change_pending= 1;
+ ret= 1+!!is_dir;
+ex:;
+
+#ifndef Xorriso_fat_local_meM
+ if(sfe!=NULL)
+   free(sfe);
+ if(sub_path!=NULL)
+   free(sub_path);
+#endif /* ! Xorriso_fat_local_meM */
+
+ if(iter!=NULL)
+   iso_dir_iter_free(iter);
+ return(ret);
+} 
+
+
+int Xorriso__node_name_cmp(const void *node1, const void *node2)
+{
+ char *name1, *name2;
+
+ name1= (char *) iso_node_get_name(*((IsoNode **) node1));
+ name2= (char *) iso_node_get_name(*((IsoNode **) node2));
+ return(strcmp(name1,name2));
+}
+
+
+/* @param flag bit0= only accept directory nodes
+               bit1= do not report memory usage as DEBUG
+               bit2= do not apply search pattern but accept any node
+*/
+int Xorriso_sorted_node_array(struct XorrisO *xorriso, 
+                              IsoDir *dir_node,
+                              int *nodec, IsoNode ***node_array,
+                              off_t boss_mem, int flag)
+{
+ int i, ret, failed_at;
+ char *npt;
+ IsoDirIter *iter= NULL;
+ IsoNode *node;
+ off_t mem;
+
+ mem= ((*nodec)+1)*sizeof(IsoNode *);
+ ret= Xorriso_check_temp_mem_limit(xorriso, mem+boss_mem, flag&2);
+ if(ret<=0)
+   return(ret);
+
+ *node_array= calloc(sizeof(IsoNode *), (*nodec)+1);
+ if(*node_array==NULL) {
+   sprintf(xorriso->info_text,
+           "Cannot allocate memory for %d directory entries", *nodec); 
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+   return(-1);
+ }
+
+ ret= iso_dir_get_children(dir_node, &iter);
+ if(ret<0) {
+   sprintf(xorriso->info_text, "Cannot create IsoDirIter object");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+   return(-1);
+ }
+ 
+ for(i= 0; iso_dir_iter_next(iter, &node) == 1 && i<*nodec; ) {
+   npt= (char *) iso_node_get_name(node);
+   if(!(flag&4)) {
+     ret= Xorriso_regexec(xorriso, npt, &failed_at, 0);
+     if(ret)
+ continue; /* no match */
+   }
+   if(flag&1)
+     if(!LIBISO_ISDIR(node))
+ continue;
+   (*node_array)[i++]= node;
+ }
+ *nodec= i;
+ if(*nodec<=0)
+   return(1);
+ qsort(*node_array, *nodec, sizeof(IsoNode *), Xorriso__node_name_cmp);
+ return(1);
+}
+
+
+/* @param flag bit0= do not only sum up sizes but also print subdirs
+*/
+int Xorriso_show_du_subs(struct XorrisO *xorriso, IsoDir *dir_node,
+                      char *abs_path, char *rel_path, off_t *size,
+                      off_t boss_mem, int flag)
+{
+ int i, ret, no_sort= 0, filec= 0, l;
+ IsoDirIter *iter= NULL;
+ IsoNode *node, **node_array= NULL;
+ char *name;
+ off_t sub_size, report_size, mem= 0;
+
+#ifdef Xorriso_fat_local_meM
+ char path[SfileadrL], show_path[SfileadrL], sfe[5*SfileadrL];
+#else /* Xorriso_fat_local_meM */
+ char *path= NULL, *show_path= NULL, *sfe= NULL;
+
+ sfe= malloc(5*SfileadrL);
+ path= malloc(SfileadrL);
+ show_path= malloc(SfileadrL);
+ if(path==NULL || show_path==NULL || sfe==NULL) {
+   Xorriso_no_malloc_memory(xorriso, &sfe, 0);
+   {ret= -1; goto ex;}
+ }
+
+#endif /* ! Xorriso_fat_local_meM */
+
+ *size= 0;
+ ret= iso_dir_get_children(dir_node, &iter);
+ if(ret<0) {
+cannot_create_iter:;
+   Xorriso_process_msg_queues(xorriso,0);
+   sprintf(xorriso->info_text, "Cannot obtain ISO directory iterator");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+   {ret= -1; goto ex;}
+ }
+ for(i= 0; iso_dir_iter_next(iter, &node) == 1; ) {
+   sub_size= 0;
+   name= (char *) iso_node_get_name(node);
+   strcpy(show_path, rel_path);
+   if(Sfile_add_to_path(show_path, name, 0)<=0)
+       goto much_too_long;
+   if(LIBISO_ISDIR(node)) {
+     strcpy(path, abs_path);
+     if(Sfile_add_to_path(path, name, 0)<=0) {
+much_too_long:;
+       Xorriso_much_too_long(xorriso, strlen(path)+strlen(name)+1, 2);
+       {ret= -1; goto ex;}
+     }
+     filec++;
+     l= strlen(rel_path)+1;
+     mem+= l;
+     if(l % sizeof(char *))
+       mem+= sizeof(char *)-(l % sizeof(char *));
+     if(flag&1) /* diving and counting is done further below */
+ continue;
+     ret= Xorriso_show_du_subs(xorriso, (IsoDir *) node,
+                               path, show_path, &sub_size, boss_mem, 0);
+     if(ret<0)
+       goto ex;
+     if(ret==0)
+ continue;
+   }
+
+   if(LIBISO_ISREG(node)) {
+     sub_size+= iso_file_get_size((IsoFile *) node)+2048;
+/*
+     sub_size+= iso_file_get_size((IsoFile *) node)+strlen(name)+1;
+*/
+   }
+
+   if(sub_size>0)
+     (*size)+= sub_size;
+   Xorriso_process_msg_queues(xorriso,0);
+ }
+
+ if(filec<=0 || !(flag&1))
+   {ret= 1; goto ex;}
+
+ /* Reset iteration */
+ iso_dir_iter_free(iter);
+ iter= NULL;
+ Xorriso_process_msg_queues(xorriso,0);
+
+ ret= Xorriso_sorted_node_array(xorriso, dir_node, &filec, &node_array,
+                                boss_mem, 1|2|4);
+ if(ret<0)
+   goto ex;
+ if(ret==0) {
+   no_sort= 1;
+   ret= iso_dir_get_children(dir_node, &iter);
+   if(ret<0)
+     goto cannot_create_iter;
+ }
+
+ for(i= 0; (no_sort || i<filec) && !(xorriso->request_to_abort); i++) {
+   if(no_sort) {
+     ret= iso_dir_iter_next(iter, &node);
+     if(ret!=1)
+ break;
+     if(!LIBISO_ISDIR(node))
+ continue;
+   } else
+     node= node_array[i];
+
+   sub_size= 0;
+   name= (char *) iso_node_get_name(node);
+   strcpy(show_path, rel_path);
+   if(Sfile_add_to_path(show_path, name, 0)<=0)
+     goto much_too_long;
+   strcpy(path, abs_path);
+   if(Sfile_add_to_path(path, name, 0)<=0)
+     goto much_too_long;
+   ret= Xorriso_show_du_subs(xorriso, (IsoDir *) node,
+                             path, show_path, &sub_size, boss_mem+mem, flag&1);
+   if(ret<0)
+     goto ex;
+
+   if(LIBISO_ISREG(node)) {
+     sub_size+= iso_file_get_size((IsoFile *) node)+2048;
+/*
+     sub_size+= iso_tree_node_get_size((IsoFile *) node)+strlen(name)+1;
+*/
+   }
+   if(sub_size>0)
+     (*size)+= sub_size;
+   report_size= sub_size/1024;
+   if(report_size*1024<sub_size)
+      report_size++;
+   sprintf(xorriso->result_line, "%7.f ",(double) (report_size));
+   sprintf(xorriso->result_line+strlen(xorriso->result_line), "%s\n",
+           Text_shellsafe(show_path, sfe, 0));
+   Xorriso_result(xorriso, 0);
+ }
+ ret= 1;
+ex:;
+
+#ifndef Xorriso_fat_local_meM
+ if(sfe!=NULL)
+   free(sfe);
+ if(path!=NULL)
+   free(path);
+ if(show_path!=NULL)
+   free(show_path);
+#endif /* ! Xorriso_fat_local_meM */
+
+ if(iter!=NULL)
+   iso_dir_iter_free(iter);
+ if(node_array!=NULL)
+   free((char *) node_array);
+ Xorriso_process_msg_queues(xorriso,0);
+ return(ret);
+}
+
+
+/* @param flag bit0= *node is already valid */
+int Xorriso_fake_stbuf(struct XorrisO *xorriso, char *path, struct stat *stbuf,
+                       IsoNode **node, int flag)
+{
+ int ret;
+ IsoImage *volume;
+
+ memset((char *) stbuf, 0, sizeof(struct stat));
+ if(!(flag&1)) {
+   ret= Xorriso_get_volume(xorriso, &volume, 0);
+   if(ret<=0)
+     return(-1);
+   ret= iso_tree_path_to_node(volume, path, node);
+   if(ret<=0)
+     node= NULL;
+ }
+ if(*node==NULL)
+   return(0);
+
+ /* >>> stbuf->st_dev */
+ /* >>> stbuf->st_ino */
+
+ stbuf->st_mode= iso_node_get_permissions(*node) & 07777;
+ if(LIBISO_ISDIR(*node))
+   stbuf->st_mode|= S_IFDIR;
+ else if(LIBISO_ISREG(*node))
+   stbuf->st_mode|= S_IFREG;
+ else if(LIBISO_ISLNK(*node))
+   stbuf->st_mode|= S_IFLNK;
+ else if(LIBISO_ISLNK(*node))
+   stbuf->st_mode|= S_IFCHR;
+ else if(LIBISO_ISBLK(*node))
+   stbuf->st_mode|= S_IFBLK;
+ else if(LIBISO_ISFIFO(*node))
+   stbuf->st_mode|= S_IFIFO;
+ else if(LIBISO_ISSOCK(*node))
+   stbuf->st_mode|= S_IFSOCK;
+
+ /* >>> NG  How to represent LIBISO_BOOT ? */
+
+
+ /* >>> With directories this should be : number of subdirs + 2 */
+ /* >>> ??? How to obtain RR hardlink number for other types ? */
+ stbuf->st_nlink= 1;
+
+ stbuf->st_uid= iso_node_get_uid(*node);
+ stbuf->st_gid= iso_node_get_gid(*node);
+
+ /* >>> stbuf->st_rdev */
+
+ if(LIBISO_ISREG(*node))
+   stbuf->st_size= iso_file_get_size((IsoFile *) *node)+2048;
+ else
+   stbuf->st_size= 0;
+
+ stbuf->st_blksize= 2048;
+ stbuf->st_blocks= stbuf->st_size / (off_t) 2048;
+ if(stbuf->st_blocks * (off_t) 2048 != stbuf->st_size)
+   stbuf->st_blocks++; 
+
+ stbuf->st_atime= iso_node_get_atime(*node);
+ stbuf->st_mtime= iso_node_get_mtime(*node);
+ stbuf->st_ctime= iso_node_get_ctime(*node);
+ return(1);
+}
+
+
+int Xorriso_sorted_dir_i(struct XorrisO *xorriso, IsoDir *dir_node,
+                         int *filec, char ***filev, off_t boss_mem, int flag)
+{
+ int i,j,ret;
+ IsoDirIter *iter= NULL;
+ IsoNode *node;
+ char *name;
+ off_t mem;
+
+ (*filec)= 0;
+ (*filev)= NULL;
+
+ ret= iso_dir_get_children(dir_node, &iter);
+ if(ret<0) {
+cannot_iter:;
+   Xorriso_process_msg_queues(xorriso,0);
+   sprintf(xorriso->info_text, "Cannot obtain ISO directory iterator");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+   {ret= -1; goto ex;}
+ }
+ mem= 0;
+ for(i= 0; iso_dir_iter_next(iter, &node) == 1; ) {
+   name= (char *) iso_node_get_name(node);
+   mem+= sizeof(char *)+strlen(name)+8;
+   (*filec)++;
+ }
+ iso_dir_iter_free(iter);
+ if(*filec==0)
+   {ret= 1; goto ex;}
+
+ ret= Xorriso_check_temp_mem_limit(xorriso, mem+boss_mem, 2);
+ if(ret<=0)
+   goto ex;
+ (*filev)= (char **) calloc(*filec, sizeof(char *));
+ if(*filev==NULL)
+   {ret= -1; goto ex; }
+ ret= iso_dir_get_children(dir_node, &iter);
+ if(ret<0) 
+   goto cannot_iter;
+ for(i= 0; i<*filec; i++) {
+   ret= iso_dir_iter_next(iter, &node);
+   if(ret!=1)
+ break;
+   name= (char *) iso_node_get_name(node);
+   (*filev)[i]= strdup(name);
+   if((*filev)[i]==NULL) {
+     for(j= 0; j<i; j++)
+       if((*filev)[j]!=NULL)
+         free((*filev)[j]);
+     free((char *) (*filev));
+     ret= -1; goto ex;
+   }
+ }
+ Sort_argv(*filec, *filev, 0);
+ ret= 1;
+ex:;
+ if(iter!=NULL)
+   iso_dir_iter_free(iter);
+ return(ret);
+}
+
+
+/* @param flag bit0= long format
+               bit1= do not print count of nodes
+               bit2= du format
+               bit3= print directories as themselves (ls -d)
+*/
+int Xorriso_ls_filev(struct XorrisO *xorriso, char *wd,
+                     int filec, char **filev, off_t boss_mem, int flag)
+{
+ int i, ret, was_error= 0, dfilec= 0, pass, passes;
+ IsoNode *node;
+ IsoImage *volume;
+ char sfe[5*SfileadrL], sfe2[5*SfileadrL], path[SfileadrL];
+ char link_target[SfileadrL], *rpt, **dfilev= NULL;
+ off_t size;
+ struct stat stbuf;
+
+ rpt= xorriso->result_line;
+
+ ret= Xorriso_get_volume(xorriso, &volume, 0);
+ if(ret<=0)
+   return(ret);
+
+ Sort_argv(filec, filev, 0);
+
+ /* Count valid nodes, warn of invalid ones */
+ for(i= 0; i<filec; i++) {
+   ret= Xorriso_make_abs_adr(xorriso, wd, filev[i], path, 1|4);
+   if(ret<=0) {
+     was_error++;
+ continue;
+   }
+   ret= iso_tree_path_to_node(volume, path, &node);
+   if(ret<=0) {
+     sprintf(xorriso->info_text, "Not found in ISO image: %s",
+             Text_shellsafe(path, sfe, 0));
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING", 0);
+     was_error++;
+ continue;
+   }
+ }
+
+ if((flag&8) && !(flag&(2|4))) {
+   sprintf(xorriso->info_text, "Valid ISO nodes found: %d\n", filec-was_error);
+   Xorriso_info(xorriso,1);
+   if(filec-was_error<=0)
+     return(!was_error);
+ }
+
+ passes= 1+!(flag&(4|8));
+ for(pass= 0; pass<passes; pass++)
+ for(i= 0; i<filec && !(xorriso->request_to_abort); i++) {
+   rpt[0]= 0;
+   ret= Xorriso_make_abs_adr(xorriso, wd, filev[i], path, 1|4);
+   if(ret<=0)
+ continue;
+   ret= Xorriso_fake_stbuf(xorriso, path, &stbuf, &node, 0);
+   if(ret<=0)
+ continue;
+   if(LIBISO_ISDIR(node)  && !(flag&(4|8))) {
+     if(pass==0)
+ continue;
+     if(filec>1) {
+       strcpy(xorriso->result_line, "\n");
+       Xorriso_result(xorriso,0);
+       sprintf(xorriso->result_line, "%s:\n", Text_shellsafe(filev[i], sfe,0));
+       Xorriso_result(xorriso,0);
+     }
+     ret= Xorriso_sorted_dir_i(xorriso, 
+                               (IsoDir *) node, &dfilec, &dfilev, boss_mem, 0);
+     if(ret<=0) {
+
+       /* >>> libisofs iterator loop and single item Xorriso_lsx_filev() */;
+
+     } else {
+       if(flag&1) {
+         sprintf(xorriso->result_line, "total %d\n", dfilec);
+         Xorriso_result(xorriso,0);
+       }
+       Xorriso_ls_filev(xorriso, path,
+                        dfilec, dfilev, boss_mem, (flag&1)|2|8);
+     }
+     if(dfilec>0)
+       Sfile_destroy_argv(&dfilec, &dfilev, 0);
+ continue;
+   } else
+     if(pass>0)
+ continue;
+   link_target[0]= 0;
+   if((flag&5)==1) { /* -ls_l */
+     ret= Xorriso_format_ls_l(xorriso, &stbuf, 0);
+     if(ret<=0)
+ continue;
+     if(LIBISO_ISLNK(node)) {
+       if(Sfile_str(link_target, (char *) iso_symlink_get_dest(
+                                                   (IsoSymlink *) node), 0)<=0)
+         link_target[0]= 0;
+     }
+   } else if(flag&4) { /* -du or -dus */
+     size= stbuf.st_size;
+     if(S_ISDIR(stbuf.st_mode)) {
+       ret= Xorriso_show_du_subs(xorriso, (IsoDir *) node,
+                                 path, filev[i], &size, boss_mem, flag&1);
+       if(ret<0)
+         return(-1);
+       if(ret==0)
+ continue;
+     }
+     sprintf(rpt, "%7.f ",(double) (size/1024));
+   }
+   if(link_target[0] && (flag&5)==1)
+     sprintf(xorriso->result_line+strlen(xorriso->result_line), "%s -> %s\n",
+             Text_shellsafe(filev[i], sfe, 0),
+             Text_shellsafe(link_target, sfe2, 0));
+   else
+     sprintf(xorriso->result_line+strlen(xorriso->result_line), "%s\n",
+             Text_shellsafe(filev[i], sfe, 0));
+   Xorriso_result(xorriso, 0);
+ }
+ return(!was_error);
+}
+
+
+/* This function needs less buffer memory than Xorriso_ls_filev() but cannot
+   perform structured pattern matching as done by Xorriso_expand_pattern()
+   for subsequent Xorriso_ls_filev().
+   @param flag bit0= long format
+               bit1= only check for directory existence
+               bit2= do not apply search pattern but accept any file
+*/
+int Xorriso_ls(struct XorrisO *xorriso, int flag)
+{
+ int ret, is_dir= 0, i, filec= 0, failed_at, no_sort= 0;
+ IsoNode *node, **node_array= NULL;
+ IsoDir *dir_node;
+ IsoImage *volume;
+ IsoDirIter *iter= NULL;
+ char sfe[5*SfileadrL], sfe2[5*SfileadrL], link_target[SfileadrL], *npt, *rpt;
+ struct stat stbuf;
+
+ rpt= xorriso->result_line;
+
+ ret= Xorriso_get_volume(xorriso, &volume, 0);
+ if(ret<=0)
+   return(ret);
+
+ ret= Xorriso_node_from_path(xorriso, volume, xorriso->wdi, &node, 0);
+ if(ret<=0)
+   goto wdi_is_not_a_dir;
+ if(LIBISO_ISDIR(node))
+   is_dir= 1;
+ if(!is_dir) {
+wdi_is_not_a_dir:;
+   sprintf(xorriso->info_text,
+           "Working directory path does not lead to a directory in ISO image"); 
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+   ret= 0; goto ex;
+ }
+ if(flag&2)
+   {ret= 1; goto ex;}
+
+ dir_node= (IsoDir *) node;
+ ret= iso_dir_get_children(dir_node, &iter);
+ if(ret<0) {
+cannot_create_iter:;
+   Xorriso_process_msg_queues(xorriso,0);
+   sprintf(xorriso->info_text, "Cannot obtain ISO directory iterator");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+   {ret= -1; goto ex;}
+ }
+ Xorriso_process_msg_queues(xorriso,0);
+
+ for(i= 0; iso_dir_iter_next(iter, &node) == 1; ) {
+   npt= (char *) iso_node_get_name(node);
+   if(!(flag&4)) {
+     ret= Xorriso_regexec(xorriso, npt, &failed_at, 0);
+     if(ret)
+ continue; /* no match */
+   }
+   filec++;
+ }
+ /* Reset iteration */
+ iso_dir_iter_free(iter);
+ iter= NULL;
+ Xorriso_process_msg_queues(xorriso,0);
+
+ sprintf(xorriso->info_text, "Valid ISO nodes found: %d\n", filec);
+ Xorriso_info(xorriso,1);
+
+ ret= Xorriso_sorted_node_array(xorriso, dir_node, &filec, &node_array, 0,
+                                flag&4);
+ if(ret<0)
+   goto ex;
+ if(ret==0) {
+   no_sort= 1;
+   ret= iso_dir_get_children(dir_node, &iter);
+   if(ret<0)
+     goto cannot_create_iter;
+ }
+
+ for(i= 0; i<filec && !(xorriso->request_to_abort); i++) {
+   if(no_sort) {
+     ret= iso_dir_iter_next(iter, &node);
+     if(ret!=1)
+ break;
+     npt= (char *) iso_node_get_name(node);
+     if(!(flag&4)) {
+       ret= Xorriso_regexec(xorriso, npt, &failed_at, 0);
+       if(ret)
+ continue; /* no match */
+     }
+   } else
+     node= node_array[i];
+
+   npt= (char *) iso_node_get_name(node);
+   link_target[0]= 0;
+   if(LIBISO_ISLNK(node)) {
+     if(Sfile_str(link_target, (char *) iso_symlink_get_dest(
+                                                   (IsoSymlink *) node), 0)<=0)
+       link_target[0]= 0;
+   }
+   rpt[0]= 0;
+   if(flag&1) {
+     ret= Xorriso_fake_stbuf(xorriso, "", &stbuf, &node, 1);
+     if(ret<=0)
+ continue;
+     ret= Xorriso_format_ls_l(xorriso, &stbuf, 0);
+     if(ret<=0)
+ continue;
+   }
+   if(link_target[0] && (flag&1))
+     sprintf(xorriso->result_line+strlen(xorriso->result_line), "%s -> %s\n",
+             Text_shellsafe(npt, sfe, 0), 
+             Text_shellsafe(link_target, sfe2, 0));
+   else
+     sprintf(xorriso->result_line+strlen(xorriso->result_line), "%s\n",
+             Text_shellsafe(npt, sfe, 0));
+   Xorriso_result(xorriso, 0);
+ }
+
+ ret= 1;
+ex:;
+ if(iter!=NULL)
+   iso_dir_iter_free(iter);
+ Xorriso_process_msg_queues(xorriso,0);
+ if(node_array!=NULL)
+   free((char *) node_array);
+ return(1);
+}
+
+
+int Xorriso_rename(struct XorrisO *xorriso, char *origin, char *dest, int flag)
+{
+ int ret, ol, dest_ret;
+ char sfe[5*SfileadrL], eff_dest[SfileadrL], dir_adr[SfileadrL], *cpt;
+ char *leafname, eff_origin[SfileadrL], sfe2[5*SfileadrL];
+ IsoImage *volume;
+ IsoDir *origin_dir, *dest_dir;
+ IsoNode *node;
+
+ ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, origin, eff_origin, 0);
+ if(ret<=0)
+   return(ret);
+ dest_ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, dest, eff_dest,1);
+ if(dest_ret<0)
+   return(dest_ret);
+ if(dest_ret==0) { /* obtain eff_dest address despite it does not exist */
+   ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, dest, eff_dest, 2);
+   if(ret<=0)
+     return(ret);
+ }
+
+ /* Prevent that destination is a subordinate of origin
+    (that would be a black hole plopping out of the universe) */
+ ol= strlen(eff_origin);
+ if(ol==0) {
+   sprintf(xorriso->info_text, "May not rename root directory");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+   return(0);
+ } else if(strcmp(eff_origin, eff_dest)==0) {
+   sprintf(xorriso->info_text, "Ignored attempt to rename %s to itself",
+           Text_shellsafe(eff_origin,sfe,0));
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING", 0);
+   return(0);
+ } else if(strncmp(eff_origin, eff_dest, ol)==0 &&
+           (eff_dest[ol]==0 || eff_dest[ol]=='/')) {
+   sprintf(xorriso->info_text,
+           "May not rename %s to its own sub address %s",
+           Text_shellsafe(eff_origin,sfe,0), Text_shellsafe(eff_dest,sfe2,0));
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+   return(0);
+ }
+
+ /* Check whether destination exists and may be not overwriteable */
+ if(dest_ret==2 && xorriso->do_overwrite!=1) {
+   sprintf(xorriso->info_text, "Renaming may not overwrite directory: %s",
+           Text_shellsafe(eff_dest, sfe, 0));
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+   return(0);
+ } else if (dest_ret==1 && !xorriso->do_overwrite) {
+   sprintf(xorriso->info_text, "Renaming may not overwite: %s",
+           Text_shellsafe(eff_dest, sfe, 0));
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+   return(0);
+ } else if(dest_ret>0) {
+   ret= Xorriso_rmi(xorriso, NULL, eff_dest, 1|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 */
+ strcpy(dir_adr, eff_dest);
+ cpt= strrchr(dir_adr, '/');
+ if(cpt==NULL)
+   cpt= dir_adr+strlen(dir_adr);
+ *cpt= 0;
+ if(dir_adr[0]!=0) {
+   ret= Xorriso_graft_in(xorriso, NULL, dir_adr, 1);
+   if(ret<=0)
+     return(ret);
+ }
+
+ /* Move node */
+ ret= Xorriso_get_volume(xorriso, &volume, 0);
+ if(ret<=0)
+   return(ret);
+ ret= iso_tree_path_to_node(volume, dir_adr, (IsoNode **) &dest_dir);
+ if(ret<=0)
+   dest_dir= NULL;
+ strcpy(dir_adr, eff_origin);
+ cpt= strrchr(dir_adr, '/');
+ if(cpt==NULL)
+   cpt= dir_adr+strlen(dir_adr);
+ *cpt= 0;
+ ret= iso_tree_path_to_node(volume, dir_adr, (IsoNode **) &origin_dir);
+ if(ret<=0)
+   origin_dir= NULL;
+ ret= iso_tree_path_to_node(volume, eff_origin, &node);
+ if(ret<=0)
+   node= NULL;
+ if(dest_dir==NULL || origin_dir==NULL || node==NULL) {
+   Xorriso_process_msg_queues(xorriso,0);
+   sprintf(xorriso->info_text,
+           "Internal error on rename: confirmed node turns out as NULL");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+   return(-1);
+ }
+ ret= iso_node_take(node);
+ if(ret<0) {
+   Xorriso_process_msg_queues(xorriso,0);
+   sprintf(xorriso->info_text,
+           "Internal error on rename: failed to take node");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+   return(-1);
+ }
+ ret= iso_dir_add_node(dest_dir, node, 0);
+ if(ret<0) {
+   Xorriso_process_msg_queues(xorriso,0);
+   sprintf(xorriso->info_text,
+           "Internal error on rename: failed to insert node");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+   return(-1);
+ }
+ leafname= strrchr(eff_dest, '/');
+ if(leafname==NULL)
+   leafname= eff_dest;
+ else
+   leafname++;
+ ret= iso_node_set_name(node, leafname);
+ if(ret<0) {
+   Xorriso_process_msg_queues(xorriso,0);
+   sprintf(xorriso->info_text, "Internal error on rename: failed to set name");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+   return(-1);
+ }
+ Xorriso_process_msg_queues(xorriso,0);
+ return(1);
+}
+
+
+/* @param flag bit0= do not produce info message on success
+   @return 1=success,
+           0=was already directory, -1=was other type, -2=other error
+*/
+int Xorriso_mkdir(struct XorrisO *xorriso, char *path, int flag)
+{
+ int ret;
+ char eff_path[SfileadrL], sfe[5*SfileadrL];
+
+ ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, path, eff_path, 1);
+ if(ret<0)
+   return(-2);
+ if(ret>0) {
+   sprintf(xorriso->info_text,"-mkdir: Address already existing %s",
+          Text_shellsafe(eff_path, sfe, 0));
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0,
+                       (ret==2 ? "WARNING" : "SORRY"), 0);
+   return(-1+(ret==2));
+ }
+ ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, path, eff_path, 2);
+ if(ret<0)
+   return(-2);
+ ret= Xorriso_graft_in(xorriso, NULL, eff_path, 1);
+ if(ret<=0)
+   return(-2);
+ if(!(flag&1)) {
+   sprintf(xorriso->info_text, "Created directory in ISO image: %s\n",
+           Text_shellsafe(eff_path,sfe,0));
+   Xorriso_info(xorriso, 0);
+ }
+ return(1);
+}
+
+
+/* @param flag bit0= count results rather than storing them
+               bit1= this is a recursion
+               bit2= prepend wd (automatically done if wd[0]!=0)
+*/
+int Xorriso_obtain_pattern_files_i(
+       struct XorrisO *xorriso, char *wd, IsoDir *dir,
+       int *filec, char **filev, int count_limit, off_t *mem,
+       int *dive_count, int flag)
+{
+ int ret, failed_at;
+ IsoDirIter *iter= NULL;
+ IsoNode *node;
+ char *name;
+
+#ifdef Xorriso_fat_local_meM
+ char adr[SfileadrL];
+#else /* Xorriso_fat_local_meM */
+ char *adr= NULL;
+
+ adr= malloc(SfileadrL);
+ if(adr==NULL) {
+   Xorriso_no_malloc_memory(xorriso, &adr, 0);
+   {ret= -1; goto ex;}
+ }
+#endif /* ! Xorriso_fat_local_meM */
+
+
+ if(!(flag&2))
+   *dive_count= 0;
+ else
+   (*dive_count)++;
+ ret= Xorriso_check_for_root_pattern(xorriso, filec, filev, count_limit,
+                                     mem, (flag&1)|2);
+ if(ret!=2)
+   goto ex;
+
+ ret= iso_dir_get_children(dir, &iter);
+ if(ret<0) {
+   Xorriso_process_msg_queues(xorriso,0);
+   sprintf(xorriso->info_text, "Cannot obtain ISO directory iterator");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+   {ret= -1; goto ex;}
+ }
+ while(iso_dir_iter_next(iter, &node) == 1) {
+   name= (char *) iso_node_get_name(node);
+   ret= Xorriso_make_abs_adr(xorriso, wd, name, adr, flag&4);
+   if(ret<=0)
+     goto ex;
+   ret= Xorriso_regexec(xorriso, adr, &failed_at, 1);
+   if(ret) { /* no match */
+     if(failed_at <= *dive_count) /* no hope for a match */
+ continue;
+
+     if(!LIBISO_ISDIR(node)) {
+
+       /* >>> How to deal with softlinks ? */
+
+ continue;
+     }
+     /* dive deeper */
+     ret= Xorriso_obtain_pattern_files_i(
+                          xorriso, adr, (IsoDir *) node,
+                          filec, filev, count_limit, mem, dive_count, flag|2);
+     if(ret<=0)
+       goto ex;
+   } else {
+     ret= Xorriso_register_matched_adr(xorriso, adr, count_limit,
+                                       filec, filev, mem, (flag&1)|2);
+     if(ret<=0)
+       goto ex;
+   }
+ } 
+ ret= 1;
+ex:;
+
+#ifndef Xorriso_fat_local_meM
+ if(adr!=NULL)
+   free(adr);
+#endif /* ! Xorriso_fat_local_meM */
+
+ if(flag&2)
+   (*dive_count)--;
+ return(ret);
+}
+
+
+/* @param flag bit0= a match count !=1 is a SORRY event
+               bit1= with bit0 tolerate 0 matches if pattern is a constant
+*/
+int Xorriso_expand_pattern(struct XorrisO *xorriso,
+                           int num_patterns, char **patterns, int extra_filec,
+                           int *filec, char ***filev, off_t *mem, int flag)
+{
+ int ret, count= 0, abs_adr= 0, i, was_count, was_filec;
+ int nonconst_mismatches= 0, dive_count= 0;
+ char sfe[5*SfileadrL];
+ IsoImage *volume;
+ IsoDir *dir= NULL, *root_dir;
+
+ *filec= 0;
+ *filev= NULL;
+
+ xorriso->search_mode= 3;
+ xorriso->structured_search= 1;
+
+ ret= Xorriso_get_volume(xorriso, &volume, 0);
+ if(ret<=0)
+   return(ret);
+ root_dir= iso_image_get_root(volume);
+ if(root_dir==NULL) {
+   Xorriso_process_msg_queues(xorriso,0);
+   sprintf(xorriso->info_text,
+           "While expanding pattern : Cannot obtain root node of ISO image");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+   ret= -1; goto ex;
+ }
+
+ for(i= 0; i<num_patterns; i++) {
+   ret=  Xorriso_prepare_expansion_pattern(xorriso, patterns[i], 0);
+   if(ret<=0)
+     return(ret);
+   if(ret==2)
+     abs_adr= 4;
+   if(patterns[i][0]=='/' || abs_adr) {
+     dir= root_dir;
+     abs_adr= 4;
+   } else {
+     /* This is done so late to allow the following:
+        It is not an error if xorriso->wdi does not exist yet, but one may
+        not use it as base for relative address searches.
+     */
+     ret= iso_tree_path_to_node(volume, xorriso->wdi, (IsoNode **) &dir);
+     if(ret<0) {
+       Xorriso_process_msg_queues(xorriso,0);
+       sprintf(xorriso->info_text,
+  "While expanding pattern %s : Working directory does not exist in ISO image",
+               Text_shellsafe(patterns[i], sfe, 0));
+       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+       ret= 0; goto ex;
+     }
+     if(!LIBISO_ISDIR((IsoNode *) dir)) {
+       sprintf(xorriso->info_text,
+           "Working directory path does not lead to a directory in ISO image");
+       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+       ret= 0; goto ex;
+     }
+   }
+
+   /* count the matches */
+   was_count= count;
+   ret= Xorriso_obtain_pattern_files_i(xorriso, "", dir, &count, NULL, 0,
+                                       mem, &dive_count, 1 | abs_adr);
+   if(ret<=0)
+     goto ex;
+   if(was_count==count && strcmp(patterns[i],"*")!=0 && (flag&3)!=1) {
+     count++;
+     Xorriso_eval_nonmatch(xorriso, patterns[i], &nonconst_mismatches, mem, 0);
+   }
+ }
+
+ ret= Xorriso_check_matchcount(xorriso, count, nonconst_mismatches,
+                               num_patterns, patterns, flag&1);
+ if(ret<=0)
+   goto ex;
+ count+= extra_filec;
+ mem+= extra_filec*sizeof(char *);
+ if(count<=0)
+   {ret= 0; goto ex;}
+ ret= Xorriso_alloc_pattern_mem(xorriso, *mem, count, filev, 0);
+ if(ret<=0)
+   goto ex;
+ /* now store addresses */
+ for(i= 0; i<num_patterns; i++) {
+   ret=  Xorriso_prepare_expansion_pattern(xorriso, patterns[i], 0);
+   if(ret<=0)
+     return(ret);
+   if(ret==2)
+     abs_adr= 4;
+
+   was_filec= *filec;
+   ret= Xorriso_obtain_pattern_files_i(xorriso, "", dir, filec, *filev, count,
+                                       mem, &dive_count, abs_adr);
+   if(ret<=0)
+     goto ex;
+   if(was_filec == *filec && strcmp(patterns[i],"*")!=0) {
+     (*filev)[*filec]= strdup(patterns[i]);
+     if((*filev)[*filec]==NULL) {
+       (*mem)= strlen(patterns[i])+1;
+       Xorriso_no_pattern_memory(xorriso, *mem, 0);
+       ret= -1; goto ex;
+     }
+     (*filec)++;
+   } 
+ }
+ ret= 1;
+ex:;
+ if(ret<=0) {
+   if(filev!=NULL)
+     Sfile_destroy_argv(&count, filev, 0);
+   *filec= 0;
+ }
+ return(ret);
+}
+
+
+int Xorriso_set_st_mode(struct XorrisO *xorriso, char *in_path,
+                        mode_t mode_and, mode_t mode_or, int flag)
+{
+ mode_t mode= 0;
+ int ret;
+ IsoNode *node;
+ char sfe[5*SfileadrL], path[SfileadrL];
+
+ ret= Xorriso_get_node_by_path(xorriso, in_path, path, &node, 0);
+ if(ret<=0)
+   return(ret);
+ mode= iso_node_get_permissions(node);
+ mode= (mode & mode_and) | mode_or;
+ iso_node_set_permissions(node, mode);
+ iso_node_set_ctime(node, time(NULL));
+ sprintf(xorriso->info_text,"Permissions now: %-5.5o  %s",
+         mode, Text_shellsafe(path, sfe, 0));
+ Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
+ xorriso->volset_change_pending= 1;
+ Xorriso_process_msg_queues(xorriso,0);
+ return(1);
+}
+
+
+int Xorriso_set_uid(struct XorrisO *xorriso, char *in_path, uid_t uid,
+                    int flag)
+{
+ int ret;
+ IsoNode *node;
+
+ ret= Xorriso_get_node_by_path(xorriso, in_path, NULL, &node, 0);
+ if(ret<=0)
+   return(ret);
+ iso_node_set_uid(node, uid);
+ iso_node_set_ctime(node, time(NULL));
+ xorriso->volset_change_pending= 1;
+ Xorriso_process_msg_queues(xorriso,0);
+ return(1);
+}
+
+
+int Xorriso_set_gid(struct XorrisO *xorriso, char *in_path, gid_t gid,
+                    int flag)
+{
+ int ret;
+ IsoNode *node;
+
+ ret= Xorriso_get_node_by_path(xorriso, in_path, NULL, &node, 0);
+ if(ret<=0)
+   return(ret);
+ iso_node_set_gid(node, gid);
+ iso_node_set_ctime(node, time(NULL));
+ xorriso->volset_change_pending= 1;
+ Xorriso_process_msg_queues(xorriso,0);
+ return(1);
+}
+
+
+/* @parm flag  bit0= atime, bit1= ctime, bit2= mtime, bit8=no auto ctime */
+int Xorriso_set_time(struct XorrisO *xorriso, char *in_path, time_t t,
+                    int flag)
+{
+ int ret;
+ IsoNode *node;
+
+ ret= Xorriso_get_node_by_path(xorriso, in_path, NULL, &node, 0);
+ if(ret<=0)
+   return(ret);
+ if(flag&1)
+   iso_node_set_atime(node, t);
+ if(flag&2)
+   iso_node_set_ctime(node, t);
+ if(flag&4)
+   iso_node_set_mtime(node, t);
+ if(!(flag&(2|256)))
+   iso_node_set_ctime(node, time(NULL));
+ xorriso->volset_change_pending= 1;
+ Xorriso_process_msg_queues(xorriso,0);
+ return(1);
+}
+
+
+int Xorriso_findi_action(struct XorrisO *xorriso, struct FindjoB *job,
+                         char *abs_path, char *show_path, 
+                         IsoNode *node, int depth, int flag)
+{
+ int ret, type, action= 0;
+ uid_t user= 0;
+ gid_t group= 0;
+ time_t date= 0;
+ mode_t mode_or= 0, mode_and= ~1;
+ char *target, sfe[5*SfileadrL];
+ struct FindjoB *subjob;
+ struct stat dir_stbuf;
+
+ action= Findjob_get_action_parms(job, &target, &user, &group,
+                                &mode_and, &mode_or, &type, &date, &subjob, 0);
+ if(action<0)
+   action= 0;
+
+ if(action==1) {
+   /* >>> rm */;
+ } else if(action==2) {
+
+   /* >>> rm_r */;
+
+ } else if(action==3) {
+
+   /* >>> mv target */;
+
+ } else if(action==4) { /* chown */
+   ret= Xorriso_set_uid(xorriso, abs_path, user, 0);
+ } else if(action==5) { /* chgrp */
+   ret= Xorriso_set_gid(xorriso, abs_path, group, 0);
+ } else if(action==6) { /* chmod */
+   ret= Xorriso_set_st_mode(xorriso, abs_path, mode_and, mode_or, 0);
+ } else if(action==7) { /* alter_date */
+   ret= Xorriso_set_time(xorriso, abs_path, date, type&7);
+ } else if(action==8) { /* lsdl */
+   ret= Xorriso_ls_filev(xorriso, "", 1, &abs_path, (off_t) 0, 1|2|8);
+ } else if(action>=9 && action<=13) { /* actions which have own findjobs */
+   Findjob_set_start_path(subjob, abs_path, 0);
+   ret= Xorriso_findi(xorriso, subjob, NULL, abs_path, &dir_stbuf, depth, 0);
+ } else {
+   sprintf(xorriso->result_line, "%s\n", Text_shellsafe(show_path, sfe, 0));
+   Xorriso_result(xorriso, 0);
+   ret= 1;
+ }
+ return(ret);
+}
+
+
+int Xorriso_findi(struct XorrisO *xorriso, struct FindjoB *job,
+                  void *dir_node_generic, char *dir_path,
+                  struct stat *dir_stbuf, int depth, int flag)
+{
+ int ret, action= 0;
+ IsoDirIter *iter= NULL;
+ IsoDir *dir_node;
+ IsoNode *node;
+ IsoImage *volume;
+ struct stat stbuf;
+ char *name;
+#ifdef Xorriso_fat_local_meM
+ char path[SfileadrL], sfe[5*SfileadrL];
+#else /* Xorriso_fat_local_meM */
+ char *path= NULL, *sfe= NULL, *abs_path= NULL;
+
+ sfe= malloc(5*SfileadrL);
+ path= malloc(SfileadrL);
+ abs_path= malloc(SfileadrL);
+ if(sfe==NULL || path==NULL || abs_path==NULL) {
+   Xorriso_no_malloc_memory(xorriso, &sfe, 0);
+   {ret= -1; goto ex;}
+ }
+#endif /* ! Xorriso_fat_local_meM */
+
+ action= Findjob_get_action(job, 0);
+ if(action<0)
+   action= 0;
+
+ dir_node= (IsoDir *) dir_node_generic;
+ if(dir_node==NULL) {
+   ret= Xorriso_get_volume(xorriso, &volume, 0);
+   if(ret<=0)
+     {ret= -1; goto ex;}
+   ret= Xorriso_make_abs_adr(xorriso, xorriso->wdi, dir_path, path, 1|2|4);
+   if(ret<=0)
+     goto ex;
+   ret= iso_tree_path_to_node(volume, path, (IsoNode **) &dir_node);
+   if(ret<=0)
+     {ret= 0; goto ex;}
+   ret= Xorriso_fake_stbuf(xorriso, "", dir_stbuf,
+                           (IsoNode **) &dir_node, 1);
+   if(ret<=0)
+     goto ex;
+
+   name= strrchr(dir_path, '/');
+   if(name==NULL)
+     name= dir_path;
+   else
+     name++;
+   ret= Findjob_test(job, name, NULL, dir_stbuf, depth, 0);
+   if(ret<0)
+     goto ex;
+   if(ret>0) {
+     ret= Xorriso_findi_action(xorriso, job, path, dir_path, 
+                               (IsoNode *) dir_node, depth, 0);
+     if(ret<=0)
+       goto ex;
+   }
+ }
+ if(!LIBISO_ISDIR((IsoNode *) dir_node))
+   {ret= 2; goto ex;}
+
+ ret= iso_dir_get_children(dir_node, &iter);
+ if(ret<0) {
+   Xorriso_process_msg_queues(xorriso,0);
+   sprintf(xorriso->info_text, "Cannot obtain ISO directory iterator");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+   {ret= -1; goto ex;}
+ }
+ while(iso_dir_iter_next(iter, &node) == 1 && !xorriso->request_to_abort) {
+   name= (char *) iso_node_get_name(node);
+   ret= Xorriso_make_abs_adr(xorriso, dir_path, name, path, 4);
+   if(ret<=0)
+     goto ex;
+   ret= Xorriso_fake_stbuf(xorriso, "", &stbuf, &node, 1);
+   if(ret<0)
+     goto ex;
+   if(ret==0)
+ continue;
+
+   ret= Findjob_test(job, name, dir_stbuf, &stbuf, depth, 0);
+   if(ret<0)
+     goto ex;
+   if(ret>0) {
+
+#ifdef NIX
+     sprintf(xorriso->result_line, "%s\n", Text_shellsafe(path, sfe, 0));
+     Xorriso_result(xorriso, 0);
+#else
+     ret= Xorriso_make_abs_adr(xorriso, xorriso->wdi, path, abs_path, 1|4);
+     if(ret<=0)
+       goto ex;
+     ret= Xorriso_findi_action(xorriso, job, abs_path, path, node, depth, 0);
+     if(ret<=0) {
+       if(Xorriso_eval_problem_status(xorriso, ret, 1|2)<0)
+         goto ex;
+     }
+#endif /* ! NIX */
+
+   }
+
+   if(S_ISDIR(stbuf.st_mode)) {
+     ret= Xorriso_findi(xorriso, job, (void *) node, path,
+                        &stbuf, depth+1, flag);
+     if(ret<0)
+       goto ex;
+   }
+ }
+
+ ret= 1;
+ex:;
+
+#ifndef Xorriso_fat_local_meM
+ if(sfe!=NULL)
+   free(sfe);
+ if(path!=NULL)
+   free(path);
+ if(abs_path!=NULL)
+   free(abs_path);
+#endif /* ! Xorriso_fat_local_meM */
+
+ Xorriso_process_msg_queues(xorriso,0);
+ if(iter!=NULL)
+   iso_dir_iter_free(iter);
+ return(ret);
+}
+
+
+int Xorriso_set_volid(struct XorrisO *xorriso, char *volid, int flag)
+{
+ int ret;
+ IsoImage *volume;
+
+ ret= Xorriso_get_volume(xorriso, &volume, 0);
+ if(ret<=0)
+   return(ret);
+ iso_image_set_volume_id(volume, volid);
+ Xorriso_process_msg_queues(xorriso,0);
+ return(1);
+}
+
+
diff --git a/libisoburn/trunk/test/ng_xorrisoburn.h b/libisoburn/trunk/test/ng_xorrisoburn.h
new file mode 100644
index 00000000..18a8c3d5
--- /dev/null
+++ b/libisoburn/trunk/test/ng_xorrisoburn.h
@@ -0,0 +1,133 @@
+
+
+/* Adapter to libisoburn, libisofs and libburn for xorriso,
+   a command line oriented batch and dialog tool which creates, loads,
+   manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2008 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2.
+
+   This file contains the inner isofs- and burn-library interface of xorriso.
+*/
+
+#ifndef Xorrisoburn_includeD
+#define Xorrisoburn_includeD yes
+
+struct XorrisO;
+struct FindjoB;
+
+int Xorriso_startup_libraries(struct XorrisO *xorriso, int flag);
+
+int Xorriso_create_empty_iso(struct XorrisO *xorriso, int flag);
+
+/* @param flag bit0=aquire as isoburn input drive
+               bit1=aquire as libburn output drive (as isoburn drive if bit0)
+   @return <=0 failure , 1=success , 2=neither readable or writeable
+*/
+int Xorriso_aquire_drive(struct XorrisO *xorriso, char *adr, int flag);
+
+int Xorriso_give_up_drive(struct XorrisO *xorriso, int flag);
+
+int Xorriso_write_session(struct XorrisO *xorriso, 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
+*/
+int Xorriso_graft_in(struct XorrisO *xorriso, char *disk_path, char *img_path,
+                     int flag);
+
+int Xorriso__text_to_sev(char *severity_name, int *severity_number,int flag);
+
+/* @param flag bit0=report about output drive 
+               bit1=short report form
+*/
+int Xorriso_toc(struct XorrisO *xorriso, int flag);
+
+int Xorriso_show_devices(struct XorrisO *xorriso, int flag);
+
+int Xorriso_tell_media_space(struct XorrisO *xorriso,
+                             int *media_space, int *free_space, int flag);
+
+int Xorriso_blank_media(struct XorrisO *xorriso, int flag);
+
+int Xorriso_format_media(struct XorrisO *xorriso, int flag);
+
+/* @param boss_iter  Opaque internal handle. Use NULL outside xorrisoburn.c :
+               If not NULL then this is an iterator suitable for
+               iso_dir_iter_remove() which is then to be used instead
+               of iso_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, void *boss_iter,
+                char *path, int flag);
+
+/* @param flag bit0= long format
+               bit1= do not print count of nodes
+               bit2= du format
+               bit3= print directories as themselves (ls -d)
+*/
+int Xorriso_ls_filev(struct XorrisO *xorriso, char *wd, 
+                     int filec, char **filev, off_t boss_mem, int flag);
+
+/* This function needs less buffer memory than Xorriso_ls_filev() but cannot
+   perform structured pattern matching.
+   @param flag bit0= long format
+               bit1= only check for directory existence
+               bit2= do not apply search pattern but accept any file
+*/
+int Xorriso_ls(struct XorrisO *xorriso, int flag);
+
+/* @param wd        Path to prepend in case img_path is not absolute
+   @param img_path  Absolute or relative path to be normalized
+   @param eff_path  returns resulting effective path.
+                    Must provide at least SfileadrL bytes of storage.
+   @param flag bit0= do not produce problem events (unless faulty path format)
+               bit1= work purely literally, do not use libisofs
+               bit2= (with bit1) this is an address in the disk world
+   @return -1 = faulty path format, 0 = not found ,
+            1 = found simple node , 2 = found directory
+*/
+int Xorriso_normalize_img_path(struct XorrisO *xorriso, char *wd,
+                               char *img_path, char eff_path[], int flag);
+
+int Xorriso_rename(struct XorrisO *xorriso, char *origin, char *dest,int flag);
+
+/* @param flag bit0= do not produce info message on success
+   @return 1=success, 0=was already directory, -1=was other type, -2=bad path
+*/
+int Xorriso_mkdir(struct XorrisO *xorriso, char *img_path, int flag);
+
+/* @param flag bit0= a match count !=1 is a SORRY event */
+int Xorriso_expand_pattern(struct XorrisO *xorriso,
+                           int num_patterns, char **patterns, int extra_filec,
+                           int *filec, char ***filev, off_t *mem, int flag);
+
+int Xorriso_set_st_mode(struct XorrisO *xorriso, char *path,
+                        mode_t mode_and, mode_t mode_or, int flag);
+
+int Xorriso_set_uid(struct XorrisO *xorriso, char *in_path, uid_t uid,
+                    int flag);
+
+int Xorriso_set_gid(struct XorrisO *xorriso, char *in_path, gid_t gid,
+                    int flag);
+
+/* @parm flag  bit0= atime, bit1= ctime, bit2= mtime, bit8=no auto ctime */
+int Xorriso_set_time(struct XorrisO *xorriso, char *in_path, time_t t,
+                    int flag);
+
+int Xorriso_findi(struct XorrisO *xorriso, struct FindjoB *job,
+                  void *dir_node_generic, char *dir_path,
+                  struct stat *dir_stbuf, int depth, int flag);
+
+int Xorriso_set_volid(struct XorrisO *xorriso, char *volid, int flag);
+
+#endif /* Xorrisoburn_includeD */
+
diff --git a/libisoburn/trunk/test/xorriso_timestamp.h b/libisoburn/trunk/test/xorriso_timestamp.h
index cedbdab9..714096b3 100644
--- a/libisoburn/trunk/test/xorriso_timestamp.h
+++ b/libisoburn/trunk/test/xorriso_timestamp.h
@@ -1 +1 @@
-#define Xorriso_timestamP "2008.01.09.175418"
+#define Xorriso_timestamP "2008.01.10.114451"