libisoburn  1.5.4
About: libisoburn is a frontend for the libraries libburn and libisofs which enables creation and expansion of ISO-9660 filesystems on all media and file types supported by libburn. It implements the API and command interpreter of program xorriso, and installs this program as small dynamically linked binary. xorriso is suitable for incremental data backup and for production of bootable ISO 9660 images. A statically linked version is available as GNU xorriso.
  Fossies Dox: libisoburn-1.5.4.tar.gz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

opts_i_o.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 options as mentioned in man page
9  or info file derived from xorriso.texi.
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 <errno.h>
26 
27 #include "xorriso.h"
28 #include "xorriso_private.h"
29 #include "xorrisoburn.h"
30 
31 
32 /* Command -iso_nowtime "dynamic"|timespec */
33 int Xorriso_option_iso_nowtime(struct XorrisO *xorriso, char *text, int flag)
34 {
35  char *time_type = "m";
36  int t_type= 0, ret;
37  time_t t;
38 
39  if(strcmp(text, "dynamic") == 0) {
40  xorriso->do_override_now_time= 0;
41  Xorriso_set_libisofs_now(xorriso, 2);
42  Xorriso_msgs_submit(xorriso, 0, "-iso_nowtime: Set to \"dynamic\"", 0,
43  "NOTE", 0);
44  return(1);
45  }
46  ret= Xorriso_convert_datestring(xorriso, "-iso_nowtime", time_type, text,
47  &t_type, &t, 0);
48  if(ret<=0)
49  goto ex;
50  xorriso->do_override_now_time= 1;
51  xorriso->now_time_override= t;
52  Xorriso_set_libisofs_now(xorriso, 1);
53  sprintf(xorriso->info_text, "-iso_nowtime: Set to =%.f", (double) t);
54  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
55  ret= 1;
56 ex:;
57  return(ret);
58 }
59 
60 
61 /* Option -iso_rr_pattern "on"|"ls"|"off" */
62 int Xorriso_option_iso_rr_pattern(struct XorrisO *xorriso, char *mode,int flag)
63 {
64  if(strcmp(mode, "off")==0)
65  xorriso->do_iso_rr_pattern= 0;
66  else if(strcmp(mode, "on")==0)
67  xorriso->do_iso_rr_pattern= 1;
68  else if(strcmp(mode, "ls")==0)
69  xorriso->do_iso_rr_pattern= 2;
70  else {
71  sprintf(xorriso->info_text, "-iso_rr_pattern: unknown mode '%s'", mode);
72  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
73  return(0);
74  }
75  return(1);
76 }
77 
78 
79 /* Option -jigdo aspect argument */
80 int Xorriso_option_jigdo(struct XorrisO *xorriso, char *aspect, char *arg,
81  int flag)
82 {
83  int ret;
84 
85  ret= Xorriso_jigdo_interpreter(xorriso, aspect, arg, 0);
86  return(ret);
87 }
88 
89 
90 /* Option -joliet "on"|"off" */
91 int Xorriso_option_joliet(struct XorrisO *xorriso, char *mode, int flag)
92 {
93  if(strcmp(mode, "off")==0)
94  xorriso->do_joliet= 0;
95  else if(strcmp(mode, "on")==0)
96  xorriso->do_joliet= 1;
97  else {
98  sprintf(xorriso->info_text, "-joliet: unknown mode '%s'", mode);
99  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
100  return(0);
101  }
102  return(1);
103 }
104 
105 
106 /* Command -joliet_map */
107 int Xorriso_option_joliet_map(struct XorrisO *xorriso, char *mode, int flag)
108 {
109  if(strcmp(mode, "unmapped") == 0) {
110  xorriso->joliet_map= 0;
111  } else if(strcmp(mode, "stripped") == 0) {
112  xorriso->joliet_map= 1;
113  } else {
114  sprintf(xorriso->info_text, "-joliet_map: unknown mode '%s'", mode);
115  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
116  return(0);
117  }
118  return(1);
119 }
120 
121 
122 /* Command -launch_frontend */
124  int argc, char **argv, int *idx, int flag)
125 {
126  int ret, end_idx;
127 
128  end_idx= Xorriso_end_idx(xorriso, argc, argv, *idx, 1);
129 
130  if(xorriso->launch_frontend_banned) {
131  sprintf(xorriso->info_text,
132  "-launch_frontend was already executed in this xorriso run");
133  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
134  ret= 0; goto ex;
135  }
136  xorriso->launch_frontend_banned= 1;
137  if(end_idx <= *idx)
138  {ret= 1; goto ex;}
139  if(argv[*idx][0] == 0)
140  {ret= 1; goto ex;}
141  xorriso->dialog= 2;
142  ret= Xorriso_launch_frontend(xorriso, end_idx - *idx, argv + *idx,
143  "", "", 0);
144 ex:;
145  (*idx)= end_idx;
146  return(ret);
147 }
148 
149 
150 /* Option -list_arg_sorting */
151 int Xorriso_option_list_arg_sorting(struct XorrisO *xorriso, int flag)
152 {
153  int ret;
154 
155  ret= Xorriso_cmd_sorting_rank(xorriso, 0, NULL, 0, 1);
156  return(ret);
157 }
158 
159 
160 /* Option -list_delimiter */
161 int Xorriso_option_list_delimiter(struct XorrisO *xorriso, char *text,
162  int flag)
163 {
164  int ret, argc;
165  char **argv= NULL;
166 
167  if(text[0] == 0) {
168  sprintf(xorriso->info_text,
169  "-list_delimiter: New delimiter text is empty");
170  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
171  return(0);
172  }
173  if(strlen(text) > 80) {
174  sprintf(xorriso->info_text,
175  "-list_delimiter: New delimiter text is too long");
176  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
177  return(0);
178  }
179  ret= Sfile_make_argv(xorriso->progname, text, &argc, &argv, 4);
180  if(ret > 0) {
181  if(argc > 2) {
182  sprintf(xorriso->info_text,
183  "-list_delimiter: New delimiter text contains more than one word");
184  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
185  }
186  Sfile_make_argv(xorriso->progname, text, &argc, &argv, 2);
187  if(argc > 2)
188  return(0);
189  }
190  if(strchr(text, '"') != NULL || strchr(text, '\'') != NULL) {
191  sprintf(xorriso->info_text,
192  "-list_delimiter: New delimiter text contains quotation marks");
193  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
194  return(0);
195  }
196  strcpy(xorriso->list_delimiter, text);
197  return(1);
198 }
199 
200 
201 /* Option -list_extras */
202 int Xorriso_option_list_extras(struct XorrisO *xorriso, char *mode, int flag)
203 {
204  int ret;
205 
206  ret= Xorriso_list_extras(xorriso, mode, 0);
207  return(ret);
208 }
209 
210 
211 /* Option -list_formats */
212 int Xorriso_option_list_formats(struct XorrisO *xorriso, int flag)
213 {
214  int ret;
215 
216  ret= Xorriso_list_formats(xorriso, 0);
217  return(ret);
218 }
219 
220 
221 /* Option -list_speeds */
222 int Xorriso_option_list_speeds(struct XorrisO *xorriso, int flag)
223 {
224  int ret;
225 
226  ret= Xorriso_list_speeds(xorriso, 0);
227  return(ret);
228 }
229 
230 
231 /* Option -list_profiles */
232 int Xorriso_option_list_profiles(struct XorrisO *xorriso, char *which,
233  int flag)
234 {
235  int ret;
236  int mode= 0;
237 
238  if(strncmp(which,"in",2)==0)
239  mode|= 1;
240  else if(strncmp(which,"out",3)==0)
241  mode|= 2;
242  else
243  mode|= 3;
244  if(mode & 1) {
245  ret= Xorriso_toc(xorriso, 1 | 16 | 32);
246  if(ret > 0)
247  Xorriso_list_profiles(xorriso, 0);
248  }
249  if((mode & 2) && xorriso->in_drive_handle != xorriso->out_drive_handle) {
250  ret= Xorriso_toc(xorriso, 1 | 2 | 16 | 32);
251  if(ret > 0)
252  Xorriso_list_profiles(xorriso, 2);
253  }
254  return(1);
255 }
256 
257 
258 /* Command -lns alias -lnsi */
259 int Xorriso_option_lnsi(struct XorrisO *xorriso, char *target, char *path,
260  int flag)
261 {
262  int ret;
263  char *eff_path= NULL, *buffer= NULL, *namept;
264 
265  Xorriso_alloc_meM(eff_path, char, SfileadrL);
266  Xorriso_alloc_meM(buffer, char, SfileadrL);
267 
268  ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, path, eff_path, 1);
269  if(ret < 0)
270  {ret= 0; goto ex;}
271  if(ret > 0) {
272  sprintf(xorriso->info_text, "-lns: Address already existing: ");
273  Text_shellsafe(eff_path, xorriso->info_text, 1);
274  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
275  {ret= 0; goto ex;}
276  }
277  ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, path, eff_path, 2);
278  if(ret < 0)
279  {ret= 0; goto ex;}
280  ret= Xorriso_truncate_path_comps(xorriso, target, buffer, &namept, 0);
281  if(ret < 0)
282  {ret= 0; goto ex;}
283  ret= Xorriso_graft_in(xorriso, NULL, namept, eff_path, (off_t) 0, (off_t) 0,
284  1024);
285  if(ret <= 0)
286  {ret= 0; goto ex;}
287  ret= 1;
288 ex:;
289  Xorriso_free_meM(buffer);
290  Xorriso_free_meM(eff_path);
291  return(ret);
292 }
293 
294 
295 /* Option -load session|track|sbsector value */
296 /* @param flag bit0= with adr_mode sbsector: adr_value is possibly 16 too high
297  @return <=0 error , 1 success, 2 revoked by -reassure
298 */
299 int Xorriso_option_load(struct XorrisO *xorriso, char *adr_mode,
300  char *adr_value, int flag)
301 {
302  int ret;
303 
304  if(Xorriso_change_is_pending(xorriso, 0)) {
305  sprintf(xorriso->info_text,
306  "-load: Image changes pending. -commit or -rollback first");
307  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
308  return(0);
309  }
310  ret= Xorriso_reassure(xorriso, "-load", "loads an alternative image", 0);
311  if(ret<=0)
312  return(2);
313  ret= Xorriso_decode_load_adr(xorriso, "-load", adr_mode, adr_value,
314  &(xorriso->image_start_mode),
315  xorriso->image_start_value, flag & 1);
316  if(ret <= 0)
317  return(ret);
318  xorriso->image_start_mode|= (1<<30); /* enable non-default msc1 processing */
319  if(strlen(xorriso->indev)>0) {
320  ret= Xorriso_option_rollback(xorriso, 1); /* Load image, no -reassure */
321  if(ret<=0)
322  return(ret);
323  }
324  return(1);
325 }
326 
327 
328 /* Option -logfile */
329 int Xorriso_option_logfile(struct XorrisO *xorriso, char *channel,
330  char *fileadr, int flag)
331 {
332  int hflag,channel_no= 0, ret;
333 
334  if(channel[0]==0) {
335 logfile_wrong_form:;
336  sprintf(xorriso->info_text,"Wrong form. Correct would be: -logfile \".\"|\"R\"|\"I\"|\"M\" file_address");
337  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
338  return(0);
339  }
340  hflag= 2;
341  if(channel[0]=='R')
342  channel_no= 1;
343  else if(channel[0]=='I')
344  channel_no= 2;
345  else if(channel[0]=='M')
346  channel_no= 3;
347  else if(channel[0]=='.')
348  hflag= 4;
349  else
350  goto logfile_wrong_form;
351  if(strcmp(fileadr,"-")==0 || fileadr[0]==0)
352  hflag|= (1<<15);
353  xorriso->logfile[channel_no][0]= 0;
354  ret= Xorriso_write_to_channel(xorriso, fileadr, channel_no, hflag);
355  if(ret<=0) {
356  sprintf(xorriso->info_text, "Cannot open logfile: %s", fileadr);
357  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
358  } else if(!(hflag&(1<<15)))
359  if(Sfile_str(xorriso->logfile[channel_no], fileadr, 0)<=0)
360  return(-1);
361  return(ret>0);
362 }
363 
364 
365 /* Options -ls alias -lsi and -lsl alias -lsli
366  and -lsd alias -lsdi and -lsdl alias -lsdli
367  and -du alias -dui and -dus alias -dusi
368  @param flag bit0= long format (-lsl , -du, not -dus, not -ls)
369  bit1= do not expand patterns but use literally
370  bit2= -du rather than -ls
371  bit3= list directories as themselves (-lsd)
372 */
373 int Xorriso_option_lsi(struct XorrisO *xorriso, int argc, char **argv,
374  int *idx, int flag)
375 {
376  int ret, end_idx, filec= 0, nump, i, star= 1;
377  char **filev= NULL, **patterns= NULL;
378  off_t mem= 0;
379  struct stat stbuf;
380 
381  if(flag & 4) {
382  if(!(flag & 1))
383  star= 0;
384  } else {
385  if(flag & 8)
386  star= 0;
387  }
388 
389  end_idx= Xorriso_end_idx(xorriso, argc, argv, *idx, 1);
390  if(xorriso->do_iso_rr_pattern==0)
391  flag|= 2;
392 
393  nump= end_idx - *idx;
394  if((flag&2) && nump>0 ) {
395  ;
396  } else if(nump <= 0) {
397  if(Xorriso_iso_lstat(xorriso, xorriso->wdi, &stbuf, 0)<0) {
398  sprintf(xorriso->info_text,
399  "Current -cd path does not yet exist in the ISO image");
400  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
401  {ret= 0; goto ex;}
402  }
403  if(!S_ISDIR(stbuf.st_mode)) {
404  sprintf(xorriso->info_text,
405  "Current -cd meanwhile points to a non-directory in ISO image");
406  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
407  {ret= 0; goto ex;}
408  }
409  patterns= calloc(1, sizeof(char *));
410  if(patterns == NULL) {
411 no_memory:;
412  sprintf(xorriso->info_text,
413  "Cannot allocate enough memory for pattern expansion");
414  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
415  {ret= -1; goto ex;}
416  }
417  nump= 1;
418  if(star)
419  patterns[0]= "*";
420  else
421  patterns[0]= ".";
422  flag&= ~2;
423  } else {
424  patterns= calloc(nump, sizeof(char *));
425  if(patterns==NULL)
426  goto no_memory;
427  for(i= 0; i<nump; i++) {
428  if(argv[i + *idx][0]==0) {
429  if(star)
430  patterns[i]= "*";
431  else
432  patterns[i]= ".";
433  } else
434  patterns[i]= argv[i + *idx];
435  }
436  }
437 
438  if((flag & 1) && !(xorriso->ino_behavior & 32)) {
439  ret= Xorriso_make_hln_array(xorriso, 0); /* for stbuf.st_nlink */
440  if(ret < 0)
441  goto ex;
442  }
443  if(flag&2) {
444  ret= Xorriso_ls_filev(xorriso, xorriso->wdi, nump, argv + (*idx), mem,
445  flag&(1|4|8));
446  } else if(nump==1 && strcmp(patterns[0],"*")==0 && !(flag&4)){
447  /* save temporary memory by calling simpler function */
448  ret= Xorriso_ls(xorriso, (flag&1)|4);
449  } else {
450  ret= Xorriso_expand_pattern(xorriso, nump, patterns, 0, &filec, &filev,
451  &mem, 0);
452  if(ret<=0)
453  {ret= 0; goto ex;}
454  ret= Xorriso_ls_filev(xorriso, xorriso->wdi, filec, filev, mem,
455  flag&(1|4|8));
456  }
457  if(ret<=0)
458  {ret= 0; goto ex;}
459 
460  ret= 1;
461 ex:;
462  if(patterns!=NULL)
463  free((char *) patterns);
464  Sfile_destroy_argv(&filec, &filev, 0);
465  (*idx)= end_idx;
466  return(ret);
467 }
468 
469 
470 /* Options -lsx, -lslx, -lsdx , -lsdlx , -dux , -dusx
471  @param flag bit0= long format (-lslx , -dux)
472  bit1= do not expand patterns but use literally
473  bit2= du rather than ls
474  bit3= list directories as themselves (ls -d)
475 */
476 int Xorriso_option_lsx(struct XorrisO *xorriso, int argc, char **argv,
477  int *idx, int flag)
478 {
479  int ret, end_idx, filec= 0, nump, i;
480  char **filev= NULL, **patterns= NULL;
481  off_t mem= 0;
482 
483  end_idx= Xorriso_end_idx(xorriso, argc, argv, *idx, 1|2);
484  if(xorriso->do_disk_pattern==0)
485  flag|= 2;
486 
487  nump= end_idx - *idx;
488  if((flag&2) && nump>0) {
489  ;
490  } else if(nump <= 0) {
491  patterns= calloc(1, sizeof(char *));
492  if(patterns == NULL) {
493 no_memory:;
494  sprintf(xorriso->info_text,
495  "Cannot allocate enough memory for pattern expansion");
496  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
497  {ret= -1; goto ex;}
498  }
499  nump= 1;
500  if(flag&8)
501  patterns[0]= ".";
502  else
503  patterns[0]= "*";
504  flag&= ~2;
505  } else {
506  patterns= calloc(nump, sizeof(char *));
507  if(patterns==NULL)
508  goto no_memory;
509  for(i= 0; i<nump; i++) {
510  if(argv[i + *idx][0]==0)
511  patterns[i]= "*";
512  else
513  patterns[i]= argv[i + *idx];
514  }
515  }
516  if(flag&2) {
517  ret= Xorriso_lsx_filev(xorriso, xorriso->wdx,
518  nump, argv + (*idx), mem, flag&(1|4|8));
519 
520 #ifdef Not_yeT
521  } else if(nump==1 && strcmp(patterns[0],"*")==0 && !(flag&4)){
522  /* save temporary memory by calling simpler function */
523  ret= Xorriso_ls(xorriso, (flag&1)|4);
524 #endif
525 
526  } else {
527  ret= Xorriso_expand_disk_pattern(xorriso, nump, patterns, 0, &filec, &filev,
528  &mem, 0);
529  if(ret<=0)
530  {ret= 0; goto ex;}
531  ret= Xorriso_lsx_filev(xorriso, xorriso->wdx, filec, filev, mem,
532  flag&(1|4|8));
533  }
534  if(ret<=0)
535  {ret= 0; goto ex;}
536 
537  ret= 1;
538 ex:;
539  if(patterns!=NULL)
540  free((char *) patterns);
541  Sfile_destroy_argv(&filec, &filev, 0);
542  (*idx)= end_idx;
543  return(ret);
544 }
545 
546 
547 /* Option -map , -map_single */
548 /* @param flag bit0=do not report the added item
549  bit1=do not reset pacifier, no final pacifier message
550  bit5= -map_single: do not insert directory tree
551 */
552 int Xorriso_option_map(struct XorrisO *xorriso, char *disk_path,
553  char *iso_path, int flag)
554 {
555  int ret;
556  char *eff_origin= NULL, *eff_dest= NULL, *ipth;
557 
558  Xorriso_alloc_meM(eff_origin, char, SfileadrL);
559  Xorriso_alloc_meM(eff_dest, char, SfileadrL);
560 
561  if(!(flag&2))
562  Xorriso_pacifier_reset(xorriso, 0);
563 
564  ipth= iso_path;
565  if(ipth[0]==0)
566  ipth= disk_path;
567  if(disk_path[0]==0) {
568  sprintf(xorriso->info_text, "-map: Empty disk_path given");
569  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 1);
570  {ret= 0; goto ex;}
571  }
572  ret= Xorriso_normalize_img_path(xorriso, xorriso->wdx, disk_path, eff_origin,
573  2|4);
574  if(ret<=0)
575  goto ex;
576  ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, ipth, eff_dest, 2);
577  if(ret<=0)
578  goto ex;
579  ret= Xorriso_graft_in(xorriso, NULL, eff_origin, eff_dest,
580  (off_t) 0, (off_t) 0, 2|(flag&32));
581  if(!(flag&2))
582  Xorriso_pacifier_callback(xorriso, "files added", xorriso->pacifier_count,
583  xorriso->pacifier_total, "", 1);
584  if(ret<=0)
585  goto ex;
586 
587  if(!(flag&1)) {
588  sprintf(xorriso->info_text, "Added to ISO image: %s '%s'='%s'\n",
589  (ret>1 ? "directory" : "file"), (eff_dest[0] ? eff_dest : "/"),
590  eff_origin);
591  Xorriso_info(xorriso,0);
592  }
593  ret= 1;
594 ex:;
595  Xorriso_free_meM(eff_origin);
596  Xorriso_free_meM(eff_dest);
597  return(ret);
598 }
599 
600 
601 /* Command -map_l , -compare_l , -update_l , -extract_l , -update_lxi ,
602  -update_li
603 */
604 /* @param flag bit4= do not establish and dispose xorriso->di_array
605  for update_l
606  bit8-11= mode 0= -map_l
607  1= -compare_l
608  2= -update_l
609  3= -extract_l
610  4= -update_lxi
611  5= -update_li
612 */
613 int Xorriso_option_map_l(struct XorrisO *xorriso, int argc, char **argv,
614  int *idx, int flag)
615 {
616  int ret, end_idx, optc= 0, was_failure= 1, i, j, fret, mode, problem_count;
617  int ns_flag= 2|4, nt_flag= 2, opt_args_flag= 2, arg2c= 0, opt2c= 0;
618  int new_opt2c;
619  char *source_prefix= NULL, *target_prefix= NULL, *cmd, **optv= NULL;
620  char *eff_source= NULL, *eff_target= NULL, *s_wd, *t_wd;
621  char **eff_src_array= NULL, **eff_tgt_array= NULL, **opt2v= NULL;
622  char **arg2v= NULL;
623 
624  cmd= "-map_l";
625  s_wd= xorriso->wdx;
626  t_wd= xorriso->wdi;
627  Xorriso_pacifier_reset(xorriso, 0);
628  mode= (flag>>8) & 15;
629 
630  if(mode==1)
631  cmd= "-compare_l";
632  else if(mode==2)
633  cmd= "-update_l";
634  else if(mode == 3 || mode == 5) {
635  if(mode == 5)
636  cmd= "-update_li";
637  else
638  cmd= "-extract_l";
639  ns_flag= 2;
640  s_wd= xorriso->wdi;
641  nt_flag= 2|4;
642  t_wd= xorriso->wdx;
643  opt_args_flag= 0;
644  } else if(mode == 4) {
645  cmd= "-update_lxi";
646  }
647 
648  end_idx= Xorriso_end_idx(xorriso, argc, argv, *idx, 1|2);
649  if(end_idx - (*idx) < 3) {
650  sprintf(xorriso->info_text, "%s: Not enough arguments given (%d < 3)", cmd,
651  end_idx - (*idx));
652  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 1);
653  ret= 0; goto ex;
654  }
655 
656  Xorriso_alloc_meM(source_prefix, char, SfileadrL);
657  Xorriso_alloc_meM(target_prefix, char, SfileadrL);
658  Xorriso_alloc_meM(eff_source, char, SfileadrL);
659  Xorriso_alloc_meM(eff_target, char, SfileadrL);
660 
661  ret= Xorriso_normalize_img_path(xorriso, s_wd, argv[*idx],
662  source_prefix, ns_flag | 64);
663  if(ret<=0)
664  goto ex;
665  ret= Xorriso_normalize_img_path(xorriso, t_wd, argv[(*idx)+1],
666  target_prefix, nt_flag);
667  if(ret<=0)
668  goto ex;
669  ret= Xorriso_opt_args(xorriso, cmd, argc, argv, (*idx)+2, &end_idx,
670  &optc, &optv, opt_args_flag);
671  if(ret<=0)
672  goto ex;
673  if(mode == 4) {
674  /* Convert pattern from disk to iso_rr */
675  arg2c= end_idx - *idx - 2;
676  Xorriso_alloc_meM(arg2v, char *, arg2c);
677  for(i = 0; i < arg2c; i++)
678  arg2v[i]= NULL;
679  arg2c= 0;
680  for(i = (*idx) + 2; i < end_idx; i++) {
681  ret= Xorriso_normalize_img_path(xorriso, s_wd, argv[i],
682  eff_source, ns_flag);
683  if(ret<=0)
684  goto ex;
685  ret= Xorriso__exchange_prefix(source_prefix, target_prefix,
686  eff_source, eff_target, 0);
687  if(ret <= 0)
688  continue;
689  Xorriso_alloc_meM(arg2v[arg2c], char, strlen(eff_target) + 1);
690  strcpy(arg2v[arg2c], eff_target);
691  arg2c++;
692  }
693  /* Expand wildcards in iso_rr, do not include unmatched patterns */
694  ret= Xorriso_opt_args(xorriso, cmd, arg2c, arg2v, 0, &i,
695  &opt2c, &opt2v, (1 << 10) | (1 << 7));
696  if(ret<=0)
697  goto ex;
698  /* Convert from iso_rr path to disk path */
699  new_opt2c= 0;
700  for(i = 0; i < opt2c; i++) {
701  ret= Xorriso__exchange_prefix(target_prefix, source_prefix,
702  opt2v[i], eff_source, 0);
703  free(opt2v[i]);
704  opt2v[i]= NULL;
705  if(ret <= 0)
706  continue;
707  Xorriso_alloc_meM(opt2v[new_opt2c], char, strlen(eff_source) + 1);
708  strcpy(opt2v[new_opt2c], eff_source);
709  new_opt2c++;
710  }
711  opt2c= new_opt2c;
712  /* Merge both results */
713  if(opt2c > 0) {
714  Sfile_destroy_argv(&arg2c, &arg2v, 0);
715  Xorriso_alloc_meM(arg2v, char *, optc + opt2c);
716  for(i = 0; i < optc + opt2c; i++)
717  arg2v[i]= NULL;
718  arg2c= 0;
719  for(i= 0; i < optc; i++) {
720  ret= Xorriso_normalize_img_path(xorriso, s_wd, optv[i],
721  eff_source, ns_flag);
722  if(ret<=0)
723  goto ex;
724  Xorriso_alloc_meM(arg2v[arg2c], char, strlen(eff_source) + 1);
725  strcpy(arg2v[arg2c], eff_source);
726  arg2c++;
727  }
728  for(i= 0; i < opt2c; i++) {
729  for(j= 0; j < optc; j++)
730  if(strcmp(opt2v[i], arg2v[j]) == 0)
731  break;
732  if(j < optc)
733  continue;
734  arg2v[arg2c++]= opt2v[i];
735  opt2v[i]= NULL;
736  }
737  Sfile_destroy_argv(&optc, &optv, 0);
738  optv= arg2v;
739  arg2v= NULL;
740  optc= arg2c;
741  arg2c= 0;
742  }
743  }
744 
745  if(mode == 3 &&
746  (xorriso->do_restore_sort_lba || !(xorriso->ino_behavior & 4))) {
747  eff_src_array= calloc(optc, sizeof(char *));
748  eff_tgt_array= calloc(optc, sizeof(char *));
749  if(eff_src_array == NULL || eff_tgt_array == NULL) {
750  Xorriso_no_malloc_memory(xorriso, NULL, 0);
751  ret= -1; goto ex;
752  }
753  for(i= 0; i < optc; i++)
754  eff_src_array[i]= eff_tgt_array[i]= NULL;
755  }
756  if((mode == 2 || mode == 4) &&
757  !((xorriso->ino_behavior & 2) || (flag & 16) ||
758  xorriso->di_array != NULL)) {
759  /* Create all-image node array sorted by isofs.di */
760  ret= Xorriso_make_di_array(xorriso, 0);
761  if(ret <= 0)
762  goto ex;
763  }
764 
765  for(i= 0; i<optc; i++) {
766  ret= Xorriso_normalize_img_path(xorriso, s_wd, optv[i],
767  eff_source, ns_flag);
768  if(ret<=0)
769  goto ex;
770  ret= Xorriso__exchange_prefix(source_prefix, target_prefix,
771  eff_source, eff_target, 0);
772  if(ret == 0) {
773  sprintf(xorriso->info_text, "%s: disk_path ", cmd);
774  Text_shellsafe(eff_source, xorriso->info_text, 1);
775  strcat(xorriso->info_text, " does not begin with disk_prefix ");
776  Text_shellsafe(source_prefix, xorriso->info_text, 1);
777  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 1);
778  }
779  if(ret <= 0)
780  goto ex;
781 
782  if(mode==0)
783  ret= Xorriso_option_map(xorriso, eff_source, eff_target, 2);
784  else if(mode==1)
785  ret= Xorriso_option_compare(xorriso, eff_source, eff_target, 2|8);
786  else if(mode == 2 || mode == 4)
787  ret= Xorriso_option_update(xorriso, eff_source, eff_target, 2 | 8 | 16);
788  else if(mode==3) {
789  if(eff_src_array != NULL) {
790  eff_src_array[i]= strdup(eff_source);
791  eff_tgt_array[i]= strdup(eff_target);
792  if(eff_src_array[i] == NULL || eff_tgt_array[i] == NULL) {
793  Xorriso_no_malloc_memory(xorriso, &(eff_src_array[i]), 0);
794  ret= -1; goto ex;
795  }
796  } else {
797  ret= Xorriso_option_extract(xorriso, eff_source, eff_target, 2 | 4);
798  }
799  } else if(mode == 5) {
800  ret= Xorriso_option_update(xorriso, eff_target, eff_source, 2 | 8 | 16);
801  }
802 
803  if(ret>0 && !xorriso->request_to_abort)
804  continue; /* regular bottom of loop */
805  was_failure= 1;
806  fret= Xorriso_eval_problem_status(xorriso, ret, 1 | 2);
807  if(fret>=0)
808  continue;
809  goto ex;
810  }
811 
812  ret= 1;
813  if(mode == 3 && eff_src_array != NULL) {
815  target_prefix, strlen(target_prefix) + 1, 0);
816  if(ret <= 0)
817  goto ex;
819  source_prefix, strlen(source_prefix) + 1, 0);
820  if(ret <= 0)
821  goto ex;
822  ret= Xorriso_restore_sorted(xorriso, optc, eff_src_array, eff_tgt_array,
823  &problem_count, 0);
824  if(ret <= 0 || problem_count > 0)
825  was_failure= 1;
826  }
827  if(mode==0)
828  Xorriso_pacifier_callback(xorriso, "files added", xorriso->pacifier_count,
829  xorriso->pacifier_total, "", 1);
830  else if(mode==1 || mode==2 || mode == 4 || mode == 5)
831  Xorriso_pacifier_callback(xorriso, "content bytes read",
832  xorriso->pacifier_count, 0, "", 1 | 8 | 32);
833  else if(mode==3)
834  Xorriso_pacifier_callback(xorriso, "files restored",xorriso->pacifier_count,
835  xorriso->pacifier_total, "", 1|4);
836 ex:;
837  Xorriso_destroy_node_array(xorriso, 0);
838  i= optc;
839  Sfile_destroy_argv(&i, &eff_src_array, 0);
840  i= optc;
841  Sfile_destroy_argv(&i, &eff_tgt_array, 0);
842  Xorriso_free_meM(source_prefix);
843  Xorriso_free_meM(target_prefix);
844  Xorriso_free_meM(eff_source);
845  Xorriso_free_meM(eff_target);
846  (*idx)= end_idx;
847  Xorriso_opt_args(xorriso, cmd, argc, argv, *idx, &end_idx, &optc, &optv, 256);
848  Xorriso_opt_args(xorriso, cmd, argc, argv, *idx, &end_idx, &opt2c, &opt2v,
849  256);
850  if(arg2c > 0)
851  Sfile_destroy_argv(&arg2c, &arg2v, 0);
852  else if(arg2v != NULL)
853  Xorriso_free_meM(arg2v);
854 
855  if(ret<=0)
856  return(ret);
857  return(!was_failure);
858 }
859 
860 
861 /* Option -mark */
862 int Xorriso_option_mark(struct XorrisO *xorriso, char *mark, int flag)
863 {
864  if(mark[0]==0)
865  xorriso->mark_text[0]= 0;
866  else
867  strncpy(xorriso->mark_text,mark,sizeof(xorriso->mark_text)-1);
868  xorriso->mark_text[sizeof(xorriso->mark_text)-1]= 0;
869  return(1);
870 }
871 
872 
873 /* Option -md5 "on"|"all"|"off" */
874 int Xorriso_option_md5(struct XorrisO *xorriso, char *mode, int flag)
875 {
876  char *npt, *cpt;
877  int l;
878 
879  npt= cpt= mode;
880  for(; npt!=NULL; cpt= npt+1) {
881  npt= strchr(cpt,':');
882  if(npt==NULL)
883  l= strlen(cpt);
884  else
885  l= npt-cpt;
886  if(l == 0)
887  continue;
888  if(l == 3 && strncmp(cpt, "off", l) == 0)
889  xorriso->do_md5&= ~31;
890  else if(l == 2 && strncmp(cpt, "on", l) == 0)
891  xorriso->do_md5= (xorriso->do_md5 & ~31) | 7 | 16;
892  else if(l == 3 && strncmp(cpt, "all", l) == 0)
893  xorriso->do_md5|= 31;
894  else if(l == 18 && strncmp(cpt, "stability_check_on", l) == 0)
895  xorriso->do_md5|= 8;
896  else if(l == 19 && strncmp(cpt, "stability_check_off", l) == 0)
897  xorriso->do_md5&= ~8;
898  else if(l == 13 && strncmp(cpt, "load_check_on", l) == 0)
899  xorriso->do_md5&= ~32;
900  else if(l == 14 && strncmp(cpt, "load_check_off", l) == 0)
901  xorriso->do_md5|= 32;
902  else {
903  sprintf(xorriso->info_text, "-md5: unknown mode ");
904  Text_shellsafe(cpt, xorriso->info_text, 1);
905  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
906  return(0);
907  }
908  }
909  return(1);
910 }
911 
912 
913 /* Option -mkdir alias -mkdiri */
914 int Xorriso_option_mkdiri(struct XorrisO *xorriso, int argc, char **argv,
915  int *idx, int flag)
916 {
917  int i, end_idx, ret, was_failure= 0, fret;
918 
919  end_idx= Xorriso_end_idx(xorriso, argc, argv, *idx, 0);
920 
921  for(i= *idx; i<end_idx; i++) {
922  ret= Xorriso_mkdir(xorriso, argv[i], 0);
923  if(ret>0 && !xorriso->request_to_abort)
924  continue; /* regular bottom of loop */
925  was_failure= 1;
926  fret= Xorriso_eval_problem_status(xorriso, ret, 1|2);
927  if(fret>=0)
928  continue;
929  goto ex;
930  }
931  ret= 1;
932 ex:;
933  (*idx)= end_idx;
934  if(ret<=0)
935  return(ret);
936  return(!was_failure);
937 }
938 
939 
940 int Xorriso_option_modesty_on_drive(struct XorrisO *xorriso, char *mode,
941  int flag)
942 {
943  char *npt, *cpt, *ppt;
944  int l, num, set_min;
945 
946  npt= cpt= mode;
947  for(; npt!=NULL; cpt= npt+1) {
948  npt= strchr(cpt,':');
949  if(npt==NULL)
950  l= strlen(cpt);
951  else
952  l= npt-cpt;
953  if(l == 0)
954  continue;
955  if(l == 3 && strncmp(cpt, "off", l) == 0) {
956  xorriso->modesty_on_drive= 0;
957  } else if(l == 1 && strncmp(cpt, "0", l) == 0) {
958  xorriso->modesty_on_drive= 0;
959  } else if(l == 2 && strncmp(cpt, "on", l) == 0) {
960  xorriso->modesty_on_drive= 1;
961  } else if(l == 1 && strncmp(cpt, "1", l) == 0) {
962  xorriso->modesty_on_drive= 1;
963  } else if(l == 2 && strncmp(cpt, "-1", l) == 0) {
964  ;
965  } else if(*cpt >= '1' && *cpt <= '9') {
966  ppt= cpt;
967  set_min= 2;
968 set_size_percent:;
969  sscanf(ppt, "%d", &num);
970  if(num == -1) {
971  ;
972  } else if(num < 25) {
973 bad_percent:;
974  sprintf(xorriso->info_text, "-modesty_on_drive: percentage out of range [25 to 100]");
975  Text_shellsafe(cpt, xorriso->info_text, 1);
976  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
977  return(0);
978  } else if(num > 100) {
979  goto bad_percent;
980  }
981  if(set_min == 2) {
982  xorriso->modesty_on_drive= 1;
983  }
984  if(set_min)
985  xorriso->min_buffer_percent= num;
986  else
987  xorriso->max_buffer_percent= num;
988  } else if(l >= 12 && strncmp(cpt, "min_percent=", 12) == 0) {
989  ppt= cpt + 12;
990  set_min= 1;
991  goto set_size_percent;
992  } else if(l >= 12 && strncmp(cpt, "max_percent=", 12) == 0) {
993  ppt= cpt + 12;
994  set_min= 0;
995  goto set_size_percent;
996  } else if(l >= 9 && strncmp(cpt, "min_usec=", 9) == 0) {
997  ppt= cpt + 9;
998  set_min= 1;
999 set_sec:;
1000  num= -1;
1001  sscanf(ppt, "%d", &num);
1002  if(num < 0)
1003  num= 0;
1004  if(set_min == 2)
1005  xorriso->max_buffer_usec= num;
1006  else if(set_min == 1)
1007  xorriso->min_buffer_usec= num;
1008  else if(set_min == 0)
1009  xorriso->max_buffer_percent= num;
1010  else
1011  xorriso->buffer_timeout_sec= num;
1012  } else if(l >= 9 && strncmp(cpt, "max_usec=", 9) == 0) {
1013  ppt= cpt + 9;
1014  set_min= 2;
1015  goto set_sec;
1016  } else if(l >= 12 && strncmp(cpt, "timeout_sec=", 12) == 0) {
1017  ppt= cpt + 12;
1018  set_min= -1;
1019  goto set_sec;
1020  } else {
1021  sprintf(xorriso->info_text, "-modesty_on_drive: unknown mode ");
1022  Text_shellsafe(cpt, xorriso->info_text, 1);
1023  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
1024  return(0);
1025  }
1026  }
1027  return(1);
1028 }
1029 
1030 
1031 /* Options -mount , -mount_cmd , -session_string */
1032 /* @param bit0= -mount_cmd: print mount command to result channel rather
1033  than performing it
1034  bit1= perform -session_string rather than -mount_cmd
1035 */
1036 int Xorriso_option_mount(struct XorrisO *xorriso, char *dev, char *adr_mode,
1037  char *adr, char *cmd, int flag)
1038 {
1039  int ret, entity_code= 0, m_flag;
1040  char entity_id[81], *mnt;
1041 
1042  if(flag & 1)
1043  mnt= "-mount_cmd";
1044  else if(flag & 2)
1045  mnt= "-session_string";
1046  else {
1047  mnt= "-mount";
1048  if(xorriso->allow_restore <= 0) {
1049  sprintf(xorriso->info_text,
1050  "-mount: image-to-disk features are not enabled by option -osirrox");
1051  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
1052  return(0);
1053  }
1054  if(Xorriso_change_is_pending(xorriso, 0)) {
1055  sprintf(xorriso->info_text,
1056  "%s: Image changes pending. -commit or -rollback first", mnt);
1057  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
1058  return(0);
1059  }
1060  }
1061  ret= Xorriso_decode_load_adr(xorriso, mnt, adr_mode, adr,
1062  &entity_code, entity_id, 0);
1063  if(ret <= 0)
1064  return(ret);
1065  if(flag & 2)
1066  m_flag= 1 | 4;
1067  else
1068  m_flag= (flag & 1) | 2;
1069  ret= Xorriso_mount(xorriso, dev, entity_code, entity_id, cmd, m_flag);
1070  return(ret);
1071 }
1072 
1073 
1074 /* Option -mount_opts option[:...] */
1075 int Xorriso_option_mount_opts(struct XorrisO *xorriso, char *mode, int flag)
1076 {
1077  int was, l;
1078  char *cpt, *npt;
1079 
1080  was= xorriso->mount_opts_flag;
1081  npt= cpt= mode;
1082  for(cpt= mode; npt!=NULL; cpt= npt+1) {
1083  npt= strchr(cpt,':');
1084  if(npt==NULL)
1085  l= strlen(cpt);
1086  else
1087  l= npt-cpt;
1088  if(l==0)
1089  goto unknown_mode;
1090  if(strncmp(cpt, "shared", l)==0) {
1091  xorriso->mount_opts_flag|= 1;
1092  } else if(strncmp(cpt, "exclusive", l)==0) {
1093  xorriso->mount_opts_flag&= ~1;
1094  } else {
1095 unknown_mode:;
1096  if(l<SfileadrL)
1097  sprintf(xorriso->info_text, "-mount_opts: unknown option '%s'", cpt);
1098  else
1099  sprintf(xorriso->info_text, "-mount_opts: oversized parameter (%d)",l);
1100  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
1101  xorriso->mount_opts_flag= was;
1102  return(0);
1103  }
1104  }
1105  return(1);
1106 }
1107 
1108 
1109 /* Command -move */
1110 int Xorriso_option_move(struct XorrisO *xorriso, char *origin, char *dest,
1111  int flag)
1112 {
1113  int ret;
1114  char *eff_origin= NULL, *eff_dest= NULL;
1115 
1116  Xorriso_alloc_meM(eff_origin, char, SfileadrL);
1117  Xorriso_alloc_meM(eff_dest, char, SfileadrL);
1118 
1119  ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, origin, eff_origin, 0);
1120  if(ret <= 0)
1121  {ret= 0; goto ex;}
1122  ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, dest, eff_dest, 2);
1123  if(ret < 0)
1124  {ret= 0; goto ex;}
1125  ret= Xorriso_rename(xorriso, NULL, eff_origin, eff_dest, 0);
1126  if(ret <= 0)
1127  goto ex;
1128  ret= 1;
1129 ex:;
1130  Xorriso_free_meM(eff_origin);
1131  Xorriso_free_meM(eff_dest);
1132  return(ret);
1133 }
1134 
1135 
1136 /* Command -msg_op */
1137 int Xorriso_option_msg_op(struct XorrisO *xorriso, char *what, char *arg,
1138  int flag)
1139 {
1140  int ret, available, argc, pargc, i, pflag, max_words, input_lines, msd_mem;
1141  char **argv= NULL, **pargv= NULL, *msg= "";
1142  char *prefix, *separators;
1143 
1144  msd_mem= xorriso->msg_sieve_disabled;
1145 
1146  ret= 1;
1147  if(strcmp(what, "parse") == 0 || strcmp(what, "parse_silently") == 0 ||
1148  strcmp(what, "parse_bulk") == 0 ||
1149  strcmp(what, "parse_bulk_silently") == 0) {
1150  ret= Xorriso_parse_line(xorriso, arg, "", "", 5, &argc, &argv, 0);
1151  prefix= "";
1152  if(argc > 0)
1153  prefix= argv[0];
1154  separators= "";
1155  if(argc > 1)
1156  separators= argv[1];
1157  max_words= 0;
1158  if(argc > 2)
1159  sscanf(argv[2], "%d", &max_words);
1160  pflag= 0;
1161  if(argc > 3)
1162  sscanf(argv[3], "%d", &pflag);
1163  input_lines= 1;
1164  if(argc > 4)
1165  sscanf(argv[4], "%d", &input_lines);
1166  if(strcmp(what, "parse") == 0 || strcmp(what, "parse_silently") == 0) {
1167  ret= Xorriso_msg_op_parse(xorriso, "", prefix, separators,
1168  max_words, pflag, input_lines,
1169  (strcmp(what, "parse_silently") == 0));
1170  } else {
1171  ret= Xorriso_msg_op_parse_bulk(xorriso, prefix, separators,
1172  max_words, pflag, input_lines,
1173  (strcmp(what, "parse_bulk_silently") == 0));
1174  }
1175  if(ret <= 0)
1176  goto ex;
1177  xorriso->msg_sieve_disabled= msd_mem;
1178  Xorriso__dispose_words(&argc, &argv);
1179  } else if(strcmp(what, "start_sieve") == 0) {
1180  Xorriso_sieve_dispose(xorriso, 0);
1181  ret= Xorriso_sieve_big(xorriso, 0);
1182  msg= "Message sieve enabled";
1183 
1184 /* >>> } else if(strcmp(what, "add_filter_rule") == 0) { */;
1185 
1186  } else if(strcmp(what, "clear_sieve") == 0) {
1187  ret= Xorriso_sieve_clear_results(xorriso, 0);
1188  msg= "Recorded message sieve results disposed";
1189  } else if(strcmp(what, "end_sieve") == 0) {
1190  ret= Xorriso_sieve_dispose(xorriso, 0);
1191  msg= "Message sieve disabled";
1192  } else if(strcmp(what, "read_sieve") == 0) {
1193  ret= Xorriso_sieve_get_result(xorriso, arg, &pargc, &pargv, &available, 0);
1194  xorriso->msg_sieve_disabled= 1;
1195  sprintf(xorriso->result_line, "%d\n", ret);
1196  Xorriso_result(xorriso, 1);
1197  if(ret > 0) {
1198  sprintf(xorriso->result_line, "%d\n", pargc);
1199  Xorriso_result(xorriso, 1);
1200  for(i= 0; i < pargc; i++) {
1201  ret= Sfile_count_char(pargv[i], '\n') + 1;
1202  sprintf(xorriso->result_line, "%d\n", ret);
1203  Xorriso_result(xorriso, 1);
1204  Sfile_str(xorriso->result_line, pargv[i], 0);
1205  strcat(xorriso->result_line, "\n");
1206  Xorriso_result(xorriso, 1);
1207  }
1208  } else {
1209  strcpy(xorriso->result_line, "0\n");
1210  Xorriso_result(xorriso, 1);
1211  available= 0;
1212  }
1213  sprintf(xorriso->result_line, "%d\n", available);
1214  Xorriso_result(xorriso, 1);
1215  xorriso->msg_sieve_disabled= msd_mem;
1216  Xorriso__dispose_words(&pargc, &pargv);
1217  ret= 1;
1218  } else if(strcmp(what, "show_sieve") == 0) {
1219  ret= Xorriso_sieve_get_result(xorriso, "", &pargc, &pargv, &available, 8);
1220  xorriso->msg_sieve_disabled= 1;
1221  sprintf(xorriso->result_line, "%d\n", ret);
1222  Xorriso_result(xorriso, 1);
1223  if(ret > 0) {
1224  sprintf(xorriso->result_line, "%d\n", pargc);
1225  Xorriso_result(xorriso, 1);
1226  for(i= 0; i < pargc; i++) {
1227  sprintf(xorriso->result_line, "%s\n", pargv[i]);
1228  Xorriso_result(xorriso, 1);
1229  }
1230  }
1231  xorriso->msg_sieve_disabled= msd_mem;
1232  Xorriso__dispose_words(&pargc, &pargv);
1233  } else if(strcmp(what, "compare_sev") == 0) {
1234  ret= Xorriso_parse_line(xorriso, arg, "", ",", 2, &argc, &argv, 0);
1235  if(argc < 2) {
1236  sprintf(xorriso->info_text,
1237  "-msg_op cmp_sev: malformed severity pair '%s'", arg);
1238  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
1239  } else {
1240  ret= Xorriso__severity_cmp(argv[0], argv[1]);
1241  sprintf(xorriso->result_line, "%d\n", ret);
1242  Xorriso_result(xorriso, 1);
1243  }
1244  Xorriso__dispose_words(&argc, &argv);
1245  } else if(strcmp(what, "list_sev") == 0) {
1246  sprintf(xorriso->result_line, "%s\n", Xorriso__severity_list(0));
1247  Xorriso_result(xorriso, 1);
1248  } else {
1249  sprintf(xorriso->info_text, "-msg_op: unknown operation '%s'", what);
1250  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
1251  ret= 0;
1252  }
1253  if(ret > 0 && msg[0])
1254  Xorriso_msgs_submit(xorriso, 0, msg, 0, "NOTE", 0);
1255 
1256 ex:;
1257  xorriso->msg_sieve_disabled= msd_mem;
1258  return(ret);
1259 }
1260 
1261 
1262 /* Option -mv alias -mvi */
1263 int Xorriso_option_mvi(struct XorrisO *xorriso, int argc, char **argv,
1264  int *idx, int flag)
1265 {
1266  int i, end_idx_dummy, ret, is_dir= 0, was_failure= 0, fret;
1267  char *eff_origin= NULL, *eff_dest= NULL, *dest_dir= NULL;
1268  char *leafname= NULL;
1269  int optc= 0;
1270  char **optv= NULL;
1271 
1272  Xorriso_alloc_meM(eff_origin, char, SfileadrL);
1273  Xorriso_alloc_meM(eff_dest, char, SfileadrL);
1274  Xorriso_alloc_meM(dest_dir, char, SfileadrL);
1275  Xorriso_alloc_meM(leafname, char, SfileadrL);
1276 
1277  ret= Xorriso_cpmv_args(xorriso, "-mvi", argc, argv, idx,
1278  &optc, &optv, eff_dest, 0);
1279  if(ret<=0)
1280  goto ex;
1281  if(ret==2) {
1282  is_dir= 1;
1283  strcpy(dest_dir, eff_dest);
1284  }
1285  /* Perform movements */
1286  for(i= 0; i<optc; i++) {
1287  ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi,optv[i],eff_origin,0);
1288  if(ret<=0 || xorriso->request_to_abort)
1289  goto problem_handler;
1290  if(is_dir) {
1291  ret= Sfile_leafname(eff_origin, leafname, 0);
1292  if(ret<=0)
1293  goto problem_handler;
1294  strcpy(eff_dest, dest_dir);
1295  ret= Sfile_add_to_path(eff_dest, leafname, 0);
1296  if(ret<=0) {
1297  sprintf(xorriso->info_text, "Effective path gets much too long (%d)",
1298  (int) (strlen(eff_dest)+strlen(leafname)+1));
1299  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
1300  goto problem_handler;
1301  }
1302  }
1303  ret= Xorriso_rename(xorriso, NULL, eff_origin, eff_dest, 0);
1304  if(ret<=0 || xorriso->request_to_abort)
1305  goto problem_handler;
1306  sprintf(xorriso->info_text, "Renamed in ISO image: ");
1307  Text_shellsafe(eff_origin, xorriso->info_text, 1);
1308  strcat(xorriso->info_text, " to ");
1309  Text_shellsafe(eff_dest, xorriso->info_text, 1 | 2);
1310  strcat(xorriso->info_text, "\n");
1311  Xorriso_info(xorriso, 0);
1312 
1313  continue; /* regular bottom of loop */
1314 problem_handler:;
1315  was_failure= 1;
1316  fret= Xorriso_eval_problem_status(xorriso, ret, 1|2);
1317  if(fret>=0)
1318  continue;
1319  goto ex;
1320  }
1321  ret= !was_failure;
1322 ex:;
1323  Xorriso_free_meM(eff_origin);
1324  Xorriso_free_meM(eff_dest);
1325  Xorriso_free_meM(dest_dir);
1326  Xorriso_free_meM(leafname);
1327  Xorriso_opt_args(xorriso, "-mvi",
1328  argc, argv, *idx, &end_idx_dummy, &optc, &optv, 256);
1329  return(ret);
1330 }
1331 
1332 
1333 /* Option -named_pipe_loop */
1334 int Xorriso_option_named_pipe_loop(struct XorrisO *xorriso, char *mode,
1335  char *stdin_pipe, char *stdout_pipe,
1336  char *stderr_pipe, int flag)
1337 {
1338  char *pipe_paths[3], *cpt, *npt;
1339  int ret, hflag= 0, l;
1340 
1341  npt= mode;
1342  for(cpt= mode; npt != NULL; cpt= npt + 1) {
1343  npt= strchr(cpt, ':');
1344  if(npt==NULL)
1345  l= strlen(cpt);
1346  else
1347  l= npt-cpt;
1348  if(l==0) {
1349  ;
1350  } else if(strncmp(cpt, "-", l) == 0) {
1351  ;
1352  } else if(strncmp(cpt, "cleanup", l) == 0) {
1353  hflag|= 1;
1354  } else if(strncmp(cpt, "keep", l) == 0) {
1355  hflag&= ~1;
1356  } else if(strncmp(cpt, "buffered", l) == 0) {
1357  hflag|= 2;
1358  } else if(strncmp(cpt, "direct", l) == 0) {
1359  hflag&= ~2;
1360  } else {
1361  sprintf(xorriso->info_text, "-named_pipe_loop: unknown mode in '%s'",
1362  mode);
1363  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
1364  return(0);
1365  }
1366  }
1367  pipe_paths[0]= stdin_pipe;
1368  pipe_paths[1]= stdout_pipe;
1369  pipe_paths[2]= stderr_pipe;
1370  ret= Xorriso_named_pipe_loop(xorriso, pipe_paths, hflag);
1371  return(ret);
1372 }
1373 
1374 
1375 /* Option -no_rc */
1376 int Xorriso_option_no_rc(struct XorrisO *xorriso, int flag)
1377 {
1378  xorriso->no_rc= 1;
1379  return(1);
1380 }
1381 
1382 
1383 /* Option -not_leaf , (-hide_disk_leaf , -as mkisofs -hide) */
1384 /* @param flag bit0-bit5= hide rather than adding to disk_exclusions
1385  bit0= add to iso_rr_hidings
1386  bit1= add to joliet_hidings
1387  bit2= add to hfsplus_hidings
1388 */
1389 int Xorriso_option_not_leaf(struct XorrisO *xorriso, char *pattern, int flag)
1390 {
1391  regex_t re;
1392  char *regexpr= NULL;
1393  int ret= 0;
1394 
1395  Xorriso_alloc_meM(regexpr, char, 2 * SfileadrL + 2);
1396 
1397  if(pattern[0]==0)
1398  {ret= 0; goto cannot_add;}
1399  Xorriso__bourne_to_reg(pattern, regexpr, 0);
1400  if(regcomp(&re, regexpr, 0)!=0)
1401  {ret= 0; goto cannot_add;}
1402  if(flag & 63) {
1403  if(flag & 1) {
1404  ret= Exclusions_add_not_leafs(xorriso->iso_rr_hidings, pattern, &re, 0);
1405  if(ret<=0)
1406  goto cannot_add;
1407  }
1408  if(flag & 2) {
1409  ret= Exclusions_add_not_leafs(xorriso->joliet_hidings, pattern, &re, 0);
1410  if(ret<=0)
1411  goto cannot_add;
1412  }
1413  if(flag & 4) {
1414  ret= Exclusions_add_not_leafs(xorriso->hfsplus_hidings, pattern, &re, 0);
1415  if(ret<=0)
1416  goto cannot_add;
1417  }
1418  } else {
1419  ret= Exclusions_add_not_leafs(xorriso->disk_exclusions, pattern, &re, 0);
1420  }
1421  if(ret<=0) {
1422 cannot_add:;
1423  sprintf(xorriso->info_text,"Cannot add pattern: %s ",
1424  (flag & 3) ? "-hide_disk_leaf" : "-not_leaf");
1425  Text_shellsafe(pattern, xorriso->info_text, 1);
1426  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
1427  goto ex;
1428  }
1429  ret= 1;
1430 ex:;
1431  Xorriso_free_meM(regexpr);
1432  return(ret);
1433 }
1434 
1435 
1436 /* Option -not_list , -quoted_not_list */
1437 /* @param flag bit0= -quoted_not_list */
1438 int Xorriso_option_not_list(struct XorrisO *xorriso, char *adr, int flag)
1439 {
1440  int ret, linecount= 0, insertcount= 0, null= 0, argc= 0, i;
1441  FILE *fp= NULL;
1442  char **argv= NULL;
1443 
1444  Xorriso_pacifier_reset(xorriso, 0);
1445  if(adr[0]==0) {
1446  sprintf(xorriso->info_text, "Empty file name given with %s",
1447  (flag & 1) ? "-quoted_not_list" : "-not_list");
1448  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
1449  return(0);
1450  }
1451  ret= Xorriso_afile_fopen(xorriso, adr, "rb", &fp, 0);
1452  if(ret <= 0)
1453  return(0);
1454  while(1) {
1455  ret= Xorriso_read_lines(xorriso, fp, &linecount, &argc, &argv,
1456  4 | (flag & 1) );
1457  if(ret <= 0)
1458  goto ex;
1459  if(ret == 2)
1460  break;
1461  for(i= 0; i < argc; i++) {
1462  if(argv[i][0] == 0)
1463  continue;
1464  if(strchr(argv[i], '/')!=NULL) {
1465  null= 0;
1466  ret= Xorriso_option_not_paths(xorriso, 1, argv + i, &null, 0);
1467  } else
1468  ret= Xorriso_option_not_leaf(xorriso, argv[i], 0);
1469  if(ret<=0)
1470  goto ex;
1471  insertcount++;
1472  }
1473  }
1474  ret= 1;
1475 ex:;
1476  Xorriso_read_lines(xorriso, fp, &linecount, &argc, &argv, 2);
1477  if(fp != NULL && fp != stdin)
1478  fclose(fp);
1479  if(ret<=0) {
1480  sprintf(xorriso->info_text, "Aborted reading of file ");
1481  Text_shellsafe(adr, xorriso->info_text, 1);
1482  sprintf(xorriso->info_text + strlen(xorriso->info_text),
1483  " in line number %d", linecount);
1484  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
1485  }
1486  sprintf(xorriso->info_text, "Added %d exclusion list items from file ",
1487  insertcount);
1488  Text_shellsafe(adr, xorriso->info_text, 1);
1489  strcat(xorriso->info_text, "\n");
1490  Xorriso_info(xorriso,0);
1491  return(ret);
1492 }
1493 
1494 
1495 /* Option -not_mgt */
1496 int Xorriso_option_not_mgt(struct XorrisO *xorriso, char *setting, int flag)
1497 {
1498  int ret;
1499  char *what_data= NULL, *what, *what_next;
1500 
1501  Xorriso_alloc_meM(what_data, char, SfileadrL);
1502 
1503  if(Sfile_str(what_data, setting, 0)<=0) {
1504  sprintf(xorriso->info_text,
1505  "-not_mgt: setting string is much too long (%d)",
1506  (int) strlen(setting));
1507  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
1508  {ret= 0; goto ex;}
1509  }
1510  for(what= what_data; what!=NULL; what= what_next) {
1511  what_next= strchr(what, ':');
1512  if(what_next!=NULL) {
1513  *what_next= 0;
1514  what_next++;
1515  }
1516 
1517  if(strcmp(what, "reset")==0 || strcmp(what, "erase")==0) {
1518  if(strcmp(what, "reset")==0)
1519  xorriso->disk_excl_mode= 1;
1520  Exclusions_destroy(&(xorriso->disk_exclusions), 0);
1521  ret= Exclusions_new(&(xorriso->disk_exclusions), 0);
1522  if(ret<=0) {
1523  Xorriso_no_malloc_memory(xorriso, NULL, 0);
1524  goto ex;
1525  }
1526  } else if(strcmp(what, "on")==0) {
1527  xorriso->disk_excl_mode|= 1;
1528  } else if(strcmp(what, "off")==0) {
1529  xorriso->disk_excl_mode&= ~1;
1530  } else if(strcmp(what, "param_on")==0) {
1531  xorriso->disk_excl_mode|= 2;
1532  } else if(strcmp(what, "param_off")==0) {
1533  xorriso->disk_excl_mode&= ~2;
1534  } else if(strcmp(what, "subtree_on")==0) {
1535  xorriso->disk_excl_mode|= 4;
1536  } else if(strcmp(what, "subtree_off")==0) {
1537  xorriso->disk_excl_mode&= ~4;
1538  } else if(strcmp(what, "ignore_on")==0) {
1539  xorriso->disk_excl_mode|= 8;
1540  } else if(strcmp(what, "ignore_off")==0) {
1541  xorriso->disk_excl_mode&= ~8;
1542  } else {
1543  sprintf(xorriso->info_text, "-not_mgt: unknown setting '%s'", what);
1544  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
1545  {ret= 0; goto ex;}
1546  }
1547  }
1548  ret= 1;
1549 ex:;
1550  Xorriso_free_meM(what_data);
1551  return(ret);
1552 }
1553 
1554 
1555 /* Option -not_paths , (-hide_disk_paths , -as mkisofs -hide) */
1556 /* @param flag bit0= add to iso_rr_hidings rather than disk_exclusions
1557  bit1= add to joliet_hidings rather than disk_exclusions
1558  bit2= enable disk pattern expansion regardless of -disk_pattern
1559  bit8-13= consolidated hide state bits, duplicating bit0-1
1560  bit8= add to iso_rr_hidings
1561  bit9= add to joliet_hidings
1562  bit10= add to hfsplus_hidings
1563 */
1564 int Xorriso_option_not_paths(struct XorrisO *xorriso, int argc, char **argv,
1565  int *idx, int flag)
1566 {
1567  int ret, end_idx, num_descr= 0, dummy, optc= 0, i;
1568  char **descr= NULL, **optv= NULL, *eff_path= NULL, *hpt= NULL;
1569 
1570  end_idx= Xorriso_end_idx(xorriso, argc, argv, *idx,
1571  (xorriso->do_disk_pattern == 1 || (flag & 4)) | 2);
1572  if(end_idx<=0)
1573  {ret= end_idx; goto ex;}
1574 
1575  num_descr= end_idx - *idx;
1576  if(num_descr<=0)
1577  {ret= 1; goto ex;}
1578 
1579  /* produce absolute patterns */
1580  Xorriso_alloc_meM(eff_path, char, SfileadrL);
1581  descr= TSOB_FELD(char *, num_descr);
1582  if(descr==NULL) {
1583 no_memory:;
1584  Xorriso_no_pattern_memory(xorriso, sizeof(char *) * (off_t) num_descr, 0);
1585  ret= -1; goto ex;
1586  }
1587  for(i= 0; i<num_descr; i++)
1588  descr[i]= NULL;
1589  for(i= 0; i<num_descr; i++) {
1590  ret= Xorriso_normalize_img_path(xorriso, xorriso->wdx, argv[i+*idx],
1591  eff_path, 2|4);
1592  if(ret<=0)
1593  goto ex;
1594  descr[i]= strdup(eff_path);
1595  if(descr[i]==NULL)
1596  goto no_memory;
1597  }
1598 
1599  ret= Xorriso_opt_args(xorriso,
1600  (flag & 0x3f03) ? "-hide_disk_paths" : "-not_paths",
1601  num_descr, descr, 0, &dummy, &optc, &optv,
1602  2 | ((flag & 4) << 7));
1603  if(ret<=0)
1604  goto ex;
1605  if(flag & 0x3f03) {
1606  if(flag & 0x0101) {
1608  num_descr, descr, optc, optv, 0);
1609  if(ret<=0) {
1610 no_hide:;
1611  sprintf(xorriso->info_text, "Cannot add path list: -hide_disk_paths ");
1612  hpt= Xorriso__hide_mode_text(flag & 0x3f03, 0);
1613  if(hpt != NULL)
1614  sprintf(xorriso->info_text + strlen(xorriso->info_text), "%s ", hpt);
1615  Xorriso_free_meM(hpt);
1616  Text_shellsafe(argv[*idx], xorriso->info_text, 1);
1617  strcat(xorriso->info_text, num_descr > 1 ? " ... " : " ");
1618  strcat(xorriso->info_text, xorriso->list_delimiter);
1619  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
1620  goto ex;
1621  }
1622  }
1623  if(flag & 0x0202) {
1625  num_descr, descr, optc, optv, 0);
1626  if(ret<=0)
1627  goto no_hide;
1628  }
1629  if(flag & 0x0400) {
1631  num_descr, descr, optc, optv, 0);
1632  if(ret<=0)
1633  goto no_hide;
1634  }
1635  } else {
1637  num_descr, descr, optc, optv, 0);
1638  if(ret<=0) {
1639  sprintf(xorriso->info_text,"Cannot add path list: -not_paths ");
1640  Text_shellsafe(argv[*idx], xorriso->info_text, 1);
1641  strcat(xorriso->info_text, num_descr > 1 ? " ... " : " ");
1642  strcat(xorriso->info_text, xorriso->list_delimiter);
1643  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
1644  }
1645  }
1646 ex:;
1647  (*idx)= end_idx;
1648  Xorriso_opt_args(xorriso, "-not_paths",
1649  num_descr, descr, 0, &dummy, &optc, &optv, 256);
1650  if(descr!=NULL) {
1651  for(i= 0; i<num_descr; i++)
1652  if(descr[i]!=NULL)
1653  free(descr[i]);
1654  free((char *) descr);
1655  descr= NULL;
1656  }
1657  Xorriso_free_meM(eff_path);
1658  return(ret);
1659 }
1660 
1661 
1662 /* Option -options_from_file */
1663 int Xorriso_option_options_from_file(struct XorrisO *xorriso, char *adr,
1664  int flag)
1665 /*
1666  bit0= called from Xorriso_prescan_args,
1667  therefore execute via that same function
1668 */
1669 /*
1670 return:
1671  <=0 error , 1 = success , 3 = end program run
1672 */
1673 {
1674  int ret,linecount= 0, argc= 0, was_failure= 0, fret;
1675  FILE *fp= NULL;
1676  char **argv= NULL;
1677  int linec= 0;
1678  char *line= NULL, **linev= NULL;
1679 
1680  if(adr[0]==0) {
1681  sprintf(xorriso->info_text,"Empty file name given with -options_from_file");
1682  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
1683  return(0);
1684  }
1685  if(xorriso->is_dialog) {
1686  sprintf(xorriso->info_text,"+ performing command lines from file ");
1687  Text_shellsafe(adr, xorriso->info_text, 1);
1688  strcat(xorriso->info_text, " :\n");
1689  Xorriso_info(xorriso,1);
1690  }
1691  ret= Xorriso_afile_fopen(xorriso, adr, "rb", &fp, 0);
1692  if(ret <= 0)
1693  return(0);
1694  sprintf(xorriso->info_text, "Command file: ");
1695  Text_shellsafe(adr, xorriso->info_text, 1);
1696  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
1697  while(1) {
1698  ret= Xorriso_read_lines(xorriso, fp, &linecount, &linec, &linev, 1 | 8);
1699  if(ret <= 0)
1700  goto ex; /* no problem_handler because there is no sense in going on */
1701  if(ret == 2)
1702  break;
1703  line= linev[0];
1704  if(line[0]==0 || line[0]=='#')
1705  continue;
1706 
1707  if(flag&1) {
1708  ret= Sfile_make_argv(xorriso->progname, line, &argc, &argv,
1709  4 | 8 | ((xorriso->bsl_interpretation & 3) << 5));
1710  if(ret<=0)
1711  goto problem_handler;
1712  ret= Xorriso_prescan_args(xorriso,argc,argv,1);
1713  if(ret==0)
1714  {ret= 3; goto ex;}
1715  if(ret<0)
1716  goto problem_handler;
1717  } else {
1718  if(xorriso->is_dialog) {
1719  sprintf(xorriso->info_text,"+ %d: %s\n",linecount,line);
1720  Xorriso_info(xorriso,1);
1721  }
1722  ret= Xorriso_execute_option(xorriso,line,1|(1<<16));
1723  if(ret==3)
1724  goto ex;
1725  if(ret<=0)
1726  goto problem_handler;
1727  }
1728 
1729  continue; /* regular bottom of loop */
1730 problem_handler:;
1731  was_failure= 1;
1732  fret= Xorriso_eval_problem_status(xorriso, ret, 1);
1733  if(fret>=0)
1734  continue;
1735  goto ex;
1736  }
1737  ret= 1;
1738 ex:;
1739  Sfile_make_argv("", "", &argc, &argv, 2); /* release memory */
1740  Xorriso_read_lines(xorriso, fp, &linecount, &linec, &linev, 2);
1741  Xorriso_reset_counters(xorriso,0);
1742  if(fp != NULL && fp != stdin)
1743  fclose(fp);
1744  if(ret<=0) {
1745  sprintf(xorriso->info_text,
1746  "error triggered by line %d of file:\n ", linecount);
1747  Text_shellsafe(adr, xorriso->info_text, 1);
1748  strcat(xorriso->info_text, "\n");
1749  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 1);
1750  }
1751  sprintf(xorriso->info_text, "Command file end: ");
1752  Text_shellsafe(adr, xorriso->info_text, 1);
1753  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
1754  if(ret!=1)
1755  return(ret);
1756  return(!was_failure);
1757 }
1758 
1759 
1760 /* Option -osirrox "on"|"off" */
1761 int Xorriso_option_osirrox(struct XorrisO *xorriso, char *mode, int flag)
1762 {
1763  int l, allow_restore;
1764  char *npt, *cpt;
1765  double num= 0.0;
1766 
1767  allow_restore= xorriso->allow_restore;
1768 
1769  npt= cpt= mode;
1770  for(cpt= mode; npt!=NULL; cpt= npt+1) {
1771  npt= strchr(cpt,':');
1772  if(npt==NULL)
1773  l= strlen(cpt);
1774  else
1775  l= npt-cpt;
1776  if(l==0 && mode[0]!=0)
1777  goto unknown_mode;
1778  if(strncmp(cpt, "off", l)==0 && l >= 3)
1779  allow_restore= 0;
1780  else if(strncmp(cpt, "banned", l)==0 && l >= 5)
1781  allow_restore= -1;
1782  else if(strncmp(cpt, "blocked", l)==0 && l >= 7)
1783  allow_restore= -2;
1784  else if(strncmp(cpt, "unblock", l)==0 && l >= 7) {
1785  if(xorriso->allow_restore == -2)
1786  xorriso->allow_restore= 0;
1787  allow_restore= 1;
1788  } else if(strncmp(cpt, "device_files", l)==0 && l >= 12)
1789  allow_restore= 2;
1790  else if((strncmp(cpt, "on", l)==0 && l >= 2) || mode[0]==0)
1791  allow_restore= 1;
1792  else if(strncmp(cpt, "concat_split_on", l)==0 && l >= 15)
1793  xorriso->do_concat_split= 1;
1794  else if(strncmp(cpt, "concat_split_off", l)==0 && l >= 16)
1795  xorriso->do_concat_split= 0;
1796  else if(strncmp(cpt, "auto_chmod_on", l)==0 && l >= 13)
1797  xorriso->do_auto_chmod= 1;
1798  else if(strncmp(cpt, "auto_chmod_off", l)==0 && l >= 14)
1799  xorriso->do_auto_chmod= 0;
1800  else if(strncmp(cpt, "sort_lba_on", l)==0 && l >= 11)
1801  xorriso->do_restore_sort_lba= 1;
1802  else if(strncmp(cpt, "sort_lba_off", l)==0 && l >= 12)
1803  xorriso->do_restore_sort_lba= 0;
1804  else if(strncmp(cpt, "o_excl_on", l)==0 && l >= 9)
1805  xorriso->drives_exclusive= 1;
1806  else if(strncmp(cpt, "o_excl_off", l)==0 && l >= 10)
1807  xorriso->drives_exclusive= 0;
1808  else if(strncmp(cpt, "strict_acl_on", l)==0 && l >= 13)
1809  xorriso->do_strict_acl|= 1;
1810  else if(strncmp(cpt, "strict_acl_off", l)==0 && l >= 14)
1811  xorriso->do_strict_acl&= ~1;
1812  else if(strncmp(cpt, "check_md5_on", l) == 0 && l >= 12) {
1813  xorriso->do_md5|= 1 << 6;
1814  xorriso->do_md5&= ~(2 << 6);
1815  } else if(strncmp(cpt, "check_md5_force", l)==0 && l >= 15) {
1816  xorriso->do_md5|= 3 << 6;
1817  } else if(strncmp(cpt, "check_md5_off", l)==0 && l >= 13) {
1818  xorriso->do_md5&= ~(3 << 6);
1819  } else if(strncmp(cpt, "sparse=", 7) == 0 && l >= 7) {
1820  if(strncmp(cpt + 7, "off", 3) == 0 && l == 10) {
1821  num= 0.0;
1822  } else {
1823  Xorriso__parse_size_param(cpt, 7, l, &num);
1824  if(num < 1.0)
1825  num= 0.0;
1826  if(num > 1.0 * 1024.0 * 1024.0 * 1024.0) {
1827  strcpy(xorriso->info_text,
1828  "osirrox sparse= too large (allowed: off, 1 to 1g)");
1829  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
1830  return(0);
1831  }
1832  }
1833  xorriso->sparse_min_gap= num;
1834  } else {
1835 unknown_mode:;
1836  sprintf(xorriso->info_text, "-osirrox: unknown mode '%s'", cpt);
1837  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
1838  return(0);
1839  }
1840  }
1841  if(allow_restore > 0 && xorriso->allow_restore == -1) {
1842  sprintf(xorriso->info_text,
1843  "-osirrox: was already permanently disabled by setting 'banned'");
1844  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
1845  return(0);
1846  }
1847  if(allow_restore > 0 && xorriso->allow_restore == -2) {
1848  sprintf(xorriso->info_text,
1849  "-osirrox: is currently disabled by setting 'blocked'");
1850  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
1851  return(0);
1852  }
1853  if(xorriso->allow_restore != -1)
1854  xorriso->allow_restore= allow_restore;
1855  sprintf(xorriso->info_text,
1856  "Copying of file objects from ISO image to disk filesystem is: %s\n",
1857  xorriso->allow_restore > 0 ? "Enabled" : "Disabled");
1858  Xorriso_info(xorriso, 0);
1859  return(1);
1860 }
1861 
1862 
1863 /* Option -overwrite "on"|"nondir"|"off" */
1864 int Xorriso_option_overwrite(struct XorrisO *xorriso, char *mode, int flag)
1865 {
1866  if(strcmp(mode, "off")==0)
1867  xorriso->do_overwrite= 0;
1868  else if(strcmp(mode, "on")==0)
1869  xorriso->do_overwrite= 1;
1870  else if(strcmp(mode, "nondir")==0)
1871  xorriso->do_overwrite= 2;
1872  else {
1873  sprintf(xorriso->info_text, "-overwrite: unknown mode '%s'", mode);
1874  Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
1875  return(0);
1876  }
1877  return(1);
1878 }
1879 
1880 
int Exclusions_add_not_leafs(struct ExclusionS *o, char *not_leafs_descr, regex_t *re, int flag)
Definition: aux_objects.c:764
int Exclusions_add_not_paths(struct ExclusionS *o, int descrc, char **descrs, int pathc, char **paths, int flag)
Definition: aux_objects.c:730
int Exclusions_destroy(struct ExclusionS **o, int flag)
Definition: aux_objects.c:710
int Exclusions_new(struct ExclusionS **o, int flag)
Definition: aux_objects.c:695
int Xorriso_lst_append_binary(struct Xorriso_lsT **entry, char *data, int data_len, int flag)
Create a new list item at the end of a given list.
Definition: aux_objects.c:609
int Xorriso_destroy_node_array(struct XorrisO *xorriso, int flag)
Definition: base_obj.c:656
int Xorriso_afile_fopen(struct XorrisO *xorriso, char *filename, char *mode, FILE **ret_fp, int flag)
Definition: disk_ops.c:1780
int Xorriso_lsx_filev(struct XorrisO *xorriso, char *wd, int filec, char **filev, off_t boss_mem, int flag)
Definition: disk_ops.c:809
int Xorriso_restore_sorted(struct XorrisO *xorriso, int count, char **src_array, char **tgt_array, int *problem_count, int flag)
Definition: disk_ops.c:1427
int Xorriso_list_formats(struct XorrisO *xorriso, int flag)
Definition: drive_mgt.c:1653
int Xorriso_list_profiles(struct XorrisO *xorriso, int flag)
Definition: drive_mgt.c:2017
int Xorriso_toc(struct XorrisO *xorriso, int flag)
Definition: drive_mgt.c:1033
int Xorriso_list_speeds(struct XorrisO *xorriso, int flag)
Definition: drive_mgt.c:1984
static int Sfile_destroy_argv(int *argc, char ***argv, int flag)
#define SfileadrL
int Xorriso_change_is_pending(struct XorrisO *xorriso, int flag)
Definition: iso_img.c:995
int Xorriso_mount(struct XorrisO *xorriso, char *dev, int adr_mode, char *adr_value, char *cmd, int flag)
Definition: iso_img.c:1027
int Xorriso_rename(struct XorrisO *xorriso, void *boss_iter, char *origin, char *dest, int flag)
Definition: iso_manip.c:1635
int Xorriso_graft_in(struct XorrisO *xorriso, void *boss_iter, char *disk_path, char *img_path, off_t offset, off_t cut_size, int flag)
Definition: iso_manip.c:789
int Xorriso_mkdir(struct XorrisO *xorriso, char *path, int flag)
Definition: iso_manip.c:1306
int Xorriso_iso_lstat(struct XorrisO *xorriso, char *path, struct stat *stbuf, int flag)
Definition: iso_tree.c:363
int Xorriso_truncate_path_comps(struct XorrisO *xorriso, char *path, char *buffer, char **resultpt, int flag)
Definition: iso_tree.c:1640
int Xorriso_ls_filev(struct XorrisO *xorriso, char *wd, int filec, char **filev, off_t boss_mem, int flag)
Definition: iso_tree.c:1724
int Xorriso_ls(struct XorrisO *xorriso, int flag)
Definition: iso_tree.c:1903
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_list_extras(struct XorrisO *xorriso, char *mode, int flag)
Definition: lib_mgt.c:905
int Xorriso_set_libisofs_now(struct XorrisO *xorriso, int flag)
Definition: lib_mgt.c:1031
char * Xorriso__severity_list(int flag)
Return a blank separated list of severity names.
Definition: lib_mgt.c:420
int Xorriso_jigdo_interpreter(struct XorrisO *xorriso, char *aspect, char *arg, int flag)
Definition: lib_mgt.c:735
int Xorriso__severity_cmp(char *sev1, char *sev2)
Compare two severity texts for their severeness.
Definition: lib_mgt.c:401
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_no_pattern_memory(struct XorrisO *xorriso, off_t mem, int flag)
Definition: match.c:596
int Xorriso__bourne_to_reg(char bourne_expr[], char reg_expr[], int flag)
Definition: misc_funct.c:1162
int Xorriso__parse_size_param(char *cpt, int key_l, int l, double *num)
Definition: misc_funct.c:1371
int Xorriso__exchange_prefix(char *source_prefix, char *target_prefix, char *eff_source, char *eff_target, int flag)
Definition: misc_funct.c:1318
char * Text_shellsafe(char *in_text, char *out_text, int flag)
Definition: misc_funct.c:1044
char * Xorriso__hide_mode_text(int hide_mode, int flag)
Definition: misc_funct.c:1273
int Xorriso_option_compare(struct XorrisO *xorriso, char *disk_path, char *iso_path, int flag)
Definition: opts_a_c.c:2258
int Xorriso_option_extract(struct XorrisO *xorriso, char *iso_path, char *disk_path, int flag)
Definition: opts_d_h.c:590
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_rollback(struct XorrisO *xorriso, int flag)
Definition: opts_p_z.c:677
int Xorriso_option_update(struct XorrisO *xorriso, char *disk_path, char *iso_path, int flag)
Definition: opts_p_z.c:1778
int Xorriso_cmd_sorting_rank(struct XorrisO *xorriso, int argc, char **argv, int idx, int flag)
Definition: parse_exec.c:663
int Xorriso_eval_problem_status(struct XorrisO *xorriso, int ret, int flag)
Evaluate an advise whether to abort or whether to go on with option processing.
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_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_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_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_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_prescan_args(struct XorrisO *xorriso, int argc, char **argv, int flag)
Definition: parse_exec.c:2251
void Xorriso__dispose_words(int *argc, char ***argv)
Definition: parse_exec.c:2120
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 Sfile_make_argv(char *progname, char *line, int *argc, char ***argv, int flag)
Definition: sfile.c:828
int Sfile_add_to_path(char path[4096], char *addon, int flag)
Definition: sfile.c:137
int Sfile_leafname(char *path, char leafname[4096], int flag)
Definition: sfile.c:116
int Sfile_str(char target[4096], char *source, int flag)
Definition: sfile.c:836
int Sfile_count_char(char *text, char to_count)
Definition: sfile.c:49
#define TSOB_FELD(typ, count)
Definition: sfile.h:15
#define Xorriso_free_meM(pt)
Definition: sfile.h:27
#define Xorriso_alloc_meM(pt, typ, count)
Definition: sfile.h:19
int Xorriso_make_di_array(struct XorrisO *xorriso, int flag)
Definition: sort_cmp.c:518
int Xorriso_make_hln_array(struct XorrisO *xorriso, int flag)
Definition: sort_cmp.c:476
int do_strict_acl
char list_delimiter[81]
off_t pacifier_count
struct ExclusionS * joliet_hidings
int do_iso_rr_pattern
int do_disk_pattern
struct Xorriso_lsT * node_img_prefixes
time_t now_time_override
struct ExclusionS * disk_exclusions
int modesty_on_drive
int bsl_interpretation
int allow_restore
off_t sparse_min_gap
char progname[4096]
struct Xorriso_lsT * node_disk_prefixes
char indev[4096]
void ** di_array
int ino_behavior
int do_overwrite
int image_start_mode
int min_buffer_percent
char result_line[10 *4096]
struct ExclusionS * iso_rr_hidings
int do_auto_chmod
int drives_exclusive
int do_restore_sort_lba
char info_text[10 *4096]
int max_buffer_usec
struct ExclusionS * hfsplus_hidings
int do_concat_split
char logfile[4][4096]
int min_buffer_usec
int mount_opts_flag
int buffer_timeout_sec
int do_override_now_time
int request_to_abort
char image_start_value[81]
int launch_frontend_banned
int max_buffer_percent
void * out_drive_handle
int disk_excl_mode
char wdx[4096]
void * in_drive_handle
char mark_text[4096]
off_t pacifier_total
int msg_sieve_disabled
char wdi[4096]
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)
Submit a problem message to the xorriso problem reporting and handling system.
Definition: text_io.c:2504
int Xorriso_read_lines(struct XorrisO *xorriso, FILE *fp, int *linecount, int *argc, char ***argv, int flag)
Definition: text_io.c:644
int Xorriso_launch_frontend(struct XorrisO *xorriso, int argc, char **argv, char *cmd_pipe_adr, char *reply_pipe_adr, int flag)
Definition: text_io.c:4303
int Xorriso_sieve_big(struct XorrisO *xorriso, int flag)
Install a large sieve with filters for about any interesting message of xorriso.
Definition: text_io.c:2026
int Xorriso_pacifier_callback(struct XorrisO *xorriso, char *what_done, off_t count, off_t todo, char *current_object, int flag)
Definition: text_io.c:3969
int Xorriso_no_malloc_memory(struct XorrisO *xorriso, char **to_free, int flag)
Definition: text_io.c:4077
int Xorriso_named_pipe_loop(struct XorrisO *xorriso, char *pipe_paths[3], int flag)
Definition: text_io.c:4551
int Xorriso_info(struct XorrisO *xorriso, int flag)
Definition: text_io.c:2367
int Xorriso_write_to_channel(struct XorrisO *xorriso, char *in_text, int channel_no, int flag)
Definition: text_io.c:911
int Xorriso_msg_op_parse(struct XorrisO *xorriso, char *line, char *prefix, char *separators, int max_words, int pflag, int input_lines, int flag)
Definition: text_io.c:4161
int Xorriso_sieve_get_result(struct XorrisO *xorriso, char *name, int *argc, char ***argv, int *available, int flag)
Inquire recorded results from a particular filter rule.
Definition: text_io.c:1925
int Xorriso_msg_op_parse_bulk(struct XorrisO *xorriso, char *prefix, char *separators, int max_words, int pflag, int bulk_lines, int flag)
Definition: text_io.c:4239
int Xorriso_pacifier_reset(struct XorrisO *xorriso, int flag)
Definition: text_io.c:3937
int Xorriso_sieve_clear_results(struct XorrisO *xorriso, int flag)
Dispose all recorded results.
Definition: text_io.c:1900
int Xorriso_sieve_dispose(struct XorrisO *xorriso, int flag)
Dispose all filter rules.
Definition: text_io.c:1892
int Xorriso_reassure(struct XorrisO *xorriso, char *cmd, char *which_will, int flag)
Definition: text_io.c:2609
int Xorriso_result(struct XorrisO *xorriso, int flag)
Definition: text_io.c:2337