[Bug-xorriso] Fwd: Fixes and improvements for libisoburn

[Eliska Svobodova]

Hi,

glad about the applied patches. To the rest:

On Wed, Aug 14, 2019 at 7:31 PM Thomas Schmitt <address@hidden> wrote:

Hi,

please brace for lengthy text. :)

--------------------------------------------------------------------------

Eliska Svobodova wrote:
> 1) Bitwise operations - shift 1 << 31 is used on multiple places through
> xorriso, which is an undefined operation; fix: make 1 unsigned:  1u << 31

Looks good to me. Applied as
  https://dev.lovelyhq.com/libburnia/libisoburn/commit/fb61be034f3ab95c48e3de5855599c8acf17fa13

--------------------------------------------------------------------------

> 2) Absolute value - you are using abs() to calculate the absolute value of
> r1count and r2count, which are of type long int, so it could be truncated;
> fix: use labs()

They are off_t rather than long int. The whole ado with (double) is
because there is no printf formatter for off_t and the number of "long"s
is pure guesswork on source code level.

So i decided for a (double) based solution, avoiding fabs(3) because
there is no dependency on libm yet.
  https://dev.lovelyhq.com/libburnia/libisoburn/commit/fb61be034f3ab95c48e3de5855599c8acf17fa13

I didn't realize it. Pavel Cahyna suggested you use intmax_t in place of double because printf has a conversion for it and it would be better to stay in integer types.

--------------------------------------------------------------------------

> 3) Dereference of NULL pointers - in xorriso/opts_d_h.c, first_job pointer
> can be in case of failure of Findjob_new a NULL pointer, which is
> dereferenced in ex:

Indeed.


> in xorriso/opts_i_o.c,
> also descr can be NULL, if end_idx <= 0 and execution goes straight to ex:

Yes. But then Xorriso_opt_args() is called with flag bit 8 for disposal
of optv. descr (function parameter "argv") is not dereferenced in this case.

But argv is used for a computation which makes sense only if it is a
valid memory address. To perform it with argv == NULL invites for
misinterpretation, although i deem it unlikely that a malloc() heap
pointer is near enough to 0 to step into that puddle.

So i dediced to add a test for (argv == NUL) in Xorriso_opt_args() in
order to avoid the unlikely mistake which would cause a memory leak.
opts_i_o.c stays as is.

I missed the flag, sorry. 

> in xorriso/read_run.c,
> when catcontent is NULL, NULL is put in buf_pt and is passed to write()
> function

This is a tricky situation. A file shall be copied from ISO to hard disk.
Its type is El Torito Boot Catalog which will be mapped to regular file.
What to do if libisofs does not deliver catalog content ?
Create no file ? Create an empty file ?

Currently, the NULL pointer is supposed to be not used in the further
course of the function, because if iso_image_get_bootcat() returns no
catcontent, then catsize is supposed to be 0.
--------------------------
<libisofs/libisofs.h> has:
  * @param content
  *      Will return either NULL or an allocated memory buffer with the
  *      content bytes of the boot catalog.
  *      Dispose it by free() when no longer needed.
  * @param size
  *      Will return the number of bytes in content.
  * @return
  *      1 if reply is valid, 0 if not boot catalog was loaded, < 0 on error.
  *
  * @since 1.1.2
  */
 int iso_image_get_bootcat(IsoImage *image, IsoBoot **catnode, uint32_t *lba,
                           char **content, off_t *size);
---------------------
The implementation in libisofs is a bit complicated. It looks like no
size > 0 can be recorded if content is NULL.
Nevertheless i made sure in iso_image_get_bootcat() that if content is
NULL then size is forced to 0.
  https://dev.lovelyhq.com/libburnia/libisofs/commit/fe98b35afb2f16b4605d15c523c70541997a72de

That seems clearer to me.

So the loop while(todo>0) in libisoburn gets skipped and an empty file
emerges. For now i leave this as is.

Changes applied as
  https://dev.lovelyhq.com/libburnia/libisoburn/commit/e17db6aa3e80feaed546ad8ebee7a46b01b5d2e1

--------------------------------------------------------------------------

> 4) Missing initialization - in xorriso/iso_manip.c, own_link_stack isn't
> initialized,

Applied as
  https://dev.lovelyhq.com/libburnia/libisoburn/commit/b35629170077e591af9d32b1e2e95ce5c08160e0

--------------------------------------------------------------------------

> And we have some improvements to make the code safer and cleaner:
>
> 1) Resource leaks - in xorriso/drive_mgt.c, dynamically allocated disc isn't
> freed in case that goto ex; is used; fix: move freeing after ex:

Indeed. Just for completeness i also move the processing of possible
library messages after ex, too.


>                            - in xorriso/emulators.c and
> xorriso/opts_i_o.c,arguments should be freed by Sfile_destroy_argv function

I wonder which tool reported this with what messages.
There is a fourth occasion of the Xorriso_read_lines() loop which is not
in your patch: opts_p_z.c, Xorriso_option_path_list().

Two of the found occasions are false positives. Only those where
Xorriso_read_lines(...,2) is called conditionally are prone to memory
leaks in case of goto ex. I.e. the two in opts_i_o.c are ok by
always calling Xorriso_read_lines(...,2) after the loop.

While analysing the possibilities for a memory leak in
Xorriso_option_path_list() i found a potential leak which happens when
the argv pointer array can be allocated but then its content string cannot.
See the text_io.c part of the changeset.
  https://dev.lovelyhq.com/libburnia/libisoburn/commit/3eba8cc9210639caa830ed0f1793592bf60b66bf

So how come that the analizer reported two false positives and missed
one true positive ?
I mainly ask because it might be that the reported positives are not
actually about the aspects which we inspected, but about something else.

All reports about resource leaks are from Coverity. Here they are:

Error: RESOURCE_LEAK (CWE-772): [#def73]
libisoburn-1.4.8/xorriso/drive_mgt.c:1208: alloc_fn: Storage is returned from allocation function "isoburn_toc_drive_get_disc".
libisoburn-1.4.8/xorriso/drive_mgt.c:1208: var_assign: Assigning: "disc" = storage returned from "isoburn_toc_drive_get_disc(drive)".
libisoburn-1.4.8/xorriso/drive_mgt.c:1274: noescape: Resource "disc" is not freed or pointed-to in "isoburn_toc_disc_get_sessions".
libisoburn-1.4.8/xorriso/drive_mgt.c:1275: noescape: Resource "disc" is not freed or pointed-to in "isoburn_toc_disc_get_incmpl_sess".
libisoburn-1.4.8/xorriso/drive_mgt.c:1418: leaked_storage: Variable "disc" going out of scope leaks the storage it points to.
# 1416|    ret= 1;
# 1417|   ex:;
# 1418|->  return(ret);
# 1419|   }
# 1420|  

Error: RESOURCE_LEAK (CWE-772): [#def79]
libisoburn-1.4.8/xorriso/emulators.c:1033: alloc_arg: "Xorriso_read_lines" allocates memory that is stored into "argv".
libisoburn-1.4.8/xorriso/emulators.c:1038: leaked_storage: Variable "argv" going out of scope leaks the storage it points to.
# 1036|    if(ret<=0)
# 1037|      return(ret);
# 1038|->  return(!was_failure);
# 1039|   }
# 1040|  

Error: RESOURCE_LEAK (CWE-772): [#def187]
libisoburn-1.4.8/xorriso/opts_i_o.c:1431: alloc_arg: "Xorriso_read_lines" allocates memory that is stored into "argv".
libisoburn-1.4.8/xorriso/opts_i_o.c:1446: leaked_storage: Variable "argv" going out of scope leaks the storage it points to.
# 1444|    strcat(xorriso->info_text, "\n");
# 1445|    Xorriso_info(xorriso,0);
# 1446|->  return(ret);
# 1447|   }
# 1448|  

Error: RESOURCE_LEAK (CWE-772): [#def189]
libisoburn-1.4.8/xorriso/opts_i_o.c:1695: alloc_arg: "Xorriso_read_lines" allocates memory that is stored into "linev".
libisoburn-1.4.8/xorriso/opts_i_o.c:1711: leaked_storage: Variable "linev" going out of scope leaks the storage it points to.
# 1709|    if(ret!=1)
# 1710|      return(ret);
# 1711|->  return(!was_failure);
# 1712|   }
# 1713| 

I couldn't find the reason, why it missed the true-positive. I would guess that it has something to do with flags, analyzers I used, had real problems with them because they weren't able to determine when and what flags will be raised.

--------------------------------------------------------------------------

> 2) Overflow in strcpy - in multiple files, there are strcpys which copy
> dynamically allocated strings into static strings, it would be better to use
> strncpy to avoid overflow

This would put a cap on potential memory errors. But an overflow of
a string is also a problem with program logics. So a blanket solution is
not to expect.

I realize that but I don't know the program sufficiently to handle logics after error occurs...

In particular:

> --- a/xorriso/drive_mgt.c
> @@ -910,7 +910,8 @@ int Xorriso_toc_line(struct XorrisO *xorriso, int flag)
> - strcpy(xorriso->info_text, xorriso->result_line);

xorriso->result_line is of the same size as xorriso->info_text.
If any oversized text made it into result_line, then the program is
doomed already.

No need for action.


> --- a/xorriso/iso_tree.c
> @@ -865,7 +865,8 @@ int Xorriso_getfattr(struct XorrisO *xorriso,
> -       strcpy(xorriso->result_line, bsl);

(The patch does not address the subsequent sprintf() which would overflow
 if all available space was filled by the strncpy().)

The result size is pre-checked by

     if(strlen(names[i]) + value_lengths[i] >= SfileadrL) {
       sprintf(xorriso->result_line, "# oversized: name %d , value %d bytes\n",
               (int) strlen(names[i]), (int) value_lengths[i]);

Function Sfile_bsl_encoder() cannot inflate the text size by a factor
of 10 to surpass the size of xorriso->result_line.

No need for action.


> --- a/xorriso/misc_funct.c
> @@ -521,7 +521,8 @@ int Decode_xorriso_timestamp(struct tm *erg, char *code,
> - strcpy(buf, code);

The size is pre-checked by

  l= strlen(code);
  if(l>17 || l<10)
    return(0);

No need for action.


> --- a/xorriso/opts_a_c.c
> @@ -368,8 +368,10 @@ int Xorriso_option_application_id(struct XorrisO
> - else
> -   strcpy(xorriso->application_id,name);

The size is pre-checked by

 if(Xorriso_check_name_len(xorriso, name,
                           (int) sizeof(xorriso->application_id),
                           "-application_id", 0) <= 0)
   return(0);

which will complain and refuse if oversize is detected.

No need for action.


> @@ -568,7 +570,8 @@ int Xorriso_option_biblio_file(struct XorrisO *xorriso, char *name, int flag)
>  if(Xorriso_check_name_len(xorriso, name, (int) sizeof(xorriso->biblio_file),
>                            "-biblio_file", 0) <= 0)
> - strcpy(xorriso->biblio_file, name);

The same.

No need for action.


> @@ -847,7 +850,8 @@ treatment_patch:;
> -     strcpy(xorriso->boot_image_bin_path, treatpt + 9);
> @@ -871,7 +876,8 @@ treatment_patch:;
> -     strcpy(xorriso->boot_image_bin_path, treatpt + 9);

Here xorriso should refuse to perform the -boot_image command.

I added length tests with error exit.

I am glad that at least one message was right. I am sorry I bothered you with so many false-positives, I should have checked them more closely. I just thought that additional control wouldn't mind.

> @@ -861,7 +865,8 @@ treatment_patch:;
> -     strcpy(xorriso->boot_image_bin_form, formpt);

This line is only executed with known short texts:

 if(strcmp(formpt, "isolinux")==0 || strcmp(formpt, "grub") == 0)
   isolinux_grub= 1;
 ...
   if(isolinux_grub) {
     ...
     strcpy(xorriso->boot_image_bin_form, formpt);

No need for action.


> @@ -1438,7 +1444,8 @@ int Xorriso_option_cdi(struct XorrisO *xorriso,
> - strcpy(xorriso->wdi, namept);

The length of eff_path was tested in Xorriso_normalize_img_path().
Xorriso_truncate_path_comps() either sets namept to eff_path or it
writes a truncated version of eff_path into path and sets namept to
path.

No need for action.


> @@ -2378,10 +2385,12 @@ int Xorriso_option_concat(struct XorrisO *xorriso,
> -   strcpy(xorriso->list_delimiter, delimiter);

The size is pre-checked by

   ret= Xorriso_check_thing_len(xorriso, argv[*idx + 1],
                                sizeof(xorriso->list_delimiter), "-concat",
                                "Delimiter", 0);
   if(ret <= 0)
     goto ex;

No need for action.


> -   strcpy(xorriso->list_delimiter, delimiter_mem);

delimiter_mem is the memorized content of xorriso->list_delimiter before
the operation began. So it cannot be too large.

No need for action.


> @@ -2427,7 +2436,8 @@ int Xorriso_option_copyright_file(struct XorrisO
> - strcpy(xorriso->copyright_file, name);

The size is pre-checked by

 if(Xorriso_check_name_len(xorriso, name,
                           (int) sizeof(xorriso->copyright_file),
                           "-copyright_file", 0) <= 0)
   return(0);

No need for action.


> --- a/xorriso/opts_p_z.c
> -   strcpy(xorriso->mark_text, xorriso->info_text);

mark_text is indeed smaller than info_text. But info_text only serves
as temporary storage for a string which formerly was in mark_text:

   strcpy(xorriso->info_text, xorriso->mark_text);

No need for action.


> @@ -417,7 +418,8 @@ int Xorriso_option_publisher(struct XorrisO *xorriso,
> strcpy(xorriso->publisher,name);

The size is pre-checked by Xorriso_check_name_len().

No need for action.


> --- a/xorriso/text_io.c
> @@ -612,7 +612,8 @@ klammer_affe:;
> -   strcpy(xorriso->pending_option,cpt);

cpt cannot be longer than SfileadrL-1, because it is a pointer into
a string which was checked for this length:

 ret= Xorriso_dialog_input(xorriso,line, SfileadrL, 1);
 ...
 cpt= line;
 ...

No need for action.

So only one occasion survived:
  https://dev.lovelyhq.com/libburnia/libisoburn/commit/06346c1e982ee4e813372914b16201cba17ced3f

--------------------------------------------------------------------------

> 3) Memcpy - in libisoburn/isofs_wrap.c, strncpy is used to copy fixed-size
> memory without ending null (Coverity reported it as a mistake), memcpy would
> be probably better in order to express the intent more clearly and to avoid
> false-positive warning in the future.

Maybe it gets smarter and avoids this warning together with all the false
positives above.

The man pages of strncpy(3) and memcpy(3) describe quite similar semantics
with the difference that strncpy() would be safe against reading
inappropriate bytes if src is shorter than n.
But on the other hand, a manipulation of an ISO 9660 Primary Volume
Descriptor is sypposed to be a binary data operation. So memset() is
indeed more appropriate than strncpy().

Applied by
  https://dev.lovelyhq.com/libburnia/libisoburn/commit/fe5fd8eefa42273c6d84d240582eee5c90412b43

As I said, this is more a cosmetic change to improve code readability and performance (even only little bit).

--------------------------------------------------------------------------

I hope i got everything properly processed now. Review is welcome.


Have a nice day :)

Thomas

 These are all remaining errors I found. Thank you for checking them, I really appreciate that (this is my first attempt in contributing).

Have a nice day too!

Eliska

Additional info:

I just realized I didn't send you the right error messages from Coverity (those I sent were processed by another tool). So, here they are.

With Pavel Cahyna, we might also have discovered the reason why Coverity reported those false-positive resource leaks. It cannot understand flags, so when it sees call:

Xorriso_read_lines(xorriso, fp, &linecount, &argc, &argv, 2);

it thinks it is a memory-allocating function. It cannot know that with flag==2 it only deallocates memory and leaves.

In fact, all three reports were false-positives but one of them was close to another mistake (deallocating inside if condition).

Why it didn't find the fourth call of the function Xorriso_read_lines remains a mystery. It would be a false-positive anyway.

	
	/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
	
	   Copyright 2007-2015 Thomas Schmitt, <address@hidden>
	
	   Provided under GPL version 2 or later.
	
	   This file contains the implementation of options as mentioned in man page
	   or info file derived from xorriso.texi.
	*/
	
	#ifdef HAVE_CONFIG_H
	#include "../config.h"
	#endif
	
	#include <ctype.h>
	#include <sys/types.h>
	#include <unistd.h>
	#include <stdlib.h>
	#include <stdio.h>
	#include <string.h>
	#include <sys/stat.h>
	#include <sys/time.h>
	#include <time.h>
	#include <errno.h>
	
	#include "xorriso.h"
	#include "xorriso_private.h"
	#include "xorrisoburn.h"
	
	
	/* Option -iso_rr_pattern "on"|"ls"|"off" */
	int Xorriso_option_iso_rr_pattern(struct XorrisO *xorriso, char *mode,int flag)
	{
	 if(strcmp(mode, "off")==0)
	   xorriso->do_iso_rr_pattern= 0;
	 else if(strcmp(mode, "on")==0)
	   xorriso->do_iso_rr_pattern= 1;
	 else if(strcmp(mode, "ls")==0)
	   xorriso->do_iso_rr_pattern= 2;
	 else {
	   sprintf(xorriso->info_text, "-iso_rr_pattern: unknown mode '%s'", mode);
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   return(0);
	 }
	 return(1);
	}
	
	
	/* Option -jigdo aspect argument */
	int Xorriso_option_jigdo(struct XorrisO *xorriso, char *aspect, char *arg,
	                         int flag)
	{
	 int ret;
	
	 ret= Xorriso_jigdo_interpreter(xorriso, aspect, arg, 0);
	 return(ret);
	}
	
	
	/* Option -joliet "on"|"off" */
	int Xorriso_option_joliet(struct XorrisO *xorriso, char *mode, int flag)
	{
	 if(strcmp(mode, "off")==0)
	   xorriso->do_joliet= 0;
	 else if(strcmp(mode, "on")==0)
	   xorriso->do_joliet= 1;
	 else {
	   sprintf(xorriso->info_text, "-joliet: unknown mode '%s'", mode);
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   return(0);
	 }
	 return(1);
	}
	
	
	/* Command -launch_frontend */
	int Xorriso_option_launch_frontend(struct XorrisO *xorriso,
	                                   int argc, char **argv, int *idx, int flag)
	{
	 int ret, end_idx;
	
	 end_idx= Xorriso_end_idx(xorriso, argc, argv, *idx, 1);
	
	 if(xorriso->launch_frontend_banned) {
	   sprintf(xorriso->info_text,
	           "-launch_frontend was already executed in this xorriso run");
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
	   ret= 0; goto ex;
	 }
	 xorriso->launch_frontend_banned= 1;
	 if(end_idx <= *idx)
	   {ret= 1; goto ex;}
	 if(argv[*idx][0] == 0)
	   {ret= 1; goto ex;}
	 xorriso->dialog= 2;
	 ret= Xorriso_launch_frontend(xorriso, end_idx - *idx, argv + *idx,
	                              "", "", 0);
	ex:;
	 (*idx)= end_idx;
	 return(ret);
	}
	
	
	/* Option -list_arg_sorting */
	int Xorriso_option_list_arg_sorting(struct XorrisO *xorriso, int flag)
	{
	 int ret;
	
	 ret= Xorriso_cmd_sorting_rank(xorriso, 0, NULL, 0, 1);
	 return(ret);
	}
	
	
	/* Option -list_delimiter */
	int Xorriso_option_list_delimiter(struct XorrisO *xorriso, char *text,
	                                  int flag)
	{
	 int ret, argc;
	 char **argv= NULL;
	
	 if(text[0] == 0) {
	   sprintf(xorriso->info_text,
	           "-list_delimiter: New delimiter text is empty");
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   return(0);
	 }
	 if(strlen(text) > 80) {
	   sprintf(xorriso->info_text,
	           "-list_delimiter: New delimiter text is too long");
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   return(0);
	 }
	 ret= Sfile_make_argv(xorriso->progname, text, &argc, &argv, 4);
	 if(ret > 0) {
	   if(argc > 2) {
	     sprintf(xorriso->info_text,
	            "-list_delimiter: New delimiter text contains more than one word");
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   }
	   Sfile_make_argv(xorriso->progname, text, &argc, &argv, 2);
	   if(argc > 2)
	     return(0);
	 }
	 if(strchr(text, '"') != NULL || strchr(text, '\'') != NULL) {
	   sprintf(xorriso->info_text,
	           "-list_delimiter: New delimiter text contains quotation marks");
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   return(0);
	 }
	 strcpy(xorriso->list_delimiter, text);
	 return(1);
	}
	
	
	/* Option -list_extras */
	int Xorriso_option_list_extras(struct XorrisO *xorriso, char *mode, int flag)
	{
	 int ret;
	
	 ret= Xorriso_list_extras(xorriso, mode, 0);
	 return(ret);
	}
	
	
	/* Option -list_formats */
	int Xorriso_option_list_formats(struct XorrisO *xorriso, int flag)
	{
	 int ret;
	
	 ret= Xorriso_list_formats(xorriso, 0);
	 return(ret);
	}
	
	
	/* Option -list_speeds */
	int Xorriso_option_list_speeds(struct XorrisO *xorriso, int flag)
	{
	 int ret;
	
	 ret= Xorriso_list_speeds(xorriso, 0);
	 return(ret);
	}
	
	
	/* Option -list_profiles */
	int Xorriso_option_list_profiles(struct XorrisO *xorriso, char *which,
	                                 int flag)
	{
	 int ret;
	 int mode= 0;
	
	 if(strncmp(which,"in",2)==0)
	   mode|= 1;
	 else if(strncmp(which,"out",3)==0)
	   mode|= 2;
	 else
	   mode|= 3;
	 if(mode & 1) {
	   ret= Xorriso_toc(xorriso, 1 | 16 | 32);
	   if(ret > 0)
	     Xorriso_list_profiles(xorriso, 0);
	 }
	 if((mode & 2) && xorriso->in_drive_handle != xorriso->out_drive_handle) {
	   ret= Xorriso_toc(xorriso, 1 | 2 | 16 | 32);
	   if(ret > 0)
	     Xorriso_list_profiles(xorriso, 2);
	 }
	 return(1);
	}
	
	
	/* Command -lns alias -lnsi */
	int Xorriso_option_lnsi(struct XorrisO *xorriso, char *target, char *path,
	                        int flag)
	{
	 int ret;
	 char *eff_path= NULL, *buffer= NULL, *namept;
	
	 Xorriso_alloc_meM(eff_path, char, SfileadrL);
	 Xorriso_alloc_meM(buffer, char, SfileadrL);
	
	 ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, path, eff_path, 1);
	 if(ret < 0)
	   {ret= 0; goto ex;}
	 if(ret > 0) { 
	   sprintf(xorriso->info_text, "-lns: Address already existing: ");
	   Text_shellsafe(eff_path, xorriso->info_text, 1);
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   {ret= 0; goto ex;}
	 } 
	 ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, path, eff_path, 2);
	 if(ret < 0)
	   {ret= 0; goto ex;}
	 ret= Xorriso_truncate_path_comps(xorriso, target, buffer, &namept, 0);
	 if(ret < 0)
	   {ret= 0; goto ex;}
	 ret= Xorriso_graft_in(xorriso, NULL, namept, eff_path, (off_t) 0, (off_t) 0,
	                       1024);
	 if(ret <= 0)
	   {ret= 0; goto ex;}
	 ret= 1;
	ex:;
	 Xorriso_free_meM(buffer);
	 Xorriso_free_meM(eff_path);
	 return(ret);
	}
	
	
	/* Option -load session|track|sbsector value */
	/* @param flag bit0= with adr_mode sbsector: adr_value is possibly 16 too high
	   @return <=0 error , 1 success, 2 revoked by -reassure
	*/
	int Xorriso_option_load(struct XorrisO *xorriso, char *adr_mode,
	                          char *adr_value, int flag)
	{
	 int ret;
	
	 if(Xorriso_change_is_pending(xorriso, 0)) {
	   sprintf(xorriso->info_text,
	           "-load: Image changes pending. -commit or -rollback first");
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   return(0);
	 }
	 ret= Xorriso_reassure(xorriso, "-load", "loads an alternative image", 0);
	 if(ret<=0)
	   return(2);
	 ret= Xorriso_decode_load_adr(xorriso, "-load", adr_mode, adr_value,
	                              &(xorriso->image_start_mode),
	                              xorriso->image_start_value, flag & 1);
	 if(ret <= 0)
	   return(ret);
	 xorriso->image_start_mode|= (1<<30); /* enable non-default msc1 processing */
	 if(strlen(xorriso->indev)>0) {
	   ret= Xorriso_option_rollback(xorriso, 1); /* Load image, no -reassure */
	   if(ret<=0)
	     return(ret);
	 }
	 return(1);
	}
	
	
	/* Option -logfile */
	int Xorriso_option_logfile(struct XorrisO *xorriso, char *channel,
	                                                      char *fileadr, int flag)
	{
	 int hflag,channel_no= 0, ret;
	   
	 if(channel[0]==0) {
	logfile_wrong_form:;
	   sprintf(xorriso->info_text,"Wrong form. Correct would be: -logfile \".\"|\"R\"|\"I\"|\"M\" file_address");
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
	   return(0);
	 }
	 hflag= 2;
	 if(channel[0]=='R')
	   channel_no= 1;
	 else if(channel[0]=='I')
	   channel_no= 2;
	 else if(channel[0]=='M')
	   channel_no= 3;
	 else if(channel[0]=='.')
	   hflag= 4;
	 else
	   goto logfile_wrong_form;
	 if(strcmp(fileadr,"-")==0 || fileadr[0]==0)
	     hflag|= (1<<15);
	 xorriso->logfile[channel_no][0]= 0;
	 ret= Xorriso_write_to_channel(xorriso, fileadr, channel_no, hflag);
	 if(ret<=0) {
	   sprintf(xorriso->info_text, "Cannot open logfile:  %s", fileadr);
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
	 } else if(!(hflag&(1<<15)))
	   if(Sfile_str(xorriso->logfile[channel_no], fileadr, 0)<=0)
	     return(-1);
	 return(ret>0);
	}
	
	
	/* Options -ls  alias -lsi   and -lsl  alias -lsli
	       and -lsd alias -lsdi  and -lsdl alias -lsdli
	       and -du  alias -dui   and -dus  alias -dusi
	   @param flag bit0= long format (-lsl , -du, not -dus, not -ls)
	               bit1= do not expand patterns but use literally
	               bit2= -du rather than -ls
	               bit3= list directories as themselves (-lsd) 
	*/
	int Xorriso_option_lsi(struct XorrisO *xorriso, int argc, char **argv,
	                      int *idx, int flag)
	{
	 int ret, end_idx, filec= 0, nump, i, star= 1;
	 char **filev= NULL, **patterns= NULL;
	 off_t mem= 0;
	 struct stat stbuf;
	
	 if(flag & 4) {
	   if(!(flag & 1))
	     star= 0;
	 } else {
	   if(flag & 8)
	     star= 0;
	 }
	
	 end_idx= Xorriso_end_idx(xorriso, argc, argv, *idx, 1);
	 if(xorriso->do_iso_rr_pattern==0)
	   flag|= 2;
	
	 nump= end_idx - *idx;
	 if((flag&2) && nump>0 ) {
	   ;
	 } else if(nump <= 0) {
	   if(Xorriso_iso_lstat(xorriso, xorriso->wdi, &stbuf, 0)<0) {
	     sprintf(xorriso->info_text,
	             "Current -cd path does not yet exist in the ISO image");
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
	     {ret= 0; goto ex;}
	   }
	   if(!S_ISDIR(stbuf.st_mode)) {
	     sprintf(xorriso->info_text,
	             "Current -cd meanwhile points to a non-directory in ISO image");
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
	     {ret= 0; goto ex;}
	   }
	   patterns= calloc(1, sizeof(char *));
	   if(patterns == NULL) {
	no_memory:;
	     sprintf(xorriso->info_text,
	             "Cannot allocate enough memory for pattern expansion");
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
	     {ret= -1; goto ex;}
	   }
	   nump= 1;
	   if(star)
	     patterns[0]= "*";
	   else 
	     patterns[0]= ".";
	   flag&= ~2;
	 } else {
	   patterns= calloc(nump, sizeof(char *));
	   if(patterns==NULL)
	     goto no_memory;
	   for(i= 0; i<nump; i++) {
	     if(argv[i + *idx][0]==0) {
	       if(star)
	         patterns[i]= "*";
	       else
	         patterns[i]= ".";
	     } else
	       patterns[i]= argv[i + *idx];
	   }
	 }
	
	 if((flag & 1) && !(xorriso->ino_behavior & 32)) {
	   ret= Xorriso_make_hln_array(xorriso, 0); /* for stbuf.st_nlink */
	   if(ret < 0)
	     goto ex;
	 }
	 if(flag&2) {
	   ret= Xorriso_ls_filev(xorriso, xorriso->wdi, nump, argv + (*idx), mem,
	                         flag&(1|4|8)); 
	 } else if(nump==1 && strcmp(patterns[0],"*")==0 && !(flag&4)){
	   /* save temporary memory by calling simpler function */
	   ret= Xorriso_ls(xorriso, (flag&1)|4);
	 } else {
	   ret= Xorriso_expand_pattern(xorriso, nump, patterns, 0, &filec, &filev,
	                               &mem, 0);
	   if(ret<=0)
	     {ret= 0; goto ex;}
	   ret= Xorriso_ls_filev(xorriso, xorriso->wdi, filec, filev, mem,
	                         flag&(1|4|8)); 
	 }
	 if(ret<=0)
	   {ret= 0; goto ex;}
	
	 ret= 1;
	ex:;
	 if(patterns!=NULL)
	   free((char *) patterns);
	 Sfile_destroy_argv(&filec, &filev, 0);
	 (*idx)= end_idx;
	 return(ret);
	}
	
	
	/* Options -lsx, -lslx, -lsdx , -lsdlx , -dux , -dusx
	   @param flag bit0= long format (-lslx , -dux)
	               bit1= do not expand patterns but use literally
	               bit2= du rather than ls
	               bit3= list directories as themselves (ls -d) 
	*/
	int Xorriso_option_lsx(struct XorrisO *xorriso, int argc, char **argv,
	                      int *idx, int flag)
	{
	 int ret, end_idx, filec= 0, nump, i;
	 char **filev= NULL, **patterns= NULL;
	 off_t mem= 0;
	
	 end_idx= Xorriso_end_idx(xorriso, argc, argv, *idx, 1|2);
	 if(xorriso->do_disk_pattern==0)
	   flag|= 2;
	
	 nump= end_idx - *idx;
	 if((flag&2) && nump>0) {
	   ;
	 } else if(nump <= 0) {
	   patterns= calloc(1, sizeof(char *));
	   if(patterns == NULL) {
	no_memory:;
	     sprintf(xorriso->info_text,
	             "Cannot allocate enough memory for pattern expansion");
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
	     {ret= -1; goto ex;}
	   }
	   nump= 1;
	   if(flag&8)
	     patterns[0]= ".";
	   else
	     patterns[0]= "*";
	   flag&= ~2;
	 } else {
	   patterns= calloc(nump, sizeof(char *));
	   if(patterns==NULL)
	     goto no_memory;
	   for(i= 0; i<nump; i++) {
	     if(argv[i + *idx][0]==0)
	       patterns[i]= "*";
	     else
	       patterns[i]= argv[i + *idx];
	   }
	 }
	 if(flag&2) {
	   ret= Xorriso_lsx_filev(xorriso, xorriso->wdx,
	                          nump, argv + (*idx), mem, flag&(1|4|8)); 
	
	#ifdef Not_yeT
	 } else if(nump==1 && strcmp(patterns[0],"*")==0 && !(flag&4)){
	   /* save temporary memory by calling simpler function */
	   ret= Xorriso_ls(xorriso, (flag&1)|4);
	#endif
	
	 } else {
	   ret= Xorriso_expand_disk_pattern(xorriso, nump, patterns, 0, &filec, &filev,
	                                    &mem, 0);
	   if(ret<=0)
	     {ret= 0; goto ex;}
	   ret= Xorriso_lsx_filev(xorriso, xorriso->wdx, filec, filev, mem,
	                          flag&(1|4|8)); 
	 }
	 if(ret<=0)
	   {ret= 0; goto ex;}
	
	 ret= 1;
	ex:;
	 if(patterns!=NULL)
	   free((char *) patterns);
	 Sfile_destroy_argv(&filec, &filev, 0);
	 (*idx)= end_idx;
	 return(ret);
	}
	
	
	/* Option -map , -map_single */
	/* @param flag bit0=do not report the added item
	               bit1=do not reset pacifier, no final pacifier message
	               bit5= -map_single: do not insert directory tree
	*/
	int Xorriso_option_map(struct XorrisO *xorriso, char *disk_path,
	                       char *iso_path, int flag)
	{
	 int ret;
	 char *eff_origin= NULL, *eff_dest= NULL, *ipth;
	
	 Xorriso_alloc_meM(eff_origin, char, SfileadrL);
	 Xorriso_alloc_meM(eff_dest, char, SfileadrL);
	
	 if(!(flag&2))
	   Xorriso_pacifier_reset(xorriso, 0);
	
	 ipth= iso_path;
	 if(ipth[0]==0)
	   ipth= disk_path;
	 if(disk_path[0]==0) {
	   sprintf(xorriso->info_text, "-map: Empty disk_path given");
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 1);
	   {ret= 0; goto ex;}
	 }
	 ret= Xorriso_normalize_img_path(xorriso, xorriso->wdx, disk_path, eff_origin,
	                                 2|4);
	 if(ret<=0)
	   goto ex;
	 ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, ipth, eff_dest, 2);
	 if(ret<=0)
	   goto ex;
	 ret= Xorriso_graft_in(xorriso, NULL, eff_origin, eff_dest,
	                       (off_t) 0, (off_t) 0, 2|(flag&32));
	 if(!(flag&2))
	   Xorriso_pacifier_callback(xorriso, "files added", xorriso->pacifier_count,
	                             xorriso->pacifier_total, "", 1);
	 if(ret<=0)
	   goto ex;
	
	 if(!(flag&1)) {
	   sprintf(xorriso->info_text, "Added to ISO image: %s '%s'='%s'\n",
	           (ret>1 ? "directory" : "file"), (eff_dest[0] ? eff_dest : "/"),
	           eff_origin);
	   Xorriso_info(xorriso,0);
	 }
	 ret= 1;
	ex:;
	 Xorriso_free_meM(eff_origin);
	 Xorriso_free_meM(eff_dest);
	 return(ret);
	}
	
	
	/* Command -map_l , -compare_l , -update_l , -extract_l , -update_lxi ,
	           -update_li
	*/
	/* @param flag bit4= do not establish and dispose xorriso->di_array
	                     for update_l
	               bit8-11= mode 0= -map_l
	                             1= -compare_l
	                             2= -update_l
	                             3= -extract_l
	                             4= -update_lxi
	                             5= -update_li
	*/
	int Xorriso_option_map_l(struct XorrisO *xorriso, int argc, char **argv,
	                         int *idx, int flag)
	{
	 int ret, end_idx, optc= 0, was_failure= 1, i, j, fret, mode, problem_count;
	 int ns_flag= 2|4, nt_flag= 2, opt_args_flag= 2, arg2c= 0, opt2c= 0;
	 int new_opt2c;
	 char *source_prefix= NULL, *target_prefix= NULL, *cmd, **optv= NULL;
	 char *eff_source= NULL, *eff_target= NULL, *s_wd, *t_wd;
	 char **eff_src_array= NULL, **eff_tgt_array= NULL, **opt2v= NULL;
	 char **arg2v= NULL;
	
	 cmd= "-map_l";
	 s_wd= xorriso->wdx;
	 t_wd= xorriso->wdi;
	 Xorriso_pacifier_reset(xorriso, 0);
	 mode= (flag>>8) & 15;
	
	 if(mode==1)
	   cmd= "-compare_l";
	 else if(mode==2)
	   cmd= "-update_l";
	 else if(mode == 3 || mode == 5) {
	   if(mode == 5)
	     cmd= "-update_li";
	   else
	     cmd= "-extract_l";
	   ns_flag= 2;
	   s_wd= xorriso->wdi;
	   nt_flag= 2|4;
	   t_wd= xorriso->wdx;
	   opt_args_flag= 0;
	 } else if(mode == 4) {
	   cmd= "-update_lxi";
	 }
	
	 end_idx= Xorriso_end_idx(xorriso, argc, argv, *idx, 1|2);
	 if(end_idx - (*idx) < 3) {
	   sprintf(xorriso->info_text, "%s: Not enough arguments given (%d < 3)", cmd,
	           end_idx - (*idx));
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 1);
	   ret= 0; goto ex;
	 }
	
	 Xorriso_alloc_meM(source_prefix, char, SfileadrL);
	 Xorriso_alloc_meM(target_prefix, char, SfileadrL);
	 Xorriso_alloc_meM(eff_source, char, SfileadrL);
	 Xorriso_alloc_meM(eff_target, char, SfileadrL);
	
	 ret= Xorriso_normalize_img_path(xorriso, s_wd, argv[*idx],
	                                 source_prefix, ns_flag | 64);
	 if(ret<=0)
	   goto ex;
	 ret= Xorriso_normalize_img_path(xorriso, t_wd, argv[(*idx)+1],
	                                 target_prefix, nt_flag);
	 if(ret<=0)
	   goto ex;
	 ret= Xorriso_opt_args(xorriso, cmd, argc, argv, (*idx)+2, &end_idx,
	                       &optc, &optv, opt_args_flag);
	 if(ret<=0)
	   goto ex;
	 if(mode == 4) {
	   /* Convert pattern from disk to iso_rr */
	   arg2c= end_idx - *idx - 2;
	   Xorriso_alloc_meM(arg2v, char *, arg2c);
	   for(i = 0; i < arg2c; i++)
	     arg2v[i]= NULL;
	   arg2c= 0;
	   for(i = (*idx) + 2; i < end_idx; i++) {
	     ret= Xorriso_normalize_img_path(xorriso, s_wd, argv[i],
	                                     eff_source, ns_flag);
	     if(ret<=0)
	       goto ex;
	     ret= Xorriso__exchange_prefix(source_prefix, target_prefix,
	                                   eff_source, eff_target, 0);
	     if(ret <= 0)
	   continue;
	     Xorriso_alloc_meM(arg2v[arg2c], char, strlen(eff_target) + 1);
	     strcpy(arg2v[arg2c], eff_target);
	     arg2c++;
	   }
	   /* Expand wildcards in iso_rr, do not include unmatched patterns */
	   ret= Xorriso_opt_args(xorriso, cmd, arg2c, arg2v, 0, &i,
	                          &opt2c, &opt2v, (1 << 10) | (1 << 7));
	   if(ret<=0)
	     goto ex;
	   /* Convert from iso_rr path to disk path */
	   new_opt2c= 0;
	   for(i = 0; i < opt2c; i++) {
	     ret= Xorriso__exchange_prefix(target_prefix, source_prefix,
	                                   opt2v[i], eff_source, 0);
	     free(opt2v[i]);
	     opt2v[i]= NULL;
	     if(ret <= 0)
	   continue;
	     Xorriso_alloc_meM(opt2v[new_opt2c], char, strlen(eff_source) + 1);
	     strcpy(opt2v[new_opt2c], eff_source);
	     new_opt2c++;
	   }
	   opt2c= new_opt2c;
	   /* Merge both results */
	   if(opt2c > 0) {
	     Sfile_destroy_argv(&arg2c, &arg2v, 0);
	     Xorriso_alloc_meM(arg2v, char *, optc + opt2c);
	     for(i = 0; i < optc + opt2c; i++)
	       arg2v[i]= NULL;
	     arg2c= 0;
	     for(i= 0; i < optc; i++) {
	       ret= Xorriso_normalize_img_path(xorriso, s_wd, optv[i],
	                                       eff_source, ns_flag);
	       if(ret<=0)
	         goto ex;
	       Xorriso_alloc_meM(arg2v[arg2c], char, strlen(eff_source) + 1);
	       strcpy(arg2v[arg2c], eff_source);
	       arg2c++;
	     }
	     for(i= 0; i < opt2c; i++) {
	       for(j= 0; j < optc; j++)
	         if(strcmp(opt2v[i], arg2v[j]) == 0)
	       break;
	       if(j < optc)
	     continue;
	       arg2v[arg2c++]= opt2v[i];
	       opt2v[i]= NULL;
	     }
	     Sfile_destroy_argv(&optc, &optv, 0);
	     optv= arg2v;
	     arg2v= NULL;
	     optc= arg2c;
	     arg2c= 0;
	   }
	 }
	
	 if(mode == 3 &&
	    (xorriso->do_restore_sort_lba || !(xorriso->ino_behavior & 4))) {
	   eff_src_array= calloc(optc, sizeof(char *));
	   eff_tgt_array= calloc(optc, sizeof(char *));
	   if(eff_src_array == NULL || eff_tgt_array == NULL) {
	     Xorriso_no_malloc_memory(xorriso, NULL, 0);
	     ret= -1; goto ex;
	   }
	   for(i= 0; i < optc; i++)
	     eff_src_array[i]= eff_tgt_array[i]= NULL;
	 }
	 if((mode == 2 || mode == 4) &&
	     !((xorriso->ino_behavior & 2) || (flag & 16) ||
	       xorriso->di_array != NULL)) {
	   /* Create all-image node array sorted by isofs.di */
	   ret= Xorriso_make_di_array(xorriso, 0);
	   if(ret <= 0)
	     goto ex;
	 }
	
	 for(i= 0; i<optc; i++) {
	   ret= Xorriso_normalize_img_path(xorriso, s_wd, optv[i],
	                                   eff_source, ns_flag);
	   if(ret<=0)
	     goto ex;
	   ret= Xorriso__exchange_prefix(source_prefix, target_prefix,
	                                 eff_source, eff_target, 0);
	   if(ret == 0) {
	     sprintf(xorriso->info_text, "%s: disk_path ", cmd);
	     Text_shellsafe(eff_source, xorriso->info_text, 1);
	     strcat(xorriso->info_text, " does not begin with disk_prefix ");
	     Text_shellsafe(source_prefix, xorriso->info_text, 1);
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 1);
	   }
	   if(ret <= 0)
	     goto ex;
	
	   if(mode==0)
	     ret= Xorriso_option_map(xorriso, eff_source, eff_target, 2);
	   else if(mode==1)
	     ret= Xorriso_option_compare(xorriso, eff_source, eff_target, 2|8);
	   else if(mode == 2 || mode == 4)
	     ret= Xorriso_option_update(xorriso, eff_source, eff_target, 2 | 8 | 16);
	   else if(mode==3) {
	     if(eff_src_array != NULL) {
	       eff_src_array[i]= strdup(eff_source);
	       eff_tgt_array[i]= strdup(eff_target);
	       if(eff_src_array[i] == NULL || eff_tgt_array[i] == NULL) {
	         Xorriso_no_malloc_memory(xorriso, &(eff_src_array[i]), 0);
	         ret= -1; goto ex;
	       }
	     } else {
	       ret= Xorriso_option_extract(xorriso, eff_source, eff_target, 2 | 4);
	     }
	   } else if(mode == 5) {
	     ret= Xorriso_option_update(xorriso, eff_target, eff_source, 2 | 8 | 16);
	   }
	
	   if(ret>0 && !xorriso->request_to_abort)
	 continue; /* regular bottom of loop */
	   was_failure= 1;
	   fret= Xorriso_eval_problem_status(xorriso, ret, 1 | 2);
	   if(fret>=0)
	 continue;
	   goto ex;
	 }
	
	 ret= 1;
	 if(mode == 3 && eff_src_array != NULL) {
	   ret= Xorriso_lst_append_binary(&(xorriso->node_disk_prefixes),
	                                  target_prefix, strlen(target_prefix) + 1, 0);
	   if(ret <= 0)
	     goto ex;
	   ret= Xorriso_lst_append_binary(&(xorriso->node_img_prefixes),
	                                  source_prefix, strlen(source_prefix) + 1, 0);
	   if(ret <= 0)
	     goto ex;
	   ret= Xorriso_restore_sorted(xorriso, optc, eff_src_array, eff_tgt_array,
	                               &problem_count, 0);
	   if(ret <= 0 || problem_count > 0)
	     was_failure= 1;
	 }
	 if(mode==0)
	   Xorriso_pacifier_callback(xorriso, "files added", xorriso->pacifier_count,
	                             xorriso->pacifier_total, "", 1);
	 else if(mode==1 || mode==2 || mode == 4 || mode == 5)
	   Xorriso_pacifier_callback(xorriso, "content bytes read",
	                             xorriso->pacifier_count, 0, "", 1 | 8 | 32);
	 else if(mode==3)
	   Xorriso_pacifier_callback(xorriso, "files restored",xorriso->pacifier_count,
	                             xorriso->pacifier_total, "", 1|4);
	ex:;
	 Xorriso_destroy_node_array(xorriso, 0);
	 i= optc;
	 Sfile_destroy_argv(&i, &eff_src_array, 0);
	 i= optc;
	 Sfile_destroy_argv(&i, &eff_tgt_array, 0);
	 Xorriso_free_meM(source_prefix);
	 Xorriso_free_meM(target_prefix);
	 Xorriso_free_meM(eff_source);
	 Xorriso_free_meM(eff_target);
	 (*idx)= end_idx;
	 Xorriso_opt_args(xorriso, cmd, argc, argv, *idx, &end_idx, &optc, &optv, 256);
	 Xorriso_opt_args(xorriso, cmd, argc, argv, *idx, &end_idx, &opt2c, &opt2v,
	                  256);
	 if(arg2c > 0)
	   Sfile_destroy_argv(&arg2c, &arg2v, 0);
	 else if(arg2v != NULL)
	   Xorriso_free_meM(arg2v);
	
	 if(ret<=0)
	   return(ret);
	 return(!was_failure);
	}
	
	
	/* Option -mark */
	int Xorriso_option_mark(struct XorrisO *xorriso, char *mark, int flag)
	{
	 if(mark[0]==0)
	   xorriso->mark_text[0]= 0;
	 else
	   strncpy(xorriso->mark_text,mark,sizeof(xorriso->mark_text)-1);
	 xorriso->mark_text[sizeof(xorriso->mark_text)-1]= 0;
	 return(1);
	}
	
	
	/* Option -md5 "on"|"all"|"off" */
	int Xorriso_option_md5(struct XorrisO *xorriso, char *mode, int flag)
	{
	 char *npt, *cpt;
	 int l;
	
	 npt= cpt= mode;
	 for(; npt!=NULL; cpt= npt+1) {
	   npt= strchr(cpt,':');
	   if(npt==NULL)
	     l= strlen(cpt);
	   else
	     l= npt-cpt;
	   if(l == 0)
	 continue;
	   if(l == 3 && strncmp(cpt, "off", l) == 0)
	     xorriso->do_md5&= ~31;
	   else if(l == 2 && strncmp(cpt, "on", l) == 0)
	     xorriso->do_md5= (xorriso->do_md5 & ~31) | 7 | 16;
	   else if(l == 3 && strncmp(cpt, "all", l) == 0)
	     xorriso->do_md5|= 31;
	   else if(l == 18 && strncmp(cpt, "stability_check_on", l) == 0)
	     xorriso->do_md5|= 8;
	   else if(l == 19 && strncmp(cpt, "stability_check_off", l) == 0)
	     xorriso->do_md5&= ~8;
	   else if(l == 13 && strncmp(cpt, "load_check_on", l) == 0)
	     xorriso->do_md5&= ~32;
	   else if(l == 14 && strncmp(cpt, "load_check_off", l) == 0)
	     xorriso->do_md5|= 32;
	   else {
	     sprintf(xorriso->info_text, "-md5: unknown mode ");
	     Text_shellsafe(cpt, xorriso->info_text, 1);
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	     return(0);
	   }
	 }
	 return(1);
	}
	
	
	/* Option -mkdir alias -mkdiri */
	int Xorriso_option_mkdiri(struct XorrisO *xorriso, int argc, char **argv,
	                          int *idx, int flag)
	{
	 int i, end_idx, ret, was_failure= 0, fret;
	
	 end_idx= Xorriso_end_idx(xorriso, argc, argv, *idx, 0);
	
	 for(i= *idx; i<end_idx; i++) {
	   ret= Xorriso_mkdir(xorriso, argv[i], 0);
	   if(ret>0 && !xorriso->request_to_abort)
	 continue; /* regular bottom of loop */
	   was_failure= 1;
	   fret= Xorriso_eval_problem_status(xorriso, ret, 1|2);
	   if(fret>=0)
	 continue;
	   goto ex;
	 }
	 ret= 1; 
	ex:;
	 (*idx)= end_idx;
	 if(ret<=0)
	   return(ret);
	 return(!was_failure);
	}
	
	
	int Xorriso_option_modesty_on_drive(struct XorrisO *xorriso, char *mode,
	                                    int flag)
	{
	 char *npt, *cpt, *ppt;
	 int l, num, set_min;
	
	 npt= cpt= mode;
	 for(; npt!=NULL; cpt= npt+1) {
	   npt= strchr(cpt,':');
	   if(npt==NULL)
	     l= strlen(cpt);
	   else
	     l= npt-cpt;
	   if(l == 0)
	 continue;
	   if(l == 3 && strncmp(cpt, "off", l) == 0) {
	     xorriso->modesty_on_drive= 0;
	   } else if(l == 1 && strncmp(cpt, "0", l) == 0) {
	     xorriso->modesty_on_drive= 0;
	   } else if(l == 2 && strncmp(cpt, "on", l) == 0) {
	     xorriso->modesty_on_drive= 1;
	   } else if(l == 1 && strncmp(cpt, "1", l) == 0) {
	     xorriso->modesty_on_drive= 1;
	   } else if(l == 2 && strncmp(cpt, "-1", l) == 0) {
	     ;
	   } else if(*cpt >= '1' && *cpt <= '9') {
	     ppt= cpt;
	     set_min= 2;
	set_size_percent:;
	     sscanf(ppt, "%d", &num);
	     if(num == -1) {
	       ;
	     } else if(num < 25) {
	bad_percent:;
	       sprintf(xorriso->info_text, "-modesty_on_drive: percentage out of range [25 to 100]");
	       Text_shellsafe(cpt, xorriso->info_text, 1);
	       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	       return(0);
	     } else if(num > 100) {
	       goto bad_percent;
	     }
	     if(set_min == 2) {
	       xorriso->modesty_on_drive= 1;
	     }
	     if(set_min)
	       xorriso->min_buffer_percent= num;
	     else
	       xorriso->max_buffer_percent= num;
	   } else if(l >= 12 && strncmp(cpt, "min_percent=", 12) == 0) {
	     ppt= cpt + 12;
	     set_min= 1;
	     goto set_size_percent;
	   } else if(l >= 12 && strncmp(cpt, "max_percent=", 12) == 0) {
	     ppt= cpt + 12;
	     set_min= 0;
	     goto set_size_percent;
	   } else if(l >= 9 && strncmp(cpt, "min_usec=", 9) == 0) {
	     ppt= cpt + 9;
	     set_min= 1;
	set_sec:;
	     num= -1;
	     sscanf(ppt, "%d", &num);
	     if(num < 0)
	       num= 0;
	     if(set_min == 2)
	       xorriso->max_buffer_usec= num;
	     else if(set_min == 1)
	       xorriso->min_buffer_usec= num;
	     else if(set_min == 0)
	       xorriso->max_buffer_percent= num;
	     else
	       xorriso->buffer_timeout_sec= num;
	   } else if(l >= 9 && strncmp(cpt, "max_usec=", 9) == 0) {
	     ppt= cpt + 9;
	     set_min= 2;
	     goto set_sec;
	   } else if(l >= 12 && strncmp(cpt, "timeout_sec=", 12) == 0) {
	     ppt= cpt + 12;
	     set_min= -1;
	     goto set_sec;
	   } else {
	     sprintf(xorriso->info_text, "-modesty_on_drive: unknown mode ");
	     Text_shellsafe(cpt, xorriso->info_text, 1);
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	     return(0);
	   }
	 }
	 return(1);
	}
	
	
	/* Options -mount , -mount_cmd , -session_string */
	/* @param bit0= -mount_cmd: print mount command to result channel rather
	                            than performing it
	          bit1= perform -session_string rather than -mount_cmd
	*/
	int Xorriso_option_mount(struct XorrisO *xorriso, char *dev, char *adr_mode,
	                         char *adr, char *cmd, int flag)
	{
	 int ret, entity_code= 0, m_flag;
	 char entity_id[81], *mnt;
	
	 if(flag & 1)
	   mnt= "-mount_cmd";
	 else if(flag & 2)
	   mnt= "-session_string";
	 else {
	   mnt= "-mount";
	   if(xorriso->allow_restore <= 0) {
	     sprintf(xorriso->info_text,
	          "-mount: image-to-disk features are not enabled by option -osirrox");
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	     return(0);
	   }
	   if(Xorriso_change_is_pending(xorriso, 0)) {
	     sprintf(xorriso->info_text,
	             "%s: Image changes pending. -commit or -rollback first", mnt);
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	     return(0);
	   }
	 }
	 ret= Xorriso_decode_load_adr(xorriso, mnt, adr_mode, adr,
	                              &entity_code, entity_id, 0);
	 if(ret <= 0)
	   return(ret);
	 if(flag & 2)
	   m_flag= 1 | 4;
	 else
	   m_flag= (flag & 1) | 2;
	 ret= Xorriso_mount(xorriso, dev, entity_code, entity_id, cmd, m_flag);
	 return(ret);
	}
	
	
	/* Option -mount_opts option[:...] */
	int Xorriso_option_mount_opts(struct XorrisO *xorriso, char *mode, int flag)
	{
	 int was, l;
	 char *cpt, *npt;
	
	 was= xorriso->mount_opts_flag;
	 npt= cpt= mode;
	 for(cpt= mode; npt!=NULL; cpt= npt+1) {
	   npt= strchr(cpt,':');
	   if(npt==NULL)
	     l= strlen(cpt);
	   else
	     l= npt-cpt;
	   if(l==0)
	     goto unknown_mode;
	   if(strncmp(cpt, "shared", l)==0) {
	     xorriso->mount_opts_flag|= 1;
	   } else if(strncmp(cpt, "exclusive", l)==0) {
	     xorriso->mount_opts_flag&= ~1;
	   } else {
	unknown_mode:;
	     if(l<SfileadrL)
	       sprintf(xorriso->info_text, "-mount_opts: unknown option '%s'", cpt);
	     else
	       sprintf(xorriso->info_text, "-mount_opts: oversized parameter (%d)",l);
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	     xorriso->mount_opts_flag= was;
	     return(0);
	   }
	 }
	 return(1);
	}
	
	
	/* Command -move */
	int Xorriso_option_move(struct XorrisO *xorriso, char *origin, char *dest,
	                        int flag)
	{
	 int ret;
	 char *eff_origin= NULL, *eff_dest= NULL;
	
	 Xorriso_alloc_meM(eff_origin, char, SfileadrL);
	 Xorriso_alloc_meM(eff_dest, char, SfileadrL);
	
	 ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, origin, eff_origin, 0);
	 if(ret <= 0)
	   {ret= 0; goto ex;}
	 ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, dest, eff_dest, 2);
	 if(ret < 0)
	   {ret= 0; goto ex;}
	 ret= Xorriso_rename(xorriso, NULL, eff_origin, eff_dest, 0);
	 if(ret <= 0)
	   goto ex;
	 ret= 1;
	ex:;
	 Xorriso_free_meM(eff_origin);
	 Xorriso_free_meM(eff_dest);
	 return(ret);
	}
	
	 
	/* Command -msg_op */
	int Xorriso_option_msg_op(struct XorrisO *xorriso, char *what, char *arg,
	                          int flag)
	{
	 int ret, available, argc, pargc, i, pflag, max_words, input_lines, msd_mem;
	 char **argv= NULL, **pargv= NULL, *msg= "";
	 char *prefix, *separators;
	
	 msd_mem= xorriso->msg_sieve_disabled;
	
	 ret= 1;
	 if(strcmp(what, "parse") == 0 || strcmp(what, "parse_silently") == 0 ||
	    strcmp(what, "parse_bulk") == 0 ||
	    strcmp(what, "parse_bulk_silently") == 0) {
	   ret= Xorriso_parse_line(xorriso, arg, "", "", 5, &argc, &argv, 0);
	   prefix= "";
	   if(argc > 0) 
	     prefix= argv[0];
	   separators= "";
	   if(argc > 1)
	     separators= argv[1];
	   max_words= 0;
	   if(argc > 2)
	     sscanf(argv[2], "%d", &max_words);
	   pflag= 0;
	   if(argc > 3)
	     sscanf(argv[3], "%d", &pflag);
	   input_lines= 1;
	   if(argc > 4)
	     sscanf(argv[4], "%d", &input_lines);
	   if(strcmp(what, "parse") == 0 || strcmp(what, "parse_silently") == 0) {
	     ret= Xorriso_msg_op_parse(xorriso, "", prefix, separators,
	                               max_words, pflag, input_lines,
	                               (strcmp(what, "parse_silently") == 0));
	   } else {
	     ret= Xorriso_msg_op_parse_bulk(xorriso, prefix, separators,
	                               max_words, pflag, input_lines,
	                               (strcmp(what, "parse_bulk_silently") == 0));
	   }
	   if(ret <= 0)
	     goto ex;
	   xorriso->msg_sieve_disabled= msd_mem;
	   Xorriso__dispose_words(&argc, &argv);
	 } else if(strcmp(what, "start_sieve") == 0) {
	   Xorriso_sieve_dispose(xorriso, 0);
	   ret= Xorriso_sieve_big(xorriso, 0);
	   msg= "Message sieve enabled";
	
	/* >>> } else if(strcmp(what, "add_filter_rule") == 0) { */;
	
	 } else if(strcmp(what, "clear_sieve") == 0) {
	   ret= Xorriso_sieve_clear_results(xorriso, 0);
	   msg= "Recorded message sieve results disposed";
	 } else if(strcmp(what, "end_sieve") == 0) {
	   ret= Xorriso_sieve_dispose(xorriso, 0);
	   msg= "Message sieve disabled";
	 } else if(strcmp(what, "read_sieve") == 0) {
	   ret= Xorriso_sieve_get_result(xorriso, arg, &pargc, &pargv, &available, 0);
	   xorriso->msg_sieve_disabled= 1;
	   sprintf(xorriso->result_line, "%d\n", ret);
	   Xorriso_result(xorriso, 1);
	   if(ret > 0) {
	     sprintf(xorriso->result_line, "%d\n", pargc);
	     Xorriso_result(xorriso, 1);
	     for(i= 0; i < pargc; i++) {
	       ret= Sfile_count_char(pargv[i], '\n') + 1;
	       sprintf(xorriso->result_line, "%d\n", ret);
	       Xorriso_result(xorriso, 1);
	       Sfile_str(xorriso->result_line, pargv[i], 0);
	       strcat(xorriso->result_line, "\n");
	       Xorriso_result(xorriso, 1);
	     }
	   } else {
	     strcpy(xorriso->result_line, "0\n");
	     Xorriso_result(xorriso, 1);
	     available= 0;
	   }
	   sprintf(xorriso->result_line, "%d\n", available);
	   Xorriso_result(xorriso, 1);
	   xorriso->msg_sieve_disabled= msd_mem;
	   Xorriso__dispose_words(&pargc, &pargv);
	   ret= 1;
	 } else if(strcmp(what, "show_sieve") == 0) {
	   ret= Xorriso_sieve_get_result(xorriso, "", &pargc, &pargv, &available, 8);
	   xorriso->msg_sieve_disabled= 1;
	   sprintf(xorriso->result_line, "%d\n", ret);
	   Xorriso_result(xorriso, 1);
	   if(ret > 0) {
	     sprintf(xorriso->result_line, "%d\n", pargc);
	     Xorriso_result(xorriso, 1);
	     for(i= 0; i < pargc; i++) {
	       sprintf(xorriso->result_line, "%s\n", pargv[i]);
	       Xorriso_result(xorriso, 1);
	     }
	   }
	   xorriso->msg_sieve_disabled= msd_mem;
	   Xorriso__dispose_words(&pargc, &pargv);
	 } else if(strcmp(what, "compare_sev") == 0) {
	   ret= Xorriso_parse_line(xorriso, arg, "", ",", 2, &argc, &argv, 0);
	   if(argc < 2) {
	     sprintf(xorriso->info_text,
	             "-msg_op cmp_sev: malformed severity pair '%s'", arg);
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
	   } else {
	     ret= Xorriso__severity_cmp(argv[0], argv[1]);
	     sprintf(xorriso->result_line, "%d\n", ret);
	     Xorriso_result(xorriso, 1);
	   }
	   Xorriso__dispose_words(&argc, &argv);
	 } else if(strcmp(what, "list_sev") == 0) {
	   sprintf(xorriso->result_line, "%s\n", Xorriso__severity_list(0));
	   Xorriso_result(xorriso, 1);
	 } else {
	   sprintf(xorriso->info_text, "-msg_op: unknown operation '%s'", what);
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
	   ret= 0;
	 }
	 if(ret > 0 && msg[0])
	   Xorriso_msgs_submit(xorriso, 0, msg, 0, "NOTE", 0);
	
	ex:;
	 xorriso->msg_sieve_disabled= msd_mem;
	 return(ret);
	}
	
	
	/* Option -mv alias -mvi */
	int Xorriso_option_mvi(struct XorrisO *xorriso, int argc, char **argv,
	                      int *idx, int flag)
	{
	 int i, end_idx_dummy, ret, is_dir= 0, was_failure= 0, fret;
	 char *eff_origin= NULL, *eff_dest= NULL, *dest_dir= NULL;
	 char *leafname= NULL;
	 int optc= 0;
	 char **optv= NULL;
	
	 Xorriso_alloc_meM(eff_origin, char, SfileadrL);
	 Xorriso_alloc_meM(eff_dest, char, SfileadrL);
	 Xorriso_alloc_meM(dest_dir, char, SfileadrL);
	 Xorriso_alloc_meM(leafname, char, SfileadrL);
	
	 ret= Xorriso_cpmv_args(xorriso, "-mvi", argc, argv, idx,
	                        &optc, &optv, eff_dest, 0);
	 if(ret<=0)
	   goto ex;
	 if(ret==2) {
	   is_dir= 1;
	   strcpy(dest_dir, eff_dest);
	 }
	 /* Perform movements */
	 for(i= 0; i<optc; i++) {
	   ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi,optv[i],eff_origin,0);
	   if(ret<=0 || xorriso->request_to_abort)
	     goto problem_handler;
	   if(is_dir) {
	     ret= Sfile_leafname(eff_origin, leafname, 0);
	     if(ret<=0)
	       goto problem_handler;
	     strcpy(eff_dest, dest_dir);
	     ret= Sfile_add_to_path(eff_dest, leafname, 0);
	     if(ret<=0) {
	       sprintf(xorriso->info_text, "Effective path gets much too long (%d)",
	             (int) (strlen(eff_dest)+strlen(leafname)+1));
	       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	       goto problem_handler;
	     }
	   }
	   ret= Xorriso_rename(xorriso, NULL, eff_origin, eff_dest, 0);
	   if(ret<=0 || xorriso->request_to_abort)
	     goto problem_handler;
	   sprintf(xorriso->info_text, "Renamed in ISO image: ");
	   Text_shellsafe(eff_origin, xorriso->info_text, 1);
	   strcat(xorriso->info_text, " to ");
	   Text_shellsafe(eff_dest, xorriso->info_text, 1 | 2);
	   strcat(xorriso->info_text, "\n");
	   Xorriso_info(xorriso, 0);
	
	 continue; /* regular bottom of loop */
	problem_handler:;
	   was_failure= 1;
	   fret= Xorriso_eval_problem_status(xorriso, ret, 1|2);
	   if(fret>=0)
	 continue;
	   goto ex;
	 }
	 ret= !was_failure;
	ex:;
	 Xorriso_free_meM(eff_origin);
	 Xorriso_free_meM(eff_dest);
	 Xorriso_free_meM(dest_dir);
	 Xorriso_free_meM(leafname);
	 Xorriso_opt_args(xorriso, "-mvi",
	                  argc, argv, *idx, &end_idx_dummy, &optc, &optv, 256);
	 return(ret);
	}
	
	
	/* Option -named_pipe_loop */
	int Xorriso_option_named_pipe_loop(struct XorrisO *xorriso, char *mode,
	                                   char *stdin_pipe, char *stdout_pipe,
	                                   char *stderr_pipe, int flag)
	{
	 char *pipe_paths[3], *cpt, *npt;
	 int ret, hflag= 0, l;
	
	 npt= mode;
	 for(cpt= mode; npt != NULL; cpt= npt + 1) {
	   npt= strchr(cpt, ':');
	   if(npt==NULL)
	     l= strlen(cpt);
	   else
	     l= npt-cpt;
	   if(l==0) {
	     ;
	   } else if(strncmp(cpt, "-", l) == 0) {
	     ;
	   } else if(strncmp(cpt, "cleanup", l) == 0) {
	     hflag|= 1;
	   } else if(strncmp(cpt, "keep", l) == 0) {
	     hflag&= ~1;
	   } else if(strncmp(cpt, "buffered", l) == 0) {
	     hflag|= 2;
	   } else if(strncmp(cpt, "direct", l) == 0) {
	     hflag&= ~2;
	   } else { 
	     sprintf(xorriso->info_text, "-named_pipe_loop: unknown mode in '%s'",
	             mode);
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	     return(0);
	   }
	 }
	 pipe_paths[0]= stdin_pipe;
	 pipe_paths[1]= stdout_pipe;
	 pipe_paths[2]= stderr_pipe;
	 ret= Xorriso_named_pipe_loop(xorriso, pipe_paths, hflag);
	 return(ret);
	}
	
	
	/* Option -no_rc */
	int Xorriso_option_no_rc(struct XorrisO *xorriso, int flag)
	{
	 xorriso->no_rc= 1;
	 return(1);
	}
	
	
	/* Option -not_leaf , (-hide_disk_leaf , -as mkisofs -hide) */
	/* @param flag  bit0-bit5= hide rather than adding to disk_exclusions
	                  bit0= add to iso_rr_hidings
	                  bit1= add to joliet_hidings
	                  bit2= add to hfsplus_hidings
	*/
	int Xorriso_option_not_leaf(struct XorrisO *xorriso, char *pattern, int flag)
	{
	 regex_t re;
	 char *regexpr= NULL;
	 int ret= 0;
	
	 Xorriso_alloc_meM(regexpr, char, 2 * SfileadrL + 2);
	
	 if(pattern[0]==0)
	   {ret= 0; goto cannot_add;}
	 Xorriso__bourne_to_reg(pattern, regexpr, 0);
	 if(regcomp(&re, regexpr, 0)!=0)
	   {ret= 0; goto cannot_add;}
	 if(flag & 63) {
	   if(flag & 1) {
	     ret= Exclusions_add_not_leafs(xorriso->iso_rr_hidings, pattern, &re, 0);
	     if(ret<=0)
	       goto cannot_add;
	   }
	   if(flag & 2) {
	     ret= Exclusions_add_not_leafs(xorriso->joliet_hidings, pattern, &re, 0);
	     if(ret<=0)
	       goto cannot_add;
	   }
	   if(flag & 4) {
	     ret= Exclusions_add_not_leafs(xorriso->hfsplus_hidings, pattern, &re, 0);
	     if(ret<=0)
	       goto cannot_add;
	   }
	 } else {
	   ret= Exclusions_add_not_leafs(xorriso->disk_exclusions, pattern, &re, 0);
	 }
	 if(ret<=0) {
	cannot_add:;
	   sprintf(xorriso->info_text,"Cannot add pattern: %s ",
	           (flag & 3) ? "-hide_disk_leaf" : "-not_leaf");
	   Text_shellsafe(pattern, xorriso->info_text, 1);
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   goto ex;
	 }
	 ret= 1;
	ex:;
	 Xorriso_free_meM(regexpr);
	 return(ret);
	}
	
	
	/* Option -not_list , -quoted_not_list */
	/* @param flag bit0= -quoted_not_list */
	int Xorriso_option_not_list(struct XorrisO *xorriso, char *adr, int flag)
	{
	 int ret, linecount= 0, insertcount= 0, null= 0, argc= 0, i;
	 FILE *fp= NULL;
	 char **argv= NULL;
	 
	 Xorriso_pacifier_reset(xorriso, 0);
	 if(adr[0]==0) {
	   sprintf(xorriso->info_text, "Empty file name given with %s",
	           (flag & 1) ? "-quoted_not_list" : "-not_list");
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   return(0);
	 }
	 ret= Xorriso_afile_fopen(xorriso, adr, "rb", &fp, 0);
	 if(ret <= 0)
	   return(0);
	 while(1) {
	   ret= Xorriso_read_lines(xorriso, fp, &linecount, &argc, &argv,
	                           4 | (flag & 1) );
	   if(ret <= 0)
	     goto ex;
	   if(ret == 2)
	 break;
	   for(i= 0; i < argc; i++) {
	     if(argv[i][0] == 0)
	   continue;
	     if(strchr(argv[i], '/')!=NULL) {
	       null= 0;
	       ret= Xorriso_option_not_paths(xorriso, 1, argv + i, &null, 0);
	     } else
	       ret= Xorriso_option_not_leaf(xorriso, argv[i], 0);
	     if(ret<=0)
	       goto ex;
	     insertcount++;
	   }
	 }
	 ret= 1;
	ex:;
	 Xorriso_read_lines(xorriso, fp, &linecount, &argc, &argv, 2);
	 if(fp != NULL && fp != stdin)
	   fclose(fp);
	 if(ret<=0) {
	   sprintf(xorriso->info_text, "Aborted reading of file ");
	   Text_shellsafe(adr, xorriso->info_text, 1);
	   sprintf(xorriso->info_text + strlen(xorriso->info_text),
	           " in line number %d", linecount);
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	 }
	 sprintf(xorriso->info_text, "Added %d exclusion list items from file ",
	         insertcount);
	 Text_shellsafe(adr, xorriso->info_text, 1);
	 strcat(xorriso->info_text, "\n");
	 Xorriso_info(xorriso,0);
	 return(ret);
	}
	
	
	/* Option -not_mgt */
	int Xorriso_option_not_mgt(struct XorrisO *xorriso, char *setting, int flag)
	{
	 int ret;
	 char *what_data= NULL, *what, *what_next;
	
	 Xorriso_alloc_meM(what_data, char, SfileadrL);
	
	 if(Sfile_str(what_data, setting, 0)<=0) {
	   sprintf(xorriso->info_text,
	           "-not_mgt: setting string is much too long (%d)",
	           (int) strlen(setting));
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   {ret= 0; goto ex;}
	 } 
	 for(what= what_data; what!=NULL; what= what_next) {
	   what_next= strchr(what, ':');
	   if(what_next!=NULL) {
	     *what_next= 0;
	     what_next++;
	   }
	
	   if(strcmp(what, "reset")==0 || strcmp(what, "erase")==0) {
	     if(strcmp(what, "reset")==0)
	       xorriso->disk_excl_mode= 1;
	     Exclusions_destroy(&(xorriso->disk_exclusions), 0);
	     ret= Exclusions_new(&(xorriso->disk_exclusions), 0);
	     if(ret<=0) {
	       Xorriso_no_malloc_memory(xorriso, NULL, 0);
	       goto ex;
	     }
	   } else if(strcmp(what, "on")==0) {
	     xorriso->disk_excl_mode|= 1;
	   } else if(strcmp(what, "off")==0) {
	     xorriso->disk_excl_mode&= ~1;
	   } else if(strcmp(what, "param_on")==0) {
	     xorriso->disk_excl_mode|= 2;
	   } else if(strcmp(what, "param_off")==0) {
	     xorriso->disk_excl_mode&= ~2;
	   } else if(strcmp(what, "subtree_on")==0) {
	     xorriso->disk_excl_mode|= 4;
	   } else if(strcmp(what, "subtree_off")==0) {
	     xorriso->disk_excl_mode&= ~4;
	   } else if(strcmp(what, "ignore_on")==0) {
	     xorriso->disk_excl_mode|= 8;
	   } else if(strcmp(what, "ignore_off")==0) {
	     xorriso->disk_excl_mode&= ~8;
	   } else {
	     sprintf(xorriso->info_text, "-not_mgt: unknown setting '%s'", what);
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	     {ret= 0; goto ex;}
	   }
	 }
	 ret= 1;
	ex:;
	 Xorriso_free_meM(what_data);
	 return(ret);
	}
	
	
	/* Option -not_paths , (-hide_disk_paths , -as mkisofs -hide) */
	/* @param flag  bit0= add to iso_rr_hidings rather than disk_exclusions
	                bit1= add to joliet_hidings rather than disk_exclusions
	                bit2= enable disk pattern expansion regardless of -disk_pattern
	                bit8-13= consolidated hide state bits, duplicating bit0-1
	                   bit8= add to iso_rr_hidings
	                   bit9= add to joliet_hidings
	                  bit10= add to hfsplus_hidings
	*/
	int Xorriso_option_not_paths(struct XorrisO *xorriso, int argc, char **argv,
	                             int *idx, int flag)
	{
	 int ret, end_idx, num_descr= 0, dummy, optc= 0, i;
	 char **descr= NULL, **optv= NULL, *eff_path= NULL, *hpt= NULL;
	
	 end_idx= Xorriso_end_idx(xorriso, argc, argv, *idx,
	                          (xorriso->do_disk_pattern == 1 || (flag & 4)) | 2);
	 if(end_idx<=0)
	   {ret= end_idx; goto ex;}
	
	 num_descr= end_idx - *idx;
	 if(num_descr<=0)
	   {ret= 1; goto ex;}
	 
	 /* produce absolute patterns */
	 Xorriso_alloc_meM(eff_path, char, SfileadrL);
	 descr= TSOB_FELD(char *, num_descr);
	 if(descr==NULL) {
	no_memory:;
	   Xorriso_no_pattern_memory(xorriso, sizeof(char *) * (off_t) num_descr, 0);
	   ret= -1; goto ex;
	 }
	 for(i= 0; i<num_descr; i++)
	   descr[i]= NULL;
	 for(i= 0; i<num_descr; i++) {
	   ret= Xorriso_normalize_img_path(xorriso, xorriso->wdx, argv[i+*idx],
	                                   eff_path, 2|4);
	   if(ret<=0)
	     goto ex;
	   descr[i]= strdup(eff_path); 
	   if(descr[i]==NULL)
	     goto no_memory;
	 }
	
	 ret= Xorriso_opt_args(xorriso,
	                       (flag & 0x3f03) ? "-hide_disk_paths" : "-not_paths",
	                       num_descr, descr, 0, &dummy, &optc, &optv,
	                       2 | ((flag & 4) << 7));
	 if(ret<=0)
	   goto ex; 
	 if(flag & 0x3f03) {
	   if(flag & 0x0101) {
	     ret= Exclusions_add_not_paths(xorriso->iso_rr_hidings,
	                                   num_descr, descr, optc, optv, 0);
	     if(ret<=0) {
	no_hide:;
	       sprintf(xorriso->info_text, "Cannot add path list: -hide_disk_paths ");
	       hpt= Xorriso__hide_mode_text(flag & 0x3f03, 0);
	       if(hpt != NULL)
	         sprintf(xorriso->info_text + strlen(xorriso->info_text), "%s ", hpt);
	       Xorriso_free_meM(hpt);
	       Text_shellsafe(argv[*idx], xorriso->info_text, 1);
	       strcat(xorriso->info_text, num_descr > 1 ? " ... " : " ");
	       strcat(xorriso->info_text, xorriso->list_delimiter);
	       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	       goto ex;
	     }
	   }
	   if(flag & 0x0202) {
	     ret= Exclusions_add_not_paths(xorriso->joliet_hidings,
	                                   num_descr, descr, optc, optv, 0);
	     if(ret<=0)
	       goto no_hide;
	   }
	   if(flag & 0x0400) {
	     ret= Exclusions_add_not_paths(xorriso->hfsplus_hidings,
	                                   num_descr, descr, optc, optv, 0);
	     if(ret<=0)
	       goto no_hide;
	   }
	 } else {
	   ret= Exclusions_add_not_paths(xorriso->disk_exclusions,
	                                 num_descr, descr, optc, optv, 0);
	   if(ret<=0) {
	     sprintf(xorriso->info_text,"Cannot add path list: -not_paths ");
	     Text_shellsafe(argv[*idx], xorriso->info_text, 1);
	     strcat(xorriso->info_text, num_descr > 1 ? " ... " : " ");
	     strcat(xorriso->info_text, xorriso->list_delimiter);
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   }
	 }
	ex:;
	 (*idx)= end_idx;
	 Xorriso_opt_args(xorriso, "-not_paths",
	                  num_descr, descr, 0, &dummy, &optc, &optv, 256);
	 if(descr!=NULL) {
	   for(i= 0; i<num_descr; i++)
	     if(descr[i]!=NULL)
	       free(descr[i]);
	   free((char *) descr);
	   descr= NULL;
	 }
	 Xorriso_free_meM(eff_path);
	 return(ret);
	}
	
	
	/* Option -options_from_file */
	int Xorriso_option_options_from_file(struct XorrisO *xorriso, char *adr,
	                                     int flag)
	/*
	 bit0= called from Xorriso_prescan_args,
	       therefore execute via that same function
	*/
	/*
	return:
	 <=0 error , 1 = success , 3 = end program run
	*/
	{
	 int ret,linecount= 0, argc= 0, was_failure= 0, fret;
	 FILE *fp= NULL;
	 char **argv= NULL;
	 int linec= 0;
	 char *line= NULL, **linev= NULL;
	
	 if(adr[0]==0) {
	   sprintf(xorriso->info_text,"Empty file name given with -options_from_file");
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
	   return(0);
	 }
	 if(xorriso->is_dialog) {
	   sprintf(xorriso->info_text,"+ performing command lines from file ");
	   Text_shellsafe(adr, xorriso->info_text, 1);
	   strcat(xorriso->info_text, " :\n");
	   Xorriso_info(xorriso,1);
	 }
	 ret= Xorriso_afile_fopen(xorriso, adr, "rb", &fp, 0);
	 if(ret <= 0)
	   return(0);
	 sprintf(xorriso->info_text, "Command file:  ");
	 Text_shellsafe(adr, xorriso->info_text, 1);
	 Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
	 while(1) {
	   ret= Xorriso_read_lines(xorriso, fp, &linecount, &linec, &linev, 1 | 8);
	   if(ret <= 0)
	     goto ex; /* no problem_handler because there is no sense in going on */
	   if(ret == 2)
	 break;
	   line= linev[0];
	   if(line[0]==0 || line[0]=='#')
	 continue;
	
	   if(flag&1) {
	     ret= Sfile_make_argv(xorriso->progname, line, &argc, &argv,
	                          4 | 8 | ((xorriso->bsl_interpretation & 3) << 5));
	     if(ret<=0)
	       goto problem_handler;
	     ret= Xorriso_prescan_args(xorriso,argc,argv,1);
	     if(ret==0)
	       {ret= 3; goto ex;}
	     if(ret<0)
	       goto problem_handler;
	   } else {
	     if(xorriso->is_dialog) {
	       sprintf(xorriso->info_text,"+ %d:  %s\n",linecount,line);
	       Xorriso_info(xorriso,1);
	     }
	     ret= Xorriso_execute_option(xorriso,line,1|(1<<16));
	     if(ret==3)
	       goto ex;
	     if(ret<=0)
	       goto problem_handler;
	   }
	
	 continue; /* regular bottom of loop */
	problem_handler:;
	   was_failure= 1;
	   fret= Xorriso_eval_problem_status(xorriso, ret, 1);
	   if(fret>=0)
	 continue;
	   goto ex;
	 }

(1) Event start:

Starting defect path here.

	 ret= 1;
	ex:;
	 Sfile_make_argv("", "", &argc, &argv, 2); /* release memory */

(2) Event alloc_arg:	"Xorriso_read_lines" allocates memory that is stored into "linev". [details]
Also see events:	[leaked_storage]

	 Xorriso_read_lines(xorriso, fp, &linecount, &linec, &linev, 2);
	 Xorriso_reset_counters(xorriso,0);

(3) Event cond_true:	Condition "fp != NULL", taking true branch.
(4) Event cond_true:	Condition "fp != stdin", taking true branch.

	 if(fp != NULL && fp != stdin)
	   fclose(fp);

(5) Event cond_false:

Condition "ret <= 0", taking false branch.

	 if(ret<=0) {
	   sprintf(xorriso->info_text,
	           "error triggered by line %d of file:\n    ", linecount);
	   Text_shellsafe(adr, xorriso->info_text, 1);
	   strcat(xorriso->info_text, "\n");
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 1);

(6) Event if_end:

End of if statement.

	 }
	 sprintf(xorriso->info_text, "Command file end:  ");
	 Text_shellsafe(adr, xorriso->info_text, 1);
	 Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);

(7) Event cond_false:

Condition "ret != 1", taking false branch.

	 if(ret!=1)

(8) Event if_end:

End of if statement.

	   return(ret);

(9) Event cond_true:	Condition "!was_failure", taking true branch.
(10) Event leaked_storage:	Variable "linev" going out of scope leaks the storage it points to.
Also see events:	[alloc_arg]

	 return(!was_failure);
	}
	
	
	/* Option -osirrox "on"|"off" */
	int Xorriso_option_osirrox(struct XorrisO *xorriso, char *mode, int flag)
	{
	 int l, allow_restore;
	 char *npt, *cpt;
	
	 allow_restore= xorriso->allow_restore;
	
	 npt= cpt= mode;
	 for(cpt= mode; npt!=NULL; cpt= npt+1) {
	   npt= strchr(cpt,':');
	   if(npt==NULL)
	     l= strlen(cpt);
	   else
	     l= npt-cpt;
	   if(l==0 && mode[0]!=0)
	     goto unknown_mode;
	   if(strncmp(cpt, "off", l)==0 && l >= 3)
	     allow_restore= 0;
	   else if(strncmp(cpt, "banned", l)==0 && l >= 5)
	     allow_restore= -1;
	   else if(strncmp(cpt, "blocked", l)==0 && l >= 7)
	     allow_restore= -2;
	   else if(strncmp(cpt, "unblock", l)==0 && l >= 7) {
	     if(xorriso->allow_restore == -2)
	       xorriso->allow_restore= 0;
	     allow_restore= 1;
	   } else if(strncmp(cpt, "device_files", l)==0 && l >= 12)
	     allow_restore= 2;
	   else if((strncmp(cpt, "on", l)==0 && l >= 2) || mode[0]==0)
	     allow_restore= 1;
	   else if(strncmp(cpt, "concat_split_on", l)==0 && l >= 15)
	     xorriso->do_concat_split= 1;
	   else if(strncmp(cpt, "concat_split_off", l)==0 && l >= 16)
	     xorriso->do_concat_split= 0;
	   else if(strncmp(cpt, "auto_chmod_on", l)==0 && l >= 13)
	     xorriso->do_auto_chmod= 1;
	   else if(strncmp(cpt, "auto_chmod_off", l)==0 && l >= 14)
	     xorriso->do_auto_chmod= 0;
	   else if(strncmp(cpt, "sort_lba_on", l)==0 && l >= 11)
	     xorriso->do_restore_sort_lba= 1;
	   else if(strncmp(cpt, "sort_lba_off", l)==0 && l >= 12)
	     xorriso->do_restore_sort_lba= 0;
	   else if(strncmp(cpt, "o_excl_on", l)==0 && l >= 9)
	     xorriso->drives_exclusive= 1;
	   else if(strncmp(cpt, "o_excl_off", l)==0 && l >= 10)
	     xorriso->drives_exclusive= 0;
	   else if(strncmp(cpt, "strict_acl_on", l)==0 && l >= 13)
	     xorriso->do_strict_acl|= 1;
	   else if(strncmp(cpt, "strict_acl_off", l)==0 && l >= 14)
	     xorriso->do_strict_acl&= ~1;
	   else {
	unknown_mode:;
	     sprintf(xorriso->info_text, "-osirrox: unknown mode '%s'", cpt);
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	     return(0);
	   }
	 }
	 if(allow_restore > 0 && xorriso->allow_restore == -1) {
	   sprintf(xorriso->info_text,
	     "-osirrox: was already permanently disabled by setting 'banned'");
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   return(0);
	 }
	 if(allow_restore > 0 && xorriso->allow_restore == -2) {
	   sprintf(xorriso->info_text,
	           "-osirrox: is currently disabled by setting 'blocked'");
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   return(0);
	 }
	 if(xorriso->allow_restore != -1)
	   xorriso->allow_restore= allow_restore;
	 sprintf(xorriso->info_text,
	         "Copying of file objects from ISO image to disk filesystem is: %s\n",
	         xorriso->allow_restore > 0 ? "Enabled" : "Disabled");
	 Xorriso_info(xorriso, 0);
	 return(1);
	}
	
	
	/* Option -overwrite "on"|"nondir"|"off" */
	int Xorriso_option_overwrite(struct XorrisO *xorriso, char *mode, int flag)
	{
	 if(strcmp(mode, "off")==0)
	   xorriso->do_overwrite= 0;
	 else if(strcmp(mode, "on")==0)
	   xorriso->do_overwrite= 1;
	 else if(strcmp(mode, "nondir")==0)
	   xorriso->do_overwrite= 2;
	 else {
	   sprintf(xorriso->info_text, "-overwrite: unknown mode '%s'", mode);
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   return(0);
	 }
	 return(1);
	}
	
	
	

	
	/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
	
	   Copyright 2007-2015 Thomas Schmitt, <address@hidden>
	
	   Provided under GPL version 2 or later.
	
	   This file contains the implementation of options as mentioned in man page
	   or info file derived from xorriso.texi.
	*/
	
	#ifdef HAVE_CONFIG_H
	#include "../config.h"
	#endif
	
	#include <ctype.h>
	#include <sys/types.h>
	#include <unistd.h>
	#include <stdlib.h>
	#include <stdio.h>
	#include <string.h>
	#include <sys/stat.h>
	#include <sys/time.h>
	#include <time.h>
	#include <errno.h>
	
	#include "xorriso.h"
	#include "xorriso_private.h"
	#include "xorrisoburn.h"
	
	
	/* Option -iso_rr_pattern "on"|"ls"|"off" */
	int Xorriso_option_iso_rr_pattern(struct XorrisO *xorriso, char *mode,int flag)
	{
	 if(strcmp(mode, "off")==0)
	   xorriso->do_iso_rr_pattern= 0;
	 else if(strcmp(mode, "on")==0)
	   xorriso->do_iso_rr_pattern= 1;
	 else if(strcmp(mode, "ls")==0)
	   xorriso->do_iso_rr_pattern= 2;
	 else {
	   sprintf(xorriso->info_text, "-iso_rr_pattern: unknown mode '%s'", mode);
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   return(0);
	 }
	 return(1);
	}
	
	
	/* Option -jigdo aspect argument */
	int Xorriso_option_jigdo(struct XorrisO *xorriso, char *aspect, char *arg,
	                         int flag)
	{
	 int ret;
	
	 ret= Xorriso_jigdo_interpreter(xorriso, aspect, arg, 0);
	 return(ret);
	}
	
	
	/* Option -joliet "on"|"off" */
	int Xorriso_option_joliet(struct XorrisO *xorriso, char *mode, int flag)
	{
	 if(strcmp(mode, "off")==0)
	   xorriso->do_joliet= 0;
	 else if(strcmp(mode, "on")==0)
	   xorriso->do_joliet= 1;
	 else {
	   sprintf(xorriso->info_text, "-joliet: unknown mode '%s'", mode);
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   return(0);
	 }
	 return(1);
	}
	
	
	/* Command -launch_frontend */
	int Xorriso_option_launch_frontend(struct XorrisO *xorriso,
	                                   int argc, char **argv, int *idx, int flag)
	{
	 int ret, end_idx;
	
	 end_idx= Xorriso_end_idx(xorriso, argc, argv, *idx, 1);
	
	 if(xorriso->launch_frontend_banned) {
	   sprintf(xorriso->info_text,
	           "-launch_frontend was already executed in this xorriso run");
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
	   ret= 0; goto ex;
	 }
	 xorriso->launch_frontend_banned= 1;
	 if(end_idx <= *idx)
	   {ret= 1; goto ex;}
	 if(argv[*idx][0] == 0)
	   {ret= 1; goto ex;}
	 xorriso->dialog= 2;
	 ret= Xorriso_launch_frontend(xorriso, end_idx - *idx, argv + *idx,
	                              "", "", 0);
	ex:;
	 (*idx)= end_idx;
	 return(ret);
	}
	
	
	/* Option -list_arg_sorting */
	int Xorriso_option_list_arg_sorting(struct XorrisO *xorriso, int flag)
	{
	 int ret;
	
	 ret= Xorriso_cmd_sorting_rank(xorriso, 0, NULL, 0, 1);
	 return(ret);
	}
	
	
	/* Option -list_delimiter */
	int Xorriso_option_list_delimiter(struct XorrisO *xorriso, char *text,
	                                  int flag)
	{
	 int ret, argc;
	 char **argv= NULL;
	
	 if(text[0] == 0) {
	   sprintf(xorriso->info_text,
	           "-list_delimiter: New delimiter text is empty");
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   return(0);
	 }
	 if(strlen(text) > 80) {
	   sprintf(xorriso->info_text,
	           "-list_delimiter: New delimiter text is too long");
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   return(0);
	 }
	 ret= Sfile_make_argv(xorriso->progname, text, &argc, &argv, 4);
	 if(ret > 0) {
	   if(argc > 2) {
	     sprintf(xorriso->info_text,
	            "-list_delimiter: New delimiter text contains more than one word");
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   }
	   Sfile_make_argv(xorriso->progname, text, &argc, &argv, 2);
	   if(argc > 2)
	     return(0);
	 }
	 if(strchr(text, '"') != NULL || strchr(text, '\'') != NULL) {
	   sprintf(xorriso->info_text,
	           "-list_delimiter: New delimiter text contains quotation marks");
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   return(0);
	 }
	 strcpy(xorriso->list_delimiter, text);
	 return(1);
	}
	
	
	/* Option -list_extras */
	int Xorriso_option_list_extras(struct XorrisO *xorriso, char *mode, int flag)
	{
	 int ret;
	
	 ret= Xorriso_list_extras(xorriso, mode, 0);
	 return(ret);
	}
	
	
	/* Option -list_formats */
	int Xorriso_option_list_formats(struct XorrisO *xorriso, int flag)
	{
	 int ret;
	
	 ret= Xorriso_list_formats(xorriso, 0);
	 return(ret);
	}
	
	
	/* Option -list_speeds */
	int Xorriso_option_list_speeds(struct XorrisO *xorriso, int flag)
	{
	 int ret;
	
	 ret= Xorriso_list_speeds(xorriso, 0);
	 return(ret);
	}
	
	
	/* Option -list_profiles */
	int Xorriso_option_list_profiles(struct XorrisO *xorriso, char *which,
	                                 int flag)
	{
	 int ret;
	 int mode= 0;
	
	 if(strncmp(which,"in",2)==0)
	   mode|= 1;
	 else if(strncmp(which,"out",3)==0)
	   mode|= 2;
	 else
	   mode|= 3;
	 if(mode & 1) {
	   ret= Xorriso_toc(xorriso, 1 | 16 | 32);
	   if(ret > 0)
	     Xorriso_list_profiles(xorriso, 0);
	 }
	 if((mode & 2) && xorriso->in_drive_handle != xorriso->out_drive_handle) {
	   ret= Xorriso_toc(xorriso, 1 | 2 | 16 | 32);
	   if(ret > 0)
	     Xorriso_list_profiles(xorriso, 2);
	 }
	 return(1);
	}
	
	
	/* Command -lns alias -lnsi */
	int Xorriso_option_lnsi(struct XorrisO *xorriso, char *target, char *path,
	                        int flag)
	{
	 int ret;
	 char *eff_path= NULL, *buffer= NULL, *namept;
	
	 Xorriso_alloc_meM(eff_path, char, SfileadrL);
	 Xorriso_alloc_meM(buffer, char, SfileadrL);
	
	 ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, path, eff_path, 1);
	 if(ret < 0)
	   {ret= 0; goto ex;}
	 if(ret > 0) { 
	   sprintf(xorriso->info_text, "-lns: Address already existing: ");
	   Text_shellsafe(eff_path, xorriso->info_text, 1);
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   {ret= 0; goto ex;}
	 } 
	 ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, path, eff_path, 2);
	 if(ret < 0)
	   {ret= 0; goto ex;}
	 ret= Xorriso_truncate_path_comps(xorriso, target, buffer, &namept, 0);
	 if(ret < 0)
	   {ret= 0; goto ex;}
	 ret= Xorriso_graft_in(xorriso, NULL, namept, eff_path, (off_t) 0, (off_t) 0,
	                       1024);
	 if(ret <= 0)
	   {ret= 0; goto ex;}
	 ret= 1;
	ex:;
	 Xorriso_free_meM(buffer);
	 Xorriso_free_meM(eff_path);
	 return(ret);
	}
	
	
	/* Option -load session|track|sbsector value */
	/* @param flag bit0= with adr_mode sbsector: adr_value is possibly 16 too high
	   @return <=0 error , 1 success, 2 revoked by -reassure
	*/
	int Xorriso_option_load(struct XorrisO *xorriso, char *adr_mode,
	                          char *adr_value, int flag)
	{
	 int ret;
	
	 if(Xorriso_change_is_pending(xorriso, 0)) {
	   sprintf(xorriso->info_text,
	           "-load: Image changes pending. -commit or -rollback first");
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   return(0);
	 }
	 ret= Xorriso_reassure(xorriso, "-load", "loads an alternative image", 0);
	 if(ret<=0)
	   return(2);
	 ret= Xorriso_decode_load_adr(xorriso, "-load", adr_mode, adr_value,
	                              &(xorriso->image_start_mode),
	                              xorriso->image_start_value, flag & 1);
	 if(ret <= 0)
	   return(ret);
	 xorriso->image_start_mode|= (1<<30); /* enable non-default msc1 processing */
	 if(strlen(xorriso->indev)>0) {
	   ret= Xorriso_option_rollback(xorriso, 1); /* Load image, no -reassure */
	   if(ret<=0)
	     return(ret);
	 }
	 return(1);
	}
	
	
	/* Option -logfile */
	int Xorriso_option_logfile(struct XorrisO *xorriso, char *channel,
	                                                      char *fileadr, int flag)
	{
	 int hflag,channel_no= 0, ret;
	   
	 if(channel[0]==0) {
	logfile_wrong_form:;
	   sprintf(xorriso->info_text,"Wrong form. Correct would be: -logfile \".\"|\"R\"|\"I\"|\"M\" file_address");
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
	   return(0);
	 }
	 hflag= 2;
	 if(channel[0]=='R')
	   channel_no= 1;
	 else if(channel[0]=='I')
	   channel_no= 2;
	 else if(channel[0]=='M')
	   channel_no= 3;
	 else if(channel[0]=='.')
	   hflag= 4;
	 else
	   goto logfile_wrong_form;
	 if(strcmp(fileadr,"-")==0 || fileadr[0]==0)
	     hflag|= (1<<15);
	 xorriso->logfile[channel_no][0]= 0;
	 ret= Xorriso_write_to_channel(xorriso, fileadr, channel_no, hflag);
	 if(ret<=0) {
	   sprintf(xorriso->info_text, "Cannot open logfile:  %s", fileadr);
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
	 } else if(!(hflag&(1<<15)))
	   if(Sfile_str(xorriso->logfile[channel_no], fileadr, 0)<=0)
	     return(-1);
	 return(ret>0);
	}
	
	
	/* Options -ls  alias -lsi   and -lsl  alias -lsli
	       and -lsd alias -lsdi  and -lsdl alias -lsdli
	       and -du  alias -dui   and -dus  alias -dusi
	   @param flag bit0= long format (-lsl , -du, not -dus, not -ls)
	               bit1= do not expand patterns but use literally
	               bit2= -du rather than -ls
	               bit3= list directories as themselves (-lsd) 
	*/
	int Xorriso_option_lsi(struct XorrisO *xorriso, int argc, char **argv,
	                      int *idx, int flag)
	{
	 int ret, end_idx, filec= 0, nump, i, star= 1;
	 char **filev= NULL, **patterns= NULL;
	 off_t mem= 0;
	 struct stat stbuf;
	
	 if(flag & 4) {
	   if(!(flag & 1))
	     star= 0;
	 } else {
	   if(flag & 8)
	     star= 0;
	 }
	
	 end_idx= Xorriso_end_idx(xorriso, argc, argv, *idx, 1);
	 if(xorriso->do_iso_rr_pattern==0)
	   flag|= 2;
	
	 nump= end_idx - *idx;
	 if((flag&2) && nump>0 ) {
	   ;
	 } else if(nump <= 0) {
	   if(Xorriso_iso_lstat(xorriso, xorriso->wdi, &stbuf, 0)<0) {
	     sprintf(xorriso->info_text,
	             "Current -cd path does not yet exist in the ISO image");
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
	     {ret= 0; goto ex;}
	   }
	   if(!S_ISDIR(stbuf.st_mode)) {
	     sprintf(xorriso->info_text,
	             "Current -cd meanwhile points to a non-directory in ISO image");
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
	     {ret= 0; goto ex;}
	   }
	   patterns= calloc(1, sizeof(char *));
	   if(patterns == NULL) {
	no_memory:;
	     sprintf(xorriso->info_text,
	             "Cannot allocate enough memory for pattern expansion");
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
	     {ret= -1; goto ex;}
	   }
	   nump= 1;
	   if(star)
	     patterns[0]= "*";
	   else 
	     patterns[0]= ".";
	   flag&= ~2;
	 } else {
	   patterns= calloc(nump, sizeof(char *));
	   if(patterns==NULL)
	     goto no_memory;
	   for(i= 0; i<nump; i++) {
	     if(argv[i + *idx][0]==0) {
	       if(star)
	         patterns[i]= "*";
	       else
	         patterns[i]= ".";
	     } else
	       patterns[i]= argv[i + *idx];
	   }
	 }
	
	 if((flag & 1) && !(xorriso->ino_behavior & 32)) {
	   ret= Xorriso_make_hln_array(xorriso, 0); /* for stbuf.st_nlink */
	   if(ret < 0)
	     goto ex;
	 }
	 if(flag&2) {
	   ret= Xorriso_ls_filev(xorriso, xorriso->wdi, nump, argv + (*idx), mem,
	                         flag&(1|4|8)); 
	 } else if(nump==1 && strcmp(patterns[0],"*")==0 && !(flag&4)){
	   /* save temporary memory by calling simpler function */
	   ret= Xorriso_ls(xorriso, (flag&1)|4);
	 } else {
	   ret= Xorriso_expand_pattern(xorriso, nump, patterns, 0, &filec, &filev,
	                               &mem, 0);
	   if(ret<=0)
	     {ret= 0; goto ex;}
	   ret= Xorriso_ls_filev(xorriso, xorriso->wdi, filec, filev, mem,
	                         flag&(1|4|8)); 
	 }
	 if(ret<=0)
	   {ret= 0; goto ex;}
	
	 ret= 1;
	ex:;
	 if(patterns!=NULL)
	   free((char *) patterns);
	 Sfile_destroy_argv(&filec, &filev, 0);
	 (*idx)= end_idx;
	 return(ret);
	}
	
	
	/* Options -lsx, -lslx, -lsdx , -lsdlx , -dux , -dusx
	   @param flag bit0= long format (-lslx , -dux)
	               bit1= do not expand patterns but use literally
	               bit2= du rather than ls
	               bit3= list directories as themselves (ls -d) 
	*/
	int Xorriso_option_lsx(struct XorrisO *xorriso, int argc, char **argv,
	                      int *idx, int flag)
	{
	 int ret, end_idx, filec= 0, nump, i;
	 char **filev= NULL, **patterns= NULL;
	 off_t mem= 0;
	
	 end_idx= Xorriso_end_idx(xorriso, argc, argv, *idx, 1|2);
	 if(xorriso->do_disk_pattern==0)
	   flag|= 2;
	
	 nump= end_idx - *idx;
	 if((flag&2) && nump>0) {
	   ;
	 } else if(nump <= 0) {
	   patterns= calloc(1, sizeof(char *));
	   if(patterns == NULL) {
	no_memory:;
	     sprintf(xorriso->info_text,
	             "Cannot allocate enough memory for pattern expansion");
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
	     {ret= -1; goto ex;}
	   }
	   nump= 1;
	   if(flag&8)
	     patterns[0]= ".";
	   else
	     patterns[0]= "*";
	   flag&= ~2;
	 } else {
	   patterns= calloc(nump, sizeof(char *));
	   if(patterns==NULL)
	     goto no_memory;
	   for(i= 0; i<nump; i++) {
	     if(argv[i + *idx][0]==0)
	       patterns[i]= "*";
	     else
	       patterns[i]= argv[i + *idx];
	   }
	 }
	 if(flag&2) {
	   ret= Xorriso_lsx_filev(xorriso, xorriso->wdx,
	                          nump, argv + (*idx), mem, flag&(1|4|8)); 
	
	#ifdef Not_yeT
	 } else if(nump==1 && strcmp(patterns[0],"*")==0 && !(flag&4)){
	   /* save temporary memory by calling simpler function */
	   ret= Xorriso_ls(xorriso, (flag&1)|4);
	#endif
	
	 } else {
	   ret= Xorriso_expand_disk_pattern(xorriso, nump, patterns, 0, &filec, &filev,
	                                    &mem, 0);
	   if(ret<=0)
	     {ret= 0; goto ex;}
	   ret= Xorriso_lsx_filev(xorriso, xorriso->wdx, filec, filev, mem,
	                          flag&(1|4|8)); 
	 }
	 if(ret<=0)
	   {ret= 0; goto ex;}
	
	 ret= 1;
	ex:;
	 if(patterns!=NULL)
	   free((char *) patterns);
	 Sfile_destroy_argv(&filec, &filev, 0);
	 (*idx)= end_idx;
	 return(ret);
	}
	
	
	/* Option -map , -map_single */
	/* @param flag bit0=do not report the added item
	               bit1=do not reset pacifier, no final pacifier message
	               bit5= -map_single: do not insert directory tree
	*/
	int Xorriso_option_map(struct XorrisO *xorriso, char *disk_path,
	                       char *iso_path, int flag)
	{
	 int ret;
	 char *eff_origin= NULL, *eff_dest= NULL, *ipth;
	
	 Xorriso_alloc_meM(eff_origin, char, SfileadrL);
	 Xorriso_alloc_meM(eff_dest, char, SfileadrL);
	
	 if(!(flag&2))
	   Xorriso_pacifier_reset(xorriso, 0);
	
	 ipth= iso_path;
	 if(ipth[0]==0)
	   ipth= disk_path;
	 if(disk_path[0]==0) {
	   sprintf(xorriso->info_text, "-map: Empty disk_path given");
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 1);
	   {ret= 0; goto ex;}
	 }
	 ret= Xorriso_normalize_img_path(xorriso, xorriso->wdx, disk_path, eff_origin,
	                                 2|4);
	 if(ret<=0)
	   goto ex;
	 ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, ipth, eff_dest, 2);
	 if(ret<=0)
	   goto ex;
	 ret= Xorriso_graft_in(xorriso, NULL, eff_origin, eff_dest,
	                       (off_t) 0, (off_t) 0, 2|(flag&32));
	 if(!(flag&2))
	   Xorriso_pacifier_callback(xorriso, "files added", xorriso->pacifier_count,
	                             xorriso->pacifier_total, "", 1);
	 if(ret<=0)
	   goto ex;
	
	 if(!(flag&1)) {
	   sprintf(xorriso->info_text, "Added to ISO image: %s '%s'='%s'\n",
	           (ret>1 ? "directory" : "file"), (eff_dest[0] ? eff_dest : "/"),
	           eff_origin);
	   Xorriso_info(xorriso,0);
	 }
	 ret= 1;
	ex:;
	 Xorriso_free_meM(eff_origin);
	 Xorriso_free_meM(eff_dest);
	 return(ret);
	}
	
	
	/* Command -map_l , -compare_l , -update_l , -extract_l , -update_lxi ,
	           -update_li
	*/
	/* @param flag bit4= do not establish and dispose xorriso->di_array
	                     for update_l
	               bit8-11= mode 0= -map_l
	                             1= -compare_l
	                             2= -update_l
	                             3= -extract_l
	                             4= -update_lxi
	                             5= -update_li
	*/
	int Xorriso_option_map_l(struct XorrisO *xorriso, int argc, char **argv,
	                         int *idx, int flag)
	{
	 int ret, end_idx, optc= 0, was_failure= 1, i, j, fret, mode, problem_count;
	 int ns_flag= 2|4, nt_flag= 2, opt_args_flag= 2, arg2c= 0, opt2c= 0;
	 int new_opt2c;
	 char *source_prefix= NULL, *target_prefix= NULL, *cmd, **optv= NULL;
	 char *eff_source= NULL, *eff_target= NULL, *s_wd, *t_wd;
	 char **eff_src_array= NULL, **eff_tgt_array= NULL, **opt2v= NULL;
	 char **arg2v= NULL;
	
	 cmd= "-map_l";
	 s_wd= xorriso->wdx;
	 t_wd= xorriso->wdi;
	 Xorriso_pacifier_reset(xorriso, 0);
	 mode= (flag>>8) & 15;
	
	 if(mode==1)
	   cmd= "-compare_l";
	 else if(mode==2)
	   cmd= "-update_l";
	 else if(mode == 3 || mode == 5) {
	   if(mode == 5)
	     cmd= "-update_li";
	   else
	     cmd= "-extract_l";
	   ns_flag= 2;
	   s_wd= xorriso->wdi;
	   nt_flag= 2|4;
	   t_wd= xorriso->wdx;
	   opt_args_flag= 0;
	 } else if(mode == 4) {
	   cmd= "-update_lxi";
	 }
	
	 end_idx= Xorriso_end_idx(xorriso, argc, argv, *idx, 1|2);
	 if(end_idx - (*idx) < 3) {
	   sprintf(xorriso->info_text, "%s: Not enough arguments given (%d < 3)", cmd,
	           end_idx - (*idx));
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 1);
	   ret= 0; goto ex;
	 }
	
	 Xorriso_alloc_meM(source_prefix, char, SfileadrL);
	 Xorriso_alloc_meM(target_prefix, char, SfileadrL);
	 Xorriso_alloc_meM(eff_source, char, SfileadrL);
	 Xorriso_alloc_meM(eff_target, char, SfileadrL);
	
	 ret= Xorriso_normalize_img_path(xorriso, s_wd, argv[*idx],
	                                 source_prefix, ns_flag | 64);
	 if(ret<=0)
	   goto ex;
	 ret= Xorriso_normalize_img_path(xorriso, t_wd, argv[(*idx)+1],
	                                 target_prefix, nt_flag);
	 if(ret<=0)
	   goto ex;
	 ret= Xorriso_opt_args(xorriso, cmd, argc, argv, (*idx)+2, &end_idx,
	                       &optc, &optv, opt_args_flag);
	 if(ret<=0)
	   goto ex;
	 if(mode == 4) {
	   /* Convert pattern from disk to iso_rr */
	   arg2c= end_idx - *idx - 2;
	   Xorriso_alloc_meM(arg2v, char *, arg2c);
	   for(i = 0; i < arg2c; i++)
	     arg2v[i]= NULL;
	   arg2c= 0;
	   for(i = (*idx) + 2; i < end_idx; i++) {
	     ret= Xorriso_normalize_img_path(xorriso, s_wd, argv[i],
	                                     eff_source, ns_flag);
	     if(ret<=0)
	       goto ex;
	     ret= Xorriso__exchange_prefix(source_prefix, target_prefix,
	                                   eff_source, eff_target, 0);
	     if(ret <= 0)
	   continue;
	     Xorriso_alloc_meM(arg2v[arg2c], char, strlen(eff_target) + 1);
	     strcpy(arg2v[arg2c], eff_target);
	     arg2c++;
	   }
	   /* Expand wildcards in iso_rr, do not include unmatched patterns */
	   ret= Xorriso_opt_args(xorriso, cmd, arg2c, arg2v, 0, &i,
	                          &opt2c, &opt2v, (1 << 10) | (1 << 7));
	   if(ret<=0)
	     goto ex;
	   /* Convert from iso_rr path to disk path */
	   new_opt2c= 0;
	   for(i = 0; i < opt2c; i++) {
	     ret= Xorriso__exchange_prefix(target_prefix, source_prefix,
	                                   opt2v[i], eff_source, 0);
	     free(opt2v[i]);
	     opt2v[i]= NULL;
	     if(ret <= 0)
	   continue;
	     Xorriso_alloc_meM(opt2v[new_opt2c], char, strlen(eff_source) + 1);
	     strcpy(opt2v[new_opt2c], eff_source);
	     new_opt2c++;
	   }
	   opt2c= new_opt2c;
	   /* Merge both results */
	   if(opt2c > 0) {
	     Sfile_destroy_argv(&arg2c, &arg2v, 0);
	     Xorriso_alloc_meM(arg2v, char *, optc + opt2c);
	     for(i = 0; i < optc + opt2c; i++)
	       arg2v[i]= NULL;
	     arg2c= 0;
	     for(i= 0; i < optc; i++) {
	       ret= Xorriso_normalize_img_path(xorriso, s_wd, optv[i],
	                                       eff_source, ns_flag);
	       if(ret<=0)
	         goto ex;
	       Xorriso_alloc_meM(arg2v[arg2c], char, strlen(eff_source) + 1);
	       strcpy(arg2v[arg2c], eff_source);
	       arg2c++;
	     }
	     for(i= 0; i < opt2c; i++) {
	       for(j= 0; j < optc; j++)
	         if(strcmp(opt2v[i], arg2v[j]) == 0)
	       break;
	       if(j < optc)
	     continue;
	       arg2v[arg2c++]= opt2v[i];
	       opt2v[i]= NULL;
	     }
	     Sfile_destroy_argv(&optc, &optv, 0);
	     optv= arg2v;
	     arg2v= NULL;
	     optc= arg2c;
	     arg2c= 0;
	   }
	 }
	
	 if(mode == 3 &&
	    (xorriso->do_restore_sort_lba || !(xorriso->ino_behavior & 4))) {
	   eff_src_array= calloc(optc, sizeof(char *));
	   eff_tgt_array= calloc(optc, sizeof(char *));
	   if(eff_src_array == NULL || eff_tgt_array == NULL) {
	     Xorriso_no_malloc_memory(xorriso, NULL, 0);
	     ret= -1; goto ex;
	   }
	   for(i= 0; i < optc; i++)
	     eff_src_array[i]= eff_tgt_array[i]= NULL;
	 }
	 if((mode == 2 || mode == 4) &&
	     !((xorriso->ino_behavior & 2) || (flag & 16) ||
	       xorriso->di_array != NULL)) {
	   /* Create all-image node array sorted by isofs.di */
	   ret= Xorriso_make_di_array(xorriso, 0);
	   if(ret <= 0)
	     goto ex;
	 }
	
	 for(i= 0; i<optc; i++) {
	   ret= Xorriso_normalize_img_path(xorriso, s_wd, optv[i],
	                                   eff_source, ns_flag);
	   if(ret<=0)
	     goto ex;
	   ret= Xorriso__exchange_prefix(source_prefix, target_prefix,
	                                 eff_source, eff_target, 0);
	   if(ret == 0) {
	     sprintf(xorriso->info_text, "%s: disk_path ", cmd);
	     Text_shellsafe(eff_source, xorriso->info_text, 1);
	     strcat(xorriso->info_text, " does not begin with disk_prefix ");
	     Text_shellsafe(source_prefix, xorriso->info_text, 1);
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 1);
	   }
	   if(ret <= 0)
	     goto ex;
	
	   if(mode==0)
	     ret= Xorriso_option_map(xorriso, eff_source, eff_target, 2);
	   else if(mode==1)
	     ret= Xorriso_option_compare(xorriso, eff_source, eff_target, 2|8);
	   else if(mode == 2 || mode == 4)
	     ret= Xorriso_option_update(xorriso, eff_source, eff_target, 2 | 8 | 16);
	   else if(mode==3) {
	     if(eff_src_array != NULL) {
	       eff_src_array[i]= strdup(eff_source);
	       eff_tgt_array[i]= strdup(eff_target);
	       if(eff_src_array[i] == NULL || eff_tgt_array[i] == NULL) {
	         Xorriso_no_malloc_memory(xorriso, &(eff_src_array[i]), 0);
	         ret= -1; goto ex;
	       }
	     } else {
	       ret= Xorriso_option_extract(xorriso, eff_source, eff_target, 2 | 4);
	     }
	   } else if(mode == 5) {
	     ret= Xorriso_option_update(xorriso, eff_target, eff_source, 2 | 8 | 16);
	   }
	
	   if(ret>0 && !xorriso->request_to_abort)
	 continue; /* regular bottom of loop */
	   was_failure= 1;
	   fret= Xorriso_eval_problem_status(xorriso, ret, 1 | 2);
	   if(fret>=0)
	 continue;
	   goto ex;
	 }
	
	 ret= 1;
	 if(mode == 3 && eff_src_array != NULL) {
	   ret= Xorriso_lst_append_binary(&(xorriso->node_disk_prefixes),
	                                  target_prefix, strlen(target_prefix) + 1, 0);
	   if(ret <= 0)
	     goto ex;
	   ret= Xorriso_lst_append_binary(&(xorriso->node_img_prefixes),
	                                  source_prefix, strlen(source_prefix) + 1, 0);
	   if(ret <= 0)
	     goto ex;
	   ret= Xorriso_restore_sorted(xorriso, optc, eff_src_array, eff_tgt_array,
	                               &problem_count, 0);
	   if(ret <= 0 || problem_count > 0)
	     was_failure= 1;
	 }
	 if(mode==0)
	   Xorriso_pacifier_callback(xorriso, "files added", xorriso->pacifier_count,
	                             xorriso->pacifier_total, "", 1);
	 else if(mode==1 || mode==2 || mode == 4 || mode == 5)
	   Xorriso_pacifier_callback(xorriso, "content bytes read",
	                             xorriso->pacifier_count, 0, "", 1 | 8 | 32);
	 else if(mode==3)
	   Xorriso_pacifier_callback(xorriso, "files restored",xorriso->pacifier_count,
	                             xorriso->pacifier_total, "", 1|4);
	ex:;
	 Xorriso_destroy_node_array(xorriso, 0);
	 i= optc;
	 Sfile_destroy_argv(&i, &eff_src_array, 0);
	 i= optc;
	 Sfile_destroy_argv(&i, &eff_tgt_array, 0);
	 Xorriso_free_meM(source_prefix);
	 Xorriso_free_meM(target_prefix);
	 Xorriso_free_meM(eff_source);
	 Xorriso_free_meM(eff_target);
	 (*idx)= end_idx;
	 Xorriso_opt_args(xorriso, cmd, argc, argv, *idx, &end_idx, &optc, &optv, 256);
	 Xorriso_opt_args(xorriso, cmd, argc, argv, *idx, &end_idx, &opt2c, &opt2v,
	                  256);
	 if(arg2c > 0)
	   Sfile_destroy_argv(&arg2c, &arg2v, 0);
	 else if(arg2v != NULL)
	   Xorriso_free_meM(arg2v);
	
	 if(ret<=0)
	   return(ret);
	 return(!was_failure);
	}
	
	
	/* Option -mark */
	int Xorriso_option_mark(struct XorrisO *xorriso, char *mark, int flag)
	{
	 if(mark[0]==0)
	   xorriso->mark_text[0]= 0;
	 else
	   strncpy(xorriso->mark_text,mark,sizeof(xorriso->mark_text)-1);
	 xorriso->mark_text[sizeof(xorriso->mark_text)-1]= 0;
	 return(1);
	}
	
	
	/* Option -md5 "on"|"all"|"off" */
	int Xorriso_option_md5(struct XorrisO *xorriso, char *mode, int flag)
	{
	 char *npt, *cpt;
	 int l;
	
	 npt= cpt= mode;
	 for(; npt!=NULL; cpt= npt+1) {
	   npt= strchr(cpt,':');
	   if(npt==NULL)
	     l= strlen(cpt);
	   else
	     l= npt-cpt;
	   if(l == 0)
	 continue;
	   if(l == 3 && strncmp(cpt, "off", l) == 0)
	     xorriso->do_md5&= ~31;
	   else if(l == 2 && strncmp(cpt, "on", l) == 0)
	     xorriso->do_md5= (xorriso->do_md5 & ~31) | 7 | 16;
	   else if(l == 3 && strncmp(cpt, "all", l) == 0)
	     xorriso->do_md5|= 31;
	   else if(l == 18 && strncmp(cpt, "stability_check_on", l) == 0)
	     xorriso->do_md5|= 8;
	   else if(l == 19 && strncmp(cpt, "stability_check_off", l) == 0)
	     xorriso->do_md5&= ~8;
	   else if(l == 13 && strncmp(cpt, "load_check_on", l) == 0)
	     xorriso->do_md5&= ~32;
	   else if(l == 14 && strncmp(cpt, "load_check_off", l) == 0)
	     xorriso->do_md5|= 32;
	   else {
	     sprintf(xorriso->info_text, "-md5: unknown mode ");
	     Text_shellsafe(cpt, xorriso->info_text, 1);
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	     return(0);
	   }
	 }
	 return(1);
	}
	
	
	/* Option -mkdir alias -mkdiri */
	int Xorriso_option_mkdiri(struct XorrisO *xorriso, int argc, char **argv,
	                          int *idx, int flag)
	{
	 int i, end_idx, ret, was_failure= 0, fret;
	
	 end_idx= Xorriso_end_idx(xorriso, argc, argv, *idx, 0);
	
	 for(i= *idx; i<end_idx; i++) {
	   ret= Xorriso_mkdir(xorriso, argv[i], 0);
	   if(ret>0 && !xorriso->request_to_abort)
	 continue; /* regular bottom of loop */
	   was_failure= 1;
	   fret= Xorriso_eval_problem_status(xorriso, ret, 1|2);
	   if(fret>=0)
	 continue;
	   goto ex;
	 }
	 ret= 1; 
	ex:;
	 (*idx)= end_idx;
	 if(ret<=0)
	   return(ret);
	 return(!was_failure);
	}
	
	
	int Xorriso_option_modesty_on_drive(struct XorrisO *xorriso, char *mode,
	                                    int flag)
	{
	 char *npt, *cpt, *ppt;
	 int l, num, set_min;
	
	 npt= cpt= mode;
	 for(; npt!=NULL; cpt= npt+1) {
	   npt= strchr(cpt,':');
	   if(npt==NULL)
	     l= strlen(cpt);
	   else
	     l= npt-cpt;
	   if(l == 0)
	 continue;
	   if(l == 3 && strncmp(cpt, "off", l) == 0) {
	     xorriso->modesty_on_drive= 0;
	   } else if(l == 1 && strncmp(cpt, "0", l) == 0) {
	     xorriso->modesty_on_drive= 0;
	   } else if(l == 2 && strncmp(cpt, "on", l) == 0) {
	     xorriso->modesty_on_drive= 1;
	   } else if(l == 1 && strncmp(cpt, "1", l) == 0) {
	     xorriso->modesty_on_drive= 1;
	   } else if(l == 2 && strncmp(cpt, "-1", l) == 0) {
	     ;
	   } else if(*cpt >= '1' && *cpt <= '9') {
	     ppt= cpt;
	     set_min= 2;
	set_size_percent:;
	     sscanf(ppt, "%d", &num);
	     if(num == -1) {
	       ;
	     } else if(num < 25) {
	bad_percent:;
	       sprintf(xorriso->info_text, "-modesty_on_drive: percentage out of range [25 to 100]");
	       Text_shellsafe(cpt, xorriso->info_text, 1);
	       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	       return(0);
	     } else if(num > 100) {
	       goto bad_percent;
	     }
	     if(set_min == 2) {
	       xorriso->modesty_on_drive= 1;
	     }
	     if(set_min)
	       xorriso->min_buffer_percent= num;
	     else
	       xorriso->max_buffer_percent= num;
	   } else if(l >= 12 && strncmp(cpt, "min_percent=", 12) == 0) {
	     ppt= cpt + 12;
	     set_min= 1;
	     goto set_size_percent;
	   } else if(l >= 12 && strncmp(cpt, "max_percent=", 12) == 0) {
	     ppt= cpt + 12;
	     set_min= 0;
	     goto set_size_percent;
	   } else if(l >= 9 && strncmp(cpt, "min_usec=", 9) == 0) {
	     ppt= cpt + 9;
	     set_min= 1;
	set_sec:;
	     num= -1;
	     sscanf(ppt, "%d", &num);
	     if(num < 0)
	       num= 0;
	     if(set_min == 2)
	       xorriso->max_buffer_usec= num;
	     else if(set_min == 1)
	       xorriso->min_buffer_usec= num;
	     else if(set_min == 0)
	       xorriso->max_buffer_percent= num;
	     else
	       xorriso->buffer_timeout_sec= num;
	   } else if(l >= 9 && strncmp(cpt, "max_usec=", 9) == 0) {
	     ppt= cpt + 9;
	     set_min= 2;
	     goto set_sec;
	   } else if(l >= 12 && strncmp(cpt, "timeout_sec=", 12) == 0) {
	     ppt= cpt + 12;
	     set_min= -1;
	     goto set_sec;
	   } else {
	     sprintf(xorriso->info_text, "-modesty_on_drive: unknown mode ");
	     Text_shellsafe(cpt, xorriso->info_text, 1);
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	     return(0);
	   }
	 }
	 return(1);
	}
	
	
	/* Options -mount , -mount_cmd , -session_string */
	/* @param bit0= -mount_cmd: print mount command to result channel rather
	                            than performing it
	          bit1= perform -session_string rather than -mount_cmd
	*/
	int Xorriso_option_mount(struct XorrisO *xorriso, char *dev, char *adr_mode,
	                         char *adr, char *cmd, int flag)
	{
	 int ret, entity_code= 0, m_flag;
	 char entity_id[81], *mnt;
	
	 if(flag & 1)
	   mnt= "-mount_cmd";
	 else if(flag & 2)
	   mnt= "-session_string";
	 else {
	   mnt= "-mount";
	   if(xorriso->allow_restore <= 0) {
	     sprintf(xorriso->info_text,
	          "-mount: image-to-disk features are not enabled by option -osirrox");
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	     return(0);
	   }
	   if(Xorriso_change_is_pending(xorriso, 0)) {
	     sprintf(xorriso->info_text,
	             "%s: Image changes pending. -commit or -rollback first", mnt);
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	     return(0);
	   }
	 }
	 ret= Xorriso_decode_load_adr(xorriso, mnt, adr_mode, adr,
	                              &entity_code, entity_id, 0);
	 if(ret <= 0)
	   return(ret);
	 if(flag & 2)
	   m_flag= 1 | 4;
	 else
	   m_flag= (flag & 1) | 2;
	 ret= Xorriso_mount(xorriso, dev, entity_code, entity_id, cmd, m_flag);
	 return(ret);
	}
	
	
	/* Option -mount_opts option[:...] */
	int Xorriso_option_mount_opts(struct XorrisO *xorriso, char *mode, int flag)
	{
	 int was, l;
	 char *cpt, *npt;
	
	 was= xorriso->mount_opts_flag;
	 npt= cpt= mode;
	 for(cpt= mode; npt!=NULL; cpt= npt+1) {
	   npt= strchr(cpt,':');
	   if(npt==NULL)
	     l= strlen(cpt);
	   else
	     l= npt-cpt;
	   if(l==0)
	     goto unknown_mode;
	   if(strncmp(cpt, "shared", l)==0) {
	     xorriso->mount_opts_flag|= 1;
	   } else if(strncmp(cpt, "exclusive", l)==0) {
	     xorriso->mount_opts_flag&= ~1;
	   } else {
	unknown_mode:;
	     if(l<SfileadrL)
	       sprintf(xorriso->info_text, "-mount_opts: unknown option '%s'", cpt);
	     else
	       sprintf(xorriso->info_text, "-mount_opts: oversized parameter (%d)",l);
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	     xorriso->mount_opts_flag= was;
	     return(0);
	   }
	 }
	 return(1);
	}
	
	
	/* Command -move */
	int Xorriso_option_move(struct XorrisO *xorriso, char *origin, char *dest,
	                        int flag)
	{
	 int ret;
	 char *eff_origin= NULL, *eff_dest= NULL;
	
	 Xorriso_alloc_meM(eff_origin, char, SfileadrL);
	 Xorriso_alloc_meM(eff_dest, char, SfileadrL);
	
	 ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, origin, eff_origin, 0);
	 if(ret <= 0)
	   {ret= 0; goto ex;}
	 ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, dest, eff_dest, 2);
	 if(ret < 0)
	   {ret= 0; goto ex;}
	 ret= Xorriso_rename(xorriso, NULL, eff_origin, eff_dest, 0);
	 if(ret <= 0)
	   goto ex;
	 ret= 1;
	ex:;
	 Xorriso_free_meM(eff_origin);
	 Xorriso_free_meM(eff_dest);
	 return(ret);
	}
	
	 
	/* Command -msg_op */
	int Xorriso_option_msg_op(struct XorrisO *xorriso, char *what, char *arg,
	                          int flag)
	{
	 int ret, available, argc, pargc, i, pflag, max_words, input_lines, msd_mem;
	 char **argv= NULL, **pargv= NULL, *msg= "";
	 char *prefix, *separators;
	
	 msd_mem= xorriso->msg_sieve_disabled;
	
	 ret= 1;
	 if(strcmp(what, "parse") == 0 || strcmp(what, "parse_silently") == 0 ||
	    strcmp(what, "parse_bulk") == 0 ||
	    strcmp(what, "parse_bulk_silently") == 0) {
	   ret= Xorriso_parse_line(xorriso, arg, "", "", 5, &argc, &argv, 0);
	   prefix= "";
	   if(argc > 0) 
	     prefix= argv[0];
	   separators= "";
	   if(argc > 1)
	     separators= argv[1];
	   max_words= 0;
	   if(argc > 2)
	     sscanf(argv[2], "%d", &max_words);
	   pflag= 0;
	   if(argc > 3)
	     sscanf(argv[3], "%d", &pflag);
	   input_lines= 1;
	   if(argc > 4)
	     sscanf(argv[4], "%d", &input_lines);
	   if(strcmp(what, "parse") == 0 || strcmp(what, "parse_silently") == 0) {
	     ret= Xorriso_msg_op_parse(xorriso, "", prefix, separators,
	                               max_words, pflag, input_lines,
	                               (strcmp(what, "parse_silently") == 0));
	   } else {
	     ret= Xorriso_msg_op_parse_bulk(xorriso, prefix, separators,
	                               max_words, pflag, input_lines,
	                               (strcmp(what, "parse_bulk_silently") == 0));
	   }
	   if(ret <= 0)
	     goto ex;
	   xorriso->msg_sieve_disabled= msd_mem;
	   Xorriso__dispose_words(&argc, &argv);
	 } else if(strcmp(what, "start_sieve") == 0) {
	   Xorriso_sieve_dispose(xorriso, 0);
	   ret= Xorriso_sieve_big(xorriso, 0);
	   msg= "Message sieve enabled";
	
	/* >>> } else if(strcmp(what, "add_filter_rule") == 0) { */;
	
	 } else if(strcmp(what, "clear_sieve") == 0) {
	   ret= Xorriso_sieve_clear_results(xorriso, 0);
	   msg= "Recorded message sieve results disposed";
	 } else if(strcmp(what, "end_sieve") == 0) {
	   ret= Xorriso_sieve_dispose(xorriso, 0);
	   msg= "Message sieve disabled";
	 } else if(strcmp(what, "read_sieve") == 0) {
	   ret= Xorriso_sieve_get_result(xorriso, arg, &pargc, &pargv, &available, 0);
	   xorriso->msg_sieve_disabled= 1;
	   sprintf(xorriso->result_line, "%d\n", ret);
	   Xorriso_result(xorriso, 1);
	   if(ret > 0) {
	     sprintf(xorriso->result_line, "%d\n", pargc);
	     Xorriso_result(xorriso, 1);
	     for(i= 0; i < pargc; i++) {
	       ret= Sfile_count_char(pargv[i], '\n') + 1;
	       sprintf(xorriso->result_line, "%d\n", ret);
	       Xorriso_result(xorriso, 1);
	       Sfile_str(xorriso->result_line, pargv[i], 0);
	       strcat(xorriso->result_line, "\n");
	       Xorriso_result(xorriso, 1);
	     }
	   } else {
	     strcpy(xorriso->result_line, "0\n");
	     Xorriso_result(xorriso, 1);
	     available= 0;
	   }
	   sprintf(xorriso->result_line, "%d\n", available);
	   Xorriso_result(xorriso, 1);
	   xorriso->msg_sieve_disabled= msd_mem;
	   Xorriso__dispose_words(&pargc, &pargv);
	   ret= 1;
	 } else if(strcmp(what, "show_sieve") == 0) {
	   ret= Xorriso_sieve_get_result(xorriso, "", &pargc, &pargv, &available, 8);
	   xorriso->msg_sieve_disabled= 1;
	   sprintf(xorriso->result_line, "%d\n", ret);
	   Xorriso_result(xorriso, 1);
	   if(ret > 0) {
	     sprintf(xorriso->result_line, "%d\n", pargc);
	     Xorriso_result(xorriso, 1);
	     for(i= 0; i < pargc; i++) {
	       sprintf(xorriso->result_line, "%s\n", pargv[i]);
	       Xorriso_result(xorriso, 1);
	     }
	   }
	   xorriso->msg_sieve_disabled= msd_mem;
	   Xorriso__dispose_words(&pargc, &pargv);
	 } else if(strcmp(what, "compare_sev") == 0) {
	   ret= Xorriso_parse_line(xorriso, arg, "", ",", 2, &argc, &argv, 0);
	   if(argc < 2) {
	     sprintf(xorriso->info_text,
	             "-msg_op cmp_sev: malformed severity pair '%s'", arg);
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
	   } else {
	     ret= Xorriso__severity_cmp(argv[0], argv[1]);
	     sprintf(xorriso->result_line, "%d\n", ret);
	     Xorriso_result(xorriso, 1);
	   }
	   Xorriso__dispose_words(&argc, &argv);
	 } else if(strcmp(what, "list_sev") == 0) {
	   sprintf(xorriso->result_line, "%s\n", Xorriso__severity_list(0));
	   Xorriso_result(xorriso, 1);
	 } else {
	   sprintf(xorriso->info_text, "-msg_op: unknown operation '%s'", what);
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
	   ret= 0;
	 }
	 if(ret > 0 && msg[0])
	   Xorriso_msgs_submit(xorriso, 0, msg, 0, "NOTE", 0);
	
	ex:;
	 xorriso->msg_sieve_disabled= msd_mem;
	 return(ret);
	}
	
	
	/* Option -mv alias -mvi */
	int Xorriso_option_mvi(struct XorrisO *xorriso, int argc, char **argv,
	                      int *idx, int flag)
	{
	 int i, end_idx_dummy, ret, is_dir= 0, was_failure= 0, fret;
	 char *eff_origin= NULL, *eff_dest= NULL, *dest_dir= NULL;
	 char *leafname= NULL;
	 int optc= 0;
	 char **optv= NULL;
	
	 Xorriso_alloc_meM(eff_origin, char, SfileadrL);
	 Xorriso_alloc_meM(eff_dest, char, SfileadrL);
	 Xorriso_alloc_meM(dest_dir, char, SfileadrL);
	 Xorriso_alloc_meM(leafname, char, SfileadrL);
	
	 ret= Xorriso_cpmv_args(xorriso, "-mvi", argc, argv, idx,
	                        &optc, &optv, eff_dest, 0);
	 if(ret<=0)
	   goto ex;
	 if(ret==2) {
	   is_dir= 1;
	   strcpy(dest_dir, eff_dest);
	 }
	 /* Perform movements */
	 for(i= 0; i<optc; i++) {
	   ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi,optv[i],eff_origin,0);
	   if(ret<=0 || xorriso->request_to_abort)
	     goto problem_handler;
	   if(is_dir) {
	     ret= Sfile_leafname(eff_origin, leafname, 0);
	     if(ret<=0)
	       goto problem_handler;
	     strcpy(eff_dest, dest_dir);
	     ret= Sfile_add_to_path(eff_dest, leafname, 0);
	     if(ret<=0) {
	       sprintf(xorriso->info_text, "Effective path gets much too long (%d)",
	             (int) (strlen(eff_dest)+strlen(leafname)+1));
	       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	       goto problem_handler;
	     }
	   }
	   ret= Xorriso_rename(xorriso, NULL, eff_origin, eff_dest, 0);
	   if(ret<=0 || xorriso->request_to_abort)
	     goto problem_handler;
	   sprintf(xorriso->info_text, "Renamed in ISO image: ");
	   Text_shellsafe(eff_origin, xorriso->info_text, 1);
	   strcat(xorriso->info_text, " to ");
	   Text_shellsafe(eff_dest, xorriso->info_text, 1 | 2);
	   strcat(xorriso->info_text, "\n");
	   Xorriso_info(xorriso, 0);
	
	 continue; /* regular bottom of loop */
	problem_handler:;
	   was_failure= 1;
	   fret= Xorriso_eval_problem_status(xorriso, ret, 1|2);
	   if(fret>=0)
	 continue;
	   goto ex;
	 }
	 ret= !was_failure;
	ex:;
	 Xorriso_free_meM(eff_origin);
	 Xorriso_free_meM(eff_dest);
	 Xorriso_free_meM(dest_dir);
	 Xorriso_free_meM(leafname);
	 Xorriso_opt_args(xorriso, "-mvi",
	                  argc, argv, *idx, &end_idx_dummy, &optc, &optv, 256);
	 return(ret);
	}
	
	
	/* Option -named_pipe_loop */
	int Xorriso_option_named_pipe_loop(struct XorrisO *xorriso, char *mode,
	                                   char *stdin_pipe, char *stdout_pipe,
	                                   char *stderr_pipe, int flag)
	{
	 char *pipe_paths[3], *cpt, *npt;
	 int ret, hflag= 0, l;
	
	 npt= mode;
	 for(cpt= mode; npt != NULL; cpt= npt + 1) {
	   npt= strchr(cpt, ':');
	   if(npt==NULL)
	     l= strlen(cpt);
	   else
	     l= npt-cpt;
	   if(l==0) {
	     ;
	   } else if(strncmp(cpt, "-", l) == 0) {
	     ;
	   } else if(strncmp(cpt, "cleanup", l) == 0) {
	     hflag|= 1;
	   } else if(strncmp(cpt, "keep", l) == 0) {
	     hflag&= ~1;
	   } else if(strncmp(cpt, "buffered", l) == 0) {
	     hflag|= 2;
	   } else if(strncmp(cpt, "direct", l) == 0) {
	     hflag&= ~2;
	   } else { 
	     sprintf(xorriso->info_text, "-named_pipe_loop: unknown mode in '%s'",
	             mode);
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	     return(0);
	   }
	 }
	 pipe_paths[0]= stdin_pipe;
	 pipe_paths[1]= stdout_pipe;
	 pipe_paths[2]= stderr_pipe;
	 ret= Xorriso_named_pipe_loop(xorriso, pipe_paths, hflag);
	 return(ret);
	}
	
	
	/* Option -no_rc */
	int Xorriso_option_no_rc(struct XorrisO *xorriso, int flag)
	{
	 xorriso->no_rc= 1;
	 return(1);
	}
	
	
	/* Option -not_leaf , (-hide_disk_leaf , -as mkisofs -hide) */
	/* @param flag  bit0-bit5= hide rather than adding to disk_exclusions
	                  bit0= add to iso_rr_hidings
	                  bit1= add to joliet_hidings
	                  bit2= add to hfsplus_hidings
	*/
	int Xorriso_option_not_leaf(struct XorrisO *xorriso, char *pattern, int flag)
	{
	 regex_t re;
	 char *regexpr= NULL;
	 int ret= 0;
	
	 Xorriso_alloc_meM(regexpr, char, 2 * SfileadrL + 2);
	
	 if(pattern[0]==0)
	   {ret= 0; goto cannot_add;}
	 Xorriso__bourne_to_reg(pattern, regexpr, 0);
	 if(regcomp(&re, regexpr, 0)!=0)
	   {ret= 0; goto cannot_add;}
	 if(flag & 63) {
	   if(flag & 1) {
	     ret= Exclusions_add_not_leafs(xorriso->iso_rr_hidings, pattern, &re, 0);
	     if(ret<=0)
	       goto cannot_add;
	   }
	   if(flag & 2) {
	     ret= Exclusions_add_not_leafs(xorriso->joliet_hidings, pattern, &re, 0);
	     if(ret<=0)
	       goto cannot_add;
	   }
	   if(flag & 4) {
	     ret= Exclusions_add_not_leafs(xorriso->hfsplus_hidings, pattern, &re, 0);
	     if(ret<=0)
	       goto cannot_add;
	   }
	 } else {
	   ret= Exclusions_add_not_leafs(xorriso->disk_exclusions, pattern, &re, 0);
	 }
	 if(ret<=0) {
	cannot_add:;
	   sprintf(xorriso->info_text,"Cannot add pattern: %s ",
	           (flag & 3) ? "-hide_disk_leaf" : "-not_leaf");
	   Text_shellsafe(pattern, xorriso->info_text, 1);
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   goto ex;
	 }
	 ret= 1;
	ex:;
	 Xorriso_free_meM(regexpr);
	 return(ret);
	}
	
	
	/* Option -not_list , -quoted_not_list */
	/* @param flag bit0= -quoted_not_list */
	int Xorriso_option_not_list(struct XorrisO *xorriso, char *adr, int flag)
	{
	 int ret, linecount= 0, insertcount= 0, null= 0, argc= 0, i;
	 FILE *fp= NULL;
	 char **argv= NULL;
	 
	 Xorriso_pacifier_reset(xorriso, 0);
	 if(adr[0]==0) {
	   sprintf(xorriso->info_text, "Empty file name given with %s",
	           (flag & 1) ? "-quoted_not_list" : "-not_list");
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   return(0);
	 }
	 ret= Xorriso_afile_fopen(xorriso, adr, "rb", &fp, 0);
	 if(ret <= 0)
	   return(0);
	 while(1) {
	   ret= Xorriso_read_lines(xorriso, fp, &linecount, &argc, &argv,
	                           4 | (flag & 1) );
	   if(ret <= 0)
	     goto ex;
	   if(ret == 2)
	 break;
	   for(i= 0; i < argc; i++) {
	     if(argv[i][0] == 0)
	   continue;
	     if(strchr(argv[i], '/')!=NULL) {
	       null= 0;
	       ret= Xorriso_option_not_paths(xorriso, 1, argv + i, &null, 0);
	     } else
	       ret= Xorriso_option_not_leaf(xorriso, argv[i], 0);
	     if(ret<=0)
	       goto ex;
	     insertcount++;
	   }
	 }

(1) Event start:

Starting defect path here.

	 ret= 1;
	ex:;

(2) Event alloc_arg:	"Xorriso_read_lines" allocates memory that is stored into "argv". [details]
Also see events:	[leaked_storage]

	 Xorriso_read_lines(xorriso, fp, &linecount, &argc, &argv, 2);

(3) Event cond_true:	Condition "fp != NULL", taking true branch.
(4) Event cond_true:	Condition "fp != stdin", taking true branch.

	 if(fp != NULL && fp != stdin)
	   fclose(fp);

(5) Event cond_false:

Condition "ret <= 0", taking false branch.

	 if(ret<=0) {
	   sprintf(xorriso->info_text, "Aborted reading of file ");
	   Text_shellsafe(adr, xorriso->info_text, 1);
	   sprintf(xorriso->info_text + strlen(xorriso->info_text),
	           " in line number %d", linecount);
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);

(6) Event if_end:

End of if statement.

	 }
	 sprintf(xorriso->info_text, "Added %d exclusion list items from file ",
	         insertcount);
	 Text_shellsafe(adr, xorriso->info_text, 1);
	 strcat(xorriso->info_text, "\n");
	 Xorriso_info(xorriso,0);

(7) Event leaked_storage:	Variable "argv" going out of scope leaks the storage it points to.
Also see events:	[alloc_arg]

	 return(ret);
	}
	
	
	/* Option -not_mgt */
	int Xorriso_option_not_mgt(struct XorrisO *xorriso, char *setting, int flag)
	{
	 int ret;
	 char *what_data= NULL, *what, *what_next;
	
	 Xorriso_alloc_meM(what_data, char, SfileadrL);
	
	 if(Sfile_str(what_data, setting, 0)<=0) {
	   sprintf(xorriso->info_text,
	           "-not_mgt: setting string is much too long (%d)",
	           (int) strlen(setting));
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   {ret= 0; goto ex;}
	 } 
	 for(what= what_data; what!=NULL; what= what_next) {
	   what_next= strchr(what, ':');
	   if(what_next!=NULL) {
	     *what_next= 0;
	     what_next++;
	   }
	
	   if(strcmp(what, "reset")==0 || strcmp(what, "erase")==0) {
	     if(strcmp(what, "reset")==0)
	       xorriso->disk_excl_mode= 1;
	     Exclusions_destroy(&(xorriso->disk_exclusions), 0);
	     ret= Exclusions_new(&(xorriso->disk_exclusions), 0);
	     if(ret<=0) {
	       Xorriso_no_malloc_memory(xorriso, NULL, 0);
	       goto ex;
	     }
	   } else if(strcmp(what, "on")==0) {
	     xorriso->disk_excl_mode|= 1;
	   } else if(strcmp(what, "off")==0) {
	     xorriso->disk_excl_mode&= ~1;
	   } else if(strcmp(what, "param_on")==0) {
	     xorriso->disk_excl_mode|= 2;
	   } else if(strcmp(what, "param_off")==0) {
	     xorriso->disk_excl_mode&= ~2;
	   } else if(strcmp(what, "subtree_on")==0) {
	     xorriso->disk_excl_mode|= 4;
	   } else if(strcmp(what, "subtree_off")==0) {
	     xorriso->disk_excl_mode&= ~4;
	   } else if(strcmp(what, "ignore_on")==0) {
	     xorriso->disk_excl_mode|= 8;
	   } else if(strcmp(what, "ignore_off")==0) {
	     xorriso->disk_excl_mode&= ~8;
	   } else {
	     sprintf(xorriso->info_text, "-not_mgt: unknown setting '%s'", what);
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	     {ret= 0; goto ex;}
	   }
	 }
	 ret= 1;
	ex:;
	 Xorriso_free_meM(what_data);
	 return(ret);
	}
	
	
	/* Option -not_paths , (-hide_disk_paths , -as mkisofs -hide) */
	/* @param flag  bit0= add to iso_rr_hidings rather than disk_exclusions
	                bit1= add to joliet_hidings rather than disk_exclusions
	                bit2= enable disk pattern expansion regardless of -disk_pattern
	                bit8-13= consolidated hide state bits, duplicating bit0-1
	                   bit8= add to iso_rr_hidings
	                   bit9= add to joliet_hidings
	                  bit10= add to hfsplus_hidings
	*/
	int Xorriso_option_not_paths(struct XorrisO *xorriso, int argc, char **argv,
	                             int *idx, int flag)
	{
	 int ret, end_idx, num_descr= 0, dummy, optc= 0, i;
	 char **descr= NULL, **optv= NULL, *eff_path= NULL, *hpt= NULL;
	
	 end_idx= Xorriso_end_idx(xorriso, argc, argv, *idx,
	                          (xorriso->do_disk_pattern == 1 || (flag & 4)) | 2);
	 if(end_idx<=0)
	   {ret= end_idx; goto ex;}
	
	 num_descr= end_idx - *idx;
	 if(num_descr<=0)
	   {ret= 1; goto ex;}
	 
	 /* produce absolute patterns */
	 Xorriso_alloc_meM(eff_path, char, SfileadrL);
	 descr= TSOB_FELD(char *, num_descr);
	 if(descr==NULL) {
	no_memory:;
	   Xorriso_no_pattern_memory(xorriso, sizeof(char *) * (off_t) num_descr, 0);
	   ret= -1; goto ex;
	 }
	 for(i= 0; i<num_descr; i++)
	   descr[i]= NULL;
	 for(i= 0; i<num_descr; i++) {
	   ret= Xorriso_normalize_img_path(xorriso, xorriso->wdx, argv[i+*idx],
	                                   eff_path, 2|4);
	   if(ret<=0)
	     goto ex;
	   descr[i]= strdup(eff_path); 
	   if(descr[i]==NULL)
	     goto no_memory;
	 }
	
	 ret= Xorriso_opt_args(xorriso,
	                       (flag & 0x3f03) ? "-hide_disk_paths" : "-not_paths",
	                       num_descr, descr, 0, &dummy, &optc, &optv,
	                       2 | ((flag & 4) << 7));
	 if(ret<=0)
	   goto ex; 
	 if(flag & 0x3f03) {
	   if(flag & 0x0101) {
	     ret= Exclusions_add_not_paths(xorriso->iso_rr_hidings,
	                                   num_descr, descr, optc, optv, 0);
	     if(ret<=0) {
	no_hide:;
	       sprintf(xorriso->info_text, "Cannot add path list: -hide_disk_paths ");
	       hpt= Xorriso__hide_mode_text(flag & 0x3f03, 0);
	       if(hpt != NULL)
	         sprintf(xorriso->info_text + strlen(xorriso->info_text), "%s ", hpt);
	       Xorriso_free_meM(hpt);
	       Text_shellsafe(argv[*idx], xorriso->info_text, 1);
	       strcat(xorriso->info_text, num_descr > 1 ? " ... " : " ");
	       strcat(xorriso->info_text, xorriso->list_delimiter);
	       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	       goto ex;
	     }
	   }
	   if(flag & 0x0202) {
	     ret= Exclusions_add_not_paths(xorriso->joliet_hidings,
	                                   num_descr, descr, optc, optv, 0);
	     if(ret<=0)
	       goto no_hide;
	   }
	   if(flag & 0x0400) {
	     ret= Exclusions_add_not_paths(xorriso->hfsplus_hidings,
	                                   num_descr, descr, optc, optv, 0);
	     if(ret<=0)
	       goto no_hide;
	   }
	 } else {
	   ret= Exclusions_add_not_paths(xorriso->disk_exclusions,
	                                 num_descr, descr, optc, optv, 0);
	   if(ret<=0) {
	     sprintf(xorriso->info_text,"Cannot add path list: -not_paths ");
	     Text_shellsafe(argv[*idx], xorriso->info_text, 1);
	     strcat(xorriso->info_text, num_descr > 1 ? " ... " : " ");
	     strcat(xorriso->info_text, xorriso->list_delimiter);
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   }
	 }
	ex:;
	 (*idx)= end_idx;
	 Xorriso_opt_args(xorriso, "-not_paths",
	                  num_descr, descr, 0, &dummy, &optc, &optv, 256);
	 if(descr!=NULL) {
	   for(i= 0; i<num_descr; i++)
	     if(descr[i]!=NULL)
	       free(descr[i]);
	   free((char *) descr);
	   descr= NULL;
	 }
	 Xorriso_free_meM(eff_path);
	 return(ret);
	}
	
	
	/* Option -options_from_file */
	int Xorriso_option_options_from_file(struct XorrisO *xorriso, char *adr,
	                                     int flag)
	/*
	 bit0= called from Xorriso_prescan_args,
	       therefore execute via that same function
	*/
	/*
	return:
	 <=0 error , 1 = success , 3 = end program run
	*/
	{
	 int ret,linecount= 0, argc= 0, was_failure= 0, fret;
	 FILE *fp= NULL;
	 char **argv= NULL;
	 int linec= 0;
	 char *line= NULL, **linev= NULL;
	
	 if(adr[0]==0) {
	   sprintf(xorriso->info_text,"Empty file name given with -options_from_file");
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
	   return(0);
	 }
	 if(xorriso->is_dialog) {
	   sprintf(xorriso->info_text,"+ performing command lines from file ");
	   Text_shellsafe(adr, xorriso->info_text, 1);
	   strcat(xorriso->info_text, " :\n");
	   Xorriso_info(xorriso,1);
	 }
	 ret= Xorriso_afile_fopen(xorriso, adr, "rb", &fp, 0);
	 if(ret <= 0)
	   return(0);
	 sprintf(xorriso->info_text, "Command file:  ");
	 Text_shellsafe(adr, xorriso->info_text, 1);
	 Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
	 while(1) {
	   ret= Xorriso_read_lines(xorriso, fp, &linecount, &linec, &linev, 1 | 8);
	   if(ret <= 0)
	     goto ex; /* no problem_handler because there is no sense in going on */
	   if(ret == 2)
	 break;
	   line= linev[0];
	   if(line[0]==0 || line[0]=='#')
	 continue;
	
	   if(flag&1) {
	     ret= Sfile_make_argv(xorriso->progname, line, &argc, &argv,
	                          4 | 8 | ((xorriso->bsl_interpretation & 3) << 5));
	     if(ret<=0)
	       goto problem_handler;
	     ret= Xorriso_prescan_args(xorriso,argc,argv,1);
	     if(ret==0)
	       {ret= 3; goto ex;}
	     if(ret<0)
	       goto problem_handler;
	   } else {
	     if(xorriso->is_dialog) {
	       sprintf(xorriso->info_text,"+ %d:  %s\n",linecount,line);
	       Xorriso_info(xorriso,1);
	     }
	     ret= Xorriso_execute_option(xorriso,line,1|(1<<16));
	     if(ret==3)
	       goto ex;
	     if(ret<=0)
	       goto problem_handler;
	   }
	
	 continue; /* regular bottom of loop */
	problem_handler:;
	   was_failure= 1;
	   fret= Xorriso_eval_problem_status(xorriso, ret, 1);
	   if(fret>=0)
	 continue;
	   goto ex;
	 }
	 ret= 1;
	ex:;
	 Sfile_make_argv("", "", &argc, &argv, 2); /* release memory */
	 Xorriso_read_lines(xorriso, fp, &linecount, &linec, &linev, 2);
	 Xorriso_reset_counters(xorriso,0);
	 if(fp != NULL && fp != stdin)
	   fclose(fp);
	 if(ret<=0) {
	   sprintf(xorriso->info_text,
	           "error triggered by line %d of file:\n    ", linecount);
	   Text_shellsafe(adr, xorriso->info_text, 1);
	   strcat(xorriso->info_text, "\n");
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 1);
	 }
	 sprintf(xorriso->info_text, "Command file end:  ");
	 Text_shellsafe(adr, xorriso->info_text, 1);
	 Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
	 if(ret!=1)
	   return(ret);
	 return(!was_failure);
	}
	
	
	/* Option -osirrox "on"|"off" */
	int Xorriso_option_osirrox(struct XorrisO *xorriso, char *mode, int flag)
	{
	 int l, allow_restore;
	 char *npt, *cpt;
	
	 allow_restore= xorriso->allow_restore;
	
	 npt= cpt= mode;
	 for(cpt= mode; npt!=NULL; cpt= npt+1) {
	   npt= strchr(cpt,':');
	   if(npt==NULL)
	     l= strlen(cpt);
	   else
	     l= npt-cpt;
	   if(l==0 && mode[0]!=0)
	     goto unknown_mode;
	   if(strncmp(cpt, "off", l)==0 && l >= 3)
	     allow_restore= 0;
	   else if(strncmp(cpt, "banned", l)==0 && l >= 5)
	     allow_restore= -1;
	   else if(strncmp(cpt, "blocked", l)==0 && l >= 7)
	     allow_restore= -2;
	   else if(strncmp(cpt, "unblock", l)==0 && l >= 7) {
	     if(xorriso->allow_restore == -2)
	       xorriso->allow_restore= 0;
	     allow_restore= 1;
	   } else if(strncmp(cpt, "device_files", l)==0 && l >= 12)
	     allow_restore= 2;
	   else if((strncmp(cpt, "on", l)==0 && l >= 2) || mode[0]==0)
	     allow_restore= 1;
	   else if(strncmp(cpt, "concat_split_on", l)==0 && l >= 15)
	     xorriso->do_concat_split= 1;
	   else if(strncmp(cpt, "concat_split_off", l)==0 && l >= 16)
	     xorriso->do_concat_split= 0;
	   else if(strncmp(cpt, "auto_chmod_on", l)==0 && l >= 13)
	     xorriso->do_auto_chmod= 1;
	   else if(strncmp(cpt, "auto_chmod_off", l)==0 && l >= 14)
	     xorriso->do_auto_chmod= 0;
	   else if(strncmp(cpt, "sort_lba_on", l)==0 && l >= 11)
	     xorriso->do_restore_sort_lba= 1;
	   else if(strncmp(cpt, "sort_lba_off", l)==0 && l >= 12)
	     xorriso->do_restore_sort_lba= 0;
	   else if(strncmp(cpt, "o_excl_on", l)==0 && l >= 9)
	     xorriso->drives_exclusive= 1;
	   else if(strncmp(cpt, "o_excl_off", l)==0 && l >= 10)
	     xorriso->drives_exclusive= 0;
	   else if(strncmp(cpt, "strict_acl_on", l)==0 && l >= 13)
	     xorriso->do_strict_acl|= 1;
	   else if(strncmp(cpt, "strict_acl_off", l)==0 && l >= 14)
	     xorriso->do_strict_acl&= ~1;
	   else {
	unknown_mode:;
	     sprintf(xorriso->info_text, "-osirrox: unknown mode '%s'", cpt);
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	     return(0);
	   }
	 }
	 if(allow_restore > 0 && xorriso->allow_restore == -1) {
	   sprintf(xorriso->info_text,
	     "-osirrox: was already permanently disabled by setting 'banned'");
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   return(0);
	 }
	 if(allow_restore > 0 && xorriso->allow_restore == -2) {
	   sprintf(xorriso->info_text,
	           "-osirrox: is currently disabled by setting 'blocked'");
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   return(0);
	 }
	 if(xorriso->allow_restore != -1)
	   xorriso->allow_restore= allow_restore;
	 sprintf(xorriso->info_text,
	         "Copying of file objects from ISO image to disk filesystem is: %s\n",
	         xorriso->allow_restore > 0 ? "Enabled" : "Disabled");
	 Xorriso_info(xorriso, 0);
	 return(1);
	}
	
	
	/* Option -overwrite "on"|"nondir"|"off" */
	int Xorriso_option_overwrite(struct XorrisO *xorriso, char *mode, int flag)
	{
	 if(strcmp(mode, "off")==0)
	   xorriso->do_overwrite= 0;
	 else if(strcmp(mode, "on")==0)
	   xorriso->do_overwrite= 1;
	 else if(strcmp(mode, "nondir")==0)
	   xorriso->do_overwrite= 2;
	 else {
	   sprintf(xorriso->info_text, "-overwrite: unknown mode '%s'", mode);
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   return(0);
	 }
	 return(1);
	}
	
	
	

	
	/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
	
	   Copyright 2007-2017 Thomas Schmitt, <address@hidden>
	
	   Provided under GPL version 2 or later.
	
	   This file contains the implementation of emulators for mkisofs and cdrecord.
	*/
	
	#ifdef HAVE_CONFIG_H
	#include "../config.h"
	#endif
	
	#include <ctype.h>
	#include <sys/types.h>
	#include <unistd.h>
	#include <stdlib.h>
	#include <stdio.h>
	#include <string.h>
	#include <sys/stat.h>
	#include <sys/time.h>
	#include <time.h>
	#include <fcntl.h>
	#include <errno.h>
	
	#include "xorriso.h"
	#include "xorriso_private.h"
	#include "xorrisoburn.h"
	
	
	int Xorriso_cdrskin_uses_stdout(struct XorrisO *xorriso, int argc, char **argv,
	                                int flag)
	{
	 int i;
	
	 for(i= 0; i < argc; i++) {
	   if(strcmp(argv[i], "dev=-") == 0 ||
	      strcmp(argv[i], "dev=stdio:/dev/fd/1") == 0 ||
	      strcmp(argv[i], "-dev=-") == 0 ||
	      strcmp(argv[i], "-dev=stdio:/dev/fd/1") == 0)
	     return(1);
	 }
	 return(0);
	}
	
	
	int Xorriso_cdrskin_help(struct XorrisO *xorriso, int flag)
	{
	 static char helptext[][80]= {
	"Usage: xorriso -as cdrecord [options|source_addresses]",
	"Note: This is not cdrecord. See xorriso -help, xorriso -version, man xorrecord",
	"Options:",
	"\t-version\tprint version information and exit emulation",
	"\t--devices\tprint list of available MMC drives and exit emulation",
	"\tdev=target\tpseudo-SCSI target to use as CD-Recorder",
	"\tdrive_scsi_dev_family=sr|scd|sg\t\tselect Linux device type",
	"\t-v\t\tincrement verbose level by one",
	"\t-V\t\tincrement SCSI command transport verbose level by one",
	"\t-checkdrive\tcheck if a driver for the drive is present",
	"\t-inq\t\tdo an inquiry for the drive",
	"\tspeed=#\t\tset speed of drive",
	"\tblank=type\tblank a CD-RW disc (see blank=help)",
	"\tfs=#\t\tSet fifo size to # (0 to disable, default is 4 MB)",
	"\t-eject\t\teject the disk after doing the work",
	"\t-dummy\t\tdo everything with laser turned off",
	"\t-msinfo\t\tretrieve multi-session info for mkisofs >= 1.10",
	"\t-toc\t\tretrieve and print TOC/PMA data",
	"\t-atip\t\tretrieve media state, print \"Is *erasable\"",
	"\t-multi\t\tgenerate a TOC that allows multi session",
	"\t--multi_if_possible\tapply -multi if the medium supports it",
	"\t-waiti\t\twait until input is available before opening SCSI",
	"\t-tao\t\tWrite disk in TAO mode.",
	"\t-dao\t\tWrite disk in SAO mode.",
	"\t-sao\t\tWrite disk in SAO mode.",
	"\ttsize=#\t\tannounces exact size of source data",
	"\tpadsize=#\tAmount of padding",
	"\t-data\t\tSubsequent tracks are CD-ROM data mode 1 (default)",
	"\t-isosize\tUse iso9660 file system size for next data track",
	"\t-pad\t\tpadsize=30k",
	"\t-nopad\t\tDo not pad",
	"\tminbuf=\t\tKeep drive buffer hungry",
	"\tmodesty_on_drive=\tLike minbuf=, but with more parameters",
	"\t-immed\t\tEquivalent to minbuf=75",
	"\t--grow_overwriteable_iso\temulate multi-session on DVD+RW, BD-RE",
	"\twrite_start_address=#\t\twrite to byte address on DVD+RW, BD-RE",
	"\tstream_recording=on|number\ttry to get full speed on DVD-RAM, BD",
	"\tuse_immed_bit=on|off|default\tcontrol use of Immed bit",
	"\tdvd_obs=default|32k|64k\t\tbytes per DVD/BD write operation",
	"\tstdio_sync=on|off|end|number\twhether to fsync output to \"stdio:\"",
	"\t--no_rc\t\tDo not execute xorriso startup files",
	"\t-help\t\tprint this text to stderr and exit emulation",
	"Actually this is the integrated ISO RockRidge filesystem manipulator xorriso",
	"lending its libburn capabilities to a very limited cdrecord emulation. Only",
	"a single data track can be burnt to blank, appendable or overwriteable media.",
	"A much more elaborate cdrecord emulator is cdrskin from the same project.",
	"@End_of_helptexT@"
	};
	 int i;
	
	 for(i= 0; strcmp(helptext[i], "@End_of_helptexT@")!=0; i++) {
	   sprintf(xorriso->info_text, "%s\n", helptext[i]);
	   Xorriso_info(xorriso,0);
	 }
	 return(1);
	}
	
	
	/* micro version of cdrskin */
	int Xorriso_cdrskin(struct XorrisO *xorriso, char *whom, int argc, char **argv,
	                    int flag)
	{
	 int ret, i, k, mem_do_close, aq_ret, eject_ret, msc1, msc2, hflag;
	 int do_atip= 0, do_checkdrive= 0, do_eject= 0, do_scanbus= 0;
	 int do_toc= 0, do_verbous= 0, do_version= 0, do_help= 0, do_waiti= 0;
	 int do_multi= 0, do_msinfo= 0, do_grow= 0, do_isosize= 0, do_xa1= 0;
	 int do_auto_close= 0;
	 double write_start_address= -1.0, tsize= -1.0, mem_auto_close;
	 char *track_source= NULL, *dev_adr= NULL, *cpt;
	 char mem_report_about_text[80], *report_about= "SORRY", blank_mode[80];
	 char speed[80], *argpt;
	
	 /* cdrecord 2.01 options which are not scheduled for implementation, yet */
	 static char ignored_partial_options[][41]= {
	   "timeout=", "debug=", "kdebug=", "kd=", "driver=", "ts=",
	   "pregap=", "defpregap=", "mcn=", "isrc=", "index=", "textfile=",
	   "pktsize=", "cuefile=",
	   "gracetime=",
	
	   "assert_write_lba=", "fifo_start_at=", "dev_translation=",
	   "fallback_program=",
	   "tao_to_sao_tsize=", 
	   
	   "direct_write_amount=", "msifile=",
	
	   ""
	 };
	 static char ignored_full_options[][41]= {
	   "-d", "-silent", "-s", "-setdropts", "-prcap",
	   "-reset", "-abort", "-overburn", "-ignsize", "-useinfo",
	   "-fix", "-nofix",
	   "-raw", "-raw96p", "-raw16",
	   "-clone", "-text",
	   "-cdi", "-preemp", "-nopreemp", "-copy", "-nocopy",
	   "-scms", "-shorttrack", "-noshorttrack", "-packet", "-noclose",
	   "-media-info", "-minfo",
	   "-load", "-lock", "-raw96r", "-swab",
	   "-force", "-format",
	
	   "--adjust_speed_to_drive", "--allow_emulated_drives", "--allow_setuid",
	   "--allow_untested_media", "--any_track", "--demand_a_drive", 
	   "--fifo_disable", "--fifo_start_empty", "--fill_up_media",
	   "--list_ignored_options", "--no_rc", "--no_convert_fs_adr",
	   "--prodvd_cli_compatible", "--single_track", 
	   "--tell_media_space",
	
	   ""
	 };
	
	static char blank_help[][80]= {
	"Blanking options:",
	"\tall\t\tblank the entire disk",
	"\tdisc\t\tblank the entire disk",
	"\tdisk\t\tblank the entire disk",
	"\tfast\t\tminimally blank the entire disk",
	"\tminimal\t\tminimally blank the entire disk",
	"\tas_needed\tblank or format medium to make it ready for (re-)use",
	"\tdeformat\t\tblank a formatted DVD-RW",
	"\tdeformat_quickest\tminimally blank a formatted DVD-RW to DAO only",
	"\tformat_overwrite\tformat a DVD-RW to \"Restricted Overwrite\"",
	"@End_of_helptexT@"
	};
	
	 mem_do_close= xorriso->do_close;
	 mem_auto_close= xorriso->auto_close;
	 Xorriso_alloc_meM(track_source, char, SfileadrL);
	 Xorriso_alloc_meM(dev_adr, char, SfileadrL);
	
	 strcpy(mem_report_about_text, xorriso->report_about_text);
	
	 track_source[0]= 0;
	 dev_adr[0]= 0;
	 blank_mode[0]= 0;
	 speed[0]= 0;
	
	 if(xorriso->in_drive_handle != NULL) {
	   ret= Xorriso_option_dev(xorriso, "", 1|32); /* give up indev */
	   if(ret!=1)
	     goto ex;
	 }
	
	
	 /* Assess plan, make settings */
	 for(i= 0; i<argc; i++) {
	   sprintf(xorriso->info_text, "-as %s: ", whom);
	   Text_shellsafe(argv[i], xorriso->info_text, 1);
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
	
	   argpt= argv[i];
	   if (strncmp(argpt, "--", 2) == 0 && strlen(argpt) > 3)
	     argpt++;
	
	   for(k=0;ignored_partial_options[k][0]!=0;k++) {
	     if(argpt[0]=='-')
	       if(strncmp(argpt+1,ignored_partial_options[k],
	                            strlen(ignored_partial_options[k]))==0) {
	         argpt++;
	         goto no_volunteer;
	       }
	     if(strncmp(argpt,ignored_partial_options[k],
	                        strlen(ignored_partial_options[k]))==0)
	       goto no_volunteer;
	   }
	   for(k=0;ignored_full_options[k][0]!=0;k++)
	     if(strcmp(argpt,ignored_full_options[k])==0)
	       goto no_volunteer;
	   if(0) {
	no_volunteer:;
	     sprintf(xorriso->info_text, "-as %s: Ignored option ", whom);
	     Text_shellsafe(argpt, xorriso->info_text, 1);
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
	 continue;
	   }
	
	   if(strcmp(argpt, "-atip")==0) {
	     do_atip= 1;
	   } else if(strcmp(argpt, "-audio")==0) {
	     sprintf(xorriso->info_text, "-as %s: Option -audio not supported.", whom);
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	     ret= 0; goto ex;
	   } else if(strncmp(argpt, "-blank=", 7)==0 ||
	             strncmp(argpt, "blank=", 6)==0) {
	     cpt= strchr(argpt, '=')+1;
	     if(strcmp(cpt,"all")==0 || strcmp(cpt,"disc")==0
	        || strcmp(cpt,"disk")==0) {
	       strcpy(blank_mode, "all");
	     } else if(strcmp(cpt,"fast")==0 || strcmp(cpt,"minimal")==0) {
	       strcpy(blank_mode, "fast");
	     } else if(strcmp(cpt,"help")==0) {
	       strcpy(blank_mode, "help");
	     } else if(strcmp(cpt,"deformat")==0 ||
	               strcmp(cpt,"deformat_sequential")==0 ||
	               strcmp(cpt,"deformat_quickest")==0 ||
	               strcmp(cpt,"deformat_sequential_quickest")==0) {
	       strcpy(blank_mode, cpt);
	     } else if(strcmp(cpt,"format_overwrite")==0) {
	       strcpy(blank_mode, "format_overwrite");
	     } else if(strcmp(cpt,"as_needed")==0) {
	       strcpy(blank_mode, "as_needed");
	     } else {
	       sprintf(xorriso->info_text, "-as %s: blank=", whom);
	       Text_shellsafe(cpt, xorriso->info_text, 1);
	       strcat(xorriso->info_text, " not supported. See blank=help .");
	       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	       ret= 0; goto ex;
	     }
	   } else if(strcmp(argpt, "-checkdrive")==0) {
	     do_checkdrive= 1;
	   } else if(strcmp(argpt, "-dao")==0) {
	     xorriso->do_tao= -1;
	   } else if(strcmp(argpt, "-data")==0) {
	     /* ok */;
	   } else if(strncmp(argpt, "-dev=", 5)==0 ||
	             strncmp(argpt, "dev=", 4)==0) {
	     cpt= strchr(argpt, '=')+1;
	     strcpy(dev_adr, cpt);
	   } else if(strcmp(argv[i], "--devices")==0) {      /* intentional: argv[i] */
	     do_scanbus= 2;
	   } else if(strncmp(argpt,"driveropts=", 11)==0 ||
	             strncmp(argpt,"-driveropts=", 12)==0) {
	     if(strcmp(argpt+11, "help")==0) {
	       fprintf(stderr,"Driver options:\n");
	       fprintf(stderr,
	               "burnfree\tPrepare writer to use BURN-Free technology\n");
	     } 
	   } else if(strcmp(argpt, "-dummy")==0) {
	     xorriso->do_dummy= 1;
	   } else if(strncmp(argpt, "-dvd_obs=", 9)==0 ||
	             strncmp(argpt, "dvd_obs=", 8)==0) {
	     cpt= strchr(argpt, '=') + 1;
	     Xorriso_option_dvd_obs(xorriso, cpt, 0);
	   } else if(strcmp(argpt, "-eject")==0) {
	     do_eject= 1;
	   } else if(strncmp(argpt, "-fs=", 4)==0 || strncmp(argpt, "fs=", 3)==0) {
	     cpt= strchr(argpt, '=')+1;
	     ret= Xorriso_option_fs(xorriso, cpt, 0);
	     if(ret<=0)
	       goto ex;
	   } else if(strcmp(argv[i], "--grow_overwriteable_iso")==0 ||
	             strcmp(argv[i], "--grow_overwritable_iso")==0 ||
	             strcmp(argv[i], "--grow_overriteable_iso")==0
	             ) { /* (A history of typos) */
	                                                     /* intentional: argv[i] */
	     do_grow= 1;
	   } else if(strcmp(argpt, "-help")==0) {
	     do_help= 1;
	   } else if(strcmp(argpt, "-isosize")==0) {
	     do_isosize= 1;
	   } else if(strcmp(argpt, "-inq")==0) {
	     do_checkdrive= 2;
	   } else if(strcmp(argpt, "-mode2")==0) {
	     Xorriso_msgs_submit(xorriso, 0,
	                     "Defaulting option -mode2 to option -data", 0, "NOTE", 0);
	   } else if(strcmp(argpt, "-msinfo")==0) {
	     do_msinfo= 1;
	   } else if(strcmp(argpt, "-multi")==0) {
	     do_multi= 1;
	     do_auto_close= 0;
	   } else if(strcmp(argv[i], "--multi_if_possible") == 0) {
	     do_multi= 1;
	     do_auto_close= 1;
	   } else if(strcmp(argpt, "-nopad")==0) {
	     xorriso->padding= 0;
	   } else if(strcmp(argv[i], "--no_rc")==0) { /* intentional: argv[i] */
	     /* already performed in Xorriso_prescan_args */;
	   } else if(strcmp(argpt, "-pad")==0) {
	     xorriso->padding= 15*2048;
	   } else if(strncmp(argpt, "-padsize=", 9)==0 ||
	             strncmp(argpt, "padsize=", 8)==0) {
	     cpt= strchr(argpt, '=')+1;
	     ret= Xorriso_option_padding(xorriso, cpt, 0);
	     if(ret<=0)
	       goto ex;
	   } else if(strcmp(argpt, "-sao")==0) {
	     xorriso->do_tao= -1;
	   } else if(strcmp(argpt, "-scanbus")==0) {
	     sprintf(xorriso->info_text, "-as %s: Option -scanbus not supported.",
	             whom);
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	     ret= 0; goto ex;
	   } else if(strncmp(argpt, "-speed=", 7)==0 ||
	             strncmp(argpt, "speed=", 6)==0) {
	     cpt= strchr(argpt, '=')+1;
	     strncpy(speed, cpt, 79);
	     speed[79]= 0;
	   } else if(strncmp(argpt, "-stream_recording=", 18)==0 ||
	             strncmp(argpt, "stream_recording=", 17)==0) {
	     cpt= strchr(argpt, '=')+1;
	     Xorriso_option_stream_recording(xorriso, cpt, 0);
	
	   } else if(strncmp(argpt, "-use_immed_bit=", 15) == 0 ||
	             strncmp(argpt, "use_immed_bit=", 14) == 0) {
	     cpt= strchr(argpt, '=') + 1;
	     Xorriso_option_use_immed_bit(xorriso, cpt, 0);
	
	   } else if(strcmp(argpt, "-immed") == 0) {
	     Xorriso_option_modesty_on_drive(xorriso, "75", 0);
	
	   } else if(strncmp(argpt, "-minbuf=", 8) == 0 ||
	             strncmp(argpt, "minbuf=", 7) == 0 ||
	             strncmp(argpt, "-modesty_on_drive=", 18) == 0 ||
	             strncmp(argpt, "modesty_on_drive=", 17) == 0) {
	     cpt= strchr(argpt, '=') + 1;
	     Xorriso_option_modesty_on_drive(xorriso, cpt, 0);
	
	   } else if(strncmp(argpt, "-drive_scsi_dev_family=", 23) == 0 ||
	             strncmp(argpt, "drive_scsi_dev_family=", 22) == 0) {
	     cpt= strchr(argpt, '=') + 1;
	     Xorriso_option_scsi_dev_family(xorriso, cpt, 0);
	
	   } else if(strncmp(argpt, "-stdio_sync=", 12)==0 ||
	             strncmp(argpt, "stdio_sync=", 11)==0) {
	     cpt= strchr(argpt, '=') + 1;
	     Xorriso_option_stdio_sync(xorriso, cpt, 0);
	   } else if(strcmp(argpt, "-tao")==0) {
	     xorriso->do_tao= 1;
	   } else if(strcmp(argpt, "-toc")==0 || strcmp(argv[i], "--long_toc")==0) {
	                                             /* intentional: argpt , argv[i] */
	     do_toc= 1;
	   } else if(strncmp(argpt, "-tsize=", 7)==0 ||
	             strncmp(argpt, "tsize=", 6)==0) {
	     cpt= strchr(argpt, '=')+1;
	     tsize= Scanf_io_size(cpt, 1);
	     if(tsize > 1024.0*1024.0*1024.0*1024.0*1024.0) {
	       sprintf(xorriso->info_text, "-as %s: much too large: %s",whom, argpt);
	       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	       ret= 0; goto ex;
	     }
	   } else if(strcmp(argv[i], "-V")==0 || strcmp(argpt,"-Verbose")==0) {
	     Xorriso_option_scsi_log(xorriso, "on", 0);
	   } else if(strcmp(argv[i], "-v")==0 || strcmp(argpt,"-verbose")==0) {
	     do_verbous++;
	   } else if(strcmp(argv[i], "-vv")==0) { /* intentional: argv[i] */
	     do_verbous+= 2;
	   } else if(strcmp(argv[i], "-vvv")==0) { /* intentional: argv[i] */
	     do_verbous+= 3;
	   } else if(strcmp(argpt, "-version")==0) {
	     do_version= 1;
	   } else if(strcmp(argpt, "-waiti")==0) {
	     do_waiti= 1;
	   } else if(strncmp(argv[i], "write_start_address=", 20)==0) {
	                                                     /* intentional: argv[i] */
	     write_start_address= Scanf_io_size(argv[i]+20,0);
	   } else if(strcmp(argpt, "-xa")==0) {
	     Xorriso_msgs_submit(xorriso, 0,
	                        "Defaulting option -xa to option -data", 0, "NOTE", 0);
	   } else if(strcmp(argpt, "-xa1")==0) {
	     if(do_xa1 == 0)
	       do_xa1= 1;
	   } else if(strcmp(argv[i], "--xa1-ignore")==0) { /* intentional: argv[i] */
	     do_xa1= -1;
	   } else if(strcmp(argpt, "-xa2")==0) {
	     Xorriso_msgs_submit(xorriso, 0,
	                       "Defaulting option -xa2 to option -data", 0, "NOTE", 0);
	   } else if(strcmp(argpt, "-xamix")==0) {
	     Xorriso_msgs_submit(xorriso, 0,
	   "Option -xamix not implemented and data not yet convertible to other modes",
	                         0, "FATAL", 0);
	     ret= 0; goto ex;
	   } else if(argpt[0]=='-' && argpt[1]!=0) {
	     sprintf(xorriso->info_text, "-as %s: Unknown option ", whom);
	     Text_shellsafe(argv[i], xorriso->info_text, 1);
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	     ret= 0; goto ex;
	   } else {
	     if(track_source[0]) {
	       sprintf(xorriso->info_text, "-as %s: Surplus track source ", whom);
	       Text_shellsafe(argv[i], xorriso->info_text, 1);
	       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	       sprintf(xorriso->info_text, "First and only track source is ");
	       Text_shellsafe(track_source, xorriso->info_text, 1);
	       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
	       ret= 0; goto ex;
	     }
	     if(Sfile_str(track_source, argv[i], 0)<=0)
	       {ret= -1; goto ex;}
	   }
	 }
	
	 /* Perform actions */
	 Xorriso_option_report_about(xorriso, "NOTE", 0);
	 if(do_version) {
	   sprintf(xorriso->result_line, "Cdrecord 2.01-Emulation Copyright (C) 2017 see libburnia-project.org xorriso\n");
	   Xorriso_result(xorriso, 1);
	   Xorriso_option_version(xorriso, 0);
	 }
	
	 if(do_help) {
	   Xorriso_cdrskin_help(xorriso, 0);
	 }
	 if(strcmp(blank_mode, "help")==0) {
	   for(i= 0; strcmp(blank_help[i], "@End_of_helptexT@")!=0; i++) {
	     sprintf(xorriso->info_text, "%s\n", blank_help[i]);
	     Xorriso_info(xorriso,0);
	   }
	 }
	 if(do_help || strcmp(blank_mode, "help") == 0 || do_version) {
	   ret= 1; goto ex;
	 }
	
	 if(do_verbous<=0)
	   report_about= "NOTE";
	 else if(do_verbous<=2)
	   report_about= "UPDATE";
	 else if(do_verbous==3)
	   report_about= "DEBUG";
	 else
	   report_about= "ALL";
	 Xorriso_option_report_about(xorriso, report_about, 0);
	
	 if(do_scanbus) {
	   if(do_scanbus==1)
	     /* >>> would need -scanbus compatible output and input format */;
	   else
	     Xorriso_option_devices(xorriso, 0);
	   ret= 1; goto ex;
	 }
	
	 if(!(do_checkdrive || do_atip || do_toc || blank_mode[0] || track_source[0] ||
	      do_eject || do_msinfo)) {
	   sprintf(xorriso->info_text,
	           "-as cdrskin: No option specified, which would cause an action.");
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
	   ret= 1; goto ex;
	 }
	
	 if(do_waiti) {
	   sprintf(xorriso->info_text,
	       "xorriso: Option -waiti pauses program until input appears at stdin\n");
	   Xorriso_info(xorriso,0);
	   sprintf(xorriso->result_line, "Waiting for data on stdin...\n");
	   Xorriso_result(xorriso, 1);
	   for(ret= 0; ret==0; )
	     ret= Wait_for_input(0,1000000,0);
	   if(ret<0 || feof(stdin)) {
	     Xorriso_msgs_submit(xorriso, 0,
	                    "stdin produces exception rather than data", 0, "NOTE", 0);
	   }
	   sprintf(xorriso->info_text, "xorriso: Option -waiti pausing is done.\n");
	 }
	 if(dev_adr[0]) {
	   hflag= 2 | 64;       /* ts B11201 no more:  | 32 */
	   if(!do_grow)
	     hflag|= 8; /* consider overwriteables as blank */
	   ret= Xorriso_option_dev(xorriso, dev_adr, hflag);
	   if(ret<=0)
	     goto ex;
	 }
	
	 if(xorriso->out_drive_handle==NULL) {
	   sprintf(xorriso->info_text, "-as %s: No output drive selected", whom);
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	   ret= 0; goto ex;
	 }
	
	 if(do_msinfo) {
	   ret= Xorriso_msinfo(xorriso, &msc1, &msc2, 2 | !!do_grow);
	   if(ret<=0)
	     goto ex;
	   sprintf(xorriso->result_line, "%d,%d\n", msc1, msc2);
	   Xorriso_result(xorriso, 1);
	 }
	
	 if(speed[0]) {
	   ret= Xorriso_option_speed(xorriso, speed, 0);
	   if(ret<=0)
	     goto ex;
	 }
	
	 if(do_checkdrive) {
	   ret= Xorriso_atip(xorriso, 2-(do_checkdrive==2));
	   if(ret<=0)
	     goto ex;
	 }
	 if(do_atip) {
	   ret= Xorriso_atip(xorriso, 0);
	   if(ret<=0)
	     goto ex;
	 }
	 if(do_toc) {
	   ret= Xorriso_option_toc(xorriso, 0);
	   if(ret<=0)
	     goto ex;
	 }
	 if(strcmp(blank_mode, "format_overwrite")==0) {
	   ret= Xorriso_option_blank(xorriso, "fast", 1);
	   if(ret<=0)
	     goto ex;
	 } else if(blank_mode[0]) {
	   ret= Xorriso_option_blank(xorriso, blank_mode, 0);
	   if(ret<=0)
	     goto ex;
	 }
	 if(track_source[0]) {
	   xorriso->do_close= !do_multi;
	   xorriso->auto_close= do_auto_close;
	   ret= Xorriso_burn_track(xorriso, (off_t) write_start_address,
	                           track_source, (off_t) tsize,
	                   (!!do_grow) | ((!!do_isosize) << 1) | ((do_xa1 == 1) << 2));
	   if(ret == 2) {
	     ret= Xorriso_retry_burn_track(xorriso, (off_t) write_start_address,
	                           track_source, (off_t) tsize,
	                   (!!do_grow) | ((!!do_isosize) << 1) | ((do_xa1 == 1) << 2));
	   }
	   aq_ret= Xorriso_reaquire_outdev(xorriso, 2*(ret>0));
	   if(ret<=0 && ret<aq_ret)
	     goto ex;
	   if(aq_ret<=0)
	     {ret= aq_ret; goto ex;}
	 }
	
	 ret= 1;
	ex:;
	 if(do_eject && ret>=0) {
	   eject_ret= Xorriso_option_eject(xorriso, "out", 0);
	   if(eject_ret<ret)
	     ret= eject_ret;
	 }
	 if(ret<=0) {
	   sprintf(xorriso->info_text, "-as %s: Job could not be performed properly.",
	           whom);
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	 }
	 Xorriso_option_report_about(xorriso, mem_report_about_text, 0);
	 xorriso->do_close= mem_do_close;
	 xorriso->auto_close= mem_auto_close;
	 Xorriso_free_meM(dev_adr);
	 Xorriso_free_meM(track_source);
	 return(ret);
	}
	
	
	/* This function shall know all options of mkisofs, genisoimage, xorrisofs, ...
	   and the number of arguments which they expect and consume.
	*/
	int Xorriso_genisofs_count_args(struct XorrisO *xorriso, int argc, char **argv,
	                                int *count, int flag)
	{
	 int i;
	 char *cmd;
	
	 static char partial_options[][41]= {
	    "errctl=",
	    "isolinux_mbr=", "--modification-date=",
	    ""
	 };
	 static char arg0_options[][41]= {
	    "-allow-leading-dots", "-ldots", "-allow-lowercase", "-allow-multidot",
	    "-cache-inodes", "-no-cache-inodes", "-eltorito-alt-boot",
	    "-hard-disk-boot", "-no-emul-boot", "-no-boot", "-boot-info-table",
	    "-check-oldnames", "-d", "-D", "-dvd-video", "-f", "-gui", "-graft-points",
	    "-hide-joliet-trans-tbl", "-hide-rr-moved", "-J", "-joliet-long", "-l",
	    "-L", "-max-iso9660-filenames", "-N", "-nobak", "-no-bak",
	    "-no-limit-pathtables", "-force-rr", "-no-rr",
	    "-no-split-symlink-components", "-no-split-symlink-fields", "-pad",
	    "-no-pad", "-posix-H", "-posix-L", "-posix-P", "-print-size",
	    "-quiet", "-R", "-r", "-relaxed-filenames", "-rrip110", "-rrip112",
	    "-split-output", "-T", "-UDF", "-udf", "-udf-symlinks", "-no-udf-symlinks",
	    "-U", "-no-iso-translate", "-v", "-XA", "-xa", "-z",
	    "-hfs", "-no-hfs", "-apple", "-probe", "-no-desktop", "-mac-name",
	    "-part", "-icon-position", "-chrp-t", "-hfs-unlock", "--cap", "--netatalk",
	    "--double", "--ethershare", "--ushare", "--exchange", "--sgi", "--xinet",
	    "--macbin", "--single", "--dave", "--sfm", "--osx-double", "--osx-hfs",
	    "-debug", "-omit-period", "-disable-deep-relocation", "-joliet",
	    "-full-iso9660-filenames", "-follow-links", "-help",
	    "-transparent-compression",
	    "-omit-version-number", "-rational-rock", "-rock", "-translation-table",
	    "-untranslated-filenames", "-verbose", "-version", "-g", "-h",
	    "-no-mac-files", "-chrp-boot",
	    "--hardlinks", "--acl", "--xattr", "--md5", "--for_backup",
	    "--protective-msdos-label", "--boot-catalog-hide", "--no-emul-toc",
	    "--emul-toc", "-disallow_dir_id_ext", "--old-empty",
	    "--old-root-no-md5", "--old-root-devno", "--old-root-no-ino",
	    "--no_rc", "--norock", "-hfsplus", "-fat", "-chrp-boot-part",
	    "-isohybrid-gpt-basdat", "-isohybrid-gpt-hfsplus",
	    "-isohybrid-apm-hfsplus", "--grub2-boot-info", "-joliet-utf16",
	    "-appended_part_as_gpt", "-appended_part_as_apm", "--mbr-force-bootable",
	    "-part_like_isohybrid",
	    ""
	 };
	 static char arg1_options[][41]= {
	    "-abstract", "-A", "-appid", "--application_use",
	    "-biblio", "-b", "-B", "-boot-load-seg",
	    "-boot-load-size", "-C", "-c", "-check-session", "-copyright",
	    "-dir-mode", "-eltorito-id", "-eltorito-selcrit",
	    "-file-mode", "-G", "-gid", "-hide", "-hide-list",
	    "-hidden", "-hidden-list", "-hide-joliet", "-hide-joliet-list",
	    "-hide-hfsplus", "-hide-hfsplus-list",
	    "-hide-udf", "-hide-udf-list", "-input-charset", "-output-charset",
	    "-iso-level", "-jcharset", "-log-file", "-m", "-exclude-list", "-M",
	    "-dev", "-new-dir-mode", "-o", "-p", "-preparer",
	    "-path-list", "-publisher", "-root",
	    "-old-root", "-s", "-sectype", "-sort", "-sparc-boot", "-sparc-label",
	    "-stream-media-size", "-stream-file-name", "-sunx86-boot", "-sunx86-label",
	    "-sysid", "-table-name", "-ucs-level", "-uid", "-V", "-volset",
	    "-volset-size", "-volset-seqno", "-x", "-P",
	    "-map", "-magic", "-hfs-creator", "-hfs-type", "-boot-hfs-file", "-auto",
	    "-cluster-size", "-hide-hfs", "-hide-hfs-list", "-hfs-volid",
	    "-root-info", "-prep-boot", "-input-hfs-charset", "-output-hfs-charset",
	    "-hfs-bless", "-hfs-parms", 
	    "-eltorito-boot", "-generic-boot", "-eltorito-catalog", "-cdrecord-params",
	    "-errctl", "-exclude", "-prev-session", "-output", "-use-fileversion",
	    "-volid", "-old-exclude",
	    "-alpha-boot", "-hppa-cmdline", "-hppa-kernel-32", "-hppa-kernel-64",
	    "-hppa-bootloader", "-hppa-ramdisk", "-mips-boot", "-mipsel-boot",
	    "-jigdo-jigdo", "-jigdo-template", "-jigdo-min-file-size",
	    "-jigdo-force-md5", "-jigdo-exclude", "-jigdo-map", "-md5-list",
	    "-jigdo-template-compress",
	    "-checksum_algorithm_iso", "-checksum_algorithm_template",
	    "--stdio_sync", "--quoted_path_list", "--efi-boot", "--embedded-boot",
	    "-isohybrid-mbr", "-e", "-partition_offset", "-partition_hd_cyl",
	    "-partition_sec_hd", "-partition_cyl_align", "-untranslated_name_len",
	    "-rr_reloc_dir", "-hfsplus-serial-no", "-prep-boot-part", "-efi-boot-part",
	    "-hfsplus-block-size", "-apm-block-size", "--grub2-mbr",
	    "--grub2-sparc-core", "--sort-weight-list", "--sort-weight-patterns",
	    "-hppa-hdrversion", "-file_name_limit", "--set_all_file_dates",
	    "--gpt_disk_guid", "-iso_mbr_part_type", "-eltorito-platform",
	    ""
	 };
	 static char arg2_options[][41]= {
	    "-hfs-bless-by", "--scdbackup_tag", "--sort-weight",
	    ""
	 };
	 static char arg3_options[][41]= {
	    "-append_partition", "-hfsplus-file-creator-type",
	    ""
	 };
	 static char final_options[][41]= {
	    "-find",
	    ""
	 };
	
	 cmd= argv[0];
	 *count= 0;
	 for(i=0; partial_options[i][0]!=0; i++)
	   if(strncmp(partial_options[i], cmd, strlen(partial_options[i]))==0)
	     return(1);
	 for(i=0; arg0_options[i][0]!=0; i++)
	   if(strcmp(arg0_options[i], cmd)==0)
	     return(1);
	 *count= 1;
	 for(i=0; arg1_options[i][0]!=0; i++)
	   if(strcmp(arg1_options[i], cmd)==0)
	     return(1);
	 *count= 2;
	 for(i=0; arg2_options[i][0]!=0; i++)
	   if(strcmp(arg2_options[i], cmd)==0)
	     return(1);
	 *count= 3;
	 for(i=0; arg3_options[i][0]!=0; i++)
	   if(strcmp(arg3_options[i], cmd)==0)
	     return(1);
	 *count= argc - 1;
	 for(i=0; final_options[i][0]!=0; i++)
	   if(strcmp(final_options[i], cmd)==0)
	     return(1);
	 *count= 0;
	 return(0); 
	}
	
	
	/* @param flag bit0= do not report eventual ignore decision
	*/
	int Xorriso_genisofs_ignore(struct XorrisO *xorriso, char *whom,
	                            char *argpt, int *i, int flag)
	{
	 /* mkisofs 2.01 options which are not scheduled for implementation, yet */
	 static char ignored_arg0_options[][41]= {
	   "-allow-leading-dots", "-ldots", "-allow-multidot",
	   "-cache-inodes", "-check-oldnames",
	   "-L", "-no-bak", "-no-cache-inodes",
	   "-no-split-symlink-components", "-no-split-symlink-fields", "-nobak",
	   "-force-rr", "-T",
	   "-no-iso-translate",
	   ""
	 };
	 static char ignored_arg1_options[][41]= {
	   "-check-session", "-hide-hfs", "-hide-hfs-list",
	   "-table-name", "-volset-seqno", "-volset-size", "-sort",
	   ""
	 };
	 int k;
	
	 for(k=0;ignored_arg0_options[k][0]!=0;k++)
	   if(strcmp(argpt,ignored_arg0_options[k])==0)
	     goto no_volunteer;
	 for(k=0;ignored_arg1_options[k][0]!=0;k++)
	   if(strcmp(argpt,ignored_arg1_options[k])==0) {
	     (*i)++;
	     goto no_volunteer;
	   }
	 return(0);
	no_volunteer:;
	 sprintf(xorriso->info_text, "-as %s: Ignored option ", whom);
	 Text_shellsafe(argpt, xorriso->info_text, 1);
	 if(!(flag & 1))
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
	 return(1);
	}
	
	
	int Xorriso_genisofs_add_boot(struct XorrisO *xorriso, int flag)
	{
	 int ret;
	
	 if(xorriso->boot_img_size_default && xorriso->boot_image_emul == 0)
	   xorriso->boot_img_full_size= 1;
	 ret= Xorriso_attach_boot_image(xorriso, 0);
	 if(ret <= 0)
	   xorriso->boot_image_bin_path[0]= 0;
	 return(ret);
	}
	
	
	int Xorriso_genisofs_help(struct XorrisO *xorriso, int flag)
	{
	 static char helptext[][160]= {
	"Usage: xorriso -as mkisofs [options] file...",
	"Note: This is not mkisofs. See xorriso -help, xorriso -version, man xorrisofs",
	"Options:",
	"  -f, -follow-links           Follow symbolic links",
	"  -graft-points               Allow to use graft points for filenames",
	"  -help                       Print option help",
	"  -hfsplus                    Generate HFS+ filesystem",
	"  -hfsplus-file-creator-type CREATOR TYPE iso_rr_path",
	"                              Attach creator and type to a File",
	"  -hfs-bless FOLDER_NAME      Name of Folder to be blessed",
	"  -hfs-bless-by BLESS_TYPE ISO_RR_PATH",
	"                              Bless ISO_RR_PATH by BLESS_TYPE {p,i,s,9,x}",
	"  -hfsplus-serial-no HEXSTRING",
	"                              HFS serial number: 16 characters [0-9a-fA-F]",
	"  -hfsplus-block-size NUMBER  Set HFS+ block size",
	"  -apm-block-size NUMBER      Set Apple Partition Map block size",
	"  -hide GLOBFILE              Hide ISO9660/RR file",
	"  -hide-list FILE             File with list of ISO9660/RR files to hide",
	"  -hide-joliet GLOBFILE       Hide Joliet file",
	"  -hide-joliet-list FILE      File with list of Joliet files to hide",
	"  -hide-hfsplus GLOBFILE      Hide HFS+ file",
	"  -hide-hfsplus-list FILE     File with list of HFS+ files to hide",
	"  -input-charset CHARSET      Local input charset for file name conversion",
	"  -output-charset CHARSET     Output charset for file name conversion",
	"  -iso-level LEVEL            Set ISO9660 conformance level (1..3) or 4 for ISO9660 version 2",
	"  -disallow_dir_id_ext        Do not allow dot in ISO directory names",
	"  -J, -joliet                 Generate Joliet directory information",
	"  -joliet-long                Allow Joliet file names to be 103 Unicode characters",
	"  -joliet-utf16               Encode Joliet names in UTF-16BE rather than UCS-2",
	"  -U, -untranslated-filenames Allow Untranslated filenames (for HPUX & AIX - violates ISO9660).",
	"  -untranslated_name_len LEN  Allow up to LEN (1..96) name characters (heavily violates ISO9660).",
	"  -allow-lowercase            Allow lower case characters in addition to the current character set (violates ISO9660)",
	"  -relaxed-filenames          Allow 7 bit ASCII except lower case characters (violates ISO9660)",
	"  -d, -omit-period            Omit trailing periods from filenames (violates ISO9660)",
	"  -l, -full-iso9660-filenames Allow full 31 character filenames for ISO9660 names",
	"  -max-iso9660-filenames      Allow 37 character filenames for ISO9660 names (violates ISO9660)",
	"  -N, -omit-version-number    Omit version number from ISO9660 filename (violates ISO9660)",
	"  -D, -disable-deep-relocation",
	"                              Disable deep directory relocation (violates ISO9660)",
	"  -hide-rr-moved              Relocate deep directories to /.rr_moved",
	"  -rr_reloc_dir NAME          Set deep directory relocation target in root",
	"  -o FILE, -output FILE       Set output file name",
	"  -m GLOBFILE, -exclude GLOBFILE",
	"                              Exclude file name",
	"  -x FILE, -old-exclude FILE  Exclude file name",
	"  -exclude-list FILE          File with list of file names to exclude",
	"  -pad                        Pad output by 300k (default)",
	"  -no-pad                     Do not pad output",
	"  -M FILE, -prev-session FILE Set path to previous session to merge",
	"  -C PARAMS, -cdrecord-params PARAMS",
	"                              Magic paramters from cdrecord",
	"  -dir-mode mode              Make the mode of all directories this mode.",
	"  -file-mode mode             Make the mode of all plain files this mode.",
	"  -path-list FILE             File with list of pathnames to process",
	"  --quoted_path_list FILE     File with list of quoted pathnames to process",
	"  -print-size                 Print estimated filesystem size and exit",
	"  -quiet                      Run quietly",
	"  -gui                        Switch behaviour for GUI",
	"  -R, -rock                   Generate Rock Ridge directory information",
	"  -r, -rational-rock          Generate rationalized Rock Ridge directory information",
	"  --norock                    Disable Rock Ridge. (Strongly discouraged !)",
	"  -file_name_limit LEN        Set truncation limit for Rock Ridge names",
	"  --hardlinks                 Record eventual hard link relations of files",
	"  --acl                       Record eventual ACLs of files",
	"  --xattr                     Record eventual user space xattr of files",
	"  --md5                       Compute and record MD5 checksums of data files",
	"  --scdbackup_tag PATH NAME   With --md5 record a scdbackup checksum tag",
	"  --for_backup                Use all options which improve backup fidelity",
	"  -V ID, -volid ID            Set Volume ID",
	"  -volset ID                  Set Volume set ID",
	"  -publisher PUB              Set Volume publisher",
	"  -A ID, -appid ID            Set Application ID",
	"  -sysid ID                   Set System ID",
	"  -p PREP, -preparer PREP     Set Volume preparer",
	"  -abstract FILE              Set Abstract filename",
	"  -biblio FILE                Set Bibliographic filename",
	"  -copyright FILE             Set Copyright filename",
	"  --application_use CHAR|PATH  Set content of Application Use field",
	"  -jigdo-jigdo FILE           Produce a jigdo .jigdo file as well as the .iso",
	"  -jigdo-template FILE        Produce a jigdo .template file as well as the .iso",
	"  -jigdo-min-file-size SIZE   Minimum size for a file to be listed in the jigdo file", 
	"  -jigdo-force-md5 PATTERN    Pattern(s) where files MUST match an externally-supplied MD5sum",
	"  -jigdo-exclude PATTERN      Pattern(s) to exclude from the jigdo file",
	"  -jigdo-map PATTERN1=PATTERN2",
	"                              Pattern(s) to map paths (e.g. Debian=/mirror/debian)",
	"  -md5-list FILE              File containing MD5 sums of the files that should be checked",
	"  -jigdo-template-compress ALGORITHM",
	"                              Choose to use gzip or bzip2 compression for template data; default is gzip",
	"  -checksum_algorithm_iso alg1,alg2,...",
	"                              Specify the checksum types desired for the output image (in .jigdo)",
	"  -checksum_algorithm_template alg1,alg2,...",
	"                              Specify the checksum types desired for the output jigdo template",
	"  -eltorito-platform          Set El Torito platform id for the next boot entry",
	"  -b FILE, -eltorito-boot FILE",
	"                              Set El Torito boot image name",
	"  -eltorito-alt-boot          Start specifying alternative El Torito boot parameters",
	"  --efi-boot FILE             Set El Torito EFI boot image name and type",
	"  -e FILE                     Set EFI boot image name (more rawly)",
	"  -c FILE, -eltorito-catalog FILE",
	"                              Set El Torito boot catalog name",
	"  --boot-catalog-hide         Hide boot catalog from ISO9660/RR and Joliet",
	"  -boot-load-size #           Set numbers of load sectors",
	"  -hard-disk-boot             Boot image is a hard disk image",
	"  -no-emul-boot               Boot image is 'no emulation' image",
	"  -boot-info-table            Patch boot image with info table",
	"  --grub2-boot-info           Patch boot image at byte 2548",
	"  -eltorito-id ID             Set El Torito Id String",
	"  -eltorito-selcrit HEXBYTES  Set El Torito Selection Criteria",
	"  -isohybrid-gpt-basdat       Mark El Torito boot image as Basic Data in GPT",
	"  -isohybrid-gpt-hfsplus      Mark El Torito boot image as HFS+ in GPT",
	"  -isohybrid-apm-hfsplus      Mark El Torito boot image as HFS+ in APM",
	"  -part_like_isohybrid        Mark in MBR, GPT, APM without -isohybrid-mbr",
	"  -iso_mbr_part_type          Set type byte of ISO partition in MBR",
	"  --gpt_disk_guid GUID        Set GPT disk GUID or choose automatic GUID",
	"  -G FILE, -generic-boot FILE Set generic boot image name",
	"  --embedded-boot FILE        Alias of -G",
	"  --protective-msdos-label    Patch System Area by partition table",
	"  --mbr-force-bootable        Enforce existence of bootable flag in MBR",
	"  -partition_offset LBA       Make image mountable by first partition, too",
	"  -partition_sec_hd NUMBER    Define number of sectors per head",
	"  -partition_hd_cyl NUMBER    Define number of heads per cylinder",
	"  -partition_cyl_align MODE   Control cylinder alignment: off, on, auto, all",
	"  -mips-boot FILE             Set mips boot image name (relative to image root)",
	"  -mipsel-boot FILE           Set mipsel boot image name (relative to image root)",
	"  -B FILES, -sparc-boot FILES Set sparc boot image names",
	"  -sparc-label label text     Set sparc boot disk label",
	"  -hppa-cmdline CMDLINE       Set hppa boot command line",
	"  -hppa-kernel-32 FILE        Set hppa 32-bit image name (relative to image root)",
	"  -hppa-kernel-64 FILE        Set hppa 64-bit image name (relative to image root)",
	"  -hppa-bootloader FILE       Set hppa boot loader file name (relative to image root)",
	"  -hppa-ramdisk FILE          Set hppa ramdisk file name (relative to image root)",
	"  -hppa-hdrversion NUMBER     Set hppa PALO header version to 4 or 5",
	"  -alpha-boot FILE            Set alpha boot image name (relative to image root)",
	"  --grub2-sparc-core FILE     Set path of core file for disk label patching",
	"  -efi-boot-part DISKFILE|--efi-boot-image",
	"                              Set data source for EFI System Partition",
	"  -chrp-boot-part             Mark ISO image size by MBR partition type 0x96",
	"  -chrp-boot                  Alias of -chrp-boot-part",
	"  -prep-boot-part DISKFILE    Set data source for MBR partition type 0x41",
	"  -append_partition NUMBER TYPE FILE",
	"                              Append FILE after image. TYPE is hex: 0x..",
	"  -appended_part_as_gpt       mark appended partitions in GPT instead of MBR.",
	"  -appended_part_as_apm       mark appended partitions in APM.",
	"  --modification-date=YYYYMMDDhhmmsscc",
	"                              Override date of creation and modification",
	"  --set_all_file_dates TIME   Override mtime, atime, ctime in all files",
	"  -isohybrid-mbr FILE         Set SYSLINUX mbr/isohdp[fp]x*.bin for isohybrid",
	"  --grub2-mbr FILE            Set GRUB2 MBR for boot image address patching",
	#ifdef Xorriso_with_isohybriD
	"  isolinux_mbr=on|auto|off    Control eventual isohybrid MBR generation",
	#endif
	"  --sort-weight NUMBER FILE   Set LBA weight number to file or file tree",
	"  --sort-weight-list DISKFILE Read list of NUMBER FILE pairs for --sort-weight",
	"  --sort-weight-patterns DISKFILE  --sort-weight-list with pattern expansion",
	"  --stdio_sync on|off|number  Control forced output to disk files",
	"  --no-emul-toc               Save 64 kB size on random access output files",
	"  --emul-toc                  Multi-session history on such output files",
	"  --old-empty                 Use old style block addresses for empty files",
	"  -z, -transparent-compression",
	"                              Enable transparent compression of files",
	"  -root DIR                   Set root directory for all new files and directories",
	"  -old-root DIR               Set root directory in previous session that is searched for files",
	"  --old-root-no-md5           Do not record and use MD5 with -old-root",
	"  --old-root-no-ino           Do not use disk inode numbers with -old-root",
	"  --old-root-devno            Use disk device numbers with -old-root",
	"  -log-file LOG_FILE          Re-direct messages to LOG_FILE",
	"  --no_rc                     Do not execute startup files",
	"  -v, -verbose                Verbose",
	"  -version                    Print the current version",
	"@End_of_helptexT@"
	};
	
	 char ra_text[80];
	 int i;
	
	 strcpy(ra_text, xorriso->report_about_text);
	
	 Xorriso_option_report_about(xorriso, "NOTE", 0);
	 for(i= 0; strcmp(helptext[i], "@End_of_helptexT@")!=0; i++) {
	   sprintf(xorriso->info_text, "%s\n", helptext[i]);
	   Xorriso_info(xorriso, 1 | 2);
	 }
	 Xorriso_option_report_about(xorriso, ra_text, 0);
	 return(1);
	}
	
	
	/* Perform hiding.
	   Cumbersome: The paths and patterns apply to the disk address and not
	   to the Rock Ridge address. Actually even the literal form of the
	   mkisofs pathspec would matter (e.g. "./" versus "").
	   But xorriso normalizes disk_paths before further processing. Thus
	   the literal form does not matter.
	   @param hide_attrs
	          bit0= hide in ISO/RR
	          bit1= hide in Joliet
	          bit2= hide in HFS+
	          bit3 to bit5 are reserved for future hidings
	*/
	int Xorriso_genisofs_hide(struct XorrisO *xorriso, char *whom,
	                          char *pattern, int hide_attrs, int flag)
	{
	 int zero= 0, ret;
	 char *argv[1];
	
	 if((hide_attrs & 63) == 0)
	   return(2);
	
	 if(strchr(pattern, '/') != NULL) {
	   argv[0]= pattern;
	   ret= Xorriso_option_not_paths(xorriso, 1, argv, &zero,
	                                 4 | ((hide_attrs & 63) << 8));
	 } else {
	   ret= Xorriso_option_not_leaf(xorriso, pattern, hide_attrs & 63);
	 }
	 return(ret);
	}
	
	
	/* @param flag bit0= quoted list */
	int Xorriso_genisofs_hide_list(struct XorrisO *xorriso, char *whom,
	                               char *adr, int hide_attrs, int flag)
	{
	 int ret, linecount= 0, argc= 0, was_failure= 0, i, fret;
	 char **argv= NULL, *id= "";
	 FILE *fp= NULL;
	
	 if(adr[0]==0) {
	   if (hide_attrs & 2)
	     id = "joliet-";
	   else if (hide_attrs & 4)
	     id = "hfsplus-";
	   sprintf(xorriso->info_text,
	          "Empty file name given with -as %s -hide-%slist", whom, id);
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING", 0);
	   return(0);
	 }
	 ret= Xorriso_afile_fopen(xorriso, adr, "rb", &fp, 0);
	 if(ret <= 0)
	   return(0);
	 while(1) {
	   ret= Xorriso_read_lines(xorriso, fp, &linecount, &argc, &argv,
	                           4 | (flag & 1) );
	   if(ret <= 0)
	     goto ex;
	   if(ret == 2)
	 break;
	   for(i= 0; i < argc; i++) {
	     if(argv[i][0] == 0)
	   continue;
	     ret= Xorriso_genisofs_hide(xorriso, whom, argv[i], hide_attrs, 0);
	     if(ret <= 0 || xorriso->request_to_abort) {
	       was_failure= 1;
	       fret= Xorriso_eval_problem_status(xorriso, ret, 1|2);
	       if(fret>=0)
	   continue;
	       if(ret > 0)
	         ret= 0;
	       goto ex;
	     }
	   }
	 }

(1) Event start:

Starting defect path here.

	 ret= 1;
	ex:;

(2) Event cond_true:

Condition "flag & 1", taking true branch.

	 if(flag & 1)

(3) Event alloc_arg:	"Xorriso_read_lines" allocates memory that is stored into "argv". [details]
Also see events:	[leaked_storage]

	   Xorriso_read_lines(xorriso, fp, &linecount, &argc, &argv, 2);

(4) Event cond_true:	Condition "fp != NULL", taking true branch.
(5) Event cond_true:	Condition "fp != stdin", taking true branch.

	 if(fp != NULL && fp != stdin)
	   fclose(fp);

(6) Event cond_false:

Condition "ret <= 0", taking false branch.

	 if(ret<=0)

(7) Event if_end:

End of if statement.

	   return(ret);

(8) Event cond_true:	Condition "!was_failure", taking true branch.
(9) Event leaked_storage:	Variable "argv" going out of scope leaks the storage it points to.
Also see events:	[alloc_arg]

	 return(!was_failure);
	}
	
	
	/* Strip surplus dash from known single-dash long options */
	int Xorriso_genisofs_strip_dash(struct XorrisO *xorriso, char *arg_in,
	                                 char **arg_out, int flag)
	{
	 int ret, count;
	 char *argv[1];
	
	 *arg_out= arg_in;
	 if(strlen(arg_in) < 4)
	   return(1);
	 if(arg_in[0] != '-' || arg_in[1] != '-' || arg_in[2] == '-')
	   return(1);
	
	 argv[0]= arg_in + 1; 
	 ret= Xorriso_genisofs_count_args(xorriso, 1, argv, &count, 0);
	 if(ret > 0)
	   *arg_out= arg_in + 1;
	 return(1);
	}
	
	
	/* Interprets a string of single-char options which have no parameters
	   @param flag bit0=check whether string is ok
	               bit1=this is pass 1
	   @return with flag bit0: 0=no , 1=yes, 2= with bit1: non-pass-1 options seen
	           else          : 1 = ok , <= 0 indicates error
	*/
	int Xorriso_genisofs_fused_options(struct XorrisO *xorriso, char *whom,
	                                   char *opts,
	                                   int *option_d, int *iso_level, int *lower_r,
	                                   char ra_text[80], int flag)
	{
	 int ret, non_pass1= 0;
	 char *cpt;
	 static char pass1_covered[]= {"fvz"};
	 static char covered[]= {"dDfJlNRrTUvz"};
	
	 if(flag & 1) {
	   for(cpt= opts; *cpt != 0; cpt++) {
	     if(strchr(covered, *cpt) == NULL)
	       {ret= 0; goto ex;}
	     if(flag & 2)
	       if(strchr(pass1_covered, *cpt) == NULL)
	         non_pass1= 1;
	   }
	   ret= 1 + non_pass1; goto ex;
	 }
	 
	 for(cpt= opts; *cpt != 0; cpt++) {
	   if(*cpt == 'd') {
	     if(flag & 2)
	 continue;
	     Xorriso_relax_compliance(xorriso, "no_force_dots", 0);
	   } else if(*cpt == 'D') {
	     if(flag & 2)
	 continue;
	     *option_d= 1;
	   } else if(*cpt == 'f') {
	     if(!(flag & 2))
	 continue;
	     ret= Xorriso_option_follow(xorriso, "on", 0);
	     if(ret <= 0)
	       goto ex;
	   } else if(*cpt == 'J') {
	     if(flag & 2)
	 continue;
	     xorriso->do_joliet= 1;
	   } else if(*cpt == 'l') {
	     if(flag & 2)
	 continue;
	     if(xorriso->iso_level <= 2)
	       Xorriso_relax_compliance(xorriso, "iso_9660_level=2", 0);
	     if(*iso_level <= 2)
	       *iso_level= 2;
	   } else if(*cpt == 'N') {
	     if(flag & 2)
	 continue;
	     Xorriso_relax_compliance(xorriso, "omit_version", 0);
	   } else if(*cpt == 'R') {
	     if(flag & 2)
	 continue;
	     xorriso->do_rockridge= 1;
	   } else if(*cpt == 'r') {
	     if(flag & 2)
	 continue;
	     xorriso->do_rockridge= 1;
	     *lower_r= 1;
	   } else if(*cpt == 'T') {
	     /* ignored */;
	   } else if(*cpt == 'U') {
	     if(flag & 2)
	 continue;
	     Xorriso_relax_compliance(xorriso,
	       "no_force_dots:long_paths:long_names:omit_version:full_ascii:lowercase",
	                              0);
	   } else if(*cpt == 'v') {
	     if(!(flag & 2))
	 continue;
	     strcpy(ra_text, "UPDATE");
	   } else if(*cpt == 'z') {
	     if(!(flag & 2))
	 continue;
	     Xorriso_option_zisofs(xorriso, "by_magic=on", 0);
	   } else {
	     sprintf(xorriso->info_text, "-as %s: Unsupported option -%c", whom, *cpt);
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	     ret= 0; goto ex;
	   }
	 }
	 ret= 1; 
	ex:;
	 return(ret);
	}
	
	
	/* Implementing mkisofs tendency to map single-path pathspecs to / */
	int Xorriso_graftable_pathspec(struct XorrisO *xorriso, char *in_pathspec,
	                               char *pathspec, int flag)
	{
	 int ret, l;
	 char *esc_wdx= NULL, *eff_path= NULL, *ept;
	
	 if((!xorriso->allow_graft_points) || 
	   Fileliste__target_source_limit(in_pathspec, '=', &ept, 0) <= 0) {
	
	   Xorriso_alloc_meM(esc_wdx, char, SfileadrL);
	   Xorriso_alloc_meM(eff_path, char, SfileadrL);
	
	   strcpy(esc_wdx, xorriso->wdx);
	   if(!xorriso->allow_graft_points) {
	     ret= Fileliste__escape_source_path(esc_wdx, SfileadrL, 0);
	     if(ret <= 0) {
	       Xorriso_msgs_submit(xorriso, 0,
	                 "Escaped -cdx directory gets much too long", 0, "FAILURE", 0);
	       ret= 0; goto ex;
	     }
	   }
	   ret= Xorriso_normalize_img_path(xorriso, esc_wdx, in_pathspec,
	                                   eff_path, 2|4);
	   if(ret <= 0)
	     {ret= 0; goto ex;}
	   ret= Sfile_type(eff_path,
	            1 | ((xorriso->do_follow_param || xorriso->do_follow_links) << 2));
	   if(ret == 2) {
	     strcpy(pathspec, "/=");
	   } else {
	     pathspec[0]= '/';
	     pathspec[1]= 0;
	     ret= Sfile_leafname(eff_path, pathspec + 1, 0);
	     if(ret>0) {
	       if(!xorriso->allow_graft_points) {
	         ret= Fileliste__escape_source_path(pathspec, SfileadrL, 0);
	         if(ret <= 0) {
	           Xorriso_msgs_submit(xorriso, 0,
	                      "Escaped leaf name gets much too long", 0, "FAILURE", 0);
	           ret= 0; goto ex;
	         }
	       }
	       strcat(pathspec, "=");
	     } else
	       pathspec[0]= 0;
	   }
	   l= strlen(pathspec);
	   strcat(pathspec, eff_path);
	   if(!xorriso->allow_graft_points) {
	     ret= Fileliste__escape_source_path(pathspec + l, 2 * SfileadrL - l, 0);
	     if(ret <= 0) {
	       Xorriso_msgs_submit(xorriso, 0,
	                           "Escaped path gets much too long", 0, "FAILURE", 0);
	       ret= 0; goto ex;
	     }
	   }
	 } else {
	   Sfile_str(pathspec, in_pathspec, 0);
	 }
	 ret= 1;
	ex:;
	 Xorriso_free_meM(esc_wdx);
	 Xorriso_free_meM(eff_path);
	 return(ret);
	}
	
	
	int Xorriso_genisofs_path_pecul(struct XorrisO *xorriso, int *was_path,
	                                int with_emul_toc, int *allow_dir_id_ext,
	                                int *iso_level, int flag)
	{
	 char *sfe= NULL;
	 int ret;
	
	 if(*was_path) {
	   ret= 1; goto ex;
	 }
	 *was_path= 1;
	
	 Xorriso_alloc_meM(sfe, char, 5*SfileadrL);
	
	 /* Enforce odd mkisofs defaults on first pathspec */
	 xorriso->pacifier_style= 1;
	 if(xorriso->allow_dir_id_ext_dflt && *allow_dir_id_ext < 0)
	   *allow_dir_id_ext= 1;
	 if(*allow_dir_id_ext == 1) {
	   Xorriso_relax_compliance(xorriso, "allow_dir_id_ext", 0);
	   *allow_dir_id_ext= 2;
	 }
	 if(xorriso->iso_level_is_default && *iso_level < 0)
	   *iso_level= 1;
	 if(*iso_level >= 1 && *iso_level <= 3) {
	   sprintf(sfe, "iso_9660_level=%d", *iso_level);
	   Xorriso_relax_compliance(xorriso, sfe, 0);
	   iso_level= 0;
	 }
	 /* For the sake of compatibility give up emulated multi-session by default
	 */
	 if(with_emul_toc == 0)
	   xorriso->no_emul_toc|= 1;
	 /* mkisofs records mtime in ECMA-119 and Joliet
	 */
	 Xorriso_relax_compliance(xorriso, "rec_mtime", 0);
	 /* mkisofs is substantially faster than xorriso by not fsyncing
	 */
	 if(xorriso->stdio_sync_is_default)
	   Xorriso_option_stdio_sync(xorriso, "off", 0);
	
	 Xorriso_free_meM(sfe);
	 ret= 1;
	ex:;
	 return(ret);
	}
	
	
	int Xorriso_genisofs_platform(struct XorrisO *xorriso, char *id, int flag)
	{
	 unsigned int u;
	 char re_id[64];
	
	 if(strcmp(id, "x86") == 0)
	   return(0);
	 else if(strcmp(id, "PPC") == 0)
	   return(1);
	 else if(strcmp(id, "Mac") == 0)
	   return(2);
	 else if(strcmp(id, "efi") == 0)
	   return(0xef);
	
	 u= 0x100;
	 if(strncmp(id, "0x", 2) == 0) {
	   sscanf(id + 2, "%x", &u);
	 } else {
	   sscanf(id, "%u", &u);
	   sprintf(re_id, "%u", u);
	   if(strcmp(id, re_id) != 0)
	     goto wrong_id;
	 }
	 if(u <= 0xff)
	   return((int) u);
	
	wrong_id:;
	 sprintf(xorriso->info_text,
	         "Unrecognized El Torito Platform Id : '%.16s%s'",
	         id, strlen(id) > 16 ? "..." : "");
	 Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	 sprintf(xorriso->info_text,
	         "Recognizable are: x86, PPC, Mac, efi, [0...255], [0x00...0xff]");
	 Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "HINT", 0);
	 return(-1);
	}
	
	
	/* micro emulation of mkisofs */
	int Xorriso_genisofs(struct XorrisO *xorriso, char *whom,
	                     int argc, char **argv, int flag)
	{
	 int ret, i, j, was_path= 0, was_other_option= 0, mem_graft_points, mem;
	 int do_print_size= 0, fd, idx, iso_level= -1, palohdrversion;
	 int was_failure= 0, fret, lower_r= 0, zero= 0;
	 int dir_mode= -1, file_mode= -1, count, partition_number;
	 int allow_dir_id_ext= -1;
	 int root_seen= 0, do_md5_mem, option_d= 0, arg_count;
	 mode_t mode_and, mode_or;
	 int with_boot_image= 0, with_cat_path= 0, with_emul_toc= 0;
	 int old_root_md5= 1, old_root_dev= 0, old_root_ino= 1, sort_file_pattern= 0;
	 int *weight_list= NULL, weight_count= 0;
	 int *delay_opt_list= NULL, delay_opt_count= 0;
	 int mkisofs_b_platform_id= 0x00;
	 char *sfe= NULL, *adr= NULL, ra_text[80], *pathspec= NULL, *sort_file= NULL;
	 char *ept, *add_pt, *eff_path= NULL, *indev= NULL, msc[80], *cpt;
	 char *old_root= NULL, *argpt, *hargv[1];
	 char *boot_path, partno_text[8], *iso_rr_pt, *disk_pt, *rpt, *wpt;
	 char *rm_merge_args[3], *rr_reloc_dir_pt= NULL;
	 char *sort_weight_args[4], *bless_args[6], *sa_path;
	
	 struct stat stbuf;
	
	 Xorriso_alloc_meM(sfe, char, 5*SfileadrL);
	 Xorriso_alloc_meM(adr, char, SfileadrL+8);
	 Xorriso_alloc_meM(pathspec, char, 2*SfileadrL);
	 Xorriso_alloc_meM(eff_path, char, SfileadrL);
	 Xorriso_alloc_meM(indev, char, SfileadrL+8);
	 Xorriso_alloc_meM(old_root, char, SfileadrL);
	 Xorriso_alloc_meM(sort_file, char, SfileadrL);
	
	 for(i= 0; i<argc; i++) {
	   if(strcmp(argv[i], "-log-file") == 0 ||
	      strcmp(argv[i], "--log-file") == 0 ) {
	     if(i + 1 >= argc)
	       goto not_enough_args;
	     i+= 1;
	     if(argv[i][0]) {
	       sprintf(xorriso->info_text, "re-directing all messages to %s\n",
	               argv[i]);
	       Xorriso_info(xorriso, 0);
	     }
	     ret= Xorriso_write_to_channel(xorriso, argv[i], 2,
	                                   8 | ((argv[i][0] == 0) << 15));
	     if(ret <= 0) {
	       sprintf(xorriso->info_text, "Cannot open logfile:  %s", argv[i]);
	       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno * (ret == 0),
	                           "SORRY", 0);
	       was_failure= 1;
	       fret= Xorriso_eval_problem_status(xorriso, ret, 1|2);
	       if(fret < 0)
	         {ret= 0; goto ex;}
	     }
	     if(argv[i][0] == 0) {
	       sprintf(xorriso->info_text, "Revoked stderr message redirection");
	       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
	     }
	   }
	 }
	
	 strcpy(ra_text, xorriso->report_about_text);
	
	 weight_list= TSOB_FELD(int, (argc / 3) + 1);
	 if(weight_list == NULL) {
	   Xorriso_no_malloc_memory(xorriso, NULL, 0);
	   {ret= -1; goto ex;}
	 }
	 delay_opt_list= TSOB_FELD(int, argc + 1);
	 if(delay_opt_list == NULL) {
	   cpt= (char *) weight_list;
	   Xorriso_no_malloc_memory(xorriso, &cpt, 0);
	   {ret= -1; goto ex;}
	 } 
	
	 if(xorriso->boot_image_cat_path[0])
	   with_cat_path= -1;
	 adr[0]= indev[0]= msc[0]= old_root[0]= sort_file[0]= 0;
	 for(i= 0; i<argc; i++) {
	   ret= Xorriso_genisofs_strip_dash(xorriso, argv[i], &argpt, 0);
	   if(ret <= 0)
	     goto ex;
	   ret= Xorriso_genisofs_ignore(xorriso, whom, argpt, &i, 1);
	   if(ret == 1)
	 continue;
	   if(strcmp(argpt, "-version")==0) {
	     sprintf(xorriso->result_line,
	"mkisofs 2.01-Emulation Copyright (C) 2017 see libburnia-project.org xorriso\n"
	            );
	     fd= xorriso->dev_fd_1;
	     if(fd<0)
	       fd= 1;
	     ret= write(fd, xorriso->result_line, strlen(xorriso->result_line));
	     /* (result of write intentionally ignored) */
	     fsync(fd);
	     Xorriso_option_version(xorriso, 0);
	
	   } else if(strcmp(argpt, "-o")==0 || strcmp(argpt, "-output")==0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     adr[0]= 0;
	     if(strcmp(argv[i],"-")!=0 && strncmp(argv[i], "stdio:", 6)!=0)
	       strcpy(adr, "stdio:");
	     if(Sfile_str(adr+strlen(adr), argv[i], 0)<=0)
	       {ret= -1; goto ex;}
	   } else if(strcmp(argpt, "-M")==0  || strcmp(argpt, "-dev")==0 ||
	             strcmp(argpt, "-prev-session")==0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     if(strncmp(argv[i], "stdio:", 6)!=0)
	       strcpy(indev, "stdio:");
	     if(Sfile_str(indev+strlen(indev), argv[i], 0)<=0)
	       {ret= -1; goto ex;}
	   } else if(strcmp(argpt, "-C")==0 ||
	             strcmp(argpt, "-cdrecord-params")==0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     strncpy(msc, argv[i], sizeof(msc)-1);
	     msc[sizeof(msc)-1]= 0;
	   } else if(strcmp(argpt, "-help")==0) {
	     Xorriso_genisofs_help(xorriso, 0);
	   } else if(strcmp(argpt, "-v")==0 || strcmp(argpt, "-verbose")==0) {
	     ret= Xorriso_genisofs_fused_options(xorriso, whom, "v",
	                                  &option_d, &iso_level, &lower_r, ra_text, 2);
	     if(ret <= 0)
	       goto problem_handler_1;
	   } else if(strcmp(argpt, "-quiet")==0) {
	     strcpy(ra_text, "SORRY");
	   } else if(strcmp(argpt, "-f")==0 || strcmp(argpt, "-follow-links")==0) {
	     ret= Xorriso_genisofs_fused_options(xorriso, whom, "f",
	                                  &option_d, &iso_level, &lower_r, ra_text, 2);
	     if(ret <= 0)
	       goto problem_handler_1;
	   } else if(strcmp(argpt, "-iso-level")==0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     sscanf(argv[i], "%d", &iso_level);
	     if(iso_level < 1 || iso_level > 4) {
	       sprintf(xorriso->info_text,
	               "-as %s: unsupported -iso-level '%s' (use one of: 1,2,3,4)",
	               whom, argv[i]);
	       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	       ret= 0; goto problem_handler_1;
	     }
	     if(iso_level == 4)
	       xorriso->do_iso1999= 1;
	     else {
	       sprintf(sfe, "iso_9660_level=%s", argv[i]);
	       ret= Xorriso_relax_compliance(xorriso, sfe, 0);
	       if(ret <= 0)
	         goto problem_handler_1;
	     }
	
	   } else if(strcmp(argpt, "-input-charset")==0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     /* -local_charset */
	     if(strcmp(argv[i], "default") == 0)
	       ret= Xorriso_option_charset(xorriso, "ISO-8859-1", 4);
	     else
	       ret= Xorriso_option_charset(xorriso, argv[i], 4);
	     if(ret <= 0)
	       goto problem_handler_1;
	   } else if(strcmp(argpt, "-output-charset")==0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     /* -charset */
	     if(strcmp(argv[i], "default") == 0)
	       ret= Xorriso_option_charset(xorriso, "ISO-8859-1", 3);
	     else
	       ret= Xorriso_option_charset(xorriso, argv[i], 3);
	     if(ret <= 0)
	       goto problem_handler_1;
	
	   } else if(strcmp(argpt, "-hide") == 0 ||
	             strcmp(argpt, "-hide-list") == 0 ||
	             strcmp(argpt, "-hide-joliet") == 0 ||
	             strcmp(argpt, "-hide-joliet-list") == 0 ||
	             strcmp(argpt, "-hide-hfsplus") == 0 ||
	             strcmp(argpt, "-hide-hfsplus-list") == 0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     if(strcmp(argpt, "-hide") == 0)
	       ret= Xorriso_genisofs_hide(xorriso, whom, argv[i], 1, 0);
	     else if(strcmp(argpt, "-hide-list") == 0)
	       ret= Xorriso_genisofs_hide_list(xorriso, whom, argv[i], 1, 0);
	     else if(strcmp(argpt, "-hide-joliet") == 0) 
	       ret= Xorriso_genisofs_hide(xorriso, whom, argv[i], 2, 0);
	     else if(strcmp(argpt, "-hide-joliet-list") == 0) 
	       ret= Xorriso_genisofs_hide_list(xorriso, whom, argv[i], 2, 0);
	     else if(strcmp(argpt, "-hide-hfsplus") == 0)
	       ret= Xorriso_genisofs_hide(xorriso, whom, argv[i], 4, 0);
	     else if(strcmp(argpt, "-hide-hfsplus-list") == 0)
	       ret= Xorriso_genisofs_hide_list(xorriso, whom, argv[i], 4, 0);
	     if(ret <= 0)
	       goto problem_handler_1;
	
	   } else if(strcmp(argpt, "-root") == 0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     /* Always absolute */
	     strcpy(eff_path, "/");
	     if(Sfile_str(eff_path, argv[i], argv[i][0] != '/') <= 0)
	       {ret= -1; goto ex;}
	     strcpy(xorriso->wdi, eff_path);
	     root_seen= 1;
	
	   } else if(strcmp(argpt, "-old-root") == 0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     /* Always absolute */
	     strcpy(old_root, "/");
	     if(Sfile_str(old_root, argv[i], argv[i][0] != '/') <= 0)
	       {ret= -1; goto ex;}
	
	   } else if(strcmp(argpt, "--old-root-no-md5")==0) {
	     old_root_md5= 0;
	   } else if(strcmp(argpt, "--old-root-devno")==0) {
	     old_root_dev= 1;
	   } else if(strcmp(argpt, "--old-root-no-ino")==0) {
	     old_root_ino= 0;
	
	   } else if(strcmp(argpt, "-fat") == 0) {
	     xorriso->do_fat= 1;
	   } else if(strcmp(argpt, "-hfsplus") == 0) {
	     /* Already with -indev */
	     xorriso->do_hfsplus= 1;
	
	   } else if(strcmp(argpt, "--hardlinks")==0) {
	     Xorriso_option_hardlinks(xorriso, "on", 0);
	   } else if(strcmp(argpt, "--acl")==0) {
	     Xorriso_option_acl(xorriso, "on", 0);
	   } else if(strcmp(argpt, "--xattr")==0) {
	     Xorriso_option_xattr(xorriso, "on", 0);
	   } else if(strcmp(argpt, "--md5")==0) {
	     Xorriso_option_md5(xorriso, "on", 0);
	   } else if(strcmp(argpt, "--scdbackup_tag")==0) {
	     if(i + 2 >= argc)
	       goto not_enough_args;
	     i+= 2;
	     ret= Xorriso_option_scdbackup_tag(xorriso, argv[i-1], argv[i], 0);
	     if(ret <= 0)
	       goto problem_handler_1;
	   } else if(strcmp(argpt, "--for_backup")==0) {
	     Xorriso_option_hardlinks(xorriso, "on", 0);
	     Xorriso_option_acl(xorriso, "on", 0);
	     Xorriso_option_xattr(xorriso, "on", 0);
	     Xorriso_option_md5(xorriso, "on", 0);
	   } else if(strcmp(argpt, "-z")==0 ||
	             strcmp(argpt, "-transparent-compression")==0) {
	     ret= Xorriso_genisofs_fused_options(xorriso, whom, "z",
	                                  &option_d, &iso_level, &lower_r, ra_text, 2);
	     if(ret <= 0)
	       goto problem_handler_1;
	     Xorriso_option_zisofs(xorriso, "by_magic=on", 0);
	   } else if(strcmp(argpt, "--stdio_sync")==0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     Xorriso_option_stdio_sync(xorriso, argv[i], 0);
	   } else if(strcmp(argpt, "-disallow_dir_id_ext")==0) {
	     allow_dir_id_ext= 0;
	   } else if(strcmp(argpt, "--emul-toc")==0) {
	     with_emul_toc= 1;
	     xorriso->no_emul_toc&= ~1;
	   } else if(strcmp(argpt, "--no-emul-toc")==0) {
	     with_emul_toc= 0;
	     xorriso->no_emul_toc|= 1;
	   } else if(strcmp(argpt, "-log-file") == 0) {
	     /* already handled before this loop */;
	     i++;
	   } else if(strcmp(argpt, "-gui") == 0) {
	     xorriso->pacifier_interval= 0.25;
	   } else if(strcmp(argpt, "-file_name_limit") == 0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     Xorriso_option_file_name_limit(xorriso, argv[i], 0);
	   } else {
	     if(argv[i][0] == '-') {
	       ret= Xorriso_genisofs_fused_options(xorriso, whom, argv[i] + 1,
	                              &option_d, &iso_level, &lower_r, ra_text, 1 | 2);
	       if(ret != 1)
	         was_other_option= 1;
	     } else {
	       ret= 0;
	       was_other_option= 1;
	     }
	     if(ret > 0) {
	       Xorriso_genisofs_fused_options(xorriso, whom, argv[i] + 1,
	                                  &option_d, &iso_level, &lower_r, ra_text, 2);
	       if(ret <= 0) 
	         goto problem_handler_1;
	     } else {
	       hargv[0]= argpt;
	       ret= Xorriso_genisofs_count_args(xorriso, argc - i, hargv, &count, 0);
	       if(ret > 0)
	         i+= count; /* skip eventual arguments of known option */
	     }
	   }
	 continue; /* regular bottom of loop */
	problem_handler_1:;
	   was_failure= 1;
	   fret= Xorriso_eval_problem_status(xorriso, ret, 1|2);
	   if(fret>=0)
	 continue;
	   goto ex;
	 }
	 Xorriso_option_report_about(xorriso, ra_text, 0);
	 if(adr[0]) {
	   if(strncmp(adr, "stdio:", 6)==0 && strncmp(adr, "stdio:/dev/fd/", 14)!=0) {
	     ret= Sfile_type(adr+6, 1);
	     if(ret==-1) {
	       /* ok */;
	     } else if(ret==2 || ret==3) {
	       sprintf(xorriso->info_text,
	               "-as %s: Cannot accept %s as target: -o %s",
	               whom, (ret==3 ? "symbolic link" : "directory"),
	               Text_shellsafe(adr+6, sfe, 0));
	       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	       ret= 0; goto ex;
	     }
	   }
	   /* Regard overwriteable as blank, truncate regular files on write start */
	   ret= Xorriso_option_dev(xorriso, adr, 2|8|16);
	   if(ret<=0)
	     goto ex;
	 }
	
	 if(was_other_option && xorriso->out_drive_handle==NULL) {
	   ret= Xorriso_option_dev(xorriso, "-", 2|4); /* set outdev to stdout */
	   if(ret<=0)
	     goto ex;
	 }
	
	 if(msc[0]) {
	   cpt= strchr(msc, ',');
	   if(cpt==NULL) {
	illegal_c:;
	     sprintf(xorriso->info_text,
	             "-as %s: unusable parameter with option -C: %s",
	             whom, Text_shellsafe(msc, sfe, 0));
	     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	     {ret= 0; goto ex;}
	   } else if(cpt==msc || msc[1]==0)
	     goto illegal_c;
	   strncpy(sfe, msc, cpt-msc);
	   sfe[cpt-msc]= 0;
	   if(xorriso->in_drive_handle!=NULL && indev[0]) {
	     /* give up indev before setting the load address */
	     ret= Xorriso_option_dev(xorriso, "", 1);
	     if(ret<=0)
	       goto ex;
	   }
	   /* growisofs submits msc1+16 to avoid a theoretical bug in mkisofs.
	      Therefore this bug has to be emulated here. Sigh.
	   */
	   ret= Xorriso_option_load(xorriso, "sbsector", sfe, 1);
	   if(ret<=0)
	     goto ex;
	   ret= Xorriso_option_grow_blindly(xorriso, cpt+1, 0);
	   if(ret<=0)
	     goto ex;
	 }
	
	 if(old_root[0] || root_seen) {
	   Xorriso_option_md5(xorriso, old_root_md5 ? "on" : "off", 0);
	   Xorriso_option_disk_dev_ino(xorriso,
	                               old_root_dev && old_root_ino ? "on" :
	                               old_root_ino ? "ino_only" : "off", 0);
	   if(!old_root_ino)
	     Xorriso_option_hardlinks(xorriso, "without_update", 0);
	 }
	 if(indev[0]) {
	   do_md5_mem= xorriso->do_md5;
	   if(xorriso->do_md5 & 1) /* MD5 loading is enabled */
	     xorriso->do_md5|= 32; /* Do not check tags of superblock,tree,session
	                              because growisofs preserves the first sb tag.*/
	   ret= Xorriso_option_dev(xorriso, indev, 1);
	   xorriso->do_md5= do_md5_mem;
	   if(ret<=0)
	     goto ex;
	 }
	
	 if(!was_other_option)
	   {ret= 1; goto ex;}
	
	 if(old_root[0]) {
	   ret= Xorriso_iso_lstat(xorriso, old_root, &stbuf, 0);
	   if(ret >= 0) {
	     if(root_seen) {
	       ret= Xorriso_mkdir(xorriso, xorriso->wdi, 1 | 2);
	       if(ret < 0)
	         {ret= -(ret != -1); goto ex;}
	     } else {
	       strcpy(xorriso->wdi, "/");
	     }
	     if(strcmp(old_root, xorriso->wdi) != 0) {
	       ret= Xorriso_clone_under(xorriso, old_root, xorriso->wdi, 0);
	       if(ret <= 0)
	         goto ex;
	     }
	   }
	 }
	
	 xorriso->padding= 300*1024;
	
	 for(i= 0; i<argc; i++) {
	   sprintf(xorriso->info_text, "-as %s: %s",
	           whom, Text_shellsafe(argv[i], sfe, 0));
	   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
	   ret= Xorriso_genisofs_strip_dash(xorriso, argv[i], &argpt, 0);
	   if(ret <= 0)
	     goto ex;
	   ret= Xorriso_genisofs_ignore(xorriso, whom, argpt, &i, 0);
	   if(ret == 1)
	 continue;
	   if(strcmp(argpt, "-version")==0) {
	     /* was already handled in first argument scan */;
	   } else if(strcmp(argpt, "--norock")==0) {
	     xorriso->do_rockridge= 0;
	     lower_r= 0;
	   } else if(strcmp(argpt, "-R")==0 || strcmp(argpt, "-rock")==0) {
	     ret= Xorriso_genisofs_fused_options(xorriso, whom, "R",
	                                  &option_d, &iso_level, &lower_r, ra_text, 0);
	     if(ret <= 0)
	       goto problem_handler_2;
	   } else if(strcmp(argpt, "-r")==0 || strcmp(argpt, "-rational-rock")==0){
	     ret= Xorriso_genisofs_fused_options(xorriso, whom, "r",
	                                  &option_d, &iso_level, &lower_r, ra_text, 0);
	     if(ret <= 0)
	       goto problem_handler_2;
	   } else if(strcmp(argpt, "-J")==0 || strcmp(argpt, "-joliet")==0) {
	     ret= Xorriso_genisofs_fused_options(xorriso, whom, "J",
	                                  &option_d, &iso_level, &lower_r, ra_text, 0);
	     if(ret <= 0)
	       goto problem_handler_2;
	   } else if(strcmp(argpt, "-joliet-long")==0) {
	     Xorriso_relax_compliance(xorriso,
	                              "joliet_long_paths:joliet_long_names", 0);
	   } else if(strcmp(argpt, "-joliet-utf16")==0) {
	     Xorriso_relax_compliance(xorriso, "joliet_utf16", 0);
	   } else if(strcmp(argpt, "-fat") == 0) {
	     /* was already handled in first argument scan */;
	   } else if(strcmp(argpt, "-hfs-bless") == 0 ||
	             strcmp(argpt, "-hfs-bless-by") == 0 ||
	             strcmp(argpt, "-hfsplus-file-creator-type") == 0) {
	     arg_count= 1;
	     if(strcmp(argpt, "-hfs-bless-by") == 0)
	       arg_count= 2;
	     else if(strcmp(argpt, "-hfsplus-file-creator-type") == 0)
	       arg_count= 3;
	     if(i + arg_count >= argc)
	       goto not_enough_args;
	     /* Memorize command until all pathspecs are processed */
	     delay_opt_list[delay_opt_count++]= i;
	     if(argv[i] != argpt)
	       delay_opt_list[delay_opt_count - 1]|= 1<<31;
	     i+= arg_count;
	   } else if(strcmp(argpt, "-hfsplus") == 0) {
	     /* was already handled in first argument scan */;
	   } else if(strcmp(argpt, "-hfsplus-serial-no") == 0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     sprintf(pathspec, "hfsplus_serial=%.80s", argv[i]);
	     ret= Xorriso_option_boot_image(xorriso, "any", pathspec, 0);
	     if(ret <= 0)
	       goto problem_handler_2;
	   } else if(strcmp(argpt, "-hfsplus-block-size") == 0 ||
	             strcmp(argpt, "-apm-block-size") == 0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     ret= -1;
	     sscanf(argv[i], "%d", &ret);
	     if(argpt[1] == 'h')
	       sprintf(sfe, "hfsplus_block_size=%d", ret);
	     else
	       sprintf(sfe, "apm_block_size=%d", ret);
	     ret= Xorriso_option_boot_image(xorriso, "any", sfe, 0);
	     if(ret <= 0)
	       goto problem_handler_2;
	
	   } else if(strcmp(argpt, "-graft-points")==0) {
	     xorriso->allow_graft_points= 3;
	   } else if(strcmp(argpt, "-path-list")==0 ||
	             strcmp(argpt, "--quoted_path_list")==0) {
	     if(i+1>=argc) {
	not_enough_args:;
	       sprintf(xorriso->info_text, "-as %s: Not enough arguments to option %s",
	               whom, argv[i]);
	       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	       ret= 0; goto ex;
	     }
	     i++;
	     xorriso->pacifier_style= 1;
	     ret= Xorriso_option_path_list(xorriso, argv[i],
	                               (strcmp(argpt, "--quoted_path_list") == 0) | 2);
	     if(ret<=0)
	       goto problem_handler_2;
	     ret = Xorriso_genisofs_path_pecul(xorriso, &was_path, with_emul_toc,
	                                       &allow_dir_id_ext, &iso_level, 0);
	     if(ret <= 0)
	       goto ex;
	   } else if(strcmp(argpt, "-f")==0 || strcmp(argpt, "-follow-links")==0) {
	     /* was already handled in first argument scan */;
	   } else if(strcmp(argpt, "-pad")==0) {
	     xorriso->padding= 300*1024;
	   } else if(strcmp(argpt, "-no-pad")==0) {
	     xorriso->padding= 0;
	   } else if(strcmp(argpt, "-print-size")==0) {
	     do_print_size= 1;
	   } else if(strcmp(argpt, "-o")==0 || strcmp(argpt, "-output") == 0) {
	     i++;
	     /* was already handled in first argument scan */;
	   } else if(strcmp(argpt, "-M")==0  || strcmp(argpt, "-dev")==0 ||
	             strcmp(argpt, "-prev-session")==0) {
	     i++;
	     /* was already handled in first argument scan */;
	   } else if(strcmp(argpt, "-C")==0 ||
	             strcmp(argpt, "-cdrecord-params")==0) {
	     i++;
	     /* was already handled in first argument scan */;
	   } else if(strcmp(argpt, "-help")==0) {
	     /* was already handled in first argument scan */;
	   } else if(strcmp(argpt, "-V")==0 || strcmp(argpt, "-volid")==0 ||
	             strcmp(argpt, "-volset")==0 ||
	             strcmp(argpt, "-p")==0 || strcmp(argpt, "-preparer")==0 ||
	             strcmp(argpt, "-P")==0 || strcmp(argpt, "-publisher")==0 ||
	             strcmp(argpt, "-A")==0 || strcmp(argpt, "-appid")==0 ||
	             strcmp(argpt, "--application_use")==0 ||
	             strcmp(argpt, "-sysid")==0 ||
	             strcmp(argpt, "-biblio")==0 ||
	             strcmp(argpt, "-copyright")==0 ||
	             strcmp(argpt, "-abstract")==0 ) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     ret= 1;
	     if(strcmp(argpt, "-V")==0 || strcmp(argpt, "-volid")==0)
	       ret= Xorriso_option_volid(xorriso, argv[i], 0);
	     else if(strcmp(argpt, "-volset")==0)
	       ret= Xorriso_option_volset_id(xorriso, argv[i], 0);
	     else if(strcmp(argpt, "-p")==0 ||
	             strcmp(argpt, "-preparer")==0)
	       ret= Xorriso_option_preparer_id(xorriso, argv[i], 0);
	     else if(strcmp(argpt, "-P")==0 ||
	             strcmp(argpt, "-publisher")==0)
	       ret= Xorriso_option_publisher(xorriso, argv[i], 0);
	     else if(strcmp(argpt, "-A")==0 || strcmp(argpt, "-appid")==0)
	       ret= Xorriso_option_application_id(xorriso, argv[i], 0);
	     else if(strcmp(argpt, "-sysid")==0)
	       ret= Xorriso_option_system_id(xorriso, argv[i], 0);
	     else if(strcmp(argpt, "-biblio")==0)
	       ret= Xorriso_option_biblio_file(xorriso, argv[i], 0);
	     else if(strcmp(argpt, "-copyright")==0)
	       ret= Xorriso_option_copyright_file(xorriso, argv[i], 0);
	     else if(strcmp(argpt, "-abstract")==0)
	       ret= Xorriso_option_abstract_file(xorriso, argv[i], 0);
	     else if(strcmp(argpt, "--application_use")==0)
	       ret= Xorriso_option_application_use(xorriso, argv[i], 0);
	     if(ret<=0)
	       goto problem_handler_2;
	   } else if(strcmp(argpt, "-m")==0 || strcmp(argpt, "-exclude")==0 ||
	             strcmp(argpt, "-x")==0 || strcmp(argpt, "-old-exclude")==0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     mem= xorriso->do_disk_pattern;
	     xorriso->do_disk_pattern= 1;
	     if(strchr(argv[i], '/')!=NULL) {
	       idx= i;
	       ret= Xorriso_option_not_paths(xorriso, i+1, argv, &idx, 0);
	     } else
	       ret= Xorriso_option_not_leaf(xorriso, argv[i], 0);
	     xorriso->do_disk_pattern= mem;
	     if(ret<=0)
	       goto problem_handler_2;
	   } else if(strcmp(argpt, "-exclude-list")==0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     mem= xorriso->do_disk_pattern;
	     xorriso->do_disk_pattern= 1;
	     ret= Xorriso_option_not_list(xorriso, argv[i], 0);
	     xorriso->do_disk_pattern= mem;
	     if(ret<=0)
	       goto problem_handler_2;
	   } else if(strcmp(argpt, "-v")==0 || strcmp(argpt, "-verbose")==0 ||
	             strcmp(argpt, "-quiet")==0) {
	     /* was already handled in first argument scan */;
	
	   } else if(strcmp(argpt, "-iso-level")==0) {
	     i++;
	     /* was already handled in first argument scan */;
	   } else if(strcmp(argpt, "-no-emul-boot")==0 ||
	             strcmp(argpt, "-hard-disk-boot")==0 ||
	             strcmp(argpt, "-boot-info-table")==0 ||
	             strcmp(argpt, "--grub2-boot-info") == 0 ||
	             strncmp(argpt, "isolinux_mbr=", 13)==0 ||
	             strcmp(argpt, "-eltorito-alt-boot")==0 ||
	             strcmp(argpt, "--protective-msdos-label")==0 ||
	             strcmp(argpt, "--mbr-force-bootable")==0 ||
	             strcmp(argpt, "--boot-catalog-hide")==0 ||
	             strcmp(argpt, "-isohybrid-gpt-basdat")==0 ||
	             strcmp(argpt, "-isohybrid-gpt-hfsplus")==0 ||
	             strcmp(argpt, "-isohybrid-apm-hfsplus")==0 ||
	             strcmp(argpt, "-part_like_isohybrid")==0) {
	     delay_opt_list[delay_opt_count++]= i;
	     if(argv[i] != argpt)
	       delay_opt_list[delay_opt_count - 1]|= 1<<31;
	   } else if(strcmp(argpt, "-b") == 0 ||
	             strcmp(argpt, "-eltorito-boot") == 0 ||
	             strcmp(argpt, "-eltorito-platform") == 0 ||
	             strcmp(argpt, "--efi-boot") == 0 ||
	             strcmp(argpt, "-e") == 0 ||
	             strcmp(argpt, "-mips-boot") == 0 ||
	             strcmp(argpt, "-mipsel-boot") == 0 ||
	             strcmp(argpt, "-c") == 0 ||
	             strcmp(argpt, "-eltorito-catalog") == 0 ||
	             strcmp(argpt, "-boot-load-size") == 0 ||
	             strcmp(argpt, "-eltorito-id") == 0 ||
	             strcmp(argpt, "-eltorito-selcrit") == 0 ||
	             strcmp(argpt, "--embedded-boot")==0 ||
	             strcmp(argpt, "-generic-boot")==0 ||
	             strcmp(argpt, "-G") == 0 ||
	             strcmp(argpt, "-partition_offset") == 0 ||
	             strcmp(argpt, "-partition_hd_cyl") == 0 ||
	             strcmp(argpt, "-partition_sec_hd") == 0 ||
	             strcmp(argpt, "-partition_cyl_align") == 0 ||
	             strcmp(argpt, "-isohybrid-mbr") == 0 ||
	             strcmp(argpt, "--grub2-mbr") == 0 ||
	             strncmp(argpt, "-hppa-", 6) == 0 ||
	             strcmp(argpt, "-alpha-boot") == 0 ||
	             strcmp(argpt, "--gpt_disk_guid") == 0 ||
	             strcmp(argpt, "-iso_mbr_part_type") == 0) { 
	     if(i+1>=argc)
	       goto not_enough_args;
	     delay_opt_list[delay_opt_count++]= i;
	     if(argv[i] != argpt)
	       delay_opt_list[delay_opt_count - 1]|= 1<<31;
	     i++;
	   } else if(strncmp(argpt, "--modification-date=", 20)==0) {
	     ret= Xorriso_option_volume_date(xorriso, "uuid", argpt + 20, 0);
	     if(ret <= 0)
	       goto problem_handler_2;
	
	   } else if(strcmp(argpt, "--set_all_file_dates") == 0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     ret= Xorriso_option_volume_date(xorriso, "all_file_dates", argv[i], 0);
	     if(ret <= 0)
	       goto problem_handler_2;
	   } else if(strcmp(argpt, "-input-charset")==0) {
	     i++;
	     /* was already handled in first argument scan */;
	   } else if(strcmp(argpt, "-output-charset")==0) {
	     i++;
	     /* was already handled in first argument scan */;
	   } else if(strcmp(argpt, "--hardlinks")==0 ||
	             strcmp(argpt, "--acl")==0 ||
	             strcmp(argpt, "--xattr")==0 ||
	             strcmp(argpt, "--md5")==0 ||
	             strcmp(argpt, "--for_backup")==0) {
	     /* was already handled in first argument scan */;
	   } else if(strcmp(argpt, "--scdbackup_tag")==0) {
	     /* was already handled in first argument scan */;
	     i+= 2;
	   } else if(strcmp(argpt, "--sort-weight")==0) {
	     if(i + 2 >= argc)
	       goto not_enough_args;
	     i+= 2;
	     /* memorize for find runs after pathspecs have been added */
	     weight_list[weight_count++]= i - 2;
	   } else if(strcmp(argpt, "--sort-weight-list") == 0 ||
	             strcmp(argpt, "--sort-weight-patterns") == 0) {
	     if(i + 1 >= argc)
	       goto not_enough_args;
	     i++;
	     if(Sfile_str(sort_file, argv[i], 0) <= 0)
	       {ret= -1; goto ex;}
	     sort_file_pattern= (strcmp(argpt, "--sort-weight-patterns") == 0);
	
	   } else if(strcmp(argpt, "-z")==0 ||
	             strcmp(argpt, "-transparent-compression")==0) {
	     /* was already handled in first argument scan */;
	   } else if(strcmp(argpt, "-U") == 0 ||
	             strcmp(argpt, "-untranslated-filenames") == 0) {
	     ret= Xorriso_genisofs_fused_options(xorriso, whom, "U",
	                                  &option_d, &iso_level, &lower_r, ra_text, 0);
	     if(ret <= 0)
	       goto problem_handler_2;
	   } else if(strcmp(argpt, "-untranslated_name_len") == 0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     sprintf(sfe, "untranslated_name_len=%s", argv[i]);
	     ret= Xorriso_relax_compliance(xorriso, sfe, 0);
	     if(ret <= 0)
	       goto problem_handler_2;
	   } else if(strcmp(argpt, "-N") == 0 ||
	             strcmp(argpt, "-omit-version-number") == 0) {
	     ret= Xorriso_genisofs_fused_options(xorriso, whom, "N",
	                                  &option_d, &iso_level, &lower_r, ra_text, 0);
	     if(ret <= 0)
	       goto problem_handler_2;
	   } else if(strcmp(argpt, "-l") == 0 ||
	             strcmp(argpt, "-full-iso9660-filenames") == 0) {
	     ret= Xorriso_genisofs_fused_options(xorriso, whom, "l",
	                                  &option_d, &iso_level, &lower_r, ra_text, 0);
	     if(ret <= 0)
	       goto problem_handler_2;
	   } else if(strcmp(argpt, "-max-iso9660-filenames") == 0) {
	     Xorriso_relax_compliance(xorriso, "long_names", 0);
	   } else if(strcmp(argpt, "-d") == 0 ||
	             strcmp(argpt, "-omit-period") == 0) {
	     ret= Xorriso_genisofs_fused_options(xorriso, whom, "d",
	                                  &option_d, &iso_level, &lower_r, ra_text, 0);
	     if(ret <= 0)
	       goto problem_handler_2;
	   } else if(strcmp(argpt, "-allow-lowercase") == 0) {
	     Xorriso_relax_compliance(xorriso, "lowercase", 0);
	   } else if(strcmp(argpt, "-relaxed-filenames") == 0) {
	     Xorriso_relax_compliance(xorriso, "7bit_ascii", 0);
	   } else if(strcmp(argpt, "-hide") == 0 ||
	             strcmp(argpt, "-hide-list") == 0 ||
	             strcmp(argpt, "-hide-joliet") == 0 ||
	             strcmp(argpt, "-hide-joliet-list") == 0 ||
	             strcmp(argpt, "-hide-hfsplus") == 0 ||
	             strcmp(argpt, "-hide-hfsplus-list") == 0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     /* was already handled in first argument scan */;
	   } else if(strcmp(argpt, "-root") == 0 ||
	             strcmp(argpt, "-old-root") == 0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     /* was already handled in first argument scan */;
	   } else if(strcmp(argpt, "--old-root-no-md5")==0 ||
	             strcmp(argpt, "--old-root-devno")==0 ||
	             strcmp(argpt, "--old-root-no-ino")==0) {
	     /* was already handled in first argument scan */;
	   } else if(strcmp(argpt, "-dir-mode") == 0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     ret= Xorriso_convert_modstring(xorriso, "-as mkisofs -dir-mode",
	                                    argv[i], &mode_and, &mode_or, 0);
	     if(ret<=0)
	       goto problem_handler_2;
	     dir_mode= mode_or;
	   } else if(strcmp(argpt, "-file-mode") == 0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     ret= Xorriso_convert_modstring(xorriso, "-as mkisofs -file-mode",
	                                    argv[i], &mode_and, &mode_or, 0);
	     if(ret<=0)
	       goto problem_handler_2;
	     file_mode= mode_or;
	   } else if(strcmp(argpt, "-jigdo-jigdo") == 0 ||
	             strcmp(argpt, "-jigdo-template") == 0 ||     
	             strcmp(argpt, "-jigdo-min-file-size") == 0 ||     
	             strcmp(argpt, "-jigdo-exclude") == 0 ||     
	             strcmp(argpt, "-jigdo-force-md5") == 0 ||     
	             strcmp(argpt, "-jigdo-map") == 0 ||     
	             strcmp(argpt, "-jigdo-template-compress") == 0 ||     
	             strcmp(argpt, "-checksum_algorithm_iso") == 0 ||     
	             strcmp(argpt, "-checksum_algorithm_template") == 0 ||     
	             strcmp(argpt, "-md5-list") == 0) {
	     i++;
	     ret= Xorriso_option_jigdo(xorriso, argpt, argv[i], 0);
	     if(ret <= 0)
	       goto problem_handler_2;
	
	   } else if(strcmp(argpt, "-chrp-boot-part") == 0 ||
	             strcmp(argpt, "-chrp-boot") == 0) {
	     ret= Xorriso_option_boot_image(xorriso, "any", "chrp_boot_part=on", 0);
	     if(ret <= 0)
	       goto problem_handler_2;
	
	   } else if(strcmp(argpt, "-prep-boot-part") == 0) {
	     if(i + 1 >= argc)
	       goto not_enough_args;
	     i++;
	     ret= Sfile_str(xorriso->prep_partition, argv[i], 0);
	     if(ret <= 0)
	       goto ex;
	
	   } else if(strcmp(argpt, "-efi-boot-part") == 0) {
	     if(i + 1 >= argc)
	       goto not_enough_args;
	     i++;
	     ret= Sfile_str(xorriso->efi_boot_partition, argv[i], 0);
	     if(ret <= 0)
	       goto ex;
	
	   } else if(strcmp(argpt, "-append_partition") == 0) {
	     if(i + 3 >= argc)
	       goto not_enough_args;
	     i+= 3;
	     ret= Xorriso_option_append_partition(xorriso, argv[i - 2], argv[i - 1],
	                                          argv[i], 0);
	     if(ret <= 0)
	       goto problem_handler_2;
	
	   } else if(strcmp(argpt, "-appended_part_as_gpt") == 0) {
	     xorriso->appended_as_gpt= 1;
	
	   } else if(strcmp(argpt, "-appended_part_as_apm") == 0) {
	     xorriso->appended_as_apm= 1;
	
	   } else if(strcmp(argpt, "-B") == 0 ||
	             strcmp(argpt, "-sparc-boot") == 0) {
	     i++;
	     if(strlen(argv[i]) >= SfileadrL)
	 continue;
	
	     /* Switch system area type to: SUN Disk Label */
	     strcpy(pathspec, "sparc_label=");
	     strcat(pathspec, xorriso->ascii_disc_label);
	     ret= Xorriso_option_boot_image(xorriso, "any", pathspec, 0);
	     if(ret <= 0)
	       goto problem_handler_2;
	
	     /* Interpret list of boot partition images or "..." */;
	     cpt= ept= argv[i];
	     partition_number= 2;
	     while(ept != NULL) {
	       ept= strchr(cpt, ',');
	       if(ept != NULL) {
	         strncpy(pathspec, cpt, ept - cpt);
	         pathspec[ept - cpt]= 0;
	         cpt= ept + 1;
	       } else
	         strcpy(pathspec, cpt);
	       if(strcmp(pathspec, "...") == 0) {
	         for(; partition_number <= 8; partition_number++) {
	           sprintf(partno_text, "%d", partition_number);
	           ret= Xorriso_option_append_partition(xorriso, partno_text, "0x0",
	                                                ".", 0);
	           if(ret <= 0)
	             goto problem_handler_2;
	         }
	       } else {
	         if(partition_number > 8) {
	           sprintf(xorriso->info_text,
	                "-as %s -sparc-boot %s : Too many boot images", whom, argv[i]);
	           Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE",0);
	           goto problem_handler_2;
	         }
	         sprintf(partno_text, "%d", partition_number);
	         ret= Xorriso_option_append_partition(xorriso, partno_text, "0x0",
	                                              pathspec, 0);
	         if(ret <= 0)
	           goto problem_handler_2;
	         partition_number++;
	       }
	     }
	
	   } else if(strcmp(argpt, "-sparc-label") == 0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     sprintf(sfe, "sparc_label=%s", argv[i]);
	     ret= Xorriso_option_boot_image(xorriso, "any", sfe, 0);
	     if(ret <= 0)
	       goto problem_handler_2;
	
	   } else if(strcmp(argpt, "--grub2-sparc-core") == 0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     sprintf(sfe, "grub2_sparc_core=%s", argv[i]);
	     ret= Xorriso_option_boot_image(xorriso, "any", sfe, 0);
	     if(ret <= 0)
	       goto problem_handler_2;
	
	   } else if(strcmp(argpt, "--stdio_sync")==0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     /* was already handled in first argument scan */;
	
	   } else if(strcmp(argpt, "--emul-toc")==0 ||
	             strcmp(argpt, "--no-emul-toc")==0) {
	     /* was already handled in first argument scan */;
	
	   } else if(strcmp(argpt, "--old-empty")==0) {
	     xorriso->do_old_empty= 1;
	
	   } else if(strcmp(argpt, "-disallow_dir_id_ext")==0) {
	     /* was already handled in first argument scan */;
	
	   } else if(strcmp(argpt, "--no_rc")==0) {
	     /* was already handled in Xorriso_prescan_args */;
	
	   } else if(strcmp(argpt, "-D") == 0 ||
	             strcmp(argpt, "-disable-deep-relocation") == 0) {
	     ret= Xorriso_genisofs_fused_options(xorriso, whom, "D",
	                                  &option_d, &iso_level, &lower_r, ra_text, 0);
	     if(ret <= 0)
	       goto problem_handler_2;
	
	   } else if(strcmp(argpt, "-hide-rr-moved") == 0) {
	     rr_reloc_dir_pt= ".rr_moved";
	     goto rr_reloc_dir;
	
	   } else if(strcmp(argpt, "-rr_reloc_dir") == 0) {
	     i++;
	     rr_reloc_dir_pt= argv[i];
	rr_reloc_dir:;
	     if(rr_reloc_dir_pt[0] == '/')
	        rr_reloc_dir_pt++;
	     if(strchr(rr_reloc_dir_pt, '/') != NULL) {
	       sprintf(xorriso->info_text,
	        "-as %s -rr_reloc_dir %s : May only use directories in root directory",
	               whom, Text_shellsafe(argv[i], sfe, 0));
	       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE",0);
	     }
	     ret= Xorriso_option_rr_reloc_dir(xorriso, rr_reloc_dir_pt, 0);
	     if(ret <= 0)
	       goto problem_handler_2;
	     Xorriso_relax_compliance(xorriso, "deep_paths_off:long_paths_off", 0);
	
	   } else if(strcmp(argpt, "-log-file") == 0 ||
	             strcmp(argpt, "-file_name_limit") == 0) {
	     i+= 1;
	     /* was already handled before this loop */;
	
	   } else if(strcmp(argpt, "-gui") == 0) {
	     /* was already handled in first argument scan */;
	
	   } else if(argpt[0]=='-' && argpt[1]!=0) {
	     ret= Xorriso_genisofs_fused_options(xorriso, whom, argv[i] + 1,
	                                  &option_d, &iso_level, &lower_r, ra_text, 1);
	     if(ret == 1) {
	       ret= Xorriso_genisofs_fused_options(xorriso, whom, argv[i] + 1,
	                                  &option_d, &iso_level, &lower_r, ra_text, 0);
	       if(ret <= 0)
	         goto problem_handler_2;
	     } else {
	       hargv[0]= argpt;
	       ret= Xorriso_genisofs_count_args(xorriso, argc - i, hargv, &count, 1);
	       if(ret > 0) {
	         sprintf(xorriso->info_text, "-as %s: Unsupported option %s",
	                 whom, Text_shellsafe(argv[i], sfe, 0));
	         Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	         i+= count;
	         goto problem_handler_2;
	       } else {
	         sprintf(xorriso->info_text, "-as %s: Unrecognized option %s",
	                 whom, Text_shellsafe(argv[i], sfe, 0));
	         Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	         goto problem_handler_2;
	       }
	     }
	   } else {
	     ret= Xorriso_graftable_pathspec(xorriso, argv[i], pathspec, 0);
	     if(ret <= 0)
	       goto problem_handler_2;
	     add_pt= pathspec;
	
	     if(old_root[0]) {
	       /* Split pathspec */
	       ret= Fileliste__target_source_limit(add_pt, '=', &ept, 0);
	       if(ret > 0) {
	         *ept= 0;
	         iso_rr_pt= add_pt;
	         disk_pt= ept + 1;
	       } else {
	         iso_rr_pt= "/";
	         disk_pt= add_pt;
	       }
	
	       /* Unescape iso_rr_pt */
	       strcpy(eff_path, iso_rr_pt);
	       iso_rr_pt= eff_path;
	       for(wpt= rpt= iso_rr_pt; *rpt != 0; rpt++) {
	         if(*rpt == '\\') {
	           if(*(rpt + 1) == '\\')
	             rpt++;
	           else if(*(rpt + 1) == '=')
	       continue;
	         }
	         *(wpt++) = *rpt;
	       }
	       *wpt= 0;
	
	       if(root_seen) {
	         ret= Sfile_prepend_path(xorriso->wdi, iso_rr_pt, 0);
	         if(ret<=0) {
	           Xorriso_msgs_submit(xorriso, 0, "Effective path gets much too long",
	                               0, "FAILURE", 0);
	           goto problem_handler_2;
	         }
	       }
	       /* update_merge */
	       ret= Xorriso_option_update(xorriso, disk_pt, iso_rr_pt, 1 | 8 | 32);
	     } else {
	       mem_graft_points= xorriso->allow_graft_points;
	       xorriso->allow_graft_points= 3;
	       zero= 0;
	       ret= Xorriso_option_add(xorriso, 1, &add_pt, &zero,
	                               (was_path << 1) | (root_seen << 2));
	       xorriso->allow_graft_points= mem_graft_points;
	     }
	     if(ret<=0)
	       goto problem_handler_2;
	
	     /* Enforce odd mkisofs defaults on first pathspec */
	     ret = Xorriso_genisofs_path_pecul(xorriso, &was_path, with_emul_toc,
	                                       &allow_dir_id_ext, &iso_level, 0);
	     if(ret <= 0)
	       goto ex;
	   }
	 continue; /* regular bottom of loop */
	problem_handler_2:;
	   was_failure= 1;
	   fret= Xorriso_eval_problem_status(xorriso, ret, 1|2);
	   if(fret>=0)
	 continue;
	   goto ex;
	 }
	
	 if(old_root[0]) {
	   /* Delete all visited nodes which were not found on disk */
	   if(root_seen)
	     rm_merge_args[0]= xorriso->wdi;
	   else
	     rm_merge_args[0]= "/";
	   rm_merge_args[1]= "-exec";
	   rm_merge_args[2]= "rm_merge";
	   zero= 0;
	   ret= Xorriso_option_find(xorriso, 3, rm_merge_args, &zero, 2);
	   if(ret<=0)
	     goto ex;
	 }
	
	 if(lower_r) {
	   static char *lower_r_args[3]= {"/", "-exec", "mkisofs_r"};
	   zero= 0;
	   ret= Xorriso_option_find(xorriso, 3, lower_r_args, &zero, 2);
	   if(ret<=0)
	     goto ex;
	 }
	 if(dir_mode >= 0) {
	   static char *dir_mode_args[6]= {"/", "-type", "d", "-exec", "chmod", ""};
	   zero= 0;
	   sprintf(sfe, "0%o", (unsigned int) dir_mode);
	   dir_mode_args[5]= sfe;
	   ret= Xorriso_option_find(xorriso, 6, dir_mode_args, &zero, 2);
	   if(ret<=0)
	     goto ex;
	 }
	 if(file_mode >= 0) {
	   static char *file_mode_args[6]= {"/", "-type", "f", "-exec", "chmod", ""};
	   zero= 0;
	   sprintf(sfe, "0%o", (unsigned int) file_mode);
	   file_mode_args[5]= sfe;
	   ret= Xorriso_option_find(xorriso, 6, file_mode_args, &zero, 2);
	   if(ret<=0)
	     goto ex;
	 }
	
	 if(sort_file[0]) {
	   ret= Xorriso_apply_sort_file(xorriso, sort_file, sort_file_pattern);
	   if(ret<=0)
	     goto ex;
	 }
	
	 for(j= 0; j < weight_count; j++) {
	   i= weight_list[j];
	   /* find argv[i+2] -exec sort_weight argv[i+1] */
	   zero= 0;
	   sort_weight_args[0]= argv[i + 2];
	   sort_weight_args[1]= "-exec";
	   sort_weight_args[2]= "sort_weight";
	   sort_weight_args[3]= argv[i + 1];
	   ret= Xorriso_option_find(xorriso, 4, sort_weight_args, &zero, 2);
	   if(ret > 0)
	 continue;
	   /* Problem handler */
	   was_failure= 1;
	   fret= Xorriso_eval_problem_status(xorriso, ret, 1|2);
	   if(fret>=0)
	 continue;
	   goto ex;
	 }
	
	 if(option_d)
	   Xorriso_relax_compliance(xorriso, "deep_paths:long_paths", 0);
	
	 /* After all pathspecs are added: perform delayed options, mostly boot related
	 */
	 for(j= 0; j < delay_opt_count; j++) {
	   i= delay_opt_list[j] & ~(1 << 31);
	   if(delay_opt_list[j] & (1 << 31))
	     argpt= argv[i] + 1;
	   else
	     argpt= argv[i];
	   if(strcmp(argpt, "-no-emul-boot")==0) {
	     xorriso->boot_image_emul= 0;
	     xorriso->boot_emul_default= 0;
	   } else if(strcmp(argpt, "-hard-disk-boot")==0) {
	     xorriso->boot_image_emul= 1;
	     xorriso->boot_emul_default= 0;
	   } else if(strcmp(argpt, "-boot-info-table")==0) {
	     xorriso->patch_isolinux_image= (xorriso->patch_isolinux_image & ~2) | 1;
	   } else if(strcmp(argpt, "--grub2-boot-info") == 0) {
	     xorriso->patch_isolinux_image=
	                                  (xorriso->patch_isolinux_image & ~2) | 512;
	   } else if(strcmp(argpt, "-b") == 0 ||
	             strcmp(argpt, "-eltorito-boot") == 0 ||
	             strcmp(argpt, "--efi-boot") == 0 ||
	             strcmp(argpt, "-e") == 0) {
	     i++;
	     if(strcmp(argpt, "--efi-boot") == 0) {
	       if(xorriso->boot_image_bin_path[0]) {
	         ret= Xorriso_genisofs_add_boot(xorriso, 0);
	         if(ret <= 0)
	           goto problem_handler_boot;
	       }
	       boot_path= xorriso->boot_image_bin_path;
	       xorriso->boot_efi_default= 1;
	       xorriso->boot_image_emul= 0;
	       xorriso->boot_emul_default= 0;
	
	     } else {
	       boot_path= xorriso->boot_image_bin_path; 
	       if(strcmp(argpt, "-e") == 0)
	         xorriso->boot_platform_id= 0xef;
	       else
	         xorriso->boot_platform_id= mkisofs_b_platform_id;
	       xorriso->boot_efi_default= 0;
	       if(xorriso->boot_emul_default)
	         xorriso->boot_image_emul= 2;
	     }
	     boot_path[0]= 0;
	     if(argv[i][0] != '/' && strncmp(argv[i], "--interval:", 11) != 0)
	       strcat(boot_path, "/");
	     ret= Sfile_str(boot_path + strlen(boot_path), argv[i], 0);
	     if(ret <= 0)
	       goto ex;
	     if(xorriso->boot_efi_default && xorriso->boot_image_bin_path[0]) {
	       ret= Xorriso_genisofs_add_boot(xorriso, 0);
	       if(ret <= 0)
	         goto problem_handler_boot;
	     }
	     xorriso->keep_boot_image= 0;
	     with_boot_image= 1;
	   } else if(strcmp(argpt, "-eltorito-platform") == 0) {
	     if(i + 1>=argc)
	       goto not_enough_args;
	     i++;
	     mem= mkisofs_b_platform_id;
	     mkisofs_b_platform_id= Xorriso_genisofs_platform(xorriso, argv[i], 0);
	     if(mkisofs_b_platform_id < 0) {
	       mkisofs_b_platform_id= 0;
	       goto problem_handler_boot;
	     }
	     if(mkisofs_b_platform_id != mem &&
	        xorriso->boot_image_bin_path[0] != 0) {
	       ret= Xorriso_genisofs_add_boot(xorriso, 0);
	       if(ret <= 0)
	         goto problem_handler_boot;
	     }
	
	   } else if(strcmp(argpt, "-c") == 0 ||
	             strcmp(argpt, "-eltorito-catalog") == 0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     xorriso->boot_image_cat_path[0]= 0;
	     if(argv[i][0] != '/')
	       strcat(xorriso->boot_image_cat_path, "/");
	     ret= Sfile_str(xorriso->boot_image_cat_path
	                    + strlen(xorriso->boot_image_cat_path), argv[i], 0);
	     if(ret <= 0)
	       goto ex;
	     if(with_cat_path == 0)
	       with_cat_path= 1;
	   } else if(strcmp(argpt, "-boot-load-size") == 0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     if(strcmp(argv[i], "full") == 0) {
	       xorriso->boot_img_full_size= 1;
	     } else {
	       sscanf(argv[i], "%d", &ret);
	       xorriso->boot_image_load_size= ret * 512;
	     }
	     xorriso->boot_img_size_default= 0;
	   } else if(strcmp(argpt, "-eltorito-id") == 0 ||
	             strcmp(argpt, "-eltorito-selcrit") == 0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     if(strcmp(argpt, "-eltorito-id") == 0)
	       sprintf(sfe, "id_string=%s", argv[i]);
	     else
	       sprintf(sfe, "sel_crit=%s", argv[i]);
	     ret= Xorriso_option_boot_image(xorriso, "any", sfe, 0);
	     if(ret <= 0)
	       goto problem_handler_boot;
	   } else if(strncmp(argpt, "isolinux_mbr=", 13)==0) {
	     sprintf(sfe, "isohybrid=%s", argpt + 13);
	     ret= Xorriso_option_boot_image(xorriso, "isolinux", sfe, 0);
	     if(ret <= 0)
	       goto problem_handler_boot;
	   } else if(strcmp(argpt, "-isohybrid-gpt-basdat") == 0) {
	     xorriso->patch_isolinux_image = (xorriso->patch_isolinux_image & ~0x0fc) |
	                                     (1 << 2);
	   } else if(strcmp(argpt, "-isohybrid-gpt-hfsplus") == 0) {
	     xorriso->patch_isolinux_image = (xorriso->patch_isolinux_image & ~0x0fc) |
	                                     (2 << 2);
	   } else if(strcmp(argpt, "-isohybrid-apm-hfsplus") == 0) {
	     xorriso->patch_isolinux_image = xorriso->patch_isolinux_image | (1 << 8);
	
	   } else if(strcmp(argpt, "-part_like_isohybrid") == 0) {
	     xorriso->part_like_isohybrid= 1;
	
	   } else if(strcmp(argpt, "-iso_mbr_part_type") == 0) {
	     if(i + 1 >= argc)
	       goto not_enough_args;
	     i++;
	     sprintf(sfe, "iso_mbr_part_type=%s", argv[i]);
	     ret= Xorriso_option_boot_image(xorriso, "any", sfe, 0);
	     if(ret <= 0)
	       goto problem_handler_boot;
	
	   } else if(strcmp(argpt, "--gpt_disk_guid") == 0) {
	     if(i + 1 >= argc)
	       goto not_enough_args;
	     i++;
	     ret= Xorriso_parse_gpt_guid(xorriso, argv[i], 0);
	     if(ret <= 0)
	       goto problem_handler_boot;
	
	   } else if(strcmp(argpt, "-eltorito-alt-boot")==0) {
	     ret= Xorriso_genisofs_add_boot(xorriso, 0);
	     if(ret <= 0)
	       goto problem_handler_boot;
	   } else if(strcmp(argpt, "--embedded-boot")==0 ||
	             strcmp(argpt, "-generic-boot")==0 ||
	             strcmp(argpt, "-G") == 0 ||
	             strcmp(argpt, "-isohybrid-mbr") == 0 ||
	             strcmp(argpt, "--grub2-mbr") == 0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++; 
	     if(strcmp(argv[i], ".") == 0)
	       sa_path= "";
	     else
	       sa_path= argv[i];
	     ret= Xorriso_set_system_area_path(xorriso, sa_path, 0);
	     if(ret <= 0)
	       goto problem_handler_boot;
	     if(strcmp(argpt, "-isohybrid-mbr")==0)
	       xorriso->system_area_options=
	                                    (xorriso->system_area_options & ~4001) | 2;
	     else if(strcmp(argpt, "--grub2-mbr") == 0)
	       xorriso->system_area_options= 
	                                  (xorriso->system_area_options & ~2) | 0x4000;
	   } else if(strcmp(argpt, "--protective-msdos-label")==0) {
	     xorriso->system_area_options= (xorriso->system_area_options & ~2) | 1;
	
	   } else if(strcmp(argpt, "--mbr-force-bootable") == 0) {
	     xorriso->system_area_options= xorriso->system_area_options | (1 << 15);
	
	   } else if(strcmp(argpt, "--boot-catalog-hide")==0) {
	     xorriso->boot_image_cat_hidden|= 3;
	   } else if(strcmp(argpt, "-partition_offset") == 0 ||
	             strcmp(argpt, "-partition_sec_hd") == 0 ||
	             strcmp(argpt, "-partition_hd_cyl") == 0 ||
	             strcmp(argpt, "-partition_cyl_align") == 0) {
	     if(i+1>=argc)
	       goto not_enough_args;
	     i++;
	     sprintf(sfe, "%s=%.16s", argpt + 1, argv[i]);
	     ret= Xorriso_option_boot_image(xorriso, "any", sfe, 0);
	     if(ret <= 0)
	       goto problem_handler_boot;
	
	   } else if(strcmp(argpt, "-mips-boot") == 0 ||
	             strcmp(argpt, "-mipsel-boot") == 0) {
	     if(i + 1 >= argc)
	       goto not_enough_args;
	     i++;
	     if(strcmp(argpt, "-mipsel-boot") == 0)
	       strcpy(sfe, "mipsel_path=");
	     else
	       strcpy(sfe, "mips_path=");
	     ret= Sfile_str(sfe, argv[i], 1);
	     if(ret <= 0)
	       goto ex;
	
	     ret= Xorriso_option_boot_image(xorriso, "any", sfe, 0);
	     if(ret <= 0)
	       goto problem_handler_boot;
	
	   } else if(strncmp(argpt, "-hppa-", 6) == 0) {
	     if(i + 1 >= argc)
	       goto not_enough_args;
	     i++;
	     sprintf(sfe, "-as mkisofs %s %s", argpt, argv[i]);
	     palohdrversion= (xorriso->system_area_options >> 2) & 0x3f;
	     if(palohdrversion != 4)
	       palohdrversion= 5;
	     ret= Xorriso_coordinate_system_area(xorriso, palohdrversion, 0, sfe, 0);
	     if(ret <= 0)
	       goto ex;
	     ret= Xorriso_set_hppa_boot_parm(xorriso, argv[i], argpt + 6, 0);
	     if(ret <= 0)
	       goto problem_handler_boot;
	
	   } else if(strcmp(argpt, "-alpha-boot") == 0) {
	     if(i + 1 >= argc)
	       goto not_enough_args;
	     i++;
	     sprintf(sfe, "-as mkisofs %s %s", argpt, argv[i]);
	     ret= Xorriso_coordinate_system_area(xorriso, 6, 0, sfe, 0);
	     if(ret <= 0)
	       goto ex;
	     ret= Xorriso_set_alpha_boot(xorriso, argv[i], 0);
	
	   } else if(strcmp(argpt, "-hfs-bless") == 0) {
	     static char *bless_arg_data[6]= {
	        "/", "-disk_path", "", "-exec", "set_hfs_bless", "p"};
	
	     for(j= 0; j < 6; j++)
	       bless_args[j]= bless_arg_data[j];
	     bless_args[2]= argv[i + 1];
	     zero= 0;
	     ret= Xorriso_option_find(xorriso, 6, bless_args, &zero, 2 | 16);
	     if(ret<=0)
	        goto ex;
	     if(ret < 2) {
	       sprintf(xorriso->info_text,
	               "-hfs-bless: Could not find a data file which stems from underneath disk directory ");
	       Text_shellsafe(argv[i + 1], xorriso->info_text, 1);
	       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
	       Xorriso_msgs_submit(xorriso, 0,
	                 "Consider to use: -hfs-bless-by p ISO_RR_PATH", 0, "HINT", 0);
	       goto problem_handler_boot;
	     }
	
	   } else if(strcmp(argpt, "-hfs-bless-by") == 0) {
	     ret= Xorriso_hfsplus_bless(xorriso, argv[i + 2], NULL, argv[i + 1], 0);
	     if(ret <= 0)
	       goto problem_handler_boot;
	
	   } else if(strcmp(argpt, "-hfsplus-file-creator-type") == 0) {
	     ret= Xorriso_hfsplus_file_creator_type(xorriso, argv[i + 3], NULL,
	                                            argv[i + 1],  argv[i + 2], 0);
	     if(ret <= 0)
	       goto problem_handler_boot;
	
	   }
	 continue; /* regular bottom of loop */
	problem_handler_boot:;
	   /* Problem handler */
	   was_failure= 1;
	   fret= Xorriso_eval_problem_status(xorriso, ret, 1|2);
	   if(fret>=0)
	 continue;
	   goto ex;
	 }
	 if(with_boot_image && with_cat_path == 0)
	   strcpy(xorriso->boot_image_cat_path, "/boot.catalog");
	 /* The boot catalog has to be hidden separately */
	 if(xorriso->boot_image_cat_path[0]) {
	   ret= Xorriso_path_is_hidden(xorriso, xorriso->boot_image_cat_path, 0);
	   if(ret > 0)
	     xorriso->boot_image_cat_hidden|= ret;
	   else if(ret < 0)
	     was_failure= 1;
	 }
	
	 /* Enforce the -boot-load-size default of mkisofs */
	 if(with_boot_image && xorriso->boot_img_size_default &&
	    xorriso->boot_image_emul == 0)
	   xorriso->boot_img_full_size= 1;
	
	 if(xorriso->no_emul_toc & 1)
	   xorriso->do_padding_by_libisofs= 1;
	
	 if(do_print_size) {
	   ret= Xorriso_option_print_size(xorriso, 1);
	   goto ex;
	 }
	
	 ret= !was_failure;
	ex:;
	 if(was_path && (!do_print_size) && !old_root[0])
	   Xorriso_pacifier_callback(xorriso, "files added", xorriso->pacifier_count,
	                             xorriso->pacifier_total, "", 1);
	 if(do_print_size && Xorriso_change_is_pending(xorriso, 1))
	   xorriso->volset_change_pending= 2;
	 if(weight_list != NULL)
	   free(weight_list);
	 if(delay_opt_list != NULL)
	   free(delay_opt_list);
	 Xorriso_free_meM(sort_file);
	 Xorriso_free_meM(sfe);
	 Xorriso_free_meM(adr);
	 Xorriso_free_meM(pathspec);
	 Xorriso_free_meM(eff_path);
	 Xorriso_free_meM(indev);
	 Xorriso_free_meM(old_root);
	 return(ret);
	}
	
	
	int Xorriso_as_genisofs(struct XorrisO *xorriso, int argc, char **argv,
	                      int *idx, int flag)
	{
	 int end_idx, ret, old_idx;
	
	 old_idx= *idx;
	 end_idx= Xorriso_end_idx(xorriso, argc, argv, *idx, 1);
	 (*idx)= end_idx;
	 if(end_idx<=0 || old_idx>=argc)
	   return(1);
	 ret= Xorriso_genisofs(xorriso, "genisofs", end_idx-old_idx, argv+old_idx, 0);
	 return(ret);
	}
	
	
	int Xorriso_as_cdrskin(struct XorrisO *xorriso, int argc, char **argv,
	                      int *idx, int flag)
	{
	 int end_idx, ret, old_idx;
	
	 old_idx= *idx;
	 end_idx= Xorriso_end_idx(xorriso, argc, argv, *idx, 1);
	 (*idx)= end_idx;
	 if(end_idx<=0 || old_idx>=argc)
	   return(1);
	 ret= Xorriso_cdrskin(xorriso, "cdrskin", end_idx-old_idx, argv+old_idx, 0);
	 return(ret);
	}