| |
| /* 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> |
| |
| |
| 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.", |
| "Meta command", |
| " @drain_sieve", |
| "reports all recorded results of all installed message sieve filter rules.", |
| "For illustration perform this xorriso command sequence", |
| " -msg_op start_sieve - -outdev /dev/sr0 -msg_op clear_sieve - -toc", |
| "and then @drain_sieve.", |
| "@END@" |
| }; |
| int i; |
| |
| for (i = 0; strcmp(helptext[i], "@END@") != 0; i++) |
| fprintf(stderr, "%s\n", helptext[i]); |
| return(1); |
| } |
| |
| |
| /* Local helpers of parent process */ |
| |
| struct boss_state { |
| /* What the parent needs to know about its connection to xorriso */ |
| |
| /* The ends of the dialog pipes */ |
| int command_fd; |
| int reply_fd; |
| |
| /* For synchronization between boss and xorriso */ |
| int mark_count; |
| char pending_mark[16]; |
| |
| /* 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; |
| |
| /* A primitive catcher for result lines */ |
| int reply_lines_size; /* 0= catching disabled */ |
| char **reply_lines; |
| int reply_lines_count; |
| }; |
| |
| #define Frontend_xorriso_max_resulT 1000 |
| |
| |
| /* Some basic gestures of this program: */ |
| |
| static int prompt_for_command(struct boss_state *boss, |
| char *line, int line_size); |
| |
| static int transmit_command(struct boss_state *boss, char *line); |
| |
| static int await_all_replies(struct boss_state *boss); |
| |
| static int de_pkt_result(struct boss_state *boss); |
| |
| static int drain_sieve(struct boss_state *boss); |
| |
| 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); |
| |
| |
| |
| /* 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 ret; |
| char line[4096]; |
| struct boss_state boss; |
| |
| close(command_pipe[0]); /* Close unused read end */ |
| close(reply_pipe[1]); /* Close unused write end */ |
| |
| memset(&boss, 0, sizeof(boss)); |
| boss.command_fd = command_pipe[1]; |
| boss.reply_fd = reply_pipe[0]; |
| strcpy(boss.progname, argv[0]); |
| boss.reply_lines = NULL; |
| |
| /* Dialog loop */ |
| sprintf(boss.pending_mark, "%d", boss.mark_count); |
| while (1) { |
| |
| /* Wait for pending mark and print all replies */ |
| ret = await_all_replies(&boss); |
| if (ret < 0) |
| break; |
| |
| /* Prompt for command line */ |
| ret = prompt_for_command(&boss, line, sizeof(line)); |
| if (ret <= 0) |
| break; |
| |
| /* Send line and -mark command */ |
| ret = transmit_command(&boss, line); |
| if (ret <= 0) |
| 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 show_parsed(struct boss_state *boss, char *line); |
| static int record_reply_line(struct boss_state *boss, char *line); |
| static int make_reply_lines(struct boss_state *boss); |
| static int input_interpreter(char *line, struct boss_state *boss); |
| |
| |
| /* Ask the user for command input and trigger processing of meta commands. |
| */ |
| static int prompt_for_command(struct boss_state *boss, |
| char *line, int line_size) |
| { |
| 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, boss); |
| if (ret == 0) |
| return(1); |
| if (ret < 0) |
| return(-1); |
| } |
| } |
| |
| |
| /* Transmit a command (which must end by white space, e.g. newline) |
| and its unique synchronization mark. |
| */ |
| static int transmit_command(struct boss_state *boss, char *line) |
| { |
| int ret; |
| char mark_line[32]; |
| |
| ret = write(boss->command_fd, line, strlen(line)); |
| if (ret == -1) { |
| perror("write"); |
| return(0); |
| } |
| /* Produce new unique -mark text to watch for */ |
| (boss->mark_count)++; |
| sprintf(boss->pending_mark, "%d", boss->mark_count); |
| sprintf(mark_line, "-mark %s\n", boss->pending_mark); |
| ret = write(boss->command_fd, mark_line, strlen(mark_line)); |
| if (ret == -1) { |
| perror("write"); |
| return(0); |
| } |
| return(1); |
| } |
| |
| |
| /* Read reply messages from xorriso and wait for the expected synchronization |
| mark. Messages can be printed or collected in boss->reply_lines. |
| */ |
| static int await_all_replies(struct boss_state *boss) |
| { |
| int count, remainder = 0, ret; |
| char buf[32769], *line, *npt; |
| |
| while (1) { |
| count = read(boss->reply_fd, buf + remainder, |
| sizeof(buf) - 1 - remainder); |
| if (count == -1) { |
| perror("read"); |
| return(-1); |
| } |
| if (count == 0) { |
| fprintf(stderr, "+++ EOF encountered 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, boss->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. |
| */ |
| if (boss->reply_lines_count < boss->reply_lines_size) { |
| ret = record_reply_line(boss, line); |
| if (ret <= 0) |
| return(ret); |
| } else |
| 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. |
| */ |
| if (boss->reply_lines_count < boss->reply_lines_size) { |
| ret = record_reply_line(boss, line); |
| if (ret <= 0) |
| return(ret); |
| } else |
| fprintf(stderr, "%s\n", line); |
| } |
| |
| /* Parse line and show words */ |
| if (strlen(line) >= 5) |
| show_parsed(boss, line + 5); |
| |
| line = npt + 1; |
| } |
| } |
| return(1); |
| } |
| |
| |
| /* Throw away I channel. |
| Unpack and reconstruct payload of R channel lines. |
| */ |
| static int de_pkt_result(struct boss_state *boss) |
| { |
| int i, l, w; |
| char *payload = NULL, *new_payload = NULL; |
| |
| w = 0; |
| for (i = 0; i < boss->reply_lines_count; i++) { |
| if (boss->reply_lines[i][0] != 'R' || |
| strlen(boss->reply_lines[i]) < 5) |
| continue; |
| |
| if (payload == NULL) { |
| payload = strdup(boss->reply_lines[i] + 5); |
| } else { |
| l = strlen(payload); |
| new_payload = calloc(l + strlen(boss->reply_lines[i] + 5) + 1, 1); |
| if (new_payload == NULL) |
| goto no_mem; |
| strcpy(new_payload, payload); |
| strcpy(new_payload + l, boss->reply_lines[i] + 5); |
| free(payload); |
| payload = new_payload; |
| } |
| if (payload == NULL) |
| goto no_mem; |
| l = strlen(payload); |
| if (l > 0) |
| if (payload[l - 1] == '\n') |
| payload[l - 1] = 0; |
| |
| if (boss->reply_lines[i][2] != '0') { |
| free(boss->reply_lines[w]); |
| boss->reply_lines[w] = payload; |
| w++; |
| payload = NULL; |
| } |
| } |
| for (i = w ; i < boss->reply_lines_count; i++) { |
| free(boss->reply_lines[i]); |
| boss->reply_lines[i] = NULL; |
| } |
| boss->reply_lines_count = w; |
| return(1); |
| no_mem:; |
| fprintf(stderr, "FATAL: Out of memory !\n"); |
| return(-1); |
| } |
| |
| |
| /* Inquire and print all recorded message sieve results. |
| */ |
| static int drain_sieve(struct boss_state *boss) |
| { |
| int ret, i, j, names_size = 0, names_count = 0, first_result; |
| int number_of_strings, available, xorriso_ret, number_of_lines, k, r; |
| char **names = NULL, line[1024]; |
| |
| /* Install catcher for reply_lines */ |
| ret = make_reply_lines(boss); |
| if (ret <= 0) |
| goto ex; |
| boss->reply_lines_size = Frontend_xorriso_max_resulT; |
| boss->reply_lines_count = 0; |
| |
| /* Get list of filter rule names from -msg_op show_sieve */ |
| ret = transmit_command(boss, "-msg_op show_sieve -\n"); |
| if (ret <= 0) |
| goto ex; |
| ret = await_all_replies(boss); |
| if (ret <= 0) |
| goto ex; |
| ret = de_pkt_result(boss); |
| if (ret <= 0) |
| goto ex; |
| |
| names = boss->reply_lines; |
| boss->reply_lines = NULL; |
| names_size = Frontend_xorriso_max_resulT; |
| names_count= boss->reply_lines_count; |
| ret = make_reply_lines(boss); |
| if (ret <= 0) |
| goto ex; |
| boss->reply_lines_size = Frontend_xorriso_max_resulT; |
| |
| /* Inquire caught results of each name by -msg_op read_sieve |
| until return value is <= 0 |
| */ |
| printf("--------------------------------------------------\n"); |
| for (i = 0; i < names_count; i++) { |
| available = 1; |
| first_result = 1; |
| while (available > 0) { |
| boss->reply_lines_count = 0; |
| sprintf(line, "-msg_op read_sieve '%s'\n", names[i]); |
| ret = transmit_command(boss, line); |
| if (ret <= 0) |
| goto ex; |
| ret = await_all_replies(boss); |
| if (ret <= 0) |
| goto ex; |
| ret = de_pkt_result(boss); |
| if (ret <= 0) |
| goto ex; |
| |
| if (boss->reply_lines_count < 2) { |
| fprintf(stderr, "drain_sieve: illegible result reply\n"); |
| {ret= 0; goto ex;} |
| } |
| xorriso_ret = -1; |
| sscanf(boss->reply_lines[0], "%d", &xorriso_ret); |
| if(xorriso_ret <= 0) |
| break; |
| number_of_strings = -1; |
| sscanf(boss->reply_lines[1], "%d", &number_of_strings); |
| if(xorriso_ret < 0) |
| break; |
| if (first_result) |
| printf(" '%s' |\n", names[i]); |
| first_result = 0; |
| for (j = 0; names[i][j] != 0; j++) |
| printf("-"); |
| printf("-----\n"); |
| r = 2; |
| for (j = 0; j < number_of_strings && r < boss->reply_lines_count; |
| j++) { |
| number_of_lines = -1; |
| sscanf(boss->reply_lines[r], "%d", &number_of_lines); |
| r++; |
| printf("|"); |
| for (k = 0; k < number_of_lines |
| && r < boss->reply_lines_count; k++) { |
| printf("%s%s", boss->reply_lines[r], |
| k < number_of_lines - 1 ? "\n" : ""); |
| r++; |
| } |
| printf("|\n"); |
| } |
| } |
| if (first_result == 0) |
| printf("--------------------------------------------------\n"); |
| } |
| |
| /* Dispose all recorded results */ |
| ret = transmit_command(boss, "-msg_op clear_sieve -\n"); |
| if (ret <= 0) |
| goto ex; |
| ret = await_all_replies(boss); |
| if (ret <= 0) |
| goto ex; |
| |
| ret = 1; |
| ex:; |
| /* Disable result catcher */ |
| boss->reply_lines_size = 0; |
| if (names != NULL) |
| dispose_parsed_words(&names_size, &names); |
| return(ret); |
| } |
| |
| |
| /* ------------------------- Helpers of local helpers ---------------------- */ |
| |
| |
| static int show_parsed(struct boss_state *boss, char *line) |
| { |
| int argc, ret = 0, i; |
| char **argv = NULL; |
| |
| if (!boss->do_parse) |
| return(2); |
| ret = parse_line(boss->progname, line, boss->prefix, boss->separators, |
| boss->max_words, &argc, &argv, boss->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 make_reply_lines(struct boss_state *boss) |
| { |
| int i; |
| |
| if (boss->reply_lines != NULL) |
| return(1); |
| |
| boss->reply_lines = calloc(Frontend_xorriso_max_resulT, |
| sizeof(char *)); |
| if (boss->reply_lines == 0) { |
| fprintf(stderr, "FATAL: Out of memory !\n"); |
| return(-1); |
| } |
| boss->reply_lines_count = 0; |
| boss->reply_lines_size = 0; |
| for (i = 0; i < Frontend_xorriso_max_resulT; i++) |
| boss->reply_lines[i] = NULL; |
| return(1); |
| } |
| |
| |
| static int record_reply_line(struct boss_state *boss, char *line) |
| { |
| if (boss->reply_lines[boss->reply_lines_count] != NULL) |
| free(boss->reply_lines[boss->reply_lines_count]); |
| boss->reply_lines[boss->reply_lines_count] = strdup(line); |
| if (boss->reply_lines[boss->reply_lines_count] == NULL) { |
| fprintf(stderr, "FATAL: Out of memory !\n"); |
| return(-1); |
| } |
| boss->reply_lines_count++; |
| return(1); |
| } |
| |
| |
| static int input_interpreter(char *line, struct boss_state *boss) |
| { |
| int argc, ret = 0; |
| char **argv = NULL; |
| |
| ret = parse_line(boss->progname, line, "", "", 6, &argc, &argv, 0); |
| if (ret <= 0 || argc <= 0) |
| return(0); |
| if (strcmp(argv[0], "@parse") == 0) { |
| boss->do_parse = 1; |
| boss->prefix[0] = 0; |
| if (argc > 1) |
| strcpy(boss->prefix, argv[1]); |
| boss->separators[0] = 0; |
| if (argc > 2) |
| strcpy(boss->separators, argv[2]); |
| boss->max_words = 0; |
| if (argc > 3) |
| sscanf(argv[3], "%d", &(boss->max_words)); |
| boss->max_words = 0; |
| if (argc > 4) |
| sscanf(argv[4], "%d", &(boss->flag)); |
| ret = 1; |
| } else if(strcmp(argv[0], "@noparse") == 0) { |
| boss->do_parse = 0; |
| ret = 1; |
| } else if(strcmp(argv[0], "@drain_sieve") == 0) { |
| ret= drain_sieve(boss); |
| } else { |
| ret = 0; |
| } |
| dispose_parsed_words(&argc, &argv); /* release memory */ |
| return ret; |
| } |
| |
| |
| /* -------- 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= 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); |
| } |
| |
