X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=findutils%2Fxargs.c;h=76d1d5489037a63aae2e7cc7c387ccca80287627;hb=d5fddcd57f4e692dd100121bb66adea8129fdbd6;hp=eef7c6909ce4d19e630ae7776bbca7c1cf343d68;hpb=27421a1878847389391c1a43420baaccf57057a7;p=oweals%2Fbusybox.git diff --git a/findutils/xargs.c b/findutils/xargs.c index eef7c6909..76d1d5489 100644 --- a/findutils/xargs.c +++ b/findutils/xargs.c @@ -1,3 +1,4 @@ +/* vi: set sw=4 ts=4: */ /* * Mini xargs implementation for busybox * Options are supported: "-prtx -n max_arg -s max_chars -e[ouf_str]" @@ -9,35 +10,17 @@ * - 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. - * - * 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 + * Licensed under the GPL v2 or later, see the file LICENSE in this tarball. * * 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 -#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. */ @@ -50,86 +33,69 @@ #ifdef TEST -# ifndef CONFIG_FEATURE_XARGS_SUPPORT_CONFIRMATION -# define CONFIG_FEATURE_XARGS_SUPPORT_CONFIRMATION +# ifndef ENABLE_FEATURE_XARGS_SUPPORT_CONFIRMATION +# define ENABLE_FEATURE_XARGS_SUPPORT_CONFIRMATION 1 # endif -# ifndef CONFIG_FEATURE_XARGS_SUPPORT_QUOTES -# define CONFIG_FEATURE_XARGS_SUPPORT_QUOTES +# ifndef ENABLE_FEATURE_XARGS_SUPPORT_QUOTES +# define ENABLE_FEATURE_XARGS_SUPPORT_QUOTES 1 # endif -# ifndef CONFIG_FEATURE_XARGS_SUPPORT_TERMOPT -# define CONFIG_FEATURE_XARGS_SUPPORT_TERMOPT +# ifndef ENABLE_FEATURE_XARGS_SUPPORT_TERMOPT +# define ENABLE_FEATURE_XARGS_SUPPORT_TERMOPT 1 # endif -# ifndef CONFIG_FEATURE_XARGS_SUPPORT_ZERO_TERM -# define CONFIG_FEATURE_XARGS_SUPPORT_ZERO_TERM +# 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 int xargs_exec(char *const *args) +static int xargs_exec(char **args) { - 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; - - 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 (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"); + 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; } -typedef struct xlist_s { - char *data; - size_t lenght; - struct xlist_s *link; +typedef struct xlist_t { + struct xlist_t *link; + size_t length; + char xstr[1]; } xlist_t; -static int eof_stdin_detected; +static smallint eof_stdin_detected; #define ISBLANK(c) ((c) == ' ' || (c) == '\t') -#define ISSPACE(c) (ISBLANK (c) || (c) == '\n' || (c) == '\r' \ +#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, +#if ENABLE_FEATURE_XARGS_SUPPORT_QUOTES +static xlist_t *process_stdin(xlist_t *list_arg, const char *eof_str, size_t mc, char *buf) { #define NORM 0 @@ -137,26 +103,28 @@ static xlist_t *process_stdin(xlist_t * list_arg, #define BACKSLASH 2 #define SPACE 4 - char *s = NULL; /* start word */ - char *p = NULL; /* pointer to end word */ - char q = 0; /* quote char */ + 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 */ + 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; + prev = cur = list_arg; + while (1) { + if (!cur) break; + prev = cur; + line_l += cur->length; + cur = cur->link; } while (!eof_stdin_detected) { c = getchar(); if (c == EOF) { - eof_stdin_detected++; + eof_stdin_detected = 1; if (s) goto unexpected_eof; break; @@ -167,19 +135,16 @@ static xlist_t *process_stdin(xlist_t * list_arg, state = NORM; goto set; } else if (state == QUOTE) { - if (c == q) { - q = 0; - state = NORM; - } else { + if (c != q) goto set; - } - } else { /* if(state == NORM) */ - + q = '\0'; + state = NORM; + } else { /* if (state == NORM) */ if (ISSPACE(c)) { if (s) { -unexpected_eof: + unexpected_eof: state = SPACE; - c = 0; + c = '\0'; goto set; } } else { @@ -191,36 +156,36 @@ unexpected_eof: q = c; state = QUOTE; } else { -set: - if ((p - buf) >= mc) + 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 (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; + eof_str_detected = (strcmp(s, eof_str) == 0); } if (!eof_str_detected) { - size_t lenght = (p - buf); - - cur = xmalloc(sizeof(xlist_t) + lenght); - cur->data = memcpy(cur + 1, s, lenght); - cur->lenght = lenght; + 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 += lenght; + line_l += length; if (line_l > mc) { /* stop memory usage :-) */ break; @@ -234,28 +199,30 @@ set: } #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) +static xlist_t *process_stdin(xlist_t *list_arg, + const char *eof_str, size_t mc, char *buf) { - 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 */ + 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; - for (prev = cur = list_arg; cur; cur = cur->link) { - line_l += cur->lenght; /* previous allocated */ - if (prev != cur) - prev = prev->link; + prev = cur = list_arg; + while (1) { + if (!cur) break; + prev = cur; + line_l += cur->length; + cur = cur->link; } while (!eof_stdin_detected) { c = getchar(); if (c == EOF) { - eof_stdin_detected++; + eof_stdin_detected = 1; } if (eof_str_detected) continue; @@ -266,28 +233,28 @@ static xlist_t *process_stdin(xlist_t * list_arg, } if (s == NULL) s = p = buf; - if ((p - buf) >= mc) + 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 */ + *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; + eof_str_detected = (strcmp(s, eof_str) == 0); } if (!eof_str_detected) { - size_t lenght = (p - buf); - - cur = xmalloc(sizeof(xlist_t) + lenght); - cur->data = memcpy(cur + 1, s, lenght); - cur->lenght = lenght; + 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 += lenght; + line_l += length; if (line_l > mc) { /* stop memory usage :-) */ break; @@ -298,92 +265,78 @@ static xlist_t *process_stdin(xlist_t * list_arg, } return list_arg; } -#endif /* CONFIG_FEATURE_XARGS_SUPPORT_QUOTES */ +#endif /* FEATURE_XARGS_SUPPORT_QUOTES */ -#ifdef CONFIG_FEATURE_XARGS_SUPPORT_CONFIRMATION +#if ENABLE_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. */ + otherwise, return false. Uses "/dev/tty", not stdin. */ static int xargs_ask_confirmation(void) { - static FILE *tty_stream; + 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); - } + 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); - if (savec == 'y' || savec == 'Y') - return 1; - return 0; + fclose(tty_stream); + return (savec == 'y' || savec == 'Y'); } - -# define OPT_INC_P 1 #else -# define OPT_INC_P 0 # define xargs_ask_confirmation() 1 -#endif /* CONFIG_FEATURE_XARGS_SUPPORT_CONFIRMATION */ +#endif /* FEATURE_XARGS_SUPPORT_CONFIRMATION */ -#ifdef CONFIG_FEATURE_XARGS_SUPPORT_TERMOPT -# define OPT_INC_X 1 -#else -# define OPT_INC_X 0 -#endif - -#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) +#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 */ + 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; + prev = cur = list_arg; + while (1) { + if (!cur) break; + prev = cur; + line_l += cur->length; + cur = cur->link; } while (!eof_stdin_detected) { c = getchar(); if (c == EOF) { - eof_stdin_detected++; + eof_stdin_detected = 1; if (s == NULL) break; - c = 0; + c = '\0'; } if (s == NULL) s = p = buf; - if ((p - buf) >= mc) + 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 */ + 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; + 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 += lenght; + line_l += length; if (line_l > mc) { /* stop memory usage :-) */ break; @@ -393,35 +346,40 @@ static xlist_t *process0_stdin(xlist_t * list_arg, const char *eof_str, } 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)) -*/ - +#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, a, n; + int i, n; xlist_t *list = NULL; xlist_t *cur; int child_error = 0; @@ -429,49 +387,46 @@ int xargs_main(int argc, char **argv) int n_max_arg; size_t n_chars = 0; long orig_arg_max; - const char *eof_str = "_"; - unsigned long opt; + const char *eof_str = NULL; + unsigned 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; +#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 -#ifdef CONFIG_FEATURE_XARGS_SUPPORT_CONFIRMATION - bb_opt_complementally = "pt"; -#endif + opt = getopt32(argv, OPTION_STR, &max_args, &max_chars, &eof_str, &eof_str); - 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); + /* -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++; } 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++) { + 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("can not fit single argument within argument list size limit"); + bb_error_msg_and_die("cannot fit single argument within argument list size limit"); } n_max_chars -= n_chars; } else { @@ -485,26 +440,21 @@ int xargs_main(int argc, char **argv) } max_chars = xmalloc(n_max_chars); - if ((opt & OPT_UPTO_NUMBER)) { - n_max_arg = bb_xgetularg10_bnd(max_args, 1, INT_MAX); + if (opt & OPT_UPTO_NUMBER) { + n_max_arg = xatoul_range(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 - - while ((list = READ_ARGS(list, eof_str, n_max_chars, max_chars)) != NULL || - (opt & OPT_NO_EMPTY) == 0) + 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; -#ifdef CONFIG_FEATURE_XARGS_SUPPORT_TERMOPT +#if ENABLE_FEATURE_XARGS_SUPPORT_TERMOPT for (cur = list; cur;) { - n_chars += cur->lenght; + n_chars += cur->length; n++; cur = cur->link; if (n_chars > n_max_chars || (n == n_max_arg && cur)) { @@ -515,43 +465,43 @@ int xargs_main(int argc, char **argv) } #else for (cur = list; cur; cur = cur->link) { - n_chars += cur->lenght; + n_chars += cur->length; n++; if (n_chars > n_max_chars || n == n_max_arg) { break; } } -#endif /* CONFIG_FEATURE_XARGS_SUPPORT_TERMOPT */ +#endif /* FEATURE_XARGS_SUPPORT_TERMOPT */ - /* allocating pointers for execvp: - a*arg, n*arg from stdin, NULL */ - args = xcalloc(n + a + 1, sizeof(char *)); + /* allocate pointers for execvp: + argc*arg, n*arg from stdin, NULL */ + args = xzalloc((n + argc + 1) * sizeof(char *)); - /* Store the command to be executed + /* store the command to be executed (taken from the command line) */ - for (i = 0; i < a; i++) + for (i = 0; i < argc; i++) args[i] = argv[i]; /* (taken from stdin) */ for (cur = list; n; cur = cur->link) { - args[i++] = cur->data; + args[i++] = cur->xstr; n--; } - if ((opt & (OPT_INTERACTIVE | OPT_VERBOSE))) { + if (opt & (OPT_INTERACTIVE | OPT_VERBOSE)) { for (i = 0; args[i]; i++) { if (i) fputc(' ', stderr); fputs(args[i], stderr); } - if ((opt & OPT_INTERACTIVE) == 0) + if (!(opt & OPT_INTERACTIVE)) fputc('\n', stderr); } - if ((opt & OPT_INTERACTIVE) == 0 || xargs_ask_confirmation() != 0) { + if (!(opt & OPT_INTERACTIVE) || xargs_ask_confirmation()) { child_error = xargs_exec(args); } /* clean up */ - for (i = a; args[i]; i++) { + for (i = argc; args[i]; i++) { cur = list; list = list->link; free(cur); @@ -560,23 +510,22 @@ int xargs_main(int argc, char **argv) if (child_error > 0 && child_error != 123) { break; } - } -#ifdef CONFIG_FEATURE_CLEAN_UP - free(max_chars); -#endif + } /* while */ + if (ENABLE_FEATURE_CLEAN_UP) + free(max_chars); return child_error; } #ifdef TEST -const char *bb_applet_name = "debug stuff usage"; +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", - bb_applet_name); - exit(1); + applet_name); + exit(EXIT_FAILURE); } int main(int argc, char **argv)