X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=findutils%2Fxargs.c;h=76d1d5489037a63aae2e7cc7c387ccca80287627;hb=d5fddcd57f4e692dd100121bb66adea8129fdbd6;hp=27f83350f3bc5cfdaf9ce7bc4e86cdc6731b4c4f;hpb=add3eadc4691a1870980abb925a7424e13fde344;p=oweals%2Fbusybox.git diff --git a/findutils/xargs.c b/findutils/xargs.c index 27f83350f..76d1d5489 100644 --- a/findutils/xargs.c +++ b/findutils/xargs.c @@ -1,220 +1,535 @@ +/* vi: set sw=4 ts=4: */ /* * Mini xargs implementation for busybox - * Only "-prt" options are supported in this version of xargs. + * Options are supported: "-prtx -n max_arg -s max_chars -e[ouf_str]" * - * (C) 2002 by Vladimir Oleynik - * (C) 2003 by Glenn McGrath + * (C) 2002,2003 by Vladimir Oleynik * - * Special thanks Mark Whitley for stimul to rewrote :) + * Special thanks + * - Mark Whitley and Glenn McGrath for stimulus to rewrite :) + * - Mike Rendell + * and David MacKenzie . * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. + * Licensed under the GPL v2 or later, see the file LICENSE in this tarball. * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * - * - * Reference: - * http://www.opengroup.org/onlinepubs/007904975/utilities/xargs.html - * - * - * BUGS: - * p option doesnt accept user input, should read input from /dev/tty - * - * E option doesnt allow spaces before argument - * - * xargs should terminate if an invocation of a constructed command line - * returns an exit status of 255. - * - * exit value of isnt correct - * - * doesnt print quoted string properly + * xargs is described in the Single Unix Specification v3 at + * http://www.opengroup.org/onlinepubs/007904975/utilities/xargs.html * */ -#include -#include -#include -#include -#include -#include -#include -#include -#include "busybox.h" +#include "libbb.h" + +/* This is a NOEXEC applet. Be very careful! */ + + +/* COMPAT: SYSV version defaults size (and has a max value of) to 470. + We try to make it as large as possible. */ +#if !defined(ARG_MAX) && defined(_SC_ARG_MAX) +#define ARG_MAX sysconf (_SC_ARG_MAX) +#endif +#ifndef ARG_MAX +#define ARG_MAX 470 +#endif + + +#ifdef TEST +# ifndef ENABLE_FEATURE_XARGS_SUPPORT_CONFIRMATION +# define ENABLE_FEATURE_XARGS_SUPPORT_CONFIRMATION 1 +# endif +# ifndef ENABLE_FEATURE_XARGS_SUPPORT_QUOTES +# define ENABLE_FEATURE_XARGS_SUPPORT_QUOTES 1 +# endif +# ifndef ENABLE_FEATURE_XARGS_SUPPORT_TERMOPT +# define ENABLE_FEATURE_XARGS_SUPPORT_TERMOPT 1 +# endif +# ifndef ENABLE_FEATURE_XARGS_SUPPORT_ZERO_TERM +# define ENABLE_FEATURE_XARGS_SUPPORT_ZERO_TERM 1 +# endif +#endif /* - This function have special algorithm. - Don`t use fork and include to main! + This function has special algorithm. + Don't use fork and include to main! */ -static void xargs_exec(char * const * args) +static int xargs_exec(char **args) { - int p; - int common[4]; /* shared vfork stack */ - - common[0] = 0; - if ((p = vfork()) >= 0) { - if (p == 0) { - /* vfork -- child */ - execvp(args[0], args); - common[0] = errno; /* set error to shared stack */ - _exit(1); - } else { - /* vfork -- parent */ - wait(NULL); - if(common[0]) { - errno = common[0]; - bb_perror_msg_and_die("%s", args[0]); - } - } - } else { - bb_perror_msg_and_die("vfork"); + int status; + + status = spawn_and_wait(args); + if (status < 0) { + bb_simple_perror_msg(args[0]); + return errno == ENOENT ? 127 : 126; + } + if (status == 255) { + bb_error_msg("%s: exited with status 255; aborting", args[0]); + return 124; + } +/* Huh? I think we won't see this, ever. We don't wait with WUNTRACED! + if (WIFSTOPPED(status)) { + bb_error_msg("%s: stopped by signal %d", + args[0], WSTOPSIG(status)); + return 125; + } +*/ + if (status >= 1000) { + bb_error_msg("%s: terminated by signal %d", + args[0], status - 1000); + return 125; } + if (status) + return 123; + return 0; } -#define OPT_VERBOSE 0x2 -#define OPT_INTERACTIVE 0x4 -#define OPT_TERMINATE 0x8 -#define OPT_UPTO_NUMBER 0x10 -#define OPT_UPTO_SIZE 0x20 -#define OPT_EOF_STRING 0x40 -int xargs_main(int argc, char **argv) +typedef struct xlist_t { + struct xlist_t *link; + size_t length; + char xstr[1]; +} xlist_t; + +static smallint eof_stdin_detected; + +#define ISBLANK(c) ((c) == ' ' || (c) == '\t') +#define ISSPACE(c) (ISBLANK(c) || (c) == '\n' || (c) == '\r' \ + || (c) == '\f' || (c) == '\v') + +#if ENABLE_FEATURE_XARGS_SUPPORT_QUOTES +static xlist_t *process_stdin(xlist_t *list_arg, + const char *eof_str, size_t mc, char *buf) { - char *s_max_args = NULL; - char *s_line_size = NULL; - unsigned long flg; +#define NORM 0 +#define QUOTE 1 +#define BACKSLASH 2 +#define SPACE 4 - char *eof_string = "_"; - int line_size = LINE_MAX; - unsigned int max_args = LINE_MAX / 2; + char *s = NULL; /* start word */ + char *p = NULL; /* pointer to end word */ + char q = '\0'; /* quote char */ + char state = NORM; + char eof_str_detected = 0; + size_t line_l = 0; /* size loaded args line */ + int c; /* current char */ + xlist_t *cur; + xlist_t *prev; - char *line_buffer = NULL; - char *line_buffer_ptr_ptr; - char *old_arg = NULL; + prev = cur = list_arg; + while (1) { + if (!cur) break; + prev = cur; + line_l += cur->length; + cur = cur->link; + } - char **args; - char *args_entry_ptr; + while (!eof_stdin_detected) { + c = getchar(); + if (c == EOF) { + eof_stdin_detected = 1; + if (s) + goto unexpected_eof; + break; + } + if (eof_str_detected) + continue; + if (state == BACKSLASH) { + state = NORM; + goto set; + } else if (state == QUOTE) { + if (c != q) + goto set; + q = '\0'; + state = NORM; + } else { /* if (state == NORM) */ + if (ISSPACE(c)) { + if (s) { + unexpected_eof: + state = SPACE; + c = '\0'; + goto set; + } + } else { + if (s == NULL) + s = p = buf; + if (c == '\\') { + state = BACKSLASH; + } else if (c == '\'' || c == '"') { + q = c; + state = QUOTE; + } else { + set: + if ((size_t)(p - buf) >= mc) + bb_error_msg_and_die("argument line too long"); + *p++ = c; + } + } + } + if (state == SPACE) { /* word's delimiter or EOF detected */ + if (q) { + bb_error_msg_and_die("unmatched %s quote", + q == '\'' ? "single" : "double"); + } + /* word loaded */ + if (eof_str) { + eof_str_detected = (strcmp(s, eof_str) == 0); + } + if (!eof_str_detected) { + size_t length = (p - buf); + /* Dont xzalloc - it can be quite big */ + cur = xmalloc(offsetof(xlist_t, xstr) + length); + cur->link = NULL; + cur->length = length; + memcpy(cur->xstr, s, length); + if (prev == NULL) { + list_arg = cur; + } else { + prev->link = cur; + } + prev = cur; + line_l += length; + if (line_l > mc) { + /* stop memory usage :-) */ + break; + } + } + s = NULL; + state = NORM; + } + } + return list_arg; +} +#else +/* The variant does not support single quotes, double quotes or backslash */ +static xlist_t *process_stdin(xlist_t *list_arg, + const char *eof_str, size_t mc, char *buf) +{ - int i; - int a; + int c; /* current char */ + char eof_str_detected = 0; + char *s = NULL; /* start word */ + char *p = NULL; /* pointer to end word */ + size_t line_l = 0; /* size loaded args line */ + xlist_t *cur; + xlist_t *prev; - - bb_opt_complementaly = "pt"; + prev = cur = list_arg; + while (1) { + if (!cur) break; + prev = cur; + line_l += cur->length; + cur = cur->link; + } - flg = bb_getopt_ulflags(argc, argv, "+tpxn:s:E::", &s_max_args, &s_line_size, &eof_string); + while (!eof_stdin_detected) { + c = getchar(); + if (c == EOF) { + eof_stdin_detected = 1; + } + if (eof_str_detected) + continue; + if (c == EOF || ISSPACE(c)) { + if (s == NULL) + continue; + c = EOF; + } + if (s == NULL) + s = p = buf; + if ((size_t)(p - buf) >= mc) + bb_error_msg_and_die("argument line too long"); + *p++ = (c == EOF ? '\0' : c); + if (c == EOF) { /* word's delimiter or EOF detected */ + /* word loaded */ + if (eof_str) { + eof_str_detected = (strcmp(s, eof_str) == 0); + } + if (!eof_str_detected) { + size_t length = (p - buf); + /* Dont xzalloc - it can be quite big */ + cur = xmalloc(offsetof(xlist_t, xstr) + length); + cur->link = NULL; + cur->length = length; + memcpy(cur->xstr, s, length); + if (prev == NULL) { + list_arg = cur; + } else { + prev->link = cur; + } + prev = cur; + line_l += length; + if (line_l > mc) { + /* stop memory usage :-) */ + break; + } + s = NULL; + } + } + } + return list_arg; +} +#endif /* FEATURE_XARGS_SUPPORT_QUOTES */ - if (s_max_args) { - max_args = bb_xgetularg10(s_max_args); + +#if ENABLE_FEATURE_XARGS_SUPPORT_CONFIRMATION +/* Prompt the user for a response, and + if the user responds affirmatively, return true; + otherwise, return false. Uses "/dev/tty", not stdin. */ +static int xargs_ask_confirmation(void) +{ + FILE *tty_stream; + int c, savec; + + tty_stream = xfopen_for_read(CURRENT_TTY); + fputs(" ?...", stderr); + fflush(stderr); + c = savec = getc(tty_stream); + while (c != EOF && c != '\n') + c = getc(tty_stream); + fclose(tty_stream); + return (savec == 'y' || savec == 'Y'); +} +#else +# define xargs_ask_confirmation() 1 +#endif /* FEATURE_XARGS_SUPPORT_CONFIRMATION */ + +#if ENABLE_FEATURE_XARGS_SUPPORT_ZERO_TERM +static xlist_t *process0_stdin(xlist_t *list_arg, + const char *eof_str UNUSED_PARAM, size_t mc, char *buf) +{ + int c; /* current char */ + char *s = NULL; /* start word */ + char *p = NULL; /* pointer to end word */ + size_t line_l = 0; /* size loaded args line */ + xlist_t *cur; + xlist_t *prev; + + prev = cur = list_arg; + while (1) { + if (!cur) break; + prev = cur; + line_l += cur->length; + cur = cur->link; } - if (s_line_size) { - line_size = bb_xgetularg10(s_line_size); + + while (!eof_stdin_detected) { + c = getchar(); + if (c == EOF) { + eof_stdin_detected = 1; + if (s == NULL) + break; + c = '\0'; + } + if (s == NULL) + s = p = buf; + if ((size_t)(p - buf) >= mc) + bb_error_msg_and_die("argument line too long"); + *p++ = c; + if (c == '\0') { /* word's delimiter or EOF detected */ + /* word loaded */ + size_t length = (p - buf); + /* Dont xzalloc - it can be quite big */ + cur = xmalloc(offsetof(xlist_t, xstr) + length); + cur->link = NULL; + cur->length = length; + memcpy(cur->xstr, s, length); + if (prev == NULL) { + list_arg = cur; + } else { + prev->link = cur; + } + prev = cur; + line_l += length; + if (line_l > mc) { + /* stop memory usage :-) */ + break; + } + s = NULL; + } } + return list_arg; +} +#endif /* FEATURE_XARGS_SUPPORT_ZERO_TERM */ + +/* Correct regardless of combination of CONFIG_xxx */ +enum { + OPTBIT_VERBOSE = 0, + OPTBIT_NO_EMPTY, + OPTBIT_UPTO_NUMBER, + OPTBIT_UPTO_SIZE, + OPTBIT_EOF_STRING, + OPTBIT_EOF_STRING1, + IF_FEATURE_XARGS_SUPPORT_CONFIRMATION(OPTBIT_INTERACTIVE,) + IF_FEATURE_XARGS_SUPPORT_TERMOPT( OPTBIT_TERMINATE ,) + IF_FEATURE_XARGS_SUPPORT_ZERO_TERM( OPTBIT_ZEROTERM ,) + + OPT_VERBOSE = 1 << OPTBIT_VERBOSE , + OPT_NO_EMPTY = 1 << OPTBIT_NO_EMPTY , + OPT_UPTO_NUMBER = 1 << OPTBIT_UPTO_NUMBER, + OPT_UPTO_SIZE = 1 << OPTBIT_UPTO_SIZE , + OPT_EOF_STRING = 1 << OPTBIT_EOF_STRING , /* GNU: -e[] */ + OPT_EOF_STRING1 = 1 << OPTBIT_EOF_STRING1, /* SUS: -E */ + OPT_INTERACTIVE = IF_FEATURE_XARGS_SUPPORT_CONFIRMATION((1 << OPTBIT_INTERACTIVE)) + 0, + OPT_TERMINATE = IF_FEATURE_XARGS_SUPPORT_TERMOPT( (1 << OPTBIT_TERMINATE )) + 0, + OPT_ZEROTERM = IF_FEATURE_XARGS_SUPPORT_ZERO_TERM( (1 << OPTBIT_ZEROTERM )) + 0, +}; +#define OPTION_STR "+trn:s:e::E:" \ + IF_FEATURE_XARGS_SUPPORT_CONFIRMATION("p") \ + IF_FEATURE_XARGS_SUPPORT_TERMOPT( "x") \ + IF_FEATURE_XARGS_SUPPORT_ZERO_TERM( "0") + +int xargs_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; +int xargs_main(int argc, char **argv) +{ + char **args; + int i, n; + xlist_t *list = NULL; + xlist_t *cur; + int child_error = 0; + char *max_args, *max_chars; + int n_max_arg; + size_t n_chars = 0; + long orig_arg_max; + const char *eof_str = NULL; + unsigned opt; + size_t n_max_chars; +#if ENABLE_FEATURE_XARGS_SUPPORT_ZERO_TERM + xlist_t* (*read_args)(xlist_t*, const char*, size_t, char*) = process_stdin; +#else +#define read_args process_stdin +#endif + + opt = getopt32(argv, OPTION_STR, &max_args, &max_chars, &eof_str, &eof_str); + + /* -E ""? You may wonder why not just omit -E? + * This is used for portability: + * old xargs was using "_" as default for -E / -e */ + if ((opt & OPT_EOF_STRING1) && eof_str[0] == '\0') + eof_str = NULL; + + if (opt & OPT_ZEROTERM) + IF_FEATURE_XARGS_SUPPORT_ZERO_TERM(read_args = process0_stdin); - a = argc - optind; argv += optind; - if(a==0) { + argc -= optind; + if (!argc) { /* default behavior is to echo all the filenames */ - *argv = "echo"; - a++; + *argv = (char*)"echo"; + argc++; } - /* allocating pointers for execvp: a*arg, arg from stdin, NULL */ - args = xcalloc(a + 2, sizeof(char *)); - /* Store the command to be executed (taken from the command line) */ - for (i = 0; i < a; i++) { - line_size -= strlen(*argv) + 1; - args[i] = *argv++; - } - if (line_size < 1) { - bb_error_msg_and_die("can not fit single argument within argument list size limit"); + orig_arg_max = ARG_MAX; + if (orig_arg_max == -1) + orig_arg_max = LONG_MAX; + orig_arg_max -= 2048; /* POSIX.2 requires subtracting 2048 */ + + if (opt & OPT_UPTO_SIZE) { + n_max_chars = xatoul_range(max_chars, 1, orig_arg_max); + for (i = 0; i < argc; i++) { + n_chars += strlen(*argv) + 1; + } + if (n_max_chars < n_chars) { + bb_error_msg_and_die("cannot fit single argument within argument list size limit"); + } + n_max_chars -= n_chars; + } else { + /* Sanity check for systems with huge ARG_MAX defines (e.g., Suns which + have it at 1 meg). Things will work fine with a large ARG_MAX but it + will probably hurt the system more than it needs to; an array of this + size is allocated. */ + if (orig_arg_max > 20 * 1024) + orig_arg_max = 20 * 1024; + n_max_chars = orig_arg_max; } + max_chars = xmalloc(n_max_chars); - args[i] = xmalloc(line_size); - args_entry_ptr = args[i]; - - /* Now, read in one line at a time from stdin, and store this - * line to be used later as an argument to the command */ - do { - char *line_buffer_ptr = NULL; - unsigned int arg_count = 0; - unsigned int arg_size = 0; - - *args_entry_ptr = '\0'; - - /* Get the required number of entries from stdin */ - do { - /* (Re)fill the line buffer */ - if (line_buffer == NULL) { - line_buffer = bb_get_chomped_line_from_file(stdin); - if (line_buffer == NULL) { - /* EOF, exit outer loop */ - break; - } - line_buffer_ptr = strtok_r(line_buffer, " \t", &line_buffer_ptr_ptr); - } else { - if (old_arg) { - line_buffer_ptr = old_arg; - old_arg = NULL; - } else { - line_buffer_ptr = strtok_r(NULL, " \t", &line_buffer_ptr_ptr); - } - } - /* If no arguments left go back and get another line */ - if (line_buffer_ptr == NULL) { - free(line_buffer); - line_buffer = NULL; - continue; - } + if (opt & OPT_UPTO_NUMBER) { + n_max_arg = xatoul_range(max_args, 1, INT_MAX); + } else { + n_max_arg = n_max_chars; + } - if (eof_string && (strcmp(line_buffer_ptr, eof_string) == 0)) { - /* logical EOF, exit outer loop */ - line_buffer = NULL; + while ((list = read_args(list, eof_str, n_max_chars, max_chars)) != NULL || + !(opt & OPT_NO_EMPTY)) + { + opt |= OPT_NO_EMPTY; + n = 0; + n_chars = 0; +#if ENABLE_FEATURE_XARGS_SUPPORT_TERMOPT + for (cur = list; cur;) { + n_chars += cur->length; + n++; + cur = cur->link; + if (n_chars > n_max_chars || (n == n_max_arg && cur)) { + if (opt & OPT_TERMINATE) + bb_error_msg_and_die("argument list too long"); break; } - - /* Check the next argument will fit */ - arg_size += 1 + strlen(line_buffer_ptr); - if (arg_size > line_size) { - if ((arg_count == 0) || ((flg & OPT_TERMINATE) && (arg_count != max_args))){ - bb_error_msg_and_die("argument line too long"); - } - old_arg = line_buffer_ptr; + } +#else + for (cur = list; cur; cur = cur->link) { + n_chars += cur->length; + n++; + if (n_chars > n_max_chars || n == n_max_arg) { break; } + } +#endif /* FEATURE_XARGS_SUPPORT_TERMOPT */ - /* Add the entry to our pre-allocated space */ - strcat(args_entry_ptr, line_buffer_ptr); - strcat(args_entry_ptr, " "); - arg_count++; - } while (arg_count < max_args); - - if (*args_entry_ptr != '\0') { - if(flg & (OPT_VERBOSE | OPT_INTERACTIVE)) { - for(i=0; args[i]; i++) { - if(i) - fputc(' ', stderr); - fputs(args[i], stderr); - } + /* allocate pointers for execvp: + argc*arg, n*arg from stdin, NULL */ + args = xzalloc((n + argc + 1) * sizeof(char *)); - fputs(((flg & OPT_INTERACTIVE) ? " ?..." : "\n"), stderr); - } + /* store the command to be executed + (taken from the command line) */ + for (i = 0; i < argc; i++) + args[i] = argv[i]; + /* (taken from stdin) */ + for (cur = list; n; cur = cur->link) { + args[i++] = cur->xstr; + n--; + } - if((flg & OPT_INTERACTIVE) == 0 || bb_ask_confirmation() != 0 ) { - xargs_exec(args); + if (opt & (OPT_INTERACTIVE | OPT_VERBOSE)) { + for (i = 0; args[i]; i++) { + if (i) + fputc(' ', stderr); + fputs(args[i], stderr); } + if (!(opt & OPT_INTERACTIVE)) + fputc('\n', stderr); + } + if (!(opt & OPT_INTERACTIVE) || xargs_ask_confirmation()) { + child_error = xargs_exec(args); } - } while (line_buffer); -#ifdef CONFIG_FEATURE_CLEAN_UP - free(args); -#endif - return 0; + /* clean up */ + for (i = argc; args[i]; i++) { + cur = list; + list = list->link; + free(cur); + } + free(args); + if (child_error > 0 && child_error != 123) { + break; + } + } /* while */ + if (ENABLE_FEATURE_CLEAN_UP) + free(max_chars); + return child_error; +} + + +#ifdef TEST + +const char *applet_name = "debug stuff usage"; + +void bb_show_usage(void) +{ + fprintf(stderr, "Usage: %s [-p] [-r] [-t] -[x] [-n max_arg] [-s max_chars]\n", + applet_name); + exit(EXIT_FAILURE); +} + +int main(int argc, char **argv) +{ + return xargs_main(argc, argv); } +#endif /* TEST */