/* vi: set sw=4 ts=4: */ /* * Mini xargs implementation for busybox * Options are supported: "-prtx -n max_arg -s max_chars -e[ouf_str]" * * (C) 2002,2003 by Vladimir Oleynik * * Special thanks * - Mark Whitley and Glenn McGrath for stimulus to rewrite :) * - Mike Rendell * and David MacKenzie . * * 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 "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 has special algorithm. Don't use fork and include to main! */ static int xargs_exec(char *const *args) { pid_t p; volatile int exec_errno = 0; /* shared vfork stack */ int status; p = vfork(); if (p < 0) bb_perror_msg_and_die("vfork"); if (p == 0) { /* vfork -- child */ BB_EXECVP(args[0], args); exec_errno = errno; /* set error to shared stack */ _exit(1); } /* vfork -- parent */ 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; } 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)) return 123; return 0; } 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) { #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 ((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 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; 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 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; 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 (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); 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 = xfopen(CURRENT_TTY, "r"); /* 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; } #else # define xargs_ask_confirmation() 1 #endif /* CONFIG_FEATURE_XARGS_SUPPORT_CONFIRMATION */ #ifdef CONFIG_FEATURE_XARGS_SUPPORT_ZERO_TERM static xlist_t *process0_stdin(xlist_t * list_arg, const char *eof_str ATTRIBUTE_UNUSED, 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 == 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 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; } #endif /* CONFIG_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, USE_FEATURE_XARGS_SUPPORT_CONFIRMATION(OPTBIT_INTERACTIVE,) USE_FEATURE_XARGS_SUPPORT_TERMOPT( OPTBIT_TERMINATE ,) USE_FEATURE_XARGS_SUPPORT_ZERO_TERM( OPTBIT_ZEROTERM ,) OPT_VERBOSE = 1< 20 * 1024) orig_arg_max = 20 * 1024; n_max_chars = orig_arg_max; } max_chars = xmalloc(n_max_chars); if (opt & OPT_UPTO_NUMBER) { n_max_arg = xatoul_range(max_args, 1, INT_MAX); } else { n_max_arg = n_max_chars; } 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 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 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 */ /* allocate pointers for execvp: argc*arg, n*arg from stdin, NULL */ args = xzalloc((n + argc + 1) * sizeof(char *)); /* 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->data; n--; } 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); } /* 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; } } 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(1); } int main(int argc, char **argv) { return xargs_main(argc, argv); } #endif /* TEST */