710 lines
20 KiB
C
710 lines
20 KiB
C
|
|
/* Beefed-up example from man 2 pipe
|
|
to illustrate how xorriso is to be used by frontend programs via two pipes.
|
|
Additionally there is a standalone implementation of Xorriso_parse_line().
|
|
|
|
Copyright 2012 Thomas Schmitt, <scdbackup@gmx.net>
|
|
Unaltered provided under BSD license.
|
|
You may issue licenses of your choice for derived code, provided that they
|
|
do not infringe anybody's right to do the same for this original code.
|
|
|
|
Build:
|
|
cc -g -o frontend_pipes_xorriso frontend_pipes_xorriso.c
|
|
|
|
Usage:
|
|
./frontend_pipes_xorriso [path_to_xorriso_binary | -h]
|
|
|
|
*/
|
|
|
|
#include <sys/wait.h>
|
|
#include <assert.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
|
|
|
|
/* Local helpers of parent process */
|
|
|
|
struct parse_rules { /* Parsing_parameters. See xorriso.h Xorriso_parse_line */
|
|
int do_parse;
|
|
char progname[1024];
|
|
|
|
char prefix[1024];
|
|
char separators[256];
|
|
int max_words;
|
|
int flag;
|
|
};
|
|
|
|
int parse_line(char *progname, char *line,
|
|
char *prefix, char *separators, int max_words,
|
|
int *argc, char ***argv, int flag);
|
|
|
|
int dispose_parsed_words(int *argc, char ***argv);
|
|
|
|
static int await_all_replies(int fd, char *pending_mark,
|
|
struct parse_rules *parse);
|
|
|
|
static int prompt_for_command(char *line, int line_size,
|
|
struct parse_rules *parse);
|
|
|
|
static int usage();
|
|
|
|
|
|
/* Parent and child */
|
|
int main(int argc, char *argv[])
|
|
{
|
|
int command_pipe[2], reply_pipe[2];
|
|
pid_t cpid;
|
|
char *xorriso_path = "/usr/bin/xorriso";
|
|
|
|
if (argc > 1) {
|
|
if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "-help") == 0 ||
|
|
strcmp(argv[1], "--help") == 0) {
|
|
usage();
|
|
exit(0);
|
|
}
|
|
xorriso_path = argv[1];
|
|
}
|
|
|
|
if (pipe(command_pipe) == -1)
|
|
{ perror("pipe"); exit(1); }
|
|
if (pipe(reply_pipe) == -1)
|
|
{ perror("pipe"); exit(1); }
|
|
|
|
cpid = fork();
|
|
if (cpid == -1)
|
|
{ perror("fork"); exit(2); }
|
|
|
|
if (cpid == 0) {
|
|
/* Child redirects stdin and stdout. Then it becomes xorriso. */
|
|
|
|
char *xargv[8];
|
|
|
|
close(command_pipe[1]); /* Close unused write end */
|
|
close(reply_pipe[0]); /* Close unused read end */
|
|
|
|
/* Attach pipe ends to stdin and stdout */
|
|
close(0);
|
|
if (dup2(command_pipe[0], 0) == -1)
|
|
{ perror("dup2(,0)"); exit(1); }
|
|
close(1);
|
|
if (dup2(reply_pipe[1], 1) == -1)
|
|
{ perror("dup2(,1)"); exit(1); }
|
|
|
|
xargv[0] = xorriso_path;
|
|
xargv[1] = "-dialog";
|
|
xargv[2] = "on";
|
|
xargv[3] = "-pkt_output";
|
|
xargv[4] = "on";
|
|
xargv[5] = "-mark";
|
|
xargv[6] = "0"; /* corresponds to mark_count = 0 in parent */
|
|
xargv[7] = NULL;
|
|
execv(xorriso_path, xargv);
|
|
perror("execv"); exit(1);
|
|
|
|
} else {
|
|
/* Parent prompts user for command lines and prints xorriso replies.
|
|
It knows when all reply text of the pending command line has arrived
|
|
by watching for -mark reply pending_mark.
|
|
*/
|
|
|
|
int mark_count = 0, ret;
|
|
char pending_mark[16], line[4096];
|
|
struct parse_rules parse;
|
|
|
|
close(command_pipe[0]); /* Close unused read end */
|
|
close(reply_pipe[1]); /* Close unused write end */
|
|
|
|
memset(&parse, 0, sizeof(parse)); /* Disable parsing as default */
|
|
strcpy(parse.progname, argv[0]);
|
|
|
|
/* Dialog loop */
|
|
sprintf(pending_mark, "%d", mark_count);
|
|
while (1) {
|
|
|
|
/* Wait for pending mark and print all replies */
|
|
ret = await_all_replies(reply_pipe[0], pending_mark, &parse);
|
|
if (ret < 0)
|
|
break;
|
|
|
|
/* Prompt for command line */
|
|
ret = prompt_for_command(line, sizeof(line), &parse);
|
|
if (ret <= 0)
|
|
break;
|
|
|
|
/* Send line and -mark command */
|
|
ret = write(command_pipe[1], line, strlen(line));
|
|
if (ret == -1) {
|
|
perror("write");
|
|
break;
|
|
}
|
|
/* Produce new unique -mark text to watch for */
|
|
mark_count++;
|
|
sprintf(pending_mark, "%d", mark_count);
|
|
sprintf(line, "-mark %s\n", pending_mark);
|
|
ret = write(command_pipe[1], line, strlen(line));
|
|
if (ret == -1) {
|
|
perror("write");
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/* >>> if child is still operational: send -rollback_end */;
|
|
|
|
/* >>> wait a short while */;
|
|
|
|
/* >>> if not yet ended: kill child */;
|
|
|
|
wait(NULL); /* Wait for child */
|
|
exit(0);
|
|
}
|
|
}
|
|
|
|
|
|
/* ------------------- Local helpers of parent process -------------------- */
|
|
|
|
|
|
static int usage()
|
|
{
|
|
static char helptext[][80] = {
|
|
"usage: frontend_pipes_xorriso [path_to_xorriso|-h]",
|
|
"",
|
|
"Forks a process that runs xorriso and communicates with it via two pipes.",
|
|
"The command pipe sends payload commands and -mark commands. The reply pipe",
|
|
"receives -pkt_output lines which it dispatches to stdout and stderr.",
|
|
"The communication between both processes is made synchronous by the parent",
|
|
"awaiting the -mark message of the child.",
|
|
"Optionally the reply lines can be parsed into words. This is initiated by",
|
|
"meta command",
|
|
" @parse [prefix [separators [max_words [flag]]]]",
|
|
"which sets the four parameters for a function equivalent to",
|
|
"Xorriso_parse_line() (see xorriso.h). All reply will then be parsed and",
|
|
"non-empty word arrays are displayed. Meta command",
|
|
" @noparse",
|
|
"ends this mode.",
|
|
"@END@"
|
|
};
|
|
int i;
|
|
|
|
for (i = 0; strcmp(helptext[i], "@END@") != 0; i++)
|
|
fprintf(stderr, "%s\n", helptext[i]);
|
|
return(1);
|
|
}
|
|
|
|
|
|
static int show_parsed(struct parse_rules *parse, char *line)
|
|
{
|
|
int argc, ret = 0, i;
|
|
char **argv = NULL;
|
|
|
|
if (!parse->do_parse)
|
|
return(2);
|
|
ret = parse_line(parse->progname, line, parse->prefix, parse->separators,
|
|
parse->max_words, &argc, &argv, parse->flag);
|
|
if (ret <= 0 || argc <= 0)
|
|
return(0);
|
|
fprintf(stderr, "-----------------------------------------------------\n");
|
|
fprintf(stderr, "parse_line returns %d, argc = %d\n", ret, argc);
|
|
for (i = 0; i < argc; i++)
|
|
fprintf(stderr, "%2d : %s\n", i, argv[i]);
|
|
fprintf(stderr, "-----------------------------------------------------\n");
|
|
dispose_parsed_words(&argc, &argv); /* release memory */
|
|
return(1);
|
|
}
|
|
|
|
|
|
static int await_all_replies(int fd, char *pending_mark,
|
|
struct parse_rules *parse)
|
|
{
|
|
int count, remainder = 0;
|
|
char buf[32769], *line, *npt;
|
|
|
|
while (1) {
|
|
count = read(fd, buf + remainder, sizeof(buf) - 1 - remainder);
|
|
if (count == -1) {
|
|
perror("read");
|
|
return(-1);
|
|
}
|
|
if (count == 0) {
|
|
fprintf(stderr, "+++ EOF encounterd by Master process\n");
|
|
return(-2);
|
|
}
|
|
for (npt = buf + remainder; npt < buf + count; npt++) {
|
|
if (*npt == 0) {
|
|
fprintf(stderr,
|
|
"+++ Protocol error : Reply contains 0-chars\n");
|
|
return(-1);
|
|
}
|
|
}
|
|
|
|
/* Split buf into lines */
|
|
buf[remainder + count] = 0; /* for convenience */
|
|
line = buf;
|
|
while (1) {
|
|
npt = strchr(line, '\n');
|
|
if (npt == NULL) {
|
|
/* Move line to start of buffer and set remainder */
|
|
if (line != buf) {
|
|
remainder = 0;
|
|
for (npt = line; *npt; npt++)
|
|
buf[remainder++] = *npt;
|
|
}
|
|
/* Now read more data in the hope to get a newline char */
|
|
break;
|
|
}
|
|
/* Interpret line */
|
|
*npt = 0;
|
|
if (line[0] == 'M') {
|
|
/* M-replies will be outdated until the pending command line
|
|
is completely done and the appended -mark command gets
|
|
into effect.
|
|
*/
|
|
if (strlen(line) < 6) {
|
|
fprintf(stderr,
|
|
"+++ Protocol error : M-channel line shorter than 6 chars\n");
|
|
return(-1);
|
|
}
|
|
if (strcmp(line + 5, pending_mark) == 0) {
|
|
if ((line - buf) + strlen(line) + 1 < count) {
|
|
fprintf(stderr,
|
|
"+++ Protocol error : Surplus reply data after M-match\n");
|
|
fprintf(stderr, "%s\n", line + strlen(line) + 1);
|
|
return(-1);
|
|
}
|
|
return (1); /* Expected mark has arrived */
|
|
}
|
|
} else if (line[0] == 'R') {
|
|
/* R-replies are result lines of inquiry commands, like -ls.
|
|
They should be handled by specialized code which knows
|
|
how to parse and interpret them.
|
|
*/
|
|
printf("%s\n", line);
|
|
} else {
|
|
/* I-replies are pacifiers, notifications, warnings, or
|
|
error messages. They should be handled by a general
|
|
message interpreter which determines their severity
|
|
and decides whether to bother the user.
|
|
*/
|
|
fprintf(stderr, "%s\n", line);
|
|
}
|
|
|
|
/* Parse line and show words */
|
|
if (strlen(line) >= 5)
|
|
show_parsed(parse, line + 5);
|
|
|
|
line = npt + 1;
|
|
}
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
static int input_interpreter(char *line, struct parse_rules *parse)
|
|
{
|
|
int argc, ret = 0;
|
|
char **argv = NULL;
|
|
|
|
ret = parse_line(parse->progname, line, "", "", 6, &argc, &argv, 0);
|
|
if (ret <= 0 || argc <= 0)
|
|
return(0);
|
|
if (strcmp(argv[0], "@parse") == 0) {
|
|
parse->do_parse = 1;
|
|
parse->prefix[0] = 0;
|
|
if (argc > 1)
|
|
strcpy(parse->prefix, argv[1]);
|
|
parse->separators[0] = 0;
|
|
if (argc > 2)
|
|
strcpy(parse->separators, argv[2]);
|
|
parse->max_words = 0;
|
|
if (argc > 3)
|
|
sscanf(argv[3], "%d", &(parse->max_words));
|
|
parse->max_words = 0;
|
|
if (argc > 4)
|
|
sscanf(argv[4], "%d", &(parse->flag));
|
|
ret = 1;
|
|
} else if(strcmp(argv[0], "@noparse") == 0) {
|
|
parse->do_parse = 0;
|
|
ret = 1;
|
|
} else {
|
|
ret = 0;
|
|
}
|
|
dispose_parsed_words(&argc, &argv); /* release memory */
|
|
return ret;
|
|
}
|
|
|
|
|
|
static int prompt_for_command(char *line, int line_size,
|
|
struct parse_rules *parse)
|
|
{
|
|
int l, ret;
|
|
char *line_res;
|
|
|
|
while (1) {
|
|
fprintf(stderr, "+++ Enter a command and its parameters :\n");
|
|
line_res = fgets(line, line_size - 1, stdin);
|
|
if (line_res == NULL)
|
|
return(0);
|
|
l = strlen(line);
|
|
if (l == 0) {
|
|
line[0] = '\n';
|
|
line[1] = 0;
|
|
} else if (line[l - 1] != '\n') {
|
|
line[l] = '\n';
|
|
line[l + 1] = 0;
|
|
}
|
|
/* Interpret meta commands which begin by @ */
|
|
ret = input_interpreter(line, parse);
|
|
if (ret == 0)
|
|
return(1);
|
|
if (ret < 0)
|
|
return(-1);
|
|
}
|
|
}
|
|
|
|
|
|
/* -------- Line-to-word parser equivalent to Xorriso_parse_line() -------- */
|
|
|
|
|
|
static int Sfile_sep_make_argv(char *progname, char *line, char *separators,
|
|
int max_words, int *argc, char ***argv, int flag);
|
|
|
|
|
|
int parse_line(char *progname, char *line,
|
|
char *prefix, char *separators, int max_words,
|
|
int *argc, char ***argv, int flag)
|
|
{
|
|
int ret, bsl_mode;
|
|
char *to_parse;
|
|
|
|
*argc = 0;
|
|
*argv = NULL;
|
|
|
|
to_parse = line;
|
|
bsl_mode = (flag >> 1) & 15;
|
|
if (prefix[0]) {
|
|
if (strncmp(line, prefix, strlen(prefix)) == 0) {
|
|
to_parse = line + strlen(prefix);
|
|
} else {
|
|
ret = 2; goto ex;
|
|
}
|
|
}
|
|
ret = Sfile_sep_make_argv(progname, to_parse, separators,
|
|
max_words, argc, argv,
|
|
(!(flag & 32)) | 4 | (bsl_mode << 5));
|
|
if (ret < 0) {
|
|
fprintf(stderr,
|
|
"%s : Severe lack of resources during command line parsing\n",
|
|
progname);
|
|
goto ex;
|
|
}
|
|
if (ret == 0) {
|
|
fprintf(stderr,
|
|
"%s : Incomplete quotation in %s line: %s\n",
|
|
progname, (flag & 32) ? "command" : "parsed", to_parse);
|
|
goto ex;
|
|
}
|
|
ex:;
|
|
if (ret <= 0)
|
|
Sfile_sep_make_argv("", "", "", 0, argc, argv, 2); /* release memory */
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int dispose_parsed_words(int *argc, char ***argv)
|
|
{
|
|
Sfile_sep_make_argv("", "", "", 0, argc, argv, 2);
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* -------------- Some helpers copied from xorriso/sfile.c ----------------- */
|
|
|
|
|
|
static int Sfile_destroy_argv(int *argc, char ***argv, int flag)
|
|
{
|
|
int i;
|
|
|
|
if(*argc>0 && *argv!=NULL){
|
|
for(i=0;i<*argc;i++){
|
|
if((*argv)[i]!=NULL)
|
|
free((*argv)[i]);
|
|
}
|
|
free((char *) *argv);
|
|
}
|
|
*argc= 0;
|
|
*argv= NULL;
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* Converts backslash codes into single characters:
|
|
\a BEL 7 , \b BS 8 , \e ESC 27 , \f FF 12 , \n LF 10 , \r CR 13 ,
|
|
\t HT 9 , \v VT 11 , \\ \ 92
|
|
\[0-9][0-9][0-9] octal code , \x[0-9a-f][0-9a-f] hex code ,
|
|
\cX control-x (ascii(X)-64)
|
|
@param upto maximum number of characters to examine for backslash.
|
|
The scope of a backslash (0 to 3 characters) is not affected.
|
|
@param eaten returns the difference in length between input and output
|
|
@param flag bit0= only determine *eaten, do not convert
|
|
bit1= allow to convert \000 to binary 0
|
|
*/
|
|
static int Sfile_bsl_interpreter(char *text, int upto, int *eaten, int flag)
|
|
{
|
|
char *rpt, *wpt, num_text[8], wdummy[8];
|
|
unsigned int num= 0;
|
|
|
|
*eaten= 0;
|
|
wpt= text;
|
|
for(rpt= text; *rpt != 0 && rpt - text < upto; rpt++) {
|
|
if(flag & 1)
|
|
wpt= wdummy;
|
|
if(*rpt == '\\') {
|
|
rpt++;
|
|
(*eaten)++;
|
|
if(*rpt == 'a') {
|
|
*(wpt++)= 7;
|
|
} else if(*rpt == 'b') {
|
|
*(wpt++)= 8;
|
|
} else if(*rpt == 'e') {
|
|
*(wpt++)= 27;
|
|
} else if(*rpt == 'f') {
|
|
*(wpt++)= 12;
|
|
} else if(*rpt == 'n') {
|
|
*(wpt++)= 10;
|
|
} else if(*rpt == 'r') {
|
|
*(wpt++)= 13;
|
|
} else if(*rpt == 't') {
|
|
*(wpt++)= 9;
|
|
} else if(*rpt == 'v') {
|
|
*(wpt++)= 11;
|
|
} else if(*rpt == '\\') {
|
|
*(wpt++)= '\\';
|
|
} else if(rpt[0] >= '0' && rpt[0] <= '7' &&
|
|
rpt[1] >= '0' && rpt[1] <= '7' &&
|
|
rpt[2] >= '0' && rpt[2] <= '7') {
|
|
num_text[0]= '0';
|
|
num_text[1]= *(rpt + 0);
|
|
num_text[2]= *(rpt + 1);
|
|
num_text[3]= *(rpt + 2);
|
|
num_text[4]= 0;
|
|
sscanf(num_text, "%o", &num);
|
|
if((num > 0 || (flag & 2)) && num <= 255) {
|
|
rpt+= 2;
|
|
(*eaten)+= 2;
|
|
*(wpt++)= num;
|
|
} else
|
|
goto not_a_code;
|
|
} else if(rpt[0] == 'x' &&
|
|
((rpt[1] >= '0' && rpt[1] <= '9') ||
|
|
(rpt[1] >= 'A' && rpt[1] <= 'F') ||
|
|
(rpt[1] >= 'a' && rpt[1] <= 'f'))
|
|
&&
|
|
((rpt[2] >= '0' && rpt[2] <= '9') ||
|
|
(rpt[2] >= 'A' && rpt[2] <= 'F') ||
|
|
(rpt[2] >= 'a' && rpt[2] <= 'f'))
|
|
) {
|
|
num_text[0]= *(rpt + 1);
|
|
num_text[1]= *(rpt + 2);
|
|
num_text[2]= 0;
|
|
sscanf(num_text, "%x", &num);
|
|
if(num > 0 && num <= 255) {
|
|
rpt+= 2;
|
|
(*eaten)+= 2;
|
|
*(wpt++)= num;
|
|
} else
|
|
goto not_a_code;
|
|
} else if(*rpt == 'c') {
|
|
if(rpt[1] > 64 && rpt[1] < 96) {
|
|
*(wpt++)= rpt[1] - 64;
|
|
rpt++;
|
|
(*eaten)++;
|
|
} else
|
|
goto not_a_code;
|
|
} else {
|
|
not_a_code:;
|
|
*(wpt++)= '\\';
|
|
rpt--;
|
|
(*eaten)--;
|
|
}
|
|
} else
|
|
*(wpt++)= *rpt;
|
|
}
|
|
*wpt= *rpt;
|
|
return(1);
|
|
}
|
|
|
|
|
|
#define SfileadrL 4096
|
|
|
|
static int Sfile_sep_make_argv(char *progname, char *line, char *separators,
|
|
int max_words, int *argc, char ***argv, int flag)
|
|
/*
|
|
bit0= read progname as first argument from line
|
|
bit1= just release argument list argv and return
|
|
bit2= abort with return(0) if incomplete quotes are found
|
|
bit3= eventually prepend missing '-' to first argument read from line
|
|
bit4= like bit2 but only check quote completeness, do not allocate memory
|
|
bit5+6= interpretation of backslashes:
|
|
0= no interpretation, leave unchanged
|
|
1= only inside double quotes
|
|
2= outside single quotes
|
|
3= everywhere
|
|
bit7= append a NULL element to argv
|
|
*/
|
|
{
|
|
int i,pass,maxl=0,l,argzaehl=0,bufl,line_start_argc, bsl_mode, ret= 0, eaten;
|
|
char *cpt,*start;
|
|
char *buf= NULL;
|
|
|
|
Sfile_destroy_argv(argc,argv,0);
|
|
if(flag&2)
|
|
{ret= 1; goto ex;}
|
|
|
|
if(flag & 16)
|
|
flag|= 4;
|
|
bsl_mode= (flag >> 5) & 3;
|
|
|
|
buf= calloc(strlen(line) + SfileadrL, 1);
|
|
if(buf == NULL)
|
|
{ret= -1; goto ex;}
|
|
for(pass=0;pass<2;pass++) {
|
|
cpt= line-1;
|
|
if(!(flag&1)){
|
|
argzaehl= line_start_argc= 1;
|
|
if(pass==0)
|
|
maxl= strlen(progname);
|
|
else
|
|
strcpy((*argv)[0],progname);
|
|
} else {
|
|
argzaehl= line_start_argc= 0;
|
|
if(pass==0) maxl= 0;
|
|
}
|
|
while(*(++cpt)!=0){
|
|
if(*separators) {
|
|
if(strchr(separators, *cpt) != NULL)
|
|
continue;
|
|
} else if(isspace(*cpt))
|
|
continue;
|
|
start= cpt;
|
|
buf[0]= 0;
|
|
cpt--;
|
|
|
|
if(max_words > 0 && argzaehl >= max_words && *cpt != 0) {
|
|
/* take uninterpreted up to the end */
|
|
cpt+= strlen(cpt) - 1;
|
|
}
|
|
|
|
while(*(++cpt)!=0) {
|
|
if(*separators) {
|
|
if(strchr(separators, *cpt) != NULL)
|
|
break;
|
|
} else if(isspace(*cpt))
|
|
break;
|
|
if(*cpt=='"'){
|
|
l= cpt-start; bufl= strlen(buf);
|
|
if(l>0) {
|
|
strncpy(buf + bufl, start, l); buf[bufl + l]= 0;
|
|
if(bsl_mode >= 3) {
|
|
ret= Sfile_bsl_interpreter(buf, l, &eaten, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
}
|
|
}
|
|
l= strlen(buf);
|
|
start= cpt+1;
|
|
while(*(++cpt)!=0) if(*cpt=='"') break;
|
|
if((flag&4) && *cpt==0)
|
|
{ret= 0; goto ex;}
|
|
l= cpt-start; bufl= strlen(buf);
|
|
if(l>0) {
|
|
strncpy(buf + bufl, start, l);
|
|
buf[bufl + l]= 0;
|
|
if(bsl_mode >= 1) {
|
|
ret= Sfile_bsl_interpreter(buf + bufl, l, &eaten, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
}
|
|
}
|
|
start= cpt+1;
|
|
}else if(*cpt=='\''){
|
|
l= cpt-start; bufl= strlen(buf);
|
|
if(l>0) {
|
|
strncpy(buf + bufl, start, l); buf[bufl + l]= 0;
|
|
if(bsl_mode >= 3) {
|
|
ret= Sfile_bsl_interpreter(buf, l, &eaten, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
}
|
|
}
|
|
l= strlen(buf);
|
|
start= cpt+1;
|
|
while(*(++cpt)!=0) if(*cpt=='\'') break;
|
|
if((flag&4) && *cpt==0)
|
|
{ret= 0; goto ex;}
|
|
l= cpt-start; bufl= strlen(buf);
|
|
if(l>0) {
|
|
strncat(buf,start,l);buf[bufl+l]= 0;
|
|
if(bsl_mode >= 2) {
|
|
ret= Sfile_bsl_interpreter(buf + bufl, l, &eaten, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
}
|
|
}
|
|
start= cpt+1;
|
|
}
|
|
if(*cpt==0) break;
|
|
}
|
|
l= cpt-start;
|
|
bufl= strlen(buf);
|
|
if(l>0) {
|
|
strncpy(buf + bufl, start, l); buf[bufl + l]= 0;
|
|
if(bsl_mode >= 3) {
|
|
ret= Sfile_bsl_interpreter(buf, l, &eaten, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
}
|
|
}
|
|
l= strlen(buf);
|
|
if(pass==0){
|
|
if(argzaehl==line_start_argc && (flag&8))
|
|
if(buf[0]!='-' && buf[0]!=0 && buf[0]!='#')
|
|
l++;
|
|
if(l>maxl) maxl= l;
|
|
}else{
|
|
strcpy((*argv)[argzaehl],buf);
|
|
if(argzaehl==line_start_argc && (flag&8))
|
|
if(buf[0]!='-' && buf[0]!=0 && buf[0]!='#')
|
|
sprintf((*argv)[argzaehl],"-%s", buf);
|
|
}
|
|
argzaehl++;
|
|
if(*cpt==0) break;
|
|
}
|
|
if(pass==0){
|
|
if(flag & 16)
|
|
{ret= 1; goto ex;}
|
|
*argc= argzaehl;
|
|
if(argzaehl>0 || (flag & 128)) {
|
|
*argv= (char **) calloc((argzaehl + !!(flag & 128)), sizeof(char *));
|
|
if(*argv==NULL)
|
|
{ret= -1; goto ex;}
|
|
}
|
|
for(i=0;i<*argc;i++) {
|
|
(*argv)[i]= (char *) calloc(maxl + 1, 1);
|
|
if((*argv)[i]==NULL)
|
|
{ret= -1; goto ex;}
|
|
}
|
|
if(flag & 128)
|
|
(*argv)[*argc]= NULL;
|
|
}
|
|
}
|
|
ret= 1;
|
|
ex:
|
|
if(buf != NULL)
|
|
free(buf);
|
|
return(ret);
|
|
}
|
|
|