From 61796945e37a6cd9dd230e8e7a86536ad58fcd14 Mon Sep 17 00:00:00 2001 From: Glenn L McGrath Date: Fri, 10 Oct 2003 12:10:18 +0000 Subject: Vods versions of xargs --- findutils/xargs.c | 701 +++++++++++++++++++++++++++++++++++++++--------------- 1 file changed, 510 insertions(+), 191 deletions(-) (limited to 'findutils/xargs.c') diff --git a/findutils/xargs.c b/findutils/xargs.c index 1af42384b..8bab44623 100644 --- a/findutils/xargs.c +++ b/findutils/xargs.c @@ -1,11 +1,13 @@ /* * 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 stimul to rewrote :) + * - 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 @@ -21,15 +23,6 @@ * 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: - * - E option doesnt allow spaces before argument - * - exit value of isnt correct - * - doesnt print quoted string properly */ #include @@ -38,224 +31,550 @@ #include #include #include +#include #include #include - #include "busybox.h" +/* 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 CONFIG_FEATURE_XARGS_SUPPORT_CONFIRMATION +# define CONFIG_FEATURE_XARGS_SUPPORT_CONFIRMATION +# endif +# ifndef CONFIG_FEATURE_XARGS_SUPPORT_QUOTES +# define CONFIG_FEATURE_XARGS_SUPPORT_QUOTES +# endif +# ifndef CONFIG_FEATURE_XARGS_SUPPORT_TERMOPT +# define CONFIG_FEATURE_XARGS_SUPPORT_TERMOPT +# endif +# ifndef CONFIG_FEATURE_XARGS_SUPPORT_ZERO_TERM +# define CONFIG_FEATURE_XARGS_SUPPORT_ZERO_TERM +# endif +#endif + /* This function have special algorithm. Don`t use fork and include to main! */ -static int xargs_exec(char **args) +static int +xargs_exec (char *const *args) { - pid_t p; - volatile int exec_errno; /* shared vfork stack */ - - exec_errno = 0; - p = vfork(); - if (p < 0) { - bb_perror_msg_and_die("vfork"); - } else if (p == 0) { - /* vfork -- child */ - execvp(args[0], args); - exec_errno = errno; /* set error to shared stack */ - _exit(1); + pid_t p; + volatile int exec_errno = 0; /* shared vfork stack */ + + if ((p = vfork ()) >= 0) { + if (p == 0) { + /* vfork -- child */ + execvp (args[0], args); + exec_errno = errno; /* set error to shared stack */ + _exit (1); } else { - /* vfork -- parent */ - int status; + /* vfork -- parent */ + int status; - while (wait(&status) == (pid_t) - 1) { - if (errno != EINTR) { - break; - } + while (wait (&status) == (pid_t) - 1) + if (errno != EINTR) + break; + if (exec_errno) { + errno = exec_errno; + bb_perror_msg ("%s", args[0]); + return exec_errno == ENOENT ? 127 : 126; + } else { + if (WEXITSTATUS (status) == 255) { + bb_error_msg ("%s: exited with status 255; aborting", args[0]); + return 124; } - - if (exec_errno) { - errno = exec_errno; - bb_perror_msg("%s", args[0]); - return exec_errno == ENOENT ? 127 : 126; - } else if (WEXITSTATUS(status) == 255) { - bb_error_msg("%s: exited with status 255; aborting", args[0]); - return 124; - } else if (WIFSTOPPED(status)) { - bb_error_msg("%s: stopped by signal %d", args[0], - WSTOPSIG(status)); - return 125; - } else if (WIFSIGNALED(status)) { - bb_error_msg("%s: terminated by signal %d", args[0], - WTERMSIG(status)); - return 125; - } else if (WEXITSTATUS(status)) { - return 123; - } else { - return 0; + if (WIFSTOPPED (status)) { + bb_error_msg ("%s: stopped by signal %d", args[0], + WSTOPSIG (status)); + return 125; + } + if (WIFSIGNALED (status)) { + bb_error_msg ("%s: terminated by signal %d", args[0], + WTERMSIG (status)); + return 125; } + if (WEXITSTATUS (status) != 0) + return 123; + return 0; + } } + } else { + bb_perror_msg_and_die ("vfork"); + } } -#define OPT_VERBOSE 0x1 -#define OPT_TERMINATE 0x2 -#define OPT_UPTO_NUMBER 0x4 -#define OPT_UPTO_SIZE 0x8 -#define OPT_EOF_STRING 0x10 -int xargs_main(int argc, char **argv) +typedef struct xlist_s { + char *data; + size_t lenght; + struct xlist_s *link; +} xlist_t; + +static int eof_stdin_detected; + +#define ISBLANK(c) ((c) == ' ' || (c) == '\t') +#define ISSPACE(c) (ISBLANK (c) || (c) == '\n' || (c) == '\r' \ + || (c) == '\f' || (c) == '\v') + +#ifdef CONFIG_FEATURE_XARGS_SUPPORT_QUOTES +static xlist_t * +process_stdin (xlist_t *list_arg, const char *eof_str, size_t mc, char *buf) { -#ifdef CONFIG_FEATURE_XARGS_FANCY - char *s_max_args = NULL; - char *s_line_size = NULL; -#endif - char *eof_string = "_"; - unsigned long flg; +#define NORM 0 +#define QUOTE 1 +#define BACKSLASH 2 +#define SPACE 4 + + 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; + + for(prev = cur = list_arg; cur; cur = cur->link) { + line_l += cur->lenght; /* previous allocated */ + if(prev != cur) + prev = prev->link; + } + + while(!eof_stdin_detected) { + c = getchar(); + if(c == EOF) { + eof_stdin_detected++; + 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) { + q = 0; + state = NORM; + } else { + goto set; + } + } 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( (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 lenght = (p-buf); - int line_size; - unsigned int max_args = LINE_MAX; + cur = xmalloc(sizeof(xlist_t) + lenght); + cur->data = memcpy(cur + 1, s, lenght); + cur->lenght = lenght; + cur->link = NULL; + if(prev == NULL) { + list_arg = cur; + } else { + prev->link = cur; + } + prev = cur; + line_l += lenght; + if(line_l > mc) { + /* stop memory usage :-) */ + break; + } + } + s = NULL; + state = NORM; + } + } + return list_arg; +} +#else +/* The variant is unsupport single, double quotes and backslash */ +static xlist_t * +process_stdin (xlist_t *list_arg, const char *eof_str, size_t mc, char *buf) +{ - char *line_buffer = NULL; - char *line_buffer_ptr_ptr; - char *old_arg = NULL; + int c; /* current char */ + int 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; - char **args; - char *args_entry_ptr; + for(prev = cur = list_arg; cur; cur = cur->link) { + line_l += cur->lenght; /* previous allocated */ + if(prev != cur) + prev = prev->link; + } - int i; - int a; + while(!eof_stdin_detected) { + c = getchar(); + if(c == EOF) { + eof_stdin_detected++; + } + if(eof_str_detected) + continue; + if (c == EOF || ISSPACE (c)) { + if(s == NULL) + continue; + c = EOF; + } + if (s == NULL) + s = p = buf; + if( (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 lenght = (p-buf); -#if 0 - /* Default to maximum line length */ - if (LINE_MAX > ARG_MAX - 2048) { - /* Minimum command line length */ - line_size = LINE_MAX; - } else { - /* Maximum command line length */ - line_size = ARG_MAX = 2048; + cur = xmalloc(sizeof(xlist_t) + lenght); + cur->data = memcpy(cur + 1, s, lenght); + cur->lenght = lenght; + cur->link = NULL; + if(prev == NULL) { + list_arg = cur; + } else { + prev->link = cur; + } + prev = cur; + line_l += lenght; + if(line_l > mc) { + /* stop memory usage :-) */ + break; + } + s = NULL; + } } + } + return list_arg; +} +#endif /* CONFIG_FEATURE_XARGS_SUPPORT_QUOTES */ + + +#ifdef CONFIG_FEATURE_XARGS_SUPPORT_CONFIRMATION +/* Prompt the user for a response, and + if the user responds affirmatively, return true; + otherwise, return false. Used "/dev/tty", not stdin. */ +static int +xargs_ask_confirmation (void) +{ + static FILE *tty_stream; + int c, savec; + + if (!tty_stream) { + tty_stream = fopen ("/dev/tty", "r"); + if (!tty_stream) + bb_perror_msg_and_die ("/dev/tty"); + /* pranoidal security by vodz */ + fcntl(fileno(tty_stream), F_SETFD, FD_CLOEXEC); + } + fputs (" ?...", stderr); + fflush (stderr); + c = savec = getc (tty_stream); + while (c != EOF && c != '\n') + c = getc (tty_stream); + if (savec == 'y' || savec == 'Y') + return 1; + return 0; +} +# define OPT_INC_P 1 #else - line_size = LINE_MAX; -#endif - -#ifndef CONFIG_FEATURE_XARGS_FANCY - flg = bb_getopt_ulflags(argc, argv, "+t"); +# define OPT_INC_P 0 +# define xargs_ask_confirmation() 1 +#endif /* CONFIG_FEATURE_XARGS_SUPPORT_CONFIRMATION */ + +#ifdef CONFIG_FEATURE_XARGS_SUPPORT_TERMOPT +# define OPT_INC_X 1 #else - flg = bb_getopt_ulflags(argc, argv, "+txn:s:E::", &s_max_args, &s_line_size, &eof_string); +# define OPT_INC_X 0 +#endif - if (s_line_size) { - line_size = bb_xgetularg10_bnd(s_max_args, 1, line_size); +#ifdef CONFIG_FEATURE_XARGS_SUPPORT_ZERO_TERM +static xlist_t * +process0_stdin (xlist_t *list_arg, const char *eof_str, 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; + + for(prev = cur = list_arg; cur; cur = cur->link) { + line_l += cur->lenght; /* previous allocated */ + if(prev != cur) + prev = prev->link; + } + + while(!eof_stdin_detected) { + c = getchar(); + if(c == EOF) { + eof_stdin_detected++; + if(s == NULL) + break; + c = 0; } - if (s_max_args) { - max_args = bb_xgetularg10(s_max_args); + if (s == NULL) + s = p = buf; + if( (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 lenght = (p-buf); + + cur = xmalloc(sizeof(xlist_t) + lenght); + cur->data = memcpy(cur + 1, s, lenght); + cur->lenght = lenght; + cur->link = NULL; + if(prev == NULL) { + list_arg = cur; + } else { + prev->link = cur; + } + prev = cur; + line_l += lenght; + if(line_l > mc) { + /* stop memory usage :-) */ + break; + } + s = NULL; } + } + return list_arg; +} +# define READ_ARGS(l, e, nmc, mc) (*read_args)(l, e, nmc, mc) +# define OPT_INC_0 1 /* future use */ +#else +# define OPT_INC_0 0 /* future use */ +# define READ_ARGS(l, e, nmc, mc) process_stdin(l, e, nmc, mc) +#endif /* CONFIG_FEATURE_XARGS_SUPPORT_ZERO_TERM */ + + +#define OPT_VERBOSE (1<<0) +#define OPT_NO_EMPTY (1<<1) +#define OPT_UPTO_NUMBER (1<<2) +#define OPT_UPTO_SIZE (1<<3) +#define OPT_EOF_STRING (1<<4) +#ifdef CONFIG_FEATURE_XARGS_SUPPORT_CONFIRMATION +#define OPT_INTERACTIVE (1<<5) +#else +#define OPT_INTERACTIVE (0) /* require for algorithm &| */ #endif +#define OPT_TERMINATE (1<<(5+OPT_INC_P)) +#define OPT_ZEROTERM (1<<(5+OPT_INC_P+OPT_INC_X)) +/* next future +#define OPT_NEXT_OTHER (1<<(5+OPT_INC_P+OPT_INC_X+OPT_INC_0)) +*/ - a = argc - optind; - argv += optind; - if (a == 0) { - /* default behavior is to echo all the filenames */ - *argv = "echo"; - a++; - } - /* allocating pointers for execvp: a*arg, arg from stdin, NULL */ - args = xcalloc(a + 2, sizeof(char *)); +int +xargs_main (int argc, char **argv) +{ + char **args; + int i, a, 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 = "_"; + unsigned long opt; + size_t n_max_chars; +#ifdef CONFIG_FEATURE_XARGS_SUPPORT_ZERO_TERM + xlist_t * (*read_args) (xlist_t *, const char *, size_t, char *) = process_stdin; +#endif - /* Store the command to be executed (taken from the command line) */ +#ifdef CONFIG_FEATURE_XARGS_SUPPORT_CONFIRMATION + bb_opt_complementaly = "pt"; +#endif + + opt = bb_getopt_ulflags (argc, argv, "+trn:s:e::" +#ifdef CONFIG_FEATURE_XARGS_SUPPORT_CONFIRMATION + "p" +#endif +#ifdef CONFIG_FEATURE_XARGS_SUPPORT_TERMOPT + "x" +#endif +#ifdef CONFIG_FEATURE_XARGS_SUPPORT_ZERO_TERM + "0" +#endif + , &max_args, &max_chars, &eof_str); + + a = argc - optind; + argv += optind; + if (a == 0) { + /* default behavior is to echo all the filenames */ + *argv = "echo"; + a++; + } + + 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 = bb_xgetularg10_bnd (max_chars, 1, orig_arg_max); for (i = 0; i < a; i++) { - line_size -= strlen(*argv) + 1; - args[i] = *argv++; + n_chars += strlen (*argv) + 1; } - if (line_size < 1) { - bb_error_msg_and_die("can not fit single argument within argument list size limit"); + if (n_max_chars < n_chars) { + bb_error_msg_and_die + ("can not 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; - } - -#ifdef CONFIG_FEATURE_XARGS_FANCY - if (eof_string && (strcmp(line_buffer_ptr, eof_string) == 0)) { -#else - if (strcmp(line_buffer_ptr, eof_string) == 0) { + if ((opt & OPT_UPTO_NUMBER)) { + n_max_arg = bb_xgetularg10_bnd (max_args, 1, INT_MAX); + } else { + n_max_arg = n_max_chars; + } + +#ifdef CONFIG_FEATURE_XARGS_SUPPORT_ZERO_TERM + if(opt & OPT_ZEROTERM) + read_args = process0_stdin; #endif - /* logical EOF, exit outer loop */ - line_buffer = NULL; - break; - } - - /* Check the next argument will fit */ - arg_size += 1 + strlen(line_buffer_ptr); - if (arg_size > line_size) { - if ((arg_count == 0) -#ifdef CONFIG_FEATURE_XARGS_FANCY - || ((flg & OPT_TERMINATE) && (arg_count != max_args))) { + + while ((list = READ_ARGS(list, eof_str, n_max_chars, max_chars)) != NULL + || (opt & OPT_NO_EMPTY) == 0) { + opt |= OPT_NO_EMPTY; + n = 0; + n_chars = 0; +#ifdef CONFIG_FEATURE_XARGS_SUPPORT_TERMOPT + for (cur = list; cur; ) { + n_chars += cur->lenght; + 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; + } + } #else - ) { -#endif - bb_error_msg_and_die("argument line too long"); - } - old_arg = line_buffer_ptr; - break; - } - - /* 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); - - /* Remove the last space */ - args_entry_ptr[arg_size - 1] = '\0'; - - if (*args_entry_ptr != '\0') { - if (flg & OPT_VERBOSE) { - for (i = 0; args[i]; i++) { - if (i) { - fputc(' ', stderr); - } - fputs(args[i], stderr); - } - fputc('\n', stderr); - } - xargs_exec(args); + for (cur = list; cur; cur = cur->link) { + n_chars += cur->lenght; + n++; + if (n_chars > n_max_chars || n == n_max_arg) { + break; + } + } +#endif /* CONFIG_FEATURE_XARGS_SUPPORT_TERMOPT */ + + /* allocating pointers for execvp: + a*arg, n*arg from stdin, NULL */ + args = xcalloc (n + a + 1, sizeof (char *)); + + /* Store the command to be executed + (taken from the command line) */ + for (i = 0; i < a; i++) + args[i] = argv[i]; + /* (taken from stdin) */ + for (cur = list; n; cur = cur->link) { + args[i++] = cur->data; + n--; + } + + if ((opt & (OPT_INTERACTIVE|OPT_VERBOSE))) { + for (i = 0; args[i]; i++) { + if (i) + fputc (' ', stderr); + fputs (args[i], stderr); } - } while (line_buffer); + if((opt & OPT_INTERACTIVE) == 0) + fputc ('\n', stderr); + } + if ((opt & OPT_INTERACTIVE) == 0 || xargs_ask_confirmation () != 0) { + child_error = xargs_exec (args); + } + /* clean up */ + for (i = a; args[i]; i++) { + cur = list; + list = list->link; + free (cur); + } + free (args); + if (child_error > 0 && child_error != 123) { + break; + } + } #ifdef CONFIG_FEATURE_CLEAN_UP - free(args); + free(max_chars); #endif - return 0; + return child_error; +} + + +#ifdef TEST + +const char *bb_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", bb_applet_name); + exit(1); +} + +int main(int argc, char **argv) +{ + return xargs_main(argc, argv); } +#endif /* TEST */ -- cgit v1.2.3