« back to all changes in this revision
Viewing changes to xorriso/text_io.c
- browse files at revision 12
- compare with another revision
- download diff
- download tarball
- view history from revision 12
- Committer: Bazaar Package Importer
- Author(s): George Danchev
- Date: 2011-05-26 16:21:32 UTC
- mfrom: (9.1.12 sid)
- Revision ID: james.westby@ubuntu.com-20110526162132-9lzoagfaggnera53
Tags: 1.0.8.pl00-4
* [MA] Improve package descriptions and README.Debian.
* [MA] Migrate to format "3.0 (quilt)" and compatibility 8.
+ debian/control: Drop build-dep on 'cdbs'. Require debhelper (>= 8).
+ debian/rules: Reformulate using 'dh'.
+ debian/libisoburn{1,-dev,-doc}.docs: New files.
+ debian/xorriso.docs: Addition of upstream documents.
* [GD] Make sure doxygen documentaton (doc package) is not built
when dpkg-buildpackage -B is called (i.e. autobuilders).
* [GD] Move doxygen, graphviz to Build-Depends-Indep.
* [GD] Add missing copyrights for debian packaging.
* [GD] Standards-Version: 3.9.2 (no changes needed).
* [GD] More package description and README.Debian improvements;
thanks to Tony Mancill <tmancill@debian.org>.
* [MA] Migrate to format "3.0 (quilt)" and compatibility 8.
+ debian/control: Drop build-dep on 'cdbs'. Require debhelper (>= 8).
+ debian/rules: Reformulate using 'dh'.
+ debian/libisoburn{1,-dev,-doc}.docs: New files.
+ debian/xorriso.docs: Addition of upstream documents.
* [GD] Make sure doxygen documentaton (doc package) is not built
when dpkg-buildpackage -B is called (i.e. autobuilders).
* [GD] Move doxygen, graphviz to Build-Depends-Indep.
* [GD] Add missing copyrights for debian packaging.
* [GD] Standards-Version: 3.9.2 (no changes needed).
* [GD] More package description and README.Debian improvements;
thanks to Tony Mancill <tmancill@debian.org>.
- files added:
- ChangeLog
- debian/local
- files removed:
- debian/libisoburn1.symbols
- files modified:
- COPYRIGHT
added
removed
xorriso/text_io.c
1
2
/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
3
4
Copyright 2007-2010 Thomas Schmitt, <scdbackup@gmx.net>
5
6
Provided under GPL version 2 or later.
7
8
This file contains the implementation of text i/o functions.
9
*/
10
11
#ifdef HAVE_CONFIG_H
12
#include "../config.h"
13
#endif
14
15
#include <ctype.h>
16
#include <sys/types.h>
17
#include <unistd.h>
18
#include <stdlib.h>
19
#include <stdio.h>
20
#include <string.h>
21
#include <sys/stat.h>
22
#include <sys/time.h>
23
#include <time.h>
24
#include <errno.h>
25
#include <signal.h>
26
27
/* for -charset */
28
#include <iconv.h>
29
#include <langinfo.h>
30
#include <locale.h>
31
32
33
#ifdef Xorriso_with_readlinE
34
#ifdef Xorriso_with_old_readlinE
35
#include <readline.h>
36
#include <history.h>
37
#else /* Xorriso_with_old_readlinE */
38
#include <readline/readline.h>
39
#include <readline/history.h>
40
#endif /* ! Xorriso_with_old_readlinE */
41
#endif /* Xorriso_with_readlinE */
42
43
44
#include "xorriso.h"
45
#include "xorriso_private.h"
46
#include "xorrisoburn.h"
47
48
49
int Xorriso_protect_stdout(struct XorrisO *xorriso, int flag)
50
{
51
if(xorriso->dev_fd_1>=0)
52
return(2);
53
xorriso->dev_fd_1= dup(1);
54
close(1);
55
dup2(2,1);
56
return(1);
57
}
58
59
60
int Xorriso_dialog_input(struct XorrisO *xorriso, char line[], int linesize,
61
int flag)
62
/*
63
bit0= do not write to history
64
bit1= do not read input (but eventually write to history)
65
bit2= do not write to history line which begin with "-history:" or "-history "
66
*/
67
{
68
char *cpt= NULL, **argv= NULL, *linept, *why_append= "";
69
int ret, argc= 0, base_length= 0, l, append_line;
70
#ifdef Xorriso_with_readlinE
71
static char last_input[SfileadrL]= {""};
72
#endif /* ! Xorriso_with_readlinE */
73
double tdiff;
74
struct timeval tv;
75
struct timezone tz;
76
77
gettimeofday(&tv,&tz);
78
tdiff= tv.tv_sec+(1.e-6*(double) tv.tv_usec);
79
80
fflush(stdout);
81
linept= line;
82
83
get_single:;
84
#ifdef Xorriso_with_readlinE
85
86
if(xorriso->use_stdin || xorriso->dev_fd_1>=0) {
87
if(flag&2)
88
{ret= 1; goto ex;}
89
if(Sfile_fgets_n(linept,linesize - base_length - 1, stdin,
90
(xorriso->dialog == 2)) == NULL) {
91
/* need a very dramatic end */
92
kill(getpid(),SIGHUP);
93
{ret= -1; goto ex;}
94
}
95
goto process_single;
96
}
97
if(flag&2) {
98
cpt= NULL;
99
} else {
100
cpt= readline("");
101
if(cpt==NULL) {
102
/* need a very dramatic end */
103
kill(getpid(),SIGHUP);
104
{ret= -1; goto ex;}
105
}
106
l= strlen(cpt);
107
if(l >= linesize - base_length - 1) {
108
strncpy(linept, cpt, linesize - 1);
109
line[linesize - 1]= 0;
110
sprintf(xorriso->info_text,"Input line too long !");
111
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
112
goto new_empty;
113
} else
114
strcpy(linept, cpt);
115
}
116
117
process_single:;
118
119
#else /* Xorriso_with_readlinE */
120
121
if(flag&2)
122
{ret= 1; goto ex;}
123
if(Sfile_fgets_n(linept, linesize - base_length - 1, stdin,
124
(xorriso->dialog == 2)) == NULL) {
125
/* need a very dramatic end */
126
kill(getpid(),SIGHUP);
127
{ret= -1; goto ex;}
128
}
129
130
#endif /* ! Xorriso_with_readlinE */
131
132
if(xorriso->dialog == 2) {
133
append_line= 0;
134
if(linept != line && strcmp(linept, "@@@") == 0) {
135
sprintf(xorriso->info_text, "Incomplete input line cleared by %s",
136
linept);
137
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE",0);
138
new_empty:;
139
line[0]= 0;
140
linept= line;
141
sprintf(xorriso->info_text, "-------------------------------------\n");
142
Xorriso_info(xorriso,0);
143
sprintf(xorriso->info_text, "Enter new text for empty input line :\n");
144
Xorriso_info(xorriso,0);
145
goto get_single;
146
}
147
l= strlen(line);
148
ret= Sfile_make_argv("", line, &argc, &argv, 16);
149
if(ret < 0)
150
goto ex;
151
if(ret == 0 && !append_line) {
152
/* append a newline character */
153
if(l >= linesize - 1) {
154
sprintf(xorriso->info_text,"Input line too long !");
155
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
156
goto new_empty;
157
}
158
line[l]= '\n';
159
line[l + 1]= 0;
160
append_line= 1;
161
why_append= "Quoted newline char";
162
}
163
if(l > 0 && !append_line)
164
if(line[l - 1] == '\\') {
165
line[l - 1]= 0;
166
append_line= 1;
167
why_append= "Trailing backslash ";
168
}
169
if(append_line) {
170
base_length= strlen(line);
171
linept= line + base_length;
172
sprintf(xorriso->info_text,
173
"---------------------------------------------------------------\n");
174
Xorriso_info(xorriso,0);
175
sprintf(xorriso->info_text,
176
"%s : Enter rest of line (or @@@ to clear it) :\n", why_append);
177
Xorriso_info(xorriso,0);
178
goto get_single;
179
}
180
}
181
182
#ifdef Xorriso_with_readlinE
183
184
if(line[0]!=0 && strcmp(last_input,line)!=0 && !(flag&1))
185
if(!((flag&4) &&
186
(strncmp(line,"-history:",9)==0 || strncmp(line,"-history ",9)==0))) {
187
add_history(line);
188
strncpy(last_input,line,sizeof(last_input)-1);
189
last_input[sizeof(last_input)-1]= 0;
190
}
191
192
#endif /* ! Xorriso_with_readlinE */
193
194
ret= 1;
195
ex:;
196
if(cpt!=NULL)
197
free(cpt);
198
gettimeofday(&tv,&tz);
199
xorriso->idle_time+= tv.tv_sec+(1.e-6*(double) tv.tv_usec)-tdiff;
200
return(ret);
201
}
202
203
204
int Xorriso_request_confirmation(struct XorrisO *xorriso, int flag)
205
/*
206
bit0= important operation going on:
207
demand confirmation of abort, only abort on @@@
208
bit1= mark '@' and '@@' by return 4
209
bit2= accept: i|n= ignore | do not remove , r|y= retry | remove , q|x= abort
210
bit3= @@@ = 'done reading' rather than 'abort'
211
bit4= in non-dialog mode return 6 rather than 1
212
*/
213
/* return: <=0 error
214
1= go on | do not remove existing file
215
2= abort
216
3= redo request for confirmation
217
4= see flag bit1
218
(5= skip volume)
219
6= retry failed operation | remove existing file
220
*/
221
{
222
int ret;
223
char line[SfileadrL],*cpt,previous_line[SfileadrL];
224
char *abort_req_text,*abort_really_text;
225
226
if(!xorriso->dialog) {
227
if(flag&16)
228
return(6);
229
return(1);
230
}
231
if(flag&8) {
232
abort_req_text= "request to end";
233
abort_really_text= "done reading";
234
} else {
235
abort_req_text= "request to abort";
236
abort_really_text= "abort this command";
237
}
238
ret= Xorriso_dialog_input(xorriso,line,sizeof(line),1);
239
xorriso->result_line_counter= 0;
240
xorriso->result_page_counter++;
241
if(ret<=0)
242
if(xorriso->result_page_length>0)
243
xorriso->result_page_length= -xorriso->result_page_length;
244
245
cpt= line;
246
if(strcmp(cpt,"@@@")==0 ||
247
strcmp(cpt,"x")==0 || strcmp(cpt,"X")==0 ||
248
strcmp(cpt,"q")==0 || strcmp(cpt,"Q")==0) {
249
if(flag&1) {
250
strcpy(previous_line,cpt);
251
sprintf(xorriso->info_text,
252
"... [%s = %s registered. Really %s ? (y/n) ] ...\n",
253
cpt,abort_req_text,abort_really_text);
254
Xorriso_info(xorriso,0);
255
ret= Xorriso_dialog_input(xorriso,line,sizeof(line),1);
256
if(ret<=0)
257
return(ret);
258
cpt= line;
259
if(strcmp(cpt,previous_line)==0 ||
260
((*cpt=='Y' || *cpt=='y' || *cpt=='j' || *cpt=='J' || *cpt=='1') &&
261
*(cpt+1)==0)) {
262
xorriso->request_to_abort= 1;
263
sprintf(xorriso->info_text,
264
"------- ( %s confirmed )\n",abort_req_text);
265
Xorriso_info(xorriso,0);
266
return(2);
267
}
268
sprintf(xorriso->info_text, "....... ( %s revoked )\n",abort_req_text);
269
Xorriso_info(xorriso,0);
270
return(3);
271
}
272
xorriso->request_to_abort= 1;
273
sprintf(xorriso->info_text,
274
"----------- [%s = request to abort registered. Operation ends ] ------------\n",
275
cpt);
276
Xorriso_info(xorriso,0);
277
return(2);
278
} else if(*cpt=='@') {
279
if(strcmp(cpt,"@@")==0) {
280
goto klammer_affe;
281
282
} else if(strcmp(cpt,"@")==0) {
283
klammer_affe:;
284
if(xorriso->result_page_length>0)
285
xorriso->result_page_length= -xorriso->result_page_length;
286
if(flag&1) {
287
sprintf(xorriso->info_text,
288
"... [@ = prompt suppression registered. Prompting disabled temporarily ] ...\n");
289
Xorriso_info(xorriso,0);
290
}
291
292
} else {
293
Xorriso_dialog_input(xorriso,cpt,strlen(line)+1,2); /* write to history */
294
sprintf(xorriso->info_text,
295
"--- Unrecognized input beginning with @. Please enter someting else.\n");
296
Xorriso_info(xorriso,0);
297
return(3);
298
}
299
if(flag&2)
300
return(4);
301
if(flag&1)
302
return(3);
303
return(1);
304
} else if(flag&4) {
305
306
if(strcmp(cpt,"i")==0 || strcmp(cpt,"I")==0 ||
307
strcmp(cpt,"n")==0 || strcmp(cpt,"N")==0 ||
308
*cpt==0) {
309
return(1);
310
} else if(strcmp(cpt,"r")==0 || strcmp(cpt,"R")==0 ||
311
strcmp(cpt,"y")==0 || strcmp(cpt,"Y")==0) {
312
return(6);
313
} else {
314
/* >>> unknown input */
315
sprintf(xorriso->info_text,
316
"--- Please enter one of : empty line, i,n, r,y, q,x, @, @@@\n");
317
Xorriso_info(xorriso,0);
318
return(3);
319
}
320
321
} else if(*cpt!=0 && !(flag&1)) {
322
Xorriso_dialog_input(xorriso,cpt,strlen(line)+1,2); /* write to history */
323
strcpy(xorriso->pending_option,cpt);
324
xorriso->request_to_abort= 1;
325
sprintf(xorriso->info_text,
326
"-------------- [ Input of option registered. Operation ends ] ---------------\n");
327
Xorriso_info(xorriso,0);
328
return(2);
329
330
} else if(*cpt!=0) {
331
Xorriso_dialog_input(xorriso,cpt,strlen(line)+1,2); /* write to history */
332
sprintf(xorriso->info_text,
333
"--- Please enter one of : empty line, @, @@@\n");
334
Xorriso_info(xorriso,0);
335
return(3);
336
}
337
return(1);
338
}
339
340
341
/* @param flag bit0= quoted multiline mode
342
bit1= release allocated memory and return 1
343
bit2= with bit0: warn of empty text arguments
344
bit3= deliver as single quoted text including all whitespace
345
and without any backslash interpretation
346
@return -1=out of memory , 0=line format error , 1=ok, go on , 2=done
347
*/
348
int Xorriso_read_lines(struct XorrisO *xorriso, FILE *fp, int *linecount,
349
int *argc, char ***argv, int flag)
350
{
351
char line[5 * SfileadrL + 2], *linept, *fgot;
352
int l, base_length, append_line, ret, mem_linecount, i;
353
354
Sfile_make_argv("", line, argc, argv, 2);
355
if(flag & 2)
356
return(1);
357
358
mem_linecount= *linecount;
359
linept= line;
360
base_length= 0;
361
while(1) {
362
fgot= Sfile_fgets_n(linept, SfileadrL - base_length - 1, fp,
363
!!(flag & (1 | 8)));
364
if(fgot == NULL) {
365
if(ferror(fp))
366
return(0);
367
if(linept != line) {
368
sprintf(xorriso->info_text,"Open quotation mark at end of input");
369
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
370
return(0);
371
}
372
return(2);
373
}
374
l= strlen(line);
375
(*linecount)++;
376
append_line= 0;
377
if(flag & 1) { /* check whether the line is incomplete yet */
378
ret= Sfile_make_argv("", line, argc, argv, 16);
379
if(ret < 0)
380
return(ret);
381
if(ret == 0 && !append_line) {
382
line[l]= '\n';
383
line[l + 1]= 0;
384
append_line= 1;
385
}
386
if(l > 0 && !append_line)
387
if(line[l - 1] == '\\') {
388
line[l - 1]= 0;
389
append_line= 1;
390
}
391
}
392
if(l >= SfileadrL) {
393
sprintf(xorriso->info_text,"Input line too long !");
394
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
395
return(0);
396
}
397
if(!append_line)
398
break;
399
base_length= strlen(line);
400
linept= line + base_length;
401
}
402
if((flag & 1) && !(flag & 8)) {
403
ret= Sfile_make_argv("", line, argc, argv,
404
1 | ((xorriso->bsl_interpretation & 3) << 5));
405
if(ret < 0)
406
return(ret);
407
if(flag & 4)
408
for(i= 0; i < *argc; i++) {
409
if((*argv)[i][0] == 0) {
410
sprintf(xorriso->info_text, "Empty text as quoted argument in ");
411
} else if(strlen((*argv)[i]) >= SfileadrL) {
412
(*argv)[i][SfileadrL - 1]= 0;
413
sprintf(xorriso->info_text,
414
"Input text too long and now truncated in");
415
} else
416
continue;
417
if(mem_linecount + 1 < *linecount)
418
sprintf(xorriso->info_text + strlen(xorriso->info_text),
419
"lines %d to %d", mem_linecount + 1, *linecount);
420
else
421
sprintf(xorriso->info_text + strlen(xorriso->info_text),
422
"line %d", mem_linecount + 1);
423
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING", 0);
424
}
425
} else {
426
(*argv)= Smem_malloC(sizeof(char *));
427
if(argv == NULL)
428
return(-1);
429
(*argv)[0]= strdup(line);
430
if((*argv)[0] == NULL)
431
return(-1);
432
*argc= 1;
433
}
434
return(1);
435
}
436
437
438
int Xorriso_predict_linecount(struct XorrisO *xorriso, char *line,
439
int *linecount, int flag)
440
{
441
int width,l;
442
char *spt,*ept;
443
444
*linecount= 0;
445
spt= line;
446
width= xorriso->result_page_width;
447
while(1) {
448
ept= strchr(spt,'\n');
449
if(ept==NULL)
450
l= strlen(spt);
451
else
452
l= ept-spt;
453
l+= xorriso->result_open_line_len;
454
if(ept!=NULL && l==0)
455
(*linecount)++;
456
else {
457
(*linecount)+= l/width;
458
if(ept==NULL) {
459
xorriso->result_open_line_len= l%width;
460
break;
461
}
462
(*linecount)+= !!(l%width);
463
}
464
xorriso->result_open_line_len= 0;
465
spt= ept+1;
466
}
467
return(1);
468
}
469
470
471
int Xorriso_pager(struct XorrisO *xorriso, char *line, int flag)
472
/*
473
bit1= mark '@' by return 4
474
*/
475
/* return: <=0 error , 1=go on , 2=abort , 4=see flag bit1*/
476
{
477
int ret,linecount;
478
char info_text[10*SfileadrL];
479
480
if(xorriso->result_page_length<=0 || xorriso->request_not_to_ask ||
481
xorriso->dialog == 0)
482
return(1);
483
Xorriso_predict_linecount(xorriso,line,&linecount,0);
484
if(xorriso->result_line_counter+linecount>xorriso->result_page_length) {
485
ask_for_page:;
486
strcpy(info_text,xorriso->info_text);
487
sprintf(xorriso->info_text,"\n");
488
Xorriso_info(xorriso,0);
489
sprintf(xorriso->info_text,
490
".... [Press Enter to continue. @,Enter avoids further stops. @@@ aborts] ....\n");
491
Xorriso_info(xorriso,0);
492
ret= Xorriso_request_confirmation(xorriso,flag&2);
493
strcpy(xorriso->info_text,info_text);
494
if(ret<=0)
495
return(ret);
496
if(ret==2)
497
return(2);
498
if(ret==3)
499
goto ask_for_page;
500
}
501
xorriso->result_line_counter+= linecount;
502
return(1);
503
}
504
505
506
int Xorriso_write_to_channel(struct XorrisO *xorriso,
507
char *in_text, int channel_no, int flag)
508
/*
509
bit0= eventually backslash encode linefeeds
510
bit1= text is the name of the log file for the given channel
511
bit2= text is the name of the consolidated packet log file for all channels
512
bit15= with bit1 or bit2: close depicted log file
513
*/
514
{
515
char *rpt, *npt, *text= NULL;
516
int ret= 1, info_redirected= 0, result_redirected= 0;
517
char prefix[16];
518
FILE *logfile_fp, *pktlog_fp;
519
struct Xorriso_lsT *msglist;
520
static int num_channels= 4;
521
static char channel_prefixes[4][4]= {".","R","I","M"};
522
523
text= in_text; /* might change due to backslash encoding */
524
525
if(channel_no<0 || channel_no>=num_channels)
526
{ret= -1; goto ex;}
527
528
/* Logfiles */
529
logfile_fp= xorriso->logfile_fp[channel_no];
530
pktlog_fp= xorriso->pktlog_fp;
531
if((flag&2) && logfile_fp!=NULL) {
532
fprintf(logfile_fp,
533
"! end ! end ! end ! end ! end ! end ! end ! end xorriso log : %s : %s\n",
534
channel_prefixes[channel_no],Sfile_datestr(time(0),1|2|256));
535
fclose(logfile_fp);
536
xorriso->logfile_fp[channel_no]= logfile_fp= NULL;
537
}
538
if((flag&4) && pktlog_fp!=NULL) {
539
fprintf(pktlog_fp,
540
"I:1:! end ! end ! end ! end ! end ! end ! end ! end xorriso log : %s : %s\n",
541
channel_prefixes[channel_no],Sfile_datestr(time(0),1|2|256));
542
fclose(pktlog_fp);
543
xorriso->pktlog_fp= pktlog_fp= NULL;
544
}
545
if(flag&(1<<15))
546
{ret= 1; goto ex;}
547
if((flag&2)) {
548
xorriso->logfile_fp[channel_no]= logfile_fp= fopen(text,"a");
549
if(logfile_fp==NULL)
550
{ret= 0; goto ex;}
551
fprintf(logfile_fp,
552
"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! xorriso log : %s : %s\n",
553
channel_prefixes[channel_no],Sfile_datestr(time(0),1|2|256));
554
fflush(logfile_fp);
555
}
556
if((flag&4)) {
557
xorriso->pktlog_fp= pktlog_fp= fopen(text,"a");
558
if(pktlog_fp==NULL)
559
{ret= 0; goto ex;}
560
fprintf(pktlog_fp,
561
"I:1:!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! xorriso log : . : %s\n",
562
Sfile_datestr(time(0),1|2|256));
563
fflush(pktlog_fp);
564
}
565
if(flag&(2|4))
566
{ret= 1; goto ex;}
567
568
/* Eventually perform backslash encoding of non-printable characters */
569
if(((xorriso->bsl_interpretation & 32) && channel_no == 1) ||
570
((xorriso->bsl_interpretation & 64) && channel_no == 2)) {
571
ret= Sfile_bsl_encoder(&text, text, strlen(text), 1 | 2 | 4);
572
if(ret <= 0)
573
{ret= -1; goto ex;}
574
}
575
576
/* Eventually perform messag redirection */
577
if(xorriso->msglist_stackfill > 0) {
578
if(xorriso->msglist_flags[xorriso->msglist_stackfill - 1] & 1)
579
result_redirected= 1;
580
if(xorriso->msglist_flags[xorriso->msglist_stackfill - 1] & 2)
581
info_redirected= 1;
582
}
583
if(result_redirected) {
584
if(channel_no==1 || channel_no==3) {
585
msglist= xorriso->result_msglists[xorriso->msglist_stackfill - 1];
586
ret= Xorriso_lst_append_binary(&msglist, text, strlen(text) + 1, 0);
587
if(ret <= 0)
588
{ret= -1; goto ex;}
589
if(xorriso->result_msglists[xorriso->msglist_stackfill - 1] == NULL)
590
xorriso->result_msglists[xorriso->msglist_stackfill - 1]= msglist;
591
}
592
}
593
if(info_redirected) {
594
if(channel_no==2 || channel_no==3) {
595
msglist= xorriso->info_msglists[xorriso->msglist_stackfill - 1];
596
ret= Xorriso_lst_append_binary(&msglist, text, strlen(text) + 1, 0);
597
if(ret <= 0)
598
{ret= -1; goto ex;}
599
if(xorriso->info_msglists[xorriso->msglist_stackfill - 1] == NULL)
600
xorriso->info_msglists[xorriso->msglist_stackfill - 1]= msglist;
601
}
602
}
603
if((channel_no == 1 && result_redirected) ||
604
(channel_no == 2 && info_redirected) ||
605
(result_redirected && info_redirected))
606
{ret= 1; goto ex;}
607
608
/* Non-redirected output */
609
if(!xorriso->packet_output) {
610
if(channel_no==1 || channel_no==3) {
611
printf("%s",text);
612
fflush(stdout);
613
}
614
if(channel_no==2 || channel_no==3)
615
fprintf(stderr,"%s",text);
616
if(logfile_fp!=NULL) {
617
fprintf(logfile_fp,"%s",text);
618
fflush(logfile_fp);
619
}
620
if(pktlog_fp==NULL)
621
{ret= 1; goto ex;}
622
}
623
rpt= text;
624
sprintf(prefix,"%s:x: ",channel_prefixes[channel_no]);
625
while(*rpt!=0) {
626
npt= strchr(rpt,'\n');
627
if(npt==NULL)
628
prefix[2]= '0';
629
else
630
prefix[2]= '1';
631
if(xorriso->packet_output) {
632
ret= fwrite(prefix,5,1,stdout);
633
if(ret<=0)
634
{ret= 0; goto ex;}
635
}
636
if(pktlog_fp!=NULL) {
637
ret= fwrite(prefix,5,1,pktlog_fp);
638
if(ret<=0)
639
{ret= 0; goto ex;}
640
}
641
if(npt==NULL) {
642
if(xorriso->packet_output) {
643
ret= fwrite(rpt,strlen(rpt),1,stdout);
644
if(ret<=0)
645
{ret= 0; goto ex;}
646
ret= fwrite("\n",1,1,stdout);
647
if(ret<=0)
648
{ret= 0; goto ex;}
649
}
650
if(pktlog_fp!=NULL) {
651
ret= fwrite(rpt,strlen(rpt),1,pktlog_fp);
652
if(ret<=0)
653
{ret= 0; goto ex;}
654
ret= fwrite("\n",1,1,pktlog_fp);
655
if(ret<=0)
656
{ret= 0; goto ex;}
657
}
658
break;
659
} else {
660
if(xorriso->packet_output) {
661
ret= fwrite(rpt,npt+1-rpt,1,stdout);
662
if(ret<=0)
663
{ret= 0; goto ex;}
664
}
665
if(pktlog_fp!=NULL) {
666
ret= fwrite(rpt,npt+1-rpt,1,pktlog_fp);
667
if(ret<=0)
668
{ret= 0; goto ex;}
669
}
670
}
671
rpt= npt+1;
672
}
673
if(xorriso->packet_output)
674
fflush(stdout);
675
if(pktlog_fp!=NULL)
676
fflush(pktlog_fp);
677
ret= 1;
678
ex:
679
if(text != in_text && text != NULL)
680
free(text);
681
return(ret);
682
}
683
684
685
int Xorriso_push_outlists(struct XorrisO *xorriso, int *stack_handle,
686
int flag)
687
{
688
if(xorriso->msglist_stackfill + 1 >= Xorriso_max_outlist_stacK) {
689
Xorriso_msgs_submit(xorriso, 0,
690
"Overflow of message output redirection stack", 0, "FATAL", 0);
691
return(-1);
692
}
693
if((flag & 3) == 0)
694
flag|= 3;
695
xorriso->msglist_stackfill++;
696
xorriso->result_msglists[xorriso->msglist_stackfill - 1]= NULL;
697
xorriso->info_msglists[xorriso->msglist_stackfill - 1]= NULL;
698
xorriso->msglist_flags[xorriso->msglist_stackfill - 1]= flag & 3;
699
*stack_handle= xorriso->msglist_stackfill - 1;
700
return(1);
701
}
702
703
704
int Xorriso_pull_outlists(struct XorrisO *xorriso, int stack_handle,
705
struct Xorriso_lsT **result_list,
706
struct Xorriso_lsT **info_list, int flag)
707
{
708
int i;
709
710
if(stack_handle < 0 || stack_handle >= xorriso->msglist_stackfill) {
711
Xorriso_msgs_submit(xorriso, 0,
712
"Program error: Wrong message output redirection stack handle",
713
0, "FATAL", 0);
714
return(-1);
715
}
716
*result_list= xorriso->result_msglists[stack_handle];
717
*info_list= xorriso->info_msglists[stack_handle];
718
for(i = stack_handle + 1; i < xorriso->msglist_stackfill - 1; i++) {
719
xorriso->result_msglists[i - 1]= xorriso->result_msglists[i];
720
xorriso->info_msglists[i - 1]= xorriso->info_msglists[i];
721
}
722
xorriso->msglist_stackfill--;
723
return(1);
724
}
725
726
727
int Xorriso_result(struct XorrisO *xorriso, int flag)
728
/*
729
bit0= no considerations or computations or dialog. Just put out.
730
*/
731
{
732
int ret, redirected= 0;
733
734
if(flag&1)
735
goto put_it_out;
736
if(xorriso->request_to_abort)
737
return(1);
738
if(xorriso->msglist_stackfill > 0)
739
if(xorriso->msglist_flags[xorriso->msglist_stackfill - 1] & 1)
740
redirected= 1;
741
if(xorriso->result_page_length>0 && !redirected) {
742
ret= Xorriso_pager(xorriso,xorriso->result_line,2);
743
if(ret<=0)
744
return(ret);
745
if(ret==2)
746
return(1);
747
if(xorriso->request_to_abort)
748
return(1);
749
}
750
put_it_out:;
751
xorriso->bar_is_fresh= 0;
752
ret= Xorriso_write_to_channel(xorriso, xorriso->result_line, 1,0);
753
return(ret);
754
}
755
756
757
int Xorriso_info(struct XorrisO *xorriso, int flag)
758
/*
759
bit0= use pager (as with result)
760
bit1= permission to suppress output
761
bit2= insist in showing output
762
*/
763
{
764
int ret;
765
static int note_sev= 0;
766
767
if(flag&2)
768
if(xorriso->request_to_abort)
769
return(1);
770
771
if(note_sev==0)
772
Xorriso__text_to_sev("NOTE", ¬e_sev, 0);
773
if(note_sev<xorriso->report_about_severity &&
774
note_sev<xorriso->abort_on_severity && !(flag&4))
775
return(1);
776
777
if(flag&1) {
778
ret= Xorriso_pager(xorriso,xorriso->info_text,2);
779
if(ret<=0)
780
return(ret);
781
if(ret==2)
782
return(1);
783
if(flag&2)
784
if(xorriso->request_to_abort)
785
return(1);
786
}
787
xorriso->bar_is_fresh= 0;
788
ret=Xorriso_write_to_channel(xorriso, xorriso->info_text, 2, 0);
789
return(ret);
790
}
791
792
793
int Xorriso_mark(struct XorrisO *xorriso, int flag)
794
{
795
int ret= 1,r_ret,i_ret;
796
797
if(xorriso->mark_text[0]==0)
798
return(1);
799
if(xorriso->packet_output)
800
ret=Xorriso_write_to_channel(xorriso, xorriso->mark_text, 3, 0);
801
else {
802
sprintf(xorriso->result_line,"%s\n",xorriso->mark_text);
803
r_ret= Xorriso_result(xorriso,1);
804
strcpy(xorriso->info_text,xorriso->result_line);
805
i_ret= Xorriso_info(xorriso,0);
806
if(r_ret==0 || i_ret==0)
807
ret= 0;
808
}
809
return(ret);
810
}
811
812
813
int Xorriso_restxt(struct XorrisO *xorriso, char *text)
814
{
815
int ret;
816
817
strncpy(xorriso->result_line,text,sizeof(xorriso->result_line)-1);
818
xorriso->result_line[sizeof(xorriso->result_line)-1]= 0;
819
ret= Xorriso_result(xorriso,0);
820
return(ret);
821
}
822
823
824
/* @param flag bit0-7= purpose
825
0= ERRFILE
826
1= mark line (only to be put out if enabled)
827
*/
828
int Xorriso_process_errfile(struct XorrisO *xorriso,
829
int error_code, char msg_text[], int os_errno,
830
int flag)
831
{
832
char ttx[41];
833
int purpose;
834
835
if(strlen(msg_text)>SfileadrL)
836
return(-1);
837
838
purpose= flag&255;
839
if(purpose==1 && !(xorriso->errfile_mode&1))
840
return(2);
841
if(xorriso->errfile_fp!=NULL) {
842
if(purpose==1)
843
fprintf(xorriso->errfile_fp, "----------------- %s %s\n",
844
msg_text, Ftimetxt(time(0), ttx, 1));
845
else
846
fprintf(xorriso->errfile_fp, "%s\n", msg_text);
847
fflush(xorriso->errfile_fp);
848
return(1);
849
}
850
if(xorriso->errfile_log[0]==0)
851
return(1);
852
if(strcmp(xorriso->errfile_log, "-")==0 ||
853
strcmp(xorriso->errfile_log, "-R")==0) {
854
if(purpose==1)
855
sprintf(xorriso->result_line, "----------------- %s %s\n",
856
msg_text, Ftimetxt(time(0), ttx, 1));
857
else
858
sprintf(xorriso->result_line, "%s\n", msg_text);
859
Xorriso_result(xorriso, 1);
860
return(1);
861
}
862
if(strcmp(xorriso->errfile_log, "-I")==0) {
863
if(purpose==1)
864
sprintf(xorriso->info_text, "ERRFILE_MARK=%s %s\n",
865
msg_text, Ftimetxt(time(0), ttx, 1));
866
else
867
sprintf(xorriso->info_text, "ERRFILE=%s", msg_text);
868
Xorriso_info(xorriso, 0);
869
return(1);
870
}
871
return(2);
872
}
873
874
875
/* Note: It is ok to submit xorriso->info_text as msg_text here. */
876
/* flag:
877
bit0= for Xorriso_info() : use pager (as with result)
878
bit1= for Xorriso_info() : permission to suppress output
879
bit2..5= name prefix
880
0="xorriso"
881
1="libisofs"
882
2="libburn"
883
3="libisoburn"
884
else: ""
885
bit6= append carriage return rather than line feed (if not os_errno)
886
bit7= perform Xorriso_process_msg_queues() first
887
*/
888
int Xorriso_msgs_submit(struct XorrisO *xorriso,
889
int error_code, char msg_text[], int os_errno,
890
char severity[], int flag)
891
{
892
int ret, lt, li, sev, i;
893
char *sev_text= "FATAL", prefix[80];
894
static char pfx_list[20][16]= {
895
"xorriso : ", "libisofs: ", "libburn : ", "libisoburn: ",
896
"", "", "", "", "", "", "", "", "", "", "", "" };
897
898
if(flag&128)
899
Xorriso_process_msg_queues(xorriso, 0);
900
901
if(strcmp(severity, "ERRFILE")==0)
902
Xorriso_process_errfile(xorriso, error_code, msg_text, os_errno, 0);
903
904
/* Set problem status */
905
ret= Xorriso__text_to_sev(severity, &sev, 0);
906
if(ret<=0)
907
Xorriso__text_to_sev(sev_text, &sev, 0);
908
else
909
sev_text= severity;
910
if(xorriso->problem_status<sev) {
911
xorriso->problem_status= sev;
912
strcpy(xorriso->problem_status_text, sev_text);
913
}
914
if(xorriso->eternal_problem_status<sev) {
915
xorriso->eternal_problem_status= sev;
916
strcpy(xorriso->eternal_problem_status_text, sev_text);
917
}
918
919
/* Report problem event */
920
if(sev<xorriso->report_about_severity && sev<xorriso->abort_on_severity)
921
return(2);
922
sprintf(prefix,"%s%s : ", pfx_list[(flag>>2)&15], sev_text);
923
li= strlen(prefix);
924
lt= strlen(msg_text);
925
if(lt>sizeof(xorriso->info_text)-li-2)
926
lt= sizeof(xorriso->info_text)-li-2;
927
if(msg_text==xorriso->info_text) {
928
for(i= lt; i>=0; i--)
929
msg_text[i+li]= msg_text[i];
930
for(i=0; i<li; i++)
931
msg_text[i]= prefix[i];
932
} else {
933
strcpy(xorriso->info_text, prefix);
934
strncpy(xorriso->info_text+li, msg_text, lt);
935
}
936
if((flag&64) && os_errno<=0)
937
xorriso->info_text[li+lt]= '\r';
938
else
939
xorriso->info_text[li+lt]= '\n';
940
xorriso->info_text[li+lt+1]= 0;
941
942
#ifdef NIX
943
944
/* <<< */
945
Xorriso_info(xorriso,4|(flag&3));
946
if(os_errno>0) {
947
sprintf(xorriso->info_text, "%s%s : %s\n",
948
pfx_list[(flag>>2)&15], sev_text, strerror(os_errno));
949
Xorriso_info(xorriso,4|(flag&3));
950
}
951
952
#else
953
954
if(os_errno>0) {
955
sprintf(xorriso->info_text + strlen(xorriso->info_text) - 1,
956
" : %s\n", strerror(os_errno));
957
}
958
Xorriso_info(xorriso,4|(flag&3));
959
960
#endif
961
962
return(1);
963
}
964
965
966
/* To be used with isoburn_set_msgs_submit()
967
*/
968
int Xorriso_msgs_submit_void(void *xorriso,
969
int error_code, char msg_text[], int os_errno,
970
char severity[], int flag)
971
{
972
int ret;
973
974
ret= Xorriso_msgs_submit((struct XorrisO *) xorriso, error_code, msg_text,
975
os_errno, severity, flag);
976
return(ret);
977
}
978
979
980
/** @return -1= abort , 0= no , 1= yes
981
*/
982
int Xorriso_reassure(struct XorrisO *xorriso, char *cmd, char *which_will,
983
int flag)
984
{
985
int ret;
986
987
if(!xorriso->do_reassure)
988
return(1);
989
sprintf(xorriso->info_text, "Really perform %s which will %s ? (y/n)\n",
990
cmd, which_will);
991
Xorriso_info(xorriso, 4);
992
do {
993
ret= Xorriso_request_confirmation(xorriso, 2|4|16);
994
} while(ret==3);
995
if(ret==6 || ret==4) {
996
sprintf(xorriso->info_text, "%s confirmed", cmd);
997
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
998
return(1);
999
}
1000
if(ret==2) {
1001
sprintf(xorriso->info_text, "%s aborted", cmd);
1002
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
1003
return(-1);
1004
}
1005
sprintf(xorriso->info_text, "%s revoked", cmd);
1006
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
1007
return(0);
1008
}
1009
1010
1011
int Xorriso_write_session_log(struct XorrisO *xorriso, int flag)
1012
{
1013
FILE *fp= NULL;
1014
char sfe[5*SfileadrL], timetext[40], *rpt, *wpt;
1015
1016
if(xorriso->session_logfile[0]==0)
1017
return(2);
1018
fp= fopen(xorriso->session_logfile, "a");
1019
if(fp==0) {
1020
sprintf(xorriso->info_text, "-session_log: Cannot open file %s",
1021
Text_shellsafe(xorriso->session_logfile, sfe, 0));
1022
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
1023
return(0);
1024
}
1025
wpt= sfe;
1026
for(rpt= xorriso->volid; *rpt!=0; rpt++) {
1027
if(*rpt=='\n') {
1028
*(wpt++)= '\\';
1029
*(wpt++)= 'n';
1030
} else
1031
*(wpt++)= *rpt;
1032
}
1033
*wpt= 0;
1034
fprintf(fp, "%s %d %d %s\n",
1035
Ftimetxt(time(0), timetext, 2), xorriso->session_lba,
1036
xorriso->session_blocks, sfe);
1037
fclose(fp);
1038
return(1);
1039
}
1040
1041
1042
int Xorriso_status_filter(struct XorrisO *xorriso, char *filter, char *line,
1043
int flag)
1044
{
1045
if(filter!=NULL)
1046
if(filter[0]=='-')
1047
if(strncmp(filter, line, strlen(filter))!=0)
1048
return(0);
1049
return(1);
1050
}
1051
1052
1053
int Xorriso_status_result(struct XorrisO *xorriso, char *filter, FILE *fp,
1054
int flag)
1055
/*
1056
bit1= do only report to fp
1057
*/
1058
{
1059
int ret;
1060
1061
ret= Xorriso_status_filter(xorriso, filter, xorriso->result_line, 0);
1062
if(ret <= 0)
1063
return(2);
1064
if(!(flag&2))
1065
Xorriso_result(xorriso,0);
1066
if(fp!=NULL) {
1067
ret= fwrite(xorriso->result_line,strlen(xorriso->result_line),1,fp);
1068
if(ret<=0)
1069
return(ret);
1070
}
1071
return(1);
1072
}
1073
1074
1075
int Xorriso_status(struct XorrisO *xorriso, char *filter, FILE *fp, int flag)
1076
/*
1077
bit0= do only report non-default settings
1078
bit1= do only report to fp
1079
bit2= report current -resume status even if bit0 is set, but only if valid
1080
bit3= report readline history
1081
bit4= report -resume options indirectly as
1082
-options_from_file:${resume_state_file}_pos
1083
*/
1084
{
1085
int is_default, no_defaults, i, ret, adr_mode, do_single;
1086
int show_indev= 1, show_outdev= 1, show_dev= 0;
1087
int part_table_implicit= 0;
1088
char *line, sfe[5 * SfileadrL + 80], mode[80], *form, *treatment;
1089
char *in_pt, *out_pt, *nl_charset, *local_charset, *mode_pt;
1090
char *dev_filter= NULL, xorriso_id[129];
1091
static char channel_prefixes[4][4]= {".","R","I","M"};
1092
static char load_names[][20]= {"auto", "session", "track", "lba", "volid"};
1093
static int max_load_mode= 4;
1094
struct Xorriso_lsT *paths, *leafs, *s, *plst, *vlst;
1095
1096
no_defaults= flag&1;
1097
line= xorriso->result_line;
1098
1099
if(xorriso->no_rc) {
1100
sprintf(line,"-no_rc\n");
1101
Xorriso_status_result(xorriso,filter,fp,flag&2);
1102
}
1103
1104
is_default= strcmp(xorriso->list_delimiter, "--") == 0;
1105
sprintf(line,"-list_delimiter %s\n", xorriso->list_delimiter);
1106
if(!(is_default && no_defaults))
1107
Xorriso_status_result(xorriso,filter,fp,flag&2);
1108
1109
is_default= 0;
1110
if(xorriso->dialog == 2)
1111
sprintf(line,"-dialog on\n");
1112
else if(xorriso->dialog == 1)
1113
sprintf(line,"-dialog single_line\n");
1114
else {
1115
sprintf(line,"-dialog off\n");
1116
is_default= 1;
1117
}
1118
if(!(is_default && no_defaults))
1119
Xorriso_status_result(xorriso,filter,fp,flag&2);
1120
1121
is_default= (xorriso->result_page_length==0 && xorriso->result_page_width==80);
1122
sprintf(line,"-page %d %d\n",
1123
(xorriso->result_page_length>=0?xorriso->result_page_length
1124
:-xorriso->result_page_length),
1125
xorriso->result_page_width);
1126
if(!(is_default && no_defaults))
1127
Xorriso_status_result(xorriso,filter,fp,flag&2);
1128
1129
is_default= (xorriso->use_stdin==0);
1130
sprintf(line,"-use_readline %s\n", (xorriso->use_stdin?"off":"on"));
1131
if(!(is_default && no_defaults))
1132
Xorriso_status_result(xorriso,filter,fp,flag&2);
1133
1134
is_default= (xorriso->bsl_interpretation == 0);
1135
strcpy(line, "-backslash_codes ");
1136
if(xorriso->bsl_interpretation == 0)
1137
strcat(line, "off");
1138
else if(xorriso->bsl_interpretation == (3 | 16 | 32 | 64))
1139
strcat(line, "on");
1140
else {
1141
if((xorriso->bsl_interpretation & 3) == 1)
1142
strcat(line, "in_double_quotes");
1143
else if((xorriso->bsl_interpretation & 3) == 2)
1144
strcat(line, "in_quotes");
1145
else if((xorriso->bsl_interpretation & 3) == 3)
1146
strcat(line, "with_quoted_input");
1147
if(xorriso->bsl_interpretation & 16) {
1148
if(strlen(line) > 17)
1149
strcat(line, ":");
1150
strcat(line, "with_program_arguments");
1151
}
1152
if((xorriso->bsl_interpretation & (32 | 64)) == (32 | 64)) {
1153
if(strlen(line) > 17)
1154
strcat(line, ":");
1155
strcat(line, "encode_output");
1156
} else {
1157
if(xorriso->bsl_interpretation & 32) {
1158
if(strlen(line) > 17)
1159
strcat(line, ":");
1160
strcat(line, "encode_results");
1161
}
1162
if(xorriso->bsl_interpretation & 64) {
1163
if(strlen(line) > 17)
1164
strcat(line, ":");
1165
strcat(line, "encode_infos");
1166
}
1167
}
1168
}
1169
strcat(line, "\n");
1170
if(!(is_default && no_defaults))
1171
Xorriso_status_result(xorriso,filter,fp,flag&2);
1172
1173
is_default= !xorriso->packet_output;
1174
sprintf(line,"-pkt_output %s\n",(xorriso->packet_output?"on":"off"));
1175
if(!(is_default && no_defaults))
1176
Xorriso_status_result(xorriso,filter,fp,flag&2);
1177
1178
for(i=0;i<4;i++) {
1179
is_default= (xorriso->logfile[i]!=0);
1180
sprintf(line,"-logfile %s %s\n",
1181
channel_prefixes[i],Text_shellsafe(xorriso->logfile[i],sfe,0));
1182
if(!(is_default && no_defaults))
1183
Xorriso_status_result(xorriso,filter,fp,flag&2);
1184
}
1185
1186
is_default= (xorriso->errfile_log[0]==0);
1187
sprintf(line,"-errfile_log %s\n",Text_shellsafe(xorriso->errfile_log,sfe,0));
1188
if(!(is_default && no_defaults))
1189
Xorriso_status_result(xorriso,filter,fp,flag&2);
1190
1191
if(xorriso->check_media_default == NULL) {
1192
is_default= 1;
1193
sprintf(line, "-check_media_defaults reset=now %s\n",
1194
xorriso->list_delimiter);
1195
} else {
1196
ret= Xorriso_check_media_list_job(xorriso, xorriso->check_media_default,
1197
line, no_defaults);
1198
is_default= (ret == 2);
1199
strcat(line, "\n");
1200
}
1201
if(!(is_default && no_defaults))
1202
Xorriso_status_result(xorriso,filter,fp,flag&2);
1203
1204
is_default= (xorriso->img_read_error_mode==2);
1205
treatment= "best_effort";
1206
if(xorriso->img_read_error_mode==1)
1207
treatment= "failure";
1208
else if(xorriso->img_read_error_mode==2)
1209
treatment= "fatal";
1210
sprintf(line,"-error_behavior image_loading %s\n", treatment);
1211
if(!(is_default && no_defaults))
1212
Xorriso_status_result(xorriso,filter,fp,flag&2);
1213
is_default= (xorriso->extract_error_mode == 1);
1214
treatment= "keep";
1215
if(xorriso->extract_error_mode == 0)
1216
treatment= "best_effort";
1217
else if(xorriso->extract_error_mode == 2)
1218
treatment= "delete";
1219
sprintf(line,"-error_behavior file_extraction %s\n", treatment);
1220
if(!(is_default && no_defaults))
1221
Xorriso_status_result(xorriso,filter,fp,flag&2);
1222
1223
is_default= (xorriso->mark_text[0]==0);
1224
sprintf(line,"-mark %s\n",Text_shellsafe(xorriso->mark_text,sfe,0));
1225
if(!(is_default && no_defaults))
1226
Xorriso_status_result(xorriso,filter,fp,flag&2);
1227
1228
is_default= (xorriso->temp_mem_limit==16*1024*1024);
1229
if((xorriso->temp_mem_limit/1024/1024)*1024*1024==xorriso->temp_mem_limit)
1230
sprintf(line,"-temp_mem_limit %dm\n", xorriso->temp_mem_limit/1024/1024);
1231
else
1232
sprintf(line,"-temp_mem_limit %dk\n", xorriso->temp_mem_limit/1024);
1233
if(!(is_default && no_defaults))
1234
Xorriso_status_result(xorriso,filter,fp,flag&2);
1235
1236
1237
sprintf(line,"-prog %s\n",Text_shellsafe(xorriso->progname,sfe,0));
1238
Xorriso_status_result(xorriso,filter,fp,flag&2);
1239
1240
if(xorriso->ban_stdio_write) {
1241
sprintf(line,"-ban_stdio_write\n");
1242
Xorriso_status_result(xorriso,filter,fp,flag&2);
1243
}
1244
1245
is_default= ((xorriso->early_stdio_test & 14) == 0);
1246
sprintf(line, "-early_stdio_test %s\n",
1247
xorriso->early_stdio_test & 6 ? xorriso->early_stdio_test & 8 ?
1248
"appendable_wo" : "on" : "off");
1249
if(!(is_default && no_defaults))
1250
Xorriso_status_result(xorriso,filter,fp,flag&2);
1251
1252
is_default= (xorriso->allow_restore==0 && xorriso->do_concat_split==1 &&
1253
xorriso->do_auto_chmod==0 && xorriso->drives_exclusive == 1);
1254
mode_pt= "off";
1255
if(xorriso->allow_restore == -1)
1256
mode_pt= "banned";
1257
else if(xorriso->allow_restore == 1)
1258
mode_pt= "on";
1259
else if(xorriso->allow_restore == 2)
1260
mode_pt= "device_files";
1261
if(xorriso->allow_restore == -1)
1262
sprintf(line,"-osirrox %s\n", mode_pt);
1263
else
1264
sprintf(line,"-osirrox %s:%s:%s:%s:%s\n", mode_pt,
1265
xorriso->do_concat_split ? "concat_split_on" : "concat_split_off",
1266
xorriso->do_auto_chmod ? "auto_chmod_on" : "auto_chmod_off",
1267
xorriso->do_restore_sort_lba ? "sort_lba_on" : "sort_lba_off",
1268
xorriso->drives_exclusive ? "o_excl_on" : "o_excl_off"
1269
);
1270
if(!(is_default && no_defaults))
1271
Xorriso_status_result(xorriso,filter,fp,flag&2);
1272
1273
is_default= (xorriso->mount_opts_flag == 0);
1274
sprintf(line,"-mount_opts %s\n",
1275
xorriso->mount_opts_flag & 1 ? "shared" : "exclusive");
1276
if(!(is_default && no_defaults))
1277
Xorriso_status_result(xorriso,filter,fp,flag&2);
1278
1279
Xorriso_boot_image_status(xorriso, filter, fp, flag & 3);
1280
1281
is_default= (xorriso->system_area_disk_path[0] == 0);
1282
sprintf(line,"-boot_image %s system_area=%s\n",
1283
xorriso->system_area_disk_path[0] && (xorriso->system_area_options & 2)
1284
? "isolinux" : "any",
1285
Text_shellsafe(xorriso->system_area_disk_path, sfe, 0));
1286
if(!(is_default && no_defaults))
1287
Xorriso_status_result(xorriso,filter,fp,flag&2);
1288
1289
is_default= (xorriso->partition_offset == 0);
1290
sprintf(line,"-boot_image any partition_offset=%lu\n",
1291
(unsigned long int) xorriso->partition_offset);
1292
if(!(is_default && no_defaults))
1293
Xorriso_status_result(xorriso,filter,fp,flag&2);
1294
is_default= (xorriso->partition_secs_per_head == 0);
1295
sprintf(line,"-boot_image any partition_sec_hd=%lu\n",
1296
(unsigned long int) xorriso->partition_secs_per_head);
1297
if(!(is_default && no_defaults))
1298
Xorriso_status_result(xorriso,filter,fp,flag&2);
1299
is_default= (xorriso->partition_heads_per_cyl == 0);
1300
sprintf(line,"-boot_image any partition_hd_cyl=%lu\n",
1301
(unsigned long int) xorriso->partition_heads_per_cyl);
1302
if(!(is_default && no_defaults))
1303
Xorriso_status_result(xorriso,filter,fp,flag&2);
1304
1305
ret= (xorriso->system_area_options & 0x300) >> 8;
1306
is_default= (ret == 0);
1307
sprintf(line,"-boot_image any partition_cyl_align=%s\n",
1308
ret == 0 ? "auto" : ret == 1 ? "on" : "off");
1309
if(!(is_default && no_defaults))
1310
Xorriso_status_result(xorriso,filter,fp,flag&2);
1311
1312
if((xorriso->system_area_disk_path[0] || !part_table_implicit) &&
1313
(xorriso->partition_offset == 0 || (xorriso->system_area_options & 2))) {
1314
is_default= ((xorriso->system_area_options & 3) == 0);
1315
sprintf(line,"-boot_image %s partition_table=%s\n",
1316
xorriso->system_area_options & 2 ? "isolinux" : "grub",
1317
xorriso->system_area_options & 3 ? "on" : "off");
1318
if(!(is_default && no_defaults))
1319
Xorriso_status_result(xorriso,filter,fp,flag&2);
1320
}
1321
1322
#ifdef Xorriso_with_isohybriD
1323
if(strcmp(form, "isolinux") == 0) {
1324
static char modes[4][6]= {"off", "auto", "on", "force"};
1325
is_default= (xorriso->boot_image_isohybrid == 1);
1326
sprintf(line,"-boot_image isolinux isohybrid=%s\n",
1327
modes[xorriso->boot_image_isohybrid & 3]);
1328
if(!(is_default && no_defaults))
1329
Xorriso_status_result(xorriso,filter,fp,flag&2);
1330
}
1331
#endif /* Xorriso_with_isohybriD */
1332
1333
sprintf(line,"-cd %s\n",
1334
(xorriso->wdi[0] ? Text_shellsafe(xorriso->wdi,sfe,0) : "'/'"));
1335
Xorriso_status_result(xorriso,filter,fp,flag&2);
1336
sprintf(line,"-cdx %s\n",
1337
(xorriso->wdx[0] ? Text_shellsafe(xorriso->wdx,sfe,0) : "'/'"));
1338
Xorriso_status_result(xorriso,filter,fp,flag&2);
1339
1340
is_default= (xorriso->split_size==0);
1341
strcpy(line,"-split_size ");
1342
if(xorriso->split_size % (1024*1024) || xorriso->split_size==0) {
1343
Sfile_off_t_text(line+strlen(line), xorriso->split_size, 0);
1344
} else {
1345
Sfile_off_t_text(line+strlen(line), xorriso->split_size / (1024*1024), 0);
1346
strcat(line, "m");
1347
}
1348
strcat(line, "\n");
1349
if(!(is_default && no_defaults))
1350
Xorriso_status_result(xorriso,filter,fp,flag&2);
1351
1352
is_default= (xorriso->add_plainly==0);
1353
sprintf(line,"-add_plainly %s\n",
1354
(xorriso->add_plainly == 1 ? "unknown" :
1355
xorriso->add_plainly == 2 ? "dashed" :
1356
xorriso->add_plainly == 3 ? "any" : "none"));
1357
if(!(is_default && no_defaults))
1358
Xorriso_status_result(xorriso,filter,fp,flag&2);
1359
1360
ret= Exclusions_get_descrs(xorriso->disk_exclusions, &paths, &leafs, 0);
1361
if(ret>0) {
1362
for(; paths!=NULL; paths= paths->next) {
1363
sprintf(line, "-not_paths %s %s\n",
1364
Text_shellsafe(paths->text, sfe, 0), xorriso->list_delimiter);
1365
Xorriso_status_result(xorriso,filter,fp,flag&2);
1366
}
1367
for(; leafs!=NULL; leafs= leafs->next) {
1368
sprintf(line,"-not_leaf %s\n", Text_shellsafe(leafs->text, sfe, 0));
1369
Xorriso_status_result(xorriso,filter,fp,flag&2);
1370
}
1371
}
1372
1373
is_default= (xorriso->file_size_limit ==
1374
Xorriso_default_file_size_limiT);
1375
if(xorriso->file_size_limit <= 0)
1376
sprintf(line, "-file_size_limit off %s\n", xorriso->list_delimiter);
1377
else
1378
sprintf(line, "-file_size_limit %.f %s\n",
1379
(double) xorriso->file_size_limit, xorriso->list_delimiter);
1380
if(!(is_default && no_defaults))
1381
Xorriso_status_result(xorriso,filter,fp,flag&2);
1382
1383
is_default= (xorriso->disk_excl_mode==1);
1384
sprintf(line, "-not_mgt %s:%s:%s:%s\n",
1385
(xorriso->disk_excl_mode&1 ? "on" : "off"),
1386
(xorriso->disk_excl_mode&2 ? "param_on" : "param_off"),
1387
(xorriso->disk_excl_mode&4 ? "subtree_on" : "subtree_off"),
1388
(xorriso->disk_excl_mode&8 ? "ignore_on" : "ignore_off"));
1389
if(!(is_default && no_defaults))
1390
Xorriso_status_result(xorriso,filter,fp,flag&2);
1391
1392
is_default= (xorriso->do_iso_rr_pattern==1);
1393
sprintf(line,"-iso_rr_pattern %s\n",
1394
(xorriso->do_iso_rr_pattern == 1 ? "on" :
1395
(xorriso->do_iso_rr_pattern == 2 ? "ls" : "off")));
1396
if(!(is_default && no_defaults))
1397
Xorriso_status_result(xorriso,filter,fp,flag&2);
1398
1399
is_default= (xorriso->do_disk_pattern==2);
1400
sprintf(line,"-disk_pattern %s\n",
1401
(xorriso->do_disk_pattern == 1 ? "on" :
1402
(xorriso->do_disk_pattern == 2 ? "ls" : "off")));
1403
if(!(is_default && no_defaults))
1404
Xorriso_status_result(xorriso,filter,fp,flag&2);
1405
1406
is_default= xorriso->volid_default;
1407
sprintf(line,"-volid %s\n",Text_shellsafe(xorriso->volid,sfe,0));
1408
if(!(is_default && no_defaults))
1409
Xorriso_status_result(xorriso,filter,fp,flag&2);
1410
if(is_default && xorriso->loaded_volid[0] &&
1411
strcmp(xorriso->loaded_volid, xorriso->volid)!=0 && !no_defaults) {
1412
sprintf(line,"# loaded image effective -volid %s\n",
1413
Text_shellsafe(xorriso->loaded_volid,sfe,0));
1414
Xorriso_status_result(xorriso,filter,fp,flag&2);
1415
}
1416
1417
Xorriso_preparer_string(xorriso, xorriso_id, 0);
1418
is_default= (strcmp(xorriso->preparer_id, xorriso_id) == 0);
1419
sprintf(line,"-preparer_id %s\n",Text_shellsafe(xorriso->preparer_id,sfe,0));
1420
if(!(is_default && no_defaults))
1421
Xorriso_status_result(xorriso,filter,fp,flag&2);
1422
1423
is_default= (xorriso->publisher[0]==0);
1424
sprintf(line,"-publisher %s\n",Text_shellsafe(xorriso->publisher,sfe,0));
1425
if(!(is_default && no_defaults))
1426
Xorriso_status_result(xorriso,filter,fp,flag&2);
1427
1428
is_default= (xorriso->application_id[0]==0);
1429
sprintf(line,"-application_id %s\n",
1430
Text_shellsafe(xorriso->application_id,sfe,0));
1431
if(!(is_default && no_defaults))
1432
Xorriso_status_result(xorriso,filter,fp,flag&2);
1433
1434
is_default= (xorriso->system_id[0]==0);
1435
sprintf(line,"-system_id %s\n", Text_shellsafe(xorriso->system_id,sfe,0));
1436
if(!(is_default && no_defaults))
1437
Xorriso_status_result(xorriso,filter,fp,flag&2);
1438
1439
is_default= (xorriso->volset_id[0]==0);
1440
sprintf(line,"-volset_id %s\n", Text_shellsafe(xorriso->volset_id,sfe,0));
1441
if(!(is_default && no_defaults))
1442
Xorriso_status_result(xorriso,filter,fp,flag&2);
1443
1444
is_default= (xorriso->vol_creation_time == 0);
1445
sprintf(line,"-volume_date c %s\n",
1446
is_default ? "default" :
1447
Ftimetxt(xorriso->vol_creation_time, sfe, 2));
1448
if(!(is_default && no_defaults))
1449
Xorriso_status_result(xorriso,filter,fp,flag&2);
1450
1451
is_default= (xorriso->vol_modification_time == 0);
1452
sprintf(line,"-volume_date m %s\n",
1453
xorriso->vol_uuid[0] ? "overridden" :
1454
is_default ? "default" :
1455
Ftimetxt(xorriso->vol_modification_time, sfe, 2));
1456
if(!(is_default && no_defaults))
1457
Xorriso_status_result(xorriso,filter,fp,flag&2);
1458
1459
is_default= (xorriso->vol_expiration_time == 0);
1460
sprintf(line,"-volume_date x %s\n",
1461
is_default ? "default" :
1462
Ftimetxt(xorriso->vol_expiration_time, sfe, 2));
1463
if(!(is_default && no_defaults))
1464
Xorriso_status_result(xorriso,filter,fp,flag&2);
1465
1466
is_default= (xorriso->vol_effective_time == 0);
1467
sprintf(line,"-volume_date f %s\n",
1468
is_default ? "default" :
1469
Ftimetxt(xorriso->vol_effective_time, sfe, 2));
1470
if(!(is_default && no_defaults))
1471
Xorriso_status_result(xorriso,filter,fp,flag&2);
1472
1473
is_default= (xorriso->vol_uuid[0] == 0);
1474
sprintf(line,"-volume_date uuid %s\n",
1475
Text_shellsafe(xorriso->vol_uuid,sfe,0));
1476
if(!(is_default && no_defaults))
1477
Xorriso_status_result(xorriso,filter,fp,flag&2);
1478
1479
is_default= (xorriso->copyright_file[0] == 0);
1480
sprintf(line,"-copyright_file %s\n",
1481
Text_shellsafe(xorriso->copyright_file,sfe,0));
1482
if(!(is_default && no_defaults))
1483
Xorriso_status_result(xorriso,filter,fp,flag&2);
1484
1485
is_default= (xorriso->biblio_file[0]==0);
1486
sprintf(line,"-biblio_file %s\n",Text_shellsafe(xorriso->biblio_file,sfe,0));
1487
if(!(is_default && no_defaults))
1488
Xorriso_status_result(xorriso,filter,fp,flag&2);
1489
1490
is_default= (xorriso->abstract_file[0]==0);
1491
sprintf(line,"-abstract_file %s\n",
1492
Text_shellsafe(xorriso->abstract_file,sfe,0));
1493
if(!(is_default && no_defaults))
1494
Xorriso_status_result(xorriso,filter,fp,flag&2);
1495
1496
is_default= (xorriso->do_joliet==0);
1497
sprintf(line,"-joliet %s\n", (xorriso->do_joliet == 1 ? "on" : "off"));
1498
if(!(is_default && no_defaults))
1499
Xorriso_status_result(xorriso,filter,fp,flag&2);
1500
1501
Xorriso_lst_get_last(xorriso->jigdo_params, &plst, 0);
1502
Xorriso_lst_get_last(xorriso->jigdo_values, &vlst, 0);
1503
if(plst == NULL || vlst == NULL) {
1504
is_default= 1;
1505
sprintf(line,"-jigdo clear 'all'\n");
1506
if(!(is_default && no_defaults))
1507
Xorriso_status_result(xorriso, filter, fp, flag & 2);
1508
}
1509
while(plst != NULL && vlst != NULL) {
1510
sprintf(line,"-jigdo %s %s\n", Xorriso_lst_get_text(plst, 0),
1511
Text_shellsafe(Xorriso_lst_get_text(vlst, 0), sfe, 0));
1512
Xorriso_status_result(xorriso, filter, fp, flag & 2);
1513
plst= Xorriso_lst_get_prev(plst, 0);
1514
vlst= Xorriso_lst_get_prev(vlst, 0);
1515
}
1516
1517
if(xorriso->do_global_uid) {
1518
sprintf(line,"-uid %lu\n", (unsigned long) xorriso->global_uid);
1519
Xorriso_status_result(xorriso,filter,fp,flag&2);
1520
}
1521
1522
if(xorriso->do_global_gid) {
1523
sprintf(line,"-gid %lu\n", (unsigned long) xorriso->global_gid);
1524
Xorriso_status_result(xorriso,filter,fp,flag&2);
1525
}
1526
1527
Xorriso_status_extf(xorriso, filter, fp, flag & 2);
1528
Xorriso_status_zisofs(xorriso, filter, fp, flag & 3);
1529
1530
is_default= !xorriso->allow_graft_points;
1531
sprintf(line,"-pathspecs %s\n", xorriso->allow_graft_points ? "on" : "off");
1532
if(!(is_default && no_defaults))
1533
Xorriso_status_result(xorriso,filter,fp,flag&2);
1534
1535
is_default= (xorriso->do_follow_pattern && (!xorriso->do_follow_param)
1536
&& xorriso->do_follow_mount && (!xorriso->do_follow_links)
1537
&& xorriso->follow_link_limit==100);
1538
mode[0]= 0;
1539
if(xorriso->do_follow_pattern &&
1540
!(xorriso->do_follow_links && xorriso->do_follow_mount))
1541
strcat(mode,":pattern");
1542
if(xorriso->do_follow_param && !(xorriso->do_follow_links))
1543
strcat(mode,":param");
1544
if(xorriso->do_follow_links)
1545
strcat(mode,":link");
1546
if(xorriso->do_follow_mount)
1547
strcat(mode,":mount");
1548
if(mode[0]==0)
1549
strcpy(mode, ":off");
1550
sprintf(mode+strlen(mode), ":limit=%d", xorriso->follow_link_limit);
1551
sprintf(line,"-follow %s\n", mode+1);
1552
if(!(is_default && no_defaults))
1553
Xorriso_status_result(xorriso,filter,fp,flag&2);
1554
1555
is_default= (xorriso->do_overwrite==2);
1556
sprintf(line,"-overwrite %s\n",(xorriso->do_overwrite == 1 ? "on" :
1557
(xorriso->do_overwrite == 2 ? "nondir" : "off")));
1558
if(!(is_default && no_defaults))
1559
Xorriso_status_result(xorriso,filter,fp,flag&2);
1560
1561
is_default= !xorriso->do_reassure;
1562
sprintf(line,"-reassure %s\n",(xorriso->do_reassure == 1 ? "on" :
1563
(xorriso->do_reassure == 2 ? "tree" : "off")));
1564
if(!(is_default && no_defaults))
1565
Xorriso_status_result(xorriso,filter,fp,flag&2);
1566
1567
is_default= !xorriso->do_close;
1568
sprintf(line,"-close %s\n",(xorriso->do_close ? "on" : "off"));
1569
if(!(is_default && no_defaults))
1570
Xorriso_status_result(xorriso,filter,fp,flag&2);
1571
1572
is_default= !xorriso->do_dummy;
1573
sprintf(line,"-dummy %s\n",(xorriso->do_dummy ? "on" : "off"));
1574
if(!(is_default && no_defaults))
1575
Xorriso_status_result(xorriso,filter,fp,flag&2);
1576
1577
is_default= (xorriso->speed==0);
1578
sprintf(line,"-speed %dkB/s\n", xorriso->speed);
1579
if(!(is_default && no_defaults))
1580
Xorriso_status_result(xorriso,filter,fp,flag&2);
1581
1582
is_default= (xorriso->do_stream_recording==0);
1583
strcpy(mode, "off");
1584
if(xorriso->do_stream_recording == 1)
1585
strcpy(mode, "full");
1586
if(xorriso->do_stream_recording == 2)
1587
strcpy(mode, "data");
1588
else if(xorriso->do_stream_recording == 32)
1589
strcpy(mode, "on");
1590
else if(xorriso->do_stream_recording >= 16)
1591
sprintf(mode, "%ds", xorriso->do_stream_recording);
1592
sprintf(line,"-stream_recording %s\n", mode);
1593
if(!(is_default && no_defaults))
1594
Xorriso_status_result(xorriso,filter,fp,flag&2);
1595
1596
is_default= (xorriso->dvd_obs == 0);
1597
strcpy(mode, "default");
1598
if(xorriso->dvd_obs == 32768 || xorriso->dvd_obs == 65536)
1599
sprintf(mode, "%dk", xorriso->dvd_obs / 1024);
1600
sprintf(line,"-dvd_obs %s\n", mode);
1601
if(!(is_default && no_defaults))
1602
Xorriso_status_result(xorriso,filter,fp,flag&2);
1603
1604
is_default= (xorriso->stdio_sync == 0);
1605
strcpy(line, "-stdio_sync ");
1606
if(xorriso->stdio_sync == -1)
1607
strcat(line, "off");
1608
else if(xorriso->stdio_sync == 0)
1609
strcat(line, "on");
1610
else if(xorriso->stdio_sync % 512) {
1611
Sfile_off_t_text(line+strlen(line), (off_t) (xorriso->stdio_sync * 2048),
1612
0);
1613
} else {
1614
Sfile_off_t_text(line+strlen(line), (off_t) (xorriso->stdio_sync / 512), 0);
1615
strcat(line, "m");
1616
}
1617
strcat(line, "\n");
1618
if(!(is_default && no_defaults))
1619
Xorriso_status_result(xorriso,filter,fp,flag&2);
1620
1621
is_default= (xorriso->fs==4*512);
1622
if((xorriso->fs/512)*512==xorriso->fs)
1623
sprintf(line,"-fs %dm\n", xorriso->fs/512);
1624
else
1625
sprintf(line,"-fs %dk\n", xorriso->fs*2);
1626
if(!(is_default && no_defaults))
1627
Xorriso_status_result(xorriso,filter,fp,flag&2);
1628
1629
is_default= (xorriso->padding==300*1024);
1630
sprintf(line,"-padding %dk\n", xorriso->padding/1024);
1631
if(!(is_default && no_defaults))
1632
Xorriso_status_result(xorriso,filter,fp,flag&2);
1633
is_default= (xorriso->do_padding_by_libisofs == 0);
1634
sprintf(line,"-padding %s\n",
1635
xorriso->do_padding_by_libisofs ? "included" : "appended");
1636
if(!(is_default && no_defaults))
1637
Xorriso_status_result(xorriso,filter,fp,flag&2);
1638
1639
is_default= (strcmp(xorriso->report_about_text,"UPDATE")==0);
1640
sprintf(line,"-report_about %s\n",xorriso->report_about_text);
1641
if(!(is_default && no_defaults))
1642
Xorriso_status_result(xorriso,filter,fp,flag&2);
1643
1644
is_default= (xorriso->scsi_log == 0);
1645
sprintf(line,"-scsi_log %s\n", xorriso->scsi_log ? "on" : "off");
1646
if(!(is_default && no_defaults))
1647
Xorriso_status_result(xorriso,filter,fp,flag&2);
1648
1649
is_default= (xorriso->session_logfile[0]==0);
1650
sprintf(line,"-session_log %s\n",
1651
Text_shellsafe(xorriso->session_logfile,sfe,0));
1652
if(!(is_default && no_defaults))
1653
Xorriso_status_result(xorriso,filter,fp,flag&2);
1654
1655
is_default= (xorriso->pacifier_style==0);
1656
sprintf(line,"-pacifier '%s'\n",
1657
xorriso->pacifier_style==1 ? "mkisofs" :
1658
xorriso->pacifier_style==2 ? "cdrecord" : "xorriso");
1659
if(!(is_default && no_defaults))
1660
Xorriso_status_result(xorriso,filter,fp,flag&2);
1661
1662
is_default= (strcmp(xorriso->return_with_text,"SORRY")==0 &&
1663
xorriso->return_with_value==32);
1664
sprintf(line,"-return_with %s %d\n",
1665
xorriso->return_with_text, xorriso->return_with_value);
1666
if(!(is_default && no_defaults))
1667
Xorriso_status_result(xorriso,filter,fp,flag&2);
1668
1669
is_default= (strcmp(xorriso->abort_on_text,"FATAL")==0);
1670
sprintf(line,"-abort_on %s\n",xorriso->abort_on_text);
1671
if(!(is_default && no_defaults))
1672
Xorriso_status_result(xorriso,filter,fp,flag&2);
1673
1674
if(xorriso->status_history_max!=Xorriso_status_history_maX || !no_defaults) {
1675
sprintf(line,"-status_history_max %d\n",xorriso->status_history_max);
1676
Xorriso_status_result(xorriso,filter,fp,flag&2);
1677
}
1678
1679
#ifdef Xorriso_with_readlinE
1680
1681
if((flag&8) && xorriso->status_history_max>0) {
1682
HIST_ENTRY **hl;
1683
int hc,i;
1684
1685
hl= history_list();
1686
if(hl!=NULL) {
1687
for(hc= 0;hl[hc]!=NULL;hc++);
1688
if(hc>0)
1689
if(strcmp(hl[hc-1]->line,"-end")==0)
1690
hc--;
1691
if(hc>=xorriso->status_history_max)
1692
i= hc-xorriso->status_history_max;
1693
else
1694
i= 0;
1695
for(;i<hc;i++) {
1696
sprintf(line,"-history %s\n",Text_shellsafe(hl[i]->line,sfe,0));
1697
Xorriso_status_result(xorriso,filter,fp,flag&2);
1698
}
1699
}
1700
}
1701
1702
#endif /* Xorriso_with_readlinE */
1703
1704
is_default= (xorriso->toc_emulation_flag == 0);
1705
sprintf(line,"-rom_toc_scan %s%s\n",
1706
xorriso->toc_emulation_flag & 4 ? "force" :
1707
xorriso->toc_emulation_flag & 1 ? "on" : "off",
1708
xorriso->toc_emulation_flag & 2 ? ":emul_off" : "");
1709
if(!(is_default && no_defaults))
1710
Xorriso_status_result(xorriso, filter, fp, flag & 2);
1711
1712
is_default= (xorriso->displacement == 0);
1713
sprintf(line, "-displacement %s%lu\n",
1714
xorriso->displacement_sign < 0 ? "-" : "",
1715
(unsigned long) xorriso->displacement);
1716
if(!(is_default && no_defaults))
1717
Xorriso_status_result(xorriso, filter, fp, flag & 2);
1718
1719
adr_mode= xorriso->image_start_mode & 0xffff;
1720
if(adr_mode>=0 && adr_mode<=max_load_mode) {
1721
is_default= (adr_mode==0);
1722
sprintf(line,"-load %s ", load_names[adr_mode]);
1723
if(adr_mode==0)
1724
sprintf(line+strlen(line),"''\n");
1725
else if(adr_mode>=1 && adr_mode<=3)
1726
sprintf(line+strlen(line),"%s\n", xorriso->image_start_value);
1727
else
1728
sprintf(line+strlen(line),"%s\n",
1729
Text_shellsafe(xorriso->image_start_value, sfe, 0));
1730
if(!(is_default && no_defaults))
1731
Xorriso_status_result(xorriso,filter,fp,flag&2);
1732
}
1733
1734
is_default= (xorriso->do_calm_drive & 1);
1735
sprintf(line,"-calm_drive %s\n", xorriso->do_calm_drive & 1 ? "on" : "off");
1736
if(!(is_default && no_defaults))
1737
Xorriso_status_result(xorriso,filter,fp,flag&2);
1738
1739
is_default= (xorriso->grow_blindly_msc2<0);
1740
sprintf(sfe, "%d", xorriso->grow_blindly_msc2);
1741
sprintf(line,"-grow_blindly %s\n",
1742
xorriso->grow_blindly_msc2 < 0 ? "off" : sfe);
1743
if(!(is_default && no_defaults))
1744
Xorriso_status_result(xorriso,filter,fp,flag&2);
1745
1746
Xorriso_get_local_charset(xorriso, &local_charset, 0);
1747
nl_charset= nl_langinfo(CODESET);
1748
is_default= (strcmp(local_charset, nl_charset) == 0);
1749
sprintf(line, "-local_charset %s\n", Text_shellsafe(local_charset, sfe, 0));
1750
if(!(is_default && no_defaults))
1751
Xorriso_status_result(xorriso, filter, fp, flag & 2);
1752
1753
is_default= (xorriso->out_charset == NULL && xorriso->in_charset == NULL);
1754
in_pt= "";
1755
if(xorriso->in_charset != NULL)
1756
in_pt= xorriso->in_charset;
1757
out_pt= "";
1758
if(xorriso->out_charset != NULL)
1759
out_pt= xorriso->out_charset;
1760
do_single= 0;
1761
ret= Xorriso_status_filter(xorriso, filter, "-in_charset", 0);
1762
if(ret <= 0)
1763
ret= Xorriso_status_filter(xorriso, filter, "-out_charset", 0);
1764
if(ret > 0)
1765
do_single= 1;
1766
if(strcmp(in_pt, out_pt) == 0 && !do_single) {
1767
sprintf(line, "-charset %s\n", Text_shellsafe(in_pt, sfe, 0));
1768
if(!(is_default && no_defaults))
1769
Xorriso_status_result(xorriso, filter, fp, flag & 2);
1770
} else {
1771
sprintf(line, "-in_charset %s\n", Text_shellsafe(in_pt, sfe, 0));
1772
if(!(is_default && no_defaults))
1773
Xorriso_status_result(xorriso, filter, fp, flag & 2);
1774
sprintf(line, "-out_charset %s\n", Text_shellsafe(out_pt, sfe, 0));
1775
if(!(is_default && no_defaults))
1776
Xorriso_status_result(xorriso, filter, fp, flag & 2);
1777
}
1778
is_default= ((xorriso->do_aaip & (256 | 512)) == 0);
1779
sprintf(line,"-auto_charset %s\n", (xorriso->do_aaip & 256 ? "on" : "off"));
1780
if(!(is_default && no_defaults))
1781
Xorriso_status_result(xorriso,filter,fp,flag&2);
1782
1783
is_default= ((xorriso->ino_behavior & 31) == 7);
1784
switch (xorriso->ino_behavior & 15) {
1785
case 0: form= "on";
1786
break; case 8: form= "without_update";
1787
break; default: form= "off";
1788
}
1789
sprintf(line,"-hardlinks %s:%s\n", form,
1790
xorriso->ino_behavior & 16 ?
1791
"cheap_sorted_extract" : "normal_extract");
1792
if(!(is_default && no_defaults))
1793
Xorriso_status_result(xorriso,filter,fp,flag&2);
1794
1795
is_default= ((xorriso->do_aaip & (1 | 4)) == 0);
1796
sprintf(line,"-acl %s\n", (xorriso->do_aaip & 1 ? "on" : "off"));
1797
if(!(is_default && no_defaults))
1798
Xorriso_status_result(xorriso,filter,fp,flag&2);
1799
is_default= ((xorriso->do_aaip & (2 | 8)) == 0);
1800
sprintf(line,"-xattr %s\n", (xorriso->do_aaip & 4 ? "on" : "off"));
1801
if(!(is_default && no_defaults))
1802
Xorriso_status_result(xorriso,filter,fp,flag&2);
1803
is_default= ((xorriso->do_aaip & (16 | 32 | 64)) == 0);
1804
sprintf(line,"-disk_dev_ino %s\n",
1805
(xorriso->do_aaip & 16 ? (xorriso->do_aaip & 128 ? "ino_only" : "on" )
1806
: "off"));
1807
if(!(is_default && no_defaults))
1808
Xorriso_status_result(xorriso,filter,fp,flag&2);
1809
1810
is_default= ((xorriso->do_md5 & 31) == 0);
1811
sprintf(line, "-md5 ");
1812
if(xorriso->do_md5 & 1) {
1813
if((xorriso->do_md5 & 8) == 8) {
1814
strcat(line, "all");
1815
} else {
1816
strcat(line, "on");
1817
if(xorriso->do_md5 & 8)
1818
strcat(line, ":stability_check_on");
1819
}
1820
if(xorriso->do_md5 & 32)
1821
strcat(line, ":load_check_off");
1822
strcat(line, "\n");
1823
} else
1824
strcat(line, "off\n");
1825
if(!(is_default && no_defaults))
1826
Xorriso_status_result(xorriso,filter,fp,flag&2);
1827
1828
is_default= (xorriso->scdbackup_tag_name[0] == 0 &&
1829
xorriso->scdbackup_tag_listname[0] == 0);
1830
sprintf(line, "-scdbackup_tag ");
1831
Text_shellsafe(xorriso->scdbackup_tag_listname, line, 1);
1832
strcat(line, " ");
1833
Text_shellsafe(xorriso->scdbackup_tag_name, line, 1);
1834
strcat(line, "\n");
1835
if(!(is_default && no_defaults))
1836
Xorriso_status_result(xorriso,filter,fp,flag&2);
1837
1838
is_default= (Xorriso_get_relax_text(xorriso, sfe, 0) == 2);
1839
sprintf(line,"-compliance %s\n", sfe);
1840
if(!(is_default && no_defaults))
1841
Xorriso_status_result(xorriso,filter,fp,flag&2);
1842
1843
is_default= (xorriso->assert_volid[0] == 0);
1844
sprintf(line, "-assert_volid ");
1845
Text_shellsafe(xorriso->assert_volid, line, 1);
1846
strcat(line, " ");
1847
Text_shellsafe(xorriso->assert_volid_sev, line, 1);
1848
strcat(line, "\n");
1849
if(!(is_default && no_defaults))
1850
Xorriso_status_result(xorriso,filter,fp,flag&2);
1851
1852
is_default= 1;
1853
if(xorriso->drive_blacklist != NULL || xorriso->drive_whitelist != NULL ||
1854
xorriso->drive_greylist == NULL)
1855
is_default= 0;
1856
if(xorriso->drive_greylist != NULL) {
1857
if(strcmp(Xorriso_get_pattern(xorriso, xorriso->drive_greylist, 0, 0),
1858
"/dev") != 0)
1859
is_default= 0;
1860
if(Xorriso_get_pattern(xorriso, xorriso->drive_greylist, 1, 0) != NULL)
1861
is_default= 0;
1862
}
1863
if(!(is_default && no_defaults)) {
1864
for(s= xorriso->drive_blacklist; s != NULL; s= Xorriso_lst_get_next(s, 0)) {
1865
sprintf(line, "-drive_class 'banned' %s\n",
1866
Text_shellsafe(Xorriso_lst_get_text(s, 0), sfe, 0));
1867
Xorriso_status_result(xorriso,filter,fp,flag&2);
1868
}
1869
for(s= xorriso->drive_greylist; s != NULL; s= Xorriso_lst_get_next(s, 0)) {
1870
sprintf(line, "-drive_class 'caution' %s\n",
1871
Text_shellsafe(Xorriso_lst_get_text(s, 0), sfe, 0));
1872
Xorriso_status_result(xorriso,filter,fp,flag&2);
1873
}
1874
for(s= xorriso->drive_whitelist; s != NULL; s= Xorriso_lst_get_next(s, 0)) {
1875
sprintf(line, "-drive_class 'harmless' %s\n",
1876
Text_shellsafe(Xorriso_lst_get_text(s, 0), sfe, 0));
1877
Xorriso_status_result(xorriso,filter,fp,flag&2);
1878
}
1879
}
1880
1881
do_single= 0;
1882
dev_filter= filter;
1883
if(dev_filter != NULL) {
1884
show_dev= Xorriso_status_filter(xorriso, filter, "-dev", 0);
1885
if(show_dev > 0)
1886
dev_filter= NULL;
1887
}
1888
if(dev_filter != NULL) {
1889
show_indev= Xorriso_status_filter(xorriso, filter, "-indev", 0);
1890
show_outdev= Xorriso_status_filter(xorriso, filter, "-outdev", 0);
1891
if(show_outdev > 0 || show_indev > 0)
1892
do_single= 1;
1893
}
1894
if(xorriso->drives_exclusive != xorriso->indev_is_exclusive &&
1895
xorriso->indev[0])
1896
do_single= 1;
1897
else if(xorriso->drives_exclusive != xorriso->outdev_is_exclusive &&
1898
xorriso->outdev[0])
1899
do_single= 1;
1900
if(strcmp(xorriso->indev, xorriso->outdev) == 0 && !do_single) {
1901
sprintf(line,"-dev %s\n", Text_shellsafe(xorriso->indev,sfe,0));
1902
Xorriso_status_result(xorriso, dev_filter, fp, flag & 2);
1903
} else {
1904
if(xorriso->drives_exclusive != xorriso->indev_is_exclusive &&
1905
xorriso->indev[0] && show_indev) {
1906
sprintf(line,"-osirrox o_excl_%s\n",
1907
xorriso->indev_is_exclusive ? "on" : "off");
1908
Xorriso_status_result(xorriso, NULL, fp, flag & 2);
1909
}
1910
sprintf(line,"-indev %s\n", Text_shellsafe(xorriso->indev,sfe,0));
1911
Xorriso_status_result(xorriso, dev_filter, fp, flag & 2);
1912
if(xorriso->drives_exclusive != xorriso->indev_is_exclusive &&
1913
xorriso->indev[0] && show_indev) {
1914
sprintf(line,"-osirrox o_excl_%s\n",
1915
xorriso->drives_exclusive ? "on" : "off");
1916
Xorriso_status_result(xorriso, NULL, fp, flag & 2);
1917
}
1918
1919
if(xorriso->drives_exclusive != xorriso->outdev_is_exclusive &&
1920
xorriso->outdev[0] && show_outdev) {
1921
sprintf(line,"-osirrox o_excl_%s\n",
1922
xorriso->outdev_is_exclusive ? "on" : "off");
1923
Xorriso_status_result(xorriso, NULL, fp, flag & 2);
1924
}
1925
sprintf(line,"-outdev %s\n", Text_shellsafe(xorriso->outdev,sfe,0));
1926
Xorriso_status_result(xorriso, dev_filter, fp, flag & 2);
1927
if(xorriso->drives_exclusive != xorriso->outdev_is_exclusive &&
1928
xorriso->outdev[0] && show_outdev) {
1929
sprintf(line,"-osirrox o_excl_%s\n",
1930
xorriso->drives_exclusive ? "on" : "off");
1931
Xorriso_status_result(xorriso, NULL, fp, flag & 2);
1932
}
1933
}
1934
1935
return(1);
1936
}
1937
1938
1939
int Xorriso_pacifier_reset(struct XorrisO *xorriso, int flag)
1940
{
1941
xorriso->start_time= Sfile_microtime(0);
1942
xorriso->last_update_time= xorriso->start_time;
1943
xorriso->pacifier_count= 0;
1944
xorriso->pacifier_total= 0;
1945
xorriso->pacifier_byte_count= 0;
1946
return(1);
1947
}
1948
1949
1950
/* This call is to be issued by long running workers in short intervals.
1951
It will check whether enough time has elapsed since the last pacifier
1952
message and eventually issue an update message.
1953
@param what_done A sparse description of the action, preferrably in past
1954
tense. E.g. "done" , "files added".
1955
@param count The number of objects processed so far.
1956
Is ignored if <=0.
1957
@param todo The number of objects to be done in total.
1958
Is ignored if <=0.
1959
@param current_object A string telling the object currently processed.
1960
Ignored if "".
1961
@param flag bit0= report unconditionally, no time check
1962
bit1= report count <=0 (no thank you for being patient then)
1963
bit2= report xorriso->pacifier_byte_count
1964
bit6= report with carriage return rather than line feed
1965
*/
1966
int Xorriso_pacifier_callback(struct XorrisO *xorriso, char *what_done,
1967
off_t count, off_t todo, char *current_object,
1968
int flag)
1969
{
1970
double current_time, since;
1971
char count_text[80], byte_text[80];
1972
1973
current_time= Sfile_microtime(0);
1974
if(current_time - xorriso->last_update_time < xorriso->pacifier_interval
1975
&& !(flag&1))
1976
return(1);
1977
xorriso->last_update_time= Sfile_microtime(0);
1978
since= current_time - xorriso->start_time;
1979
if((flag&1)&&since<1.0)
1980
since= 1.0;
1981
byte_text[0]= 0;
1982
if(flag&4) {
1983
strcat(byte_text, " (");
1984
Sfile_scale((double) xorriso->pacifier_byte_count,
1985
byte_text+strlen(byte_text), 7, 1e5, 0);
1986
strcat(byte_text, ")");
1987
}
1988
if(count<=0.0 && !(flag&2)) {
1989
if(since < 2)
1990
return(2);
1991
sprintf(xorriso->info_text,
1992
"Thank you for being patient for %.f seconds", since);
1993
} else if(todo<=0.0) {
1994
if(count<10000000)
1995
sprintf(count_text, "%.f", (double) count);
1996
else
1997
Sfile_scale((double) count, count_text, 7, 1e5, 1);
1998
sprintf(xorriso->info_text, "%s %s%s in %.f %s",
1999
count_text, what_done, byte_text, since, (flag&64) ? "s" : "seconds");
2000
} else {
2001
sprintf(xorriso->info_text, "%.f of %.f %s%s in %.f seconds",
2002
(double) count, (double) todo, what_done, byte_text, since);
2003
}
2004
if(current_object[0]!=0)
2005
sprintf(xorriso->info_text+strlen(xorriso->info_text),
2006
", now at %s", current_object);
2007
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "UPDATE", (flag&64));
2008
return(1);
2009
}
2010
2011
2012
int Xorriso_reset_counters(struct XorrisO *xorriso, int flag)
2013
{
2014
xorriso->error_count= 0;
2015
xorriso->insert_count= 0;
2016
xorriso->insert_bytes= 0;
2017
Xorriso_pacifier_reset(xorriso, 0);
2018
return(1);
2019
}
2020
2021
2022
int Xorriso_no_malloc_memory(struct XorrisO *xorriso, char **to_free, int flag)
2023
{
2024
if(to_free!=NULL)
2025
if(*to_free!=NULL) {
2026
/* Eventual memory sacrifice to get on going */
2027
free(*to_free);
2028
*to_free= NULL;
2029
}
2030
sprintf(xorriso->info_text, "Out of virtual memory");
2031
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "ABORT", 0);
2032
return(1);
2033
}
2034
2035
2036
/* @param flag bit0=path is in source filesystem , bit1= unconditionally */
2037
int Xorriso_much_too_long(struct XorrisO *xorriso, int len, int flag)
2038
{
2039
if(len>=SfileadrL || (flag&2)) {
2040
sprintf(xorriso->info_text,
2041
"Path given for %s is much too long (%d)",
2042
((flag&1) ? "local filesystem" : "ISO image"), len);
2043
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
2044
return(0);
2045
}
2046
return(1);
2047
}
2048
2049
2050
int Xorriso_no_findjob(struct XorrisO *xorriso, char *cmd, int flag)
2051
{
2052
sprintf(xorriso->info_text, "%s: cannot create find job object", cmd);
2053
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
2054
return(1);
2055
}
2056
2057
2058
int Xorriso_report_md5_outcome(struct XorrisO *xorriso, char *severity,
2059
int flag)
2060
{
2061
int has_md5;
2062
2063
has_md5= Xorriso_image_has_md5(xorriso, 0);
2064
if(xorriso->find_check_md5_result & 1) {
2065
sprintf(xorriso->result_line,
2066
"Mismatch detected between file contents and MD5 checksums.\n");
2067
} else if(xorriso->find_check_md5_result & 8) {
2068
sprintf(xorriso->result_line,
2069
"File contents and their MD5 checksums match.\n");
2070
} else {
2071
sprintf(xorriso->result_line,
2072
"Not a single file with MD5 checksum was found.");
2073
if(has_md5 <= 0)
2074
strcat(xorriso->result_line,
2075
" (There is no MD5 checksum array loaded.)\n");
2076
else
2077
strcat(xorriso->result_line, "\n");
2078
}
2079
Xorriso_result(xorriso,0);
2080
if(xorriso->find_check_md5_result & 2) {
2081
sprintf(xorriso->result_line,
2082
"Encountered errors other than non-match during MD5 checking.\n");
2083
Xorriso_result(xorriso,0);
2084
}
2085
if((xorriso->find_check_md5_result & 4) && has_md5) {
2086
sprintf(xorriso->result_line,
2087
"There were data files which have no MD5 and thus could not be checked.\n");
2088
Xorriso_result(xorriso,0);
2089
}
2090
if((xorriso->find_check_md5_result & 3) && strcmp(severity, "ALL") != 0) {
2091
sprintf(xorriso->info_text, "Event triggered by MD5 comparison mismatch");
2092
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, severity, 0);
2093
}
2094
return(1);
2095
}
2096
Loggerhead is a web-based interface for Breezy
Version: 2.0.1