3339 lines
99 KiB
C
3339 lines
99 KiB
C
|
|
/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
|
|
|
|
Copyright 2007-2019 Thomas Schmitt, <scdbackup@gmx.net>
|
|
|
|
Provided under GPL version 2 or later.
|
|
|
|
This file contains the implementation of functions which deal with parsing
|
|
and interpretation of command input.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "../config.h"
|
|
#endif
|
|
|
|
#include <ctype.h>
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/time.h>
|
|
#include <time.h>
|
|
#include <fcntl.h>
|
|
#include <errno.h>
|
|
#include <pwd.h>
|
|
#include <grp.h>
|
|
#include <sys/resource.h>
|
|
#include <sys/wait.h>
|
|
|
|
|
|
#include "xorriso.h"
|
|
#include "xorriso_private.h"
|
|
#include "xorrisoburn.h"
|
|
|
|
|
|
#ifdef Xorriso_fetch_with_msg_queueS
|
|
#include <pthread.h>
|
|
#endif
|
|
|
|
|
|
/* @param flag bit0= do not warn of wildcards
|
|
bit1= these are disk_paths
|
|
*/
|
|
int Xorriso_end_idx(struct XorrisO *xorriso,
|
|
int argc, char **argv, int idx, int flag)
|
|
{
|
|
int i, warned= 0;
|
|
|
|
for(i= idx; i<argc; i++) {
|
|
if(strcmp(argv[i], xorriso->list_delimiter)==0)
|
|
break;
|
|
if(!((flag&1) || warned))
|
|
warned= Xorriso_warn_of_wildcards(xorriso, argv[i], flag&2);
|
|
}
|
|
return(i);
|
|
}
|
|
|
|
|
|
/* Returns a vector of strings which belong to an open ended arg list.
|
|
If expansion is enabled, the vector might be allocated, else it is
|
|
a pointer into the argv input vector.
|
|
Thus the release of that memory is an expert task to be done by this
|
|
function only. Use bit8 for that. With bit8 parameter argc MUST be the
|
|
same value as with the call which might have allocated memory.
|
|
@param xorriso The environment object
|
|
@param argc Length of argv
|
|
@param argv The vector with arguments, eventual list_delimiter ("--")
|
|
and then eventual unrelated words
|
|
@param idx Start index in argv of the argument list
|
|
@param optc Length of the effective possibly expanded option vector
|
|
@param optv The option vector. Maybe a pointer into argv or maybe
|
|
an own allocated vector.
|
|
@param flag bit0= do not warn of wildcards
|
|
bit1= these are disk_paths
|
|
bit2= never expand wildcards
|
|
bit3= do not expand last argument
|
|
bit4= ignore last argument
|
|
bit5= demand exactly one match
|
|
bit6= with bit5 allow 0 matches if pattern is a constant
|
|
bit7= silently tolerate empty argument list
|
|
bit8= free the eventually allocated sub_vector
|
|
bit9= always expand wildcards
|
|
bit10= do not add unresolved pattern to optv
|
|
*/
|
|
int Xorriso_opt_args(struct XorrisO *xorriso, char *cmd,
|
|
int argc, char **argv, int idx,
|
|
int *end_idx, int *optc, char ***optv, int flag)
|
|
{
|
|
int i, do_expand, nump, was_empty= 0, filec= 0, ret;
|
|
char **filev= NULL, **patterns= NULL;
|
|
off_t mem= 0;
|
|
|
|
if(flag&2)
|
|
do_expand= (xorriso->do_disk_pattern==1 && !(flag&4)) || (flag & 512);
|
|
else
|
|
do_expand= (xorriso->do_iso_rr_pattern==1 && !(flag&4)) || (flag & 512);
|
|
if(flag&256) {
|
|
if(argv == NULL || *optv < argv || (*optv >= argv + argc && argc > 0))
|
|
Sfile_destroy_argv(optc, optv, 0);
|
|
return(1);
|
|
}
|
|
if(idx>=argc) {
|
|
*end_idx= argc;
|
|
*optc= 0;
|
|
*optv= NULL;
|
|
sprintf(xorriso->info_text, "%s : Not enough arguments given", cmd);
|
|
if((flag & 128))
|
|
return(1);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
|
|
return(0);
|
|
}
|
|
*end_idx= Xorriso_end_idx(xorriso, argc, argv, idx,
|
|
((flag&1) || do_expand) | (flag&2));
|
|
if(*end_idx<0)
|
|
return(*end_idx);
|
|
if((flag&16) && (*end_idx)>idx)
|
|
(*end_idx)--;
|
|
|
|
*optc= *end_idx - idx;
|
|
*optv= NULL;
|
|
if(*optc<=0 || !do_expand) {
|
|
copy_args:;
|
|
if(*optc > 0) {
|
|
Xorriso_alloc_meM(*optv, char *, *optc);
|
|
for(i= 0; i < *optc; i++) {
|
|
Xorriso_alloc_meM((*optv)[i], char, strlen(argv[idx + i]) + 1);
|
|
strcpy((*optv)[i], argv[idx + i]);
|
|
}
|
|
}
|
|
return(1);
|
|
}
|
|
patterns= calloc(*optc, sizeof(char *));
|
|
if(patterns==NULL) {
|
|
no_memory:;
|
|
sprintf(xorriso->info_text,
|
|
"%s : Cannot allocate enough memory for pattern expansion", cmd);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
{ret= -1; goto ex;}
|
|
}
|
|
nump= 0;
|
|
if(flag&8) {
|
|
was_empty= 1;
|
|
mem+= strlen(argv[idx + *optc - 1])+1+sizeof(char *);
|
|
}
|
|
for(i= 0; i<*optc-!!(flag&8); i++) {
|
|
if(argv[i + idx][0]==0) {
|
|
was_empty++;
|
|
mem+= sizeof(char *); /* as upper limit for size of an empty string */
|
|
continue;
|
|
}
|
|
patterns[nump++]= argv[i + idx];
|
|
}
|
|
if(nump<=0) { /* Only empty texts. May the caller get happy with them. */
|
|
free(patterns);
|
|
goto copy_args;
|
|
}
|
|
if(flag&2)
|
|
ret= Xorriso_expand_disk_pattern(xorriso, nump, patterns, was_empty,
|
|
&filec, &filev, &mem,
|
|
((flag >> 5) & 3) | ((!!(flag & 1024)) << 3));
|
|
else
|
|
ret= Xorriso_expand_pattern(xorriso, nump, patterns, was_empty,
|
|
&filec, &filev, &mem,
|
|
((flag >> 5) & 3) | ((!!(flag & 1024)) << 3));
|
|
if(ret<=0)
|
|
{ret= 0; goto ex;}
|
|
for(i= 0; i<was_empty; i++) {
|
|
if(i==was_empty-1 && (flag&8))
|
|
filev[filec++]= strdup(argv[idx + *optc - 1]);
|
|
else
|
|
filev[filec++]= strdup("");
|
|
if(filev[filec-1]==NULL)
|
|
goto no_memory;
|
|
}
|
|
|
|
#ifdef Xorriso_verbous_pattern_expansioN
|
|
{ int l;
|
|
sprintf(xorriso->info_text, "Pattern expansion yields %d items:", filec);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
|
|
l= 0;
|
|
xorriso->info_text[0]= 0;
|
|
for(i= 0; i<filec; i++) {
|
|
l= strlen(xorriso->info_text);
|
|
if(l>0 && l+1+strlen(filev[i])>60) {
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
|
|
xorriso->info_text[0]= 0;
|
|
l= 0;
|
|
}
|
|
sprintf(xorriso->info_text+l, " %s", filev[i]);
|
|
}
|
|
l= strlen(xorriso->info_text);
|
|
if(l>0)
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
|
|
}
|
|
#endif /* Xorriso_verbous_pattern_expansioN */
|
|
|
|
ret= 1;
|
|
ex:;
|
|
if(patterns!=NULL)
|
|
free((char *) patterns);
|
|
if(ret<=0) {
|
|
Sfile_destroy_argv(&filec, &filev, 0);
|
|
} else {
|
|
*optc= filec;
|
|
*optv= filev;
|
|
}
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= get eternal problem status
|
|
*/
|
|
int Xorriso_get_problem_status(struct XorrisO *xorriso, char severity[80],
|
|
int flag)
|
|
{
|
|
if(flag & 1) {
|
|
strcpy(severity, xorriso->eternal_problem_status_text);
|
|
return(xorriso->eternal_problem_status);
|
|
} else {
|
|
strcpy(severity, xorriso->problem_status_text);
|
|
return(xorriso->problem_status);
|
|
}
|
|
}
|
|
|
|
|
|
/* @param flag bit0= set eternal problem status to severity,
|
|
and set problem status to ALL
|
|
*/
|
|
int Xorriso_set_problem_status(struct XorrisO *xorriso, char *severity,
|
|
int flag)
|
|
{
|
|
char *sev_text= "ALL";
|
|
int sev, ret;
|
|
|
|
#ifdef Xorriso_fetch_with_msg_queueS
|
|
int locked= 0, uret;
|
|
static int complaints= 0, complaint_limit= 5;
|
|
#endif
|
|
|
|
if(severity[0] && strlen(severity) < sizeof(xorriso->problem_status_text))
|
|
sev_text= severity;
|
|
ret= Xorriso__text_to_sev(sev_text, &sev, 0);
|
|
if(ret<=0)
|
|
return(0);
|
|
|
|
#ifdef Xorriso_fetch_with_msg_queueS
|
|
|
|
ret= pthread_mutex_lock(&(xorriso->problem_status_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 problem_status returns %d\n",
|
|
ret);
|
|
} else
|
|
locked= 1;
|
|
|
|
#endif /* Xorriso_fetch_with_msg_queueS */
|
|
|
|
if(flag & 1) {
|
|
strcpy(xorriso->problem_status_text, "ALL");
|
|
Xorriso__text_to_sev(xorriso->problem_status_text,
|
|
&(xorriso->problem_status), 0);
|
|
} else {
|
|
xorriso->problem_status= sev;
|
|
strcpy(xorriso->problem_status_text, sev_text);
|
|
}
|
|
if(sev > xorriso->eternal_problem_status || (flag & 1)) {
|
|
xorriso->eternal_problem_status= sev;
|
|
strcpy(xorriso->eternal_problem_status_text, sev_text);
|
|
}
|
|
|
|
#ifdef Xorriso_fetch_with_msg_queueS
|
|
|
|
if(locked) {
|
|
uret= pthread_mutex_unlock(&(xorriso->problem_status_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 problem_status returns %d\n",
|
|
uret);
|
|
}
|
|
}
|
|
|
|
#endif /* Xorriso_fetch_with_msg_queueS */
|
|
|
|
return(1);
|
|
}
|
|
|
|
|
|
/**
|
|
@param flag bit0= do not issue own event messages
|
|
bit1= take xorriso->request_to_abort as reason for abort
|
|
@return Gives the advice:
|
|
2= pardon was given, go on
|
|
1= no problem, go on
|
|
0= function failed but xorriso would not abort, go on
|
|
<0= do abort
|
|
-1 = due to problem_status
|
|
-2 = due to xorriso->request_to_abort
|
|
*/
|
|
int Xorriso_eval_problem_status(struct XorrisO *xorriso, int ret, int flag)
|
|
{
|
|
static int sev= 0;
|
|
if(sev==0)
|
|
Xorriso__text_to_sev("SORRY", &sev, 0);
|
|
|
|
if((flag&2) && xorriso->request_to_abort)
|
|
return(-2);
|
|
|
|
Xorriso_process_msg_queues(xorriso, 0);
|
|
if(ret>0 && xorriso->problem_status <= 0)
|
|
return(1);
|
|
|
|
if(xorriso->problem_status < xorriso->abort_on_severity &&
|
|
xorriso->problem_status > 0) {
|
|
if(xorriso->problem_status >= sev && !(flag&1)) {
|
|
sprintf(xorriso->info_text,
|
|
"xorriso : NOTE : Tolerated problem event of severity '%s'\n",
|
|
xorriso->problem_status_text);
|
|
Xorriso_info(xorriso, 0);/* submit not as problem event */
|
|
}
|
|
ret= 2;
|
|
} else if(xorriso->problem_status > 0) {
|
|
sprintf(xorriso->info_text,
|
|
"xorriso : aborting : -abort_on '%s' encountered '%s'\n",
|
|
xorriso->abort_on_text, xorriso->problem_status_text);
|
|
if(!(flag&1))
|
|
Xorriso_info(xorriso, 0);/* submit not as problem event */
|
|
ret= -1;
|
|
} else if(ret>0)
|
|
ret= 1;
|
|
else
|
|
ret= 2;
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= a non-existing target of multiple sources is a directory
|
|
bit1= all paths except the last one are disk_paths
|
|
bit2= the last path is a disk_path
|
|
@return <=0 is error, 1= leaf file object, 2= directory
|
|
*/
|
|
int Xorriso_cpmv_args(struct XorrisO *xorriso, char *cmd,
|
|
int argc, char **argv, int *idx,
|
|
int *optc, char ***optv, char eff_dest[SfileadrL],
|
|
int flag)
|
|
{
|
|
int destc= 0, is_dir=0, end_idx, ret, i;
|
|
char **destv= NULL;
|
|
|
|
end_idx= Xorriso_end_idx(xorriso, argc, argv, *idx,
|
|
(xorriso->do_iso_rr_pattern==1)|(flag&2));
|
|
if(end_idx - *idx < 2) {
|
|
sprintf(xorriso->info_text, "%s: not enough arguments", cmd);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
|
|
{ret= 0; goto ex;}
|
|
}
|
|
|
|
ret= Xorriso_opt_args(xorriso, cmd, argc, argv, *idx, &end_idx, optc, optv,
|
|
1 | (flag&2) | 16); /* ignore last argument */
|
|
if(ret<=0)
|
|
goto ex;
|
|
/* demand one match, or 0 with a constant */
|
|
ret= Xorriso_opt_args(xorriso, cmd, argc, argv, end_idx, &end_idx, &destc,
|
|
&destv, 1 | ((flag&4)>>1) | 32 | 64);
|
|
if(ret<=0)
|
|
goto ex;
|
|
|
|
/* Evaluate target address */
|
|
if(flag&4)
|
|
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdx, destv[0], eff_dest,
|
|
2|4|16);
|
|
else
|
|
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, destv[0], eff_dest,
|
|
1);
|
|
if(ret<0)
|
|
{ret= 0; goto ex;}
|
|
if(ret==2 || ((flag&1) && *optc > 1 && ret==0)) {
|
|
is_dir= 1;
|
|
} else if(*optc > 1) {
|
|
if(flag & 2)
|
|
for(i= 0; i<*optc; i++)
|
|
Xorriso_msgs_submit(xorriso, 0, (*optv)[i], 0, "ERRFILE", 0);
|
|
sprintf(xorriso->info_text,
|
|
"%s: more than one origin given, destination is a non-directory: ",
|
|
cmd);
|
|
Text_shellsafe(destv[0], xorriso->info_text, 1);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
{ret= 0; goto ex;}
|
|
}
|
|
if(ret==0) { /* compute complete eff_dest */
|
|
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, destv[0], eff_dest,
|
|
2 | (flag&4));
|
|
if(ret<0)
|
|
{ret= 0; goto ex;}
|
|
}
|
|
|
|
ret= 1+is_dir;
|
|
ex:;
|
|
Xorriso_opt_args(xorriso, cmd, argc, argv, *idx, &end_idx, &destc, &destv,
|
|
256);
|
|
(*idx)= end_idx;
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= with adr_mode sbsector: adr_value is possibly 16 too high
|
|
*/
|
|
int Xorriso_decode_load_adr(struct XorrisO *xorriso, char *cmd,
|
|
char *adr_mode, char *adr_value,
|
|
int *entity_code, char entity_id[81],
|
|
int flag)
|
|
{
|
|
double num;
|
|
int l;
|
|
|
|
if(strcmp(adr_mode, "auto")==0)
|
|
*entity_code= 0;
|
|
else if(strcmp(adr_mode, "session")==0)
|
|
*entity_code= 1;
|
|
else if(strcmp(adr_mode, "track")==0)
|
|
*entity_code= 2;
|
|
else if(strcmp(adr_mode, "lba")==0 || strcmp(adr_mode, "sbsector")==0)
|
|
*entity_code= 3 | ((flag&1) << 16);
|
|
else if(strcmp(adr_mode, "volid")==0)
|
|
*entity_code= 4;
|
|
else {
|
|
sprintf(xorriso->info_text, "%s: unknown address mode '%s'", cmd, adr_mode);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
l= strlen(adr_value);
|
|
if(l==0)
|
|
*entity_code= 0;
|
|
|
|
if(*entity_code>=1 && *entity_code<= 3) {
|
|
num= Scanf_io_size(adr_value, 0);
|
|
if(*entity_code==3 &&
|
|
(adr_value[l-1]<'0' || adr_value[l-1]>'9'))
|
|
num/= 2048.0;
|
|
sprintf(entity_id, "%.f", num);
|
|
} else {
|
|
if(strlen(adr_value)>80) {
|
|
sprintf(xorriso->info_text, "%s: address value too long (80 < %d)",
|
|
cmd, (int) strlen(adr_value));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
strcpy(entity_id, adr_value);
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_check_thing_len(struct XorrisO *xorriso, char *name, int size,
|
|
char *cmd, char *thing, int flag)
|
|
{
|
|
if((int) strlen(name) >= size) {
|
|
sprintf(xorriso->info_text,
|
|
"%s too long with option %s (%d > %d)", thing, cmd,
|
|
(int) strlen(name), size - 1);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
|
|
return(0);
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_check_name_len(struct XorrisO *xorriso, char *name, int size,
|
|
char *cmd, int flag)
|
|
{
|
|
return Xorriso_check_thing_len(xorriso, name, size, cmd, "Name", flag);
|
|
}
|
|
|
|
|
|
/* @return <0 error , >=0 number of skipped dashes
|
|
*/
|
|
int Xorriso_normalize_command(struct XorrisO *xorriso, char *original_cmd,
|
|
int argno, char *cmd_data, int sizeof_cmd_data,
|
|
char **cmd, int flag)
|
|
{
|
|
int was_dashed= 0;
|
|
char *dash_pt;
|
|
|
|
if((int) strlen(original_cmd) >= sizeof_cmd_data) {
|
|
if(argno>=0)
|
|
sprintf(xorriso->info_text, "Oversized argument #%d (length %d)\n",
|
|
argno, (int) strlen(original_cmd));
|
|
else
|
|
sprintf(xorriso->info_text, "Oversized option (length %d)\n",
|
|
(int) strlen(original_cmd));
|
|
return(-1);
|
|
}
|
|
strcpy(cmd_data, original_cmd);
|
|
*cmd= cmd_data;
|
|
if(strcmp(*cmd, xorriso->list_delimiter)==0)
|
|
return(1);
|
|
while((*cmd)[0]=='-') {
|
|
if((*cmd)[1]==0)
|
|
break;
|
|
was_dashed++;
|
|
(*cmd)++;
|
|
}
|
|
for(dash_pt= *cmd; *dash_pt!=0; dash_pt++)
|
|
if(*dash_pt=='-')
|
|
*dash_pt= '_';
|
|
return(was_dashed);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= do not warn of unknown option
|
|
@return <=0 error,
|
|
1=count is valid, 2=dashed unknown, 3=undashed unknown
|
|
*/
|
|
int Xorriso_count_args(struct XorrisO *xorriso, int argc, char **argv,
|
|
int *count, int flag)
|
|
{
|
|
int ret, was_dashed= 0, i, cmd_data_size= 2 * SfileadrL;
|
|
char *cmd, *cmd_data= NULL;
|
|
static char arg0_commands[][40]= {
|
|
"ban_stdio_write","close_filter_list","commit",
|
|
"device_links","devices","end",
|
|
"for_backup", "help",
|
|
"list_arg_sorting","list_formats","list_speeds",
|
|
"no_rc","print_size","pvd_info","pwd","pwdi","pwdx",
|
|
"read_mkisofsrc","rollback","rollback_end",
|
|
"tell_media_space","toc","version",
|
|
""
|
|
};
|
|
static char arg1_commands[][40]= {
|
|
"abort_on","acl","add_plainly","application_id","application_use",
|
|
"auto_charset","abstract_file",
|
|
"backslash_codes","blank","biblio_file",
|
|
"calm_drive","cd","cdi","cdx","changes_pending","charset",
|
|
"close","close_damaged",
|
|
"commit_eject","compliance","copyright_file",
|
|
"dev","dialog","disk_dev_ino","disk_pattern","displacement",
|
|
"drive_access","dummy","dvd_obs","early_stdio_test","ecma119_map","eject",
|
|
"iso_nowtime","iso_rr_pattern","file_name_limit","follow","format","fs",
|
|
"gid","grow_blindly","hardlinks",
|
|
"hfsplus","history","indev","in_charset","joliet",
|
|
"list_delimiter","list_extras","list_profiles","local_charset",
|
|
"mark","md5","mount_opts","modesty_on_drive",
|
|
"not_leaf","not_list","not_mgt",
|
|
"options_from_file","osirrox","outdev","out_charset","overwrite",
|
|
"pacifier","padding","path_list","pathspecs","pkt_output",
|
|
"preparer_id","print","print_info","print_mark","prompt",
|
|
"prog","prog_help","publisher","quoted_not_list","quoted_path_list",
|
|
"read_fs","read_speed","reassure","report_about",
|
|
"report_el_torito","report_system_area","rockridge",
|
|
"rom_toc_scan","rr_reloc_dir","scsi_dev_family","scsi_log",
|
|
"session_log","sh_style_result","signal_handling","sleep",
|
|
"speed","split_size","status","status_history_max",
|
|
"stdio_sync","stream_recording","system_id","temp_mem_limit","toc_of",
|
|
"uid","unregister_filter","use_immed_bit","use_readline",
|
|
"volid","volset_id",
|
|
"write_type","xattr","zisofs",
|
|
""
|
|
};
|
|
static char arg2_commands[][40]= {
|
|
"assert_volid","boot_image","clone","compare","compare_r","drive_class",
|
|
"data_cache_size",
|
|
"errfile_log","error_behavior","extract","extract_single",
|
|
"jigdo","lns","lnsi","load","logfile",
|
|
"map","map_single","move","msg_op","page","return_with",
|
|
"scdbackup_tag","update","update_r","volume_date",
|
|
""
|
|
};
|
|
static char arg3_commands[][40]= {
|
|
"append_partition",
|
|
""
|
|
};
|
|
static char arg4_commands[][40]= {
|
|
"cut_out","extract_cut","mount","mount_cmd","named_pipe_loop",
|
|
"paste_in","session_string",
|
|
""
|
|
};
|
|
static char argn_commands[][40]= {
|
|
"add","alter_date","alter_date_r","as",
|
|
"check_md5","check_md5_r","check_media","check_media_defaults",
|
|
"chgrp","chgrpi","chgrp_r","chgrp_ri","chmod","chmodi",
|
|
"chmod_r","chmod_ri","chown","chowni","chown_r","chown_ri",
|
|
"compare_l","concat","cp_clone","cp_rax","cp_rx","cpr","cpri","cpax","cpx",
|
|
"du","dui","dus","dusi","dux","dusx","external_filter","extract_l",
|
|
"file_size_limit","find","findi","finds","findx",
|
|
"getfacl","getfacli","getfacl_r","getfacl_ri",
|
|
"getfattr","getfattri","getfattr_r","getfattr_ri","hide",
|
|
"launch_frontend","ls","lsi","lsl","lsli","lsd","lsdi","lsdl","lsdli",
|
|
"lsx","lslx","lsdx","lsdlx","map_l","mv","mvi","mkdir","mkdiri",
|
|
"not_paths","rm","rmi","rm_r","rm_ri","rmdir","rmdiri",
|
|
"update_l","update_li","update_lx","update_lxi",
|
|
"setfacl","setfacli","setfacl_list","setfacl_listi",
|
|
"setfacl_r","setfacl_ri","setfattr","setfattri",
|
|
"setfattr_list","setfattr_listi","setfattr_r","setfattr_ri",
|
|
"set_filter","set_filter_r","show_stream","show_stream_r",
|
|
""
|
|
};
|
|
|
|
Xorriso_alloc_meM(cmd_data, char, cmd_data_size);
|
|
|
|
*count= 0;
|
|
if(argc<=0)
|
|
{ret= -1; goto ex;}
|
|
ret= Xorriso_normalize_command(xorriso, argv[0], -1,
|
|
cmd_data, cmd_data_size, &cmd, 0);
|
|
if(ret<0)
|
|
goto ex;
|
|
was_dashed= (ret>0);
|
|
if(cmd[0]=='#' || cmd[0]==0 || strcmp(cmd, xorriso->list_delimiter) == 0) {
|
|
/* ignore: comment line , empty option , orphaned list delimiter */
|
|
{ret= 1; goto ex;}
|
|
}
|
|
for(i=0; arg0_commands[i][0]!=0; i++)
|
|
if(strcmp(arg0_commands[i], cmd)==0)
|
|
{ret= 1; goto ex;}
|
|
*count= 1;
|
|
for(i=0; arg1_commands[i][0]!=0; i++)
|
|
if(strcmp(arg1_commands[i], cmd)==0)
|
|
{ret= 1; goto ex;}
|
|
*count= 2;
|
|
for(i=0; arg2_commands[i][0]!=0; i++)
|
|
if(strcmp(arg2_commands[i], cmd)==0)
|
|
{ret= 1; goto ex;}
|
|
*count= 3;
|
|
for(i=0; arg3_commands[i][0]!=0; i++)
|
|
if(strcmp(arg3_commands[i], cmd)==0)
|
|
{ret= 1; goto ex;}
|
|
*count= 4;
|
|
for(i=0; arg4_commands[i][0]!=0; i++)
|
|
if(strcmp(arg4_commands[i], cmd)==0)
|
|
{ret= 1; goto ex;}
|
|
*count= 0;
|
|
for(i=0; argn_commands[i][0]!=0; i++)
|
|
if(strcmp(argn_commands[i], cmd)==0) {
|
|
ret= Xorriso_end_idx(xorriso, argc, argv, 1, 1);
|
|
if(ret<1)
|
|
goto ex;
|
|
*count= ret-1;
|
|
{ret= 1; goto ex;}
|
|
}
|
|
|
|
if(!(flag&1)) {
|
|
sprintf(xorriso->info_text, "Unknown option : '%s'", argv[0]);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING", 0);
|
|
}
|
|
|
|
ret= 2 + !was_dashed;
|
|
ex:
|
|
Xorriso_free_meM(cmd_data);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= list sorting order rather than looking for argv[idx]
|
|
*/
|
|
int Xorriso_cmd_sorting_rank(struct XorrisO *xorriso,
|
|
int argc, char **argv, int idx, int flag)
|
|
{
|
|
int ret, i, cmd_data_size= 2 * SfileadrL;
|
|
char *cmd, *cmd_data= NULL;
|
|
static char *commands[]= {
|
|
|
|
"* Execution order of program arguments with option -x:",
|
|
"x",
|
|
|
|
"* Support for frontend programs via stdin and stdout (1):",
|
|
"prog", "prog_help",
|
|
|
|
"* Exception processing:",
|
|
"abort_on", "return_with", "report_about", "signal_handling",
|
|
"error_behavior",
|
|
|
|
"* Scripting, dialog and program control features (1):",
|
|
"no_rc", "help", "version", "list_extras", "list_arg_sorting",
|
|
"temp_mem_limit", "backslash_codes",
|
|
"errfile_log", "session_log", "scsi_log",
|
|
"options_from_file", "list_delimiter",
|
|
"print", "print_info", "print_mark", "prompt", "sleep",
|
|
"sh_style_result",
|
|
|
|
"* Influencing opening of drives:",
|
|
"drive_access","drive_class","early_stdio_test",
|
|
|
|
"* Drive and media related inquiry actions (1):",
|
|
"devices", "device_links",
|
|
"mount_opts", "mount_cmd", "session_string",
|
|
|
|
"* Influencing the behavior of image loading:",
|
|
"read_speed", "load", "displacement", "read_fs",
|
|
"assert_volid", "in_charset",
|
|
"auto_charset", "hardlinks", "acl", "xattr", "md5", "for_backup",
|
|
"ecma119_map",
|
|
"disk_dev_ino", "rom_toc_scan", "calm_drive", "ban_stdio_write",
|
|
"data_cache_size",
|
|
"scsi_dev_family", "iso_nowtime",
|
|
|
|
"* Character sets:",
|
|
"charset", "local_charset",
|
|
|
|
"* Acquiring source and target drive:",
|
|
"dev", "indev", "outdev",
|
|
|
|
"* Drive and media related inquiry actions (2):",
|
|
"list_profiles", "list_formats", "list_speeds",
|
|
"toc", "toc_of", "pvd_info", "report_system_area", "report_el_torito",
|
|
|
|
"* Settings for file insertion:",
|
|
"file_name_limit", "file_size_limit",
|
|
"not_mgt", "not_paths", "not_leaf", "not_list",
|
|
"quoted_not_list", "follow", "pathspecs", "overwrite", "split_size",
|
|
|
|
"* Navigation in ISO image and disk filesystem (1):",
|
|
"cd", "cdx", "pwd", "pwdx",
|
|
|
|
"* Inserting files into ISO image:",
|
|
"disk_pattern", "add_plainly",
|
|
"mkdir", "lns", "add", "path_list", "quoted_path_list",
|
|
"map", "map_single", "map_l", "update", "update_r",
|
|
"update_l", "update_li", "update_lx", "update_lxi",
|
|
"cut_out", "cpr",
|
|
"clone", "cp_clone",
|
|
|
|
"* Navigation in ISO image and disk filesystem (2):",
|
|
"ls", "lsd", "lsl", "lsdl", "lsx", "lsdx", "lslx", "lsdlx",
|
|
"getfacl", "getfacl_r", "getfattr", "getfattr_r", "du", "dus",
|
|
"dux", "dusx", "findx",
|
|
"compare", "compare_r", "compare_l", "show_stream", "show_stream_r",
|
|
|
|
"* File manipulations:",
|
|
"iso_rr_pattern",
|
|
"rm", "rm_r", "rmdir", "move", "mv",
|
|
"chown", "chown_r", "chgrp", "chgrp_r", "chmod", "chmod_r", "setfacl",
|
|
"setfacl_r", "setfacl_list", "setfattr", "setfattr_r", "setfattr_list",
|
|
"alter_date", "alter_date_r", "hide",
|
|
|
|
"* Filters for data file content:",
|
|
"external_filter", "unregister_filter", "close_filter_list",
|
|
"set_filter", "set_filter_r",
|
|
|
|
"* Tree traversal command -find:",
|
|
"find",
|
|
|
|
"* osirrox ISO-to-disk restore options:",
|
|
"osirrox", "extract", "extract_single", "extract_l", "extract_cut",
|
|
"cpx", "cpax", "cp_rx", "cp_rax", "paste_in", "concat",
|
|
"mount",
|
|
|
|
"* Settings for result writing:",
|
|
"rockridge", "joliet", "hfsplus","compliance", "rr_reloc_dir",
|
|
"volid", "volset_id", "publisher",
|
|
"application_id", "system_id", "volume_date", "copyright_file",
|
|
"abstract_file", "biblio_file", "preparer_id", "application_use",
|
|
"out_charset", "read_mkisofsrc",
|
|
"uid", "gid", "zisofs", "speed", "stream_recording", "dvd_obs",
|
|
"modesty_on_drive", "use_immed_bit",
|
|
"stdio_sync", "dummy", "fs", "close", "padding", "write_type",
|
|
"grow_blindly", "pacifier", "scdbackup_tag",
|
|
|
|
"* Bootable ISO images:",
|
|
"boot_image", "append_partition",
|
|
|
|
"* Jigdo Template Extraction:",
|
|
"jigdo",
|
|
|
|
"* Command compatibility emulations:",
|
|
"as",
|
|
|
|
"* Scripting, dialog and program control features (2):",
|
|
"history", "status_history_max", "status",
|
|
|
|
"* Drive and media related inquiry actions (3):",
|
|
"print_size", "tell_media_space",
|
|
|
|
"* Writing the result, drive control:",
|
|
"format", "blank", "close_damaged",
|
|
"rollback", "changes_pending", "commit", "commit_eject",
|
|
"eject",
|
|
|
|
"* Evaluation of readability and recovery:",
|
|
"check_media_defaults", "check_media", "check_md5", "check_md5_r",
|
|
|
|
"* Support for frontend programs via stdin and stdout (2):",
|
|
"pkt_output", "logfile", "mark", "msg_op",
|
|
|
|
"* Dialog mode control:",
|
|
"dialog", "page", "use_readline", "reassure",
|
|
|
|
"* Support for frontend programs via stdin and stdout (3):",
|
|
"launch_frontend", "named_pipe_loop",
|
|
|
|
"* Scripting, dialog and program control features (3):",
|
|
"rollback_end", "end",
|
|
|
|
""
|
|
};
|
|
|
|
if(flag & 1) {
|
|
for(i= 0; commands[i][0] !=0; i++) {
|
|
if(commands[i][0] == '*')
|
|
sprintf(xorriso->result_line, "#%s\n", commands[i] + 1);
|
|
else
|
|
sprintf(xorriso->result_line, "-%s\n", commands[i]);
|
|
Xorriso_result(xorriso, 0);
|
|
}
|
|
ret= 1; goto ex;
|
|
}
|
|
if(argc <= 0)
|
|
{ret= -1; goto ex;}
|
|
|
|
Xorriso_alloc_meM(cmd_data, char, cmd_data_size);
|
|
ret= Xorriso_normalize_command(xorriso, argv[idx], -1,
|
|
cmd_data, cmd_data_size, &cmd, 0);
|
|
if(ret < 0)
|
|
goto ex;
|
|
|
|
if(cmd[0] == '#' || cmd[0] == 0 ||
|
|
strcmp(cmd, xorriso->list_delimiter) == 0) {
|
|
/* Move to end: comment line , empty option , orphaned list delimiter */
|
|
ret= 0x7fffffff; goto ex;
|
|
}
|
|
for(i= 0; commands[i][0] !=0; i++) {
|
|
if(commands[i][0] == '*') /* headline in command list */
|
|
continue;
|
|
if(strcmp(commands[i], cmd) != 0)
|
|
continue;
|
|
ret= i + 1; goto ex;
|
|
}
|
|
|
|
ret= 1;
|
|
ex:
|
|
Xorriso_free_meM(cmd_data);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso__cmp_cmd_rank(const void *a, const void *b)
|
|
{
|
|
int ra, rb;
|
|
|
|
ra= ((int *) a)[1];
|
|
rb= ((int *) b)[1];
|
|
if(ra < rb)
|
|
return(-1);
|
|
if(ra > rb)
|
|
return(1);
|
|
ra= ((int *) a)[2];
|
|
rb= ((int *) b)[2];
|
|
if(ra < rb)
|
|
return(-1);
|
|
if(ra > rb)
|
|
return(1);
|
|
return(0);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= print command sequence rather than executing it
|
|
bit1= these are command line arguments
|
|
(for xorriso->argument_emulation)
|
|
*/
|
|
int Xorriso_exec_args_sorted(struct XorrisO *xorriso,
|
|
int argc, char **argv, int *idx, int flag)
|
|
{
|
|
int cmd_count= 0, ret, i, arg_count, *idx_rank= NULL, cmd_idx;
|
|
|
|
/* Count commands and allocate index-rank array */
|
|
for(i= *idx; i < argc; i++) {
|
|
ret= Xorriso_count_args(xorriso, argc - i, argv + i, &arg_count, 1);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
if(ret != 1)
|
|
continue;
|
|
cmd_count++;
|
|
i+= arg_count;
|
|
}
|
|
if(cmd_count <= 0)
|
|
{ret= 1; goto ex;}
|
|
Xorriso_alloc_meM(idx_rank, int, 3 * cmd_count);
|
|
|
|
/* Fill index-rank array and sort */
|
|
cmd_count= 0;
|
|
for(i= *idx; i < argc; i++) {
|
|
ret= Xorriso_count_args(xorriso, argc - i, argv + i, &arg_count, 1);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
if(ret != 1)
|
|
continue;
|
|
idx_rank[3 * cmd_count]= i;
|
|
ret= Xorriso_cmd_sorting_rank(xorriso, argc, argv, i, 0);
|
|
if(ret < 0)
|
|
goto ex;
|
|
idx_rank[3 * cmd_count + 1]= ret;
|
|
idx_rank[3 * cmd_count + 2]= cmd_count;
|
|
cmd_count++;
|
|
i+= arg_count;
|
|
}
|
|
qsort(idx_rank, cmd_count, 3 * sizeof(int), Xorriso__cmp_cmd_rank);
|
|
|
|
/* Execute or print indice from index-rank array */
|
|
if(flag & 1) {
|
|
sprintf(xorriso->result_line,
|
|
"Automatically determined command sequence:\n");
|
|
Xorriso_result(xorriso, 0);
|
|
xorriso->result_line[0]= 0;
|
|
}
|
|
for(i= 0; i < cmd_count; i++) {
|
|
cmd_idx= idx_rank[3 * i];
|
|
if(flag & 1) {
|
|
if(strlen(xorriso->result_line) + 1 + strlen(argv[cmd_idx]) > 78) {
|
|
strcat(xorriso->result_line, "\n");
|
|
Xorriso_result(xorriso, 0);
|
|
xorriso->result_line[0]= 0;
|
|
}
|
|
sprintf(xorriso->result_line + strlen(xorriso->result_line),
|
|
" %s", argv[cmd_idx]);
|
|
} else {
|
|
ret= Xorriso_interpreter(xorriso, argc, argv, &cmd_idx, 4 | (flag & 2));
|
|
if(ret <= 0 || ret == 3)
|
|
goto ex;
|
|
}
|
|
}
|
|
if(flag & 1) {
|
|
if(strlen(xorriso->result_line) > 0) {
|
|
strcat(xorriso->result_line, "\n");
|
|
Xorriso_result(xorriso, 0);
|
|
}
|
|
} else
|
|
*idx= argc;
|
|
ret= 1;
|
|
ex:
|
|
Xorriso_free_meM(idx_rank);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= recursion
|
|
bit1= these are command line arguments
|
|
(for xorriso->argument_emulation)
|
|
bit2= Only execute the one command argv[*idx] and advance
|
|
*idx to the next command if successful. Then return.
|
|
*/
|
|
int Xorriso_interpreter(struct XorrisO *xorriso,
|
|
int argc, char **argv, int *idx, int flag)
|
|
/*
|
|
return:
|
|
<=0 error , 1 = success , 2 = problem event ignored , 3 = end program run
|
|
*/
|
|
{
|
|
int ret, was_dashed, end_ret, num1, num2, cmd_data_size= 2 * SfileadrL;
|
|
int mem_idx, arg_count, i;
|
|
char *cmd, *original_cmd, *cmd_data= NULL, *arg1, *arg2, *arg3, *arg4;
|
|
|
|
Xorriso_alloc_meM(cmd_data, char, cmd_data_size);
|
|
|
|
if(xorriso==NULL)
|
|
{ret= 0; goto ex;}
|
|
if(xorriso->is_dialog) {
|
|
xorriso->result_line_counter= xorriso->result_page_counter= 0;
|
|
if(xorriso->result_page_length<0)
|
|
xorriso->result_page_length= -xorriso->result_page_length;
|
|
}
|
|
|
|
next_command:;
|
|
if(flag&2) {
|
|
ret= 1;
|
|
if(xorriso->argument_emulation==1)
|
|
ret= Xorriso_as_genisofs(xorriso, argc, argv, idx, 0);
|
|
else if(xorriso->argument_emulation==2)
|
|
ret= Xorriso_as_cdrskin(xorriso, argc, argv, idx, 0);
|
|
if(xorriso->argument_emulation>0) {
|
|
xorriso->argument_emulation= 0;
|
|
if(ret<=0)
|
|
goto eval_any_problems;
|
|
if((*idx)>=argc)
|
|
{ret= 1; goto ex;}
|
|
}
|
|
if((xorriso->arrange_args || (flag & 8)) && !(flag & (4 | 16))) {
|
|
ret= Xorriso_exec_args_sorted(xorriso, argc, argv, idx, 0);
|
|
goto ex;
|
|
}
|
|
}
|
|
|
|
ret= Xorriso_count_args(xorriso, argc - *idx, argv + *idx, &arg_count, 1);
|
|
if((ret == 1 || ret == 2) &&
|
|
strcmp(argv[*idx], xorriso->list_delimiter) != 0) {
|
|
sprintf(xorriso->info_text, "Command: %s", argv[*idx]);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
|
|
for(i= 1; i <= arg_count && *idx + i < argc; i++) {
|
|
sprintf(xorriso->info_text, "Parameter: %s", argv[*idx + i]);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
|
|
}
|
|
if(*idx + arg_count >= argc) {
|
|
sprintf(xorriso->info_text, "Missing arguments: %d",
|
|
*idx + arg_count + 1 - argc);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
|
|
}
|
|
}
|
|
|
|
xorriso->prepended_wd= 0;
|
|
xorriso->request_to_abort= xorriso->request_not_to_ask= 0;
|
|
Xorriso_set_problem_status(xorriso, "", 0);
|
|
if((*idx)<argc)
|
|
original_cmd= cmd= argv[*idx];
|
|
else
|
|
original_cmd= cmd= "";
|
|
if(xorriso->add_plainly==3 && cmd[0] && !xorriso->is_dialog) {
|
|
(*idx)++;
|
|
goto add_plain_argument;
|
|
}
|
|
was_dashed= 0;
|
|
ret= Xorriso_normalize_command(xorriso, original_cmd, -1,
|
|
cmd_data, cmd_data_size, &cmd, 0);
|
|
if(ret<0)
|
|
goto eval_any_problems;
|
|
was_dashed= ret;
|
|
|
|
(*idx)++;
|
|
if((*idx)<argc)
|
|
arg1= argv[(*idx)];
|
|
else
|
|
arg1= "";
|
|
if((*idx)+1<argc)
|
|
arg2= argv[(*idx)+1];
|
|
else
|
|
arg2= "";
|
|
if((*idx) + 2 < argc)
|
|
arg3= argv[(*idx) + 2];
|
|
else
|
|
arg3= "";
|
|
|
|
ret= 1;
|
|
if(cmd[0]=='#' || cmd[0]==0) {
|
|
/* ignore comment line and empty option */;
|
|
|
|
} else if(strcmp(cmd,"abort_on")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_abort_on(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"abstract_file")==0) {
|
|
(*idx)++;
|
|
Xorriso_option_abstract_file(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"acl")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_acl(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"add")==0) {
|
|
ret= Xorriso_option_add(xorriso, argc, argv, idx, 0);
|
|
|
|
} else if(strcmp(cmd,"add_plainly")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_add_plainly(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"alter_date")==0 || strcmp(cmd,"alter_date_r")==0) {
|
|
(*idx)+= 2;
|
|
ret= Xorriso_option_alter_date(xorriso, arg1, arg2, argc, argv, idx,
|
|
strlen(cmd)>10);
|
|
|
|
} else if(strcmp(cmd,"append_partition")==0) {
|
|
(*idx)+= 3;
|
|
ret= Xorriso_option_append_partition(xorriso, arg1, arg2, arg3, 0);
|
|
|
|
} else if(strcmp(cmd,"application_id")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_application_id(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"application_use") == 0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_application_use(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"as")==0) {
|
|
ret= Xorriso_option_as(xorriso, argc, argv, idx, 0);
|
|
|
|
} else if(strcmp(cmd,"assert_volid")==0) {
|
|
(*idx)+= 2;
|
|
ret= Xorriso_option_assert_volid(xorriso, arg1, arg2, 0);
|
|
|
|
} else if(strcmp(cmd,"auto_charset")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_auto_charset(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"backslash_codes")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_backslash_codes(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"ban_stdio_write")==0) {
|
|
ret= Xorriso_option_ban_stdio_write(xorriso, 0);
|
|
|
|
} else if(strcmp(cmd,"biblio_file")==0) {
|
|
(*idx)++;
|
|
Xorriso_option_biblio_file(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"blank")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_blank(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"boot_image")==0) {
|
|
(*idx)+= 2;
|
|
ret= Xorriso_option_boot_image(xorriso, arg1, arg2, 0);
|
|
|
|
} else if(strcmp(cmd,"calm_drive")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_calm_drive(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"cd")==0 || strcmp(cmd,"cdi")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_cdi(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"cdx")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_cdx(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd, "changes_pending")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_changes_pending(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"charset")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_charset(xorriso, arg1, 3);
|
|
|
|
} else if(strcmp(cmd,"check_md5")==0) {
|
|
ret= Xorriso_option_check_md5(xorriso, argc, argv, idx, 0);
|
|
|
|
} else if(strcmp(cmd,"check_md5_r")==0) {
|
|
ret= Xorriso_option_check_md5(xorriso, argc, argv, idx, 8);
|
|
|
|
} else if(strcmp(cmd,"check_media")==0) {
|
|
ret= Xorriso_option_check_media(xorriso, argc, argv, idx, 0);
|
|
|
|
} else if(strcmp(cmd,"check_media_defaults")==0) {
|
|
ret= Xorriso_option_check_media_defaults(xorriso, argc, argv, idx, 0);
|
|
|
|
} else if(strcmp(cmd,"chgrp")==0 || strcmp(cmd,"chgrpi")==0) {
|
|
(*idx)+= 1;
|
|
ret= Xorriso_option_chgrpi(xorriso, arg1, argc, argv, idx, 0);
|
|
|
|
} else if(strcmp(cmd,"chgrp_r")==0 || strcmp(cmd,"chgrp_ri")==0) {
|
|
(*idx)+= 1;
|
|
ret= Xorriso_option_chgrpi(xorriso, arg1, argc, argv, idx, 1);
|
|
|
|
} else if(strcmp(cmd,"chmod")==0 || strcmp(cmd,"chmodi")==0) {
|
|
(*idx)+= 1;
|
|
ret= Xorriso_option_chmodi(xorriso, arg1, argc, argv, idx, 0);
|
|
|
|
} else if(strcmp(cmd,"chmod_r")==0 || strcmp(cmd,"chmod_ri")==0) {
|
|
(*idx)+= 1;
|
|
ret= Xorriso_option_chmodi(xorriso, arg1, argc, argv, idx, 1);
|
|
|
|
} else if(strcmp(cmd,"chown_r")==0 || strcmp(cmd,"chown_ri")==0) {
|
|
(*idx)+= 1;
|
|
ret= Xorriso_option_chowni(xorriso, arg1, argc, argv, idx, 1);
|
|
|
|
} else if(strcmp(cmd,"chown")==0 || strcmp(cmd,"chowni")==0) {
|
|
(*idx)+= 1;
|
|
ret= Xorriso_option_chowni(xorriso, arg1, argc, argv, idx, 0);
|
|
|
|
} else if(strcmp(cmd,"clone")==0) {
|
|
(*idx)+= 2;
|
|
ret= Xorriso_option_clone(xorriso, arg1, arg2, 1);
|
|
|
|
} else if(strcmp(cmd,"close")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_close(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"close_damaged")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_close_damaged(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"close_filter_list")==0) {
|
|
ret= Xorriso_option_close_filter_list(xorriso, 0);
|
|
|
|
} else if(strcmp(cmd,"commit")==0) {
|
|
ret= Xorriso_option_commit(xorriso, 0);
|
|
|
|
} else if(strcmp(cmd,"commit_eject")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_commit_eject(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"compare")==0) {
|
|
(*idx)+= 2;
|
|
ret= Xorriso_option_compare(xorriso, arg1, arg2, 1);
|
|
|
|
} else if(strcmp(cmd,"compare_l")==0) {
|
|
ret= Xorriso_option_map_l(xorriso, argc, argv, idx, 1<<8);
|
|
|
|
} else if(strcmp(cmd,"compare_r")==0) {
|
|
(*idx)+= 2;
|
|
ret= Xorriso_option_compare(xorriso, arg1, arg2, 1|8);
|
|
|
|
} else if(strcmp(cmd,"compliance")==0) {
|
|
(*idx)++;
|
|
Xorriso_option_compliance(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"concat") == 0) {
|
|
ret= Xorriso_option_concat(xorriso, argc, argv, idx, 0);
|
|
|
|
} else if(strcmp(cmd,"copyright_file")==0) {
|
|
(*idx)++;
|
|
Xorriso_option_copyright_file(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"cp_clone") == 0) {
|
|
ret= Xorriso_option_cp_clone(xorriso, argc, argv, idx, 0);
|
|
|
|
} else if(strcmp(cmd,"cp_rx")==0 || strcmp(cmd,"cp_rax")==0) {
|
|
ret= Xorriso_option_cpx(xorriso, argc, argv, idx,
|
|
1|((strcmp(cmd,"cp_rax")==0)<<1));
|
|
|
|
} else if(strcmp(cmd,"cpr")==0 || strcmp(cmd,"cpri")==0) {
|
|
ret= Xorriso_option_cpri(xorriso, argc, argv, idx, 0);
|
|
|
|
} else if(strcmp(cmd,"cpx")==0 || strcmp(cmd,"cpax")==0) {
|
|
ret= Xorriso_option_cpx(xorriso, argc, argv, idx,
|
|
(strcmp(cmd,"cpax")==0)<<1);
|
|
|
|
} else if(strcmp(cmd,"cut_out")==0) {
|
|
(*idx)+= 4;
|
|
if((*idx)>argc) {
|
|
sprintf(xorriso->info_text,
|
|
"-cut_out: Not enough arguments. Needed are: disk_path start count so_rr_path");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0;
|
|
} else
|
|
ret= Xorriso_option_cut_out(xorriso, arg1, arg2,
|
|
argv[(*idx)-2], argv[(*idx)-1], 0);
|
|
|
|
} else if(strcmp(cmd,"data_cache_size")==0) {
|
|
(*idx)+= 2;
|
|
ret= Xorriso_option_data_cache_size(xorriso, arg1, arg2, 0);
|
|
|
|
} else if(strcmp(cmd,"dev")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_dev(xorriso, arg1, 3);
|
|
|
|
} else if(strcmp(cmd,"device_links")==0) {
|
|
ret= Xorriso_option_devices(xorriso, 1);
|
|
|
|
} else if(strcmp(cmd,"devices")==0) {
|
|
ret= Xorriso_option_devices(xorriso, 0);
|
|
|
|
} else if(strcmp(cmd,"dialog")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_dialog(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"disk_dev_ino")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_disk_dev_ino(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"displacement")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_displacement(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"disk_pattern")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_disk_pattern(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"drive_access")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_drive_access(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"drive_class")==0) {
|
|
(*idx)+= 2;
|
|
ret= Xorriso_option_drive_class(xorriso, arg1, arg2, 0);
|
|
|
|
} else if(strcmp(cmd,"du")==0 || strcmp(cmd,"dui")==0 ||
|
|
strcmp(cmd,"dus")==0 || strcmp(cmd,"dusi")==0) {
|
|
ret= Xorriso_option_lsi(xorriso, argc, argv, idx, (cmd[2]!='s')|4);
|
|
|
|
} else if(strcmp(cmd,"dummy")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_dummy(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"dvd_obs")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_dvd_obs(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"dux")==0 || strcmp(cmd,"dusx")==0) {
|
|
ret= Xorriso_option_lsx(xorriso, argc, argv, idx, (cmd[2]!='s')|4);
|
|
|
|
} else if(strcmp(cmd,"early_stdio_test")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_early_stdio_test(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"ecma119_map")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_ecma119_map(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"eject")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_eject(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"end")==0) {
|
|
end_ret= Xorriso_option_end(xorriso, 0);
|
|
ret= Xorriso_eval_problem_status(xorriso, ret, 0);
|
|
if(ret<0)
|
|
goto ex;
|
|
if(end_ret!=2)
|
|
{ret= 3; goto ex;}
|
|
|
|
} else if(strcmp(cmd,"errfile_log")==0) {
|
|
(*idx)+= 2;
|
|
ret= Xorriso_option_errfile_log(xorriso, arg1, arg2, 0);
|
|
|
|
} else if(strcmp(cmd,"error_behavior")==0) {
|
|
(*idx)+= 2;
|
|
ret= Xorriso_option_error_behavior(xorriso, arg1, arg2, 0);
|
|
|
|
} else if(strcmp(cmd,"external_filter")==0) {
|
|
ret= Xorriso_option_external_filter(xorriso, argc, argv, idx, 0);
|
|
|
|
} else if(strcmp(cmd,"extract")==0) {
|
|
(*idx)+= 2;
|
|
ret= Xorriso_option_extract(xorriso, arg1, arg2, 0);
|
|
|
|
} else if(strcmp(cmd,"extract_cut")==0) {
|
|
(*idx)+= 4;
|
|
if((*idx)>argc) {
|
|
sprintf(xorriso->info_text,
|
|
"-extract_cut: Not enough arguments. Needed are: disk_path start count so_rr_path");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0;
|
|
} else
|
|
ret= Xorriso_option_extract_cut(xorriso, arg1, arg2,
|
|
argv[(*idx)-2], argv[(*idx)-1], 0);
|
|
|
|
} else if(strcmp(cmd,"extract_l")==0) {
|
|
ret= Xorriso_option_map_l(xorriso, argc, argv, idx, 3<<8);
|
|
|
|
} else if(strcmp(cmd,"extract_single")==0) {
|
|
(*idx)+= 2;
|
|
ret= Xorriso_option_extract(xorriso, arg1, arg2, 32);
|
|
|
|
} else if(strcmp(cmd,"file_name_limit")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_file_name_limit(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"file_size_limit")==0) {
|
|
ret= Xorriso_option_file_size_limit(xorriso, argc, argv, idx, 0);
|
|
|
|
} else if(strcmp(cmd,"find")==0 || strcmp(cmd,"findi")==0) {
|
|
ret= Xorriso_option_find(xorriso, argc, argv, idx, 0);
|
|
|
|
} else if(strcmp(cmd,"findx")==0) {
|
|
ret= Xorriso_option_find(xorriso, argc, argv, idx, 1);
|
|
|
|
} else if(strcmp(cmd,"follow")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_follow(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"for_backup")==0) {
|
|
Xorriso_option_hardlinks(xorriso, "on", 0);
|
|
Xorriso_option_acl(xorriso, "on", 0);
|
|
Xorriso_option_xattr(xorriso, "any", 0);
|
|
Xorriso_option_md5(xorriso, "on", 0);
|
|
ret= 1;
|
|
|
|
} else if(strcmp(cmd,"format")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_blank(xorriso, arg1, 1);
|
|
|
|
} else if(strcmp(cmd,"fs")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_fs(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"getfacl")==0 || strcmp(cmd,"getfacli")==0) {
|
|
ret= Xorriso_option_getfacli(xorriso, argc, argv, idx, 0);
|
|
|
|
} else if(strcmp(cmd,"getfacl_r")==0 || strcmp(cmd,"getfacl_ri")==0) {
|
|
ret= Xorriso_option_getfacli(xorriso, argc, argv, idx, 1);
|
|
|
|
} else if(strcmp(cmd,"getfattr")==0 || strcmp(cmd,"getfattri")==0) {
|
|
ret= Xorriso_option_getfacli(xorriso, argc, argv, idx, 2);
|
|
|
|
} else if(strcmp(cmd,"getfattr_r")==0 || strcmp(cmd,"getfattr_ri")==0) {
|
|
ret= Xorriso_option_getfacli(xorriso, argc, argv, idx, 1 | 2);
|
|
|
|
} else if(strcmp(cmd,"gid")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_gid(xorriso,arg1,0);
|
|
|
|
} else if(strcmp(cmd,"grow_blindly")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_grow_blindly(xorriso,arg1,0);
|
|
|
|
} else if(strcmp(cmd,"hardlinks")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_hardlinks(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"hfsplus")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_hfsplus(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"help")==0) {
|
|
Xorriso_option_help(xorriso,0);
|
|
|
|
} else if(strcmp(cmd,"hide")==0) {
|
|
(*idx)+= 1;
|
|
ret= Xorriso_option_hide(xorriso, arg1, argc, argv, idx, 1);
|
|
|
|
} else if(strcmp(cmd,"history")==0) {
|
|
/* add to readline history */
|
|
(*idx)++;
|
|
ret= Xorriso_option_history(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"indev")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_dev(xorriso, arg1, 1);
|
|
|
|
} else if(strcmp(cmd,"in_charset")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_charset(xorriso, arg1, 1);
|
|
|
|
} else if(strcmp(cmd,"iso_nowtime")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_iso_nowtime(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"iso_rr_pattern")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_iso_rr_pattern(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"jigdo")==0) {
|
|
(*idx)+= 2;
|
|
ret= Xorriso_option_jigdo(xorriso, arg1, arg2, 0);
|
|
|
|
} else if(strcmp(cmd,"joliet")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_joliet(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd, "launch_frontend") == 0) {
|
|
ret= Xorriso_option_launch_frontend(xorriso, argc, argv, idx, 0);
|
|
|
|
} else if(strcmp(cmd, "list_arg_sorting") == 0) {
|
|
ret= Xorriso_option_list_arg_sorting(xorriso, 0);
|
|
|
|
} else if(strcmp(cmd, "list_delimiter") == 0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_list_delimiter(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd, "list_extras") == 0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_list_extras(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"list_formats")==0) {
|
|
ret= Xorriso_option_list_formats(xorriso, 0);
|
|
|
|
} else if(strcmp(cmd,"list_profiles")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_list_profiles(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"list_speeds")==0) {
|
|
ret= Xorriso_option_list_speeds(xorriso, 0);
|
|
|
|
} else if(strcmp(cmd, "lns") == 0 || strcmp(cmd, "lnsi") == 0) {
|
|
(*idx)+= 2;
|
|
ret= Xorriso_option_lnsi(xorriso, arg1, arg2, 0);
|
|
|
|
} else if(strcmp(cmd,"load")==0) {
|
|
(*idx)+= 2;
|
|
ret= Xorriso_option_load(xorriso, arg1, arg2, 0);
|
|
|
|
} else if(strcmp(cmd,"local_charset")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_charset(xorriso, arg1, 4);
|
|
|
|
} else if(strcmp(cmd,"logfile")==0) {
|
|
(*idx)+= 2;
|
|
ret= Xorriso_option_logfile(xorriso, arg1, arg2, 0);
|
|
|
|
} else if(strcmp(cmd,"ls")==0 || strcmp(cmd,"lsi")==0 ||
|
|
strcmp(cmd,"lsl")==0 || strcmp(cmd,"lsli")==0) {
|
|
ret= Xorriso_option_lsi(xorriso, argc, argv, idx, (cmd[2]=='l'));
|
|
|
|
} else if(strcmp(cmd,"lsd")==0 || strcmp(cmd,"lsdi")==0 ||
|
|
strcmp(cmd,"lsdl")==0 || strcmp(cmd,"lsdli")==0) {
|
|
ret= Xorriso_option_lsi(xorriso, argc, argv, idx, (cmd[3]=='l')|8);
|
|
|
|
} else if(strcmp(cmd,"lsdx")==0 || strcmp(cmd,"lsdlx")==0) {
|
|
ret= Xorriso_option_lsx(xorriso, argc, argv, idx, (cmd[3]=='l')|8);
|
|
|
|
} else if(strcmp(cmd,"lsx")==0 || strcmp(cmd,"lslx")==0) {
|
|
ret= Xorriso_option_lsx(xorriso, argc, argv, idx, (cmd[2]=='l'));
|
|
|
|
} else if(strcmp(cmd,"map")==0) {
|
|
(*idx)+= 2;
|
|
ret= Xorriso_option_map(xorriso, arg1, arg2, 0);
|
|
|
|
} else if(strcmp(cmd,"map_l")==0) {
|
|
ret= Xorriso_option_map_l(xorriso, argc, argv, idx, 0);
|
|
|
|
} else if(strcmp(cmd,"map_single")==0) {
|
|
(*idx)+= 2;
|
|
ret= Xorriso_option_map(xorriso, arg1, arg2, 32);
|
|
|
|
} else if(strcmp(cmd,"mark")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_mark(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd, "md5")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_md5(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"mkdir")==0 || strcmp(cmd,"mkdiri")==0) {
|
|
ret= Xorriso_option_mkdiri(xorriso, argc, argv, idx, 0);
|
|
|
|
} else if(strcmp(cmd, "modesty_on_drive")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_modesty_on_drive(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd, "mount") == 0 || strcmp(cmd, "mount_cmd") == 0) {
|
|
(*idx)+= 4;
|
|
if((*idx)>argc) {
|
|
sprintf(xorriso->info_text,
|
|
"-%s: Not enough arguments. Needed are: device entity id command",
|
|
cmd);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0;
|
|
} else
|
|
ret= Xorriso_option_mount(xorriso, arg1, arg2,
|
|
argv[(*idx)-2], argv[(*idx)-1],
|
|
(strcmp(cmd, "mount_cmd") == 0));
|
|
|
|
} else if(strcmp(cmd, "mount_opts")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_mount_opts(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd, "move")==0) {
|
|
(*idx)+= 2;
|
|
ret= Xorriso_option_move(xorriso, arg1, arg2, 0);
|
|
|
|
} else if(strcmp(cmd,"msg_op") == 0) {
|
|
(*idx)+= 2;
|
|
ret= Xorriso_option_msg_op(xorriso, arg1, arg2, 0);
|
|
|
|
} else if(strcmp(cmd,"mv")==0 || strcmp(cmd,"mvi")==0) {
|
|
ret= Xorriso_option_mvi(xorriso, argc, argv, idx, 0);
|
|
|
|
} else if(strcmp(cmd,"named_pipe_loop")==0) {
|
|
if((*idx) + 3 < argc)
|
|
arg4= argv[(*idx) + 3];
|
|
else
|
|
arg4= "";
|
|
(*idx)+= 4;
|
|
ret= Xorriso_option_named_pipe_loop(xorriso, arg1, arg2, arg3, arg4, 0);
|
|
if(ret == 3)
|
|
goto ex;
|
|
|
|
} else if(strcmp(cmd,"no_rc")==0) {
|
|
ret= Xorriso_option_no_rc(xorriso, 0);
|
|
|
|
} else if(strcmp(cmd,"not_leaf")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_not_leaf(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"not_list")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_not_list(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"not_mgt")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_not_mgt(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"not_paths")==0) {
|
|
ret= Xorriso_option_not_paths(xorriso, argc, argv, idx, 0);
|
|
|
|
} else if(strcmp(cmd,"options_from_file")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_options_from_file(xorriso,arg1,0);
|
|
if(ret==3)
|
|
goto ex;
|
|
|
|
} else if(strcmp(cmd,"osirrox")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_osirrox(xorriso,arg1,0);
|
|
|
|
} else if(strcmp(cmd,"outdev")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_dev(xorriso, arg1, 2);
|
|
|
|
} else if(strcmp(cmd,"out_charset")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_charset(xorriso, arg1, 2);
|
|
|
|
} else if(strcmp(cmd,"overwrite")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_overwrite(xorriso,arg1,0);
|
|
|
|
} else if(strcmp(cmd,"pacifier")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_pacifier(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"padding")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_padding(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"page")==0) {
|
|
(*idx)+= 2;
|
|
num1= num2= 0;
|
|
sscanf(arg1,"%d",&num1);
|
|
sscanf(arg2,"%d",&num2);
|
|
if(num1<0)
|
|
num1= 0;
|
|
if(arg1[0]==0)
|
|
num1= 16;
|
|
if(num2<=0)
|
|
num2= 80;
|
|
ret= Xorriso_option_page(xorriso, num1, num2, 0);
|
|
|
|
} else if(strcmp(cmd,"paste_in")==0) {
|
|
(*idx)+= 4;
|
|
if((*idx)>argc) {
|
|
sprintf(xorriso->info_text,
|
|
"-paste_in: Not enough arguments. Needed are: disk_path start count so_rr_path");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0;
|
|
} else
|
|
ret= Xorriso_option_paste_in(xorriso, arg1, arg2,
|
|
argv[(*idx)-2], argv[(*idx)-1], 0);
|
|
|
|
} else if(strcmp(cmd,"path-list")==0 || strcmp(cmd,"path_list")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_path_list(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"pathspecs")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_pathspecs(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"pkt_output")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_pkt_output(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"preparer_id")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_preparer_id(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"print")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_print(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"print_info")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_print(xorriso, arg1, 1);
|
|
|
|
} else if(strcmp(cmd,"print_mark")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_print(xorriso, arg1, 2);
|
|
|
|
} else if(strcmp(cmd,"print_size")==0) {
|
|
Xorriso_option_print_size(xorriso, 0);
|
|
|
|
} else if(strcmp(cmd,"prompt")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_prompt(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"prog")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_prog(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"publisher")==0) {
|
|
(*idx)++;
|
|
Xorriso_option_publisher(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"pvd_info")==0) {
|
|
Xorriso_option_pvd_info(xorriso, 0);
|
|
|
|
} else if(strcmp(cmd,"pwd")==0 || strcmp(cmd,"pwdi")==0) {
|
|
Xorriso_option_pwdi(xorriso, 0);
|
|
|
|
} else if(strcmp(cmd,"pwdx")==0) {
|
|
Xorriso_option_pwdx(xorriso, 0);
|
|
|
|
} else if(strcmp(cmd,"quoted_not_list")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_not_list(xorriso, arg1, 1);
|
|
|
|
} else if(strcmp(cmd,"quoted_path_list")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_path_list(xorriso, arg1, 1);
|
|
|
|
} else if(strcmp(cmd,"read_fs")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_read_fs(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"read_mkisofsrc")==0) {
|
|
ret= Xorriso_option_read_mkisofsrc(xorriso, 0);
|
|
|
|
} else if(strcmp(cmd,"read_speed")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_speed(xorriso, arg1, 1);
|
|
|
|
} else if(strcmp(cmd,"reassure")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_reassure(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"report_about")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_report_about(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"report_el_torito")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_report_el_torito(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"report_system_area")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_report_system_area(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"return_with")==0) {
|
|
(*idx)+= 2;
|
|
num2= 0;
|
|
sscanf(arg2,"%d",&num2);
|
|
ret= Xorriso_option_return_with(xorriso, arg1, num2, 0);
|
|
|
|
} else if(strcmp(cmd,"rm")==0 || strcmp(cmd,"rmi")==0) {
|
|
ret= Xorriso_option_rmi(xorriso, argc, argv, idx, 0);
|
|
|
|
} else if(strcmp(cmd,"rm_r")==0 || strcmp(cmd,"rm_ri")==0) {
|
|
ret= Xorriso_option_rmi(xorriso, argc, argv, idx, 1);
|
|
|
|
} else if(strcmp(cmd,"rmdir")==0 || strcmp(cmd,"rmdiri")==0) {
|
|
ret= Xorriso_option_rmi(xorriso, argc, argv, idx, 2);
|
|
|
|
} else if(strcmp(cmd, "rockridge") == 0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_rockridge(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"rollback")==0) {
|
|
ret= Xorriso_option_rollback(xorriso, 0);
|
|
|
|
} else if(strcmp(cmd,"rollback_end")==0) {
|
|
end_ret= Xorriso_option_end(xorriso, 1);
|
|
ret= Xorriso_eval_problem_status(xorriso, ret, 0);
|
|
if(ret<0)
|
|
goto ex;
|
|
if(end_ret!=2)
|
|
{ret= 3; goto ex;}
|
|
|
|
} else if(strcmp(cmd,"rom_toc_scan")==0) {
|
|
(*idx)++;
|
|
Xorriso_option_rom_toc_scan(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"rr_reloc_dir")==0) {
|
|
(*idx)++;
|
|
Xorriso_option_rr_reloc_dir(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"scdbackup_tag")==0) {
|
|
(*idx)+= 2;
|
|
ret= Xorriso_option_scdbackup_tag(xorriso, arg1, arg2, 0);
|
|
|
|
} else if(strcmp(cmd, "scsi_dev_family") == 0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_scsi_dev_family(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd, "scsi_log") == 0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_scsi_log(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"session_log")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_session_log(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd, "session_string") == 0) {
|
|
(*idx)+= 4;
|
|
if((*idx)>argc) {
|
|
sprintf(xorriso->info_text,
|
|
"-%s: Not enough arguments. Needed are: device entity id command",
|
|
cmd);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0;
|
|
} else
|
|
ret= Xorriso_option_mount(xorriso, arg1, arg2,
|
|
argv[(*idx)-2], argv[(*idx)-1], 2);
|
|
|
|
} else if(strcmp(cmd,"setfacl")==0 || strcmp(cmd,"setfacli")==0) {
|
|
(*idx)+= 1;
|
|
ret= Xorriso_option_setfacli(xorriso, arg1, argc, argv, idx, 0);
|
|
|
|
} else if(strcmp(cmd,"setfacl_list")==0 || strcmp(cmd,"setfacl_listi")==0) {
|
|
(*idx)+= 1;
|
|
ret= Xorriso_option_setfacl_listi(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"setfacl_r")==0 || strcmp(cmd,"setfacl_ri")==0) {
|
|
(*idx)+= 1;
|
|
ret= Xorriso_option_setfacli(xorriso, arg1, argc, argv, idx, 1);
|
|
|
|
} else if(strcmp(cmd,"setfattr")==0 || strcmp(cmd,"setfattri")==0) {
|
|
(*idx)+= 2;
|
|
ret= Xorriso_option_setfattri(xorriso, arg1, arg2, argc, argv, idx, 0);
|
|
|
|
} else if(strcmp(cmd,"setfattr_list")==0 || strcmp(cmd,"setfattr_listi")==0) {
|
|
(*idx)+= 1;
|
|
ret= Xorriso_option_setfattr_listi(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"setfattr_r")==0 || strcmp(cmd,"setfattr_ri")==0) {
|
|
(*idx)+= 2;
|
|
ret= Xorriso_option_setfattri(xorriso, arg1, arg2, argc, argv, idx, 1);
|
|
|
|
} else if(strcmp(cmd,"set_filter")==0 || strcmp(cmd,"set_filter_r")==0) {
|
|
(*idx)+= 1;
|
|
ret= Xorriso_option_set_filter(xorriso, arg1, argc, argv, idx,
|
|
strcmp(cmd,"set_filter_r")==0);
|
|
|
|
} else if(strcmp(cmd,"show_stream")==0 || strcmp(cmd,"show_stream_r")==0) {
|
|
ret= Xorriso_option_set_filter(xorriso, "", argc, argv, idx,
|
|
(strcmp(cmd,"show_stream_r")==0) | 2 | 4);
|
|
|
|
} else if(strcmp(cmd,"sh_style_result")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_sh_style_result(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"signal_handling")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_signal_handling(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"sleep")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_sleep(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"speed")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_speed(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"split_size")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_split_size(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"status")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_status(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"status_history_max")==0) {
|
|
(*idx)++;
|
|
sscanf(arg1,"%d",&num1);
|
|
ret= Xorriso_option_status_history_max(xorriso, num1, 0);
|
|
|
|
} else if(strcmp(cmd,"stdio_sync")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_stdio_sync(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"stream_recording")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_stream_recording(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"system_id")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_system_id(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"tell_media_space")==0) {
|
|
Xorriso_option_tell_media_space(xorriso, 0);
|
|
|
|
} else if(strcmp(cmd,"temp_mem_limit")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_temp_mem_limit(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"test")==0) { /* This option does not exist. */
|
|
/* install temporary test code here */;
|
|
|
|
if (0) {
|
|
/* Test setup for for Xorriso_push_outlists() et.al. */
|
|
/* Test setup for Xorriso_parse_line */
|
|
int stack_handle = -1, line_count= 0;
|
|
struct Xorriso_lsT *result_list, *info_list;
|
|
int Xorriso_process_msg_lists(struct XorrisO *xorriso,
|
|
struct Xorriso_lsT *result_list,
|
|
struct Xorriso_lsT *info_list,
|
|
int *line_count, int flag);
|
|
|
|
(*idx)++;
|
|
if(strcmp(arg1, "push") == 0) {
|
|
ret= Xorriso_push_outlists(xorriso, &stack_handle, 3);
|
|
fprintf(stderr, "xorriso -test: push = %d, handle = %d\n",
|
|
ret, stack_handle);
|
|
} else if(strcmp(arg1, "pull") == 0) {
|
|
ret= Xorriso_pull_outlists(xorriso, -1, &result_list, &info_list, 0);
|
|
fprintf(stderr, "xorriso -test: pull = %d\n", ret);
|
|
if(ret > 0) {
|
|
ret= Xorriso_process_msg_lists(xorriso, result_list, info_list,
|
|
&line_count, 0);
|
|
fprintf(stderr,
|
|
"xorriso -test: Xorriso_process_msg_lists() = %d, line_count = %d\n",
|
|
ret, line_count);
|
|
}
|
|
} else if(strcmp(arg1, "fetch") == 0) {
|
|
ret= Xorriso_fetch_outlists(xorriso, -1, &result_list, &info_list, 0);
|
|
fprintf(stderr, "xorriso -test: fetch = %d\n", ret);
|
|
if(ret > 0) {
|
|
ret= Xorriso_process_msg_lists(xorriso, result_list, info_list,
|
|
&line_count, 0);
|
|
fprintf(stderr,
|
|
"xorriso -test: Xorriso_process_msg_lists() = %d, line_count = %d\n",
|
|
ret, line_count);
|
|
}
|
|
} else if(strcmp(arg1, "peek") == 0) {
|
|
ret= Xorriso_peek_outlists(xorriso, -1, 0, 0);
|
|
fprintf(stderr, "xorriso -test: peek = %d\n", ret);
|
|
} else if(strcmp(arg1, "sleep_peek") == 0) {
|
|
usleep(1000000);
|
|
ret= Xorriso_peek_outlists(xorriso, -1, 0, 0);
|
|
fprintf(stderr, "xorriso -test: sleep_peek = %d\n", ret);
|
|
} else if(strcmp(arg1, "peek_loop") == 0) {
|
|
ret= Xorriso_peek_outlists(xorriso, -1, 3, 4);
|
|
fprintf(stderr, "xorriso -test: peek_loop = %d\n", ret);
|
|
} else if(strcmp(arg1, "start") == 0) {
|
|
ret= Xorriso_start_msg_watcher(xorriso, NULL, NULL, NULL, NULL, 0);
|
|
fprintf(stderr, "xorriso -test: Xorriso_start_msg_watcher() = %d\n", ret);
|
|
} else if(strcmp(arg1, "stop") == 0) {
|
|
ret= Xorriso_stop_msg_watcher(xorriso, 0);
|
|
fprintf(stderr, "xorriso -test: Xorriso_stop_msg_watcher() = %d\n", ret);
|
|
|
|
} else if(strcmp(arg1, "help") == 0) {
|
|
fprintf(stderr, "-test [mode] [arguments]\n");
|
|
fprintf(stderr, " push\n");
|
|
fprintf(stderr, " perform Xorriso_push_outlists()\n");
|
|
fprintf(stderr, " pull\n");
|
|
fprintf(stderr, " perform Xorriso_pull_outlists() and show messages\n");
|
|
fprintf(stderr, " fetch\n");
|
|
fprintf(stderr, " perform Xorriso_fetch_outlists() and show\n");
|
|
fprintf(stderr, " peek\n");
|
|
fprintf(stderr, " perform Xorriso_peek_outlists()\n");
|
|
fprintf(stderr, " sleep_peek\n");
|
|
fprintf(stderr, " sleep 1 s and perform Xorriso_peek_outlists()\n");
|
|
fprintf(stderr, " peek_loop\n");
|
|
fprintf(stderr, " wait for up to 3s in Xorriso_peek_outlists()\n");
|
|
fprintf(stderr, " for return value 0 or -1\n");
|
|
fprintf(stderr, " start\n");
|
|
fprintf(stderr, " perform Xorriso_start_msg_watcher()\n");
|
|
fprintf(stderr, " stop\n");
|
|
fprintf(stderr, " perform Xorriso_stop_msg_watcher()\n");
|
|
} else {
|
|
fprintf(stderr, "xorriso -test: unknown mode: %s\n", arg1);
|
|
}
|
|
ret= 0;
|
|
}
|
|
|
|
} else if(strcmp(cmd,"toc")==0) {
|
|
Xorriso_option_toc(xorriso, 0);
|
|
|
|
} else if(strcmp(cmd,"toc_of")==0) {
|
|
(*idx)++;
|
|
Xorriso_option_toc_of(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"uid")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_uid(xorriso,arg1,0);
|
|
|
|
} else if(strcmp(cmd,"unregister_filter")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_unregister_filter(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"update")==0) {
|
|
(*idx)+= 2;
|
|
ret= Xorriso_option_update(xorriso, arg1, arg2, 1);
|
|
|
|
} else if(strcmp(cmd,"update_l") == 0 || strcmp(cmd,"update_lx") == 0) {
|
|
ret= Xorriso_option_map_l(xorriso, argc, argv, idx, 2<<8);
|
|
|
|
} else if(strcmp(cmd,"update_li") == 0) {
|
|
ret= Xorriso_option_map_l(xorriso, argc, argv, idx, 5 << 8);
|
|
|
|
} else if(strcmp(cmd,"update_lxi") == 0) {
|
|
ret= Xorriso_option_map_l(xorriso, argc, argv, idx, 4 << 8);
|
|
|
|
} else if(strcmp(cmd,"update_r")==0) {
|
|
(*idx)+= 2;
|
|
ret= Xorriso_option_update(xorriso, arg1, arg2, 1|8);
|
|
|
|
} else if(strcmp(cmd,"use_immed_bit")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_use_immed_bit(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"use_readline")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_use_readline(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"version")==0){
|
|
ret= Xorriso_option_version(xorriso, 0);
|
|
|
|
} else if(strcmp(cmd,"volset_id")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_volset_id(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"volid")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_volid(xorriso,arg1,0);
|
|
|
|
} else if(strcmp(cmd,"volume_date")==0) {
|
|
(*idx)+= 2;
|
|
ret= Xorriso_option_volume_date(xorriso, arg1, arg2, 0);
|
|
|
|
} else if(strcmp(cmd,"write_type")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_write_type(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd, "x") == 0) {
|
|
/* only in effect in Xorriso_prescan_args() */;
|
|
|
|
} else if(strcmp(cmd,"xattr")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_xattr(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd,"zisofs")==0) {
|
|
(*idx)++;
|
|
ret= Xorriso_option_zisofs(xorriso, arg1, 0);
|
|
|
|
} else if(strcmp(cmd, xorriso->list_delimiter)==0){
|
|
/* tis ok */;
|
|
|
|
} else if(was_dashed) {
|
|
if(xorriso->add_plainly>1)
|
|
goto add_plain_argument;
|
|
unknown_option:;
|
|
sprintf(xorriso->info_text, "Not a known command: '%s'\n",
|
|
original_cmd);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
{ret= 0; goto eval_any_problems;}
|
|
|
|
} else {
|
|
if(xorriso->add_plainly<=0)
|
|
goto unknown_option;
|
|
add_plain_argument:;
|
|
mem_idx= *idx;
|
|
(*idx)--;
|
|
ret= Xorriso_option_add(xorriso, (*idx)+1, argv, idx, 0);
|
|
(*idx)= mem_idx;
|
|
|
|
}
|
|
|
|
eval_any_problems:
|
|
ret= Xorriso_eval_problem_status(xorriso, ret, 0);
|
|
if(ret<0)
|
|
goto ex;
|
|
|
|
if(*idx < argc && !(flag & 4))
|
|
goto next_command;
|
|
|
|
ex:;
|
|
fflush(stdout);
|
|
Xorriso_free_meM(cmd_data);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_parse_line(struct XorrisO *xorriso, char *line,
|
|
char *prefix, char *separators, int max_words,
|
|
int *argc, char ***argv, int flag)
|
|
{
|
|
int ret, bsl_mode;
|
|
char *to_parse, *progname= "";
|
|
|
|
if(xorriso == NULL && (flag & (32 | 64))) {
|
|
ret= -2; goto ex;
|
|
}
|
|
|
|
*argc= 0;
|
|
*argv= NULL;
|
|
|
|
to_parse= line;
|
|
if((flag & 1) || xorriso == NULL)
|
|
bsl_mode= (flag >> 1) & 3;
|
|
else
|
|
bsl_mode= xorriso->bsl_interpretation & 3;
|
|
if(prefix[0]) {
|
|
if(strncmp(line, prefix, strlen(prefix)) == 0) {
|
|
to_parse= line + strlen(prefix);
|
|
} else {
|
|
ret= 2; goto ex;
|
|
}
|
|
}
|
|
|
|
if(xorriso != NULL)
|
|
progname= xorriso->progname;
|
|
ret= Sfile_sep_make_argv(progname, to_parse, separators,
|
|
max_words, argc, argv,
|
|
(!(flag & 32)) | 4 | (bsl_mode << 5));
|
|
if(ret < 0) {
|
|
if(xorriso != NULL)
|
|
Xorriso_msgs_submit(xorriso, 0,
|
|
"Severe lack of resources during command line parsing", 0, "FATAL", 0);
|
|
ret= -1; goto ex;
|
|
}
|
|
if(ret == 0) {
|
|
if((flag & 64) && xorriso != NULL) {
|
|
sprintf(xorriso->info_text, "Incomplete quotation in %s line: %s",
|
|
(flag & 32) ? "command" : "parsed", to_parse);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
}
|
|
goto ex;
|
|
}
|
|
ret= 1;
|
|
ex:;
|
|
if(ret <= 0)
|
|
Sfile_sep_make_argv("", "", "", 0, argc, argv, 2); /* release memory */
|
|
return(ret);
|
|
}
|
|
|
|
|
|
void Xorriso__dispose_words(int *argc, char ***argv)
|
|
{
|
|
Sfile_make_argv("", "", argc, argv, 2); /* release memory */
|
|
}
|
|
|
|
|
|
int Xorriso_execute_option(struct XorrisO *xorriso, char *line, int flag)
|
|
/*
|
|
bit0-bit15 are forwarded to Xorriso_interpreter
|
|
|
|
bit16= no pageing of info lines
|
|
bit17= print === bar even if xorriso->found<0
|
|
*/
|
|
{
|
|
int ret,argc= 0, idx= 1;
|
|
char **argv= NULL;
|
|
double tdiff;
|
|
struct timeval tv;
|
|
|
|
gettimeofday(&tv, NULL);
|
|
Xorriso_reset_counters(xorriso,0);
|
|
xorriso->idle_time= 0.0;
|
|
tdiff= tv.tv_sec+(1.e-6*(double) tv.tv_usec);
|
|
|
|
ret= Xorriso_parse_line(xorriso, line, "", "", 0, &argc, &argv, 32 | 64);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
|
|
if(argc<2)
|
|
{ret= 1; goto ex;}
|
|
if(argv[1][0]=='#')
|
|
{ret= 1; goto ex;}
|
|
|
|
ret= Xorriso_interpreter(xorriso, argc, argv, &idx, flag&0xffff);
|
|
if(ret<0)
|
|
goto ex;
|
|
gettimeofday(&tv, NULL);
|
|
tdiff= tv.tv_sec+(1.e-6*(double) tv.tv_usec)-tdiff-xorriso->idle_time;
|
|
if(tdiff<0.001)
|
|
tdiff= 0.001;
|
|
if(xorriso->error_count>0) {
|
|
sprintf(xorriso->info_text,
|
|
"----------------------------- %7.f errors encountered\n",
|
|
xorriso->error_count);
|
|
Xorriso_info(xorriso,!(flag&(1<<16)));
|
|
}
|
|
|
|
/* ??? >>> print elapsed time tdiff ? */;
|
|
|
|
if((flag&(1<<17)) && !xorriso->bar_is_fresh) {
|
|
sprintf(xorriso->info_text,"============================\n");
|
|
Xorriso_info(xorriso,0);
|
|
xorriso->bar_is_fresh= 1;
|
|
}
|
|
Xorriso_reset_counters(xorriso,0);
|
|
ex:;
|
|
Sfile_make_argv("", "", &argc, &argv, 2); /* release memory */
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_dialog(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int ret, line_size= 2 * SfileadrL;
|
|
char *line= NULL;
|
|
|
|
Xorriso_alloc_meM(line, char, line_size);
|
|
|
|
if(!xorriso->dialog)
|
|
{ret= 1; goto ex;}
|
|
if(xorriso->abort_on_is_default)
|
|
Xorriso_option_abort_on(xorriso, "NEVER", 0);
|
|
xorriso->is_dialog= 1;
|
|
while(1) {
|
|
if(xorriso->pending_option[0]!=0) {
|
|
Xorriso_mark(xorriso,0);
|
|
strcpy(line,xorriso->pending_option);
|
|
xorriso->pending_option[0]= 0;
|
|
} else {
|
|
if(!xorriso->bar_is_fresh) {
|
|
sprintf(xorriso->info_text,"============================\n");
|
|
Xorriso_info(xorriso,0);
|
|
xorriso->bar_is_fresh= 1;
|
|
}
|
|
sprintf(xorriso->info_text,"enter option and arguments :\n");
|
|
Xorriso_info(xorriso,0);
|
|
Xorriso_mark(xorriso,0);
|
|
ret= Xorriso_dialog_input(xorriso,line, line_size, 4);
|
|
if(ret<=0)
|
|
break;
|
|
}
|
|
sprintf(xorriso->info_text,
|
|
"==============================================================\n");
|
|
Xorriso_info(xorriso,0);
|
|
|
|
ret= Xorriso_execute_option(xorriso,line,1<<17);
|
|
if(ret<0)
|
|
goto ex;
|
|
if(ret==3)
|
|
goto ex;
|
|
xorriso->did_something_useful= 1;
|
|
xorriso->no_volset_present= 0; /* Re-enable "No ISO image present." */
|
|
}
|
|
ret= 1;
|
|
ex:;
|
|
xorriso->is_dialog= 0;
|
|
Xorriso_free_meM(line);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @return 1=replaced , 2=not replaced , <=0 = error
|
|
*/
|
|
int Xorriso_replace_arg_by_bsl(struct XorrisO *xorriso, char **arg,
|
|
char **argpt, int flag)
|
|
{
|
|
int ret, eaten, l;
|
|
|
|
if(!(xorriso->bsl_interpretation & 16))
|
|
return(2);
|
|
l= strlen(*argpt);
|
|
Xorriso_free_meM(*arg);
|
|
Xorriso_alloc_meM(*arg, char, l + 1);
|
|
strcpy(*arg, *argpt);
|
|
*argpt= *arg;
|
|
ret= Sfile_bsl_interpreter(*arg, l, &eaten, 0);
|
|
ex:;
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_prescan_args(struct XorrisO *xorriso, int argc, char **argv,
|
|
int flag)
|
|
/*
|
|
bit0= do not interpret argv[1]
|
|
bit1= complain about inknown arguments
|
|
*/
|
|
/*
|
|
return:
|
|
<0 error
|
|
0 end program
|
|
1 ok, go on
|
|
*/
|
|
{
|
|
int i, ret, was_dashed, num2, arg_count;
|
|
int advice, mem_add_plainly, error_seen= 0, mem_bsl;
|
|
int was_report_about= 0, was_abort_on= 0, was_return_with= 0;
|
|
int was_signal_handling= 0, was_scsi_log= 0, cmd_data_size= 5 * SfileadrL;
|
|
char *cmd, *original_cmd, *cmd_data= NULL, *arg1, *arg2;
|
|
char *arg1_data= NULL, *arg2_data= NULL;
|
|
char mem_list_delimiter[81];
|
|
|
|
strcpy(mem_list_delimiter, xorriso->list_delimiter);
|
|
mem_add_plainly= xorriso->add_plainly;
|
|
mem_bsl= xorriso->bsl_interpretation;
|
|
|
|
Xorriso_alloc_meM(cmd_data, char, cmd_data_size);
|
|
|
|
for(i=1+(flag&1);i<argc;i++) {
|
|
original_cmd= cmd= argv[i];
|
|
was_dashed= 0;
|
|
|
|
was_dashed= Xorriso_normalize_command(xorriso, original_cmd, i,
|
|
cmd_data, cmd_data_size, &cmd, 0);
|
|
if(was_dashed<0)
|
|
{ret= -1; goto ex;}
|
|
|
|
arg1= "";
|
|
if(i + 1 < argc) {
|
|
arg1= argv[i + 1];
|
|
ret= Xorriso_replace_arg_by_bsl(xorriso, &arg1_data, &arg1, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
}
|
|
arg2= "";
|
|
if(i + 2 < argc) {
|
|
arg2= argv[i + 2];
|
|
ret= Xorriso_replace_arg_by_bsl(xorriso, &arg2_data, &arg2, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
}
|
|
if(i>1)
|
|
xorriso->did_something_useful= 1;
|
|
if(i==1 && argc==2) {
|
|
if(strcmp(cmd,"prog_help")==0) {
|
|
i++;
|
|
Xorriso_option_prog_help(xorriso,arg1,0);
|
|
xorriso->did_something_useful= 1;
|
|
{ret= 0; goto ex;}
|
|
} else if(strcmp(cmd,"help")==0) {
|
|
if(xorriso->argument_emulation == 1) {
|
|
Xorriso_genisofs_help(xorriso, 0);
|
|
} else if(xorriso->argument_emulation == 2) {
|
|
Xorriso_cdrskin_help(xorriso, 0);
|
|
} else {
|
|
Xorriso_option_help(xorriso,0);
|
|
}
|
|
xorriso->did_something_useful= 1;
|
|
{ret= 0; goto ex;}
|
|
}
|
|
} else if(i==1 && strcmp(cmd,"no_rc")==0) {
|
|
ret= Xorriso_option_no_rc(xorriso, 0);
|
|
if(ret<=0)
|
|
error_seen= 1;
|
|
{ret= 1; goto ex;}
|
|
} else if(xorriso->argument_emulation == 1) { /* mkisofs emulation */
|
|
if(xorriso->dev_fd_1 < 0)
|
|
goto protect_stdout;
|
|
{ret= 1; goto ex;}
|
|
|
|
} else if(xorriso->argument_emulation == 2) { /* cdrecord emulation */
|
|
if(xorriso->dev_fd_1 < 0)
|
|
if(Xorriso_cdrskin_uses_stdout(xorriso, argc - 1 - (flag & 1),
|
|
argv + 1 + (flag & 1), 0))
|
|
goto protect_stdout;
|
|
{ret= 1; goto ex;}
|
|
|
|
} else if((strcmp(cmd,"dev")==0 || strcmp(cmd,"outdev")==0 ||
|
|
strcmp(cmd,"indev")==0) &&
|
|
(strcmp(arg1,"stdio:/dev/fd/1")==0 || strcmp(arg1,"-")==0) &&
|
|
xorriso->dev_fd_1<0) {
|
|
/* Detach fd 1 from externally perceived stdout and attach it to stderr.
|
|
Keep dev_fd_1 connected to external stdout. dev_fd_1 is to be used when
|
|
"stdio:/dev/fd/1" is interpreted as drive address.
|
|
*/
|
|
protect_stdout:;
|
|
ret= Xorriso_protect_stdout(xorriso, 0);
|
|
if(ret == 1) {
|
|
sprintf(xorriso->info_text,
|
|
"Encountered - or stdio:/dev/fd/1 as possible write target.");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
|
|
sprintf(xorriso->info_text,
|
|
"Redirecting nearly all text message output to stderr.");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
|
|
sprintf(xorriso->info_text, "Disabling use of libreadline.");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
|
|
}
|
|
if(xorriso->argument_emulation >= 1 && xorriso->argument_emulation <=2)
|
|
{ret= 1; goto ex;}
|
|
|
|
} else if(strcmp(cmd,"abort_on")==0 && was_dashed == 1) {
|
|
i++;
|
|
if(!was_abort_on)
|
|
Xorriso_option_abort_on(xorriso, arg1, 0);
|
|
was_abort_on= 1;
|
|
|
|
} else if(strcmp(cmd,"report_about")==0 && was_dashed == 1) {
|
|
i++;
|
|
if(!was_report_about)
|
|
Xorriso_option_report_about(xorriso, arg1, 0);
|
|
was_report_about= 1;
|
|
|
|
} else if(strcmp(cmd,"return_with")==0 && was_dashed == 1) {
|
|
i+= 2;
|
|
num2= 0;
|
|
sscanf(arg2,"%d",&num2);
|
|
if(!was_return_with)
|
|
Xorriso_option_return_with(xorriso, arg1, num2, 0);
|
|
was_return_with= 1;
|
|
|
|
} else if(strcmp(cmd,"as")==0 && was_dashed == 1) {
|
|
ret= Xorriso_count_args(xorriso, argc - i, argv + i, &arg_count, 1);
|
|
if(ret == 1) {
|
|
i+= arg_count;
|
|
|
|
if((strcmp(arg1, "cdrecord")==0 || strcmp(arg1, "wodim")==0 ||
|
|
strcmp(arg1, "cdrskin")==0 || strcmp(arg1, "xorrecord")==0) &&
|
|
xorriso->dev_fd_1 < 0)
|
|
if(Xorriso_cdrskin_uses_stdout(xorriso, arg_count - 1,
|
|
argv + i - arg_count + 2, 0))
|
|
goto protect_stdout;
|
|
}
|
|
if(was_dashed == 1) {
|
|
if((strcmp(arg1, "mkisofs")==0 || strcmp(arg1, "genisoimage")==0 ||
|
|
strcmp(arg1, "genisofs")==0 || strcmp(arg1, "xorrisofs")==0) &&
|
|
xorriso->dev_fd_1 < 0)
|
|
goto protect_stdout;
|
|
}
|
|
|
|
} else if(strcmp(cmd, "list_delimiter") == 0) {
|
|
/* Needed for interpreting other args. Gets reset after prescan. */
|
|
i++;
|
|
ret= Xorriso_option_list_delimiter(xorriso, arg1, 0);
|
|
if(ret <= 0)
|
|
error_seen= 1;
|
|
|
|
} else if(strcmp(cmd, "add_plainly") == 0) {
|
|
i++;
|
|
ret= Xorriso_option_add_plainly(xorriso, arg1, 0);
|
|
if(ret <= 0)
|
|
error_seen= 1;
|
|
if(xorriso->add_plainly == 3) {
|
|
/* All further arguments count as pathspecs */
|
|
{ret= 1; goto ex;}
|
|
}
|
|
} else if(strcmp(cmd, "scsi_log") == 0 && was_dashed == 1) {
|
|
i++;
|
|
if(!was_scsi_log)
|
|
Xorriso_option_scsi_log(xorriso, arg1, 0);
|
|
was_scsi_log= 1;
|
|
|
|
} else if(strcmp(cmd, "signal_handling") == 0 && was_dashed == 1) {
|
|
i++;
|
|
if(!was_signal_handling)
|
|
Xorriso_option_signal_handling(xorriso, arg1, 1); /* no install */
|
|
was_signal_handling= 1;
|
|
|
|
} else if(strcmp(original_cmd, "-x") == 0) {
|
|
xorriso->arrange_args= 1;
|
|
|
|
} else if(strcmp(cmd, "backslash_codes") == 0) {
|
|
i++;
|
|
ret= Xorriso_option_backslash_codes(xorriso, arg1, 0);
|
|
if(ret <= 0)
|
|
error_seen= 1;
|
|
|
|
} else {
|
|
ret= Xorriso_count_args(xorriso, argc - i, argv + i, &arg_count, 1);
|
|
if(ret == 1) {
|
|
i+= arg_count;
|
|
} else if((flag & 2) && ((was_dashed && xorriso->add_plainly <= 1) ||
|
|
xorriso->add_plainly <= 0)) {
|
|
sprintf(xorriso->info_text, "Not a known command: '%s'\n",
|
|
original_cmd);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
error_seen= 1;
|
|
}
|
|
}
|
|
}
|
|
ret= 1;
|
|
ex:;
|
|
strcpy(xorriso->list_delimiter, mem_list_delimiter);
|
|
xorriso->add_plainly= mem_add_plainly;
|
|
xorriso->bsl_interpretation= mem_bsl;
|
|
Xorriso_free_meM(arg1_data);
|
|
Xorriso_free_meM(arg2_data);
|
|
Xorriso_free_meM(cmd_data);
|
|
if(error_seen && ret > 0) {
|
|
advice= Xorriso_eval_problem_status(xorriso, 0, 0);
|
|
if(advice < 0)
|
|
ret= -1;
|
|
}
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_read_as_mkisofsrc(struct XorrisO *xorriso, char *path, int flag)
|
|
{
|
|
int ret, linecount= 0;
|
|
FILE *fp= NULL;
|
|
char *sret, *line= NULL, *cpt, *wpt;
|
|
|
|
Xorriso_alloc_meM(line, char, SfileadrL);
|
|
|
|
ret= Xorriso_afile_fopen(xorriso, path, "rb", &fp, 1 | 2);
|
|
if(ret <= 0)
|
|
{ret= 0; goto ex;}
|
|
while(1) {
|
|
sret= Sfile_fgets_n(line, SfileadrL - 1, fp, 0);
|
|
if(sret == NULL) {
|
|
if(ferror(fp))
|
|
{ret= 0; goto ex;}
|
|
break;
|
|
}
|
|
linecount++;
|
|
|
|
/* Interpret line */
|
|
if(line[0] == 0 || line[0] == '#')
|
|
continue;
|
|
cpt= strchr(line, '=');
|
|
if(cpt == NULL) {
|
|
|
|
/* >>> ??? complain ? abort reading ? */;
|
|
|
|
continue;
|
|
}
|
|
*cpt= 0;
|
|
/* Names are not case sensitive */
|
|
for(wpt= line; wpt < cpt; wpt++)
|
|
if(*wpt >= 'a' && *wpt <= 'z')
|
|
*wpt= toupper(*wpt);
|
|
/* Remove trailing whitespace from name */
|
|
for(wpt= cpt - 1; wpt >= line ; wpt--)
|
|
if(*wpt == ' ' || *wpt == '\t')
|
|
*wpt= 0;
|
|
else
|
|
break;
|
|
/* Remove trailing whitespace from value */
|
|
for(wpt= cpt + 1 + strlen(cpt + 1) - 1; wpt >= cpt; wpt--)
|
|
if(*wpt == ' ' || *wpt == '\t')
|
|
*wpt= 0;
|
|
else
|
|
break;
|
|
/* Remove leading whitespace from value */
|
|
for(cpt++; *cpt == ' ' || *cpt == '\t'; cpt++);
|
|
|
|
if(strcmp(line, "APPI") == 0) {
|
|
ret= Xorriso_option_application_id(xorriso, cpt, 0);
|
|
} else if(strcmp(line, "COPY") == 0) {
|
|
ret= Xorriso_option_copyright_file(xorriso, cpt, 0);
|
|
} else if(strcmp(line, "ABST") == 0) {
|
|
ret= Xorriso_option_abstract_file(xorriso, cpt, 0);
|
|
} else if(strcmp(line, "BIBL") == 0) {
|
|
ret= Xorriso_option_biblio_file(xorriso, cpt, 0);
|
|
} else if(strcmp(line, "PREP") == 0) {
|
|
/* Not planned to be implemented. Preparer is xorriso. */
|
|
ret= 1;
|
|
} else if(strcmp(line, "PUBL") == 0) {
|
|
ret= Xorriso_option_publisher(xorriso, cpt, 0);
|
|
} else if(strcmp(line, "SYSI") == 0) {
|
|
ret= Xorriso_option_system_id(xorriso, cpt, 0);
|
|
} else if(strcmp(line, "VOLI") == 0) {
|
|
ret= Xorriso_option_volid(xorriso, cpt, 1);
|
|
} else if(strcmp(line, "VOLS") == 0) {
|
|
ret= Xorriso_option_volset_id(xorriso, cpt, 0);
|
|
} else if(strcmp(line, "HFS_TYPE") == 0) {
|
|
/* Not planned to be implemented */
|
|
ret= 1;
|
|
} else if(strcmp(line, "HFS_CREATOR") == 0) {
|
|
/* Not planned to be implemented */
|
|
ret= 1;
|
|
} else {
|
|
|
|
/* >>> ??? complain ? abort reading ? */;
|
|
|
|
}
|
|
if(ret <= 0)
|
|
goto ex;
|
|
}
|
|
xorriso->mkisofsrc_done= 1;
|
|
ret= 1;
|
|
ex:
|
|
if(fp != NULL)
|
|
fclose(fp);
|
|
Xorriso_free_meM(line);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* ./.mkisofsrc , getenv("MKISOFSRC") ,
|
|
$HOME/.mkisofsrc , $(basename $0)/.mkisofsrc
|
|
*/
|
|
int Xorriso_read_mkisofsrc(struct XorrisO *xorriso, int flag)
|
|
{
|
|
char *path= NULL, *cpt;
|
|
int ret;
|
|
|
|
Xorriso_alloc_meM(path, char, SfileadrL);
|
|
|
|
ret= Xorriso_read_as_mkisofsrc(xorriso, "./.mkisofsrc", 0);
|
|
if(ret > 0)
|
|
goto ex;
|
|
cpt= getenv("MKISOFSRC");
|
|
if(cpt != NULL) {
|
|
strncpy(path, cpt, SfileadrL - 1);
|
|
path[SfileadrL - 1]= 0;
|
|
ret= Xorriso_read_as_mkisofsrc(xorriso, path, 0);
|
|
if(ret > 0)
|
|
goto ex;
|
|
}
|
|
cpt= getenv("HOME");
|
|
if(cpt != NULL) {
|
|
strncpy(path, cpt, SfileadrL - 1 - 11);
|
|
path[SfileadrL - 1 - 11]= 0;
|
|
strcat(path, "/.mkisofsrc");
|
|
ret= Xorriso_read_as_mkisofsrc(xorriso, path, 0);
|
|
if(ret > 0)
|
|
goto ex;
|
|
}
|
|
strcpy(path, xorriso->progname);
|
|
cpt= strrchr(path, '/');
|
|
if(cpt != NULL) {
|
|
strcpy(cpt + 1, ".mkisofsrc");
|
|
ret= Xorriso_read_as_mkisofsrc(xorriso, path, 0);
|
|
if(ret > 0)
|
|
goto ex;
|
|
}
|
|
/* no .mkisofsrc file found */
|
|
ret= 2;
|
|
ex:;
|
|
Xorriso_free_meM(path);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* https://reproducible-builds.org/specs/source-date-epoch/
|
|
and reproducible-builds@lists.alioth.debian.org in august 2016
|
|
*/
|
|
int Xorriso_source_date_epoch(struct XorrisO *xorriso, int flag)
|
|
{
|
|
/* num_text must be able to take the sprintf output of "%.f".
|
|
num_text + 12 must be able to take "%d" with a 64 bit int.
|
|
*/
|
|
char *sec_text, num_text[40];
|
|
double dsec= -1.0;
|
|
time_t tsec;
|
|
struct tm *gmt;
|
|
|
|
sec_text= getenv("SOURCE_DATE_EPOCH");
|
|
if(sec_text == NULL)
|
|
return(2);
|
|
|
|
sscanf(sec_text, "%lf", &dsec);
|
|
sprintf(num_text, "%.f", dsec);
|
|
tsec= dsec;
|
|
if(dsec < 0 || ((double) tsec) != dsec ||
|
|
strcmp(sec_text, num_text) != 0) {
|
|
malformed:;
|
|
Xorriso_msgs_submit(xorriso, 0,
|
|
"Malformed environment variable SOURCE_DATE_EPOCH encountered",
|
|
0, "SORRY", 0);
|
|
Xorriso_msgs_submit(xorriso, 0,
|
|
"Unset SOURCE_DATE_EPOCH before starting xorriso or see https://reproducible-builds.org/specs/source-date-epoch/",
|
|
0, "HINT", 0);
|
|
return(0);
|
|
}
|
|
gmt= gmtime(&tsec);
|
|
if(gmt == NULL)
|
|
goto malformed;
|
|
|
|
sprintf(num_text, "%4.4d", 1900 + gmt->tm_year);
|
|
sprintf(num_text + 4, "%2.2d", gmt->tm_mon + 1);
|
|
sprintf(num_text + 6, "%2.2d", gmt->tm_mday);
|
|
sprintf(num_text + 8, "%2.2d", gmt->tm_hour);
|
|
sprintf(num_text + 10, "%2.2d", gmt->tm_min);
|
|
sprintf(num_text + 12, "%2.2d", gmt->tm_sec);
|
|
strcpy(num_text + 14, "00");
|
|
strcpy(xorriso->vol_uuid, num_text);
|
|
xorriso->gpt_guid_mode= 2; /* Disk GUID from vol_uuid */
|
|
strcpy(xorriso->all_file_dates, "set_to_mtime");
|
|
xorriso->do_override_now_time= 1;
|
|
xorriso->now_time_override= tsec;
|
|
Xorriso_set_libisofs_now(xorriso, 0);
|
|
|
|
sprintf(xorriso->info_text,
|
|
"Environment variable SOURCE_DATE_EPOCH encountered with value %s",
|
|
sec_text);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
sprintf(xorriso->info_text, "SOURCE_DATE_EPOCH : -volume_date uuid %s",
|
|
xorriso->vol_uuid);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
|
|
sprintf(xorriso->info_text,
|
|
"SOURCE_DATE_EPOCH : -volume_date all_file_dates %s",
|
|
xorriso->all_file_dates);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
|
|
sprintf(xorriso->info_text,
|
|
"SOURCE_DATE_EPOCH : -boot_image any gpt_disk_guid=volume_date_uuid");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
|
|
sprintf(xorriso->info_text,
|
|
"SOURCE_DATE_EPOCH : -iso_nowtime =%.f", (double) tsec);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
|
|
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_read_rc(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int ret,i,was_failure= 0,fret;
|
|
|
|
/* Interpret environment variable SOURCE_DATE_EPOCH */
|
|
ret= Xorriso_source_date_epoch(xorriso, 0);
|
|
ret= Xorriso_eval_problem_status(xorriso, ret, 0);
|
|
if(ret < 0)
|
|
return(0);
|
|
|
|
if(xorriso->no_rc)
|
|
return(1);
|
|
i= xorriso->rc_filename_count-1;
|
|
Sfile_home_adr_s(".xorrisorc", xorriso->rc_filenames[i],
|
|
sizeof(xorriso->rc_filenames[i]),0);
|
|
for(i=0;i<xorriso->rc_filename_count;i++) {
|
|
ret= Sfile_type(xorriso->rc_filenames[i],1|8);
|
|
if(ret!=1)
|
|
continue;
|
|
ret= Xorriso_option_options_from_file(xorriso,xorriso->rc_filenames[i],0);
|
|
if(ret>1)
|
|
return(ret);
|
|
if(ret==1)
|
|
continue; /* regular bottom of loop */
|
|
was_failure= 1;
|
|
fret= Xorriso_eval_problem_status(xorriso, ret, 1);
|
|
if(fret>=0)
|
|
continue;
|
|
return(ret);
|
|
}
|
|
if(xorriso->argument_emulation == 1 && !xorriso->mkisofsrc_done) {
|
|
ret= Xorriso_read_mkisofsrc(xorriso, 0);
|
|
if(ret <= 0)
|
|
was_failure= 1;
|
|
}
|
|
return(!was_failure);
|
|
}
|
|
|
|
|
|
int Xorriso_make_return_value(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int exit_value= 0;
|
|
|
|
if(xorriso->eternal_problem_status >= xorriso->return_with_severity)
|
|
exit_value= xorriso->return_with_value;
|
|
if(exit_value) {
|
|
sprintf(xorriso->info_text,
|
|
"-return_with %s %d triggered by problem severity %s",
|
|
xorriso->return_with_text, exit_value,
|
|
xorriso->eternal_problem_status_text);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
}
|
|
return(exit_value);
|
|
}
|
|
|
|
|
|
int Xorriso_program_arg_bsl(struct XorrisO *xorriso, int argc, char ***argv,
|
|
int flag)
|
|
{
|
|
int i, ret, eaten, bsl_mem, params_to_come= 0, cmd_data_size= 5 * SfileadrL;
|
|
int next_is_backslash_codes= 0, next_is_list_delimiter= 0;
|
|
char **new_argv= NULL, *cmd, *cmd_data= NULL;
|
|
char mem_list_delimiter[81];
|
|
|
|
strcpy(mem_list_delimiter, xorriso->list_delimiter);
|
|
bsl_mem= xorriso->bsl_interpretation;
|
|
if(argc <= 0)
|
|
return(0);
|
|
Xorriso_alloc_meM(cmd_data, char, cmd_data_size);
|
|
new_argv= (char **) Smem_malloC(argc * sizeof(char *));
|
|
if(new_argv == NULL)
|
|
{ret= -1; goto ex;}
|
|
for(i= 0; i < argc; i++) {
|
|
new_argv[i]= strdup((*argv)[i]);
|
|
if(new_argv[i] == NULL)
|
|
{ret= -1; goto ex;}
|
|
if(i == 0)
|
|
continue;
|
|
if(xorriso->bsl_interpretation & 16) {
|
|
ret= Sfile_bsl_interpreter(new_argv[i], strlen(new_argv[i]), &eaten, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
}
|
|
if(params_to_come == 0) {
|
|
ret= Xorriso_normalize_command(xorriso, new_argv[i], i,
|
|
cmd_data, cmd_data_size, &cmd, 0);
|
|
if(ret < 0)
|
|
goto ex;
|
|
if(strcmp(cmd, "backslash_codes") == 0) {
|
|
params_to_come= 1;
|
|
next_is_backslash_codes= 1;
|
|
} else if(strcmp(cmd, "list_delimiter") == 0) {
|
|
params_to_come= 1;
|
|
next_is_list_delimiter= 1;
|
|
} else {
|
|
ret= Xorriso_count_args(xorriso, argc - i, *argv + i,
|
|
¶ms_to_come, 1);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
if(ret != 1)
|
|
params_to_come= 0;
|
|
}
|
|
} else {
|
|
params_to_come--;
|
|
if(next_is_backslash_codes) {
|
|
next_is_backslash_codes= 0;
|
|
ret= Xorriso_option_backslash_codes(xorriso, new_argv[i], 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
} else if(next_is_list_delimiter) {
|
|
next_is_list_delimiter= 0;
|
|
ret= Xorriso_option_list_delimiter(xorriso, new_argv[i], 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
}
|
|
}
|
|
}
|
|
ret= 1;
|
|
ex:;
|
|
Xorriso_free_meM(cmd_data);
|
|
strcpy(xorriso->list_delimiter, mem_list_delimiter);
|
|
xorriso->bsl_interpretation= bsl_mem;
|
|
if(ret <= 0) {
|
|
if(new_argv != NULL)
|
|
free((char *) new_argv);
|
|
} else
|
|
*argv= new_argv;
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= prepend wd only if name does not begin by '/'
|
|
bit1= normalize image path
|
|
bit2= prepend wd (automatically done if wd[0]!=0)
|
|
bit3= (with bit1) this is an address in the disk world
|
|
*/
|
|
int Xorriso_make_abs_adr(struct XorrisO *xorriso, char *wd, char *name,
|
|
char adr[], int flag)
|
|
{
|
|
char *norm_adr= NULL;
|
|
int ret;
|
|
|
|
Xorriso_alloc_meM(norm_adr, char, SfileadrL);
|
|
|
|
if((wd[0]!=0 || (flag&4)) && !((flag&1) && name[0]=='/')) {
|
|
if(strlen(wd)+1>=SfileadrL)
|
|
goto much_too_long;
|
|
strcpy(adr, wd);
|
|
if(name[0])
|
|
if(Sfile_add_to_path(adr, name, 0)<=0) {
|
|
much_too_long:;
|
|
Xorriso_much_too_long(xorriso, (int) (strlen(adr)+strlen(name)+1), 2);
|
|
{ret= 0; goto ex;}
|
|
}
|
|
} else {
|
|
if(strlen(name)+1>=SfileadrL)
|
|
goto much_too_long;
|
|
strcpy(adr, name);
|
|
}
|
|
if(flag&2) {
|
|
ret= Xorriso_normalize_img_path(xorriso, "", adr, norm_adr,
|
|
1|2|((flag&8)>>1));
|
|
if(ret<=0)
|
|
goto ex;
|
|
if(norm_adr[0]==0)
|
|
strcpy(norm_adr, "/");
|
|
strcpy(adr, norm_adr);
|
|
}
|
|
ret= 1;
|
|
ex:;
|
|
Xorriso_free_meM(norm_adr);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= do not complain in case of error, but set info_text */
|
|
int Xorriso_convert_datestring(struct XorrisO *xorriso, char *cmd,
|
|
char *time_type, char *timestring,
|
|
int *t_type, time_t *t, int flag)
|
|
{
|
|
int ret;
|
|
|
|
*t_type= 0;
|
|
if(strcmp(time_type, "a")==0)
|
|
(*t_type)|= 1;
|
|
else if(strcmp(time_type, "a-c")==0)
|
|
(*t_type)|= 1 | 256;
|
|
else if(strcmp(time_type, "m")==0)
|
|
(*t_type)|= 4;
|
|
else if(strcmp(time_type, "m-c")==0)
|
|
(*t_type)|= 4 | 256;
|
|
else if(strcmp(time_type, "b")==0)
|
|
(*t_type)|= 5;
|
|
else if(strcmp(time_type, "b-c")==0)
|
|
(*t_type)|= 5 | 256;
|
|
else if(strcmp(time_type, "c")==0)
|
|
(*t_type)|= 2 | 256;
|
|
else {
|
|
sprintf(xorriso->info_text, "%s: Unrecognized type '%s'", cmd, time_type);
|
|
if(!(flag & 1))
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
|
|
return(0);
|
|
}
|
|
ret= Decode_timestring(timestring, t, 0);
|
|
if(ret<=0) {
|
|
sprintf(xorriso->info_text, "%s: Cannot decode timestring '%s'", cmd,
|
|
timestring);
|
|
if(!(flag & 1))
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
|
|
return(0);
|
|
}
|
|
sprintf(xorriso->info_text, "Understanding timestring '%s' as: %s",
|
|
timestring, ctime(t));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param flag bit1= do not report memory usage as DEBUG
|
|
*/
|
|
int Xorriso_check_temp_mem_limit(struct XorrisO *xorriso, off_t mem, int flag)
|
|
{
|
|
char mem_text[80], limit_text[80];
|
|
|
|
Sfile_scale((double) mem, mem_text,5,1e4,0);
|
|
if(!(flag&2)) {
|
|
sprintf(xorriso->info_text,
|
|
"Temporary memory needed for result sorting : %s", mem_text);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
|
|
}
|
|
if(mem > xorriso->temp_mem_limit) {
|
|
Sfile_scale((double) xorriso->temp_mem_limit,limit_text,5,1e4,1);
|
|
sprintf(xorriso->info_text,
|
|
"Cannot sort. List of matching files exceeds -temp_mem_limit (%s > %s)",
|
|
mem_text, limit_text);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING", 0);
|
|
return(0);
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_wait_child_end(struct XorrisO *xorriso, pid_t child_pid,
|
|
int *status, int flag)
|
|
{
|
|
int ret;
|
|
|
|
do {
|
|
/* try to read and print the reply */;
|
|
ret= waitpid(child_pid, status, WNOHANG);
|
|
if(ret == -1) {
|
|
if(errno != EINTR)
|
|
return(0);
|
|
} else if(ret == 0) {
|
|
continue;
|
|
} else {
|
|
break;
|
|
}
|
|
} while(1);
|
|
|
|
/* >>> interpret *status */;
|
|
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_make_argv_with_null(struct XorrisO *xorriso,
|
|
int in_argc, char **in_argv,
|
|
int *argc, char ***argv, int flag)
|
|
{
|
|
int i, ret= 0;
|
|
|
|
*argv= NULL;
|
|
Xorriso_alloc_meM(*argv, char *, in_argc + 1);
|
|
for(i= 0; i < in_argc; i++) {
|
|
Xorriso_alloc_meM((*argv)[i], char, strlen(in_argv[i]) + 1);
|
|
strcpy((*argv)[i], in_argv[i]);
|
|
*argc= i + 1;
|
|
}
|
|
(*argv)[in_argc]= NULL;
|
|
ret= 1;
|
|
ex:;
|
|
if(ret <= 0)
|
|
Sfile_destroy_argv(argc, argv, 0);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/*
|
|
@param flag bit0= use env_path to find the desired program
|
|
bit1= use in_argv rather than parsing cmd to words
|
|
bit2= -reserved-
|
|
bit3= demand absolute cmd path
|
|
return:
|
|
<=0 : error
|
|
1 : done
|
|
*/
|
|
int Xorriso_execv(struct XorrisO *xorriso, char *cmd,
|
|
int in_argc, char **in_argv, char *env_path,
|
|
int *stdin_pipe, int *stdout_pipe, pid_t *forked_pid,
|
|
int *status, int flag)
|
|
{
|
|
int ret, argc= 0, has_slash;
|
|
char **argv= NULL, *pathlist= NULL, *cpt, *npt, *prog= NULL;
|
|
pid_t child_pid;
|
|
struct stat stbuf;
|
|
|
|
Xorriso_alloc_meM(prog, char, 5 * SfileadrL);
|
|
|
|
wait3(NULL,WNOHANG,NULL); /* just to remove any old dead child */
|
|
|
|
if(flag & 2) {
|
|
ret= Xorriso_make_argv_with_null(xorriso, in_argc, in_argv,
|
|
&argc, &argv, 0);
|
|
} else {
|
|
ret= Sfile_make_argv("", cmd, &argc, &argv, 1|4|128);
|
|
}
|
|
if(ret <= 0)
|
|
goto ex;
|
|
if(argc < 1)
|
|
{ret= 0; goto ex;}
|
|
|
|
strcpy(prog, argv[0]);
|
|
has_slash= (strchr(argv[0], '/') != NULL);
|
|
if((flag & 8) && !has_slash) {
|
|
sprintf(xorriso->info_text, "External program path contains no '/': ");
|
|
Text_shellsafe(argv[0], xorriso->info_text, 1);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
if((flag & 1) && !has_slash) {
|
|
if(env_path == NULL)
|
|
env_path= "/bin:/sbin";
|
|
else if(env_path[0] == 0)
|
|
env_path= "/bin:/sbin";
|
|
if(Sregex_string(&pathlist, env_path, 0) <= 0)
|
|
{ret= -1; goto ex;}
|
|
for(cpt= npt= pathlist; npt != NULL; cpt= npt + 1) {
|
|
npt= strchr(cpt, ':');
|
|
if(npt != NULL)
|
|
*npt= 0;
|
|
if(strlen(cpt) + strlen(argv[0]) + 1 >= SfileadrL)
|
|
{ret= -1; goto ex;}
|
|
sprintf(prog, "%s/%s", cpt, argv[0]);
|
|
ret= stat(prog, &stbuf);
|
|
if(ret != -1)
|
|
break;
|
|
prog[0]= 0;
|
|
}
|
|
if(prog[0] == 0) {
|
|
sprintf(xorriso->info_text, "Cannot find external program ");
|
|
Text_shellsafe(argv[0], xorriso->info_text, 1);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
}
|
|
|
|
child_pid= fork();
|
|
if(child_pid==-1)
|
|
{ret= -1; goto ex;}
|
|
|
|
if(child_pid==0) {
|
|
/* this is the child process */
|
|
|
|
sprintf(xorriso->info_text, "Executing external program ");
|
|
Text_shellsafe(prog, xorriso->info_text, 1);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
|
|
Xorriso_destroy(&xorriso, 0); /* reduce memory foot print */
|
|
|
|
if(stdin_pipe != NULL) {
|
|
close(0);
|
|
if(dup2(stdin_pipe[0], 0) == -1)
|
|
{ perror("dup2(,0)"); exit(1); }
|
|
close(stdin_pipe[1]); /* unused */
|
|
}
|
|
if(stdout_pipe != NULL) {
|
|
close(1);
|
|
if(dup2(stdout_pipe[1], 1) == -1)
|
|
{ perror("dup2(,1)"); exit(1); }
|
|
close(stdout_pipe[0]); /* unused */
|
|
}
|
|
|
|
execv(prog, argv); /* should never come back */
|
|
fprintf(stderr,"--- execution of shell command failed:\n");
|
|
fprintf(stderr," %s\n",cmd);
|
|
exit(127);
|
|
}
|
|
|
|
|
|
/* this is the original process waiting for child to exit */
|
|
|
|
if(stdin_pipe != NULL)
|
|
close(stdin_pipe[0]); /* unused */
|
|
if(stdout_pipe != NULL)
|
|
close(stdout_pipe[1]); /* unused */
|
|
if(stdin_pipe != NULL || stdout_pipe != NULL) {
|
|
/* Pipes need to be fed by the caller who later calls Xorriso_wait_child_end
|
|
with *forked_pid as child_pid.
|
|
*/
|
|
*forked_pid= child_pid;
|
|
{ret= 1; goto ex;}
|
|
}
|
|
|
|
ret= Xorriso_wait_child_end(xorriso, child_pid, status, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
ret= 1;
|
|
ex:
|
|
Sfile_make_argv("", "", &argc, &argv, 2);
|
|
Sregex_string(&pathlist, NULL, 0);
|
|
Xorriso_free_meM(prog);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= use env_path to find the desired program
|
|
bit1= use in_argv rather than parsing cmd to words
|
|
bit2= "r" rather than "w"
|
|
bit3= demand absolute cmd path
|
|
bit4= override any restriction on external filters
|
|
*/
|
|
int Xorriso_pipe_open(struct XorrisO *xorriso, char *purpose, char *cmd,
|
|
int in_argc, char **in_argv, char *env_path,
|
|
int *fd, pid_t *forked_pid, int flag)
|
|
{
|
|
int fp_pipe[2], *stdin_pipe= NULL, *stdout_pipe= NULL, status, ret;
|
|
|
|
*fd= -1;
|
|
|
|
if(!(flag & 16)) {
|
|
ret= Xorriso_external_filter_banned(xorriso, purpose, 0);
|
|
if(ret)
|
|
return(0);
|
|
}
|
|
if(pipe(fp_pipe) != 0) {
|
|
sprintf(xorriso->info_text, "Cannot create pipe(2) object");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FATAL", 0);
|
|
return(0);
|
|
}
|
|
if(flag & 4) {
|
|
stdout_pipe= fp_pipe;
|
|
*fd= fp_pipe[0];
|
|
} else {
|
|
stdin_pipe= fp_pipe;
|
|
*fd= fp_pipe[1];
|
|
}
|
|
ret= Xorriso_execv(xorriso, cmd, in_argc, in_argv, env_path,
|
|
stdin_pipe, stdout_pipe, forked_pid, &status, flag & 11);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= path is a command parameter
|
|
*/
|
|
int Xorriso_path_is_excluded(struct XorrisO *xorriso, char *path, int flag)
|
|
{
|
|
int ret;
|
|
|
|
if(!(xorriso->disk_excl_mode&1)) /* exclusion is off */
|
|
return(0);
|
|
if((flag&1) && !(xorriso->disk_excl_mode&2)) /* params are exempted */
|
|
return(0);
|
|
ret= Exclusions_match(xorriso->disk_exclusions, path,
|
|
!!(xorriso->disk_excl_mode&4));
|
|
if(ret<0) {
|
|
sprintf(xorriso->info_text,
|
|
"Error during disk file exclusion decision");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
}
|
|
if(ret>0 && (flag&1)) {
|
|
sprintf(xorriso->info_text, "Disk path parameter excluded by %s : ",
|
|
(ret==1 ? "-not_paths" : "-not_leaf"));
|
|
Text_shellsafe(path, xorriso->info_text, 1);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
}
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_path_is_hidden(struct XorrisO *xorriso, char *path, int flag)
|
|
{
|
|
int ret, hide_attrs= 0;
|
|
|
|
ret= Exclusions_match(xorriso->iso_rr_hidings, path, 0);
|
|
if(ret < 0) {
|
|
failure:;
|
|
sprintf(xorriso->info_text, "Error during disk file hiding decision");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
return(-1);
|
|
}
|
|
if(ret > 0)
|
|
hide_attrs|= 1;
|
|
ret= Exclusions_match(xorriso->joliet_hidings, path, 0);
|
|
if(ret < 0)
|
|
goto failure;
|
|
if(ret > 0)
|
|
hide_attrs|= 2;
|
|
ret= Exclusions_match(xorriso->hfsplus_hidings, path, 0);
|
|
if(ret < 0)
|
|
goto failure;
|
|
if(ret > 0)
|
|
hide_attrs|= 4;
|
|
return(hide_attrs);
|
|
}
|
|
|
|
|
|
/* Normalize ACL and sort apart "access" ACL from "default" ACL.
|
|
*/
|
|
int Xorriso_normalize_acl_text(struct XorrisO *xorriso, char *in_text,
|
|
char **access_acl_text, char **default_acl_text, int flag)
|
|
{
|
|
int ret, access_count= 0, default_count= 0, pass, is_default, line_len;
|
|
int was_error= 0, line_count= 0, perms;
|
|
char *acl_text= NULL, *cpt, *npt, *access_wpt= NULL, *default_wpt= NULL;
|
|
char *dpt= NULL, *ddpt= NULL, **wpt, *ppt;
|
|
|
|
if(in_text[0] == 0 || strcmp(in_text, "clear") == 0 ||
|
|
strcmp(in_text, "--remove-all") == 0) {
|
|
*access_acl_text= *default_acl_text= NULL;
|
|
return(1);
|
|
} else if (strcmp(in_text, "--remove-default") == 0) {
|
|
|
|
/* >>> protect Access-ACL and delete Default-ACL */;
|
|
|
|
/* <<< */
|
|
return(0);
|
|
|
|
}
|
|
|
|
acl_text= strdup(in_text);
|
|
if(acl_text == NULL) {
|
|
Xorriso_no_malloc_memory(xorriso, NULL, 0);
|
|
{ret= -1; goto ex;}
|
|
}
|
|
|
|
/* From comma to newline */
|
|
for(cpt= strchr(acl_text, ','); cpt != NULL; cpt= strchr(cpt + 1, ','))
|
|
*cpt= '\n';
|
|
|
|
/* Normalize to long text form
|
|
and sort apart "access" ACL from "default" ACL */;
|
|
for(pass= 0; pass < 2; pass++) {
|
|
line_count= 0;
|
|
for(cpt= acl_text; cpt != NULL; cpt= npt) {
|
|
line_count++;
|
|
npt= strchr(cpt, '\n');
|
|
if(npt != NULL)
|
|
npt++;
|
|
if(*cpt == '#' || *cpt == '\n' || *cpt == 0)
|
|
continue;
|
|
|
|
is_default= 0;
|
|
wpt= &access_wpt;
|
|
if(*cpt == 'd') {
|
|
is_default= 1;
|
|
if(pass == 1)
|
|
wpt= &default_wpt;
|
|
cpt= strchr(cpt, ':');
|
|
if(cpt == NULL) {
|
|
was_error= line_count;
|
|
continue;
|
|
}
|
|
cpt++;
|
|
}
|
|
|
|
line_len= 0;
|
|
dpt= strchr(cpt, ':');
|
|
if(dpt != NULL)
|
|
ddpt= strchr(dpt + 1, ':');
|
|
if(dpt == NULL || ddpt == NULL) {
|
|
was_error= line_count;
|
|
continue;
|
|
}
|
|
if(*cpt == 'u') {
|
|
if(pass == 0) {
|
|
line_len+= 5;
|
|
line_len+= ddpt - dpt;
|
|
} else {
|
|
strcpy(*wpt, "user:");
|
|
strncpy(*wpt + 5, dpt + 1, ddpt - dpt);
|
|
(*wpt)+= 5 + (ddpt - dpt);
|
|
}
|
|
} else if(*cpt == 'g') {
|
|
if(pass == 0) {
|
|
line_len+= 6 + (ddpt - dpt);
|
|
} else {
|
|
strcpy(*wpt, "group:");
|
|
strncpy(*wpt + 6, dpt + 1, ddpt - dpt);
|
|
(*wpt)+= 6 + (ddpt - dpt);
|
|
}
|
|
} else if(*cpt == 'o') {
|
|
if(pass == 0) {
|
|
if(ddpt - dpt > 1) {
|
|
was_error= line_count;
|
|
continue;
|
|
}
|
|
line_len+= 6 + (ddpt - dpt);
|
|
} else {
|
|
strcpy(*wpt, "other:");
|
|
strncpy(*wpt + 6, dpt + 1, ddpt - dpt);
|
|
(*wpt)+= 6 + (ddpt - dpt);
|
|
}
|
|
} else if(*cpt == 'm') {
|
|
if(pass == 0) {
|
|
if(ddpt - dpt > 1) {
|
|
was_error= line_count;
|
|
continue;
|
|
}
|
|
line_len+= 5 + (ddpt - dpt);
|
|
} else {
|
|
strcpy(*wpt, "mask:");
|
|
strncpy(*wpt + 5, dpt + 1, ddpt - dpt);
|
|
(*wpt)+= 5 + (ddpt - dpt);
|
|
}
|
|
|
|
} else {
|
|
/* Unknown tag type */
|
|
was_error= line_count;
|
|
continue;
|
|
}
|
|
|
|
/* Examine permissions at ddpt + 1 */;
|
|
perms= 0;
|
|
for(ppt= ddpt + 1; *ppt != 0 && *ppt != '\n'; ppt++) {
|
|
if(*ppt == 'r')
|
|
perms|= 4;
|
|
else if(*ppt == 'w')
|
|
perms|= 2;
|
|
else if(*ppt == 'x')
|
|
perms|= 1;
|
|
else if(*ppt == '-' || *ppt == ' ' || *ppt == '\t')
|
|
;
|
|
else if(*ppt == '#')
|
|
break;
|
|
else {
|
|
was_error= line_count;
|
|
break;
|
|
}
|
|
}
|
|
if(pass == 0) {
|
|
line_len+= 4;
|
|
} else {
|
|
sprintf(*wpt, "%c%c%c\n",
|
|
perms & 4 ? 'r' : '-', perms & 2 ? 'w' : '-', perms & 1 ? 'x' : '-');
|
|
(*wpt)+= 4;
|
|
}
|
|
|
|
if(pass == 0) {
|
|
if(is_default)
|
|
default_count+= line_len;
|
|
else
|
|
access_count+= line_len;
|
|
}
|
|
}
|
|
|
|
if(pass == 0) {
|
|
*access_acl_text= calloc(access_count + 1, 1);
|
|
*default_acl_text= calloc(default_count + 1, 1);
|
|
if(*access_acl_text == NULL || *default_acl_text == NULL) {
|
|
Xorriso_no_malloc_memory(xorriso, access_acl_text, 0);
|
|
{ret= -1; goto ex;}
|
|
}
|
|
access_wpt= *access_acl_text;
|
|
default_wpt= *default_acl_text;
|
|
} else {
|
|
*access_wpt= 0;
|
|
*default_wpt= 0;
|
|
}
|
|
}
|
|
|
|
ret= 1;
|
|
ex:;
|
|
if(acl_text != NULL)
|
|
free(acl_text);
|
|
if(was_error) {
|
|
sprintf(xorriso->info_text,
|
|
"Malformed ACL entries encountered. Last one in line number %d.",
|
|
was_error);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
return(ret);
|
|
}
|
|
|