2917 lines
89 KiB
C
2917 lines
89 KiB
C
|
|
/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
|
|
|
|
Copyright 2007-2012 Thomas Schmitt, <scdbackup@gmx.net>
|
|
|
|
Provided under GPL version 2 or later.
|
|
|
|
This file contains the implementation of text i/o functions.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "../config.h"
|
|
#endif
|
|
|
|
#include <ctype.h>
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/time.h>
|
|
#include <time.h>
|
|
#include <errno.h>
|
|
#include <signal.h>
|
|
#include <pthread.h>
|
|
|
|
|
|
/* for -charset */
|
|
#include <iconv.h>
|
|
#include <langinfo.h>
|
|
#include <locale.h>
|
|
|
|
|
|
#ifdef Xorriso_with_readlinE
|
|
#ifdef Xorriso_with_old_readlinE
|
|
#include <readline.h>
|
|
#include <history.h>
|
|
#else /* Xorriso_with_old_readlinE */
|
|
#include <readline/readline.h>
|
|
#include <readline/history.h>
|
|
#endif /* ! Xorriso_with_old_readlinE */
|
|
#endif /* Xorriso_with_readlinE */
|
|
|
|
|
|
#include "xorriso.h"
|
|
#include "xorriso_private.h"
|
|
#include "xorrisoburn.h"
|
|
|
|
|
|
int Xorriso_protect_stdout(struct XorrisO *xorriso, int flag)
|
|
{
|
|
if(xorriso->dev_fd_1>=0)
|
|
return(2);
|
|
xorriso->dev_fd_1= dup(1);
|
|
close(1);
|
|
dup2(2,1);
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_dialog_input(struct XorrisO *xorriso, char line[], int linesize,
|
|
int flag)
|
|
/*
|
|
bit0= do not write to history
|
|
bit1= do not read input (but eventually write to history)
|
|
bit2= do not write to history line which begin with "-history:" or "-history "
|
|
*/
|
|
{
|
|
char *cpt= NULL, **argv= NULL, *linept, *why_append= "";
|
|
int ret, argc= 0, base_length= 0, l, append_line;
|
|
#ifdef Xorriso_with_readlinE
|
|
static char last_input[SfileadrL]= {""};
|
|
#endif /* ! Xorriso_with_readlinE */
|
|
double tdiff;
|
|
struct timeval tv;
|
|
struct timezone tz;
|
|
|
|
gettimeofday(&tv,&tz);
|
|
tdiff= tv.tv_sec+(1.e-6*(double) tv.tv_usec);
|
|
|
|
fflush(stdout);
|
|
linept= line;
|
|
|
|
get_single:;
|
|
#ifdef Xorriso_with_readlinE
|
|
|
|
if(xorriso->use_stdin || xorriso->dev_fd_1>=0) {
|
|
if(flag&2)
|
|
{ret= 1; goto ex;}
|
|
if(Sfile_fgets_n(linept,linesize - base_length - 1, stdin,
|
|
(xorriso->dialog == 2)) == NULL) {
|
|
/* need a very dramatic end */
|
|
kill(getpid(),SIGHUP);
|
|
{ret= -1; goto ex;}
|
|
}
|
|
goto process_single;
|
|
}
|
|
if(flag&2) {
|
|
cpt= NULL;
|
|
} else {
|
|
cpt= readline("");
|
|
if(cpt==NULL) {
|
|
/* need a very dramatic end */
|
|
kill(getpid(),SIGHUP);
|
|
{ret= -1; goto ex;}
|
|
}
|
|
l= strlen(cpt);
|
|
if(l >= linesize - base_length - 1) {
|
|
strncpy(linept, cpt, linesize - 1);
|
|
line[linesize - 1]= 0;
|
|
sprintf(xorriso->info_text,"Input line too long !");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
|
|
goto new_empty;
|
|
} else
|
|
strcpy(linept, cpt);
|
|
}
|
|
|
|
process_single:;
|
|
|
|
#else /* Xorriso_with_readlinE */
|
|
|
|
if(flag&2)
|
|
{ret= 1; goto ex;}
|
|
if(Sfile_fgets_n(linept, linesize - base_length - 1, stdin,
|
|
(xorriso->dialog == 2)) == NULL) {
|
|
/* need a very dramatic end */
|
|
kill(getpid(),SIGHUP);
|
|
{ret= -1; goto ex;}
|
|
}
|
|
|
|
#endif /* ! Xorriso_with_readlinE */
|
|
|
|
if(xorriso->dialog == 2) {
|
|
append_line= 0;
|
|
if(linept != line && strcmp(linept, "@@@") == 0) {
|
|
sprintf(xorriso->info_text, "Incomplete input line cleared by %s",
|
|
linept);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE",0);
|
|
new_empty:;
|
|
line[0]= 0;
|
|
linept= line;
|
|
sprintf(xorriso->info_text, "-------------------------------------\n");
|
|
Xorriso_info(xorriso,0);
|
|
sprintf(xorriso->info_text, "Enter new text for empty input line :\n");
|
|
Xorriso_info(xorriso,0);
|
|
goto get_single;
|
|
}
|
|
l= strlen(line);
|
|
ret= Sfile_make_argv("", line, &argc, &argv, 16);
|
|
if(ret < 0)
|
|
goto ex;
|
|
if(ret == 0 && !append_line) {
|
|
/* append a newline character */
|
|
if(l >= linesize - 1) {
|
|
sprintf(xorriso->info_text,"Input line too long !");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
|
|
goto new_empty;
|
|
}
|
|
line[l]= '\n';
|
|
line[l + 1]= 0;
|
|
append_line= 1;
|
|
why_append= "Quoted newline char";
|
|
}
|
|
if(l > 0 && !append_line)
|
|
if(line[l - 1] == '\\') {
|
|
line[l - 1]= 0;
|
|
append_line= 1;
|
|
why_append= "Trailing backslash ";
|
|
}
|
|
if(append_line) {
|
|
base_length= strlen(line);
|
|
linept= line + base_length;
|
|
sprintf(xorriso->info_text,
|
|
"---------------------------------------------------------------\n");
|
|
Xorriso_info(xorriso,0);
|
|
sprintf(xorriso->info_text,
|
|
"%s : Enter rest of line (or @@@ to clear it) :\n", why_append);
|
|
Xorriso_info(xorriso,0);
|
|
goto get_single;
|
|
}
|
|
}
|
|
|
|
#ifdef Xorriso_with_readlinE
|
|
|
|
if(line[0]!=0 && strcmp(last_input,line)!=0 && !(flag&1))
|
|
if(!((flag&4) &&
|
|
(strncmp(line,"-history:",9)==0 || strncmp(line,"-history ",9)==0))) {
|
|
add_history(line);
|
|
strncpy(last_input,line,sizeof(last_input)-1);
|
|
last_input[sizeof(last_input)-1]= 0;
|
|
}
|
|
|
|
#endif /* ! Xorriso_with_readlinE */
|
|
|
|
ret= 1;
|
|
ex:;
|
|
if(cpt!=NULL)
|
|
free(cpt);
|
|
gettimeofday(&tv,&tz);
|
|
xorriso->idle_time+= tv.tv_sec+(1.e-6*(double) tv.tv_usec)-tdiff;
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_request_confirmation(struct XorrisO *xorriso, int flag)
|
|
/*
|
|
bit0= important operation going on:
|
|
demand confirmation of abort, only abort on @@@
|
|
bit1= mark '@' and '@@' by return 4
|
|
bit2= accept: i|n= ignore | do not remove , r|y= retry | remove , q|x= abort
|
|
bit3= @@@ = 'done reading' rather than 'abort'
|
|
bit4= in non-dialog mode return 6 rather than 1
|
|
*/
|
|
/* return: <=0 error
|
|
1= go on | do not remove existing file
|
|
2= abort
|
|
3= redo request for confirmation
|
|
4= see flag bit1
|
|
(5= skip volume)
|
|
6= retry failed operation | remove existing file
|
|
*/
|
|
{
|
|
int ret;
|
|
char *line= NULL, *cpt, *previous_line= NULL;
|
|
char *abort_req_text,*abort_really_text;
|
|
|
|
Xorriso_alloc_meM(line, char, SfileadrL);
|
|
Xorriso_alloc_meM(previous_line, char, SfileadrL);
|
|
|
|
if(!xorriso->dialog) {
|
|
if(flag&16)
|
|
{ret= 6; goto ex;}
|
|
{ret= 1; goto ex;}
|
|
}
|
|
if(flag&8) {
|
|
abort_req_text= "request to end";
|
|
abort_really_text= "done reading";
|
|
} else {
|
|
abort_req_text= "request to abort";
|
|
abort_really_text= "abort this command";
|
|
}
|
|
ret= Xorriso_dialog_input(xorriso,line, SfileadrL, 1);
|
|
xorriso->result_line_counter= 0;
|
|
xorriso->result_page_counter++;
|
|
if(ret<=0)
|
|
if(xorriso->result_page_length>0)
|
|
xorriso->result_page_length= -xorriso->result_page_length;
|
|
|
|
cpt= line;
|
|
if(strcmp(cpt,"@@@")==0 ||
|
|
strcmp(cpt,"x")==0 || strcmp(cpt,"X")==0 ||
|
|
strcmp(cpt,"q")==0 || strcmp(cpt,"Q")==0) {
|
|
if(flag&1) {
|
|
strcpy(previous_line,cpt);
|
|
sprintf(xorriso->info_text,
|
|
"... [%s = %s registered. Really %s ? (y/n) ] ...\n",
|
|
cpt,abort_req_text,abort_really_text);
|
|
Xorriso_info(xorriso,0);
|
|
ret= Xorriso_dialog_input(xorriso,line, SfileadrL, 1);
|
|
if(ret<=0)
|
|
goto ex;
|
|
cpt= line;
|
|
if(strcmp(cpt,previous_line)==0 ||
|
|
((*cpt=='Y' || *cpt=='y' || *cpt=='j' || *cpt=='J' || *cpt=='1') &&
|
|
*(cpt+1)==0)) {
|
|
xorriso->request_to_abort= 1;
|
|
sprintf(xorriso->info_text,
|
|
"------- ( %s confirmed )\n",abort_req_text);
|
|
Xorriso_info(xorriso,0);
|
|
{ret= 2; goto ex;}
|
|
}
|
|
sprintf(xorriso->info_text, "....... ( %s revoked )\n",abort_req_text);
|
|
Xorriso_info(xorriso,0);
|
|
{ret= 3; goto ex;}
|
|
}
|
|
xorriso->request_to_abort= 1;
|
|
sprintf(xorriso->info_text,
|
|
"----------- [%s = request to abort registered. Operation ends ] ------------\n",
|
|
cpt);
|
|
Xorriso_info(xorriso,0);
|
|
{ret= 2; goto ex;}
|
|
} else if(*cpt=='@') {
|
|
if(strcmp(cpt,"@@")==0) {
|
|
goto klammer_affe;
|
|
|
|
} else if(strcmp(cpt,"@")==0) {
|
|
klammer_affe:;
|
|
if(xorriso->result_page_length>0)
|
|
xorriso->result_page_length= -xorriso->result_page_length;
|
|
if(flag&1) {
|
|
sprintf(xorriso->info_text,
|
|
"... [@ = prompt suppression registered. Prompting disabled temporarily ] ...\n");
|
|
Xorriso_info(xorriso,0);
|
|
}
|
|
|
|
} else {
|
|
Xorriso_dialog_input(xorriso,cpt,strlen(line)+1,2); /* write to history */
|
|
sprintf(xorriso->info_text,
|
|
"--- Unrecognized input beginning with @. Please enter someting else.\n");
|
|
Xorriso_info(xorriso,0);
|
|
{ret= 3; goto ex;}
|
|
}
|
|
if(flag&2)
|
|
{ret= 4; goto ex;}
|
|
if(flag&1)
|
|
{ret= 3; goto ex;}
|
|
{ret= 1; goto ex;}
|
|
} else if(flag&4) {
|
|
|
|
if(strcmp(cpt,"i")==0 || strcmp(cpt,"I")==0 ||
|
|
strcmp(cpt,"n")==0 || strcmp(cpt,"N")==0 ||
|
|
*cpt==0) {
|
|
{ret= 1; goto ex;}
|
|
} else if(strcmp(cpt,"r")==0 || strcmp(cpt,"R")==0 ||
|
|
strcmp(cpt,"y")==0 || strcmp(cpt,"Y")==0) {
|
|
{ret= 6; goto ex;}
|
|
} else {
|
|
/* >>> unknown input */
|
|
sprintf(xorriso->info_text,
|
|
"--- Please enter one of : empty line, i,n, r,y, q,x, @, @@@\n");
|
|
Xorriso_info(xorriso,0);
|
|
{ret= 3; goto ex;}
|
|
}
|
|
|
|
} else if(*cpt!=0 && !(flag&1)) {
|
|
Xorriso_dialog_input(xorriso,cpt,strlen(line)+1,2); /* write to history */
|
|
strcpy(xorriso->pending_option,cpt);
|
|
xorriso->request_to_abort= 1;
|
|
sprintf(xorriso->info_text,
|
|
"-------------- [ Input of option registered. Operation ends ] ---------------\n");
|
|
Xorriso_info(xorriso,0);
|
|
{ret= 2; goto ex;}
|
|
|
|
} else if(*cpt!=0) {
|
|
Xorriso_dialog_input(xorriso,cpt,strlen(line)+1,2); /* write to history */
|
|
sprintf(xorriso->info_text,
|
|
"--- Please enter one of : empty line, @, @@@\n");
|
|
Xorriso_info(xorriso,0);
|
|
{ret= 3; goto ex;}
|
|
}
|
|
ret= 1;
|
|
ex:;
|
|
Xorriso_free_meM(line);
|
|
Xorriso_free_meM(previous_line);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= quoted multiline mode
|
|
bit1= release allocated memory and return 1
|
|
bit2= with bit0: warn of empty text arguments
|
|
bit3= deliver as single quoted text including all whitespace
|
|
and without any backslash interpretation
|
|
@return -1=out of memory , 0=line format error , 1=ok, go on , 2=done
|
|
*/
|
|
int Xorriso_read_lines(struct XorrisO *xorriso, FILE *fp, int *linecount,
|
|
int *argc, char ***argv, int flag)
|
|
{
|
|
char *line= NULL, *linept, *fgot;
|
|
int l, base_length, append_line, ret, mem_linecount, i;
|
|
|
|
Sfile_make_argv("", line, argc, argv, 2);
|
|
if(flag & 2)
|
|
{ret= 1; goto ex;}
|
|
|
|
Xorriso_alloc_meM(line, char, 5 * SfileadrL + 2);
|
|
|
|
mem_linecount= *linecount;
|
|
linept= line;
|
|
base_length= 0;
|
|
while(1) {
|
|
fgot= Sfile_fgets_n(linept, SfileadrL - base_length - 1, fp,
|
|
!!(flag & (1 | 8)));
|
|
if(fgot == NULL) {
|
|
if(ferror(fp))
|
|
{ret= 0; goto ex;}
|
|
if(linept != line) {
|
|
sprintf(xorriso->info_text,"Open quotation mark at end of input");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
{ret= 0; goto ex;}
|
|
}
|
|
{ret= 2; goto ex;}
|
|
}
|
|
l= strlen(line);
|
|
(*linecount)++;
|
|
append_line= 0;
|
|
if(flag & 1) { /* check whether the line is incomplete yet */
|
|
ret= Sfile_make_argv("", line, argc, argv, 16);
|
|
if(ret < 0)
|
|
goto ex;
|
|
if(ret == 0 && !append_line) {
|
|
line[l]= '\n';
|
|
line[l + 1]= 0;
|
|
append_line= 1;
|
|
}
|
|
if(l > 0 && !append_line)
|
|
if(line[l - 1] == '\\') {
|
|
line[l - 1]= 0;
|
|
append_line= 1;
|
|
}
|
|
}
|
|
if(l >= SfileadrL) {
|
|
sprintf(xorriso->info_text,"Input line too long !");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
{ret= 0; goto ex;}
|
|
}
|
|
if(!append_line)
|
|
break;
|
|
base_length= strlen(line);
|
|
linept= line + base_length;
|
|
}
|
|
if((flag & 1) && !(flag & 8)) {
|
|
ret= Sfile_make_argv("", line, argc, argv,
|
|
1 | ((xorriso->bsl_interpretation & 3) << 5));
|
|
if(ret < 0)
|
|
goto ex;
|
|
if(flag & 4)
|
|
for(i= 0; i < *argc; i++) {
|
|
if((*argv)[i][0] == 0) {
|
|
sprintf(xorriso->info_text, "Empty text as quoted argument in ");
|
|
} else if(strlen((*argv)[i]) >= SfileadrL) {
|
|
(*argv)[i][SfileadrL - 1]= 0;
|
|
sprintf(xorriso->info_text,
|
|
"Input text too long and now truncated in");
|
|
} else
|
|
continue;
|
|
if(mem_linecount + 1 < *linecount)
|
|
sprintf(xorriso->info_text + strlen(xorriso->info_text),
|
|
"lines %d to %d", mem_linecount + 1, *linecount);
|
|
else
|
|
sprintf(xorriso->info_text + strlen(xorriso->info_text),
|
|
"line %d", mem_linecount + 1);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING", 0);
|
|
}
|
|
} else {
|
|
(*argv)= Smem_malloC(sizeof(char *));
|
|
if(*argv == NULL)
|
|
{ret= -1; goto ex;}
|
|
(*argv)[0]= strdup(line);
|
|
if((*argv)[0] == NULL)
|
|
{ret= -1; goto ex;}
|
|
*argc= 1;
|
|
}
|
|
ret= 1;
|
|
ex:;
|
|
Xorriso_free_meM(line);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_predict_linecount(struct XorrisO *xorriso, char *line,
|
|
int *linecount, int flag)
|
|
{
|
|
int width,l;
|
|
char *spt,*ept;
|
|
|
|
*linecount= 0;
|
|
spt= line;
|
|
width= xorriso->result_page_width;
|
|
while(1) {
|
|
ept= strchr(spt,'\n');
|
|
if(ept==NULL)
|
|
l= strlen(spt);
|
|
else
|
|
l= ept-spt;
|
|
l+= xorriso->result_open_line_len;
|
|
if(ept!=NULL && l==0)
|
|
(*linecount)++;
|
|
else {
|
|
(*linecount)+= l/width;
|
|
if(ept==NULL) {
|
|
xorriso->result_open_line_len= l%width;
|
|
break;
|
|
}
|
|
(*linecount)+= !!(l%width);
|
|
}
|
|
xorriso->result_open_line_len= 0;
|
|
spt= ept+1;
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_pager(struct XorrisO *xorriso, char *line, int flag)
|
|
/*
|
|
bit1= mark '@' by return 4
|
|
*/
|
|
/* return: <=0 error , 1=go on , 2=abort , 4=see flag bit1*/
|
|
{
|
|
int ret,linecount;
|
|
char *info_text= NULL;
|
|
|
|
if(xorriso->result_page_length<=0 || xorriso->request_not_to_ask ||
|
|
xorriso->dialog == 0)
|
|
{ret= 1; goto ex;}
|
|
Xorriso_predict_linecount(xorriso,line,&linecount,0);
|
|
if(xorriso->result_line_counter+linecount>xorriso->result_page_length) {
|
|
ask_for_page:;
|
|
if(info_text == NULL)
|
|
Xorriso_alloc_meM(info_text, char, 10*SfileadrL);
|
|
strcpy(info_text,xorriso->info_text);
|
|
sprintf(xorriso->info_text,"\n");
|
|
Xorriso_info(xorriso,0);
|
|
sprintf(xorriso->info_text,
|
|
".... [Press Enter to continue. @,Enter avoids further stops. @@@ aborts] ....\n");
|
|
Xorriso_info(xorriso,0);
|
|
ret= Xorriso_request_confirmation(xorriso,flag&2);
|
|
strcpy(xorriso->info_text,info_text);
|
|
if(ret<=0)
|
|
goto ex;
|
|
if(ret==2)
|
|
{ret= 2; goto ex;}
|
|
if(ret==3)
|
|
goto ask_for_page;
|
|
}
|
|
xorriso->result_line_counter+= linecount;
|
|
ret= 1;
|
|
ex:;
|
|
Xorriso_free_meM(info_text);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= no error message in case of failure
|
|
*/
|
|
static int Xorriso_obtain_lock(struct XorrisO *xorriso,
|
|
pthread_mutex_t *lock_handle,
|
|
char *purpose, int flag)
|
|
{
|
|
int ret;
|
|
static int complaints= 0, complaint_limit= 5;
|
|
|
|
ret= pthread_mutex_lock(lock_handle);
|
|
if(ret != 0) {
|
|
if(flag & 1)
|
|
return(-1);
|
|
/* Cannot report failure through the failing message output system */
|
|
complaints++;
|
|
if(complaints <= complaint_limit)
|
|
fprintf(stderr,
|
|
"xorriso : pthread_mutex_lock() for %s returns %d\n",
|
|
purpose, ret);
|
|
return(-1);
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= no error message in case of failure
|
|
*/
|
|
static int Xorriso_release_lock(struct XorrisO *xorriso,
|
|
pthread_mutex_t *lock_handle,
|
|
char *purpose, int flag)
|
|
{
|
|
int ret;
|
|
static int complaints= 0, complaint_limit= 5;
|
|
|
|
ret= pthread_mutex_unlock(lock_handle);
|
|
if(ret != 0) {
|
|
if(flag & 1)
|
|
return(0);
|
|
/* Cannot report failure through the failing message output system */
|
|
complaints++;
|
|
if(complaints <= complaint_limit)
|
|
fprintf(stderr,
|
|
"xorriso : pthread_mutex_unlock() for %s returns %d\n",
|
|
purpose, ret);
|
|
return(0);
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
static int Xorriso_lock_outlists(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int ret;
|
|
|
|
ret= Xorriso_obtain_lock(xorriso, &(xorriso->result_msglists_lock),
|
|
"outlists", 0);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
static int Xorriso_unlock_outlists(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int ret;
|
|
|
|
ret= Xorriso_release_lock(xorriso, &(xorriso->result_msglists_lock),
|
|
"outlists", 0);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
static int Xorriso_write_to_msglist(struct XorrisO *xorriso,
|
|
struct Xorriso_lsT **xorriso_msglist,
|
|
char *text, int flag)
|
|
{
|
|
int ret, locked= 0;
|
|
struct Xorriso_lsT *msglist;
|
|
|
|
ret= Xorriso_lock_outlists(xorriso, 0);
|
|
if(ret > 0)
|
|
locked= 1;
|
|
msglist= *xorriso_msglist;
|
|
ret= Xorriso_lst_append_binary(&msglist, text, strlen(text) + 1, 0);
|
|
if(ret <= 0) {
|
|
ret= -1; goto ex;
|
|
}
|
|
if(*xorriso_msglist == NULL)
|
|
*xorriso_msglist= msglist;
|
|
ret= 1;
|
|
ex:;
|
|
if(locked)
|
|
Xorriso_unlock_outlists(xorriso, 0);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_write_to_channel(struct XorrisO *xorriso,
|
|
char *in_text, int channel_no, int flag)
|
|
/*
|
|
bit0= eventually backslash encode linefeeds
|
|
bit1= text is the name of the log file for the given channel
|
|
bit2= text is the name of the consolidated packet log file for all channels
|
|
bit3= text is the name of the stderr redirection file
|
|
bit15= with bit1 to bit3: close depicted log file
|
|
*/
|
|
{
|
|
char *rpt, *npt, *text= NULL, *line= NULL;
|
|
int ret= 1, info_redirected= 0, result_redirected= 0, l;
|
|
char prefix[16];
|
|
FILE *logfile_fp, *pktlog_fp;
|
|
static int num_channels= 4;
|
|
static char channel_prefixes[4][4]= {".","R","I","M"};
|
|
|
|
#ifdef Xorriso_fetch_with_msg_queueS
|
|
static int complaints= 0, complaint_limit= 5;
|
|
int locked= 0, uret;
|
|
#endif
|
|
|
|
text= in_text; /* might change due to backslash encoding */
|
|
|
|
if(channel_no<0 || channel_no>=num_channels)
|
|
{ret= -1; goto ex;}
|
|
|
|
#ifdef Xorriso_fetch_with_msg_queueS
|
|
ret= pthread_mutex_lock(&(xorriso->write_to_channel_lock));
|
|
if(ret != 0) {
|
|
/* Cannot report failure through the failing message output system */
|
|
complaints++;
|
|
if(complaints <= complaint_limit)
|
|
fprintf(stderr,
|
|
"xorriso : pthread_mutex_lock() for write_to_channel returns %d\n",
|
|
ret);
|
|
/* Intentionally not aborting here */;
|
|
} else
|
|
locked= 1;
|
|
#endif /* Xorriso_fetch_with_msg_queueS */
|
|
|
|
/* Logfiles */
|
|
logfile_fp= xorriso->logfile_fp[channel_no];
|
|
pktlog_fp= xorriso->pktlog_fp;
|
|
if((flag&2) && logfile_fp!=NULL) {
|
|
fprintf(logfile_fp,
|
|
"! end ! end ! end ! end ! end ! end ! end ! end xorriso log : %s : %s\n",
|
|
channel_prefixes[channel_no],Sfile_datestr(time(0),1|2|256));
|
|
fclose(logfile_fp);
|
|
xorriso->logfile_fp[channel_no]= logfile_fp= NULL;
|
|
}
|
|
if((flag&4) && pktlog_fp!=NULL) {
|
|
fprintf(pktlog_fp,
|
|
"I:1:! end ! end ! end ! end ! end ! end ! end ! end xorriso log : %s : %s\n",
|
|
channel_prefixes[channel_no],Sfile_datestr(time(0),1|2|256));
|
|
fclose(pktlog_fp);
|
|
xorriso->pktlog_fp= pktlog_fp= NULL;
|
|
}
|
|
if((flag & 8) && xorriso->stderr_fp != NULL) {
|
|
fclose(xorriso->stderr_fp);
|
|
xorriso->stderr_fp= NULL;
|
|
}
|
|
if(flag&(1<<15))
|
|
{ret= 1; goto ex;}
|
|
if((flag&2)) {
|
|
xorriso->logfile_fp[channel_no]= logfile_fp= fopen(text,"a");
|
|
if(logfile_fp==NULL)
|
|
{ret= 0; goto ex;}
|
|
fprintf(logfile_fp,
|
|
"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! xorriso log : %s : %s\n",
|
|
channel_prefixes[channel_no],Sfile_datestr(time(0),1|2|256));
|
|
fflush(logfile_fp);
|
|
}
|
|
if((flag&4)) {
|
|
xorriso->pktlog_fp= pktlog_fp= fopen(text,"a");
|
|
if(pktlog_fp==NULL)
|
|
{ret= 0; goto ex;}
|
|
fprintf(pktlog_fp,
|
|
"I:1:!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! xorriso log : . : %s\n",
|
|
Sfile_datestr(time(0),1|2|256));
|
|
fflush(pktlog_fp);
|
|
}
|
|
if(flag & 8) {
|
|
truncate(text, (off_t) 0);
|
|
xorriso->stderr_fp= fopen(text, "a");
|
|
if(xorriso->stderr_fp == NULL)
|
|
{ret= 0; goto ex;}
|
|
}
|
|
if(flag & (2| 4 | 8))
|
|
{ret= 1; goto ex;}
|
|
|
|
/* Eventually perform backslash encoding of non-printable characters */
|
|
if(((xorriso->bsl_interpretation & 32) && channel_no == 1) ||
|
|
((xorriso->bsl_interpretation & 64) && channel_no == 2)) {
|
|
ret= Sfile_bsl_encoder(&text, text, strlen(text), 1 | 2 | 4);
|
|
if(ret <= 0)
|
|
{ret= -1; goto ex;}
|
|
}
|
|
|
|
/* Eventually perform messag redirection */
|
|
if(xorriso->msglist_stackfill > 0) {
|
|
if(xorriso->msglist_flags[xorriso->msglist_stackfill - 1] & 1)
|
|
result_redirected= 1;
|
|
if(xorriso->msglist_flags[xorriso->msglist_stackfill - 1] & 2)
|
|
info_redirected= 1;
|
|
}
|
|
|
|
/* Non-redirected output */
|
|
if(!xorriso->packet_output) {
|
|
if(channel_no==1 || channel_no==3) {
|
|
if(result_redirected) {
|
|
ret= Xorriso_write_to_msglist(xorriso,
|
|
&(xorriso->result_msglists[xorriso->msglist_stackfill - 1]),
|
|
text, 0);
|
|
if(ret <= 0)
|
|
{ ret= -1; goto ex; }
|
|
} else {
|
|
printf("%s",text);
|
|
fflush(stdout);
|
|
}
|
|
}
|
|
if(channel_no==2 || channel_no==3) {
|
|
if(info_redirected) {
|
|
ret= Xorriso_write_to_msglist(xorriso,
|
|
&(xorriso->info_msglists[xorriso->msglist_stackfill - 1]),
|
|
text, 0);
|
|
if(ret <= 0)
|
|
{ ret= -1; goto ex; }
|
|
} else {
|
|
if(xorriso->stderr_fp != NULL) {
|
|
fprintf(xorriso->stderr_fp, "%s", text);
|
|
fflush(xorriso->stderr_fp);
|
|
} else
|
|
fprintf(stderr, "%s", text);
|
|
}
|
|
}
|
|
if(logfile_fp!=NULL) {
|
|
fprintf(logfile_fp,"%s",text);
|
|
fflush(logfile_fp);
|
|
}
|
|
if(pktlog_fp==NULL)
|
|
{ret= 1; goto ex;}
|
|
}
|
|
rpt= text;
|
|
sprintf(prefix,"%s:x: ",channel_prefixes[channel_no]);
|
|
while(*rpt!=0) {
|
|
npt= strchr(rpt,'\n');
|
|
if(npt==NULL)
|
|
prefix[2]= '0';
|
|
else
|
|
prefix[2]= '1';
|
|
if(!result_redirected) {
|
|
if(xorriso->packet_output) {
|
|
ret= fwrite(prefix,5,1,stdout);
|
|
if(ret<=0)
|
|
{ret= 0; goto ex;}
|
|
}
|
|
}
|
|
if(pktlog_fp!=NULL) {
|
|
ret= fwrite(prefix,5,1,pktlog_fp);
|
|
if(ret<=0)
|
|
{ret= 0; goto ex;}
|
|
}
|
|
if(npt==NULL) {
|
|
if(xorriso->packet_output) {
|
|
if(result_redirected) {
|
|
l= strlen(rpt);
|
|
Xorriso_alloc_meM(line, char, 5 + l + 1 + 1);
|
|
memcpy(line, prefix, 5);
|
|
memcpy(line + 5, rpt, l);
|
|
line[5 + l] = '\n';
|
|
line[5 + l + 1] = 0;
|
|
ret= Xorriso_write_to_msglist(xorriso,
|
|
&(xorriso->result_msglists[xorriso->msglist_stackfill - 1]),
|
|
line, 0);
|
|
Xorriso_free_meM(line);
|
|
line= NULL;
|
|
if(ret <= 0)
|
|
{ ret= -1; goto ex; }
|
|
} else {
|
|
ret= fwrite(rpt,strlen(rpt),1,stdout);
|
|
if(ret<=0)
|
|
{ret= 0; goto ex;}
|
|
ret= fwrite("\n",1,1,stdout);
|
|
if(ret<=0)
|
|
{ret= 0; goto ex;}
|
|
}
|
|
}
|
|
if(pktlog_fp!=NULL) {
|
|
ret= fwrite(rpt,strlen(rpt),1,pktlog_fp);
|
|
if(ret<=0)
|
|
{ret= 0; goto ex;}
|
|
ret= fwrite("\n",1,1,pktlog_fp);
|
|
if(ret<=0)
|
|
{ret= 0; goto ex;}
|
|
}
|
|
break;
|
|
} else {
|
|
if(xorriso->packet_output) {
|
|
if(result_redirected) {
|
|
l= npt + 1 - rpt;
|
|
Xorriso_alloc_meM(line, char, 5 + l + 1);
|
|
memcpy(line, prefix, 5);
|
|
memcpy(line + 5, rpt, l);
|
|
line[5 + l] = 0;
|
|
ret= Xorriso_write_to_msglist(xorriso,
|
|
&(xorriso->result_msglists[xorriso->msglist_stackfill - 1]),
|
|
line, 0);
|
|
Xorriso_free_meM(line);
|
|
line= NULL;
|
|
if(ret <= 0)
|
|
{ ret= -1; goto ex; }
|
|
} else {
|
|
ret= fwrite(rpt,npt+1-rpt,1,stdout);
|
|
if(ret<=0)
|
|
{ret= 0; goto ex;}
|
|
}
|
|
}
|
|
if(pktlog_fp!=NULL) {
|
|
ret= fwrite(rpt,npt+1-rpt,1,pktlog_fp);
|
|
if(ret<=0)
|
|
{ret= 0; goto ex;}
|
|
}
|
|
}
|
|
rpt= npt+1;
|
|
}
|
|
if(xorriso->packet_output)
|
|
fflush(stdout);
|
|
if(pktlog_fp!=NULL)
|
|
fflush(pktlog_fp);
|
|
ret= 1;
|
|
ex:
|
|
if(text != in_text && text != NULL)
|
|
free(text);
|
|
Xorriso_free_meM(line);
|
|
|
|
#ifdef Xorriso_fetch_with_msg_queueS
|
|
|
|
if(locked) {
|
|
uret= pthread_mutex_unlock(&(xorriso->write_to_channel_lock));
|
|
if(uret != 0) {
|
|
/* Cannot report failure through the failing message output system */
|
|
complaints++;
|
|
if(complaints <= complaint_limit)
|
|
fprintf(stderr,
|
|
"xorriso : pthread_mutex_unlock() for write_to_channel returns %d\n",
|
|
uret);
|
|
}
|
|
}
|
|
|
|
#endif /* Xorriso_fetch_with_msg_queueS */
|
|
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_push_outlists(struct XorrisO *xorriso, int *stack_handle,
|
|
int flag)
|
|
{
|
|
int ret, locked= 0;
|
|
|
|
ret= Xorriso_lock_outlists(xorriso, 0);
|
|
if(ret > 0)
|
|
locked= 1;
|
|
if(xorriso->msglist_stackfill + 1 >= Xorriso_max_outlist_stacK) {
|
|
Xorriso_msgs_submit(xorriso, 0,
|
|
"Overflow of message output redirection stack", 0, "FATAL", 0);
|
|
ret= -1; goto ex;
|
|
}
|
|
if((flag & 3) == 0)
|
|
flag|= 3;
|
|
xorriso->msglist_stackfill++;
|
|
xorriso->result_msglists[xorriso->msglist_stackfill - 1]= NULL;
|
|
xorriso->info_msglists[xorriso->msglist_stackfill - 1]= NULL;
|
|
xorriso->msglist_flags[xorriso->msglist_stackfill - 1]= flag & 3;
|
|
*stack_handle= xorriso->msglist_stackfill - 1;
|
|
ret= 1;
|
|
ex:;
|
|
if(locked)
|
|
Xorriso_unlock_outlists(xorriso, 0);
|
|
return(ret);
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_fetch_outlists(struct XorrisO *xorriso, int stack_handle,
|
|
struct Xorriso_lsT **result_list,
|
|
struct Xorriso_lsT **info_list, int flag)
|
|
{
|
|
int ret, locked= 0;
|
|
|
|
#ifdef Xorriso_fetch_with_msg_queueS
|
|
|
|
ret= Xorriso_process_msg_queues(xorriso, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
|
|
#endif /* Xorriso_fetch_with_msg_queueS */
|
|
|
|
if((flag & 3) == 0)
|
|
flag|= 3;
|
|
|
|
ret= Xorriso_lock_outlists(xorriso, 0);
|
|
if(ret > 0)
|
|
locked= 1;
|
|
|
|
if(stack_handle == -1)
|
|
stack_handle= xorriso->msglist_stackfill - 1;
|
|
if(stack_handle < 0 || stack_handle >= xorriso->msglist_stackfill) {
|
|
Xorriso_msgs_submit(xorriso, 0,
|
|
"Program error: Wrong message output redirection stack handle",
|
|
0, "FATAL", 0);
|
|
ret= -1; goto ex;
|
|
}
|
|
|
|
if(flag & 1) {
|
|
*result_list= xorriso->result_msglists[stack_handle];
|
|
xorriso->result_msglists[stack_handle]= NULL;
|
|
}
|
|
if(flag & 2) {
|
|
*info_list= xorriso->info_msglists[stack_handle];
|
|
xorriso->info_msglists[stack_handle]= NULL;
|
|
}
|
|
|
|
ret= 1;
|
|
ex:;
|
|
if(locked)
|
|
Xorriso_unlock_outlists(xorriso, 0);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_peek_outlists(struct XorrisO *xorriso, int stack_handle,
|
|
int timeout, int flag)
|
|
{
|
|
int ret, locked= 0, yes= 0;
|
|
static int u_wait= 19000;
|
|
time_t start_time;
|
|
|
|
if((flag & 3) == 0)
|
|
flag|= 3;
|
|
if(stack_handle == -1)
|
|
stack_handle= xorriso->msglist_stackfill - 1;
|
|
start_time= time(NULL);
|
|
|
|
try_again:;
|
|
ret= Xorriso_obtain_lock(xorriso, &(xorriso->msgw_fetch_lock),
|
|
"message watcher fetch operation", 0);
|
|
if(ret <= 0)
|
|
{yes= -2; goto ex;}
|
|
locked= 1;
|
|
|
|
yes= 0;
|
|
if(stack_handle < 0 || stack_handle >= xorriso->msglist_stackfill)
|
|
{yes= -1; goto ex;}
|
|
if(flag & 1)
|
|
yes|= (xorriso->result_msglists[stack_handle] != NULL);
|
|
if(flag & 2)
|
|
yes|= (xorriso->info_msglists[stack_handle] != NULL);
|
|
if(xorriso->msg_watcher_state == 2 && xorriso->msgw_msg_pending)
|
|
yes|= 2;
|
|
|
|
ret= Xorriso_release_lock(xorriso, &(xorriso->msgw_fetch_lock),
|
|
"message watcher fetch operation", 0);
|
|
if(ret <= 0)
|
|
{yes= -2; goto ex;}
|
|
locked= 0;
|
|
|
|
if(yes && (flag & 4)) {
|
|
usleep(u_wait);
|
|
if(time(NULL) <= start_time + timeout)
|
|
goto try_again;
|
|
}
|
|
|
|
ex:;
|
|
if(locked) {
|
|
ret= Xorriso_release_lock(xorriso, &(xorriso->msgw_fetch_lock),
|
|
"message watcher fetch operation", 0);
|
|
if(ret <= 0 && yes >= 0)
|
|
yes= -2;
|
|
}
|
|
return(yes);
|
|
}
|
|
|
|
|
|
int Xorriso_pull_outlists(struct XorrisO *xorriso, int stack_handle,
|
|
struct Xorriso_lsT **result_list,
|
|
struct Xorriso_lsT **info_list, int flag)
|
|
{
|
|
int i, ret, locked= 0;
|
|
|
|
ret= Xorriso_lock_outlists(xorriso, 0);
|
|
if(ret > 0)
|
|
locked= 1;
|
|
|
|
if(stack_handle == -1)
|
|
stack_handle= xorriso->msglist_stackfill - 1;
|
|
if(stack_handle < 0 || stack_handle >= xorriso->msglist_stackfill) {
|
|
Xorriso_msgs_submit(xorriso, 0,
|
|
"Program error: Wrong message output redirection stack handle",
|
|
0, "FATAL", 0);
|
|
ret= -1; goto ex;
|
|
}
|
|
|
|
/* Concatenate all redirections above stack_handle */
|
|
*result_list= NULL;
|
|
*info_list= NULL;
|
|
for(i = stack_handle; i < xorriso->msglist_stackfill; i++) {
|
|
if(*result_list == NULL)
|
|
*result_list= xorriso->result_msglists[i];
|
|
else
|
|
Xorriso_lst_concat(*result_list, xorriso->result_msglists[i], 0);
|
|
if(*info_list == NULL)
|
|
*info_list= xorriso->info_msglists[i];
|
|
else
|
|
Xorriso_lst_concat(*info_list, xorriso->info_msglists[i], 0);
|
|
}
|
|
xorriso->msglist_stackfill= stack_handle;
|
|
|
|
ret= 1;
|
|
ex:;
|
|
if(locked)
|
|
Xorriso_unlock_outlists(xorriso, 0);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_info_handler_stderr(void *handle, char *text)
|
|
{
|
|
struct XorrisO *xorriso;
|
|
|
|
xorriso= (struct XorrisO *) handle;
|
|
if(xorriso->stderr_fp != NULL) {
|
|
fprintf(xorriso->stderr_fp, "%s", text);
|
|
fflush(xorriso->stderr_fp);
|
|
} else {
|
|
fprintf(stderr, "%s", text);
|
|
fflush(stderr);
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_result_handler_stdout(void *handle, char *text)
|
|
{
|
|
printf("%s", text);
|
|
fflush(stdout);
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_result_handler_pkt(void *handle, char *text)
|
|
{
|
|
int nl= -1, ret, l;
|
|
struct XorrisO *xorriso;
|
|
|
|
xorriso= (struct XorrisO *) handle;
|
|
|
|
if(!xorriso->packet_output)
|
|
return Xorriso_result_handler_stdout(handle, text);
|
|
|
|
/* Interpret pkt_output */
|
|
l= strlen(text);
|
|
if(l >= 5) {
|
|
if(strchr("RIM", text[0]) != NULL && text[1] == ':' &&
|
|
strchr("01", text[2]) != NULL && text[3] == ':' && text[4] == ' ')
|
|
nl= (text[2] == '1');
|
|
}
|
|
if(nl < 0) /* Not pkt_output format */
|
|
return Xorriso_result_handler_stdout(handle, text);
|
|
|
|
if(nl == 0) {
|
|
/* Suppress newline */
|
|
if(text[l - 1] == '\n')
|
|
l--;
|
|
}
|
|
|
|
if(text[0] == 'R') {
|
|
ret= fwrite(text + 5, l - 5, 1, stdout);
|
|
} else {
|
|
ret= fwrite(text + 5, l - 5, 1,
|
|
xorriso->stderr_fp != NULL ? xorriso->stderr_fp : stderr);
|
|
}
|
|
if(ret <= 0)
|
|
return(0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_process_msg_lists(struct XorrisO *xorriso,
|
|
struct Xorriso_lsT *result_list,
|
|
struct Xorriso_lsT *info_list,
|
|
int *line_count, int flag)
|
|
{
|
|
struct Xorriso_lsT *lpt;
|
|
int ret;
|
|
int (*handler)(void *handle, char *text);
|
|
void *handle;
|
|
|
|
handler= xorriso->msgw_result_handler;
|
|
handle= xorriso->msgw_result_handle;
|
|
if(handler == NULL) {
|
|
handler= Xorriso_result_handler_pkt;
|
|
handle= xorriso;
|
|
}
|
|
for(lpt= result_list; lpt != NULL; lpt= lpt->next) {
|
|
(*line_count)++;
|
|
ret= (*handler)(handle, Xorriso_lst_get_text(lpt, 0));
|
|
if(ret < 0)
|
|
return(-1);
|
|
}
|
|
handler= xorriso->msgw_info_handler;
|
|
handle= xorriso->msgw_info_handle;
|
|
if(handler == NULL) {
|
|
handler= Xorriso_info_handler_stderr;
|
|
handle= xorriso;
|
|
}
|
|
for(lpt= info_list; lpt != NULL; lpt= lpt->next) {
|
|
(*line_count)++;
|
|
ret= (*handler)(handle, Xorriso_lst_get_text(lpt, 0));
|
|
if(ret < 0)
|
|
return(-1);
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
static void *Xorriso_msg_watcher(void *state_pt)
|
|
{
|
|
struct XorrisO *xorriso;
|
|
int ret, u_wait= 25000, line_count, sleep_thresh= 20;
|
|
struct Xorriso_lsT *result_list= NULL, *info_list= NULL;
|
|
static int debug_sev= 0;
|
|
|
|
xorriso= (struct XorrisO *) state_pt;
|
|
|
|
if(debug_sev == 0)
|
|
Xorriso__text_to_sev("DEBUG", &debug_sev, 0);
|
|
|
|
xorriso->msg_watcher_state= 2;
|
|
if(xorriso->msgw_info_handler != NULL &&
|
|
debug_sev < xorriso->report_about_severity &&
|
|
debug_sev < xorriso->abort_on_severity)
|
|
(*xorriso->msgw_info_handler)(xorriso,
|
|
"xorriso : DEBUG : Concurrent message watcher started\n");
|
|
while(1) {
|
|
line_count= 0;
|
|
|
|
/* Watch out for end request in xorriso */
|
|
if(xorriso->msg_watcher_state == 3)
|
|
break;
|
|
|
|
Xorriso_obtain_lock(xorriso, &(xorriso->msgw_fetch_lock),
|
|
"message watcher fetch operation", 1);
|
|
xorriso->msgw_msg_pending= 1;
|
|
ret= Xorriso_fetch_outlists(xorriso, -1, &result_list, &info_list, 3);
|
|
if(ret > 0) {
|
|
/* Process fetched lines */
|
|
xorriso->msgw_msg_pending= 2;
|
|
Xorriso_release_lock(xorriso, &(xorriso->msgw_fetch_lock),
|
|
"message watcher fetch operation", 1);
|
|
ret= Xorriso_process_msg_lists(xorriso, result_list, info_list,
|
|
&line_count, 0);
|
|
xorriso->msgw_msg_pending= 0;
|
|
Xorriso_lst_destroy_all(&result_list, 0);
|
|
Xorriso_lst_destroy_all(&info_list, 0);
|
|
if(ret < 0)
|
|
break;
|
|
} else {
|
|
xorriso->msgw_msg_pending= 0;
|
|
Xorriso_release_lock(xorriso, &(xorriso->msgw_fetch_lock),
|
|
"message watcher fetch operation", 1);
|
|
}
|
|
xorriso->msgw_msg_pending= 0;
|
|
|
|
if(ret < 0)
|
|
break;
|
|
|
|
if(line_count < sleep_thresh)
|
|
usleep(u_wait);
|
|
}
|
|
if(xorriso->msgw_info_handler != NULL &&
|
|
debug_sev < xorriso->report_about_severity &&
|
|
debug_sev < xorriso->abort_on_severity)
|
|
(*xorriso->msgw_info_handler)(xorriso,
|
|
"xorriso : DEBUG : Concurrent message watcher ended\n");
|
|
xorriso->msg_watcher_state= 0;
|
|
return(NULL);
|
|
}
|
|
|
|
|
|
int Xorriso_start_msg_watcher(struct XorrisO *xorriso,
|
|
int (*result_handler)(void *handle, char *text),
|
|
void *result_handle,
|
|
int (*info_handler)(void *handle, char *text),
|
|
void *info_handle,
|
|
int flag)
|
|
{
|
|
int ret, u_wait= 1000, locked= 0, pushed= 0, uret, line_count= 0;
|
|
struct Xorriso_lsT *result_list= NULL, *info_list= NULL;
|
|
pthread_attr_t attr;
|
|
pthread_attr_t *attr_pt = NULL;
|
|
pthread_t thread;
|
|
|
|
ret= pthread_mutex_lock(&(xorriso->msg_watcher_lock));
|
|
if(ret != 0) {
|
|
Xorriso_msgs_submit(xorriso, 0,
|
|
"Cannot aquire mutex lock for managing concurrent message watcher",
|
|
ret, "FATAL", 0);
|
|
ret= -1; goto ex;
|
|
}
|
|
locked= 1;
|
|
|
|
/* Check for running watcher */
|
|
if(xorriso->msg_watcher_state > 0) {
|
|
sprintf(xorriso->info_text,
|
|
"There is already a concurrent message watcher running");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
|
|
ret= Xorriso_push_outlists(xorriso, &(xorriso->msgw_stack_handle), 3);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
pushed= 1;
|
|
|
|
/* Register watcher */
|
|
xorriso->msgw_result_handler= result_handler;
|
|
xorriso->msgw_result_handle= result_handle;
|
|
xorriso->msgw_info_handler= info_handler;
|
|
xorriso->msgw_info_handle= info_handle;
|
|
xorriso->msg_watcher_state= 1;
|
|
|
|
/* Start thread */
|
|
pthread_attr_init(&attr);
|
|
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
|
|
attr_pt= &attr;
|
|
ret= pthread_create(&thread, attr_pt, Xorriso_msg_watcher, xorriso);
|
|
if(ret != 0) {
|
|
sprintf(xorriso->info_text,
|
|
"Cannot create thread for concurrent message watcher");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
|
|
/* Wait until watcher has indicated start */
|
|
while(xorriso->msg_watcher_state == 1) {
|
|
|
|
/* >>> have a timeout ? */;
|
|
|
|
usleep(u_wait);
|
|
}
|
|
|
|
ret= 1;
|
|
ex:;
|
|
if(ret <= 0 && pushed) {
|
|
uret= Xorriso_pull_outlists(xorriso, xorriso->msgw_stack_handle,
|
|
&result_list, &info_list, 0);
|
|
if(uret > 0) {
|
|
xorriso->msgw_result_handler= NULL;
|
|
xorriso->msgw_info_handler= NULL;
|
|
Xorriso_process_msg_lists(xorriso, result_list, info_list,
|
|
&line_count, 0);
|
|
Xorriso_lst_destroy_all(&result_list, 0);
|
|
Xorriso_lst_destroy_all(&info_list, 0);
|
|
}
|
|
}
|
|
if(locked) {
|
|
uret= pthread_mutex_unlock(&(xorriso->msg_watcher_lock));
|
|
if(uret != 0) {
|
|
Xorriso_msgs_submit(xorriso, 0,
|
|
"Cannot release mutex lock for managing concurrent message watcher",
|
|
uret, "FATAL", 0);
|
|
ret= -1;
|
|
}
|
|
}
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= do not complain loudly if no wather is active
|
|
*/
|
|
int Xorriso_stop_msg_watcher(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int ret, u_wait= 1000, locked= 0, uret, line_count= 0;
|
|
struct Xorriso_lsT *result_list= NULL, *info_list= NULL;
|
|
|
|
if((flag & 1) && xorriso->msg_watcher_state != 2)
|
|
/* Roughly tolerate non-running watcher */
|
|
{ret= 0; goto ex;}
|
|
|
|
ret= pthread_mutex_lock(&(xorriso->msg_watcher_lock));
|
|
if(ret != 0) {
|
|
Xorriso_msgs_submit(xorriso, 0,
|
|
"Cannot aquire mutex lock for managing concurrent message watcher",
|
|
ret, "FATAL", 0);
|
|
ret= -1; goto ex;
|
|
}
|
|
locked= 1;
|
|
|
|
/* Check for running watcher */
|
|
if(xorriso->msg_watcher_state != 2) {
|
|
sprintf(xorriso->info_text,
|
|
"There is no concurrent message watcher running");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "SORRY", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
|
|
/* Inform watcher of desire to stop it */
|
|
xorriso->msg_watcher_state= 3;
|
|
|
|
/* Wait until watcher has indicated its end */
|
|
while(xorriso->msg_watcher_state != 0) {
|
|
|
|
/* >>> have a timeout ? */;
|
|
|
|
usleep(u_wait);
|
|
}
|
|
|
|
Xorriso_obtain_lock(xorriso, &(xorriso->msgw_fetch_lock),
|
|
"message watcher fetch operation", 1);
|
|
xorriso->msgw_msg_pending= 1;
|
|
ret= Xorriso_pull_outlists(xorriso, xorriso->msgw_stack_handle,
|
|
&result_list, &info_list, 0);
|
|
if(ret > 0) {
|
|
xorriso->msgw_msg_pending= 2;
|
|
Xorriso_release_lock(xorriso, &(xorriso->msgw_fetch_lock),
|
|
"message watcher fetch operation", 1);
|
|
Xorriso_process_msg_lists(xorriso, result_list, info_list,
|
|
&line_count, 0);
|
|
xorriso->msgw_msg_pending= 0;
|
|
Xorriso_lst_destroy_all(&result_list, 0);
|
|
Xorriso_lst_destroy_all(&info_list, 0);
|
|
} else {
|
|
xorriso->msgw_msg_pending= 0;
|
|
Xorriso_release_lock(xorriso, &(xorriso->msgw_fetch_lock),
|
|
"message watcher fetch operation", 1);
|
|
}
|
|
|
|
xorriso->msgw_result_handler= NULL;
|
|
xorriso->msgw_info_handler= NULL;
|
|
|
|
ret= 1;
|
|
ex:;
|
|
if(locked) {
|
|
uret= pthread_mutex_unlock(&(xorriso->msg_watcher_lock));
|
|
if(uret != 0) {
|
|
Xorriso_msgs_submit(xorriso, 0,
|
|
"Cannot release mutex lock for managing concurrent message watcher",
|
|
uret, "FATAL", 0);
|
|
ret= -1;
|
|
}
|
|
}
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_result(struct XorrisO *xorriso, int flag)
|
|
/*
|
|
bit0= no considerations or computations or dialog. Just put out.
|
|
*/
|
|
{
|
|
int ret, redirected= 0;
|
|
|
|
if(flag&1)
|
|
goto put_it_out;
|
|
if(xorriso->request_to_abort)
|
|
return(1);
|
|
if(xorriso->msglist_stackfill > 0)
|
|
if(xorriso->msglist_flags[xorriso->msglist_stackfill - 1] & 1)
|
|
redirected= 1;
|
|
if(xorriso->result_page_length>0 && !redirected) {
|
|
ret= Xorriso_pager(xorriso,xorriso->result_line,2);
|
|
if(ret<=0)
|
|
return(ret);
|
|
if(ret==2)
|
|
return(1);
|
|
if(xorriso->request_to_abort)
|
|
return(1);
|
|
}
|
|
put_it_out:;
|
|
xorriso->bar_is_fresh= 0;
|
|
ret= Xorriso_write_to_channel(xorriso, xorriso->result_line, 1,0);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_info(struct XorrisO *xorriso, int flag)
|
|
/*
|
|
bit0= use pager (as with result)
|
|
bit1= permission to suppress output
|
|
bit2= insist in showing output
|
|
*/
|
|
{
|
|
int ret;
|
|
static int note_sev= 0;
|
|
|
|
if(flag&2)
|
|
if(xorriso->request_to_abort)
|
|
return(1);
|
|
|
|
if(note_sev==0)
|
|
Xorriso__text_to_sev("NOTE", ¬e_sev, 0);
|
|
if(note_sev<xorriso->report_about_severity &&
|
|
note_sev<xorriso->abort_on_severity && !(flag&4))
|
|
return(1);
|
|
|
|
if(flag&1) {
|
|
ret= Xorriso_pager(xorriso,xorriso->info_text,2);
|
|
if(ret<=0)
|
|
return(ret);
|
|
if(ret==2)
|
|
return(1);
|
|
if(flag&2)
|
|
if(xorriso->request_to_abort)
|
|
return(1);
|
|
}
|
|
xorriso->bar_is_fresh= 0;
|
|
ret=Xorriso_write_to_channel(xorriso, xorriso->info_text, 2, 0);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_mark(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int ret= 1,r_ret,i_ret;
|
|
|
|
if(xorriso->mark_text[0]==0)
|
|
return(1);
|
|
if(xorriso->packet_output)
|
|
ret=Xorriso_write_to_channel(xorriso, xorriso->mark_text, 3, 0);
|
|
else {
|
|
sprintf(xorriso->result_line,"%s\n",xorriso->mark_text);
|
|
r_ret= Xorriso_result(xorriso,1);
|
|
strcpy(xorriso->info_text,xorriso->result_line);
|
|
i_ret= Xorriso_info(xorriso,0);
|
|
if(r_ret==0 || i_ret==0)
|
|
ret= 0;
|
|
}
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_restxt(struct XorrisO *xorriso, char *text)
|
|
{
|
|
int ret;
|
|
|
|
strncpy(xorriso->result_line,text,sizeof(xorriso->result_line)-1);
|
|
xorriso->result_line[sizeof(xorriso->result_line)-1]= 0;
|
|
ret= Xorriso_result(xorriso,0);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0-7= purpose
|
|
0= ERRFILE
|
|
1= mark line (only to be put out if enabled)
|
|
*/
|
|
int Xorriso_process_errfile(struct XorrisO *xorriso,
|
|
int error_code, char msg_text[], int os_errno,
|
|
int flag)
|
|
{
|
|
char ttx[41];
|
|
int purpose;
|
|
|
|
if(strlen(msg_text)>SfileadrL)
|
|
return(-1);
|
|
|
|
purpose= flag&255;
|
|
if(purpose==1 && !(xorriso->errfile_mode&1))
|
|
return(2);
|
|
if(xorriso->errfile_fp!=NULL) {
|
|
if(purpose==1)
|
|
fprintf(xorriso->errfile_fp, "----------------- %s %s\n",
|
|
msg_text, Ftimetxt(time(0), ttx, 1));
|
|
else
|
|
fprintf(xorriso->errfile_fp, "%s\n", msg_text);
|
|
fflush(xorriso->errfile_fp);
|
|
return(1);
|
|
}
|
|
if(xorriso->errfile_log[0]==0)
|
|
return(1);
|
|
if(strcmp(xorriso->errfile_log, "-")==0 ||
|
|
strcmp(xorriso->errfile_log, "-R")==0) {
|
|
if(purpose==1)
|
|
sprintf(xorriso->result_line, "----------------- %s %s\n",
|
|
msg_text, Ftimetxt(time(0), ttx, 1));
|
|
else
|
|
sprintf(xorriso->result_line, "%s\n", msg_text);
|
|
Xorriso_result(xorriso, 1);
|
|
return(1);
|
|
}
|
|
if(strcmp(xorriso->errfile_log, "-I")==0) {
|
|
if(purpose==1)
|
|
sprintf(xorriso->info_text, "ERRFILE_MARK=%s %s\n",
|
|
msg_text, Ftimetxt(time(0), ttx, 1));
|
|
else
|
|
sprintf(xorriso->info_text, "ERRFILE=%s\n", msg_text);
|
|
Xorriso_info(xorriso, 0);
|
|
return(1);
|
|
}
|
|
return(2);
|
|
}
|
|
|
|
|
|
#ifdef Xorriso_fetch_with_msg_queueS
|
|
/* Important: This function must stay thread-safe with all use of xorriso. */
|
|
#else
|
|
/* Note: It is ok to submit xorriso->info_text as msg_text here. */
|
|
#endif
|
|
/* flag:
|
|
bit0= for Xorriso_info() : use pager (as with result)
|
|
bit1= for Xorriso_info() : permission to suppress output
|
|
bit2..5= name prefix
|
|
0="xorriso"
|
|
1="libisofs"
|
|
2="libburn"
|
|
3="libisoburn"
|
|
else: ""
|
|
bit6= append carriage return rather than line feed (if not os_errno)
|
|
bit7= perform Xorriso_process_msg_queues() first
|
|
bit8= do not prepend name prefix and severity
|
|
*/
|
|
int Xorriso_msgs_submit(struct XorrisO *xorriso,
|
|
int error_code, char msg_text[], int os_errno,
|
|
char severity[], int flag)
|
|
{
|
|
int ret, lt, li, sev, i;
|
|
char *sev_text= "FATAL", prefix[80], *text= NULL;
|
|
static char pfx_list[20][16]= {
|
|
"xorriso : ", "libisofs: ", "libburn : ", "libisoburn: ",
|
|
"", "", "", "", "", "", "", "", "", "", "", "" };
|
|
|
|
if(flag&128)
|
|
Xorriso_process_msg_queues(xorriso, 0);
|
|
|
|
if(strcmp(severity, "ERRFILE")==0)
|
|
Xorriso_process_errfile(xorriso, error_code, msg_text, os_errno, 0);
|
|
|
|
/* Set problem status */
|
|
ret= Xorriso__text_to_sev(severity, &sev, 0);
|
|
if(ret<=0)
|
|
Xorriso__text_to_sev(sev_text, &sev, 0);
|
|
else
|
|
sev_text= severity;
|
|
if(xorriso->problem_status<sev)
|
|
Xorriso_set_problem_status(xorriso, sev_text, 0);
|
|
|
|
/* Report problem event */
|
|
if(sev<xorriso->report_about_severity && sev<xorriso->abort_on_severity)
|
|
{ret= 2; goto ex;}
|
|
lt= strlen(msg_text);
|
|
if(!(flag & 256)) {
|
|
sprintf(prefix,"%s%s : ", pfx_list[(flag>>2)&15], sev_text);
|
|
li= strlen(prefix);
|
|
} else {
|
|
prefix[0]= 0;
|
|
li= 0;
|
|
}
|
|
if(lt > ((int) sizeof(xorriso->info_text)) - li - 2)
|
|
lt= sizeof(xorriso->info_text)-li-2;
|
|
|
|
#ifdef Xorriso_fetch_with_msg_queueS
|
|
|
|
Xorriso_alloc_meM(text, char, sizeof(xorriso->info_text));
|
|
|
|
#else /* Xorriso_fetch_with_msg_queueS */
|
|
|
|
text= xorriso->info_text;
|
|
|
|
#endif /* ! Xorriso_fetch_with_msg_queueS */
|
|
|
|
if(msg_text == text) {
|
|
if(li > 0) {
|
|
for(i= lt; i>=0; i--)
|
|
msg_text[i+li]= msg_text[i];
|
|
for(i=0; i<li; i++)
|
|
msg_text[i]= prefix[i];
|
|
}
|
|
} else {
|
|
if(li > 0)
|
|
strcpy(text, prefix);
|
|
strncpy(text + li, msg_text, lt);
|
|
}
|
|
if((flag&64) && os_errno<=0)
|
|
text[li+lt]= '\r';
|
|
else
|
|
text[li+lt]= '\n';
|
|
text[li+lt+1]= 0;
|
|
if(os_errno>0)
|
|
sprintf(text + strlen(text) - 1, " : %s\n", strerror(os_errno));
|
|
|
|
#ifdef Xorriso_fetch_with_msg_queueS
|
|
|
|
Xorriso_write_to_channel(xorriso, text, 2, 0);
|
|
|
|
#else /* Xorriso_fetch_with_msg_queueS */
|
|
|
|
Xorriso_info(xorriso,4|(flag&3));
|
|
|
|
#endif /* ! Xorriso_fetch_with_msg_queueS */
|
|
|
|
ex:;
|
|
|
|
#ifdef Xorriso_fetch_with_msg_queueS
|
|
Xorriso_free_meM(text);
|
|
#endif /* ! Xorriso_fetch_with_msg_queueS */
|
|
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* To be used with isoburn_set_msgs_submit()
|
|
*/
|
|
int Xorriso_msgs_submit_void(void *xorriso,
|
|
int error_code, char msg_text[], int os_errno,
|
|
char severity[], int flag)
|
|
{
|
|
int ret;
|
|
|
|
ret= Xorriso_msgs_submit((struct XorrisO *) xorriso, error_code, msg_text,
|
|
os_errno, severity, flag);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/** @return -1= abort , 0= no , 1= yes
|
|
*/
|
|
int Xorriso_reassure(struct XorrisO *xorriso, char *cmd, char *which_will,
|
|
int flag)
|
|
{
|
|
int ret;
|
|
|
|
if(!xorriso->do_reassure)
|
|
return(1);
|
|
sprintf(xorriso->info_text, "Really perform %s which will %s ? (y/n)\n",
|
|
cmd, which_will);
|
|
Xorriso_info(xorriso, 4);
|
|
do {
|
|
ret= Xorriso_request_confirmation(xorriso, 2|4|16);
|
|
} while(ret==3);
|
|
if(ret==6 || ret==4) {
|
|
sprintf(xorriso->info_text, "%s confirmed", cmd);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
return(1);
|
|
}
|
|
if(ret==2) {
|
|
sprintf(xorriso->info_text, "%s aborted", cmd);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
return(-1);
|
|
}
|
|
sprintf(xorriso->info_text, "%s revoked", cmd);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
return(0);
|
|
}
|
|
|
|
|
|
int Xorriso_write_session_log(struct XorrisO *xorriso, int flag)
|
|
{
|
|
FILE *fp= NULL;
|
|
char *sfe= NULL, timetext[40], *rpt, *wpt;
|
|
int ret;
|
|
|
|
if(xorriso->session_logfile[0]==0)
|
|
{ret= 2; goto ex;}
|
|
|
|
Xorriso_alloc_meM(sfe, char, 5 * SfileadrL);
|
|
|
|
fp= fopen(xorriso->session_logfile, "a");
|
|
if(fp==0) {
|
|
sprintf(xorriso->info_text, "-session_log: Cannot open file %s",
|
|
Text_shellsafe(xorriso->session_logfile, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
{ret= 0; goto ex;}
|
|
}
|
|
wpt= sfe;
|
|
for(rpt= xorriso->volid; *rpt!=0; rpt++) {
|
|
if(*rpt=='\n') {
|
|
*(wpt++)= '\\';
|
|
*(wpt++)= 'n';
|
|
} else
|
|
*(wpt++)= *rpt;
|
|
}
|
|
*wpt= 0;
|
|
fprintf(fp, "%s %d %d %s\n",
|
|
Ftimetxt(time(0), timetext, 2), xorriso->session_lba,
|
|
xorriso->session_blocks, sfe);
|
|
fclose(fp);
|
|
ret= 1;
|
|
ex:;
|
|
Xorriso_free_meM(sfe);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_status_filter(struct XorrisO *xorriso, char *filter, char *line,
|
|
int flag)
|
|
{
|
|
if(filter!=NULL)
|
|
if(filter[0]=='-')
|
|
if(strncmp(filter, line, strlen(filter))!=0)
|
|
return(0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_status_result(struct XorrisO *xorriso, char *filter, FILE *fp,
|
|
int flag)
|
|
/*
|
|
bit1= do only report to fp
|
|
*/
|
|
{
|
|
int ret;
|
|
|
|
ret= Xorriso_status_filter(xorriso, filter, xorriso->result_line, 0);
|
|
if(ret <= 0)
|
|
return(2);
|
|
if(!(flag&2))
|
|
Xorriso_result(xorriso,0);
|
|
if(fp!=NULL) {
|
|
ret= fwrite(xorriso->result_line,strlen(xorriso->result_line),1,fp);
|
|
if(ret<=0)
|
|
return(ret);
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_status(struct XorrisO *xorriso, char *filter, FILE *fp, int flag)
|
|
/*
|
|
bit0= do only report non-default settings
|
|
bit1= do only report to fp
|
|
bit2= report current -resume status even if bit0 is set, but only if valid
|
|
bit3= report readline history
|
|
bit4= report -resume options indirectly as
|
|
-options_from_file:${resume_state_file}_pos
|
|
*/
|
|
{
|
|
int is_default, no_defaults, i, ret, adr_mode, do_single, behavior;
|
|
int show_indev= 1, show_outdev= 1, show_dev= 0;
|
|
int part_table_implicit= 0;
|
|
char *line, *sfe= NULL, mode[80], *form, *treatment;
|
|
char *in_pt, *out_pt, *nl_charset, *local_charset, *mode_pt;
|
|
char *dev_filter= NULL, *xorriso_id= NULL;
|
|
static char channel_prefixes[4][4]= {".","R","I","M"};
|
|
static char load_names[][20]= {"auto", "session", "track", "lba", "volid"};
|
|
static int max_load_mode= 4;
|
|
struct Xorriso_lsT *paths, *leafs, *s, *plst, *vlst;
|
|
|
|
Xorriso_alloc_meM(sfe, char, 5 * SfileadrL + 80);
|
|
Xorriso_alloc_meM(xorriso_id, char, 129);
|
|
|
|
no_defaults= flag&1;
|
|
line= xorriso->result_line;
|
|
|
|
if(xorriso->no_rc) {
|
|
sprintf(line,"-no_rc\n");
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
}
|
|
|
|
is_default= strcmp(xorriso->list_delimiter, "--") == 0;
|
|
sprintf(line,"-list_delimiter %s\n", xorriso->list_delimiter);
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= 0;
|
|
if(xorriso->dialog == 2)
|
|
sprintf(line,"-dialog on\n");
|
|
else if(xorriso->dialog == 1)
|
|
sprintf(line,"-dialog single_line\n");
|
|
else {
|
|
sprintf(line,"-dialog off\n");
|
|
is_default= 1;
|
|
}
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->result_page_length==0 && xorriso->result_page_width==80);
|
|
sprintf(line,"-page %d %d\n",
|
|
(xorriso->result_page_length>=0?xorriso->result_page_length
|
|
:-xorriso->result_page_length),
|
|
xorriso->result_page_width);
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->use_stdin==0);
|
|
sprintf(line,"-use_readline %s\n", (xorriso->use_stdin?"off":"on"));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->bsl_interpretation == 0);
|
|
strcpy(line, "-backslash_codes ");
|
|
if(xorriso->bsl_interpretation == 0)
|
|
strcat(line, "off");
|
|
else if(xorriso->bsl_interpretation == (3 | 16 | 32 | 64))
|
|
strcat(line, "on");
|
|
else {
|
|
if((xorriso->bsl_interpretation & 3) == 1)
|
|
strcat(line, "in_double_quotes");
|
|
else if((xorriso->bsl_interpretation & 3) == 2)
|
|
strcat(line, "in_quotes");
|
|
else if((xorriso->bsl_interpretation & 3) == 3)
|
|
strcat(line, "with_quoted_input");
|
|
if(xorriso->bsl_interpretation & 16) {
|
|
if(strlen(line) > 17)
|
|
strcat(line, ":");
|
|
strcat(line, "with_program_arguments");
|
|
}
|
|
if((xorriso->bsl_interpretation & (32 | 64)) == (32 | 64)) {
|
|
if(strlen(line) > 17)
|
|
strcat(line, ":");
|
|
strcat(line, "encode_output");
|
|
} else {
|
|
if(xorriso->bsl_interpretation & 32) {
|
|
if(strlen(line) > 17)
|
|
strcat(line, ":");
|
|
strcat(line, "encode_results");
|
|
}
|
|
if(xorriso->bsl_interpretation & 64) {
|
|
if(strlen(line) > 17)
|
|
strcat(line, ":");
|
|
strcat(line, "encode_infos");
|
|
}
|
|
}
|
|
}
|
|
strcat(line, "\n");
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= !xorriso->packet_output;
|
|
sprintf(line,"-pkt_output %s\n",(xorriso->packet_output?"on":"off"));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
for(i=0;i<4;i++) {
|
|
is_default= (xorriso->logfile[i]!=0);
|
|
sprintf(line,"-logfile %s %s\n",
|
|
channel_prefixes[i],Text_shellsafe(xorriso->logfile[i],sfe,0));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
}
|
|
|
|
is_default= (xorriso->errfile_log[0]==0);
|
|
sprintf(line,"-errfile_log %s\n",Text_shellsafe(xorriso->errfile_log,sfe,0));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
if(xorriso->check_media_default == NULL) {
|
|
is_default= 1;
|
|
sprintf(line, "-check_media_defaults reset=now %s\n",
|
|
xorriso->list_delimiter);
|
|
} else {
|
|
ret= Xorriso_check_media_list_job(xorriso, xorriso->check_media_default,
|
|
line, no_defaults);
|
|
is_default= (ret == 2);
|
|
strcat(line, "\n");
|
|
}
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
behavior= Xorriso__get_signal_behavior(0);
|
|
is_default= (behavior == 1);
|
|
treatment= "on";
|
|
if(behavior == 0)
|
|
treatment= "off";
|
|
else if(behavior == 2)
|
|
treatment= "sig_dfl";
|
|
else if(behavior == 3)
|
|
treatment= "sig_ign";
|
|
sprintf(line,"-signal_handling %s\n", treatment);
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->img_read_error_mode==2);
|
|
treatment= "best_effort";
|
|
if(xorriso->img_read_error_mode==1)
|
|
treatment= "failure";
|
|
else if(xorriso->img_read_error_mode==2)
|
|
treatment= "fatal";
|
|
sprintf(line,"-error_behavior image_loading %s\n", treatment);
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
is_default= (xorriso->extract_error_mode == 1);
|
|
treatment= "keep";
|
|
if(xorriso->extract_error_mode == 0)
|
|
treatment= "best_effort";
|
|
else if(xorriso->extract_error_mode == 2)
|
|
treatment= "delete";
|
|
sprintf(line,"-error_behavior file_extraction %s\n", treatment);
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->mark_text[0]==0);
|
|
sprintf(line,"-mark %s\n",Text_shellsafe(xorriso->mark_text,sfe,0));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->temp_mem_limit==16*1024*1024);
|
|
if((xorriso->temp_mem_limit/1024/1024)*1024*1024==xorriso->temp_mem_limit)
|
|
sprintf(line,"-temp_mem_limit %dm\n", xorriso->temp_mem_limit/1024/1024);
|
|
else
|
|
sprintf(line,"-temp_mem_limit %dk\n", xorriso->temp_mem_limit/1024);
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
|
|
sprintf(line,"-prog %s\n",Text_shellsafe(xorriso->progname,sfe,0));
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
if(xorriso->ban_stdio_write) {
|
|
sprintf(line,"-ban_stdio_write\n");
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
}
|
|
|
|
is_default= ((xorriso->early_stdio_test & 14) == 0);
|
|
sprintf(line, "-early_stdio_test %s\n",
|
|
xorriso->early_stdio_test & 6 ? xorriso->early_stdio_test & 8 ?
|
|
"appendable_wo" : "on" : "off");
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= ((xorriso->cache_default & 3) == 3);
|
|
sprintf(line, "-data_cache_size ");
|
|
if(xorriso->cache_default & 1)
|
|
sprintf(line + strlen(line), "default ");
|
|
else
|
|
sprintf(line + strlen(line), "%d ", xorriso->cache_num_tiles);
|
|
if(xorriso->cache_default & 2)
|
|
sprintf(line + strlen(line), "default\n");
|
|
else
|
|
sprintf(line + strlen(line), "%d\n", xorriso->cache_tile_blocks);
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->allow_restore==0 && xorriso->do_concat_split==1 &&
|
|
xorriso->do_auto_chmod==0 && xorriso->drives_exclusive == 1);
|
|
mode_pt= "off";
|
|
if(xorriso->allow_restore == -1)
|
|
mode_pt= "banned";
|
|
else if(xorriso->allow_restore == 1)
|
|
mode_pt= "on";
|
|
else if(xorriso->allow_restore == 2)
|
|
mode_pt= "device_files";
|
|
if(xorriso->allow_restore == -1)
|
|
sprintf(line,"-osirrox %s\n", mode_pt);
|
|
else
|
|
sprintf(line,"-osirrox %s:%s:%s:%s:%s:%s\n", mode_pt,
|
|
xorriso->do_concat_split ? "concat_split_on" : "concat_split_off",
|
|
xorriso->do_auto_chmod ? "auto_chmod_on" : "auto_chmod_off",
|
|
xorriso->do_restore_sort_lba ? "sort_lba_on" : "sort_lba_off",
|
|
xorriso->drives_exclusive ? "o_excl_on" : "o_excl_off",
|
|
(xorriso->do_strict_acl & 1) ? "strict_acl_on" : "strict_acl_off"
|
|
);
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->mount_opts_flag == 0);
|
|
sprintf(line,"-mount_opts %s\n",
|
|
xorriso->mount_opts_flag & 1 ? "shared" : "exclusive");
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
Xorriso_boot_image_status(xorriso, filter, fp, flag & 3);
|
|
|
|
is_default= (xorriso->system_area_disk_path[0] == 0);
|
|
sprintf(line,"-boot_image %s system_area=%s\n",
|
|
xorriso->system_area_disk_path[0] && (xorriso->system_area_options & 2)
|
|
? "isolinux" : "any",
|
|
Text_shellsafe(xorriso->system_area_disk_path, sfe, 0));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->partition_offset == 0);
|
|
sprintf(line,"-boot_image any partition_offset=%lu\n",
|
|
(unsigned long int) xorriso->partition_offset);
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
is_default= (xorriso->partition_secs_per_head == 0);
|
|
sprintf(line,"-boot_image any partition_sec_hd=%lu\n",
|
|
(unsigned long int) xorriso->partition_secs_per_head);
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
is_default= (xorriso->partition_heads_per_cyl == 0);
|
|
sprintf(line,"-boot_image any partition_hd_cyl=%lu\n",
|
|
(unsigned long int) xorriso->partition_heads_per_cyl);
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
ret= (xorriso->system_area_options & 0x300) >> 8;
|
|
is_default= (ret == 0);
|
|
sprintf(line,"-boot_image any partition_cyl_align=%s\n",
|
|
ret == 0 ? "auto" : ret == 1 ? "on" : "off");
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
if((xorriso->system_area_disk_path[0] || !part_table_implicit) &&
|
|
(xorriso->partition_offset == 0 || (xorriso->system_area_options & 2))) {
|
|
is_default= ((xorriso->system_area_options & 3) == 0);
|
|
sprintf(line,"-boot_image %s partition_table=%s\n",
|
|
xorriso->system_area_options & 2 ? "isolinux" : "grub",
|
|
xorriso->system_area_options & 3 ? "on" : "off");
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
}
|
|
|
|
ret= ((xorriso->system_area_options & 0x3cfc) == 0x400);
|
|
is_default= (ret == 0);
|
|
sprintf(line, "-boot_image any chrp_boot_part=%s\n",
|
|
ret == 1 ? "on" : "off");
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso, filter, fp, flag & 2);
|
|
|
|
is_default= (xorriso->prep_partition[0] == 0);
|
|
sprintf(line,"-boot_image any prep_boot_part=%s\n",
|
|
Text_shellsafe(xorriso->prep_partition, sfe, 0));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso, filter, fp, flag & 2);
|
|
|
|
is_default= (xorriso->efi_boot_partition[0] == 0);
|
|
sprintf(line,"-boot_image any efi_boot_part=%s\n",
|
|
Text_shellsafe(xorriso->efi_boot_partition, sfe, 0));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso, filter, fp, flag & 2);
|
|
|
|
#ifdef Xorriso_with_isohybriD
|
|
if(strcmp(form, "isolinux") == 0) {
|
|
static char modes[4][6]= {"off", "auto", "on", "force"};
|
|
is_default= (xorriso->boot_image_isohybrid == 1);
|
|
sprintf(line,"-boot_image isolinux isohybrid=%s\n",
|
|
modes[xorriso->boot_image_isohybrid & 3]);
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
}
|
|
#endif /* Xorriso_with_isohybriD */
|
|
|
|
is_default= 1;
|
|
for(i= 0; i < 8; i++)
|
|
if(xorriso->hfsp_serial_number[i])
|
|
is_default= 0;
|
|
sprintf(line, "-boot_image any hfsplus_serial=");
|
|
for(i= 0; i < 8; i++)
|
|
sprintf(line + strlen(line), "%-2.2X",
|
|
(unsigned int) xorriso->hfsp_serial_number[i]);
|
|
strcat(line, "\n");
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso, filter, fp, flag & 2);
|
|
|
|
is_default= (xorriso->hfsp_block_size == 0);
|
|
sprintf(line, "-boot_image any hfsplus_block_size=%d\n",
|
|
xorriso->hfsp_block_size);
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso, filter, fp, flag & 2);
|
|
|
|
is_default= (xorriso->apm_block_size == 0);
|
|
sprintf(line, "-boot_image any apm_block_size=%d\n",
|
|
xorriso->apm_block_size);
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso, filter, fp, flag & 2);
|
|
|
|
sprintf(line,"-cd ");
|
|
if(filter != NULL)
|
|
if(strncmp(filter, "-cdi", 4) == 0)
|
|
sprintf(line,"-cdi ");
|
|
sprintf(line + strlen(line),"%s\n",
|
|
(xorriso->wdi[0] ? Text_shellsafe(xorriso->wdi,sfe,0) : "'/'"));
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
sprintf(line,"-cdx %s\n",
|
|
(xorriso->wdx[0] ? Text_shellsafe(xorriso->wdx,sfe,0) : "'/'"));
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->split_size==0);
|
|
strcpy(line,"-split_size ");
|
|
if(xorriso->split_size % (1024*1024) || xorriso->split_size==0) {
|
|
Sfile_off_t_text(line+strlen(line), xorriso->split_size, 0);
|
|
} else {
|
|
Sfile_off_t_text(line+strlen(line), xorriso->split_size / (1024*1024), 0);
|
|
strcat(line, "m");
|
|
}
|
|
strcat(line, "\n");
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->add_plainly==0);
|
|
sprintf(line,"-add_plainly %s\n",
|
|
(xorriso->add_plainly == 1 ? "unknown" :
|
|
xorriso->add_plainly == 2 ? "dashed" :
|
|
xorriso->add_plainly == 3 ? "any" : "none"));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
ret= Exclusions_get_descrs(xorriso->disk_exclusions, &paths, &leafs, 0);
|
|
if(ret>0) {
|
|
for(; paths!=NULL; paths= paths->next) {
|
|
sprintf(line, "-not_paths %s %s\n",
|
|
Text_shellsafe(paths->text, sfe, 0), xorriso->list_delimiter);
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
}
|
|
for(; leafs!=NULL; leafs= leafs->next) {
|
|
sprintf(line,"-not_leaf %s\n", Text_shellsafe(leafs->text, sfe, 0));
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
}
|
|
}
|
|
|
|
is_default= (xorriso->file_size_limit ==
|
|
Xorriso_default_file_size_limiT);
|
|
if(xorriso->file_size_limit <= 0)
|
|
sprintf(line, "-file_size_limit off %s\n", xorriso->list_delimiter);
|
|
else
|
|
sprintf(line, "-file_size_limit %.f %s\n",
|
|
(double) xorriso->file_size_limit, xorriso->list_delimiter);
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->disk_excl_mode==1);
|
|
sprintf(line, "-not_mgt %s:%s:%s:%s\n",
|
|
(xorriso->disk_excl_mode&1 ? "on" : "off"),
|
|
(xorriso->disk_excl_mode&2 ? "param_on" : "param_off"),
|
|
(xorriso->disk_excl_mode&4 ? "subtree_on" : "subtree_off"),
|
|
(xorriso->disk_excl_mode&8 ? "ignore_on" : "ignore_off"));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->do_iso_rr_pattern==1);
|
|
sprintf(line,"-iso_rr_pattern %s\n",
|
|
(xorriso->do_iso_rr_pattern == 1 ? "on" :
|
|
(xorriso->do_iso_rr_pattern == 2 ? "ls" : "off")));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->do_disk_pattern==2);
|
|
sprintf(line,"-disk_pattern %s\n",
|
|
(xorriso->do_disk_pattern == 1 ? "on" :
|
|
(xorriso->do_disk_pattern == 2 ? "ls" : "off")));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= xorriso->volid_default;
|
|
sprintf(line,"-volid %s\n",Text_shellsafe(xorriso->volid,sfe,0));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
if(is_default && xorriso->loaded_volid[0] &&
|
|
strcmp(xorriso->loaded_volid, xorriso->volid)!=0 && !no_defaults) {
|
|
sprintf(line,"# loaded image effective -volid %s\n",
|
|
Text_shellsafe(xorriso->loaded_volid,sfe,0));
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
}
|
|
|
|
Xorriso_preparer_string(xorriso, xorriso_id, 0);
|
|
is_default= (strcmp(xorriso->preparer_id, xorriso_id) == 0);
|
|
sprintf(line,"-preparer_id %s\n",Text_shellsafe(xorriso->preparer_id,sfe,0));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->publisher[0]==0);
|
|
sprintf(line,"-publisher %s\n",Text_shellsafe(xorriso->publisher,sfe,0));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->application_id[0]==0);
|
|
sprintf(line,"-application_id %s\n",
|
|
Text_shellsafe(xorriso->application_id,sfe,0));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->system_id[0]==0);
|
|
sprintf(line,"-system_id %s\n", Text_shellsafe(xorriso->system_id,sfe,0));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->volset_id[0]==0);
|
|
sprintf(line,"-volset_id %s\n", Text_shellsafe(xorriso->volset_id,sfe,0));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->vol_creation_time == 0);
|
|
sprintf(line,"-volume_date c %s\n",
|
|
is_default ? "default" :
|
|
Ftimetxt(xorriso->vol_creation_time, sfe, 2));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->vol_modification_time == 0);
|
|
sprintf(line,"-volume_date m %s\n",
|
|
xorriso->vol_uuid[0] ? "overridden" :
|
|
is_default ? "default" :
|
|
Ftimetxt(xorriso->vol_modification_time, sfe, 2));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->vol_expiration_time == 0);
|
|
sprintf(line,"-volume_date x %s\n",
|
|
is_default ? "default" :
|
|
Ftimetxt(xorriso->vol_expiration_time, sfe, 2));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->vol_effective_time == 0);
|
|
sprintf(line,"-volume_date f %s\n",
|
|
is_default ? "default" :
|
|
Ftimetxt(xorriso->vol_effective_time, sfe, 2));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->vol_uuid[0] == 0);
|
|
sprintf(line,"-volume_date uuid %s\n",
|
|
Text_shellsafe(xorriso->vol_uuid,sfe,0));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->copyright_file[0] == 0);
|
|
sprintf(line,"-copyright_file %s\n",
|
|
Text_shellsafe(xorriso->copyright_file,sfe,0));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->biblio_file[0]==0);
|
|
sprintf(line,"-biblio_file %s\n",Text_shellsafe(xorriso->biblio_file,sfe,0));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->abstract_file[0]==0);
|
|
sprintf(line,"-abstract_file %s\n",
|
|
Text_shellsafe(xorriso->abstract_file,sfe,0));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->do_joliet==0);
|
|
sprintf(line,"-joliet %s\n", (xorriso->do_joliet == 1 ? "on" : "off"));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->do_rockridge == 1);
|
|
sprintf(line, "-rockridge %s\n", (xorriso->do_rockridge == 1 ? "on" : "off"));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->do_hfsplus == 0);
|
|
sprintf(line,"-hfsplus %s\n", (xorriso->do_hfsplus == 1 ? "on" : "off"));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
Xorriso_lst_get_last(xorriso->jigdo_params, &plst, 0);
|
|
Xorriso_lst_get_last(xorriso->jigdo_values, &vlst, 0);
|
|
if(plst == NULL || vlst == NULL) {
|
|
is_default= 1;
|
|
sprintf(line,"-jigdo clear 'all'\n");
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso, filter, fp, flag & 2);
|
|
}
|
|
while(plst != NULL && vlst != NULL) {
|
|
sprintf(line,"-jigdo %s %s\n", Xorriso_lst_get_text(plst, 0),
|
|
Text_shellsafe(Xorriso_lst_get_text(vlst, 0), sfe, 0));
|
|
Xorriso_status_result(xorriso, filter, fp, flag & 2);
|
|
plst= Xorriso_lst_get_prev(plst, 0);
|
|
vlst= Xorriso_lst_get_prev(vlst, 0);
|
|
}
|
|
|
|
if(xorriso->do_global_uid) {
|
|
sprintf(line,"-uid %lu\n", (unsigned long) xorriso->global_uid);
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
}
|
|
|
|
if(xorriso->do_global_gid) {
|
|
sprintf(line,"-gid %lu\n", (unsigned long) xorriso->global_gid);
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
}
|
|
|
|
Xorriso_status_extf(xorriso, filter, fp, flag & 2);
|
|
Xorriso_status_zisofs(xorriso, filter, fp, flag & 3);
|
|
|
|
is_default= !xorriso->allow_graft_points;
|
|
sprintf(line,"-pathspecs %s\n", xorriso->allow_graft_points ? "on" : "off");
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->do_follow_pattern && (!xorriso->do_follow_param)
|
|
&& xorriso->do_follow_mount && (!xorriso->do_follow_links)
|
|
&& xorriso->follow_link_limit==100);
|
|
mode[0]= 0;
|
|
if(xorriso->do_follow_pattern &&
|
|
!(xorriso->do_follow_links && xorriso->do_follow_mount))
|
|
strcat(mode,":pattern");
|
|
if(xorriso->do_follow_param && !(xorriso->do_follow_links))
|
|
strcat(mode,":param");
|
|
if(xorriso->do_follow_links)
|
|
strcat(mode,":link");
|
|
if(xorriso->do_follow_mount)
|
|
strcat(mode,":mount");
|
|
if(mode[0]==0)
|
|
strcpy(mode, ":off");
|
|
sprintf(mode+strlen(mode), ":limit=%d", xorriso->follow_link_limit);
|
|
sprintf(line,"-follow %s\n", mode+1);
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->do_overwrite==2);
|
|
sprintf(line,"-overwrite %s\n",(xorriso->do_overwrite == 1 ? "on" :
|
|
(xorriso->do_overwrite == 2 ? "nondir" : "off")));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= !xorriso->do_reassure;
|
|
sprintf(line,"-reassure %s\n",(xorriso->do_reassure == 1 ? "on" :
|
|
(xorriso->do_reassure == 2 ? "tree" : "off")));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= !xorriso->do_close;
|
|
sprintf(line,"-close %s\n",(xorriso->do_close ? "on" : "off"));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->do_tao == 0);
|
|
sprintf(line,"-write_type %s\n",
|
|
xorriso->do_tao == 0 ? "auto" : xorriso->do_tao > 0 ? "tao" : "sao/dao");
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= !xorriso->do_dummy;
|
|
sprintf(line,"-dummy %s\n",(xorriso->do_dummy ? "on" : "off"));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->speed==0);
|
|
sprintf(line,"-speed %dkB/s\n", xorriso->speed);
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->do_stream_recording==0);
|
|
strcpy(mode, "off");
|
|
if(xorriso->do_stream_recording == 1)
|
|
strcpy(mode, "full");
|
|
if(xorriso->do_stream_recording == 2)
|
|
strcpy(mode, "data");
|
|
else if(xorriso->do_stream_recording == 32)
|
|
strcpy(mode, "on");
|
|
else if(xorriso->do_stream_recording >= 16)
|
|
sprintf(mode, "%ds", xorriso->do_stream_recording);
|
|
sprintf(line,"-stream_recording %s\n", mode);
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->dvd_obs == 0);
|
|
strcpy(mode, "default");
|
|
if(xorriso->dvd_obs == 32768 || xorriso->dvd_obs == 65536)
|
|
sprintf(mode, "%dk", xorriso->dvd_obs / 1024);
|
|
sprintf(line,"-dvd_obs %s\n", mode);
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->stdio_sync == 0);
|
|
strcpy(line, "-stdio_sync ");
|
|
if(xorriso->stdio_sync == -1)
|
|
strcat(line, "off");
|
|
else if(xorriso->stdio_sync == 0)
|
|
strcat(line, "on");
|
|
else if(xorriso->stdio_sync % 512) {
|
|
Sfile_off_t_text(line+strlen(line), (off_t) (xorriso->stdio_sync * 2048),
|
|
0);
|
|
} else {
|
|
Sfile_off_t_text(line+strlen(line), (off_t) (xorriso->stdio_sync / 512), 0);
|
|
strcat(line, "m");
|
|
}
|
|
strcat(line, "\n");
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->fs==4*512);
|
|
if((xorriso->fs/512)*512==xorriso->fs)
|
|
sprintf(line,"-fs %dm\n", xorriso->fs/512);
|
|
else
|
|
sprintf(line,"-fs %dk\n", xorriso->fs*2);
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->padding==300*1024);
|
|
sprintf(line,"-padding %dk\n", xorriso->padding/1024);
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
is_default= (xorriso->do_padding_by_libisofs == 0);
|
|
sprintf(line,"-padding %s\n",
|
|
xorriso->do_padding_by_libisofs ? "included" : "appended");
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (strcmp(xorriso->report_about_text,"UPDATE")==0);
|
|
sprintf(line,"-report_about %s\n",xorriso->report_about_text);
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->scsi_log == 0);
|
|
sprintf(line,"-scsi_log %s\n", xorriso->scsi_log ? "on" : "off");
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->session_logfile[0]==0);
|
|
sprintf(line,"-session_log %s\n",
|
|
Text_shellsafe(xorriso->session_logfile,sfe,0));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->pacifier_style==0);
|
|
sprintf(line,"-pacifier '%s'\n",
|
|
xorriso->pacifier_style==1 ? "mkisofs" :
|
|
xorriso->pacifier_style==2 ? "cdrecord" : "xorriso");
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (strcmp(xorriso->return_with_text,"SORRY")==0 &&
|
|
xorriso->return_with_value==32);
|
|
sprintf(line,"-return_with %s %d\n",
|
|
xorriso->return_with_text, xorriso->return_with_value);
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= 0;
|
|
sprintf(line,"-abort_on %s\n",xorriso->abort_on_text);
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
if(xorriso->status_history_max!=Xorriso_status_history_maX || !no_defaults) {
|
|
sprintf(line,"-status_history_max %d\n",xorriso->status_history_max);
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
}
|
|
|
|
#ifdef Xorriso_with_readlinE
|
|
|
|
if((flag&8) && xorriso->status_history_max>0) {
|
|
HIST_ENTRY **hl;
|
|
int hc,i;
|
|
|
|
hl= history_list();
|
|
if(hl!=NULL) {
|
|
for(hc= 0;hl[hc]!=NULL;hc++);
|
|
if(hc>0)
|
|
if(strcmp(hl[hc-1]->line,"-end")==0)
|
|
hc--;
|
|
if(hc>=xorriso->status_history_max)
|
|
i= hc-xorriso->status_history_max;
|
|
else
|
|
i= 0;
|
|
for(;i<hc;i++) {
|
|
sprintf(line,"-history %s\n",Text_shellsafe(hl[i]->line,sfe,0));
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif /* Xorriso_with_readlinE */
|
|
|
|
is_default= (xorriso->toc_emulation_flag == 0);
|
|
sprintf(line,"-rom_toc_scan %s:%s:%s\n",
|
|
xorriso->toc_emulation_flag & 4 ? "force" :
|
|
xorriso->toc_emulation_flag & 1 ? "on" : "off",
|
|
xorriso->toc_emulation_flag & 2 ? "emul_off" : "emul_on",
|
|
xorriso->toc_emulation_flag & 8 ? "emul_wide" : "emul_narrow");
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso, filter, fp, flag & 2);
|
|
|
|
is_default= (xorriso->displacement == 0);
|
|
sprintf(line, "-displacement %s%lu\n",
|
|
xorriso->displacement_sign < 0 ? "-" : "",
|
|
(unsigned long) xorriso->displacement);
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso, filter, fp, flag & 2);
|
|
|
|
adr_mode= xorriso->image_start_mode & 0xffff;
|
|
if(adr_mode>=0 && adr_mode<=max_load_mode) {
|
|
is_default= (adr_mode==0);
|
|
sprintf(line,"-load %s ", load_names[adr_mode]);
|
|
if(adr_mode==0)
|
|
sprintf(line+strlen(line),"''\n");
|
|
else if(adr_mode>=1 && adr_mode<=3)
|
|
sprintf(line+strlen(line),"%s\n", xorriso->image_start_value);
|
|
else
|
|
sprintf(line+strlen(line),"%s\n",
|
|
Text_shellsafe(xorriso->image_start_value, sfe, 0));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
}
|
|
|
|
is_default= (xorriso->do_calm_drive & 1);
|
|
sprintf(line,"-calm_drive %s\n", xorriso->do_calm_drive & 1 ? "on" : "off");
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->grow_blindly_msc2<0);
|
|
sprintf(sfe, "%d", xorriso->grow_blindly_msc2);
|
|
sprintf(line,"-grow_blindly %s\n",
|
|
xorriso->grow_blindly_msc2 < 0 ? "off" : sfe);
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
Xorriso_get_local_charset(xorriso, &local_charset, 0);
|
|
nl_charset= nl_langinfo(CODESET);
|
|
is_default= (strcmp(local_charset, nl_charset) == 0);
|
|
sprintf(line, "-local_charset %s\n", Text_shellsafe(local_charset, sfe, 0));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso, filter, fp, flag & 2);
|
|
|
|
is_default= (xorriso->out_charset == NULL && xorriso->in_charset == NULL);
|
|
in_pt= "";
|
|
if(xorriso->in_charset != NULL)
|
|
in_pt= xorriso->in_charset;
|
|
out_pt= "";
|
|
if(xorriso->out_charset != NULL)
|
|
out_pt= xorriso->out_charset;
|
|
do_single= 0;
|
|
ret= Xorriso_status_filter(xorriso, filter, "-in_charset", 0);
|
|
if(ret <= 0)
|
|
ret= Xorriso_status_filter(xorriso, filter, "-out_charset", 0);
|
|
if(ret > 0)
|
|
do_single= 1;
|
|
if(strcmp(in_pt, out_pt) == 0 && !do_single) {
|
|
sprintf(line, "-charset %s\n", Text_shellsafe(in_pt, sfe, 0));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso, filter, fp, flag & 2);
|
|
} else {
|
|
sprintf(line, "-in_charset %s\n", Text_shellsafe(in_pt, sfe, 0));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso, filter, fp, flag & 2);
|
|
sprintf(line, "-out_charset %s\n", Text_shellsafe(out_pt, sfe, 0));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso, filter, fp, flag & 2);
|
|
}
|
|
is_default= ((xorriso->do_aaip & (256 | 512)) == 0);
|
|
sprintf(line,"-auto_charset %s\n", (xorriso->do_aaip & 256 ? "on" : "off"));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= ((xorriso->ino_behavior & 31) == 7);
|
|
switch (xorriso->ino_behavior & 15) {
|
|
case 0: form= "on";
|
|
break; case 8: form= "without_update";
|
|
break; default: form= "off";
|
|
}
|
|
sprintf(line,"-hardlinks %s:%s\n", form,
|
|
xorriso->ino_behavior & 16 ?
|
|
"cheap_sorted_extract" : "normal_extract");
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= ((xorriso->do_aaip & (1 | 4)) == 0);
|
|
sprintf(line,"-acl %s\n", (xorriso->do_aaip & 1 ? "on" : "off"));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
is_default= ((xorriso->do_aaip & (2 | 8)) == 0);
|
|
sprintf(line,"-xattr %s\n", (xorriso->do_aaip & 4 ? "on" : "off"));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
is_default= ((xorriso->do_aaip & (16 | 32 | 64)) == 0);
|
|
sprintf(line,"-disk_dev_ino %s\n",
|
|
(xorriso->do_aaip & 16 ? (xorriso->do_aaip & 128 ? "ino_only" : "on" )
|
|
: "off"));
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= ((xorriso->do_md5 & 31) == 0);
|
|
sprintf(line, "-md5 ");
|
|
if(xorriso->do_md5 & 1) {
|
|
if((xorriso->do_md5 & 8) == 8) {
|
|
strcat(line, "all");
|
|
} else {
|
|
strcat(line, "on");
|
|
if(xorriso->do_md5 & 8)
|
|
strcat(line, ":stability_check_on");
|
|
}
|
|
if(xorriso->do_md5 & 32)
|
|
strcat(line, ":load_check_off");
|
|
strcat(line, "\n");
|
|
} else
|
|
strcat(line, "off\n");
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->scdbackup_tag_name[0] == 0 &&
|
|
xorriso->scdbackup_tag_listname[0] == 0);
|
|
sprintf(line, "-scdbackup_tag ");
|
|
Text_shellsafe(xorriso->scdbackup_tag_listname, line, 1);
|
|
strcat(line, " ");
|
|
Text_shellsafe(xorriso->scdbackup_tag_name, line, 1);
|
|
strcat(line, "\n");
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (Xorriso_get_relax_text(xorriso, sfe, 0) == 2);
|
|
sprintf(line,"-compliance %s\n", sfe);
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->rr_reloc_dir[0] == 0);
|
|
sprintf(line, "-rr_reloc_dir ");
|
|
Text_shellsafe(xorriso->rr_reloc_dir, line, 1);
|
|
strcat(line, "\n");
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= (xorriso->assert_volid[0] == 0);
|
|
sprintf(line, "-assert_volid ");
|
|
Text_shellsafe(xorriso->assert_volid, line, 1);
|
|
strcat(line, " ");
|
|
Text_shellsafe(xorriso->assert_volid_sev, line, 1);
|
|
strcat(line, "\n");
|
|
if(!(is_default && no_defaults))
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
|
|
is_default= 1;
|
|
if(xorriso->drive_blacklist != NULL || xorriso->drive_whitelist != NULL ||
|
|
xorriso->drive_greylist == NULL)
|
|
is_default= 0;
|
|
if(xorriso->drive_greylist != NULL) {
|
|
if(strcmp(Xorriso_get_pattern(xorriso, xorriso->drive_greylist, 0, 0),
|
|
"/dev") != 0)
|
|
is_default= 0;
|
|
if(Xorriso_get_pattern(xorriso, xorriso->drive_greylist, 1, 0) != NULL)
|
|
is_default= 0;
|
|
}
|
|
if(!(is_default && no_defaults)) {
|
|
for(s= xorriso->drive_blacklist; s != NULL; s= Xorriso_lst_get_next(s, 0)) {
|
|
sprintf(line, "-drive_class 'banned' %s\n",
|
|
Text_shellsafe(Xorriso_lst_get_text(s, 0), sfe, 0));
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
}
|
|
for(s= xorriso->drive_greylist; s != NULL; s= Xorriso_lst_get_next(s, 0)) {
|
|
sprintf(line, "-drive_class 'caution' %s\n",
|
|
Text_shellsafe(Xorriso_lst_get_text(s, 0), sfe, 0));
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
}
|
|
for(s= xorriso->drive_whitelist; s != NULL; s= Xorriso_lst_get_next(s, 0)) {
|
|
sprintf(line, "-drive_class 'harmless' %s\n",
|
|
Text_shellsafe(Xorriso_lst_get_text(s, 0), sfe, 0));
|
|
Xorriso_status_result(xorriso,filter,fp,flag&2);
|
|
}
|
|
}
|
|
|
|
do_single= 0;
|
|
dev_filter= filter;
|
|
if(dev_filter != NULL) {
|
|
show_dev= Xorriso_status_filter(xorriso, filter, "-dev", 0);
|
|
if(show_dev > 0)
|
|
dev_filter= NULL;
|
|
}
|
|
if(dev_filter != NULL) {
|
|
show_indev= Xorriso_status_filter(xorriso, filter, "-indev", 0);
|
|
show_outdev= Xorriso_status_filter(xorriso, filter, "-outdev", 0);
|
|
if(show_outdev > 0 || show_indev > 0)
|
|
do_single= 1;
|
|
}
|
|
if(xorriso->drives_exclusive != xorriso->indev_is_exclusive &&
|
|
xorriso->indev[0])
|
|
do_single= 1;
|
|
else if(xorriso->drives_exclusive != xorriso->outdev_is_exclusive &&
|
|
xorriso->outdev[0])
|
|
do_single= 1;
|
|
if(strcmp(xorriso->indev, xorriso->outdev) == 0 && !do_single) {
|
|
sprintf(line,"-dev %s\n", Text_shellsafe(xorriso->indev,sfe,0));
|
|
Xorriso_status_result(xorriso, dev_filter, fp, flag & 2);
|
|
} else {
|
|
if(xorriso->drives_exclusive != xorriso->indev_is_exclusive &&
|
|
xorriso->indev[0] && show_indev) {
|
|
sprintf(line,"-osirrox o_excl_%s\n",
|
|
xorriso->indev_is_exclusive ? "on" : "off");
|
|
Xorriso_status_result(xorriso, NULL, fp, flag & 2);
|
|
}
|
|
sprintf(line,"-indev %s\n", Text_shellsafe(xorriso->indev,sfe,0));
|
|
Xorriso_status_result(xorriso, dev_filter, fp, flag & 2);
|
|
if(xorriso->drives_exclusive != xorriso->indev_is_exclusive &&
|
|
xorriso->indev[0] && show_indev) {
|
|
sprintf(line,"-osirrox o_excl_%s\n",
|
|
xorriso->drives_exclusive ? "on" : "off");
|
|
Xorriso_status_result(xorriso, NULL, fp, flag & 2);
|
|
}
|
|
|
|
if(xorriso->drives_exclusive != xorriso->outdev_is_exclusive &&
|
|
xorriso->outdev[0] && show_outdev) {
|
|
sprintf(line,"-osirrox o_excl_%s\n",
|
|
xorriso->outdev_is_exclusive ? "on" : "off");
|
|
Xorriso_status_result(xorriso, NULL, fp, flag & 2);
|
|
}
|
|
sprintf(line,"-outdev %s\n", Text_shellsafe(xorriso->outdev,sfe,0));
|
|
Xorriso_status_result(xorriso, dev_filter, fp, flag & 2);
|
|
if(xorriso->drives_exclusive != xorriso->outdev_is_exclusive &&
|
|
xorriso->outdev[0] && show_outdev) {
|
|
sprintf(line,"-osirrox o_excl_%s\n",
|
|
xorriso->drives_exclusive ? "on" : "off");
|
|
Xorriso_status_result(xorriso, NULL, fp, flag & 2);
|
|
}
|
|
}
|
|
|
|
ret= 1;
|
|
ex:;
|
|
Xorriso_free_meM(sfe);
|
|
Xorriso_free_meM(xorriso_id);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_pacifier_reset(struct XorrisO *xorriso, int flag)
|
|
{
|
|
xorriso->start_time= Sfile_microtime(0);
|
|
xorriso->last_update_time= xorriso->start_time;
|
|
xorriso->pacifier_count= 0;
|
|
xorriso->pacifier_prev_count= 0;
|
|
xorriso->pacifier_total= 0;
|
|
xorriso->pacifier_byte_count= 0;
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* This call is to be issued by long running workers in short intervals.
|
|
It will check whether enough time has elapsed since the last pacifier
|
|
message and eventually issue an update message.
|
|
@param what_done A sparse description of the action, preferrably in past
|
|
tense. E.g. "done" , "files added".
|
|
@param count The number of objects processed so far.
|
|
Is ignored if <=0.
|
|
@param todo The number of objects to be done in total.
|
|
Is ignored if <=0.
|
|
@param current_object A string telling the object currently processed.
|
|
Ignored if "".
|
|
@param flag bit0= report unconditionally, no time check
|
|
bit1= report count <=0 (no thank you for being patient then)
|
|
bit2= report xorriso->pacifier_byte_count
|
|
bit3= report speed
|
|
bit4= with bit3: count is in blocks, else in bytes
|
|
bit5= with bit3: report total speed
|
|
bit6= report with carriage return rather than line feed
|
|
bit7= with bit5: speed unit for outdev rather than indev
|
|
*/
|
|
int Xorriso_pacifier_callback(struct XorrisO *xorriso, char *what_done,
|
|
off_t count, off_t todo, char *current_object,
|
|
int flag)
|
|
{
|
|
double current_time, since, interval_time, speed, speed_factor;
|
|
char count_text[80], byte_text[80], profile_name[80], *speed_unit;
|
|
int ret, profile_number;
|
|
off_t amount;
|
|
|
|
current_time= Sfile_microtime(0);
|
|
interval_time= current_time - xorriso->last_update_time;
|
|
if(interval_time < xorriso->pacifier_interval
|
|
&& !(flag&1))
|
|
return(1);
|
|
xorriso->last_update_time= Sfile_microtime(0);
|
|
since= current_time - xorriso->start_time;
|
|
if((flag&1)&&since<1.0)
|
|
since= 1.0;
|
|
byte_text[0]= 0;
|
|
if(flag&4) {
|
|
strcat(byte_text, " (");
|
|
Sfile_scale((double) xorriso->pacifier_byte_count,
|
|
byte_text+strlen(byte_text), 7, 1e5, 0);
|
|
strcat(byte_text, ")");
|
|
}
|
|
if(count<=0.0 && !(flag&2)) {
|
|
if(since < 2)
|
|
return(2);
|
|
sprintf(xorriso->info_text,
|
|
"Thank you for being patient for %.f seconds", since);
|
|
} else if(todo<=0.0) {
|
|
if(count<10000000)
|
|
sprintf(count_text, "%.f", (double) count);
|
|
else
|
|
Sfile_scale((double) count, count_text, 7, 1e5, 1);
|
|
sprintf(xorriso->info_text, "%s %s%s in %.f %s",
|
|
count_text, what_done, byte_text, since,
|
|
(flag & 64) ? "s" : "seconds");
|
|
} else {
|
|
sprintf(xorriso->info_text, "%.f of %.f %s%s in %.f %s",
|
|
(double) count, (double) todo, what_done, byte_text, since,
|
|
(flag & (8 | 64)) ? "s" : "seconds");
|
|
}
|
|
speed= -1.0;
|
|
if(flag & 4)
|
|
amount= xorriso->pacifier_byte_count;
|
|
else
|
|
amount= count;
|
|
if((flag & 8)) {
|
|
if(flag & 32) {
|
|
if(since > 0)
|
|
speed= amount / since;
|
|
} else if(amount >= xorriso->pacifier_prev_count) {
|
|
if(interval_time > 0)
|
|
speed= (amount - xorriso->pacifier_prev_count) / interval_time;
|
|
}
|
|
}
|
|
if(speed >= 0.0) {
|
|
if(flag & 16)
|
|
speed*= 2048.0;
|
|
ret= Xorriso_get_profile(xorriso, &profile_number, profile_name,
|
|
(flag >> 6) & 2);
|
|
speed_factor= 1385000;
|
|
speed_unit= "D";
|
|
if(ret == 2) {
|
|
speed_factor= 150.0*1024;
|
|
speed_unit= "C";
|
|
} else if(ret == 3) {
|
|
speed_factor= 4495625;
|
|
speed_unit= "B";
|
|
}
|
|
sprintf(xorriso->info_text+strlen(xorriso->info_text), " %s %.1fx%s",
|
|
(flag & 32 ? "=" : ","), speed / speed_factor, speed_unit);
|
|
}
|
|
xorriso->pacifier_prev_count= amount;
|
|
if(current_object[0]!=0)
|
|
sprintf(xorriso->info_text+strlen(xorriso->info_text),
|
|
", now at %s", current_object);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "UPDATE", (flag&64));
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_reset_counters(struct XorrisO *xorriso, int flag)
|
|
{
|
|
xorriso->error_count= 0;
|
|
xorriso->insert_count= 0;
|
|
xorriso->insert_bytes= 0;
|
|
Xorriso_pacifier_reset(xorriso, 0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_no_malloc_memory(struct XorrisO *xorriso, char **to_free, int flag)
|
|
{
|
|
if(to_free!=NULL)
|
|
if(*to_free!=NULL) {
|
|
/* Eventual memory sacrifice to get on going */
|
|
free(*to_free);
|
|
*to_free= NULL;
|
|
}
|
|
sprintf(xorriso->info_text, "Out of virtual memory");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "ABORT", 0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param flag bit0=path is in source filesystem , bit1= unconditionally */
|
|
int Xorriso_much_too_long(struct XorrisO *xorriso, int len, int flag)
|
|
{
|
|
if(len>=SfileadrL || (flag&2)) {
|
|
sprintf(xorriso->info_text,
|
|
"Path given for %s is much too long (%d)",
|
|
((flag&1) ? "local filesystem" : "ISO image"), len);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_no_findjob(struct XorrisO *xorriso, char *cmd, int flag)
|
|
{
|
|
sprintf(xorriso->info_text, "%s: cannot create find job object", cmd);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_report_md5_outcome(struct XorrisO *xorriso, char *severity,
|
|
int flag)
|
|
{
|
|
int has_md5;
|
|
|
|
has_md5= Xorriso_image_has_md5(xorriso, 0);
|
|
if(xorriso->find_check_md5_result & 1) {
|
|
sprintf(xorriso->result_line,
|
|
"Mismatch detected between file contents and MD5 checksums.\n");
|
|
} else if(xorriso->find_check_md5_result & 8) {
|
|
sprintf(xorriso->result_line,
|
|
"File contents and their MD5 checksums match.\n");
|
|
} else {
|
|
sprintf(xorriso->result_line,
|
|
"Not a single file with MD5 checksum was found.");
|
|
if(has_md5 <= 0)
|
|
strcat(xorriso->result_line,
|
|
" (There is no MD5 checksum array loaded.)\n");
|
|
else
|
|
strcat(xorriso->result_line, "\n");
|
|
}
|
|
Xorriso_result(xorriso,0);
|
|
if(xorriso->find_check_md5_result & 2) {
|
|
sprintf(xorriso->result_line,
|
|
"Encountered errors other than non-match during MD5 checking.\n");
|
|
Xorriso_result(xorriso,0);
|
|
}
|
|
if((xorriso->find_check_md5_result & 4) && has_md5) {
|
|
sprintf(xorriso->result_line,
|
|
"There were data files which have no MD5 and thus could not be checked.\n");
|
|
Xorriso_result(xorriso,0);
|
|
}
|
|
if((xorriso->find_check_md5_result & 3) && strcmp(severity, "ALL") != 0) {
|
|
sprintf(xorriso->info_text, "Event triggered by MD5 comparison mismatch");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, severity, 0);
|
|
}
|
|
return(1);
|
|
}
|
|
|