source: MondoRescue/branches/3.0/mindi-busybox/findutils/xargs.c@ 2899

Last change on this file since 2899 was 2725, checked in by Bruno Cornec, 13 years ago
  • Update mindi-busybox to 1.18.3 to avoid problems with the tar command which is now failing on recent versions with busybox 1.7.3
File size: 14.3 KB
Line 
1/* vi: set sw=4 ts=4: */
2/*
3 * Mini xargs implementation for busybox
4 *
5 * (C) 2002,2003 by Vladimir Oleynik <dzo@simtreas.ru>
6 *
7 * Special thanks
8 * - Mark Whitley and Glenn McGrath for stimulus to rewrite :)
9 * - Mike Rendell <michael@cs.mun.ca>
10 * and David MacKenzie <djm@gnu.ai.mit.edu>.
11 *
12 * Licensed under GPLv2 or later, see file LICENSE in this source tree.
13 *
14 * xargs is described in the Single Unix Specification v3 at
15 * http://www.opengroup.org/onlinepubs/007904975/utilities/xargs.html
16 */
17
18//applet:IF_XARGS(APPLET_NOEXEC(xargs, xargs, _BB_DIR_USR_BIN, _BB_SUID_DROP, xargs))
19
20//kbuild:lib-$(CONFIG_XARGS) += xargs.o
21
22//config:config XARGS
23//config: bool "xargs"
24//config: default y
25//config: help
26//config: xargs is used to execute a specified command for
27//config: every item from standard input.
28//config:
29//config:config FEATURE_XARGS_SUPPORT_CONFIRMATION
30//config: bool "Enable -p: prompt and confirmation"
31//config: default y
32//config: depends on XARGS
33//config: help
34//config: Support -p: prompt the user whether to run each command
35//config: line and read a line from the terminal.
36//config:
37//config:config FEATURE_XARGS_SUPPORT_QUOTES
38//config: bool "Enable single and double quotes and backslash"
39//config: default y
40//config: depends on XARGS
41//config: help
42//config: Support quoting in the input.
43//config:
44//config:config FEATURE_XARGS_SUPPORT_TERMOPT
45//config: bool "Enable -x: exit if -s or -n is exceeded"
46//config: default y
47//config: depends on XARGS
48//config: help
49//config: Support -x: exit if the command size (see the -s or -n option)
50//config: is exceeded.
51//config:
52//config:config FEATURE_XARGS_SUPPORT_ZERO_TERM
53//config: bool "Enable -0: NUL-terminated input"
54//config: default y
55//config: depends on XARGS
56//config: help
57//config: Support -0: input items are terminated by a NUL character
58//config: instead of whitespace, and the quotes and backslash
59//config: are not special.
60
61#include "libbb.h"
62
63/* This is a NOEXEC applet. Be very careful! */
64
65
66//#define dbg_msg(...) bb_error_msg(__VA_ARGS__)
67#define dbg_msg(...) ((void)0)
68
69
70#ifdef TEST
71# ifndef ENABLE_FEATURE_XARGS_SUPPORT_CONFIRMATION
72# define ENABLE_FEATURE_XARGS_SUPPORT_CONFIRMATION 1
73# endif
74# ifndef ENABLE_FEATURE_XARGS_SUPPORT_QUOTES
75# define ENABLE_FEATURE_XARGS_SUPPORT_QUOTES 1
76# endif
77# ifndef ENABLE_FEATURE_XARGS_SUPPORT_TERMOPT
78# define ENABLE_FEATURE_XARGS_SUPPORT_TERMOPT 1
79# endif
80# ifndef ENABLE_FEATURE_XARGS_SUPPORT_ZERO_TERM
81# define ENABLE_FEATURE_XARGS_SUPPORT_ZERO_TERM 1
82# endif
83#endif
84
85
86struct globals {
87 char **args;
88 const char *eof_str;
89 int idx;
90} FIX_ALIASING;
91#define G (*(struct globals*)&bb_common_bufsiz1)
92#define INIT_G() do { } while (0)
93
94
95/*
96 * This function has special algorithm.
97 * Don't use fork and include to main!
98 */
99static int xargs_exec(void)
100{
101 int status;
102
103 status = spawn_and_wait(G.args);
104 if (status < 0) {
105 bb_simple_perror_msg(G.args[0]);
106 return errno == ENOENT ? 127 : 126;
107 }
108 if (status == 255) {
109 bb_error_msg("%s: exited with status 255; aborting", G.args[0]);
110 return 124;
111 }
112 if (status >= 0x180) {
113 bb_error_msg("%s: terminated by signal %d",
114 G.args[0], status - 0x180);
115 return 125;
116 }
117 if (status)
118 return 123;
119 return 0;
120}
121
122/* In POSIX/C locale isspace is only these chars: "\t\n\v\f\r" and space.
123 * "\t\n\v\f\r" happen to have ASCII codes 9,10,11,12,13.
124 */
125#define ISSPACE(a) ({ unsigned char xargs__isspace = (a) - 9; xargs__isspace == (' ' - 9) || xargs__isspace <= (13 - 9); })
126
127static void store_param(char *s)
128{
129 /* Grow by 256 elements at once */
130 if (!(G.idx & 0xff)) { /* G.idx == N*256 */
131 /* Enlarge, make G.args[(N+1)*256 - 1] last valid idx */
132 G.args = xrealloc(G.args, sizeof(G.args[0]) * (G.idx + 0x100));
133 }
134 G.args[G.idx++] = s;
135}
136
137/* process[0]_stdin:
138 * Read characters into buf[n_max_chars+1], and when parameter delimiter
139 * is seen, store the address of a new parameter to args[].
140 * If reading discovers that last chars do not form the complete
141 * parameter, the pointer to the first such "tail character" is returned.
142 * (buf has extra byte at the end to accomodate terminating NUL
143 * of "tail characters" string).
144 * Otherwise, the returned pointer points to NUL byte.
145 * On entry, buf[] may contain some "seed chars" which are to become
146 * the beginning of the first parameter.
147 */
148
149#if ENABLE_FEATURE_XARGS_SUPPORT_QUOTES
150static char* FAST_FUNC process_stdin(int n_max_chars, int n_max_arg, char *buf)
151{
152#define NORM 0
153#define QUOTE 1
154#define BACKSLASH 2
155#define SPACE 4
156 char q = '\0'; /* quote char */
157 char state = NORM;
158 char *s = buf; /* start of the word */
159 char *p = s + strlen(buf); /* end of the word */
160
161 buf += n_max_chars; /* past buffer's end */
162
163 /* "goto ret" is used instead of "break" to make control flow
164 * more obvious: */
165
166 while (1) {
167 int c = getchar();
168 if (c == EOF) {
169 if (p != s)
170 goto close_word;
171 goto ret;
172 }
173 if (state == BACKSLASH) {
174 state = NORM;
175 goto set;
176 }
177 if (state == QUOTE) {
178 if (c != q)
179 goto set;
180 q = '\0';
181 state = NORM;
182 } else { /* if (state == NORM) */
183 if (ISSPACE(c)) {
184 if (p != s) {
185 close_word:
186 state = SPACE;
187 c = '\0';
188 goto set;
189 }
190 } else {
191 if (c == '\\') {
192 state = BACKSLASH;
193 } else if (c == '\'' || c == '"') {
194 q = c;
195 state = QUOTE;
196 } else {
197 set:
198 *p++ = c;
199 }
200 }
201 }
202 if (state == SPACE) { /* word's delimiter or EOF detected */
203 if (q) {
204 bb_error_msg_and_die("unmatched %s quote",
205 q == '\'' ? "single" : "double");
206 }
207 /* A full word is loaded */
208 if (G.eof_str) {
209 if (strcmp(s, G.eof_str) == 0) {
210 while (getchar() != EOF)
211 continue;
212 p = s;
213 goto ret;
214 }
215 }
216 store_param(s);
217 dbg_msg("args[]:'%s'", s);
218 s = p;
219 n_max_arg--;
220 if (n_max_arg == 0) {
221 goto ret;
222 }
223 state = NORM;
224 }
225 if (p == buf) {
226 goto ret;
227 }
228 }
229 ret:
230 *p = '\0';
231 /* store_param(NULL) - caller will do it */
232 dbg_msg("return:'%s'", s);
233 return s;
234}
235#else
236/* The variant does not support single quotes, double quotes or backslash */
237static char* FAST_FUNC process_stdin(int n_max_chars, int n_max_arg, char *buf)
238{
239 char *s = buf; /* start of the word */
240 char *p = s + strlen(buf); /* end of the word */
241
242 buf += n_max_chars; /* past buffer's end */
243
244 while (1) {
245 int c = getchar();
246 if (c == EOF) {
247 if (p == s)
248 goto ret;
249 }
250 if (c == EOF || ISSPACE(c)) {
251 if (p == s)
252 continue;
253 c = EOF;
254 }
255 *p++ = (c == EOF ? '\0' : c);
256 if (c == EOF) { /* word's delimiter or EOF detected */
257 /* A full word is loaded */
258 if (G.eof_str) {
259 if (strcmp(s, G.eof_str) == 0) {
260 while (getchar() != EOF)
261 continue;
262 p = s;
263 goto ret;
264 }
265 }
266 store_param(s);
267 dbg_msg("args[]:'%s'", s);
268 s = p;
269 n_max_arg--;
270 if (n_max_arg == 0) {
271 goto ret;
272 }
273 }
274 if (p == buf) {
275 goto ret;
276 }
277 }
278 ret:
279 *p = '\0';
280 /* store_param(NULL) - caller will do it */
281 dbg_msg("return:'%s'", s);
282 return s;
283}
284#endif /* FEATURE_XARGS_SUPPORT_QUOTES */
285
286#if ENABLE_FEATURE_XARGS_SUPPORT_ZERO_TERM
287static char* FAST_FUNC process0_stdin(int n_max_chars, int n_max_arg, char *buf)
288{
289 char *s = buf; /* start of the word */
290 char *p = s + strlen(buf); /* end of the word */
291
292 buf += n_max_chars; /* past buffer's end */
293
294 while (1) {
295 int c = getchar();
296 if (c == EOF) {
297 if (p == s)
298 goto ret;
299 c = '\0';
300 }
301 *p++ = c;
302 if (c == '\0') { /* word's delimiter or EOF detected */
303 /* A full word is loaded */
304 store_param(s);
305 dbg_msg("args[]:'%s'", s);
306 s = p;
307 n_max_arg--;
308 if (n_max_arg == 0) {
309 goto ret;
310 }
311 }
312 if (p == buf) {
313 goto ret;
314 }
315 }
316 ret:
317 *p = '\0';
318 /* store_param(NULL) - caller will do it */
319 dbg_msg("return:'%s'", s);
320 return s;
321}
322#endif /* FEATURE_XARGS_SUPPORT_ZERO_TERM */
323
324#if ENABLE_FEATURE_XARGS_SUPPORT_CONFIRMATION
325/* Prompt the user for a response, and
326 if the user responds affirmatively, return true;
327 otherwise, return false. Uses "/dev/tty", not stdin. */
328static int xargs_ask_confirmation(void)
329{
330 FILE *tty_stream;
331 int c, savec;
332
333 tty_stream = xfopen_for_read(CURRENT_TTY);
334 fputs(" ?...", stderr);
335 fflush_all();
336 c = savec = getc(tty_stream);
337 while (c != EOF && c != '\n')
338 c = getc(tty_stream);
339 fclose(tty_stream);
340 return (savec == 'y' || savec == 'Y');
341}
342#else
343# define xargs_ask_confirmation() 1
344#endif
345
346//usage:#define xargs_trivial_usage
347//usage: "[OPTIONS] [PROG ARGS]"
348//usage:#define xargs_full_usage "\n\n"
349//usage: "Run PROG on every item given by stdin\n"
350//usage: "\nOptions:"
351//usage: IF_FEATURE_XARGS_SUPPORT_CONFIRMATION(
352//usage: "\n -p Ask user whether to run each command"
353//usage: )
354//usage: "\n -r Don't run command if input is empty"
355//usage: IF_FEATURE_XARGS_SUPPORT_ZERO_TERM(
356//usage: "\n -0 Input is separated by NUL characters"
357//usage: )
358//usage: "\n -t Print the command on stderr before execution"
359//usage: "\n -e[STR] STR stops input processing"
360//usage: "\n -n N Pass no more than N args to PROG"
361//usage: "\n -s N Pass command line of no more than N bytes"
362//usage: IF_FEATURE_XARGS_SUPPORT_TERMOPT(
363//usage: "\n -x Exit if size is exceeded"
364//usage: )
365//usage:#define xargs_example_usage
366//usage: "$ ls | xargs gzip\n"
367//usage: "$ find . -name '*.c' -print | xargs rm\n"
368
369/* Correct regardless of combination of CONFIG_xxx */
370enum {
371 OPTBIT_VERBOSE = 0,
372 OPTBIT_NO_EMPTY,
373 OPTBIT_UPTO_NUMBER,
374 OPTBIT_UPTO_SIZE,
375 OPTBIT_EOF_STRING,
376 OPTBIT_EOF_STRING1,
377 IF_FEATURE_XARGS_SUPPORT_CONFIRMATION(OPTBIT_INTERACTIVE,)
378 IF_FEATURE_XARGS_SUPPORT_TERMOPT( OPTBIT_TERMINATE ,)
379 IF_FEATURE_XARGS_SUPPORT_ZERO_TERM( OPTBIT_ZEROTERM ,)
380
381 OPT_VERBOSE = 1 << OPTBIT_VERBOSE ,
382 OPT_NO_EMPTY = 1 << OPTBIT_NO_EMPTY ,
383 OPT_UPTO_NUMBER = 1 << OPTBIT_UPTO_NUMBER,
384 OPT_UPTO_SIZE = 1 << OPTBIT_UPTO_SIZE ,
385 OPT_EOF_STRING = 1 << OPTBIT_EOF_STRING , /* GNU: -e[<param>] */
386 OPT_EOF_STRING1 = 1 << OPTBIT_EOF_STRING1, /* SUS: -E<param> */
387 OPT_INTERACTIVE = IF_FEATURE_XARGS_SUPPORT_CONFIRMATION((1 << OPTBIT_INTERACTIVE)) + 0,
388 OPT_TERMINATE = IF_FEATURE_XARGS_SUPPORT_TERMOPT( (1 << OPTBIT_TERMINATE )) + 0,
389 OPT_ZEROTERM = IF_FEATURE_XARGS_SUPPORT_ZERO_TERM( (1 << OPTBIT_ZEROTERM )) + 0,
390};
391#define OPTION_STR "+trn:s:e::E:" \
392 IF_FEATURE_XARGS_SUPPORT_CONFIRMATION("p") \
393 IF_FEATURE_XARGS_SUPPORT_TERMOPT( "x") \
394 IF_FEATURE_XARGS_SUPPORT_ZERO_TERM( "0")
395
396int xargs_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
397int xargs_main(int argc, char **argv)
398{
399 int i;
400 int child_error = 0;
401 char *max_args;
402 char *max_chars;
403 char *buf;
404 unsigned opt;
405 int n_max_chars;
406 int n_max_arg;
407#if ENABLE_FEATURE_XARGS_SUPPORT_ZERO_TERM
408 char* FAST_FUNC (*read_args)(int, int, char*) = process_stdin;
409#else
410#define read_args process_stdin
411#endif
412
413 INIT_G();
414
415 G.eof_str = NULL;
416 opt = getopt32(argv, OPTION_STR, &max_args, &max_chars, &G.eof_str, &G.eof_str);
417
418 /* -E ""? You may wonder why not just omit -E?
419 * This is used for portability:
420 * old xargs was using "_" as default for -E / -e */
421 if ((opt & OPT_EOF_STRING1) && G.eof_str[0] == '\0')
422 G.eof_str = NULL;
423
424 if (opt & OPT_ZEROTERM)
425 IF_FEATURE_XARGS_SUPPORT_ZERO_TERM(read_args = process0_stdin);
426
427 argv += optind;
428 argc -= optind;
429 if (!argv[0]) {
430 /* default behavior is to echo all the filenames */
431 *--argv = (char*)"echo";
432 argc++;
433 }
434
435 /* -s NUM default. fileutils-4.4.2 uses 128k, but I heasitate
436 * to use such a big value - first need to change code to use
437 * growable buffer instead of fixed one.
438 */
439 n_max_chars = 32 * 1024;
440 /* Make smaller if system does not allow our default value.
441 * The Open Group Base Specifications Issue 6:
442 * "The xargs utility shall limit the command line length such that
443 * when the command line is invoked, the combined argument
444 * and environment lists (see the exec family of functions
445 * in the System Interfaces volume of IEEE Std 1003.1-2001)
446 * shall not exceed {ARG_MAX}-2048 bytes".
447 */
448 {
449 long arg_max = 0;
450#if defined _SC_ARG_MAX
451 arg_max = sysconf(_SC_ARG_MAX) - 2048;
452#elif defined ARG_MAX
453 arg_max = ARG_MAX - 2048;
454#endif
455 if (arg_max > 0 && n_max_chars > arg_max)
456 n_max_chars = arg_max;
457 }
458 if (opt & OPT_UPTO_SIZE) {
459 n_max_chars = xatou_range(max_chars, 1, INT_MAX);
460 }
461 /* Account for prepended fixed arguments */
462 {
463 size_t n_chars = 0;
464 for (i = 0; argv[i]; i++) {
465 n_chars += strlen(argv[i]) + 1;
466 }
467 n_max_chars -= n_chars;
468 }
469 /* Sanity check */
470 if (n_max_chars <= 0) {
471 bb_error_msg_and_die("can't fit single argument within argument list size limit");
472 }
473
474 buf = xzalloc(n_max_chars + 1);
475
476 n_max_arg = n_max_chars;
477 if (opt & OPT_UPTO_NUMBER) {
478 n_max_arg = xatou_range(max_args, 1, INT_MAX);
479 /* Not necessary, we use growable args[]: */
480 /* if (n_max_arg > n_max_chars) n_max_arg = n_max_chars */
481 }
482
483 /* Allocate pointers for execvp */
484 /* We can statically allocate (argc + n_max_arg + 1) elements
485 * and do not bother with resizing args[], but on 64-bit machines
486 * this results in args[] vector which is ~8 times bigger
487 * than n_max_chars! That is, with n_max_chars == 20k,
488 * args[] will take 160k (!), which will most likely be
489 * almost entirely unused.
490 */
491 /* See store_param() for matching 256-step growth logic */
492 G.args = xmalloc(sizeof(G.args[0]) * ((argc + 0xff) & ~0xff));
493
494 /* Store the command to be executed, part 1 */
495 for (i = 0; argv[i]; i++)
496 G.args[i] = argv[i];
497
498 while (1) {
499 char *rem;
500
501 G.idx = argc;
502 rem = read_args(n_max_chars, n_max_arg, buf);
503 store_param(NULL);
504
505 if (!G.args[argc]) {
506 if (*rem != '\0')
507 bb_error_msg_and_die("argument line too long");
508 if (opt & OPT_NO_EMPTY)
509 break;
510 }
511 opt |= OPT_NO_EMPTY;
512
513 if (opt & (OPT_INTERACTIVE | OPT_VERBOSE)) {
514 const char *fmt = " %s" + 1;
515 char **args = G.args;
516 for (i = 0; args[i]; i++) {
517 fprintf(stderr, fmt, args[i]);
518 fmt = " %s";
519 }
520 if (!(opt & OPT_INTERACTIVE))
521 bb_putchar_stderr('\n');
522 }
523
524 if (!(opt & OPT_INTERACTIVE) || xargs_ask_confirmation()) {
525 child_error = xargs_exec();
526 }
527
528 if (child_error > 0 && child_error != 123) {
529 break;
530 }
531
532 overlapping_strcpy(buf, rem);
533 } /* while */
534
535 if (ENABLE_FEATURE_CLEAN_UP) {
536 free(G.args);
537 free(buf);
538 }
539
540 return child_error;
541}
542
543
544#ifdef TEST
545
546const char *applet_name = "debug stuff usage";
547
548void bb_show_usage(void)
549{
550 fprintf(stderr, "Usage: %s [-p] [-r] [-t] -[x] [-n max_arg] [-s max_chars]\n",
551 applet_name);
552 exit(EXIT_FAILURE);
553}
554
555int main(int argc, char **argv)
556{
557 return xargs_main(argc, argv);
558}
559#endif /* TEST */
Note: See TracBrowser for help on using the repository browser.