busybox/findutils/xargs.c

794 lines
21 KiB
C
Raw Normal View History

/* vi: set sw=4 ts=4: */
/*
* Mini xargs implementation for busybox
*
2003-10-10 17:40:18 +05:30
* (C) 2002,2003 by Vladimir Oleynik <dzo@simtreas.ru>
*
2003-10-10 17:40:18 +05:30
* Special thanks
* - Mark Whitley and Glenn McGrath for stimulus to rewrite :)
2003-10-10 17:40:18 +05:30
* - Mike Rendell <michael@cs.mun.ca>
* and David MacKenzie <djm@gnu.ai.mit.edu>.
*
* Licensed under GPLv2 or later, see file LICENSE in this source tree.
*
* xargs is described in the Single Unix Specification v3 at
* http://www.opengroup.org/onlinepubs/007904975/utilities/xargs.html
*/
//config:config XARGS
//config: bool "xargs (7.2 kb)"
//config: default y
//config: help
//config: xargs is used to execute a specified command for
//config: every item from standard input.
//config:
//config:config FEATURE_XARGS_SUPPORT_CONFIRMATION
//config: bool "Enable -p: prompt and confirmation"
//config: default y
//config: depends on XARGS
//config: help
//config: Support -p: prompt the user whether to run each command
//config: line and read a line from the terminal.
//config:
//config:config FEATURE_XARGS_SUPPORT_QUOTES
//config: bool "Enable single and double quotes and backslash"
//config: default y
//config: depends on XARGS
//config: help
//config: Support quoting in the input.
//config:
//config:config FEATURE_XARGS_SUPPORT_TERMOPT
//config: bool "Enable -x: exit if -s or -n is exceeded"
//config: default y
//config: depends on XARGS
//config: help
//config: Support -x: exit if the command size (see the -s or -n option)
//config: is exceeded.
//config:
//config:config FEATURE_XARGS_SUPPORT_ZERO_TERM
//config: bool "Enable -0: NUL-terminated input"
//config: default y
//config: depends on XARGS
//config: help
//config: Support -0: input items are terminated by a NUL character
//config: instead of whitespace, and the quotes and backslash
//config: are not special.
//config:
//config:config FEATURE_XARGS_SUPPORT_REPL_STR
//config: bool "Enable -I STR: string to replace"
//config: default y
//config: depends on XARGS
//config: help
//config: Support -I STR and -i[STR] options.
//config:
//config:config FEATURE_XARGS_SUPPORT_PARALLEL
//config: bool "Enable -P N: processes to run in parallel"
//config: default y
//config: depends on XARGS
//config:
//config:config FEATURE_XARGS_SUPPORT_ARGS_FILE
//config: bool "Enable -a FILE: use FILE instead of stdin"
//config: default y
//config: depends on XARGS
//applet:IF_XARGS(APPLET_NOEXEC(xargs, xargs, BB_DIR_USR_BIN, BB_SUID_DROP, xargs))
//kbuild:lib-$(CONFIG_XARGS) += xargs.o
#include "libbb.h"
#include "common_bufsiz.h"
2003-10-10 17:40:18 +05:30
/* This is a NOEXEC applet. Be very careful! */
#if 0
# define dbg_msg(...) bb_error_msg(__VA_ARGS__)
#else
# define dbg_msg(...) ((void)0)
#endif
2003-10-10 17:40:18 +05:30
#ifdef TEST
# ifndef ENABLE_FEATURE_XARGS_SUPPORT_CONFIRMATION
# define ENABLE_FEATURE_XARGS_SUPPORT_CONFIRMATION 1
2003-10-10 17:40:18 +05:30
# endif
# ifndef ENABLE_FEATURE_XARGS_SUPPORT_QUOTES
# define ENABLE_FEATURE_XARGS_SUPPORT_QUOTES 1
2003-10-10 17:40:18 +05:30
# endif
# ifndef ENABLE_FEATURE_XARGS_SUPPORT_TERMOPT
# define ENABLE_FEATURE_XARGS_SUPPORT_TERMOPT 1
2003-10-10 17:40:18 +05:30
# endif
# ifndef ENABLE_FEATURE_XARGS_SUPPORT_ZERO_TERM
# define ENABLE_FEATURE_XARGS_SUPPORT_ZERO_TERM 1
2003-10-10 17:40:18 +05:30
# endif
#endif
struct globals {
char **args;
#if ENABLE_FEATURE_XARGS_SUPPORT_REPL_STR
char **argv;
const char *repl_str;
char eol_ch;
#endif
const char *eof_str;
int idx;
#if ENABLE_FEATURE_XARGS_SUPPORT_PARALLEL
int running_procs;
int max_procs;
#endif
smalluint xargs_exitcode;
#if ENABLE_FEATURE_XARGS_SUPPORT_QUOTES
#define NORM 0
#define QUOTE 1
#define BACKSLASH 2
#define SPACE 4
smalluint process_stdin__state;
char process_stdin__q;
#endif
} FIX_ALIASING;
#define G (*(struct globals*)bb_common_bufsiz1)
#define INIT_G() do { \
setup_common_bufsiz(); \
IF_FEATURE_XARGS_SUPPORT_REPL_STR(G.repl_str = "{}";) \
IF_FEATURE_XARGS_SUPPORT_REPL_STR(G.eol_ch = '\n';) \
/* Even zero values are set because we are NOEXEC applet */ \
G.eof_str = NULL; \
G.idx = 0; \
IF_FEATURE_XARGS_SUPPORT_PARALLEL(G.running_procs = 0;) \
IF_FEATURE_XARGS_SUPPORT_PARALLEL(G.max_procs = 1;) \
G.xargs_exitcode = 0; \
IF_FEATURE_XARGS_SUPPORT_QUOTES(G.process_stdin__state = NORM;) \
IF_FEATURE_XARGS_SUPPORT_QUOTES(G.process_stdin__q = '\0';) \
} while (0)
/*
* Returns 0 if xargs should continue (but may set G.xargs_exitcode to 123).
* Else sets G.xargs_exitcode to error code and returns nonzero.
*
* If G.max_procs == 0, performs final waitpid() loop for all children.
*/
static int xargs_exec(void)
{
2006-09-29 13:50:30 +05:30
int status;
2003-10-31 04:17:16 +05:30
#if !ENABLE_FEATURE_XARGS_SUPPORT_PARALLEL
status = spawn_and_wait(G.args);
#else
if (G.max_procs == 1) {
status = spawn_and_wait(G.args);
} else {
pid_t pid;
int wstat;
again:
if (G.running_procs >= G.max_procs)
pid = safe_waitpid(-1, &wstat, 0);
else
pid = wait_any_nohang(&wstat);
if (pid > 0) {
/* We may have children we don't know about:
* sh -c 'sleep 1 & exec xargs ...'
* Do not make G.running_procs go negative.
*/
if (G.running_procs != 0)
G.running_procs--;
status = WIFSIGNALED(wstat)
? 0x180 + WTERMSIG(wstat)
: WEXITSTATUS(wstat);
if (status > 0 && status < 255) {
/* See below why 123 does not abort */
G.xargs_exitcode = 123;
status = 0;
}
if (status == 0)
goto again; /* maybe we have more children? */
/* else: "bad" status, will bail out */
} else if (G.max_procs != 0) {
/* Not in final waitpid() loop,
* and G.running_procs < G.max_procs: start more procs
*/
status = spawn(G.args);
/* here "status" actually holds pid, or -1 */
if (status > 0) {
G.running_procs++;
status = 0;
}
/* else: status == -1 (failed to fork or exec) */
} else {
/* final waitpid() loop: must be ECHILD "no more children" */
status = 0;
}
}
#endif
/* Manpage:
* """xargs exits with the following status:
* 0 if it succeeds
* 123 if any invocation of the command exited with status 1-125
* 124 if the command exited with status 255
* ("""If any invocation of the command exits with a status of 255,
* xargs will stop immediately without reading any further input.
* An error message is issued on stderr when this happens.""")
* 125 if the command is killed by a signal
* 126 if the command cannot be run
* 127 if the command is not found
* 1 if some other error occurred."""
*/
if (status < 0) {
bb_simple_perror_msg(G.args[0]);
status = (errno == ENOENT) ? 127 : 126;
2006-09-29 13:50:30 +05:30
}
else if (status >= 0x180) {
bb_error_msg("'%s' terminated by signal %u",
G.args[0], status - 0x180);
status = 125;
2006-09-29 13:50:30 +05:30
}
else if (status != 0) {
if (status == 255) {
bb_error_msg("%s: exited with status 255; aborting", G.args[0]);
status = 124;
goto ret;
}
/* "123 if any invocation of the command exited with status 1-125"
* This implies that nonzero exit code is remembered,
* but does not cause xargs to stop: we return 0.
*/
G.xargs_exitcode = 123;
status = 0;
}
ret:
if (status != 0)
G.xargs_exitcode = status;
return status;
}
/* In POSIX/C locale isspace is only these chars: "\t\n\v\f\r" and space.
* "\t\n\v\f\r" happen to have ASCII codes 9,10,11,12,13.
*/
#define ISSPACE(a) ({ unsigned char xargs__isspace = (a) - 9; xargs__isspace == (' ' - 9) || xargs__isspace <= (13 - 9); })
2003-10-10 17:40:18 +05:30
static void store_param(char *s)
{
/* Grow by 256 elements at once */
if (!(G.idx & 0xff)) { /* G.idx == N*256? */
/* Enlarge, make G.args[(N+1)*256 - 1] last valid idx */
G.args = xrealloc(G.args, sizeof(G.args[0]) * (G.idx + 0x100));
}
G.args[G.idx++] = s;
}
/* process[0]_stdin:
* Read characters into buf[n_max_chars+1], and when parameter delimiter
* is seen, store the address of a new parameter to args[].
* If reading discovers that last chars do not form the complete
* parameter, the pointer to the first such "tail character" is returned.
* (buf has extra byte at the end to accommodate terminating NUL
* of "tail characters" string).
* Otherwise, the returned pointer points to NUL byte.
* On entry, buf[] may contain some "seed chars" which are to become
* the beginning of the first parameter.
*/
#if ENABLE_FEATURE_XARGS_SUPPORT_QUOTES
static char* FAST_FUNC process_stdin(int n_max_chars, int n_max_arg, char *buf)
2000-09-23 01:31:23 +05:30
{
#define q G.process_stdin__q
#define state G.process_stdin__state
char *s = buf; /* start of the word */
char *p = s + strlen(buf); /* end of the word */
buf += n_max_chars; /* past buffer's end */
/* "goto ret" is used instead of "break" to make control flow
* more obvious: */
2003-10-31 04:17:16 +05:30
while (1) {
int c = getchar();
2003-10-31 04:17:16 +05:30
if (c == EOF) {
if (p != s)
goto close_word;
goto ret;
2003-10-10 17:40:18 +05:30
}
2003-10-31 04:17:16 +05:30
if (state == BACKSLASH) {
state = NORM;
goto set;
}
if (state == QUOTE) {
2007-04-15 14:08:50 +05:30
if (c != q)
2003-10-31 04:17:16 +05:30
goto set;
2007-04-15 14:08:50 +05:30
q = '\0';
state = NORM;
2007-04-12 06:02:05 +05:30
} else { /* if (state == NORM) */
2003-10-31 04:17:16 +05:30
if (ISSPACE(c)) {
if (p != s) {
close_word:
2003-10-31 04:17:16 +05:30
state = SPACE;
2007-04-15 14:08:50 +05:30
c = '\0';
2003-10-31 04:17:16 +05:30
goto set;
}
} else {
if (c == '\\') {
state = BACKSLASH;
} else if (c == '\'' || c == '"') {
q = c;
state = QUOTE;
} else {
2007-04-15 14:08:50 +05:30
set:
2003-10-31 04:17:16 +05:30
*p++ = c;
}
}
}
if (state == SPACE) { /* word's delimiter or EOF detected */
state = NORM;
if (q) {
bb_error_msg_and_die("unmatched %s quote",
q == '\'' ? "single" : "double");
}
/* A full word is loaded */
if (G.eof_str) {
if (strcmp(s, G.eof_str) == 0) {
while (getchar() != EOF)
continue;
p = s;
goto ret;
2003-10-31 04:17:16 +05:30
}
}
store_param(s);
dbg_msg("args[]:'%s'", s);
s = p;
n_max_arg--;
if (n_max_arg == 0) {
goto ret;
}
}
if (p == buf) {
goto ret;
2003-10-10 17:40:18 +05:30
}
}
ret:
*p = '\0';
/* store_param(NULL) - caller will do it */
dbg_msg("return:'%s'", s);
return s;
#undef q
#undef state
2003-10-10 17:40:18 +05:30
}
#else
/* The variant does not support single quotes, double quotes or backslash */
static char* FAST_FUNC process_stdin(int n_max_chars, int n_max_arg, char *buf)
2003-10-10 17:40:18 +05:30
{
char *s = buf; /* start of the word */
char *p = s + strlen(buf); /* end of the word */
buf += n_max_chars; /* past buffer's end */
2003-10-31 04:17:16 +05:30
while (1) {
int c = getchar();
2003-10-31 04:17:16 +05:30
if (c == EOF) {
if (p == s)
goto ret;
}
2003-10-31 04:17:16 +05:30
if (c == EOF || ISSPACE(c)) {
if (p == s)
2003-10-31 04:17:16 +05:30
continue;
c = EOF;
}
2007-04-15 14:08:50 +05:30
*p++ = (c == EOF ? '\0' : c);
if (c == EOF) { /* word's delimiter or EOF detected */
/* A full word is loaded */
if (G.eof_str) {
if (strcmp(s, G.eof_str) == 0) {
while (getchar() != EOF)
continue;
p = s;
goto ret;
2003-10-31 04:17:16 +05:30
}
}
store_param(s);
dbg_msg("args[]:'%s'", s);
s = p;
n_max_arg--;
if (n_max_arg == 0) {
goto ret;
}
}
if (p == buf) {
goto ret;
2003-10-10 17:40:18 +05:30
}
2003-10-09 16:36:45 +05:30
}
ret:
*p = '\0';
/* store_param(NULL) - caller will do it */
dbg_msg("return:'%s'", s);
return s;
2003-10-10 17:40:18 +05:30
}
#endif /* FEATURE_XARGS_SUPPORT_QUOTES */
2003-10-10 17:40:18 +05:30
#if ENABLE_FEATURE_XARGS_SUPPORT_ZERO_TERM
static char* FAST_FUNC process0_stdin(int n_max_chars, int n_max_arg, char *buf)
2003-10-10 17:40:18 +05:30
{
char *s = buf; /* start of the word */
char *p = s + strlen(buf); /* end of the word */
buf += n_max_chars; /* past buffer's end */
2003-10-31 04:17:16 +05:30
while (1) {
int c = getchar();
2003-10-31 04:17:16 +05:30
if (c == EOF) {
if (p == s)
goto ret;
2007-04-15 14:08:50 +05:30
c = '\0';
2003-10-10 17:40:18 +05:30
}
2003-10-31 04:17:16 +05:30
*p++ = c;
if (c == '\0') { /* NUL or EOF detected */
/* A full word is loaded */
store_param(s);
dbg_msg("args[]:'%s'", s);
s = p;
n_max_arg--;
if (n_max_arg == 0) {
goto ret;
2003-10-31 04:17:16 +05:30
}
}
if (p == buf) {
goto ret;
2003-10-10 17:40:18 +05:30
}
}
ret:
*p = '\0';
/* store_param(NULL) - caller will do it */
dbg_msg("return:'%s'", s);
return s;
2003-10-10 17:40:18 +05:30
}
#endif /* FEATURE_XARGS_SUPPORT_ZERO_TERM */
2003-10-10 17:40:18 +05:30
#if ENABLE_FEATURE_XARGS_SUPPORT_REPL_STR
/*
* Used if -I<repl> was specified.
* In this mode, words aren't appended to PROG ARGS.
* Instead, entire input line is read, then <repl> string
* in every PROG and ARG is replaced with the line:
* echo -e "ho ho\nhi" | xargs -I_ cmd __ _
* results in "cmd 'ho hoho ho' 'ho ho'"; "cmd 'hihi' 'hi'".
* -n MAX_ARGS seems to be ignored.
* Tested with GNU findutils 4.5.10.
*/
//FIXME: n_max_chars is not handled the same way as in GNU findutils.
//FIXME: quoting is not implemented.
static char* FAST_FUNC process_stdin_with_replace(int n_max_chars, int n_max_arg UNUSED_PARAM, char *buf)
{
int i;
char *end, *p;
/* Free strings from last invocation, if any */
for (i = 0; G.args && G.args[i]; i++)
if (G.args[i] != G.argv[i])
free(G.args[i]);
end = buf + n_max_chars;
p = buf;
while (1) {
int c = getchar();
if (p == buf) {
if (c == EOF)
goto ret; /* last line is empty, return "" */
if (c == G.eol_ch)
continue; /* empty line, ignore */
/* Skip leading whitespace of each line: try
* echo -e ' \t\v1 2 3 ' | xargs -I% echo '[%]'
*/
if (ISSPACE(c))
continue;
}
if (c == EOF || c == G.eol_ch) {
c = '\0';
}
*p++ = c;
if (c == '\0') { /* EOL or EOF detected */
i = 0;
while (G.argv[i]) {
char *arg = G.argv[i];
int count = count_strstr(arg, G.repl_str);
if (count != 0)
arg = xmalloc_substitute_string(arg, count, G.repl_str, buf);
store_param(arg);
dbg_msg("args[]:'%s'", arg);
i++;
}
p = buf;
goto ret;
}
if (p == end) {
goto ret;
}
}
ret:
*p = '\0';
/* store_param(NULL) - caller will do it */
dbg_msg("return:'%s'", buf);
return buf;
}
#endif
#if ENABLE_FEATURE_XARGS_SUPPORT_CONFIRMATION
/* Prompt the user for a response, and
* if user responds affirmatively, return true;
* otherwise, return false. Uses "/dev/tty", not stdin.
*/
static int xargs_ask_confirmation(void)
{
FILE *tty_stream;
int r;
tty_stream = xfopen_for_read(CURRENT_TTY);
fputs(" ?...", stderr);
r = bb_ask_y_confirmation_FILE(tty_stream);
fclose(tty_stream);
return r;
}
#else
# define xargs_ask_confirmation() 1
#endif
//usage:#define xargs_trivial_usage
//usage: "[OPTIONS] [PROG ARGS]"
//usage:#define xargs_full_usage "\n\n"
//usage: "Run PROG on every item given by stdin\n"
//usage: IF_FEATURE_XARGS_SUPPORT_ZERO_TERM(
//usage: "\n -0 Input is separated by NULs"
//usage: )
//usage: IF_FEATURE_XARGS_SUPPORT_ARGS_FILE(
//usage: "\n -a FILE Read from FILE instead of stdin"
//usage: )
//usage: "\n -r Don't run command if input is empty"
//usage: "\n -t Print the command on stderr before execution"
//usage: IF_FEATURE_XARGS_SUPPORT_CONFIRMATION(
//usage: "\n -p Ask user whether to run each command"
//usage: )
//usage: "\n -E STR,-e[STR] STR stops input processing"
//usage: IF_FEATURE_XARGS_SUPPORT_REPL_STR(
//usage: "\n -I STR Replace STR within PROG ARGS with input line"
//usage: )
//usage: "\n -n N Pass no more than N args to PROG"
//usage: "\n -s N Pass command line of no more than N bytes"
//usage: IF_FEATURE_XARGS_SUPPORT_PARALLEL(
//usage: "\n -P N Run up to N PROGs in parallel"
//usage: )
//usage: IF_FEATURE_XARGS_SUPPORT_TERMOPT(
//usage: "\n -x Exit if size is exceeded"
//usage: )
//usage:#define xargs_example_usage
//usage: "$ ls | xargs gzip\n"
//usage: "$ find . -name '*.c' -print | xargs rm\n"
2006-09-29 13:50:30 +05:30
/* 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 ,)
IF_FEATURE_XARGS_SUPPORT_REPL_STR( OPTBIT_REPLSTR ,)
IF_FEATURE_XARGS_SUPPORT_REPL_STR( OPTBIT_REPLSTR1 ,)
2006-09-29 13:50:30 +05:30
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[<param>] */
OPT_EOF_STRING1 = 1 << OPTBIT_EOF_STRING1, /* SUS: -E<param> */
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,
OPT_REPLSTR = IF_FEATURE_XARGS_SUPPORT_REPL_STR( (1 << OPTBIT_REPLSTR )) + 0,
OPT_REPLSTR1 = IF_FEATURE_XARGS_SUPPORT_REPL_STR( (1 << OPTBIT_REPLSTR1 )) + 0,
2006-09-29 13:50:30 +05:30
};
#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") \
IF_FEATURE_XARGS_SUPPORT_REPL_STR( "I:i::") \
IF_FEATURE_XARGS_SUPPORT_PARALLEL( "P:+") \
IF_FEATURE_XARGS_SUPPORT_ARGS_FILE( "a:")
int xargs_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
int xargs_main(int argc UNUSED_PARAM, char **argv)
2003-10-10 17:40:18 +05:30
{
int initial_idx;
int i;
char *max_args;
char *max_chars;
char *buf;
unsigned opt;
int n_max_chars;
int n_max_arg;
#if ENABLE_FEATURE_XARGS_SUPPORT_ZERO_TERM \
|| ENABLE_FEATURE_XARGS_SUPPORT_REPL_STR
char* FAST_FUNC (*read_args)(int, int, char*) = process_stdin;
2006-09-29 13:50:30 +05:30
#else
#define read_args process_stdin
2003-10-10 17:40:18 +05:30
#endif
IF_FEATURE_XARGS_SUPPORT_ARGS_FILE(char *opt_a = NULL;)
INIT_G();
getopt32: remove applet_long_options FEATURE_GETOPT_LONG made dependent on LONG_OPTS. The folloving options are removed, now LONG_OPTS enables long options for affected applets: FEATURE_ENV_LONG_OPTIONS FEATURE_EXPAND_LONG_OPTIONS FEATURE_UNEXPAND_LONG_OPTIONS FEATURE_MKDIR_LONG_OPTIONS FEATURE_MV_LONG_OPTIONS FEATURE_RMDIR_LONG_OPTIONS FEATURE_ADDGROUP_LONG_OPTIONS FEATURE_ADDUSER_LONG_OPTIONS FEATURE_HWCLOCK_LONG_OPTIONS FEATURE_NSENTER_LONG_OPTS FEATURE_CHCON_LONG_OPTIONS FEATURE_RUNCON_LONG_OPTIONS They either had a small number of long options, or their long options are essential. Example: upstream addgroup and adduser have ONLY longopts, we should probably go further and get rid of non-standard short options. To this end, make addgroup and adduser "select LONG_OPTS". We had this breakage caused by us even in our own package! #if ENABLE_LONG_OPTS || !ENABLE_ADDGROUP /* We try to use --gid, not -g, because "standard" addgroup * has no short option -g, it has only long --gid. */ argv[1] = (char*)"--gid"; #else /* Breaks if system in fact does NOT use busybox addgroup */ argv[1] = (char*)"-g"; #endif xargs: its lone longopt no longer depends on DESKTOP, only on LONG_OPTS. hwclock TODO: get rid of incompatible -t, -l aliases to --systz, --localtime Shorten help texts by omitting long option when short opt alternative exists. Reduction of size comes from the fact that store of an immediate (an address of longopts) to a fixed address (global variable) is a longer insn than pushing that immediate or passing it in a register. This effect is CPU-agnostic. function old new delta getopt32 1350 22 -1328 vgetopt32 - 1318 +1318 getopt32long - 24 +24 tftpd_main 562 567 +5 scan_recursive 376 380 +4 collect_cpu 545 546 +1 date_main 1096 1095 -1 hostname_main 262 259 -3 uname_main 259 255 -4 setpriv_main 362 358 -4 rmdir_main 191 187 -4 mv_main 562 558 -4 ipcalc_main 548 544 -4 ifenslave_main 641 637 -4 gzip_main 192 188 -4 gunzip_main 77 73 -4 fsfreeze_main 81 77 -4 flock_main 318 314 -4 deluser_main 337 333 -4 cp_main 374 370 -4 chown_main 175 171 -4 applet_long_options 4 - -4 xargs_main 894 889 -5 wget_main 2540 2535 -5 udhcpc_main 2767 2762 -5 touch_main 436 431 -5 tar_main 1014 1009 -5 start_stop_daemon_main 1033 1028 -5 sed_main 682 677 -5 script_main 1082 1077 -5 run_parts_main 330 325 -5 rtcwake_main 459 454 -5 od_main 2169 2164 -5 nl_main 201 196 -5 modprobe_main 773 768 -5 mkdir_main 160 155 -5 ls_main 568 563 -5 install_main 773 768 -5 hwclock_main 411 406 -5 getopt_main 622 617 -5 fstrim_main 256 251 -5 env_main 198 193 -5 dumpleases_main 635 630 -5 dpkg_main 3991 3986 -5 diff_main 1355 1350 -5 cryptpw_main 233 228 -5 cpio_main 593 588 -5 conspy_main 1135 1130 -5 chpasswd_main 313 308 -5 adduser_main 887 882 -5 addgroup_main 416 411 -5 ftpgetput_main 351 345 -6 get_terminal_width_height 242 234 -8 expand_main 690 680 -10 static.expand_longopts 18 - -18 static.unexpand_longopts 27 - -27 mkdir_longopts 28 - -28 env_longopts 30 - -30 static.ifenslave_longopts 34 - -34 mv_longopts 46 - -46 static.rmdir_longopts 48 - -48 packed_usage 31739 31687 -52 ------------------------------------------------------------------------------ (add/remove: 2/8 grow/shrink: 3/49 up/down: 1352/-1840) Total: -488 bytes text data bss dec hex filename 915681 485 6880 923046 e15a6 busybox_old 915428 485 6876 922789 e14a5 busybox_unstripped Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>
2017-08-08 20:08:18 +05:30
opt = getopt32long(argv, OPTION_STR,
"no-run-if-empty\0" No_argument "r",
&max_args, &max_chars, &G.eof_str, &G.eof_str
IF_FEATURE_XARGS_SUPPORT_REPL_STR(, &G.repl_str, &G.repl_str)
IF_FEATURE_XARGS_SUPPORT_PARALLEL(, &G.max_procs)
IF_FEATURE_XARGS_SUPPORT_ARGS_FILE(, &opt_a)
);
2003-10-10 17:40:18 +05:30
#if ENABLE_FEATURE_XARGS_SUPPORT_PARALLEL
if (G.max_procs <= 0) /* -P0 means "run lots of them" */
G.max_procs = 100; /* let's not go crazy high */
#endif
#if ENABLE_FEATURE_XARGS_SUPPORT_ARGS_FILE
if (opt_a)
xmove_fd(xopen(opt_a, O_RDONLY), 0);
#endif
/* -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) && G.eof_str[0] == '\0')
G.eof_str = NULL;
if (opt & OPT_ZEROTERM) {
IF_FEATURE_XARGS_SUPPORT_ZERO_TERM(read_args = process0_stdin;)
IF_FEATURE_XARGS_SUPPORT_REPL_STR(G.eol_ch = '\0';)
}
2003-10-31 04:17:16 +05:30
argv += optind;
//argc -= optind;
if (!argv[0]) {
2003-10-31 04:17:16 +05:30
/* default behavior is to echo all the filenames */
*--argv = (char*)"echo";
//argc++;
2003-10-31 04:17:16 +05:30
}
/*
* The Open Group Base Specifications Issue 6:
* "The xargs utility shall limit the command line length such that
* when the command line is invoked, the combined argument
* and environment lists (see the exec family of functions
* in the System Interfaces volume of IEEE Std 1003.1-2001)
* shall not exceed {ARG_MAX}-2048 bytes".
*/
n_max_chars = bb_arg_max();
if (n_max_chars > 32 * 1024)
n_max_chars = 32 * 1024;
/*
* POSIX suggests substracting 2048 bytes from sysconf(_SC_ARG_MAX)
* so that the process may safely modify its environment.
*/
n_max_chars -= 2048;
2006-09-29 13:50:30 +05:30
if (opt & OPT_UPTO_SIZE) {
n_max_chars = xatou_range(max_chars, 1, INT_MAX);
}
/* Account for prepended fixed arguments */
{
size_t n_chars = 0;
for (i = 0; argv[i]; i++) {
n_chars += strlen(argv[i]) + 1;
2003-10-31 04:17:16 +05:30
}
n_max_chars -= n_chars;
}
/* Sanity check */
if (n_max_chars <= 0) {
libbb: reduce the overhead of single parameter bb_error_msg() calls Back in 2007, commit 0c97c9d43707 ("'simple' error message functions by Loic Grenie") introduced bb_simple_perror_msg() to allow for a lower overhead call to bb_perror_msg() when only a string was being printed with no parameters. This saves space for some CPU architectures because it avoids the overhead of a call to a variadic function. However there has never been a simple version of bb_error_msg(), and since 2007 many new calls to bb_perror_msg() have been added that only take a single parameter and so could have been using bb_simple_perror_message(). This changeset introduces 'simple' versions of bb_info_msg(), bb_error_msg(), bb_error_msg_and_die(), bb_herror_msg() and bb_herror_msg_and_die(), and replaces all calls that only take a single parameter, or use something like ("%s", arg), with calls to the corresponding 'simple' version. Since it is likely that single parameter calls to the variadic functions may be accidentally reintroduced in the future a new debugging config option WARN_SIMPLE_MSG has been introduced. This uses some macro magic which will cause any such calls to generate a warning, but this is turned off by default to avoid use of the unpleasant macros in normal circumstances. This is a large changeset due to the number of calls that have been replaced. The only files that contain changes other than simple substitution of function calls are libbb.h, libbb/herror_msg.c, libbb/verror_msg.c and libbb/xfuncs_printf.c. In miscutils/devfsd.c, networking/udhcp/common.h and util-linux/mdev.c additonal macros have been added for logging so that single parameter and multiple parameter logging variants exist. The amount of space saved varies considerably by architecture, and was found to be as follows (for 'defconfig' using GCC 7.4): Arm: -92 bytes MIPS: -52 bytes PPC: -1836 bytes x86_64: -938 bytes Note that for the MIPS architecture only an exception had to be made disabling the 'simple' calls for 'udhcp' (in networking/udhcp/common.h) because it made these files larger on MIPS. Signed-off-by: James Byrne <james.byrne@origamienergy.com> Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>
2019-07-02 15:05:03 +05:30
bb_simple_error_msg_and_die("can't fit single argument within argument list size limit");
}
buf = xzalloc(n_max_chars + 1);
2003-10-31 04:17:16 +05:30
n_max_arg = n_max_chars;
2006-09-29 13:50:30 +05:30
if (opt & OPT_UPTO_NUMBER) {
n_max_arg = xatou_range(max_args, 1, INT_MAX);
/* Not necessary, we use growable args[]: */
/* if (n_max_arg > n_max_chars) n_max_arg = n_max_chars */
}
2003-10-10 17:40:18 +05:30
#if ENABLE_FEATURE_XARGS_SUPPORT_REPL_STR
if (opt & (OPT_REPLSTR | OPT_REPLSTR1)) {
/*
* -I<str>:
* Unmodified args are kept in G.argv[i],
* G.args[i] receives malloced G.argv[i] with <str> replaced
* with input line. Setting this up:
*/
G.args = NULL;
G.argv = argv;
read_args = process_stdin_with_replace;
/* Make -I imply -r. GNU findutils seems to do the same: */
/* (otherwise "echo -n | xargs -I% echo %" would SEGV) */
opt |= OPT_NO_EMPTY;
} else
#endif
{
/* Store the command to be executed, part 1.
* We can statically allocate (argc + n_max_arg + 1) elements
* and do not bother with resizing args[], but on 64-bit machines
* this results in args[] vector which is ~8 times bigger
* than n_max_chars! That is, with n_max_chars == 20k,
* args[] will take 160k (!), which will most likely be
* almost entirely unused.
*/
for (i = 0; argv[i]; i++)
store_param(argv[i]);
}
initial_idx = G.idx;
while (1) {
char *rem;
G.idx = initial_idx;
rem = read_args(n_max_chars, n_max_arg, buf);
store_param(NULL);
2003-10-31 04:17:16 +05:30
if (!G.args[initial_idx]) { /* not even one ARG was added? */
if (*rem != '\0')
libbb: reduce the overhead of single parameter bb_error_msg() calls Back in 2007, commit 0c97c9d43707 ("'simple' error message functions by Loic Grenie") introduced bb_simple_perror_msg() to allow for a lower overhead call to bb_perror_msg() when only a string was being printed with no parameters. This saves space for some CPU architectures because it avoids the overhead of a call to a variadic function. However there has never been a simple version of bb_error_msg(), and since 2007 many new calls to bb_perror_msg() have been added that only take a single parameter and so could have been using bb_simple_perror_message(). This changeset introduces 'simple' versions of bb_info_msg(), bb_error_msg(), bb_error_msg_and_die(), bb_herror_msg() and bb_herror_msg_and_die(), and replaces all calls that only take a single parameter, or use something like ("%s", arg), with calls to the corresponding 'simple' version. Since it is likely that single parameter calls to the variadic functions may be accidentally reintroduced in the future a new debugging config option WARN_SIMPLE_MSG has been introduced. This uses some macro magic which will cause any such calls to generate a warning, but this is turned off by default to avoid use of the unpleasant macros in normal circumstances. This is a large changeset due to the number of calls that have been replaced. The only files that contain changes other than simple substitution of function calls are libbb.h, libbb/herror_msg.c, libbb/verror_msg.c and libbb/xfuncs_printf.c. In miscutils/devfsd.c, networking/udhcp/common.h and util-linux/mdev.c additonal macros have been added for logging so that single parameter and multiple parameter logging variants exist. The amount of space saved varies considerably by architecture, and was found to be as follows (for 'defconfig' using GCC 7.4): Arm: -92 bytes MIPS: -52 bytes PPC: -1836 bytes x86_64: -938 bytes Note that for the MIPS architecture only an exception had to be made disabling the 'simple' calls for 'udhcp' (in networking/udhcp/common.h) because it made these files larger on MIPS. Signed-off-by: James Byrne <james.byrne@origamienergy.com> Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>
2019-07-02 15:05:03 +05:30
bb_simple_error_msg_and_die("argument line too long");
if (opt & OPT_NO_EMPTY)
break;
2003-10-31 04:17:16 +05:30
}
opt |= OPT_NO_EMPTY;
2003-10-10 17:40:18 +05:30
2006-09-29 13:50:30 +05:30
if (opt & (OPT_INTERACTIVE | OPT_VERBOSE)) {
const char *fmt = " %s" + 1;
char **args = G.args;
for (i = 0; args[i]; i++) {
fprintf(stderr, fmt, args[i]);
fmt = " %s";
2003-10-31 04:17:16 +05:30
}
2006-09-29 13:50:30 +05:30
if (!(opt & OPT_INTERACTIVE))
bb_putchar_stderr('\n');
2003-10-31 04:17:16 +05:30
}
2006-09-29 13:50:30 +05:30
if (!(opt & OPT_INTERACTIVE) || xargs_ask_confirmation()) {
if (xargs_exec() != 0)
break; /* G.xargs_exitcode is set by xargs_exec() */
2003-10-31 04:17:16 +05:30
}
overlapping_strcpy(buf, rem);
} /* while */
if (ENABLE_FEATURE_CLEAN_UP) {
free(G.args);
free(buf);
}
#if ENABLE_FEATURE_XARGS_SUPPORT_PARALLEL
G.max_procs = 0;
xargs_exec(); /* final waitpid() loop */
#endif
return G.xargs_exitcode;
2003-10-10 17:40:18 +05:30
}
#ifdef TEST
2006-10-04 02:30:43 +05:30
const char *applet_name = "debug stuff usage";
2003-10-10 17:40:18 +05:30
void bb_show_usage(void)
{
fprintf(stderr, "Usage: %s [-p] [-r] [-t] -[x] [-n max_arg] [-s max_chars]\n",
2006-10-04 02:30:43 +05:30
applet_name);
exit(EXIT_FAILURE);
2003-10-10 17:40:18 +05:30
}
int main(int argc, char **argv)
{
2003-10-31 04:17:16 +05:30
return xargs_main(argc, argv);
2000-09-23 01:31:23 +05:30
}
#endif /* TEST */