xorriso  1.5.4.pl02
About: GNU xorriso creates, loads, manipulates and writes ISO 9660 filesystem images with Rock Ridge extensions. It is suitable for incremental data backup and for production of bootable ISO 9660 images. GNU xorriso is a statical compilation of the libraries libburn, libisofs, libisoburn, and libjte.
  Fossies Dox: xorriso-1.5.4.pl02.tar.gz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

parse_exec.c
Go to the documentation of this file.
1 
2 /* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
3 
4  Copyright 2007-2020 Thomas Schmitt, <scdbackup@gmx.net>
5 
6  Provided under GPL version 2 or later.
7 
8  This file contains the implementation of functions which deal with parsing
9  and interpretation of command input.
10 */
11 
12 #ifdef HAVE_CONFIG_H
13 #include "../config.h"
14 #endif
15 
16 #include <ctype.h>
17 #include <sys/types.h>
18 #include <unistd.h>
19 #include <stdlib.h>
20 #include <stdio.h>
21 #include <string.h>
22 #include <sys/stat.h>
23 #include <sys/time.h>
24 #include <time.h>
25 #include <fcntl.h>
26 #include <errno.h>
27 #include <pwd.h>
28 #include <grp.h>
29 #include <sys/resource.h>
30 #include <sys/wait.h>
31 
32 
33 #include "xorriso.h"
34 #include "xorriso_private.h"
35 #include "xorrisoburn.h"
36 
37 
38 #ifdef Xorriso_fetch_with_msg_queueS
39 #include <pthread.h>
40 #endif
41 
42 
43 /* @param flag bit0= do not warn of wildcards
44  bit1= these are disk_paths
45 */
46 int Xorriso_end_idx(struct XorrisO *xorriso,
47  int argc, char **argv, int idx, int flag)
48 {
49  int i, warned= 0;
50 
51  for(i= idx; i<argc; i++) {
52  if(strcmp(argv[i], xorriso->list_delimiter)==0)
53  break;
54  if(!((flag&1) || warned))
55  warned= Xorriso_warn_of_wildcards(xorriso, argv[i], flag&2);
56  }
57  return(i);
58 }
59 
60 
61 /* Returns a vector of strings which belong to an open ended arg list.
62  If expansion is enabled, the vector might be allocated, else it is
63  a pointer into the argv input vector.
64  Thus the release of that memory is an expert task to be done by this
65  function only. Use bit8 for that. With bit8 parameter argc MUST be the
66  same value as with the call which might have allocated memory.
67  @param xorriso The environment object
68  @param argc Length of argv
69  @param argv The vector with arguments, eventual list_delimiter ("--")
70  and then eventual unrelated words
71  @param idx Start index in argv of the argument list
72  @param optc Length of the effective possibly expanded option vector
73  @param optv The option vector. Maybe a pointer into argv or maybe
74  an own allocated vector.
75  @param flag bit0= do not warn of wildcards
76  bit1= these are disk_paths
77  bit2= never expand wildcards
78  bit3= do not expand last argument
79  bit4= ignore last argument
80  bit5= demand exactly one match
81  bit6= with bit5 allow 0 matches if pattern is a constant
82  bit7= silently tolerate empty argument list
83  bit8= free the eventually allocated sub_vector
84  bit9= always expand wildcards
85  bit10= do not add unresolved pattern to optv
86 */
87 int Xorriso_opt_args(struct XorrisO *xorriso, char *cmd,
88  int argc, char **argv, int idx,
89  int *end_idx, int *optc, char ***optv, int flag)
90 {
91  int i, do_expand, nump, was_empty= 0, filec= 0, ret;
92  char **filev= NULL, **patterns= NULL;
93  off_t mem= 0;
94 
95  if(flag&2)
96  do_expand= (xorriso->do_disk_pattern==1 && !(flag&4)) || (flag & 512);
97  else
98  do_expand= (xorriso->do_iso_rr_pattern==1 && !(flag&4)) || (flag & 512);
99  if(flag&256) {
100  if(argv == NULL || *optv < argv || (*optv >= argv + argc && argc > 0))
101  Sfile_destroy_argv(optc, optv, 0);
102  return(1);
103  }
104  if(idx>=argc) {
105  *end_idx= argc;
106  *optc= 0;
107  *optv= NULL;
108  sprintf(xorriso->info_text, "%s : Not enough arguments given", cmd);
109  if((flag & 128))
110  return(1);
111  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
112  return(0);
113  }
114  *end_idx= Xorriso_end_idx(xorriso, argc, argv, idx,
115  ((flag&1) || do_expand) | (flag&2));
116  if(*end_idx<0)
117  return(*end_idx);
118  if((flag&16) && (*end_idx)>idx)
119  (*end_idx)--;
120 
121  *optc= *end_idx - idx;
122  *optv= NULL;
123  if(*optc<=0 || !do_expand) {
124 copy_args:;
125  if(*optc > 0) {
126  Xorriso_alloc_meM(*optv, char *, *optc);
127  for(i= 0; i < *optc; i++) {
128  Xorriso_alloc_meM((*optv)[i], char, strlen(argv[idx + i]) + 1);
129  strcpy((*optv)[i], argv[idx + i]);
130  }
131  }
132  return(1);
133  }
134  patterns= calloc(*optc, sizeof(char *));
135  if(patterns==NULL) {
136 no_memory:;
137  sprintf(xorriso->info_text,
138  "%s : Cannot allocate enough memory for pattern expansion", cmd);
139  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
140  {ret= -1; goto ex;}
141  }
142  nump= 0;
143  if(flag&8) {
144  was_empty= 1;
145  mem+= strlen(argv[idx + *optc - 1])+1+sizeof(char *);
146  }
147  for(i= 0; i<*optc-!!(flag&8); i++) {
148  if(argv[i + idx][0]==0) {
149  was_empty++;
150  mem+= sizeof(char *); /* as upper limit for size of an empty string */
151  continue;
152  }
153  patterns[nump++]= argv[i + idx];
154  }
155  if(nump<=0) { /* Only empty texts. May the caller get happy with them. */
156  free(patterns);
157  goto copy_args;
158  }
159  if(flag&2)
160  ret= Xorriso_expand_disk_pattern(xorriso, nump, patterns, was_empty,
161  &filec, &filev, &mem,
162  ((flag >> 5) & 3) | ((!!(flag & 1024)) << 3));
163  else
164  ret= Xorriso_expand_pattern(xorriso, nump, patterns, was_empty,
165  &filec, &filev, &mem,
166  ((flag >> 5) & 3) | ((!!(flag & 1024)) << 3));
167  if(ret<=0)
168  {ret= 0; goto ex;}
169  for(i= 0; i<was_empty; i++) {
170  if(i==was_empty-1 && (flag&8))
171  filev[filec++]= strdup(argv[idx + *optc - 1]);
172  else
173  filev[filec++]= strdup("");
174  if(filev[filec-1]==NULL)
175  goto no_memory;
176  }
177 
178 #ifdef Xorriso_verbous_pattern_expansioN
179 { int l;
180  sprintf(xorriso->info_text, "Pattern expansion yields %d items:", filec);
181  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
182  l= 0;
183  xorriso->info_text[0]= 0;
184  for(i= 0; i<filec; i++) {
185  l= strlen(xorriso->info_text);
186  if(l>0 && l+1+strlen(filev[i])>60) {
187  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
188  xorriso->info_text[0]= 0;
189  l= 0;
190  }
191  sprintf(xorriso->info_text+l, " %s", filev[i]);
192  }
193  l= strlen(xorriso->info_text);
194  if(l>0)
195  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
196 }
197 #endif /* Xorriso_verbous_pattern_expansioN */
198 
199  ret= 1;
200 ex:;
201  if(patterns!=NULL)
202  free((char *) patterns);
203  if(ret<=0) {
204  Sfile_destroy_argv(&filec, &filev, 0);
205  } else {
206  *optc= filec;
207  *optv= filev;
208  }
209  return(ret);
210 }
211 
212 
213 /* @param flag bit0= get eternal problem status
214 */
215 int Xorriso_get_problem_status(struct XorrisO *xorriso, char severity[80],
216  int flag)
217 {
218  if(flag & 1) {
219  strcpy(severity, xorriso->eternal_problem_status_text);
220  return(xorriso->eternal_problem_status);
221  } else {
222  strcpy(severity, xorriso->problem_status_text);
223  return(xorriso->problem_status);
224  }
225 }
226 
227 
228 /* @param flag bit0= set eternal problem status to severity,
229  and set problem status to ALL
230 */
231 int Xorriso_set_problem_status(struct XorrisO *xorriso, char *severity,
232  int flag)
233 {
234  char *sev_text= "ALL";
235  int sev, ret;
236 
237 #ifdef Xorriso_fetch_with_msg_queueS
238  int locked= 0, uret;
239  static int complaints= 0, complaint_limit= 5;
240 #endif
241 
242  if(severity[0] && strlen(severity) < sizeof(xorriso->problem_status_text))
243  sev_text= severity;
244  ret= Xorriso__text_to_sev(sev_text, &sev, 0);
245  if(ret<=0)
246  return(0);
247 
248 #ifdef Xorriso_fetch_with_msg_queueS
249 
250  ret= pthread_mutex_lock(&(xorriso->problem_status_lock));
251  if(ret != 0) {
252  /* Cannot report failure through the failing message output system */
253  complaints++;
254  if(complaints < complaint_limit)
255  fprintf(stderr,
256  "xorriso : pthread_mutex_lock() for problem_status returns %d\n",
257  ret);
258  } else
259  locked= 1;
260 
261 #endif /* Xorriso_fetch_with_msg_queueS */
262 
263  if(flag & 1) {
264  strcpy(xorriso->problem_status_text, "ALL");
266  &(xorriso->problem_status), 0);
267  } else {
268  xorriso->problem_status= sev;
269  strcpy(xorriso->problem_status_text, sev_text);
270  }
271  if(sev > xorriso->eternal_problem_status || (flag & 1)) {
272  xorriso->eternal_problem_status= sev;
273  strcpy(xorriso->eternal_problem_status_text, sev_text);
274  }
275 
276 #ifdef Xorriso_fetch_with_msg_queueS
277 
278  if(locked) {
279  uret= pthread_mutex_unlock(&(xorriso->problem_status_lock));
280  if(uret != 0) {
281  /* Cannot report failure through the failing message output system */
282  complaints++;
283  if(complaints < complaint_limit)
284  fprintf(stderr,
285  "xorriso : pthread_mutex_unlock() for problem_status returns %d\n",
286  uret);
287  }
288  }
289 
290 #endif /* Xorriso_fetch_with_msg_queueS */
291 
292  return(1);
293 }
294 
295 
296 /**
297  @param flag bit0= do not issue own event messages
298  bit1= take xorriso->request_to_abort as reason for abort
299  @return Gives the advice:
300  2= pardon was given, go on
301  1= no problem, go on
302  0= function failed but xorriso would not abort, go on
303  <0= do abort
304  -1 = due to problem_status
305  -2 = due to xorriso->request_to_abort
306 */
307 int Xorriso_eval_problem_status(struct XorrisO *xorriso, int ret, int flag)
308 {
309  static int sev= 0;
310  if(sev==0)
311  Xorriso__text_to_sev("SORRY", &sev, 0);
312 
313  if((flag&2) && xorriso->request_to_abort)
314  return(-2);
315 
316  Xorriso_process_msg_queues(xorriso, 0);
317  if(ret>0 && xorriso->problem_status <= 0)
318  return(1);
319 
320  if(xorriso->problem_status < xorriso->abort_on_severity &&
321  xorriso->problem_status > 0) {
322  if(xorriso->problem_status >= sev && !(flag&1)) {
323  sprintf(xorriso->info_text,
324  "xorriso : NOTE : Tolerated problem event of severity '%s'\n",
325  xorriso->problem_status_text);
326  Xorriso_info(xorriso, 0);/* submit not as problem event */
327  }
328  ret= 2;
329  } else if(xorriso->problem_status > 0) {
330  sprintf(xorriso->info_text,
331  "xorriso : aborting : -abort_on '%s' encountered '%s'\n",
332  xorriso->abort_on_text, xorriso->problem_status_text);
333  if(!(flag&1))
334  Xorriso_info(xorriso, 0);/* submit not as problem event */
335  ret= -1;
336  } else if(ret>0)
337  ret= 1;
338  else
339  ret= 2;
340  return(ret);
341 }
342 
343 
344 /* @param flag bit0= a non-existing target of multiple sources is a directory
345  bit1= all paths except the last one are disk_paths
346  bit2= the last path is a disk_path
347  @return <=0 is error, 1= leaf file object, 2= directory
348 */
349 int Xorriso_cpmv_args(struct XorrisO *xorriso, char *cmd,
350  int argc, char **argv, int *idx,
351  int *optc, char ***optv, char eff_dest[SfileadrL],
352  int flag)
353 {
354  int destc= 0, is_dir=0, end_idx, ret, i;
355  char **destv= NULL;
356 
357  end_idx= Xorriso_end_idx(xorriso, argc, argv, *idx,
358  (xorriso->do_iso_rr_pattern==1)|(flag&2));
359  if(end_idx - *idx < 2) {
360  sprintf(xorriso->info_text, "%s: not enough arguments", cmd);
361  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
362  {ret= 0; goto ex;}
363  }
364 
365  ret= Xorriso_opt_args(xorriso, cmd, argc, argv, *idx, &end_idx, optc, optv,
366  1 | (flag&2) | 16); /* ignore last argument */
367  if(ret<=0)
368  goto ex;
369  /* demand one match, or 0 with a constant */
370  ret= Xorriso_opt_args(xorriso, cmd, argc, argv, end_idx, &end_idx, &destc,
371  &destv, 1 | ((flag&4)>>1) | 32 | 64);
372  if(ret<=0)
373  goto ex;
374 
375  /* Evaluate target address */
376  if(flag&4)
377  ret= Xorriso_normalize_img_path(xorriso, xorriso->wdx, destv[0], eff_dest,
378  2|4|16);
379  else
380  ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, destv[0], eff_dest,
381  1);
382  if(ret<0)
383  {ret= 0; goto ex;}
384  if(ret==2 || ((flag&1) && *optc > 1 && ret==0)) {
385  is_dir= 1;
386  } else if(*optc > 1) {
387  if(flag & 2)
388  for(i= 0; i<*optc; i++)
389  Xorriso_msgs_submit(xorriso, 0, (*optv)[i], 0, "ERRFILE", 0);
390  sprintf(xorriso->info_text,
391  "%s: more than one origin given, destination is a non-directory: ",
392  cmd);
393  Text_shellsafe(destv[0], xorriso->info_text, 1);
394  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
395  {ret= 0; goto ex;}
396  }
397  if(ret==0) { /* compute complete eff_dest */
398  ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, destv[0], eff_dest,
399  2 | (flag&4));
400  if(ret<0)
401  {ret= 0; goto ex;}
402  }
403 
404  ret= 1+is_dir;
405 ex:;
406  Xorriso_opt_args(xorriso, cmd, argc, argv, *idx, &end_idx, &destc, &destv,
407  256);
408  (*idx)= end_idx;
409  return(ret);
410 }
411 
412 
413 /* @param flag bit0= with adr_mode sbsector: adr_value is possibly 16 too high
414 */
415 int Xorriso_decode_load_adr(struct XorrisO *xorriso, char *cmd,
416  char *adr_mode, char *adr_value,
417  int *entity_code, char entity_id[81],
418  int flag)
419 {
420  double num;
421  int l;
422 
423  if(strcmp(adr_mode, "auto")==0)
424  *entity_code= 0;
425  else if(strcmp(adr_mode, "session")==0)
426  *entity_code= 1;
427  else if(strcmp(adr_mode, "track")==0)
428  *entity_code= 2;
429  else if(strcmp(adr_mode, "lba")==0 || strcmp(adr_mode, "sbsector")==0)
430  *entity_code= 3 | ((flag&1) << 16);
431  else if(strcmp(adr_mode, "volid")==0)
432  *entity_code= 4;
433  else {
434  sprintf(xorriso->info_text, "%s: unknown address mode '%s'", cmd, adr_mode);
435  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
436  return(0);
437  }
438  l= strlen(adr_value);
439  if(l==0)
440  *entity_code= 0;
441 
442  if(*entity_code>=1 && *entity_code<= 3) {
443  num= Scanf_io_size(adr_value, 0);
444  if(*entity_code==3 &&
445  (adr_value[l-1]<'0' || adr_value[l-1]>'9'))
446  num/= 2048.0;
447  sprintf(entity_id, "%.f", num);
448  } else {
449  if(strlen(adr_value)>80) {
450  sprintf(xorriso->info_text, "%s: address value too long (80 < %d)",
451  cmd, (int) strlen(adr_value));
452  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
453  return(0);
454  }
455  strcpy(entity_id, adr_value);
456  }
457  return(1);
458 }
459 
460 
461 int Xorriso_check_thing_len(struct XorrisO *xorriso, char *name, int size,
462  char *cmd, char *thing, int flag)
463 {
464  if((int) strlen(name) >= size) {
465  sprintf(xorriso->info_text,
466  "%s too long with option %s (%d > %d)", thing, cmd,
467  (int) strlen(name), size - 1);
468  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
469  return(0);
470  }
471  return(1);
472 }
473 
474 
475 int Xorriso_check_name_len(struct XorrisO *xorriso, char *name, int size,
476  char *cmd, int flag)
477 {
478  return Xorriso_check_thing_len(xorriso, name, size, cmd, "Name", flag);
479 }
480 
481 
482 /* @return <0 error , >=0 number of skipped dashes
483 */
484 int Xorriso_normalize_command(struct XorrisO *xorriso, char *original_cmd,
485  int argno, char *cmd_data, int sizeof_cmd_data,
486  char **cmd, int flag)
487 {
488  int was_dashed= 0;
489  char *dash_pt;
490 
491  if((int) strlen(original_cmd) >= sizeof_cmd_data) {
492  if(argno>=0)
493  sprintf(xorriso->info_text, "Oversized argument #%d (length %d)\n",
494  argno, (int) strlen(original_cmd));
495  else
496  sprintf(xorriso->info_text, "Oversized option (length %d)\n",
497  (int) strlen(original_cmd));
498  return(-1);
499  }
500  strcpy(cmd_data, original_cmd);
501  *cmd= cmd_data;
502  if(strcmp(*cmd, xorriso->list_delimiter)==0)
503  return(1);
504  while((*cmd)[0]=='-') {
505  if((*cmd)[1]==0)
506  break;
507  was_dashed++;
508  (*cmd)++;
509  }
510  for(dash_pt= *cmd; *dash_pt!=0; dash_pt++)
511  if(*dash_pt=='-')
512  *dash_pt= '_';
513  return(was_dashed);
514 }
515 
516 
517 /* @param flag bit0= do not warn of unknown option
518  @return <=0 error,
519  1=count is valid, 2=dashed unknown, 3=undashed unknown
520 */
521 int Xorriso_count_args(struct XorrisO *xorriso, int argc, char **argv,
522  int *count, int flag)
523 {
524  int ret, was_dashed= 0, i, cmd_data_size= 2 * SfileadrL;
525  char *cmd, *cmd_data= NULL;
526  static char arg0_commands[][40]= {
527  "ban_stdio_write","close_filter_list","commit",
528  "device_links","devices","end",
529  "for_backup", "help",
530  "list_arg_sorting","list_formats","list_speeds",
531  "no_rc","print_size","pvd_info","pwd","pwdi","pwdx",
532  "read_mkisofsrc","rollback","rollback_end",
533  "tell_media_space","toc","version",
534  ""
535  };
536  static char arg1_commands[][40]= {
537  "abort_on","acl","add_plainly","application_id","application_use",
538  "auto_charset","abstract_file",
539  "backslash_codes","blank","biblio_file",
540  "calm_drive","cd","cdi","cdx","changes_pending","charset",
541  "close","close_damaged",
542  "commit_eject","compliance","copyright_file",
543  "dev","dialog","disk_dev_ino","disk_pattern","displacement",
544  "drive_access","dummy","dvd_obs","early_stdio_test","ecma119_map","eject",
545  "extract_boot_images",
546  "iso_nowtime","iso_rr_pattern","file_name_limit","follow","format","fs",
547  "gid","grow_blindly","hardlinks",
548  "hfsplus","history","indev","in_charset","joliet","joliet_map",
549  "list_delimiter","list_extras","list_profiles","local_charset",
550  "mark","md5","mount_opts","modesty_on_drive",
551  "not_leaf","not_list","not_mgt",
552  "options_from_file","osirrox","outdev","out_charset","overwrite",
553  "pacifier","padding","path_list","pathspecs","pkt_output",
554  "preparer_id","print","print_info","print_mark","prompt",
555  "prog","prog_help","publisher","quoted_not_list","quoted_path_list",
556  "read_fs","read_speed","reassure","report_about",
557  "report_el_torito","report_system_area","rockridge",
558  "rom_toc_scan","rr_reloc_dir","scsi_dev_family","scsi_log",
559  "session_log","sh_style_result","signal_handling","sleep",
560  "speed","split_size","status","status_history_max",
561  "stdio_sync","stream_recording","system_id","temp_mem_limit","toc_of",
562  "uid","unregister_filter","use_immed_bit","use_readline",
563  "volid","volset_id",
564  "write_type","xattr","zisofs",
565  ""
566  };
567  static char arg2_commands[][40]= {
568  "assert_volid","boot_image","clone","compare","compare_r","drive_class",
569  "data_cache_size",
570  "errfile_log","error_behavior","extract","extract_single",
571  "jigdo","lns","lnsi","load","logfile",
572  "map","map_single","move","msg_op","page","return_with",
573  "scdbackup_tag","update","update_r","volume_date",
574  ""
575  };
576  static char arg3_commands[][40]= {
577  "append_partition", "truncate_overwritable",
578  ""
579  };
580  static char arg4_commands[][40]= {
581  "cut_out","extract_cut","mount","mount_cmd","named_pipe_loop",
582  "paste_in","session_string",
583  ""
584  };
585  static char argn_commands[][40]= {
586  "add","alter_date","alter_date_r","as",
587  "check_md5","check_md5_r","check_media","check_media_defaults",
588  "chgrp","chgrpi","chgrp_r","chgrp_ri","chmod","chmodi",
589  "chmod_r","chmod_ri","chown","chowni","chown_r","chown_ri",
590  "compare_l","concat","cp_clone","cp_rax","cp_rx","cpr","cpri","cpax","cpx",
591  "du","dui","dus","dusi","dux","dusx","external_filter","extract_l",
592  "file_size_limit","find","findi","finds","findx",
593  "getfacl","getfacli","getfacl_r","getfacl_ri",
594  "getfattr","getfattri","getfattr_r","getfattr_ri","hide",
595  "launch_frontend","ls","lsi","lsl","lsli","lsd","lsdi","lsdl","lsdli",
596  "lsx","lslx","lsdx","lsdlx","map_l","mv","mvi","mkdir","mkdiri",
597  "not_paths","rm","rmi","rm_r","rm_ri","rmdir","rmdiri",
598  "update_l","update_li","update_lx","update_lxi",
599  "setfacl","setfacli","setfacl_list","setfacl_listi",
600  "setfacl_r","setfacl_ri","setfattr","setfattri",
601  "setfattr_list","setfattr_listi","setfattr_r","setfattr_ri",
602  "set_filter","set_filter_r","show_stream","show_stream_r",
603  ""
604  };
605 
606  Xorriso_alloc_meM(cmd_data, char, cmd_data_size);
607 
608  *count= 0;
609  if(argc<=0)
610  {ret= -1; goto ex;}
611  ret= Xorriso_normalize_command(xorriso, argv[0], -1,
612  cmd_data, cmd_data_size, &cmd, 0);
613  if(ret<0)
614  goto ex;
615  was_dashed= (ret>0);
616  if(cmd[0]=='#' || cmd[0]==0 || strcmp(cmd, xorriso->list_delimiter) == 0) {
617  /* ignore: comment line , empty option , orphaned list delimiter */
618  {ret= 1; goto ex;}
619  }
620  for(i=0; arg0_commands[i][0]!=0; i++)
621  if(strcmp(arg0_commands[i], cmd)==0)
622  {ret= 1; goto ex;}
623  *count= 1;
624  for(i=0; arg1_commands[i][0]!=0; i++)
625  if(strcmp(arg1_commands[i], cmd)==0)
626  {ret= 1; goto ex;}
627  *count= 2;
628  for(i=0; arg2_commands[i][0]!=0; i++)
629  if(strcmp(arg2_commands[i], cmd)==0)
630  {ret= 1; goto ex;}
631  *count= 3;
632  for(i=0; arg3_commands[i][0]!=0; i++)
633  if(strcmp(arg3_commands[i], cmd)==0)
634  {ret= 1; goto ex;}
635  *count= 4;
636  for(i=0; arg4_commands[i][0]!=0; i++)
637  if(strcmp(arg4_commands[i], cmd)==0)
638  {ret= 1; goto ex;}
639  *count= 0;
640  for(i=0; argn_commands[i][0]!=0; i++)
641  if(strcmp(argn_commands[i], cmd)==0) {
642  ret= Xorriso_end_idx(xorriso, argc, argv, 1, 1);
643  if(ret<1)
644  goto ex;
645  *count= ret-1;
646  {ret= 1; goto ex;}
647  }
648 
649  if(!(flag&1)) {
650  sprintf(xorriso->info_text, "Unknown option : '%s'", argv[0]);
651  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING", 0);
652  }
653 
654  ret= 2 + !was_dashed;
655 ex:
656  Xorriso_free_meM(cmd_data);
657  return(ret);
658 }
659 
660 
661 /* @param flag bit0= list sorting order rather than looking for argv[idx]
662 */
663 int Xorriso_cmd_sorting_rank(struct XorrisO *xorriso,
664  int argc, char **argv, int idx, int flag)
665 {
666  int ret, i, cmd_data_size= 2 * SfileadrL;
667  char *cmd, *cmd_data= NULL;
668  static char *commands[]= {
669 
670  "* Execution order of program arguments with option -x:",
671  "x",
672 
673  "* Support for frontend programs via stdin and stdout (1):",
674  "prog", "prog_help",
675 
676  "* Exception processing:",
677  "abort_on", "return_with", "report_about", "signal_handling",
678  "error_behavior",
679 
680  "* Scripting, dialog and program control features (1):",
681  "no_rc", "help", "version", "list_extras", "list_arg_sorting",
682  "temp_mem_limit", "backslash_codes",
683  "errfile_log", "session_log", "scsi_log",
684  "options_from_file", "list_delimiter",
685  "print", "print_info", "print_mark", "prompt", "sleep",
686  "sh_style_result",
687 
688  "* Influencing opening of drives:",
689  "drive_access","drive_class","early_stdio_test",
690 
691  "* Drive and media related inquiry actions (1):",
692  "devices", "device_links",
693  "mount_opts", "mount_cmd", "session_string",
694 
695  "* Influencing the behavior of image loading:",
696  "read_speed", "load", "displacement", "read_fs",
697  "assert_volid", "in_charset",
698  "auto_charset", "hardlinks", "acl", "xattr", "md5", "for_backup",
699  "ecma119_map", "joliet_map",
700  "disk_dev_ino", "rom_toc_scan", "calm_drive", "ban_stdio_write",
701  "data_cache_size",
702  "scsi_dev_family", "iso_nowtime",
703 
704  "* Character sets:",
705  "charset", "local_charset",
706 
707  "* Acquiring source and target drive:",
708  "dev", "indev", "outdev",
709 
710  "* Drive and media related inquiry actions (2):",
711  "list_profiles", "list_formats", "list_speeds",
712  "toc", "toc_of", "pvd_info", "report_system_area", "report_el_torito",
713 
714  "* Settings for file insertion:",
715  "file_name_limit", "file_size_limit",
716  "not_mgt", "not_paths", "not_leaf", "not_list",
717  "quoted_not_list", "follow", "pathspecs", "overwrite", "split_size",
718 
719  "* Navigation in ISO image and disk filesystem (1):",
720  "cd", "cdx", "pwd", "pwdx",
721 
722  "* Inserting files into ISO image:",
723  "disk_pattern", "add_plainly",
724  "mkdir", "lns", "add", "path_list", "quoted_path_list",
725  "map", "map_single", "map_l", "update", "update_r",
726  "update_l", "update_li", "update_lx", "update_lxi",
727  "cut_out", "cpr",
728  "clone", "cp_clone",
729 
730  "* Navigation in ISO image and disk filesystem (2):",
731  "ls", "lsd", "lsl", "lsdl", "lsx", "lsdx", "lslx", "lsdlx",
732  "getfacl", "getfacl_r", "getfattr", "getfattr_r", "du", "dus",
733  "dux", "dusx", "findx",
734  "compare", "compare_r", "compare_l", "show_stream", "show_stream_r",
735 
736  "* File manipulations:",
737  "iso_rr_pattern",
738  "rm", "rm_r", "rmdir", "move", "mv",
739  "chown", "chown_r", "chgrp", "chgrp_r", "chmod", "chmod_r", "setfacl",
740  "setfacl_r", "setfacl_list", "setfattr", "setfattr_r", "setfattr_list",
741  "alter_date", "alter_date_r", "hide",
742 
743  "* Filters for data file content:",
744  "external_filter", "unregister_filter", "close_filter_list",
745  "set_filter", "set_filter_r",
746 
747  "* Tree traversal command -find:",
748  "find",
749 
750  "* osirrox ISO-to-disk restore options:",
751  "osirrox", "extract", "extract_single", "extract_l", "extract_cut",
752  "extract_boot_images",
753  "cpx", "cpax", "cp_rx", "cp_rax", "paste_in", "concat",
754  "mount",
755 
756  "* Settings for result writing:",
757  "rockridge", "joliet", "hfsplus","compliance", "rr_reloc_dir",
758  "volid", "volset_id", "publisher",
759  "application_id", "system_id", "volume_date", "copyright_file",
760  "abstract_file", "biblio_file", "preparer_id", "application_use",
761  "out_charset", "read_mkisofsrc",
762  "uid", "gid", "zisofs", "speed", "stream_recording", "dvd_obs",
763  "modesty_on_drive", "use_immed_bit",
764  "stdio_sync", "dummy", "fs", "close", "padding", "write_type",
765  "grow_blindly", "pacifier", "scdbackup_tag",
766 
767  "* Bootable ISO images:",
768  "boot_image", "append_partition",
769 
770  "* Jigdo Template Extraction:",
771  "jigdo",
772 
773  "* Command compatibility emulations:",
774  "as",
775 
776  "* Scripting, dialog and program control features (2):",
777  "history", "status_history_max", "status",
778 
779  "* Drive and media related inquiry actions (3):",
780  "print_size", "tell_media_space",
781 
782  "* Writing the result, drive control:",
783  "format", "blank", "truncate_overwritable", "close_damaged",
784  "rollback", "changes_pending", "commit", "commit_eject",
785  "eject",
786 
787  "* Evaluation of readability and recovery:",
788  "check_media_defaults", "check_media", "check_md5", "check_md5_r",
789 
790  "* Support for frontend programs via stdin and stdout (2):",
791  "pkt_output", "logfile", "mark", "msg_op",
792 
793  "* Dialog mode control:",
794  "dialog", "page", "use_readline", "reassure",
795 
796  "* Support for frontend programs via stdin and stdout (3):",
797  "launch_frontend", "named_pipe_loop",
798 
799  "* Scripting, dialog and program control features (3):",
800  "rollback_end", "end",
801 
802  ""
803  };
804 
805  if(flag & 1) {
806  for(i= 0; commands[i][0] !=0; i++) {
807  if(commands[i][0] == '*')
808  sprintf(xorriso->result_line, "#%s\n", commands[i] + 1);
809  else
810  sprintf(xorriso->result_line, "-%s\n", commands[i]);
811  Xorriso_result(xorriso, 0);
812  }
813  ret= 1; goto ex;
814  }
815  if(argc <= 0)
816  {ret= -1; goto ex;}
817 
818  Xorriso_alloc_meM(cmd_data, char, cmd_data_size);
819  ret= Xorriso_normalize_command(xorriso, argv[idx], -1,
820  cmd_data, cmd_data_size, &cmd, 0);
821  if(ret < 0)
822  goto ex;
823 
824  if(cmd[0] == '#' || cmd[0] == 0 ||
825  strcmp(cmd, xorriso->list_delimiter) == 0) {
826  /* Move to end: comment line , empty option , orphaned list delimiter */
827  ret= 0x7fffffff; goto ex;
828  }
829  for(i= 0; commands[i][0] !=0; i++) {
830  if(commands[i][0] == '*') /* headline in command list */
831  continue;
832  if(strcmp(commands[i], cmd) != 0)
833  continue;
834  ret= i + 1; goto ex;
835  }
836 
837  ret= 1;
838 ex:
839  Xorriso_free_meM(cmd_data);
840  return(ret);
841 }
842 
843 
844 int Xorriso__cmp_cmd_rank(const void *a, const void *b)
845 {
846  int ra, rb;
847 
848  ra= ((int *) a)[1];
849  rb= ((int *) b)[1];
850  if(ra < rb)
851  return(-1);
852  if(ra > rb)
853  return(1);
854  ra= ((int *) a)[2];
855  rb= ((int *) b)[2];
856  if(ra < rb)
857  return(-1);
858  if(ra > rb)
859  return(1);
860  return(0);
861 }
862 
863 
864 /* @param flag bit0= print command sequence rather than executing it
865  bit1= these are command line arguments
866  (for xorriso->argument_emulation)
867 */
868 int Xorriso_exec_args_sorted(struct XorrisO *xorriso,
869  int argc, char **argv, int *idx, int flag)
870 {
871  int cmd_count= 0, ret, i, arg_count, *idx_rank= NULL, cmd_idx;
872 
873  /* Count commands and allocate index-rank array */
874  for(i= *idx; i < argc; i++) {
875  ret= Xorriso_count_args(xorriso, argc - i, argv + i, &arg_count, 1);
876  if(ret <= 0)
877  goto ex;
878  if(ret != 1)
879  continue;
880  cmd_count++;
881  i+= arg_count;
882  }
883  if(cmd_count <= 0)
884  {ret= 1; goto ex;}
885  Xorriso_alloc_meM(idx_rank, int, 3 * cmd_count);
886 
887  /* Fill index-rank array and sort */
888  cmd_count= 0;
889  for(i= *idx; i < argc; i++) {
890  ret= Xorriso_count_args(xorriso, argc - i, argv + i, &arg_count, 1);
891  if(ret <= 0)
892  goto ex;
893  if(ret != 1)
894  continue;
895  idx_rank[3 * cmd_count]= i;
896  ret= Xorriso_cmd_sorting_rank(xorriso, argc, argv, i, 0);
897  if(ret < 0)
898  goto ex;
899  idx_rank[3 * cmd_count + 1]= ret;
900  idx_rank[3 * cmd_count + 2]= cmd_count;
901  cmd_count++;
902  i+= arg_count;
903  }
904  qsort(idx_rank, cmd_count, 3 * sizeof(int), Xorriso__cmp_cmd_rank);
905 
906  /* Execute or print indice from index-rank array */
907  if(flag & 1) {
908  sprintf(xorriso->result_line,
909  "Automatically determined command sequence:\n");
910  Xorriso_result(xorriso, 0);
911  xorriso->result_line[0]= 0;
912  }
913  for(i= 0; i < cmd_count; i++) {
914  cmd_idx= idx_rank[3 * i];
915  if(flag & 1) {
916  if(strlen(xorriso->result_line) + 1 + strlen(argv[cmd_idx]) > 78) {
917  strcat(xorriso->result_line, "\n");
918  Xorriso_result(xorriso, 0);
919  xorriso->result_line[0]= 0;
920  }
921  sprintf(xorriso->result_line + strlen(xorriso->result_line),
922  " %s", argv[cmd_idx]);
923  } else {
924  ret= Xorriso_interpreter(xorriso, argc, argv, &cmd_idx, 4 | (flag & 2));
925  if(ret <= 0 || ret == 3)
926  goto ex;
927  }
928  }
929  if(flag & 1) {
930  if(strlen(xorriso->result_line) > 0) {
931  strcat(xorriso->result_line, "\n");
932  Xorriso_result(xorriso, 0);
933  }
934  } else
935  *idx= argc;
936  ret= 1;
937 ex:
938  Xorriso_free_meM(idx_rank);
939  return(ret);
940 }
941 
942 
943 /* @param flag bit0= recursion
944  bit1= these are command line arguments
945  (for xorriso->argument_emulation)
946  bit2= Only execute the one command argv[*idx] and advance
947  *idx to the next command if successful. Then return.
948 */
949 int Xorriso_interpreter(struct XorrisO *xorriso,
950  int argc, char **argv, int *idx, int flag)
951 /*
952 return:
953  <=0 error , 1 = success , 2 = problem event ignored , 3 = end program run
954 */
955 {
956  int ret, was_dashed, end_ret, num1, num2, cmd_data_size= 2 * SfileadrL;
957  int mem_idx, arg_count, i;
958  char *cmd, *original_cmd, *cmd_data= NULL, *arg1, *arg2, *arg3, *arg4;
959 
960  Xorriso_alloc_meM(cmd_data, char, cmd_data_size);
961 
962  if(xorriso==NULL)
963  {ret= 0; goto ex;}
964  if(xorriso->is_dialog) {
965  xorriso->result_line_counter= xorriso->result_page_counter= 0;
966  if(xorriso->result_page_length<0)
967  xorriso->result_page_length= -xorriso->result_page_length;
968  }
969 
970 next_command:;
971  if(flag&2) {
972  ret= 1;
973  if(xorriso->argument_emulation==1)
974  ret= Xorriso_as_genisofs(xorriso, argc, argv, idx, 0);
975  else if(xorriso->argument_emulation==2)
976  ret= Xorriso_as_cdrskin(xorriso, argc, argv, idx, 0);
977  if(xorriso->argument_emulation>0) {
978  xorriso->argument_emulation= 0;
979  if(ret<=0)
980  goto eval_any_problems;
981  if((*idx)>=argc)
982  {ret= 1; goto ex;}
983  }
984  if((xorriso->arrange_args || (flag & 8)) && !(flag & (4 | 16))) {
985  ret= Xorriso_exec_args_sorted(xorriso, argc, argv, idx, 0);
986  goto ex;
987  }
988  }
989 
990  ret= Xorriso_count_args(xorriso, argc - *idx, argv + *idx, &arg_count, 1);
991  if((ret == 1 || ret == 2) &&
992  strcmp(argv[*idx], xorriso->list_delimiter) != 0) {
993  sprintf(xorriso->info_text, "Command: %s", argv[*idx]);
994  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
995  for(i= 1; i <= arg_count && *idx + i < argc; i++) {
996  sprintf(xorriso->info_text, "Parameter: %s", argv[*idx + i]);
997  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
998  }
999  if(*idx + arg_count >= argc) {
1000  sprintf(xorriso->info_text, "Missing arguments: %d",
1001  *idx + arg_count + 1 - argc);
1002  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
1003  }
1004  }
1005 
1006  xorriso->prepended_wd= 0;
1007  xorriso->request_to_abort= xorriso->request_not_to_ask= 0;
1008  Xorriso_set_problem_status(xorriso, "", 0);
1009  if((*idx)<argc)
1010  original_cmd= cmd= argv[*idx];
1011  else
1012  original_cmd= cmd= "";
1013  if(xorriso->add_plainly==3 && cmd[0] && !xorriso->is_dialog) {
1014  (*idx)++;
1015  goto add_plain_argument;
1016  }
1017  was_dashed= 0;
1018  ret= Xorriso_normalize_command(xorriso, original_cmd, -1,
1019  cmd_data, cmd_data_size, &cmd, 0);
1020  if(ret<0)
1021  goto eval_any_problems;
1022  was_dashed= ret;
1023 
1024  (*idx)++;
1025  if((*idx)<argc)
1026  arg1= argv[(*idx)];
1027  else
1028  arg1= "";
1029  if((*idx)+1<argc)
1030  arg2= argv[(*idx)+1];
1031  else
1032  arg2= "";
1033  if((*idx) + 2 < argc)
1034  arg3= argv[(*idx) + 2];
1035  else
1036  arg3= "";
1037 
1038  ret= 1;
1039  if(cmd[0]=='#' || cmd[0]==0) {
1040  /* ignore comment line and empty option */;
1041 
1042  } else if(strcmp(cmd,"abort_on")==0) {
1043  (*idx)++;
1044  ret= Xorriso_option_abort_on(xorriso, arg1, 0);
1045 
1046  } else if(strcmp(cmd,"abstract_file")==0) {
1047  (*idx)++;
1048  Xorriso_option_abstract_file(xorriso, arg1, 0);
1049 
1050  } else if(strcmp(cmd,"acl")==0) {
1051  (*idx)++;
1052  ret= Xorriso_option_acl(xorriso, arg1, 0);
1053 
1054  } else if(strcmp(cmd,"add")==0) {
1055  ret= Xorriso_option_add(xorriso, argc, argv, idx, 0);
1056 
1057  } else if(strcmp(cmd,"add_plainly")==0) {
1058  (*idx)++;
1059  ret= Xorriso_option_add_plainly(xorriso, arg1, 0);
1060 
1061  } else if(strcmp(cmd,"alter_date")==0 || strcmp(cmd,"alter_date_r")==0) {
1062  (*idx)+= 2;
1063  ret= Xorriso_option_alter_date(xorriso, arg1, arg2, argc, argv, idx,
1064  strlen(cmd)>10);
1065 
1066  } else if(strcmp(cmd,"append_partition")==0) {
1067  (*idx)+= 3;
1068  ret= Xorriso_option_append_partition(xorriso, arg1, arg2, arg3, 0);
1069 
1070  } else if(strcmp(cmd,"application_id")==0) {
1071  (*idx)++;
1072  ret= Xorriso_option_application_id(xorriso, arg1, 0);
1073 
1074  } else if(strcmp(cmd,"application_use") == 0) {
1075  (*idx)++;
1076  ret= Xorriso_option_application_use(xorriso, arg1, 0);
1077 
1078  } else if(strcmp(cmd,"as")==0) {
1079  ret= Xorriso_option_as(xorriso, argc, argv, idx, 0);
1080 
1081  } else if(strcmp(cmd,"assert_volid")==0) {
1082  (*idx)+= 2;
1083  ret= Xorriso_option_assert_volid(xorriso, arg1, arg2, 0);
1084 
1085  } else if(strcmp(cmd,"auto_charset")==0) {
1086  (*idx)++;
1087  ret= Xorriso_option_auto_charset(xorriso, arg1, 0);
1088 
1089  } else if(strcmp(cmd,"backslash_codes")==0) {
1090  (*idx)++;
1091  ret= Xorriso_option_backslash_codes(xorriso, arg1, 0);
1092 
1093  } else if(strcmp(cmd,"ban_stdio_write")==0) {
1094  ret= Xorriso_option_ban_stdio_write(xorriso, 0);
1095 
1096  } else if(strcmp(cmd,"biblio_file")==0) {
1097  (*idx)++;
1098  Xorriso_option_biblio_file(xorriso, arg1, 0);
1099 
1100  } else if(strcmp(cmd,"blank")==0) {
1101  (*idx)++;
1102  ret= Xorriso_option_blank(xorriso, arg1, 0);
1103 
1104  } else if(strcmp(cmd,"boot_image")==0) {
1105  (*idx)+= 2;
1106  ret= Xorriso_option_boot_image(xorriso, arg1, arg2, 0);
1107 
1108  } else if(strcmp(cmd,"calm_drive")==0) {
1109  (*idx)++;
1110  ret= Xorriso_option_calm_drive(xorriso, arg1, 0);
1111 
1112  } else if(strcmp(cmd,"cd")==0 || strcmp(cmd,"cdi")==0) {
1113  (*idx)++;
1114  ret= Xorriso_option_cdi(xorriso, arg1, 0);
1115 
1116  } else if(strcmp(cmd,"cdx")==0) {
1117  (*idx)++;
1118  ret= Xorriso_option_cdx(xorriso, arg1, 0);
1119 
1120  } else if(strcmp(cmd, "changes_pending")==0) {
1121  (*idx)++;
1122  ret= Xorriso_option_changes_pending(xorriso, arg1, 0);
1123 
1124  } else if(strcmp(cmd,"charset")==0) {
1125  (*idx)++;
1126  ret= Xorriso_option_charset(xorriso, arg1, 3);
1127 
1128  } else if(strcmp(cmd,"check_md5")==0) {
1129  ret= Xorriso_option_check_md5(xorriso, argc, argv, idx, 0);
1130 
1131  } else if(strcmp(cmd,"check_md5_r")==0) {
1132  ret= Xorriso_option_check_md5(xorriso, argc, argv, idx, 8);
1133 
1134  } else if(strcmp(cmd,"check_media")==0) {
1135  ret= Xorriso_option_check_media(xorriso, argc, argv, idx, 0);
1136 
1137  } else if(strcmp(cmd,"check_media_defaults")==0) {
1138  ret= Xorriso_option_check_media_defaults(xorriso, argc, argv, idx, 0);
1139 
1140  } else if(strcmp(cmd,"chgrp")==0 || strcmp(cmd,"chgrpi")==0) {
1141  (*idx)+= 1;
1142  ret= Xorriso_option_chgrpi(xorriso, arg1, argc, argv, idx, 0);
1143 
1144  } else if(strcmp(cmd,"chgrp_r")==0 || strcmp(cmd,"chgrp_ri")==0) {
1145  (*idx)+= 1;
1146  ret= Xorriso_option_chgrpi(xorriso, arg1, argc, argv, idx, 1);
1147 
1148  } else if(strcmp(cmd,"chmod")==0 || strcmp(cmd,"chmodi")==0) {
1149  (*idx)+= 1;
1150  ret= Xorriso_option_chmodi(xorriso, arg1, argc, argv, idx, 0);
1151 
1152  } else if(strcmp(cmd,"chmod_r")==0 || strcmp(cmd,"chmod_ri")==0) {
1153  (*idx)+= 1;
1154  ret= Xorriso_option_chmodi(xorriso, arg1, argc, argv, idx, 1);
1155 
1156  } else if(strcmp(cmd,"chown_r")==0 || strcmp(cmd,"chown_ri")==0) {
1157  (*idx)+= 1;
1158  ret= Xorriso_option_chowni(xorriso, arg1, argc, argv, idx, 1);
1159 
1160  } else if(strcmp(cmd,"chown")==0 || strcmp(cmd,"chowni")==0) {
1161  (*idx)+= 1;
1162  ret= Xorriso_option_chowni(xorriso, arg1, argc, argv, idx, 0);
1163 
1164  } else if(strcmp(cmd,"clone")==0) {
1165  (*idx)+= 2;
1166  ret= Xorriso_option_clone(xorriso, arg1, arg2, 1);
1167 
1168  } else if(strcmp(cmd,"close")==0) {
1169  (*idx)++;
1170  ret= Xorriso_option_close(xorriso, arg1, 0);
1171 
1172  } else if(strcmp(cmd,"close_damaged")==0) {
1173  (*idx)++;
1174  ret= Xorriso_option_close_damaged(xorriso, arg1, 0);
1175 
1176  } else if(strcmp(cmd,"close_filter_list")==0) {
1177  ret= Xorriso_option_close_filter_list(xorriso, 0);
1178 
1179  } else if(strcmp(cmd,"commit")==0) {
1180  ret= Xorriso_option_commit(xorriso, 0);
1181 
1182  } else if(strcmp(cmd,"commit_eject")==0) {
1183  (*idx)++;
1184  ret= Xorriso_option_commit_eject(xorriso, arg1, 0);
1185 
1186  } else if(strcmp(cmd,"compare")==0) {
1187  (*idx)+= 2;
1188  ret= Xorriso_option_compare(xorriso, arg1, arg2, 1);
1189 
1190  } else if(strcmp(cmd,"compare_l")==0) {
1191  ret= Xorriso_option_map_l(xorriso, argc, argv, idx, 1<<8);
1192 
1193  } else if(strcmp(cmd,"compare_r")==0) {
1194  (*idx)+= 2;
1195  ret= Xorriso_option_compare(xorriso, arg1, arg2, 1|8);
1196 
1197  } else if(strcmp(cmd,"compliance")==0) {
1198  (*idx)++;
1199  Xorriso_option_compliance(xorriso, arg1, 0);
1200 
1201  } else if(strcmp(cmd,"concat") == 0) {
1202  ret= Xorriso_option_concat(xorriso, argc, argv, idx, 0);
1203 
1204  } else if(strcmp(cmd,"copyright_file")==0) {
1205  (*idx)++;
1206  Xorriso_option_copyright_file(xorriso, arg1, 0);
1207 
1208  } else if(strcmp(cmd,"cp_clone") == 0) {
1209  ret= Xorriso_option_cp_clone(xorriso, argc, argv, idx, 0);
1210 
1211  } else if(strcmp(cmd,"cp_rx")==0 || strcmp(cmd,"cp_rax")==0) {
1212  ret= Xorriso_option_cpx(xorriso, argc, argv, idx,
1213  1|((strcmp(cmd,"cp_rax")==0)<<1));
1214 
1215  } else if(strcmp(cmd,"cpr")==0 || strcmp(cmd,"cpri")==0) {
1216  ret= Xorriso_option_cpri(xorriso, argc, argv, idx, 0);
1217 
1218  } else if(strcmp(cmd,"cpx")==0 || strcmp(cmd,"cpax")==0) {
1219  ret= Xorriso_option_cpx(xorriso, argc, argv, idx,
1220  (strcmp(cmd,"cpax")==0)<<1);
1221 
1222  } else if(strcmp(cmd,"cut_out")==0) {
1223  (*idx)+= 4;
1224  if((*idx)>argc) {
1225  sprintf(xorriso->info_text,
1226  "-cut_out: Not enough arguments. Needed are: disk_path start count so_rr_path");
1227  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
1228  ret= 0;
1229  } else
1230  ret= Xorriso_option_cut_out(xorriso, arg1, arg2,
1231  argv[(*idx)-2], argv[(*idx)-1], 0);
1232 
1233  } else if(strcmp(cmd,"data_cache_size")==0) {
1234  (*idx)+= 2;
1235  ret= Xorriso_option_data_cache_size(xorriso, arg1, arg2, 0);
1236 
1237  } else if(strcmp(cmd,"dev")==0) {
1238  (*idx)++;
1239  ret= Xorriso_option_dev(xorriso, arg1, 3);
1240 
1241  } else if(strcmp(cmd,"device_links")==0) {
1242  ret= Xorriso_option_devices(xorriso, 1);
1243 
1244  } else if(strcmp(cmd,"devices")==0) {
1245  ret= Xorriso_option_devices(xorriso, 0);
1246 
1247  } else if(strcmp(cmd,"dialog")==0) {
1248  (*idx)++;
1249  ret= Xorriso_option_dialog(xorriso, arg1, 0);
1250 
1251  } else if(strcmp(cmd,"disk_dev_ino")==0) {
1252  (*idx)++;
1253  ret= Xorriso_option_disk_dev_ino(xorriso, arg1, 0);
1254 
1255  } else if(strcmp(cmd,"displacement")==0) {
1256  (*idx)++;
1257  ret= Xorriso_option_displacement(xorriso, arg1, 0);
1258 
1259  } else if(strcmp(cmd,"disk_pattern")==0) {
1260  (*idx)++;
1261  ret= Xorriso_option_disk_pattern(xorriso, arg1, 0);
1262 
1263  } else if(strcmp(cmd,"drive_access")==0) {
1264  (*idx)++;
1265  ret= Xorriso_option_drive_access(xorriso, arg1, 0);
1266 
1267  } else if(strcmp(cmd,"drive_class")==0) {
1268  (*idx)+= 2;
1269  ret= Xorriso_option_drive_class(xorriso, arg1, arg2, 0);
1270 
1271  } else if(strcmp(cmd,"du")==0 || strcmp(cmd,"dui")==0 ||
1272  strcmp(cmd,"dus")==0 || strcmp(cmd,"dusi")==0) {
1273  ret= Xorriso_option_lsi(xorriso, argc, argv, idx, (cmd[2]!='s')|4);
1274 
1275  } else if(strcmp(cmd,"dummy")==0) {
1276  (*idx)++;
1277  ret= Xorriso_option_dummy(xorriso, arg1, 0);
1278 
1279  } else if(strcmp(cmd,"dvd_obs")==0) {
1280  (*idx)++;
1281  ret= Xorriso_option_dvd_obs(xorriso, arg1, 0);
1282 
1283  } else if(strcmp(cmd,"dux")==0 || strcmp(cmd,"dusx")==0) {
1284  ret= Xorriso_option_lsx(xorriso, argc, argv, idx, (cmd[2]!='s')|4);
1285 
1286  } else if(strcmp(cmd,"early_stdio_test")==0) {
1287  (*idx)++;
1288  ret= Xorriso_option_early_stdio_test(xorriso, arg1, 0);
1289 
1290  } else if(strcmp(cmd,"ecma119_map")==0) {
1291  (*idx)++;
1292  ret= Xorriso_option_ecma119_map(xorriso, arg1, 0);
1293 
1294  } else if(strcmp(cmd,"eject")==0) {
1295  (*idx)++;
1296  ret= Xorriso_option_eject(xorriso, arg1, 0);
1297 
1298  } else if(strcmp(cmd,"end")==0) {
1299  end_ret= Xorriso_option_end(xorriso, 0);
1300  ret= Xorriso_eval_problem_status(xorriso, ret, 0);
1301  if(ret<0)
1302  goto ex;
1303  if(end_ret!=2)
1304  {ret= 3; goto ex;}
1305 
1306  } else if(strcmp(cmd,"errfile_log")==0) {
1307  (*idx)+= 2;
1308  ret= Xorriso_option_errfile_log(xorriso, arg1, arg2, 0);
1309 
1310  } else if(strcmp(cmd,"error_behavior")==0) {
1311  (*idx)+= 2;
1312  ret= Xorriso_option_error_behavior(xorriso, arg1, arg2, 0);
1313 
1314  } else if(strcmp(cmd,"external_filter")==0) {
1315  ret= Xorriso_option_external_filter(xorriso, argc, argv, idx, 0);
1316 
1317  } else if(strcmp(cmd,"extract")==0) {
1318  (*idx)+= 2;
1319  ret= Xorriso_option_extract(xorriso, arg1, arg2, 0);
1320 
1321  } else if(strcmp(cmd,"extract_boot_images")==0) {
1322  (*idx)+= 1;
1323  if((*idx)>argc) {
1324  sprintf(xorriso->info_text,
1325  "-extract_boot_images: Empty disk_path cannot be used as target directory");
1326  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
1327  ret= 0;
1328  } else {
1329  ret= Xorriso_option_extract_boot_images(xorriso, arg1, 0);
1330  }
1331 
1332  } else if(strcmp(cmd,"extract_cut")==0) {
1333  (*idx)+= 4;
1334  if((*idx)>argc) {
1335  sprintf(xorriso->info_text,
1336  "-extract_cut: Not enough arguments. Needed are: disk_path start count iso_rr_path");
1337  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
1338  ret= 0;
1339  } else
1340  ret= Xorriso_option_extract_cut(xorriso, arg1, arg2,
1341  argv[(*idx)-2], argv[(*idx)-1], 0);
1342 
1343  } else if(strcmp(cmd,"extract_l")==0) {
1344  ret= Xorriso_option_map_l(xorriso, argc, argv, idx, 3<<8);
1345 
1346  } else if(strcmp(cmd,"extract_single")==0) {
1347  (*idx)+= 2;
1348  ret= Xorriso_option_extract(xorriso, arg1, arg2, 32);
1349 
1350  } else if(strcmp(cmd,"file_name_limit")==0) {
1351  (*idx)++;
1352  ret= Xorriso_option_file_name_limit(xorriso, arg1, 0);
1353 
1354  } else if(strcmp(cmd,"file_size_limit")==0) {
1355  ret= Xorriso_option_file_size_limit(xorriso, argc, argv, idx, 0);
1356 
1357  } else if(strcmp(cmd,"find")==0 || strcmp(cmd,"findi")==0) {
1358  ret= Xorriso_option_find(xorriso, argc, argv, idx, 0);
1359 
1360  } else if(strcmp(cmd,"findx")==0) {
1361  ret= Xorriso_option_find(xorriso, argc, argv, idx, 1);
1362 
1363  } else if(strcmp(cmd,"follow")==0) {
1364  (*idx)++;
1365  ret= Xorriso_option_follow(xorriso, arg1, 0);
1366 
1367  } else if(strcmp(cmd,"for_backup")==0) {
1368  Xorriso_option_hardlinks(xorriso, "on", 0);
1369  Xorriso_option_acl(xorriso, "on", 0);
1370  Xorriso_option_xattr(xorriso, "any", 0);
1371  Xorriso_option_md5(xorriso, "on", 0);
1372  ret= 1;
1373 
1374  } else if(strcmp(cmd,"format")==0) {
1375  (*idx)++;
1376  ret= Xorriso_option_blank(xorriso, arg1, 1);
1377 
1378  } else if(strcmp(cmd,"fs")==0) {
1379  (*idx)++;
1380  ret= Xorriso_option_fs(xorriso, arg1, 0);
1381 
1382  } else if(strcmp(cmd,"getfacl")==0 || strcmp(cmd,"getfacli")==0) {
1383  ret= Xorriso_option_getfacli(xorriso, argc, argv, idx, 0);
1384 
1385  } else if(strcmp(cmd,"getfacl_r")==0 || strcmp(cmd,"getfacl_ri")==0) {
1386  ret= Xorriso_option_getfacli(xorriso, argc, argv, idx, 1);
1387 
1388  } else if(strcmp(cmd,"getfattr")==0 || strcmp(cmd,"getfattri")==0) {
1389  ret= Xorriso_option_getfacli(xorriso, argc, argv, idx, 2);
1390 
1391  } else if(strcmp(cmd,"getfattr_r")==0 || strcmp(cmd,"getfattr_ri")==0) {
1392  ret= Xorriso_option_getfacli(xorriso, argc, argv, idx, 1 | 2);
1393 
1394  } else if(strcmp(cmd,"gid")==0) {
1395  (*idx)++;
1396  ret= Xorriso_option_gid(xorriso,arg1,0);
1397 
1398  } else if(strcmp(cmd,"grow_blindly")==0) {
1399  (*idx)++;
1400  ret= Xorriso_option_grow_blindly(xorriso,arg1,0);
1401 
1402  } else if(strcmp(cmd,"hardlinks")==0) {
1403  (*idx)++;
1404  ret= Xorriso_option_hardlinks(xorriso, arg1, 0);
1405 
1406  } else if(strcmp(cmd,"hfsplus")==0) {
1407  (*idx)++;
1408  ret= Xorriso_option_hfsplus(xorriso, arg1, 0);
1409 
1410  } else if(strcmp(cmd,"help")==0) {
1411  Xorriso_option_help(xorriso,0);
1412 
1413  } else if(strcmp(cmd,"hide")==0) {
1414  (*idx)+= 1;
1415  ret= Xorriso_option_hide(xorriso, arg1, argc, argv, idx, 1);
1416 
1417  } else if(strcmp(cmd,"history")==0) {
1418  /* add to readline history */
1419  (*idx)++;
1420  ret= Xorriso_option_history(xorriso, arg1, 0);
1421 
1422  } else if(strcmp(cmd,"indev")==0) {
1423  (*idx)++;
1424  ret= Xorriso_option_dev(xorriso, arg1, 1);
1425 
1426  } else if(strcmp(cmd,"in_charset")==0) {
1427  (*idx)++;
1428  ret= Xorriso_option_charset(xorriso, arg1, 1);
1429 
1430  } else if(strcmp(cmd,"iso_nowtime")==0) {
1431  (*idx)++;
1432  ret= Xorriso_option_iso_nowtime(xorriso, arg1, 0);
1433 
1434  } else if(strcmp(cmd,"iso_rr_pattern")==0) {
1435  (*idx)++;
1436  ret= Xorriso_option_iso_rr_pattern(xorriso, arg1, 0);
1437 
1438  } else if(strcmp(cmd,"jigdo")==0) {
1439  (*idx)+= 2;
1440  ret= Xorriso_option_jigdo(xorriso, arg1, arg2, 0);
1441 
1442  } else if(strcmp(cmd,"joliet")==0) {
1443  (*idx)++;
1444  ret= Xorriso_option_joliet(xorriso, arg1, 0);
1445 
1446  } else if(strcmp(cmd,"joliet_map")==0) {
1447  (*idx)++;
1448  ret= Xorriso_option_joliet_map(xorriso, arg1, 0);
1449 
1450  } else if(strcmp(cmd, "launch_frontend") == 0) {
1451  ret= Xorriso_option_launch_frontend(xorriso, argc, argv, idx, 0);
1452 
1453  } else if(strcmp(cmd, "list_arg_sorting") == 0) {
1454  ret= Xorriso_option_list_arg_sorting(xorriso, 0);
1455 
1456  } else if(strcmp(cmd, "list_delimiter") == 0) {
1457  (*idx)++;
1458  ret= Xorriso_option_list_delimiter(xorriso, arg1, 0);
1459 
1460  } else if(strcmp(cmd, "list_extras") == 0) {
1461  (*idx)++;
1462  ret= Xorriso_option_list_extras(xorriso, arg1, 0);
1463 
1464  } else if(strcmp(cmd,"list_formats")==0) {
1465  ret= Xorriso_option_list_formats(xorriso, 0);
1466 
1467  } else if(strcmp(cmd,"list_profiles")==0) {
1468  (*idx)++;
1469  ret= Xorriso_option_list_profiles(xorriso, arg1, 0);
1470 
1471  } else if(strcmp(cmd,"list_speeds")==0) {
1472  ret= Xorriso_option_list_speeds(xorriso, 0);
1473 
1474  } else if(strcmp(cmd, "lns") == 0 || strcmp(cmd, "lnsi") == 0) {
1475  (*idx)+= 2;
1476  ret= Xorriso_option_lnsi(xorriso, arg1, arg2, 0);
1477 
1478  } else if(strcmp(cmd,"load")==0) {
1479  (*idx)+= 2;
1480  ret= Xorriso_option_load(xorriso, arg1, arg2, 0);
1481 
1482  } else if(strcmp(cmd,"local_charset")==0) {
1483  (*idx)++;
1484  ret= Xorriso_option_charset(xorriso, arg1, 4);
1485 
1486  } else if(strcmp(cmd,"logfile")==0) {
1487  (*idx)+= 2;
1488  ret= Xorriso_option_logfile(xorriso, arg1, arg2, 0);
1489 
1490  } else if(strcmp(cmd,"ls")==0 || strcmp(cmd,"lsi")==0 ||
1491  strcmp(cmd,"lsl")==0 || strcmp(cmd,"lsli")==0) {
1492  ret= Xorriso_option_lsi(xorriso, argc, argv, idx, (cmd[2]=='l'));
1493 
1494  } else if(strcmp(cmd,"lsd")==0 || strcmp(cmd,"lsdi")==0 ||
1495  strcmp(cmd,"lsdl")==0 || strcmp(cmd,"lsdli")==0) {
1496  ret= Xorriso_option_lsi(xorriso, argc, argv, idx, (cmd[3]=='l')|8);
1497 
1498  } else if(strcmp(cmd,"lsdx")==0 || strcmp(cmd,"lsdlx")==0) {
1499  ret= Xorriso_option_lsx(xorriso, argc, argv, idx, (cmd[3]=='l')|8);
1500 
1501  } else if(strcmp(cmd,"lsx")==0 || strcmp(cmd,"lslx")==0) {
1502  ret= Xorriso_option_lsx(xorriso, argc, argv, idx, (cmd[2]=='l'));
1503 
1504  } else if(strcmp(cmd,"map")==0) {
1505  (*idx)+= 2;
1506  ret= Xorriso_option_map(xorriso, arg1, arg2, 0);
1507 
1508  } else if(strcmp(cmd,"map_l")==0) {
1509  ret= Xorriso_option_map_l(xorriso, argc, argv, idx, 0);
1510 
1511  } else if(strcmp(cmd,"map_single")==0) {
1512  (*idx)+= 2;
1513  ret= Xorriso_option_map(xorriso, arg1, arg2, 32);
1514 
1515  } else if(strcmp(cmd,"mark")==0) {
1516  (*idx)++;
1517  ret= Xorriso_option_mark(xorriso, arg1, 0);
1518 
1519  } else if(strcmp(cmd, "md5")==0) {
1520  (*idx)++;
1521  ret= Xorriso_option_md5(xorriso, arg1, 0);
1522 
1523  } else if(strcmp(cmd,"mkdir")==0 || strcmp(cmd,"mkdiri")==0) {
1524  ret= Xorriso_option_mkdiri(xorriso, argc, argv, idx, 0);
1525 
1526  } else if(strcmp(cmd, "modesty_on_drive")==0) {
1527  (*idx)++;
1528  ret= Xorriso_option_modesty_on_drive(xorriso, arg1, 0);
1529 
1530  } else if(strcmp(cmd, "mount") == 0 || strcmp(cmd, "mount_cmd") == 0) {
1531  (*idx)+= 4;
1532  if((*idx)>argc) {
1533  sprintf(xorriso->info_text,
1534  "-%s: Not enough arguments. Needed are: device entity id command",
1535  cmd);
1536  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
1537  ret= 0;
1538  } else
1539  ret= Xorriso_option_mount(xorriso, arg1, arg2,
1540  argv[(*idx)-2], argv[(*idx)-1],
1541  (strcmp(cmd, "mount_cmd") == 0));
1542 
1543  } else if(strcmp(cmd, "mount_opts")==0) {
1544  (*idx)++;
1545  ret= Xorriso_option_mount_opts(xorriso, arg1, 0);
1546 
1547  } else if(strcmp(cmd, "move")==0) {
1548  (*idx)+= 2;
1549  ret= Xorriso_option_move(xorriso, arg1, arg2, 0);
1550 
1551  } else if(strcmp(cmd,"msg_op") == 0) {
1552  (*idx)+= 2;
1553  ret= Xorriso_option_msg_op(xorriso, arg1, arg2, 0);
1554 
1555  } else if(strcmp(cmd,"mv")==0 || strcmp(cmd,"mvi")==0) {
1556  ret= Xorriso_option_mvi(xorriso, argc, argv, idx, 0);
1557 
1558  } else if(strcmp(cmd,"named_pipe_loop")==0) {
1559  if((*idx) + 3 < argc)
1560  arg4= argv[(*idx) + 3];
1561  else
1562  arg4= "";
1563  (*idx)+= 4;
1564  ret= Xorriso_option_named_pipe_loop(xorriso, arg1, arg2, arg3, arg4, 0);
1565  if(ret == 3)
1566  goto ex;
1567 
1568  } else if(strcmp(cmd,"no_rc")==0) {
1569  ret= Xorriso_option_no_rc(xorriso, 0);
1570 
1571  } else if(strcmp(cmd,"not_leaf")==0) {
1572  (*idx)++;
1573  ret= Xorriso_option_not_leaf(xorriso, arg1, 0);
1574 
1575  } else if(strcmp(cmd,"not_list")==0) {
1576  (*idx)++;
1577  ret= Xorriso_option_not_list(xorriso, arg1, 0);
1578 
1579  } else if(strcmp(cmd,"not_mgt")==0) {
1580  (*idx)++;
1581  ret= Xorriso_option_not_mgt(xorriso, arg1, 0);
1582 
1583  } else if(strcmp(cmd,"not_paths")==0) {
1584  ret= Xorriso_option_not_paths(xorriso, argc, argv, idx, 0);
1585 
1586  } else if(strcmp(cmd,"options_from_file")==0) {
1587  (*idx)++;
1588  ret= Xorriso_option_options_from_file(xorriso,arg1,0);
1589  if(ret==3)
1590  goto ex;
1591 
1592  } else if(strcmp(cmd,"osirrox")==0) {
1593  (*idx)++;
1594  ret= Xorriso_option_osirrox(xorriso,arg1,0);
1595 
1596  } else if(strcmp(cmd,"outdev")==0) {
1597  (*idx)++;
1598  ret= Xorriso_option_dev(xorriso, arg1, 2);
1599 
1600  } else if(strcmp(cmd,"out_charset")==0) {
1601  (*idx)++;
1602  ret= Xorriso_option_charset(xorriso, arg1, 2);
1603 
1604  } else if(strcmp(cmd,"overwrite")==0) {
1605  (*idx)++;
1606  ret= Xorriso_option_overwrite(xorriso,arg1,0);
1607 
1608  } else if(strcmp(cmd,"pacifier")==0) {
1609  (*idx)++;
1610  ret= Xorriso_option_pacifier(xorriso, arg1, 0);
1611 
1612  } else if(strcmp(cmd,"padding")==0) {
1613  (*idx)++;
1614  ret= Xorriso_option_padding(xorriso, arg1, 0);
1615 
1616  } else if(strcmp(cmd,"page")==0) {
1617  (*idx)+= 2;
1618  num1= num2= 0;
1619  sscanf(arg1,"%d",&num1);
1620  sscanf(arg2,"%d",&num2);
1621  if(num1<0)
1622  num1= 0;
1623  if(arg1[0]==0)
1624  num1= 16;
1625  if(num2<=0)
1626  num2= 80;
1627  ret= Xorriso_option_page(xorriso, num1, num2, 0);
1628 
1629  } else if(strcmp(cmd,"paste_in")==0) {
1630  (*idx)+= 4;
1631  if((*idx)>argc) {
1632  sprintf(xorriso->info_text,
1633  "-paste_in: Not enough arguments. Needed are: disk_path start count so_rr_path");
1634  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
1635  ret= 0;
1636  } else
1637  ret= Xorriso_option_paste_in(xorriso, arg1, arg2,
1638  argv[(*idx)-2], argv[(*idx)-1], 0);
1639 
1640  } else if(strcmp(cmd,"path-list")==0 || strcmp(cmd,"path_list")==0) {
1641  (*idx)++;
1642  ret= Xorriso_option_path_list(xorriso, arg1, 0);
1643 
1644  } else if(strcmp(cmd,"pathspecs")==0) {
1645  (*idx)++;
1646  ret= Xorriso_option_pathspecs(xorriso, arg1, 0);
1647 
1648  } else if(strcmp(cmd,"pkt_output")==0) {
1649  (*idx)++;
1650  ret= Xorriso_option_pkt_output(xorriso, arg1, 0);
1651 
1652  } else if(strcmp(cmd,"preparer_id")==0) {
1653  (*idx)++;
1654  ret= Xorriso_option_preparer_id(xorriso, arg1, 0);
1655 
1656  } else if(strcmp(cmd,"print")==0) {
1657  (*idx)++;
1658  ret= Xorriso_option_print(xorriso, arg1, 0);
1659 
1660  } else if(strcmp(cmd,"print_info")==0) {
1661  (*idx)++;
1662  ret= Xorriso_option_print(xorriso, arg1, 1);
1663 
1664  } else if(strcmp(cmd,"print_mark")==0) {
1665  (*idx)++;
1666  ret= Xorriso_option_print(xorriso, arg1, 2);
1667 
1668  } else if(strcmp(cmd,"print_size")==0) {
1669  Xorriso_option_print_size(xorriso, 0);
1670 
1671  } else if(strcmp(cmd,"prompt")==0) {
1672  (*idx)++;
1673  ret= Xorriso_option_prompt(xorriso, arg1, 0);
1674 
1675  } else if(strcmp(cmd,"prog")==0) {
1676  (*idx)++;
1677  ret= Xorriso_option_prog(xorriso, arg1, 0);
1678 
1679  } else if(strcmp(cmd,"publisher")==0) {
1680  (*idx)++;
1681  Xorriso_option_publisher(xorriso, arg1, 0);
1682 
1683  } else if(strcmp(cmd,"pvd_info")==0) {
1684  Xorriso_option_pvd_info(xorriso, 0);
1685 
1686  } else if(strcmp(cmd,"pwd")==0 || strcmp(cmd,"pwdi")==0) {
1687  Xorriso_option_pwdi(xorriso, 0);
1688 
1689  } else if(strcmp(cmd,"pwdx")==0) {
1690  Xorriso_option_pwdx(xorriso, 0);
1691 
1692  } else if(strcmp(cmd,"quoted_not_list")==0) {
1693  (*idx)++;
1694  ret= Xorriso_option_not_list(xorriso, arg1, 1);
1695 
1696  } else if(strcmp(cmd,"quoted_path_list")==0) {
1697  (*idx)++;
1698  ret= Xorriso_option_path_list(xorriso, arg1, 1);
1699 
1700  } else if(strcmp(cmd,"read_fs")==0) {
1701  (*idx)++;
1702  ret= Xorriso_option_read_fs(xorriso, arg1, 0);
1703 
1704  } else if(strcmp(cmd,"read_mkisofsrc")==0) {
1705  ret= Xorriso_option_read_mkisofsrc(xorriso, 0);
1706 
1707  } else if(strcmp(cmd,"read_speed")==0) {
1708  (*idx)++;
1709  ret= Xorriso_option_speed(xorriso, arg1, 1);
1710 
1711  } else if(strcmp(cmd,"reassure")==0) {
1712  (*idx)++;
1713  ret= Xorriso_option_reassure(xorriso, arg1, 0);
1714 
1715  } else if(strcmp(cmd,"report_about")==0) {
1716  (*idx)++;
1717  ret= Xorriso_option_report_about(xorriso, arg1, 0);
1718 
1719  } else if(strcmp(cmd,"report_el_torito")==0) {
1720  (*idx)++;
1721  ret= Xorriso_option_report_el_torito(xorriso, arg1, 0);
1722 
1723  } else if(strcmp(cmd,"report_system_area")==0) {
1724  (*idx)++;
1725  ret= Xorriso_option_report_system_area(xorriso, arg1, 0);
1726 
1727  } else if(strcmp(cmd,"return_with")==0) {
1728  (*idx)+= 2;
1729  num2= 0;
1730  sscanf(arg2,"%d",&num2);
1731  ret= Xorriso_option_return_with(xorriso, arg1, num2, 0);
1732 
1733  } else if(strcmp(cmd,"rm")==0 || strcmp(cmd,"rmi")==0) {
1734  ret= Xorriso_option_rmi(xorriso, argc, argv, idx, 0);
1735 
1736  } else if(strcmp(cmd,"rm_r")==0 || strcmp(cmd,"rm_ri")==0) {
1737  ret= Xorriso_option_rmi(xorriso, argc, argv, idx, 1);
1738 
1739  } else if(strcmp(cmd,"rmdir")==0 || strcmp(cmd,"rmdiri")==0) {
1740  ret= Xorriso_option_rmi(xorriso, argc, argv, idx, 2);
1741 
1742  } else if(strcmp(cmd, "rockridge") == 0) {
1743  (*idx)++;
1744  ret= Xorriso_option_rockridge(xorriso, arg1, 0);
1745 
1746  } else if(strcmp(cmd,"rollback")==0) {
1747  ret= Xorriso_option_rollback(xorriso, 0);
1748 
1749  } else if(strcmp(cmd,"rollback_end")==0) {
1750  end_ret= Xorriso_option_end(xorriso, 1);
1751  ret= Xorriso_eval_problem_status(xorriso, ret, 0);
1752  if(ret<0)
1753  goto ex;
1754  if(end_ret!=2)
1755  {ret= 3; goto ex;}
1756 
1757  } else if(strcmp(cmd,"rom_toc_scan")==0) {
1758  (*idx)++;
1759  Xorriso_option_rom_toc_scan(xorriso, arg1, 0);
1760 
1761  } else if(strcmp(cmd,"rr_reloc_dir")==0) {
1762  (*idx)++;
1763  Xorriso_option_rr_reloc_dir(xorriso, arg1, 0);
1764 
1765  } else if(strcmp(cmd,"scdbackup_tag")==0) {
1766  (*idx)+= 2;
1767  ret= Xorriso_option_scdbackup_tag(xorriso, arg1, arg2, 0);
1768 
1769  } else if(strcmp(cmd, "scsi_dev_family") == 0) {
1770  (*idx)++;
1771  ret= Xorriso_option_scsi_dev_family(xorriso, arg1, 0);
1772 
1773  } else if(strcmp(cmd, "scsi_log") == 0) {
1774  (*idx)++;
1775  ret= Xorriso_option_scsi_log(xorriso, arg1, 0);
1776 
1777  } else if(strcmp(cmd,"session_log")==0) {
1778  (*idx)++;
1779  ret= Xorriso_option_session_log(xorriso, arg1, 0);
1780 
1781  } else if(strcmp(cmd, "session_string") == 0) {
1782  (*idx)+= 4;
1783  if((*idx)>argc) {
1784  sprintf(xorriso->info_text,
1785  "-%s: Not enough arguments. Needed are: device entity id command",
1786  cmd);
1787  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
1788  ret= 0;
1789  } else
1790  ret= Xorriso_option_mount(xorriso, arg1, arg2,
1791  argv[(*idx)-2], argv[(*idx)-1], 2);
1792 
1793  } else if(strcmp(cmd,"setfacl")==0 || strcmp(cmd,"setfacli")==0) {
1794  (*idx)+= 1;
1795  ret= Xorriso_option_setfacli(xorriso, arg1, argc, argv, idx, 0);
1796 
1797  } else if(strcmp(cmd,"setfacl_list")==0 || strcmp(cmd,"setfacl_listi")==0) {
1798  (*idx)+= 1;
1799  ret= Xorriso_option_setfacl_listi(xorriso, arg1, 0);
1800 
1801  } else if(strcmp(cmd,"setfacl_r")==0 || strcmp(cmd,"setfacl_ri")==0) {
1802  (*idx)+= 1;
1803  ret= Xorriso_option_setfacli(xorriso, arg1, argc, argv, idx, 1);
1804 
1805  } else if(strcmp(cmd,"setfattr")==0 || strcmp(cmd,"setfattri")==0) {
1806  (*idx)+= 2;
1807  ret= Xorriso_option_setfattri(xorriso, arg1, arg2, argc, argv, idx, 0);
1808 
1809  } else if(strcmp(cmd,"setfattr_list")==0 || strcmp(cmd,"setfattr_listi")==0) {
1810  (*idx)+= 1;
1811  ret= Xorriso_option_setfattr_listi(xorriso, arg1, 0);
1812 
1813  } else if(strcmp(cmd,"setfattr_r")==0 || strcmp(cmd,"setfattr_ri")==0) {
1814  (*idx)+= 2;
1815  ret= Xorriso_option_setfattri(xorriso, arg1, arg2, argc, argv, idx, 1);
1816 
1817  } else if(strcmp(cmd,"set_filter")==0 || strcmp(cmd,"set_filter_r")==0) {
1818  (*idx)+= 1;
1819  ret= Xorriso_option_set_filter(xorriso, arg1, argc, argv, idx,
1820  strcmp(cmd,"set_filter_r")==0);
1821 
1822  } else if(strcmp(cmd,"show_stream")==0 || strcmp(cmd,"show_stream_r")==0) {
1823  ret= Xorriso_option_set_filter(xorriso, "", argc, argv, idx,
1824  (strcmp(cmd,"show_stream_r")==0) | 2 | 4);
1825 
1826  } else if(strcmp(cmd,"sh_style_result")==0) {
1827  (*idx)++;
1828  ret= Xorriso_option_sh_style_result(xorriso, arg1, 0);
1829 
1830  } else if(strcmp(cmd,"signal_handling")==0) {
1831  (*idx)++;
1832  ret= Xorriso_option_signal_handling(xorriso, arg1, 0);
1833 
1834  } else if(strcmp(cmd,"sleep")==0) {
1835  (*idx)++;
1836  ret= Xorriso_option_sleep(xorriso, arg1, 0);
1837 
1838  } else if(strcmp(cmd,"speed")==0) {
1839  (*idx)++;
1840  ret= Xorriso_option_speed(xorriso, arg1, 0);
1841 
1842  } else if(strcmp(cmd,"split_size")==0) {
1843  (*idx)++;
1844  ret= Xorriso_option_split_size(xorriso, arg1, 0);
1845 
1846  } else if(strcmp(cmd,"status")==0) {
1847  (*idx)++;
1848  ret= Xorriso_option_status(xorriso, arg1, 0);
1849 
1850  } else if(strcmp(cmd,"status_history_max")==0) {
1851  (*idx)++;
1852  sscanf(arg1,"%d",&num1);
1853  ret= Xorriso_option_status_history_max(xorriso, num1, 0);
1854 
1855  } else if(strcmp(cmd,"stdio_sync")==0) {
1856  (*idx)++;
1857  ret= Xorriso_option_stdio_sync(xorriso, arg1, 0);
1858 
1859  } else if(strcmp(cmd,"stream_recording")==0) {
1860  (*idx)++;
1861  ret= Xorriso_option_stream_recording(xorriso, arg1, 0);
1862 
1863  } else if(strcmp(cmd,"system_id")==0) {
1864  (*idx)++;
1865  ret= Xorriso_option_system_id(xorriso, arg1, 0);
1866 
1867  } else if(strcmp(cmd,"tell_media_space")==0) {
1868  Xorriso_option_tell_media_space(xorriso, 0);
1869 
1870  } else if(strcmp(cmd,"temp_mem_limit")==0) {
1871  (*idx)++;
1872  ret= Xorriso_option_temp_mem_limit(xorriso, arg1, 0);
1873 
1874  } else if(strcmp(cmd,"test")==0) { /* This option does not exist. */
1875  /* install temporary test code here */;
1876 
1877 if (0) {
1878 /* Test setup for for Xorriso_push_outlists() et.al. */
1879 /* Test setup for Xorriso_parse_line */
1880  int stack_handle = -1, line_count= 0;
1881  struct Xorriso_lsT *result_list, *info_list;
1882  int Xorriso_process_msg_lists(struct XorrisO *xorriso,
1883  struct Xorriso_lsT *result_list,
1884  struct Xorriso_lsT *info_list,
1885  int *line_count, int flag);
1886 
1887  (*idx)++;
1888  if(strcmp(arg1, "push") == 0) {
1889  ret= Xorriso_push_outlists(xorriso, &stack_handle, 3);
1890  fprintf(stderr, "xorriso -test: push = %d, handle = %d\n",
1891  ret, stack_handle);
1892  } else if(strcmp(arg1, "pull") == 0) {
1893  ret= Xorriso_pull_outlists(xorriso, -1, &result_list, &info_list, 0);
1894  fprintf(stderr, "xorriso -test: pull = %d\n", ret);
1895  if(ret > 0) {
1896  ret= Xorriso_process_msg_lists(xorriso, result_list, info_list,
1897  &line_count, 0);
1898  fprintf(stderr,
1899  "xorriso -test: Xorriso_process_msg_lists() = %d, line_count = %d\n",
1900  ret, line_count);
1901  }
1902  } else if(strcmp(arg1, "fetch") == 0) {
1903  ret= Xorriso_fetch_outlists(xorriso, -1, &result_list, &info_list, 0);
1904  fprintf(stderr, "xorriso -test: fetch = %d\n", ret);
1905  if(ret > 0) {
1906  ret= Xorriso_process_msg_lists(xorriso, result_list, info_list,
1907  &line_count, 0);
1908  fprintf(stderr,
1909  "xorriso -test: Xorriso_process_msg_lists() = %d, line_count = %d\n",
1910  ret, line_count);
1911  }
1912  } else if(strcmp(arg1, "peek") == 0) {
1913  ret= Xorriso_peek_outlists(xorriso, -1, 0, 0);
1914  fprintf(stderr, "xorriso -test: peek = %d\n", ret);
1915  } else if(strcmp(arg1, "sleep_peek") == 0) {
1916  usleep(1000000);
1917  ret= Xorriso_peek_outlists(xorriso, -1, 0, 0);
1918  fprintf(stderr, "xorriso -test: sleep_peek = %d\n", ret);
1919  } else if(strcmp(arg1, "peek_loop") == 0) {
1920  ret= Xorriso_peek_outlists(xorriso, -1, 3, 4);
1921  fprintf(stderr, "xorriso -test: peek_loop = %d\n", ret);
1922  } else if(strcmp(arg1, "start") == 0) {
1923  ret= Xorriso_start_msg_watcher(xorriso, NULL, NULL, NULL, NULL, 0);
1924  fprintf(stderr, "xorriso -test: Xorriso_start_msg_watcher() = %d\n", ret);
1925  } else if(strcmp(arg1, "stop") == 0) {
1926  ret= Xorriso_stop_msg_watcher(xorriso, 0);
1927  fprintf(stderr, "xorriso -test: Xorriso_stop_msg_watcher() = %d\n", ret);
1928 
1929  } else if(strcmp(arg1, "help") == 0) {
1930  fprintf(stderr, "-test [mode] [arguments]\n");
1931  fprintf(stderr, " push\n");
1932  fprintf(stderr, " perform Xorriso_push_outlists()\n");
1933  fprintf(stderr, " pull\n");
1934  fprintf(stderr, " perform Xorriso_pull_outlists() and show messages\n");
1935  fprintf(stderr, " fetch\n");
1936  fprintf(stderr, " perform Xorriso_fetch_outlists() and show\n");
1937  fprintf(stderr, " peek\n");
1938  fprintf(stderr, " perform Xorriso_peek_outlists()\n");
1939  fprintf(stderr, " sleep_peek\n");
1940  fprintf(stderr, " sleep 1 s and perform Xorriso_peek_outlists()\n");
1941  fprintf(stderr, " peek_loop\n");
1942  fprintf(stderr, " wait for up to 3s in Xorriso_peek_outlists()\n");
1943  fprintf(stderr, " for return value 0 or -1\n");
1944  fprintf(stderr, " start\n");
1945  fprintf(stderr, " perform Xorriso_start_msg_watcher()\n");
1946  fprintf(stderr, " stop\n");
1947  fprintf(stderr, " perform Xorriso_stop_msg_watcher()\n");
1948  } else {
1949  fprintf(stderr, "xorriso -test: unknown mode: %s\n", arg1);
1950  }
1951  ret= 0;
1952 }
1953 
1954  } else if(strcmp(cmd,"toc")==0) {
1955  Xorriso_option_toc(xorriso, 0);
1956 
1957  } else if(strcmp(cmd,"toc_of")==0) {
1958  (*idx)++;
1959  Xorriso_option_toc_of(xorriso, arg1, 0);
1960 
1961  } else if(strcmp(cmd,"truncate_overwritable")==0) {
1962  (*idx)+= 3;
1963  ret= Xorriso_option_truncate_overwritable(xorriso, arg1, arg2, arg3, 0);
1964 
1965  } else if(strcmp(cmd,"uid")==0) {
1966  (*idx)++;
1967  ret= Xorriso_option_uid(xorriso,arg1,0);
1968 
1969  } else if(strcmp(cmd,"unregister_filter")==0) {
1970  (*idx)++;
1971  ret= Xorriso_option_unregister_filter(xorriso, arg1, 0);
1972 
1973  } else if(strcmp(cmd,"update")==0) {
1974  (*idx)+= 2;
1975  ret= Xorriso_option_update(xorriso, arg1, arg2, 1);
1976 
1977  } else if(strcmp(cmd,"update_l") == 0 || strcmp(cmd,"update_lx") == 0) {
1978  ret= Xorriso_option_map_l(xorriso, argc, argv, idx, 2<<8);
1979 
1980  } else if(strcmp(cmd,"update_li") == 0) {
1981  ret= Xorriso_option_map_l(xorriso, argc, argv, idx, 5 << 8);
1982 
1983  } else if(strcmp(cmd,"update_lxi") == 0) {
1984  ret= Xorriso_option_map_l(xorriso, argc, argv, idx, 4 << 8);
1985 
1986  } else if(strcmp(cmd,"update_r")==0) {
1987  (*idx)+= 2;
1988  ret= Xorriso_option_update(xorriso, arg1, arg2, 1|8);
1989 
1990  } else if(strcmp(cmd,"use_immed_bit")==0) {
1991  (*idx)++;
1992  ret= Xorriso_option_use_immed_bit(xorriso, arg1, 0);
1993 
1994  } else if(strcmp(cmd,"use_readline")==0) {
1995  (*idx)++;
1996  ret= Xorriso_option_use_readline(xorriso, arg1, 0);
1997 
1998  } else if(strcmp(cmd,"version")==0){
1999  ret= Xorriso_option_version(xorriso, 0);
2000 
2001  } else if(strcmp(cmd,"volset_id")==0) {
2002  (*idx)++;
2003  ret= Xorriso_option_volset_id(xorriso, arg1, 0);
2004 
2005  } else if(strcmp(cmd,"volid")==0) {
2006  (*idx)++;
2007  ret= Xorriso_option_volid(xorriso,arg1,0);
2008 
2009  } else if(strcmp(cmd,"volume_date")==0) {
2010  (*idx)+= 2;
2011  ret= Xorriso_option_volume_date(xorriso, arg1, arg2, 0);
2012 
2013  } else if(strcmp(cmd,"write_type")==0) {
2014  (*idx)++;
2015  ret= Xorriso_option_write_type(xorriso, arg1, 0);
2016 
2017  } else if(strcmp(cmd, "x") == 0) {
2018  /* only in effect in Xorriso_prescan_args() */;
2019 
2020  } else if(strcmp(cmd,"xattr")==0) {
2021  (*idx)++;
2022  ret= Xorriso_option_xattr(xorriso, arg1, 0);
2023 
2024  } else if(strcmp(cmd,"zisofs")==0) {
2025  (*idx)++;
2026  ret= Xorriso_option_zisofs(xorriso, arg1, 0);
2027 
2028  } else if(strcmp(cmd, xorriso->list_delimiter)==0){
2029  /* tis ok */;
2030 
2031  } else if(was_dashed) {
2032  if(xorriso->add_plainly>1)
2033  goto add_plain_argument;
2034 unknown_option:;
2035  sprintf(xorriso->info_text, "Not a known command: '%s'\n",
2036  original_cmd);
2037  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
2038  {ret= 0; goto eval_any_problems;}
2039 
2040  } else {
2041  if(xorriso->add_plainly<=0)
2042  goto unknown_option;
2043 add_plain_argument:;
2044  mem_idx= *idx;
2045  (*idx)--;
2046  ret= Xorriso_option_add(xorriso, (*idx)+1, argv, idx, 0);
2047  (*idx)= mem_idx;
2048 
2049  }
2050 
2051 eval_any_problems:
2052  ret= Xorriso_eval_problem_status(xorriso, ret, 0);
2053  if(ret<0)
2054  goto ex;
2055 
2056  if(*idx < argc && !(flag & 4))
2057  goto next_command;
2058 
2059 ex:;
2060  fflush(stdout);
2061  Xorriso_free_meM(cmd_data);
2062  return(ret);
2063 }
2064 
2065 
2066 int Xorriso_parse_line(struct XorrisO *xorriso, char *line,
2067  char *prefix, char *separators, int max_words,
2068  int *argc, char ***argv, int flag)
2069 {
2070  int ret, bsl_mode;
2071  char *to_parse, *progname= "";
2072 
2073  if(xorriso == NULL && (flag & (32 | 64))) {
2074  ret= -2; goto ex;
2075  }
2076 
2077  *argc= 0;
2078  *argv= NULL;
2079 
2080  to_parse= line;
2081  if((flag & 1) || xorriso == NULL)
2082  bsl_mode= (flag >> 1) & 3;
2083  else
2084  bsl_mode= xorriso->bsl_interpretation & 3;
2085  if(prefix[0]) {
2086  if(strncmp(line, prefix, strlen(prefix)) == 0) {
2087  to_parse= line + strlen(prefix);
2088  } else {
2089  ret= 2; goto ex;
2090  }
2091  }
2092 
2093  if(xorriso != NULL)
2094  progname= xorriso->progname;
2095  ret= Sfile_sep_make_argv(progname, to_parse, separators,
2096  max_words, argc, argv,
2097  (!(flag & 32)) | 4 | (bsl_mode << 5));
2098  if(ret < 0) {
2099  if(xorriso != NULL)
2100  Xorriso_msgs_submit(xorriso, 0,
2101  "Severe lack of resources during command line parsing", 0, "FATAL", 0);
2102  ret= -1; goto ex;
2103  }
2104  if(ret == 0) {
2105  if((flag & 64) && xorriso != NULL) {
2106  sprintf(xorriso->info_text, "Incomplete quotation in %s line: %s",
2107  (flag & 32) ? "command" : "parsed", to_parse);
2108  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
2109  }
2110  goto ex;
2111  }
2112  ret= 1;
2113 ex:;
2114  if(ret <= 0)
2115  Sfile_sep_make_argv("", "", "", 0, argc, argv, 2); /* release memory */
2116  return(ret);
2117 }
2118 
2119 
2120 void Xorriso__dispose_words(int *argc, char ***argv)
2121 {
2122  Sfile_make_argv("", "", argc, argv, 2); /* release memory */
2123 }
2124 
2125 
2126 int Xorriso_execute_option(struct XorrisO *xorriso, char *line, int flag)
2127 /*
2128  bit0-bit15 are forwarded to Xorriso_interpreter
2129 
2130  bit16= no pageing of info lines
2131  bit17= print === bar even if xorriso->found<0
2132 */
2133 {
2134  int ret,argc= 0, idx= 1;
2135  char **argv= NULL;
2136  double tdiff;
2137  struct timeval tv;
2138 
2139  gettimeofday(&tv, NULL);
2140  Xorriso_reset_counters(xorriso,0);
2141  xorriso->idle_time= 0.0;
2142  tdiff= tv.tv_sec+(1.e-6*(double) tv.tv_usec);
2143 
2144  ret= Xorriso_parse_line(xorriso, line, "", "", 0, &argc, &argv, 32 | 64);
2145  if(ret <= 0)
2146  goto ex;
2147 
2148  if(argc<2)
2149  {ret= 1; goto ex;}
2150  if(argv[1][0]=='#')
2151  {ret= 1; goto ex;}
2152 
2153  ret= Xorriso_interpreter(xorriso, argc, argv, &idx, flag&0xffff);
2154  if(ret<0)
2155  goto ex;
2156  gettimeofday(&tv, NULL);
2157  tdiff= tv.tv_sec+(1.e-6*(double) tv.tv_usec)-tdiff-xorriso->idle_time;
2158  if(tdiff<0.001)
2159  tdiff= 0.001;
2160  if(xorriso->error_count>0) {
2161  sprintf(xorriso->info_text,
2162  "----------------------------- %7.f errors encountered\n",
2163  xorriso->error_count);
2164  Xorriso_info(xorriso,!(flag&(1<<16)));
2165  }
2166 
2167  /* ??? >>> print elapsed time tdiff ? */;
2168 
2169  if((flag&(1<<17)) && !xorriso->bar_is_fresh) {
2170  sprintf(xorriso->info_text,"============================\n");
2171  Xorriso_info(xorriso,0);
2172  xorriso->bar_is_fresh= 1;
2173  }
2174  Xorriso_reset_counters(xorriso,0);
2175 ex:;
2176  Sfile_make_argv("", "", &argc, &argv, 2); /* release memory */
2177  return(ret);
2178 }
2179 
2180 
2181 int Xorriso_dialog(struct XorrisO *xorriso, int flag)
2182 {
2183  int ret, line_size= 2 * SfileadrL;
2184  char *line= NULL;
2185 
2186  Xorriso_alloc_meM(line, char, line_size);
2187 
2188  if(!xorriso->dialog)
2189  {ret= 1; goto ex;}
2190  if(xorriso->abort_on_is_default)
2191  Xorriso_option_abort_on(xorriso, "NEVER", 0);
2192  xorriso->is_dialog= 1;
2193  while(1) {
2194  if(xorriso->pending_option[0]!=0) {
2195  Xorriso_mark(xorriso,0);
2196  strcpy(line,xorriso->pending_option);
2197  xorriso->pending_option[0]= 0;
2198  } else {
2199  if(!xorriso->bar_is_fresh) {
2200  sprintf(xorriso->info_text,"============================\n");
2201  Xorriso_info(xorriso,0);
2202  xorriso->bar_is_fresh= 1;
2203  }
2204  sprintf(xorriso->info_text,"enter option and arguments :\n");
2205  Xorriso_info(xorriso,0);
2206  Xorriso_mark(xorriso,0);
2207  ret= Xorriso_dialog_input(xorriso,line, line_size, 4);
2208  if(ret<=0)
2209  break;
2210  }
2211  sprintf(xorriso->info_text,
2212  "==============================================================\n");
2213  Xorriso_info(xorriso,0);
2214 
2215  ret= Xorriso_execute_option(xorriso,line,1<<17);
2216  if(ret<0)
2217  goto ex;
2218  if(ret==3)
2219  goto ex;
2220  xorriso->did_something_useful= 1;
2221  xorriso->no_volset_present= 0; /* Re-enable "No ISO image present." */
2222  }
2223  ret= 1;
2224 ex:;
2225  xorriso->is_dialog= 0;
2226  Xorriso_free_meM(line);
2227  return(ret);
2228 }
2229 
2230 
2231 /* @return 1=replaced , 2=not replaced , <=0 = error
2232 */
2233 int Xorriso_replace_arg_by_bsl(struct XorrisO *xorriso, char **arg,
2234  char **argpt, int flag)
2235 {
2236  int ret, eaten, l;
2237 
2238  if(!(xorriso->bsl_interpretation & 16))
2239  return(2);
2240  l= strlen(*argpt);
2241  Xorriso_free_meM(*arg);
2242  Xorriso_alloc_meM(*arg, char, l + 1);
2243  strcpy(*arg, *argpt);
2244  *argpt= *arg;
2245  ret= Sfile_bsl_interpreter(*arg, l, &eaten, 0);
2246 ex:;
2247  return(ret);
2248 }
2249 
2250 
2251 int Xorriso_prescan_args(struct XorrisO *xorriso, int argc, char **argv,
2252  int flag)
2253 /*
2254  bit0= do not interpret argv[1]
2255  bit1= complain about inknown arguments
2256 */
2257 /*
2258  return:
2259  <0 error
2260  0 end program
2261  1 ok, go on
2262 */
2263 {
2264  int i, ret, was_dashed, num2, arg_count;
2265  int advice, mem_add_plainly, error_seen= 0, mem_bsl;
2266  int was_report_about= 0, was_abort_on= 0, was_return_with= 0;
2267  int was_signal_handling= 0, was_scsi_log= 0, cmd_data_size= 5 * SfileadrL;
2268  char *cmd, *original_cmd, *cmd_data= NULL, *arg1, *arg2;
2269  char *arg1_data= NULL, *arg2_data= NULL;
2270  char mem_list_delimiter[81];
2271 
2272  strcpy(mem_list_delimiter, xorriso->list_delimiter);
2273  mem_add_plainly= xorriso->add_plainly;
2274  mem_bsl= xorriso->bsl_interpretation;
2275 
2276  Xorriso_alloc_meM(cmd_data, char, cmd_data_size);
2277 
2278  for(i=1+(flag&1);i<argc;i++) {
2279  original_cmd= cmd= argv[i];
2280  was_dashed= 0;
2281 
2282  was_dashed= Xorriso_normalize_command(xorriso, original_cmd, i,
2283  cmd_data, cmd_data_size, &cmd, 0);
2284  if(was_dashed<0)
2285  {ret= -1; goto ex;}
2286 
2287  arg1= "";
2288  if(i + 1 < argc) {
2289  arg1= argv[i + 1];
2290  ret= Xorriso_replace_arg_by_bsl(xorriso, &arg1_data, &arg1, 0);
2291  if(ret <= 0)
2292  goto ex;
2293  }
2294  arg2= "";
2295  if(i + 2 < argc) {
2296  arg2= argv[i + 2];
2297  ret= Xorriso_replace_arg_by_bsl(xorriso, &arg2_data, &arg2, 0);
2298  if(ret <= 0)
2299  goto ex;
2300  }
2301  if(i>1)
2302  xorriso->did_something_useful= 1;
2303  if(i==1 && argc==2) {
2304  if(strcmp(cmd,"prog_help")==0) {
2305  i++;
2306  Xorriso_option_prog_help(xorriso,arg1,0);
2307  xorriso->did_something_useful= 1;
2308  {ret= 0; goto ex;}
2309  } else if(strcmp(cmd,"help")==0) {
2310  if(xorriso->argument_emulation == 1) {
2311  Xorriso_genisofs_help(xorriso, 0);
2312  } else if(xorriso->argument_emulation == 2) {
2313  Xorriso_cdrskin_help(xorriso, 0);
2314  } else {
2315  Xorriso_option_help(xorriso,0);
2316  }
2317  xorriso->did_something_useful= 1;
2318  {ret= 0; goto ex;}
2319  }
2320  } else if(i==1 && strcmp(cmd,"no_rc")==0) {
2321  ret= Xorriso_option_no_rc(xorriso, 0);
2322  if(ret<=0)
2323  error_seen= 1;
2324  {ret= 1; goto ex;}
2325  } else if(xorriso->argument_emulation == 1) { /* mkisofs emulation */
2326  if(xorriso->dev_fd_1 < 0)
2327  goto protect_stdout;
2328  {ret= 1; goto ex;}
2329 
2330  } else if(xorriso->argument_emulation == 2) { /* cdrecord emulation */
2331  if(xorriso->dev_fd_1 < 0)
2332  if(Xorriso_cdrskin_uses_stdout(xorriso, argc - 1 - (flag & 1),
2333  argv + 1 + (flag & 1), 0))
2334  goto protect_stdout;
2335  {ret= 1; goto ex;}
2336 
2337  } else if((strcmp(cmd,"dev")==0 || strcmp(cmd,"outdev")==0 ||
2338  strcmp(cmd,"indev")==0) &&
2339  (strcmp(arg1,"stdio:/dev/fd/1")==0 || strcmp(arg1,"-")==0) &&
2340  xorriso->dev_fd_1<0) {
2341  /* Detach fd 1 from externally perceived stdout and attach it to stderr.
2342  Keep dev_fd_1 connected to external stdout. dev_fd_1 is to be used when
2343  "stdio:/dev/fd/1" is interpreted as drive address.
2344  */
2345 protect_stdout:;
2346  ret= Xorriso_protect_stdout(xorriso, 0);
2347  if(ret == 1) {
2348  sprintf(xorriso->info_text,
2349  "Encountered - or stdio:/dev/fd/1 as possible write target.");
2350  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
2351  sprintf(xorriso->info_text,
2352  "Redirecting nearly all text message output to stderr.");
2353  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
2354  sprintf(xorriso->info_text, "Disabling use of libreadline.");
2355  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
2356  }
2357  if(xorriso->argument_emulation >= 1 && xorriso->argument_emulation <=2)
2358  {ret= 1; goto ex;}
2359 
2360  } else if(strcmp(cmd,"abort_on")==0 && was_dashed == 1) {
2361  i++;
2362  if(!was_abort_on)
2363  Xorriso_option_abort_on(xorriso, arg1, 0);
2364  was_abort_on= 1;
2365 
2366  } else if(strcmp(cmd,"report_about")==0 && was_dashed == 1) {
2367  i++;
2368  if(!was_report_about)
2369  Xorriso_option_report_about(xorriso, arg1, 0);
2370  was_report_about= 1;
2371 
2372  } else if(strcmp(cmd,"return_with")==0 && was_dashed == 1) {
2373  i+= 2;
2374  num2= 0;
2375  sscanf(arg2,"%d",&num2);
2376  if(!was_return_with)
2377  Xorriso_option_return_with(xorriso, arg1, num2, 0);
2378  was_return_with= 1;
2379 
2380  } else if(strcmp(cmd,"as")==0 && was_dashed == 1) {
2381  ret= Xorriso_count_args(xorriso, argc - i, argv + i, &arg_count, 1);
2382  if(ret == 1) {
2383  i+= arg_count;
2384 
2385  if((strcmp(arg1, "cdrecord")==0 || strcmp(arg1, "wodim")==0 ||
2386  strcmp(arg1, "cdrskin")==0 || strcmp(arg1, "xorrecord")==0) &&
2387  xorriso->dev_fd_1 < 0)
2388  if(Xorriso_cdrskin_uses_stdout(xorriso, arg_count - 1,
2389  argv + i - arg_count + 2, 0))
2390  goto protect_stdout;
2391  }
2392  if(was_dashed == 1) {
2393  if((strcmp(arg1, "mkisofs")==0 || strcmp(arg1, "genisoimage")==0 ||
2394  strcmp(arg1, "genisofs")==0 || strcmp(arg1, "xorrisofs")==0) &&
2395  xorriso->dev_fd_1 < 0)
2396  goto protect_stdout;
2397  }
2398 
2399  } else if(strcmp(cmd, "list_delimiter") == 0) {
2400  /* Needed for interpreting other args. Gets reset after prescan. */
2401  i++;
2402  ret= Xorriso_option_list_delimiter(xorriso, arg1, 0);
2403  if(ret <= 0)
2404  error_seen= 1;
2405 
2406  } else if(strcmp(cmd, "add_plainly") == 0) {
2407  i++;
2408  ret= Xorriso_option_add_plainly(xorriso, arg1, 0);
2409  if(ret <= 0)
2410  error_seen= 1;
2411  if(xorriso->add_plainly == 3) {
2412  /* All further arguments count as pathspecs */
2413  {ret= 1; goto ex;}
2414  }
2415  } else if(strcmp(cmd, "scsi_log") == 0 && was_dashed == 1) {
2416  i++;
2417  if(!was_scsi_log)
2418  Xorriso_option_scsi_log(xorriso, arg1, 0);
2419  was_scsi_log= 1;
2420 
2421  } else if(strcmp(cmd, "signal_handling") == 0 && was_dashed == 1) {
2422  i++;
2423  if(!was_signal_handling)
2424  Xorriso_option_signal_handling(xorriso, arg1, 1); /* no install */
2425  was_signal_handling= 1;
2426 
2427  } else if(strcmp(original_cmd, "-x") == 0) {
2428  xorriso->arrange_args= 1;
2429 
2430  } else if(strcmp(cmd, "backslash_codes") == 0) {
2431  i++;
2432  ret= Xorriso_option_backslash_codes(xorriso, arg1, 0);
2433  if(ret <= 0)
2434  error_seen= 1;
2435 
2436  } else {
2437  ret= Xorriso_count_args(xorriso, argc - i, argv + i, &arg_count, 1);
2438  if(ret == 1) {
2439  i+= arg_count;
2440  } else if((flag & 2) && ((was_dashed && xorriso->add_plainly <= 1) ||
2441  xorriso->add_plainly <= 0)) {
2442  sprintf(xorriso->info_text, "Not a known command: '%s'\n",
2443  original_cmd);
2444  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
2445  error_seen= 1;
2446  }
2447  }
2448  }
2449  ret= 1;
2450 ex:;
2451  strcpy(xorriso->list_delimiter, mem_list_delimiter);
2452  xorriso->add_plainly= mem_add_plainly;
2453  xorriso->bsl_interpretation= mem_bsl;
2454  Xorriso_free_meM(arg1_data);
2455  Xorriso_free_meM(arg2_data);
2456  Xorriso_free_meM(cmd_data);
2457  if(error_seen && ret > 0) {
2458  advice= Xorriso_eval_problem_status(xorriso, 0, 0);
2459  if(advice < 0)
2460  ret= -1;
2461  }
2462  return(ret);
2463 }
2464 
2465 
2466 int Xorriso_read_as_mkisofsrc(struct XorrisO *xorriso, char *path, int flag)
2467 {
2468  int ret, linecount= 0;
2469  FILE *fp= NULL;
2470  char *sret, *line= NULL, *cpt, *wpt;
2471 
2472  Xorriso_alloc_meM(line, char, SfileadrL);
2473 
2474  ret= Xorriso_afile_fopen(xorriso, path, "rb", &fp, 1 | 2);
2475  if(ret <= 0)
2476  {ret= 0; goto ex;}
2477  while(1) {
2478  sret= Sfile_fgets_n(line, SfileadrL - 1, fp, 0);
2479  if(sret == NULL) {
2480  if(ferror(fp))
2481  {ret= 0; goto ex;}
2482  break;
2483  }
2484  linecount++;
2485 
2486  /* Interpret line */
2487  if(line[0] == 0 || line[0] == '#')
2488  continue;
2489  cpt= strchr(line, '=');
2490  if(cpt == NULL) {
2491 
2492  /* >>> ??? complain ? abort reading ? */;
2493 
2494  continue;
2495  }
2496  *cpt= 0;
2497  /* Names are not case sensitive */
2498  for(wpt= line; wpt < cpt; wpt++)
2499  if(*wpt >= 'a' && *wpt <= 'z')
2500  *wpt= toupper(*wpt);
2501  /* Remove trailing whitespace from name */
2502  for(wpt= cpt - 1; wpt >= line ; wpt--)
2503  if(*wpt == ' ' || *wpt == '\t')
2504  *wpt= 0;
2505  else
2506  break;
2507  /* Remove trailing whitespace from value */
2508  for(wpt= cpt + 1 + strlen(cpt + 1) - 1; wpt >= cpt; wpt--)
2509  if(*wpt == ' ' || *wpt == '\t')
2510  *wpt= 0;
2511  else
2512  break;
2513  /* Remove leading whitespace from value */
2514  for(cpt++; *cpt == ' ' || *cpt == '\t'; cpt++);
2515 
2516  if(strcmp(line, "APPI") == 0) {
2517  ret= Xorriso_option_application_id(xorriso, cpt, 0);
2518  } else if(strcmp(line, "COPY") == 0) {
2519  ret= Xorriso_option_copyright_file(xorriso, cpt, 0);
2520  } else if(strcmp(line, "ABST") == 0) {
2521  ret= Xorriso_option_abstract_file(xorriso, cpt, 0);
2522  } else if(strcmp(line, "BIBL") == 0) {
2523  ret= Xorriso_option_biblio_file(xorriso, cpt, 0);
2524  } else if(strcmp(line, "PREP") == 0) {
2525  /* Not planned to be implemented. Preparer is xorriso. */
2526  ret= 1;
2527  } else if(strcmp(line, "PUBL") == 0) {
2528  ret= Xorriso_option_publisher(xorriso, cpt, 0);
2529  } else if(strcmp(line, "SYSI") == 0) {
2530  ret= Xorriso_option_system_id(xorriso, cpt, 0);
2531  } else if(strcmp(line, "VOLI") == 0) {
2532  ret= Xorriso_option_volid(xorriso, cpt, 1);
2533  } else if(strcmp(line, "VOLS") == 0) {
2534  ret= Xorriso_option_volset_id(xorriso, cpt, 0);
2535  } else if(strcmp(line, "HFS_TYPE") == 0) {
2536  /* Not planned to be implemented */
2537  ret= 1;
2538  } else if(strcmp(line, "HFS_CREATOR") == 0) {
2539  /* Not planned to be implemented */
2540  ret= 1;
2541  } else {
2542 
2543  /* >>> ??? complain ? abort reading ? */;
2544 
2545  }
2546  if(ret <= 0)
2547  goto ex;
2548  }
2549  xorriso->mkisofsrc_done= 1;
2550  ret= 1;
2551 ex:
2552  if(fp != NULL)
2553  fclose(fp);
2554  Xorriso_free_meM(line);
2555  return(ret);
2556 }
2557 
2558 
2559 /* ./.mkisofsrc , getenv("MKISOFSRC") ,
2560  $HOME/.mkisofsrc , $(basename $0)/.mkisofsrc
2561  */
2562 int Xorriso_read_mkisofsrc(struct XorrisO *xorriso, int flag)
2563 {
2564  char *path= NULL, *cpt;
2565  int ret;
2566 
2567  Xorriso_alloc_meM(path, char, SfileadrL);
2568 
2569  ret= Xorriso_read_as_mkisofsrc(xorriso, "./.mkisofsrc", 0);
2570  if(ret > 0)
2571  goto ex;
2572  cpt= getenv("MKISOFSRC");
2573  if(cpt != NULL) {
2574  strncpy(path, cpt, SfileadrL - 1);
2575  path[SfileadrL - 1]= 0;
2576  ret= Xorriso_read_as_mkisofsrc(xorriso, path, 0);
2577  if(ret > 0)
2578  goto ex;
2579  }
2580  cpt= getenv("HOME");
2581  if(cpt != NULL) {
2582  strncpy(path, cpt, SfileadrL - 1 - 11);
2583  path[SfileadrL - 1 - 11]= 0;
2584  strcat(path, "/.mkisofsrc");
2585  ret= Xorriso_read_as_mkisofsrc(xorriso, path, 0);
2586  if(ret > 0)
2587  goto ex;
2588  }
2589  strcpy(path, xorriso->progname);
2590  cpt= strrchr(path, '/');
2591  if(cpt != NULL) {
2592  strcpy(cpt + 1, ".mkisofsrc");
2593  ret= Xorriso_read_as_mkisofsrc(xorriso, path, 0);
2594  if(ret > 0)
2595  goto ex;
2596  }
2597  /* no .mkisofsrc file found */
2598  ret= 2;
2599 ex:;
2600  Xorriso_free_meM(path);
2601  return(ret);
2602 }
2603 
2604 
2605 /* https://reproducible-builds.org/specs/source-date-epoch/
2606  and reproducible-builds@lists.alioth.debian.org in august 2016
2607 */
2608 int Xorriso_source_date_epoch(struct XorrisO *xorriso, int flag)
2609 {
2610  /* num_text must be able to take the sprintf output of "%.f".
2611  num_text + 12 must be able to take "%d" with a 64 bit int.
2612  */
2613  char *sec_text, num_text[40];
2614  double dsec= -1.0;
2615  time_t tsec;
2616  struct tm *gmt;
2617 
2618  sec_text= getenv("SOURCE_DATE_EPOCH");
2619  if(sec_text == NULL)
2620  return(2);
2621 
2622  sscanf(sec_text, "%lf", &dsec);
2623  sprintf(num_text, "%.f", dsec);
2624  tsec= dsec;
2625  if(dsec < 0 || ((double) tsec) != dsec ||
2626  strcmp(sec_text, num_text) != 0) {
2627 malformed:;
2628  Xorriso_msgs_submit(xorriso, 0,
2629  "Malformed environment variable SOURCE_DATE_EPOCH encountered",
2630  0, "SORRY", 0);
2631  Xorriso_msgs_submit(xorriso, 0,
2632  "Unset SOURCE_DATE_EPOCH before starting xorriso or see https://reproducible-builds.org/specs/source-date-epoch/",
2633  0, "HINT", 0);
2634  return(0);
2635  }
2636  gmt= gmtime(&tsec);
2637  if(gmt == NULL)
2638  goto malformed;
2639 
2640  sprintf(num_text, "%4.4d", 1900 + gmt->tm_year);
2641  sprintf(num_text + 4, "%2.2d", gmt->tm_mon + 1);
2642  sprintf(num_text + 6, "%2.2d", gmt->tm_mday);
2643  sprintf(num_text + 8, "%2.2d", gmt->tm_hour);
2644  sprintf(num_text + 10, "%2.2d", gmt->tm_min);
2645  sprintf(num_text + 12, "%2.2d", gmt->tm_sec);
2646  strcpy(num_text + 14, "00");
2647  strcpy(xorriso->vol_uuid, num_text);
2648  xorriso->gpt_guid_mode= 2; /* Disk GUID from vol_uuid */
2649  strcpy(xorriso->all_file_dates, "set_to_mtime");
2650  xorriso->do_override_now_time= 1;
2651  xorriso->now_time_override= tsec;
2652  Xorriso_set_libisofs_now(xorriso, 0);
2653 
2654  sprintf(xorriso->info_text,
2655  "Environment variable SOURCE_DATE_EPOCH encountered with value %s",
2656  sec_text);
2657  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
2658  sprintf(xorriso->info_text, "SOURCE_DATE_EPOCH : -volume_date uuid %s",
2659  xorriso->vol_uuid);
2660  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
2661  sprintf(xorriso->info_text,
2662  "SOURCE_DATE_EPOCH : -volume_date all_file_dates %s",
2663  xorriso->all_file_dates);
2664  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
2665  sprintf(xorriso->info_text,
2666  "SOURCE_DATE_EPOCH : -boot_image any gpt_disk_guid=volume_date_uuid");
2667  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
2668  sprintf(xorriso->info_text,
2669  "SOURCE_DATE_EPOCH : -iso_nowtime =%.f", (double) tsec);
2670  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
2671 
2672  return(1);
2673 }
2674 
2675 
2676 int Xorriso_read_rc(struct XorrisO *xorriso, int flag)
2677 {
2678  int ret,i,was_failure= 0,fret;
2679 
2680  /* Interpret environment variable SOURCE_DATE_EPOCH */
2681  ret= Xorriso_source_date_epoch(xorriso, 0);
2682  ret= Xorriso_eval_problem_status(xorriso, ret, 0);
2683  if(ret < 0)
2684  return(0);
2685 
2686  if(xorriso->no_rc)
2687  return(1);
2688  i= xorriso->rc_filename_count-1;
2689  Sfile_home_adr_s(".xorrisorc", xorriso->rc_filenames[i],
2690  sizeof(xorriso->rc_filenames[i]),0);
2691  for(i=0;i<xorriso->rc_filename_count;i++) {
2692  ret= Sfile_type(xorriso->rc_filenames[i],1|8);
2693  if(ret!=1)
2694  continue;
2695  ret= Xorriso_option_options_from_file(xorriso,xorriso->rc_filenames[i],0);
2696  if(ret>1)
2697  return(ret);
2698  if(ret==1)
2699  continue; /* regular bottom of loop */
2700  was_failure= 1;
2701  fret= Xorriso_eval_problem_status(xorriso, ret, 1);
2702  if(fret>=0)
2703  continue;
2704  return(ret);
2705  }
2706  if(xorriso->argument_emulation == 1 && !xorriso->mkisofsrc_done) {
2707  ret= Xorriso_read_mkisofsrc(xorriso, 0);
2708  if(ret <= 0)
2709  was_failure= 1;
2710  }
2711  return(!was_failure);
2712 }
2713 
2714 
2715 int Xorriso_make_return_value(struct XorrisO *xorriso, int flag)
2716 {
2717  int exit_value= 0;
2718 
2719  if(xorriso->eternal_problem_status >= xorriso->return_with_severity)
2720  exit_value= xorriso->return_with_value;
2721  if(exit_value) {
2722  sprintf(xorriso->info_text,
2723  "-return_with %s %d triggered by problem severity %s",
2724  xorriso->return_with_text, exit_value,
2725  xorriso->eternal_problem_status_text);
2726  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
2727  }
2728  return(exit_value);
2729 }
2730 
2731 
2732 int Xorriso_program_arg_bsl(struct XorrisO *xorriso, int argc, char ***argv,
2733  int flag)
2734 {
2735  int i, ret, eaten, bsl_mem, params_to_come= 0, cmd_data_size= 5 * SfileadrL;
2736  int next_is_backslash_codes= 0, next_is_list_delimiter= 0;
2737  char **new_argv= NULL, *cmd, *cmd_data= NULL;
2738  char mem_list_delimiter[81];
2739 
2740  strcpy(mem_list_delimiter, xorriso->list_delimiter);
2741  bsl_mem= xorriso->bsl_interpretation;
2742  if(argc <= 0)
2743  return(0);
2744  Xorriso_alloc_meM(cmd_data, char, cmd_data_size);
2745  new_argv= (char **) Smem_malloC(argc * sizeof(char *));
2746  if(new_argv == NULL)
2747  {ret= -1; goto ex;}
2748  for(i= 0; i < argc; i++) {
2749  new_argv[i]= strdup((*argv)[i]);
2750  if(new_argv[i] == NULL)
2751  {ret= -1; goto ex;}
2752  if(i == 0)
2753  continue;
2754  if(xorriso->bsl_interpretation & 16) {
2755  ret= Sfile_bsl_interpreter(new_argv[i], strlen(new_argv[i]), &eaten, 0);
2756  if(ret <= 0)
2757  goto ex;
2758  }
2759  if(params_to_come == 0) {
2760  ret= Xorriso_normalize_command(xorriso, new_argv[i], i,
2761  cmd_data, cmd_data_size, &cmd, 0);
2762  if(ret < 0)
2763  goto ex;
2764  if(strcmp(cmd, "backslash_codes") == 0) {
2765  params_to_come= 1;
2766  next_is_backslash_codes= 1;
2767  } else if(strcmp(cmd, "list_delimiter") == 0) {
2768  params_to_come= 1;
2769  next_is_list_delimiter= 1;
2770  } else {
2771  ret= Xorriso_count_args(xorriso, argc - i, *argv + i,
2772  &params_to_come, 1);
2773  if(ret <= 0)
2774  goto ex;
2775  if(ret != 1)
2776  params_to_come= 0;
2777  }
2778  } else {
2779  params_to_come--;
2780  if(next_is_backslash_codes) {
2781  next_is_backslash_codes= 0;
2782  ret= Xorriso_option_backslash_codes(xorriso, new_argv[i], 0);
2783  if(ret <= 0)
2784  goto ex;
2785  } else if(next_is_list_delimiter) {
2786  next_is_list_delimiter= 0;
2787  ret= Xorriso_option_list_delimiter(xorriso, new_argv[i], 0);
2788  if(ret <= 0)
2789  goto ex;
2790  }
2791  }
2792  }
2793  ret= 1;
2794 ex:;
2795  Xorriso_free_meM(cmd_data);
2796  strcpy(xorriso->list_delimiter, mem_list_delimiter);
2797  xorriso->bsl_interpretation= bsl_mem;
2798  if(ret <= 0) {
2799  if(new_argv != NULL)
2800  free((char *) new_argv);
2801  } else
2802  *argv= new_argv;
2803  return(ret);
2804 }
2805 
2806 
2807 /* @param flag bit0= prepend wd only if name does not begin by '/'
2808  bit1= normalize image path
2809  bit2= prepend wd (automatically done if wd[0]!=0)
2810  bit3= (with bit1) this is an address in the disk world
2811 */
2812 int Xorriso_make_abs_adr(struct XorrisO *xorriso, char *wd, char *name,
2813  char adr[], int flag)
2814 {
2815  char *norm_adr= NULL;
2816  int ret;
2817 
2818  Xorriso_alloc_meM(norm_adr, char, SfileadrL);
2819 
2820  if((wd[0]!=0 || (flag&4)) && !((flag&1) && name[0]=='/')) {
2821  if(strlen(wd)+1>=SfileadrL)
2822  goto much_too_long;
2823  strcpy(adr, wd);
2824  if(name[0])
2825  if(Sfile_add_to_path(adr, name, 0)<=0) {
2826 much_too_long:;
2827  Xorriso_much_too_long(xorriso, (int) (strlen(adr)+strlen(name)+1), 2);
2828  {ret= 0; goto ex;}
2829  }
2830  } else {
2831  if(strlen(name)+1>=SfileadrL)
2832  goto much_too_long;
2833  strcpy(adr, name);
2834  }
2835  if(flag&2) {
2836  ret= Xorriso_normalize_img_path(xorriso, "", adr, norm_adr,
2837  1|2|((flag&8)>>1));
2838  if(ret<=0)
2839  goto ex;
2840  if(norm_adr[0]==0)
2841  strcpy(norm_adr, "/");
2842  strcpy(adr, norm_adr);
2843  }
2844  ret= 1;
2845 ex:;
2846  Xorriso_free_meM(norm_adr);
2847  return(ret);
2848 }
2849 
2850 
2851 /* @param flag bit0= do not complain in case of error, but set info_text */
2852 int Xorriso_convert_datestring(struct XorrisO *xorriso, char *cmd,
2853  char *time_type, char *timestring,
2854  int *t_type, time_t *t, int flag)
2855 {
2856  int ret;
2857 
2858  *t_type= 0;
2859  if(strcmp(time_type, "a")==0)
2860  (*t_type)|= 1;
2861  else if(strcmp(time_type, "a-c")==0)
2862  (*t_type)|= 1 | 256;
2863  else if(strcmp(time_type, "m")==0)
2864  (*t_type)|= 4;
2865  else if(strcmp(time_type, "m-c")==0)
2866  (*t_type)|= 4 | 256;
2867  else if(strcmp(time_type, "b")==0)
2868  (*t_type)|= 5;
2869  else if(strcmp(time_type, "b-c")==0)
2870  (*t_type)|= 5 | 256;
2871  else if(strcmp(time_type, "c")==0)
2872  (*t_type)|= 2 | 256;
2873  else {
2874  sprintf(xorriso->info_text, "%s: Unrecognized type '%s'", cmd, time_type);
2875  if(!(flag & 1))
2876  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
2877  return(0);
2878  }
2879  ret= Decode_timestring(timestring, t, 0);
2880  if(ret<=0) {
2881  sprintf(xorriso->info_text, "%s: Cannot decode timestring '%s'", cmd,
2882  timestring);
2883  if(!(flag & 1))
2884  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
2885  return(0);
2886  }
2887  sprintf(xorriso->info_text, "Understanding timestring '%s' as: %s",
2888  timestring, ctime(t));
2889  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
2890  return(1);
2891 }
2892 
2893 
2894 /* @param flag bit1= do not report memory usage as DEBUG
2895 */
2896 int Xorriso_check_temp_mem_limit(struct XorrisO *xorriso, off_t mem, int flag)
2897 {
2898  char mem_text[80], limit_text[80];
2899 
2900  Sfile_scale((double) mem, mem_text,5,1e4,0);
2901  if(!(flag&2)) {
2902  sprintf(xorriso->info_text,
2903  "Temporary memory needed for result sorting : %s", mem_text);
2904  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
2905  }
2906  if(mem > xorriso->temp_mem_limit) {
2907  Sfile_scale((double) xorriso->temp_mem_limit,limit_text,5,1e4,1);
2908  sprintf(xorriso->info_text,
2909  "Cannot sort. List of matching files exceeds -temp_mem_limit (%s > %s)",
2910  mem_text, limit_text);
2911  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING", 0);
2912  return(0);
2913  }
2914  return(1);
2915 }
2916 
2917 
2918 int Xorriso_wait_child_end(struct XorrisO *xorriso, pid_t child_pid,
2919  int *status, int flag)
2920 {
2921  int ret;
2922 
2923  do {
2924  /* try to read and print the reply */;
2925  ret= waitpid(child_pid, status, WNOHANG);
2926  if(ret == -1) {
2927  if(errno != EINTR)
2928  return(0);
2929  } else if(ret == 0) {
2930  continue;
2931  } else {
2932  break;
2933  }
2934  } while(1);
2935 
2936  /* >>> interpret *status */;
2937 
2938  return(1);
2939 }
2940 
2941 
2943  int in_argc, char **in_argv,
2944  int *argc, char ***argv, int flag)
2945 {
2946  int i, ret= 0;
2947 
2948  *argv= NULL;
2949  Xorriso_alloc_meM(*argv, char *, in_argc + 1);
2950  for(i= 0; i < in_argc; i++) {
2951  Xorriso_alloc_meM((*argv)[i], char, strlen(in_argv[i]) + 1);
2952  strcpy((*argv)[i], in_argv[i]);
2953  *argc= i + 1;
2954  }
2955  (*argv)[in_argc]= NULL;
2956  ret= 1;
2957 ex:;
2958  if(ret <= 0)
2959  Sfile_destroy_argv(argc, argv, 0);
2960  return(ret);
2961 }
2962 
2963 
2964 /*
2965  @param flag bit0= use env_path to find the desired program
2966  bit1= use in_argv rather than parsing cmd to words
2967  bit2= -reserved-
2968  bit3= demand absolute cmd path
2969 return:
2970  <=0 : error
2971  1 : done
2972 */
2973 int Xorriso_execv(struct XorrisO *xorriso, char *cmd,
2974  int in_argc, char **in_argv, char *env_path,
2975  int *stdin_pipe, int *stdout_pipe, pid_t *forked_pid,
2976  int *status, int flag)
2977 {
2978  int ret, argc= 0, has_slash;
2979  char **argv= NULL, *pathlist= NULL, *cpt, *npt, *prog= NULL;
2980  pid_t child_pid;
2981  struct stat stbuf;
2982 
2983  Xorriso_alloc_meM(prog, char, 5 * SfileadrL);
2984 
2985  wait3(NULL,WNOHANG,NULL); /* just to remove any old dead child */
2986 
2987  if(flag & 2) {
2988  ret= Xorriso_make_argv_with_null(xorriso, in_argc, in_argv,
2989  &argc, &argv, 0);
2990  } else {
2991  ret= Sfile_make_argv("", cmd, &argc, &argv, 1|4|128);
2992  }
2993  if(ret <= 0)
2994  goto ex;
2995  if(argc < 1)
2996  {ret= 0; goto ex;}
2997 
2998  strcpy(prog, argv[0]);
2999  has_slash= (strchr(argv[0], '/') != NULL);
3000  if((flag & 8) && !has_slash) {
3001  sprintf(xorriso->info_text, "External program path contains no '/': ");
3002  Text_shellsafe(argv[0], xorriso->info_text, 1);
3003  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
3004  ret= 0; goto ex;
3005  }
3006  if((flag & 1) && !has_slash) {
3007  if(env_path == NULL)
3008  env_path= "/bin:/sbin";
3009  else if(env_path[0] == 0)
3010  env_path= "/bin:/sbin";
3011  if(Sregex_string(&pathlist, env_path, 0) <= 0)
3012  {ret= -1; goto ex;}
3013  for(cpt= npt= pathlist; npt != NULL; cpt= npt + 1) {
3014  npt= strchr(cpt, ':');
3015  if(npt != NULL)
3016  *npt= 0;
3017  if(strlen(cpt) + strlen(argv[0]) + 1 >= SfileadrL)
3018  {ret= -1; goto ex;}
3019  sprintf(prog, "%s/%s", cpt, argv[0]);
3020  ret= stat(prog, &stbuf);
3021  if(ret != -1)
3022  break;
3023  prog[0]= 0;
3024  }
3025  if(prog[0] == 0) {
3026  sprintf(xorriso->info_text, "Cannot find external program ");
3027  Text_shellsafe(argv[0], xorriso->info_text, 1);
3028  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
3029  ret= 0; goto ex;
3030  }
3031  }
3032 
3033  child_pid= fork();
3034  if(child_pid==-1)
3035  {ret= -1; goto ex;}
3036 
3037  if(child_pid==0) {
3038  /* this is the child process */
3039 
3040  sprintf(xorriso->info_text, "Executing external program ");
3041  Text_shellsafe(prog, xorriso->info_text, 1);
3042  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
3043  Xorriso_destroy(&xorriso, 0); /* reduce memory foot print */
3044 
3045  if(stdin_pipe != NULL) {
3046  close(0);
3047  if(dup2(stdin_pipe[0], 0) == -1)
3048  { perror("dup2(,0)"); exit(1); }
3049  close(stdin_pipe[1]); /* unused */
3050  }
3051  if(stdout_pipe != NULL) {
3052  close(1);
3053  if(dup2(stdout_pipe[1], 1) == -1)
3054  { perror("dup2(,1)"); exit(1); }
3055  close(stdout_pipe[0]); /* unused */
3056  }
3057 
3058  execv(prog, argv); /* should never come back */
3059  fprintf(stderr,"--- execution of shell command failed:\n");
3060  fprintf(stderr," %s\n",cmd);
3061  exit(127);
3062  }
3063 
3064 
3065  /* this is the original process waiting for child to exit */
3066 
3067  if(stdin_pipe != NULL)
3068  close(stdin_pipe[0]); /* unused */
3069  if(stdout_pipe != NULL)
3070  close(stdout_pipe[1]); /* unused */
3071  if(stdin_pipe != NULL || stdout_pipe != NULL) {
3072  /* Pipes need to be fed by the caller who later calls Xorriso_wait_child_end
3073  with *forked_pid as child_pid.
3074  */
3075  *forked_pid= child_pid;
3076  {ret= 1; goto ex;}
3077  }
3078 
3079  ret= Xorriso_wait_child_end(xorriso, child_pid, status, 0);
3080  if(ret <= 0)
3081  goto ex;
3082  ret= 1;
3083 ex:
3084  Sfile_make_argv("", "", &argc, &argv, 2);
3085  Sregex_string(&pathlist, NULL, 0);
3086  Xorriso_free_meM(prog);
3087  return(ret);
3088 }
3089 
3090 
3091 /* @param flag bit0= use env_path to find the desired program
3092  bit1= use in_argv rather than parsing cmd to words
3093  bit2= "r" rather than "w"
3094  bit3= demand absolute cmd path
3095  bit4= override any restriction on external filters
3096 */
3097 int Xorriso_pipe_open(struct XorrisO *xorriso, char *purpose, char *cmd,
3098  int in_argc, char **in_argv, char *env_path,
3099  int *fd, pid_t *forked_pid, int flag)
3100 {
3101  int fp_pipe[2], *stdin_pipe= NULL, *stdout_pipe= NULL, status, ret;
3102 
3103  *fd= -1;
3104 
3105  if(!(flag & 16)) {
3106  ret= Xorriso_external_filter_banned(xorriso, purpose, 0);
3107  if(ret)
3108  return(0);
3109  }
3110  if(pipe(fp_pipe) != 0) {
3111  sprintf(xorriso->info_text, "Cannot create pipe(2) object");
3112  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FATAL", 0);
3113  return(0);
3114  }
3115  if(flag & 4) {
3116  stdout_pipe= fp_pipe;
3117  *fd= fp_pipe[0];
3118  } else {
3119  stdin_pipe= fp_pipe;
3120  *fd= fp_pipe[1];
3121  }
3122  ret= Xorriso_execv(xorriso, cmd, in_argc, in_argv, env_path,
3123  stdin_pipe, stdout_pipe, forked_pid, &status, flag & 11);
3124  return(ret);
3125 }
3126 
3127 
3128 /* @param flag bit0= path is a command parameter
3129 */
3130 int Xorriso_path_is_excluded(struct XorrisO *xorriso, char *path, int flag)
3131 {
3132  int ret;
3133 
3134  if(!(xorriso->disk_excl_mode&1)) /* exclusion is off */
3135  return(0);
3136  if((flag&1) && !(xorriso->disk_excl_mode&2)) /* params are exempted */
3137  return(0);
3138  ret= Exclusions_match(xorriso->disk_exclusions, path,
3139  !!(xorriso->disk_excl_mode&4));
3140  if(ret<0) {
3141  sprintf(xorriso->info_text,
3142  "Error during disk file exclusion decision");
3143  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
3144  }
3145  if(ret>0 && (flag&1)) {
3146  sprintf(xorriso->info_text, "Disk path parameter excluded by %s : ",
3147  (ret==1 ? "-not_paths" : "-not_leaf"));
3148  Text_shellsafe(path, xorriso->info_text, 1);
3149  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
3150  }
3151  return(ret);
3152 }
3153 
3154 
3155 int Xorriso_path_is_hidden(struct XorrisO *xorriso, char *path, int flag)
3156 {
3157  int ret, hide_attrs= 0;
3158 
3159  ret= Exclusions_match(xorriso->iso_rr_hidings, path, 0);
3160  if(ret < 0) {
3161 failure:;
3162  sprintf(xorriso->info_text, "Error during disk file hiding decision");
3163  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
3164  return(-1);
3165  }
3166  if(ret > 0)
3167  hide_attrs|= 1;
3168  ret= Exclusions_match(xorriso->joliet_hidings, path, 0);
3169  if(ret < 0)
3170  goto failure;
3171  if(ret > 0)
3172  hide_attrs|= 2;
3173  ret= Exclusions_match(xorriso->hfsplus_hidings, path, 0);
3174  if(ret < 0)
3175  goto failure;
3176  if(ret > 0)
3177  hide_attrs|= 4;
3178  return(hide_attrs);
3179 }
3180 
3181 
3182 /* Normalize ACL and sort apart "access" ACL from "default" ACL.
3183  */
3184 int Xorriso_normalize_acl_text(struct XorrisO *xorriso, char *in_text,
3185  char **access_acl_text, char **default_acl_text, int flag)
3186 {
3187  int ret, access_count= 0, default_count= 0, pass, is_default, line_len;
3188  int was_error= 0, line_count= 0, perms;
3189  char *acl_text= NULL, *cpt, *npt, *access_wpt= NULL, *default_wpt= NULL;
3190  char *dpt= NULL, *ddpt= NULL, **wpt, *ppt;
3191 
3192  if(in_text[0] == 0 || strcmp(in_text, "clear") == 0 ||
3193  strcmp(in_text, "--remove-all") == 0) {
3194  *access_acl_text= *default_acl_text= NULL;
3195  return(1);
3196  } else if (strcmp(in_text, "--remove-default") == 0) {
3197 
3198  /* >>> protect Access-ACL and delete Default-ACL */;
3199 
3200  /* <<< */
3201  return(0);
3202 
3203  }
3204 
3205  acl_text= strdup(in_text);
3206  if(acl_text == NULL) {
3207  Xorriso_no_malloc_memory(xorriso, NULL, 0);
3208  {ret= -1; goto ex;}
3209  }
3210 
3211  /* From comma to newline */
3212  for(cpt= strchr(acl_text, ','); cpt != NULL; cpt= strchr(cpt + 1, ','))
3213  *cpt= '\n';
3214 
3215  /* Normalize to long text form
3216  and sort apart "access" ACL from "default" ACL */;
3217  for(pass= 0; pass < 2; pass++) {
3218  line_count= 0;
3219  for(cpt= acl_text; cpt != NULL; cpt= npt) {
3220  line_count++;
3221  npt= strchr(cpt, '\n');
3222  if(npt != NULL)
3223  npt++;
3224  if(*cpt == '#' || *cpt == '\n' || *cpt == 0)
3225  continue;
3226 
3227  is_default= 0;
3228  wpt= &access_wpt;
3229  if(*cpt == 'd') {
3230  is_default= 1;
3231  if(pass == 1)
3232  wpt= &default_wpt;
3233  cpt= strchr(cpt, ':');
3234  if(cpt == NULL) {
3235  was_error= line_count;
3236  continue;
3237  }
3238  cpt++;
3239  }
3240 
3241  line_len= 0;
3242  dpt= strchr(cpt, ':');
3243  if(dpt != NULL)
3244  ddpt= strchr(dpt + 1, ':');
3245  if(dpt == NULL || ddpt == NULL) {
3246  was_error= line_count;
3247  continue;
3248  }
3249  if(*cpt == 'u') {
3250  if(pass == 0) {
3251  line_len+= 5;
3252  line_len+= ddpt - dpt;
3253  } else {
3254  strcpy(*wpt, "user:");
3255  strncpy(*wpt + 5, dpt + 1, ddpt - dpt);
3256  (*wpt)+= 5 + (ddpt - dpt);
3257  }
3258  } else if(*cpt == 'g') {
3259  if(pass == 0) {
3260  line_len+= 6 + (ddpt - dpt);
3261  } else {
3262  strcpy(*wpt, "group:");
3263  strncpy(*wpt + 6, dpt + 1, ddpt - dpt);
3264  (*wpt)+= 6 + (ddpt - dpt);
3265  }
3266  } else if(*cpt == 'o') {
3267  if(pass == 0) {
3268  if(ddpt - dpt > 1) {
3269  was_error= line_count;
3270  continue;
3271  }
3272  line_len+= 6 + (ddpt - dpt);
3273  } else {
3274  strcpy(*wpt, "other:");
3275  strncpy(*wpt + 6, dpt + 1, ddpt - dpt);
3276  (*wpt)+= 6 + (ddpt - dpt);
3277  }
3278  } else if(*cpt == 'm') {
3279  if(pass == 0) {
3280  if(ddpt - dpt > 1) {
3281  was_error= line_count;
3282  continue;
3283  }
3284  line_len+= 5 + (ddpt - dpt);
3285  } else {
3286  strcpy(*wpt, "mask:");
3287  strncpy(*wpt + 5, dpt + 1, ddpt - dpt);
3288  (*wpt)+= 5 + (ddpt - dpt);
3289  }
3290 
3291  } else {
3292  /* Unknown tag type */
3293  was_error= line_count;
3294  continue;
3295  }
3296 
3297  /* Examine permissions at ddpt + 1 */;
3298  perms= 0;
3299  for(ppt= ddpt + 1; *ppt != 0 && *ppt != '\n'; ppt++) {
3300  if(*ppt == 'r')
3301  perms|= 4;
3302  else if(*ppt == 'w')
3303  perms|= 2;
3304  else if(*ppt == 'x')
3305  perms|= 1;
3306  else if(*ppt == '-' || *ppt == ' ' || *ppt == '\t')
3307  ;
3308  else if(*ppt == '#')
3309  break;
3310  else {
3311  was_error= line_count;
3312  break;
3313  }
3314  }
3315  if(pass == 0) {
3316  line_len+= 4;
3317  } else {
3318  sprintf(*wpt, "%c%c%c\n",
3319  perms & 4 ? 'r' : '-', perms & 2 ? 'w' : '-', perms & 1 ? 'x' : '-');
3320  (*wpt)+= 4;
3321  }
3322 
3323  if(pass == 0) {
3324  if(is_default)
3325  default_count+= line_len;
3326  else
3327  access_count+= line_len;
3328  }
3329  }
3330 
3331  if(pass == 0) {
3332  *access_acl_text= calloc(access_count + 1, 1);
3333  *default_acl_text= calloc(default_count + 1, 1);
3334  if(*access_acl_text == NULL || *default_acl_text == NULL) {
3335  Xorriso_no_malloc_memory(xorriso, access_acl_text, 0);
3336  {ret= -1; goto ex;}
3337  }
3338  access_wpt= *access_acl_text;
3339  default_wpt= *default_acl_text;
3340  } else {
3341  *access_wpt= 0;
3342  *default_wpt= 0;
3343  }
3344  }
3345 
3346  ret= 1;
3347 ex:;
3348  if(acl_text != NULL)
3349  free(acl_text);
3350  if(was_error) {
3351  sprintf(xorriso->info_text,
3352  "Malformed ACL entries encountered. Last one in line number %d.",
3353  was_error);
3354  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
3355  return(0);
3356  }
3357  return(ret);
3358 }
3359 
int Exclusions_match(struct ExclusionS *o, char *abs_path, int flag)
Definition: aux_objects.c:783
int Xorriso_destroy(struct XorrisO **xorriso, int flag)
Definition: base_obj.c:592
int Xorriso_afile_fopen(struct XorrisO *xorriso, char *filename, char *mode, FILE **ret_fp, int flag)
Definition: disk_ops.c:1780
int Xorriso_as_cdrskin(struct XorrisO *xorriso, int argc, char **argv, int *idx, int flag)
Definition: emulators.c:2815
int Xorriso_as_genisofs(struct XorrisO *xorriso, int argc, char **argv, int *idx, int flag)
Definition: emulators.c:2800
int Xorriso_genisofs_help(struct XorrisO *xorriso, int flag)
Definition: emulators.c:779
int Xorriso_cdrskin_uses_stdout(struct XorrisO *xorriso, int argc, char **argv, int flag)
Definition: emulators.c:32
int Xorriso_cdrskin_help(struct XorrisO *xorriso, int flag)
Definition: emulators.c:48
int Xorriso_external_filter_banned(struct XorrisO *xorriso, char *purpose, int flag)
Definition: filters.c:466
static int Sfile_sep_make_argv(char *progname, char *line, char *separators, int max_words, int *argc, char ***argv, int flag)
static int Sfile_bsl_interpreter(char *text, int upto, int *eaten, int flag)
static int Sfile_destroy_argv(int *argc, char ***argv, int flag)
#define SfileadrL
int Xorriso_normalize_img_path(struct XorrisO *xorriso, char *wd, char *img_path, char eff_path[], int flag)
Definition: iso_tree.c:55
int Xorriso_expand_pattern(struct XorrisO *xorriso, int num_patterns, char **patterns, int extra_filec, int *filec, char ***filev, off_t *mem, int flag)
Definition: iso_tree.c:2091
int Xorriso__text_to_sev(char *severity_name, int *severity_number, int flag)
Definition: lib_mgt.c:387
int Xorriso_set_libisofs_now(struct XorrisO *xorriso, int flag)
Definition: lib_mgt.c:1031
int Xorriso_process_msg_queues(struct XorrisO *xorriso, int flag)
Definition: lib_mgt.c:519
int Xorriso_expand_disk_pattern(struct XorrisO *xorriso, int num_patterns, char **patterns, int extra_filec, int *filec, char ***filev, off_t *mem, int flag)
Definition: match.c:641
int Xorriso_warn_of_wildcards(struct XorrisO *xorriso, char *path, int flag)
Definition: match.c:764
double Scanf_io_size(char *text, int flag)
Definition: misc_funct.c:182
char * Text_shellsafe(char *in_text, char *out_text, int flag)
Definition: misc_funct.c:1044
time_t Decode_timestring(char *code, time_t *date, int flag)
Definition: misc_funct.c:587
int Sregex_string(char **handle, char *text, int flag)
Definition: misc_funct.c:865
int Xorriso_option_abstract_file(struct XorrisO *xorriso, char *name, int flag)
Definition: opts_a_c.c:66
int Xorriso_option_check_media_defaults(struct XorrisO *xorriso, int argc, char **argv, int *idx, int flag)
Definition: opts_a_c.c:1925
int Xorriso_option_blank(struct XorrisO *xorriso, char *in_mode, int flag)
Definition: opts_a_c.c:581
int Xorriso_option_cut_out(struct XorrisO *xorriso, char *disk_path, char *start, char *count, char *iso_rr_path, int flag)
Definition: opts_a_c.c:2779
int Xorriso_option_append_partition(struct XorrisO *xorriso, char *partno_text, char *type_text, char *image_path, int flag)
Definition: opts_a_c.c:295
int Xorriso_option_cp_clone(struct XorrisO *xorriso, int argc, char **argv, int *idx, int flag)
Definition: opts_a_c.c:2464
int Xorriso_option_compare(struct XorrisO *xorriso, char *disk_path, char *iso_path, int flag)
Definition: opts_a_c.c:2258
int Xorriso_option_chgrpi(struct XorrisO *xorriso, char *gid, int argc, char **argv, int *idx, int flag)
Definition: opts_a_c.c:1954
int Xorriso_option_biblio_file(struct XorrisO *xorriso, char *name, int flag)
Definition: opts_a_c.c:566
int Xorriso_option_chowni(struct XorrisO *xorriso, char *uid, int argc, char **argv, int *idx, int flag)
Definition: opts_a_c.c:2062
int Xorriso_option_cpx(struct XorrisO *xorriso, int argc, char **argv, int *idx, int flag)
Definition: opts_a_c.c:2645
int Xorriso_option_copyright_file(struct XorrisO *xorriso, char *name, int flag)
Definition: opts_a_c.c:2451
int Xorriso_option_commit_eject(struct XorrisO *xorriso, char *which, int flag)
Definition: opts_a_c.c:2234
int Xorriso_option_as(struct XorrisO *xorriso, int argc, char **argv, int *idx, int flag)
Definition: opts_a_c.c:397
int Xorriso_option_close(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_a_c.c:2124
int Xorriso_option_acl(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_a_c.c:78
int Xorriso_option_cpri(struct XorrisO *xorriso, int argc, char **argv, int *idx, int flag)
Definition: opts_a_c.c:2568
int Xorriso_option_ban_stdio_write(struct XorrisO *xorriso, int flag)
Definition: opts_a_c.c:558
int Xorriso_option_add_plainly(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_a_c.c:220
int Xorriso_option_cdx(struct XorrisO *xorriso, char *disk_path, int flag)
Definition: opts_a_c.c:1463
int Xorriso_option_chmodi(struct XorrisO *xorriso, char *mode, int argc, char **argv, int *idx, int flag)
Definition: opts_a_c.c:2007
int Xorriso_option_close_filter_list(struct XorrisO *xorriso, int flag)
Definition: opts_a_c.c:2169
int Xorriso_option_boot_image(struct XorrisO *xorriso, char *form, char *treatment, int flag)
Definition: opts_a_c.c:695
int Xorriso_option_close_damaged(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_a_c.c:2141
int Xorriso_option_add(struct XorrisO *xorriso, int argc, char **argv, int *idx, int flag)
Definition: opts_a_c.c:123
int Xorriso_option_commit(struct XorrisO *xorriso, int flag)
Definition: opts_a_c.c:2182
int Xorriso_option_calm_drive(struct XorrisO *xorriso, char *which, int flag)
Definition: opts_a_c.c:1377
int Xorriso_option_changes_pending(struct XorrisO *xorriso, char *state, int flag)
Definition: opts_a_c.c:1530
int Xorriso_option_concat(struct XorrisO *xorriso, int argc, char **argv, int *idx, int flag)
Definition: opts_a_c.c:2368
int Xorriso_option_clone(struct XorrisO *xorriso, char *origin, char *dest, int flag)
Definition: opts_a_c.c:2113
int Xorriso_option_backslash_codes(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_a_c.c:507
int Xorriso_option_compliance(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_a_c.c:2360
int Xorriso_option_abort_on(struct XorrisO *xorriso, char *in_severity, int flag)
Definition: opts_a_c.c:39
int Xorriso_option_auto_charset(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_a_c.c:491
int Xorriso_option_cdi(struct XorrisO *xorriso, char *iso_rr_path, int flag)
Definition: opts_a_c.c:1399
int Xorriso_option_check_md5(struct XorrisO *xorriso, int argc, char **argv, int *idx, int flag)
Definition: opts_a_c.c:1635
int Xorriso_option_charset(struct XorrisO *xorriso, char *name, int flag)
Definition: opts_a_c.c:1564
int Xorriso_option_alter_date(struct XorrisO *xorriso, char *time_type, char *timestring, int argc, char **argv, int *idx, int flag)
Definition: opts_a_c.c:242
int Xorriso_option_application_id(struct XorrisO *xorriso, char *name, int flag)
Definition: opts_a_c.c:362
int Xorriso_option_check_media(struct XorrisO *xorriso, int argc, char **argv, int *idx, int flag)
Definition: opts_a_c.c:1760
int Xorriso_option_assert_volid(struct XorrisO *xorriso, char *pattern, char *severity, int flag)
Definition: opts_a_c.c:445
int Xorriso_option_application_use(struct XorrisO *xorriso, char *path, int flag)
Definition: opts_a_c.c:379
int Xorriso_option_errfile_log(struct XorrisO *xorriso, char *mode, char *path, int flag)
Definition: opts_d_h.c:478
int Xorriso_option_getfacli(struct XorrisO *xorriso, int argc, char **argv, int *idx, int flag)
Definition: opts_d_h.c:1588
int Xorriso_option_history(struct XorrisO *xorriso, char *line, int flag)
Definition: opts_d_h.c:2621
int Xorriso_option_extract_cut(struct XorrisO *xorriso, char *iso_rr_path, char *start, char *count, char *disk_path, int flag)
Definition: opts_d_h.c:669
int Xorriso_option_devices(struct XorrisO *xorriso, int flag)
Definition: opts_d_h.c:136
int Xorriso_option_end(struct XorrisO *xorriso, int flag)
Definition: opts_d_h.c:437
int Xorriso_option_file_size_limit(struct XorrisO *xorriso, int argc, char **argv, int *idx, int flag)
Definition: opts_d_h.c:730
int Xorriso_option_eject(struct XorrisO *xorriso, char *which, int flag)
Definition: opts_d_h.c:409
int Xorriso_option_drive_class(struct XorrisO *xorriso, char *d_class, char *pattern, int flag)
Definition: opts_d_h.c:298
int Xorriso_option_displacement(struct XorrisO *xorriso, char *value, int flag)
Definition: opts_d_h.c:230
int Xorriso_option_find(struct XorrisO *xorriso, int argc, char **argv, int *idx, int flag)
Definition: opts_d_h.c:818
int Xorriso_option_hardlinks(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_d_h.c:1676
int Xorriso_option_grow_blindly(struct XorrisO *xorriso, char *msc2, int flag)
Definition: opts_d_h.c:1657
int Xorriso_option_data_cache_size(struct XorrisO *xorriso, char *num_tiles, char *tile_blocks, int flag)
Definition: opts_d_h.c:40
int Xorriso_option_dummy(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_d_h.c:340
int Xorriso_option_disk_pattern(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_d_h.c:212
int Xorriso_option_extract(struct XorrisO *xorriso, char *iso_path, char *disk_path, int flag)
Definition: opts_d_h.c:590
int Xorriso_option_error_behavior(struct XorrisO *xorriso, char *occasion, char *behavior, int flag)
Definition: opts_d_h.c:524
int Xorriso_option_fs(struct XorrisO *xorriso, char *size, int flag)
Definition: opts_d_h.c:1563
int Xorriso_option_follow(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_d_h.c:1480
int Xorriso_option_gid(struct XorrisO *xorriso, char *gid, int flag)
Definition: opts_d_h.c:1642
int Xorriso_option_dialog(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_d_h.c:176
int Xorriso_option_drive_access(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_d_h.c:261
int Xorriso_option_hide(struct XorrisO *xorriso, char *hide_state, int argc, char **argv, int *idx, int flag)
Definition: opts_d_h.c:2581
int Xorriso_option_external_filter(struct XorrisO *xorriso, int argc, char **argv, int *idx, int flag)
Definition: opts_d_h.c:562
int Xorriso_option_file_name_limit(struct XorrisO *xorriso, char *value, int flag)
Definition: opts_d_h.c:707
int Xorriso_option_dev(struct XorrisO *xorriso, char *in_adr, int flag)
Definition: opts_d_h.c:72
int Xorriso_option_disk_dev_ino(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_d_h.c:194
int Xorriso_option_extract_boot_images(struct XorrisO *xorriso, char *disk_dir_path, int flag)
Definition: opts_d_h.c:651
int Xorriso_option_early_stdio_test(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_d_h.c:368
int Xorriso_option_hfsplus(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_d_h.c:2565
int Xorriso_option_help(struct XorrisO *xorriso, int flag)
Definition: opts_d_h.c:1758
int Xorriso_option_dvd_obs(struct XorrisO *xorriso, char *obs, int flag)
Definition: opts_d_h.c:348
int Xorriso_option_ecma119_map(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_d_h.c:387
int Xorriso_option_modesty_on_drive(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_i_o.c:940
int Xorriso_option_named_pipe_loop(struct XorrisO *xorriso, char *mode, char *stdin_pipe, char *stdout_pipe, char *stderr_pipe, int flag)
Definition: opts_i_o.c:1334
int Xorriso_option_mark(struct XorrisO *xorriso, char *mark, int flag)
Definition: opts_i_o.c:862
int Xorriso_option_joliet(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_i_o.c:91
int Xorriso_option_joliet_map(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_i_o.c:107
int Xorriso_option_mkdiri(struct XorrisO *xorriso, int argc, char **argv, int *idx, int flag)
Definition: opts_i_o.c:914
int Xorriso_option_not_list(struct XorrisO *xorriso, char *adr, int flag)
Definition: opts_i_o.c:1438
int Xorriso_option_iso_nowtime(struct XorrisO *xorriso, char *text, int flag)
Definition: opts_i_o.c:33
int Xorriso_option_map(struct XorrisO *xorriso, char *disk_path, char *iso_path, int flag)
Definition: opts_i_o.c:552
int Xorriso_option_no_rc(struct XorrisO *xorriso, int flag)
Definition: opts_i_o.c:1376
int Xorriso_option_not_paths(struct XorrisO *xorriso, int argc, char **argv, int *idx, int flag)
Definition: opts_i_o.c:1564
int Xorriso_option_osirrox(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_i_o.c:1761
int Xorriso_option_list_extras(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_i_o.c:202
int Xorriso_option_md5(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_i_o.c:874
int Xorriso_option_mount(struct XorrisO *xorriso, char *dev, char *adr_mode, char *adr, char *cmd, int flag)
Definition: opts_i_o.c:1036
int Xorriso_option_overwrite(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_i_o.c:1864
int Xorriso_option_list_delimiter(struct XorrisO *xorriso, char *text, int flag)
Definition: opts_i_o.c:161
int Xorriso_option_options_from_file(struct XorrisO *xorriso, char *adr, int flag)
Definition: opts_i_o.c:1663
int Xorriso_option_move(struct XorrisO *xorriso, char *origin, char *dest, int flag)
Definition: opts_i_o.c:1110
int Xorriso_option_load(struct XorrisO *xorriso, char *adr_mode, char *adr_value, int flag)
Definition: opts_i_o.c:299
int Xorriso_option_lsx(struct XorrisO *xorriso, int argc, char **argv, int *idx, int flag)
Definition: opts_i_o.c:476
int Xorriso_option_mvi(struct XorrisO *xorriso, int argc, char **argv, int *idx, int flag)
Definition: opts_i_o.c:1263
int Xorriso_option_not_mgt(struct XorrisO *xorriso, char *setting, int flag)
Definition: opts_i_o.c:1496
int Xorriso_option_mount_opts(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_i_o.c:1075
int Xorriso_option_iso_rr_pattern(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_i_o.c:62
int Xorriso_option_list_arg_sorting(struct XorrisO *xorriso, int flag)
Definition: opts_i_o.c:151
int Xorriso_option_list_speeds(struct XorrisO *xorriso, int flag)
Definition: opts_i_o.c:222
int Xorriso_option_lnsi(struct XorrisO *xorriso, char *target, char *path, int flag)
Definition: opts_i_o.c:259
int Xorriso_option_launch_frontend(struct XorrisO *xorriso, int argc, char **argv, int *idx, int flag)
Definition: opts_i_o.c:123
int Xorriso_option_jigdo(struct XorrisO *xorriso, char *aspect, char *arg, int flag)
Definition: opts_i_o.c:80
int Xorriso_option_msg_op(struct XorrisO *xorriso, char *what, char *arg, int flag)
Definition: opts_i_o.c:1137
int Xorriso_option_lsi(struct XorrisO *xorriso, int argc, char **argv, int *idx, int flag)
Definition: opts_i_o.c:373
int Xorriso_option_list_formats(struct XorrisO *xorriso, int flag)
Definition: opts_i_o.c:212
int Xorriso_option_logfile(struct XorrisO *xorriso, char *channel, char *fileadr, int flag)
Definition: opts_i_o.c:329
int Xorriso_option_not_leaf(struct XorrisO *xorriso, char *pattern, int flag)
Definition: opts_i_o.c:1389
int Xorriso_option_list_profiles(struct XorrisO *xorriso, char *which, int flag)
Definition: opts_i_o.c:232
int Xorriso_option_map_l(struct XorrisO *xorriso, int argc, char **argv, int *idx, int flag)
Definition: opts_i_o.c:613
int Xorriso_option_page(struct XorrisO *xorriso, int len, int width, int flag)
Definition: opts_p_z.c:106
int Xorriso_option_rom_toc_scan(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_p_z.c:708
int Xorriso_option_volid(struct XorrisO *xorriso, char *volid, int flag)
Definition: opts_p_z.c:2083
int Xorriso_option_status(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_p_z.c:1533
int Xorriso_option_rmi(struct XorrisO *xorriso, int argc, char **argv, int *idx, int flag)
Definition: opts_p_z.c:592
int Xorriso_option_unregister_filter(struct XorrisO *xorriso, char *name, int flag)
Definition: opts_p_z.c:1758
int Xorriso_option_uid(struct XorrisO *xorriso, char *uid, int flag)
Definition: opts_p_z.c:1743
int Xorriso_option_truncate_overwritable(struct XorrisO *xorriso, char *adr_mode, char *adr_value, char *adjust, int flag)
Definition: opts_p_z.c:1731
int Xorriso_option_volume_date(struct XorrisO *xorriso, char *time_type, char *timestring, int flag)
Definition: opts_p_z.c:2139
int Xorriso_option_pkt_output(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_p_z.c:268
int Xorriso_option_toc_of(struct XorrisO *xorriso, char *which, int flag)
Definition: opts_p_z.c:1692
int Xorriso_option_setfacl_listi(struct XorrisO *xorriso, char *path, int flag)
Definition: opts_p_z.c:833
int Xorriso_option_print_size(struct XorrisO *xorriso, int flag)
Definition: opts_p_z.c:334
int Xorriso_option_stdio_sync(struct XorrisO *xorriso, char *rhythm, int flag)
Definition: opts_p_z.c:1560
int Xorriso_option_setfacli(struct XorrisO *xorriso, char *acl_text, int argc, char **argv, int *idx, int flag)
Definition: opts_p_z.c:980
int Xorriso_option_read_mkisofsrc(struct XorrisO *xorriso, int flag)
Definition: opts_p_z.c:483
int Xorriso_option_scdbackup_tag(struct XorrisO *xorriso, char *listname, char *recname, int flag)
Definition: opts_p_z.c:767
int Xorriso_option_tell_media_space(struct XorrisO *xorriso, int flag)
Definition: opts_p_z.c:1623
int Xorriso_option_report_el_torito(struct XorrisO *xorriso, char *form, int flag)
Definition: opts_p_z.c:536
int Xorriso_option_zisofs(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_p_z.c:2252
int Xorriso_option_xattr(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_p_z.c:2228
int Xorriso_option_setfattr_listi(struct XorrisO *xorriso, char *path, int flag)
Definition: opts_p_z.c:1111
int Xorriso_option_return_with(struct XorrisO *xorriso, char *in_severity, int exit_value, int flag)
Definition: opts_p_z.c:558
int Xorriso_option_split_size(struct XorrisO *xorriso, char *size, int flag)
Definition: opts_p_z.c:1515
int Xorriso_option_report_about(struct XorrisO *xorriso, char *in_severity, int flag)
Definition: opts_p_z.c:511
int Xorriso_option_preparer_id(struct XorrisO *xorriso, char *name, int flag)
Definition: opts_p_z.c:279
int Xorriso_option_prog(struct XorrisO *xorriso, char *name, int flag)
Definition: opts_p_z.c:374
int Xorriso_option_prompt(struct XorrisO *xorriso, char *text, int flag)
Definition: opts_p_z.c:403
int Xorriso_option_scsi_dev_family(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_p_z.c:785
int Xorriso_option_stream_recording(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_p_z.c:1586
int Xorriso_option_paste_in(struct XorrisO *xorriso, char *iso_rr_path, char *disk_path, char *start, char *count, int flag)
Definition: opts_p_z.c:122
int Xorriso_option_status_history_max(struct XorrisO *xorriso, int num, int flag)
Definition: opts_p_z.c:1550
int Xorriso_option_prog_help(struct XorrisO *xorriso, char *name, int flag)
Definition: opts_p_z.c:390
int Xorriso_option_use_immed_bit(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_p_z.c:1983
int Xorriso_option_pacifier(struct XorrisO *xorriso, char *style, int flag)
Definition: opts_p_z.c:34
int Xorriso_option_use_readline(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_p_z.c:2005
int Xorriso_option_temp_mem_limit(struct XorrisO *xorriso, char *size, int flag)
Definition: opts_p_z.c:1647
int Xorriso_option_publisher(struct XorrisO *xorriso, char *name, int flag)
Definition: opts_p_z.c:417
int Xorriso_option_pathspecs(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_p_z.c:250
int Xorriso_option_pwdx(struct XorrisO *xorriso, int flag)
Definition: opts_p_z.c:450
int Xorriso_option_session_log(struct XorrisO *xorriso, char *path, int flag)
Definition: opts_p_z.c:824
int Xorriso_option_padding(struct XorrisO *xorriso, char *size, int flag)
Definition: opts_p_z.c:75
int Xorriso_option_pwdi(struct XorrisO *xorriso, int flag)
Definition: opts_p_z.c:436
int Xorriso_option_rr_reloc_dir(struct XorrisO *xorriso, char *name, int flag)
Definition: opts_p_z.c:747
int Xorriso_option_setfattri(struct XorrisO *xorriso, char *name, char *value, int argc, char **argv, int *idx, int flag)
Definition: opts_p_z.c:1055
int Xorriso_option_rollback(struct XorrisO *xorriso, int flag)
Definition: opts_p_z.c:677
int Xorriso_option_scsi_log(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_p_z.c:807
int Xorriso_option_speed(struct XorrisO *xorriso, char *speed_in, int flag)
Definition: opts_p_z.c:1414
int Xorriso_option_read_fs(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_p_z.c:464
int Xorriso_option_version(struct XorrisO *xorriso, int flag)
Definition: opts_p_z.c:2016
int Xorriso_option_reassure(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_p_z.c:493
int Xorriso_option_signal_handling(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_p_z.c:1343
int Xorriso_option_rockridge(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_p_z.c:658
int Xorriso_option_toc(struct XorrisO *xorriso, int flag)
Definition: opts_p_z.c:1668
int Xorriso_option_write_type(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_p_z.c:2208
int Xorriso_option_path_list(struct XorrisO *xorriso, char *adr, int flag)
Definition: opts_p_z.c:163
int Xorriso_option_sh_style_result(struct XorrisO *xorriso, char *mode, int flag)
Definition: opts_p_z.c:1322
int Xorriso_option_pvd_info(struct XorrisO *xorriso, int flag)
Definition: opts_p_z.c:429
int Xorriso_option_report_system_area(struct XorrisO *xorriso, char *form, int flag)
Definition: opts_p_z.c:547
int Xorriso_option_system_id(struct XorrisO *xorriso, char *name, int flag)
Definition: opts_p_z.c:1611
int Xorriso_option_volset_id(struct XorrisO *xorriso, char *name, int flag)
Definition: opts_p_z.c:2127
int Xorriso_option_sleep(struct XorrisO *xorriso, char *duration, int flag)
Definition: opts_p_z.c:1380
int Xorriso_option_print(struct XorrisO *xorriso, char *text, int flag)
Definition: opts_p_z.c:296
int Xorriso_option_set_filter(struct XorrisO *xorriso, char *name, int argc, char **argv, int *idx, int flag)
Definition: opts_p_z.c:1255
int Xorriso_option_update(struct XorrisO *xorriso, char *disk_path, char *iso_path, int flag)
Definition: opts_p_z.c:1778
int Xorriso_count_args(struct XorrisO *xorriso, int argc, char **argv, int *count, int flag)
Definition: parse_exec.c:521
int Xorriso_read_rc(struct XorrisO *xorriso, int flag)
Definition: parse_exec.c:2676
int Xorriso_read_mkisofsrc(struct XorrisO *xorriso, int flag)
Definition: parse_exec.c:2562
int Xorriso_source_date_epoch(struct XorrisO *xorriso, int flag)
Definition: parse_exec.c:2608
int Xorriso_cmd_sorting_rank(struct XorrisO *xorriso, int argc, char **argv, int idx, int flag)
Definition: parse_exec.c:663
int Xorriso_normalize_acl_text(struct XorrisO *xorriso, char *in_text, char **access_acl_text, char **default_acl_text, int flag)
Definition: parse_exec.c:3184
int Xorriso_program_arg_bsl(struct XorrisO *xorriso, int argc, char ***argv, int flag)
Definition: parse_exec.c:2732
int Xorriso_normalize_command(struct XorrisO *xorriso, char *original_cmd, int argno, char *cmd_data, int sizeof_cmd_data, char **cmd, int flag)
Definition: parse_exec.c:484
int Xorriso_eval_problem_status(struct XorrisO *xorriso, int ret, int flag)
Definition: parse_exec.c:307
int Xorriso_end_idx(struct XorrisO *xorriso, int argc, char **argv, int idx, int flag)
Definition: parse_exec.c:46
int Xorriso_wait_child_end(struct XorrisO *xorriso, pid_t child_pid, int *status, int flag)
Definition: parse_exec.c:2918
int Xorriso_make_return_value(struct XorrisO *xorriso, int flag)
Definition: parse_exec.c:2715
int Xorriso_make_abs_adr(struct XorrisO *xorriso, char *wd, char *name, char adr[], int flag)
Definition: parse_exec.c:2812
int Xorriso_make_argv_with_null(struct XorrisO *xorriso, int in_argc, char **in_argv, int *argc, char ***argv, int flag)
Definition: parse_exec.c:2942
int Xorriso_exec_args_sorted(struct XorrisO *xorriso, int argc, char **argv, int *idx, int flag)
Definition: parse_exec.c:868
int Xorriso_execute_option(struct XorrisO *xorriso, char *line, int flag)
Definition: parse_exec.c:2126
int Xorriso_convert_datestring(struct XorrisO *xorriso, char *cmd, char *time_type, char *timestring, int *t_type, time_t *t, int flag)
Definition: parse_exec.c:2852
int Xorriso_execv(struct XorrisO *xorriso, char *cmd, int in_argc, char **in_argv, char *env_path, int *stdin_pipe, int *stdout_pipe, pid_t *forked_pid, int *status, int flag)
Definition: parse_exec.c:2973
int Xorriso_path_is_excluded(struct XorrisO *xorriso, char *path, int flag)
Definition: parse_exec.c:3130
int Xorriso_pipe_open(struct XorrisO *xorriso, char *purpose, char *cmd, int in_argc, char **in_argv, char *env_path, int *fd, pid_t *forked_pid, int flag)
Definition: parse_exec.c:3097
int Xorriso_parse_line(struct XorrisO *xorriso, char *line, char *prefix, char *separators, int max_words, int *argc, char ***argv, int flag)
Definition: parse_exec.c:2066
int Xorriso_read_as_mkisofsrc(struct XorrisO *xorriso, char *path, int flag)
Definition: parse_exec.c:2466
int Xorriso_decode_load_adr(struct XorrisO *xorriso, char *cmd, char *adr_mode, char *adr_value, int *entity_code, char entity_id[81], int flag)
Definition: parse_exec.c:415
int Xorriso_dialog(struct XorrisO *xorriso, int flag)
Definition: parse_exec.c:2181
int Xorriso_cpmv_args(struct XorrisO *xorriso, char *cmd, int argc, char **argv, int *idx, int *optc, char ***optv, char eff_dest[4096], int flag)
Definition: parse_exec.c:349
int Xorriso_get_problem_status(struct XorrisO *xorriso, char severity[80], int flag)
Definition: parse_exec.c:215
int Xorriso_set_problem_status(struct XorrisO *xorriso, char *severity, int flag)
Definition: parse_exec.c:231
int Xorriso_path_is_hidden(struct XorrisO *xorriso, char *path, int flag)
Definition: parse_exec.c:3155
int Xorriso_prescan_args(struct XorrisO *xorriso, int argc, char **argv, int flag)
Definition: parse_exec.c:2251
int Xorriso_check_thing_len(struct XorrisO *xorriso, char *name, int size, char *cmd, char *thing, int flag)
Definition: parse_exec.c:461
void Xorriso__dispose_words(int *argc, char ***argv)
Definition: parse_exec.c:2120
int Xorriso_check_temp_mem_limit(struct XorrisO *xorriso, off_t mem, int flag)
Definition: parse_exec.c:2896
int Xorriso_opt_args(struct XorrisO *xorriso, char *cmd, int argc, char **argv, int idx, int *end_idx, int *optc, char ***optv, int flag)
Definition: parse_exec.c:87
int Xorriso_interpreter(struct XorrisO *xorriso, int argc, char **argv, int *idx, int flag)
Definition: parse_exec.c:949
int Xorriso__cmp_cmd_rank(const void *a, const void *b)
Definition: parse_exec.c:844
int Xorriso_replace_arg_by_bsl(struct XorrisO *xorriso, char **arg, char **argpt, int flag)
Definition: parse_exec.c:2233
int Xorriso_check_name_len(struct XorrisO *xorriso, char *name, int size, char *cmd, int flag)
Definition: parse_exec.c:475
int Sfile_home_adr_s(char *filename, char *fileadr, int fa_size, int flag)
Definition: sfile.c:863
int Sfile_type(char *filename, int flag)
Definition: sfile.c:225
int Sfile_make_argv(char *progname, char *line, int *argc, char ***argv, int flag)
Definition: sfile.c:828
char * Sfile_fgets_n(char *line, int maxl, FILE *fp, int flag)
Definition: sfile.c:33
int Sfile_add_to_path(char path[4096], char *addon, int flag)
Definition: sfile.c:137
int Sfile_scale(double value, char *result, int siz, double thresh, int flag)
Definition: sfile.c:331
#define Xorriso_free_meM(pt)
Definition: sfile.h:27
#define Xorriso_alloc_meM(pt, typ, count)
Definition: sfile.h:19
#define Smem_malloC
Definition: sfile.h:16
char list_delimiter[81]
struct ExclusionS * joliet_hidings
int do_iso_rr_pattern
int do_disk_pattern
time_t now_time_override
int mkisofsrc_done
struct ExclusionS * disk_exclusions
int bsl_interpretation
double error_count
char progname[4096]
char problem_status_text[20]
int arrange_args
char eternal_problem_status_text[20]
char all_file_dates[80]
int prepended_wd
char result_line[10 *4096]
int result_page_counter
struct ExclusionS * iso_rr_hidings
int abort_on_severity
int no_volset_present
int bar_is_fresh
char info_text[10 *4096]
int rc_filename_count
struct ExclusionS * hfsplus_hidings
char vol_uuid[17]
int result_page_length
char abort_on_text[20]
int do_override_now_time
int request_to_abort
pthread_mutex_t problem_status_lock
int eternal_problem_status
int argument_emulation
int request_not_to_ask
char return_with_text[20]
int return_with_value
int return_with_severity
int disk_excl_mode
char wdx[4096]
int result_line_counter
int temp_mem_limit
char rc_filenames[4][4096]
int abort_on_is_default
double idle_time
int gpt_guid_mode
char wdi[4096]
int problem_status
char pending_option[4096]
int did_something_useful
int Xorriso_stop_msg_watcher(struct XorrisO *xorriso, int flag)
Definition: text_io.c:1614
int Xorriso_reset_counters(struct XorrisO *xorriso, int flag)
Definition: text_io.c:4065
int Xorriso_msgs_submit(struct XorrisO *xorriso, int error_code, char msg_text[], int os_errno, char severity[], int flag)
Definition: text_io.c:2504
int Xorriso_start_msg_watcher(struct XorrisO *xorriso, int(*result_handler)(void *handle, char *text), void *result_handle, int(*info_handler)(void *handle, char *text), void *info_handle, int flag)
Definition: text_io.c:1523
int Xorriso_peek_outlists(struct XorrisO *xorriso, int stack_handle, int timeout, int flag)
Definition: text_io.c:1256
int Xorriso_no_malloc_memory(struct XorrisO *xorriso, char **to_free, int flag)
Definition: text_io.c:4077
int Xorriso_push_outlists(struct XorrisO *xorriso, int *stack_handle, int flag)
Definition: text_io.c:1174
int Xorriso_info(struct XorrisO *xorriso, int flag)
Definition: text_io.c:2367
int Xorriso_pull_outlists(struct XorrisO *xorriso, int stack_handle, struct Xorriso_lsT **result_list, struct Xorriso_lsT **info_list, int flag)
Definition: text_io.c:1309
int Xorriso_protect_stdout(struct XorrisO *xorriso, int flag)
Definition: text_io.c:63
int Xorriso_process_msg_lists(struct XorrisO *xorriso, struct Xorriso_lsT *result_list, struct Xorriso_lsT *info_list, int *line_count, int flag)
Definition: text_io.c:1416
int Xorriso_fetch_outlists(struct XorrisO *xorriso, int stack_handle, struct Xorriso_lsT **result_list, struct Xorriso_lsT **info_list, int flag)
Definition: text_io.c:1206
int Xorriso_much_too_long(struct XorrisO *xorriso, int len, int flag)
Definition: text_io.c:4097
int Xorriso_result(struct XorrisO *xorriso, int flag)
Definition: text_io.c:2337
int Xorriso_mark(struct XorrisO *xorriso, int flag)
Definition: text_io.c:2403
int Xorriso_dialog_input(struct XorrisO *xorriso, char line[], int linesize, int flag)
Definition: text_io.c:316