diff options
Diffstat (limited to 'findutils')
| -rw-r--r-- | findutils/xargs.c | 922 |
1 files changed, 922 insertions, 0 deletions
diff --git a/findutils/xargs.c b/findutils/xargs.c new file mode 100644 index 0000000..73b1a02 --- /dev/null +++ b/findutils/xargs.c @@ -0,0 +1,922 @@ +/* xargs for busybox */ + +/* xargs -- build and execute command lines from standard input + Copyright (C) 1990, 91, 92, 93, 94 Free Software Foundation, Inc. + + 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, 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., 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* Written by Mike Rendell <michael@cs.mun.ca> + and David MacKenzie <djm@gnu.ai.mit.edu>. */ + +#include "internal.h" + +#define HAVE_STRING_H 1 +#define HAVE_SYS_WAIT_H 1 +#define HAVE_UNISTD_H 1 +#define HAVE_LIMITS_H 1 +#define STDC_HEADERS 1 + +#include <sys/types.h> /* For pid_t. */ +#if HAVE_SYS_WAIT_H +#include <sys/wait.h> +#endif + +#ifndef WIFSTOPPED +#define WIFSTOPPED(w) (((w) & 0xff) == 0x7f) +#endif +#ifndef WIFSIGNALED +#define WIFSIGNALED(w) (((w) & 0xff) != 0x7f && ((w) & 0xff) != 0) +#endif +#ifndef WIFEXITED +#define WIFEXITED(w) (((w) & 0xff) == 0) +#endif + +#ifndef WSTOPSIG +#define WSTOPSIG(w) (((w) >> 8) & 0xff) +#endif +#ifndef WTERMSIG +#define WTERMSIG(w) ((w) & 0x7f) +#endif +#ifndef WEXITSTATUS +#define WEXITSTATUS(w) (((w) >> 8) & 0xff) +#endif + +#if __STDC__ +#define P_(s) s +#else +#define P_(s) () +#endif + +#include <ctype.h> + +#if !defined (isascii) || defined (STDC_HEADERS) +#ifdef isascii +#undef isascii +#endif +#define isascii(c) 1 +#endif + +#ifdef isblank +#define ISBLANK(c) (isascii (c) && isblank (c)) +#else +#define ISBLANK(c) ((c) == ' ' || (c) == '\t') +#endif + +#define ISSPACE(c) (ISBLANK (c) || (c) == '\n' || (c) == '\r' \ + || (c) == '\f' || (c) == '\v') + +#include <stdio.h> +#include <errno.h> +#include <getopt.h> + +#if defined(HAVE_STRING_H) || defined(STDC_HEADERS) +#include <string.h> +#if !defined(STDC_HEADERS) +#include <memory.h> +#endif +#else +#include <strings.h> +#define memcpy(dest, source, count) (bcopy((source), (dest), (count))) +#endif + +#ifndef _POSIX_SOURCE +#include <sys/param.h> +#endif + +#ifdef HAVE_LIMITS_H +#include <limits.h> +#endif + +#ifndef LONG_MAX +#define LONG_MAX (~(1 << (sizeof (long) * 8 - 1))) +#endif + +#ifdef HAVE_UNISTD_H +#include <unistd.h> +#endif + +#include <signal.h> + +#if !defined(SIGCHLD) && defined(SIGCLD) +#define SIGCHLD SIGCLD +#endif + +/* 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 NCARGS +#endif + +/* States for read_line. */ +#define NORM 0 +#define SPACE 1 +#define QUOTE 2 +#define BACKSLASH 3 + +#ifdef STDC_HEADERS +#include <stdlib.h> +#else +extern int errno; +#endif + +/* Return nonzero if S is the EOF string. */ +#define EOF_STR(s) (eof_str && *eof_str == *s && !strcmp (eof_str, s)) + +extern char **environ; + +/* Not char because of type promotion; NeXT gcc can't handle it. */ +typedef int boolean; +#define true 1 +#define false 0 + +#if __STDC__ +#define VOID void +#else +#define VOID char +#endif + +VOID *xmalloc P_ ((size_t n)); +VOID *xrealloc P_ ((VOID * p, size_t n)); + +/* The name this program was run with. */ +char *program_name; + +/* Buffer for reading arguments from stdin. */ +static char *linebuf; + +/* Line number in stdin since the last command was executed. */ +static int lineno = 0; + +/* If nonzero, then instead of putting the args from stdin at + the end of the command argument list, they are each stuck into the + initial args, replacing each occurrence of the `replace_pat' in the + initial args. */ +static char *replace_pat = NULL; + +/* The length of `replace_pat'. */ +static size_t rplen = 0; + +/* If nonzero, when this string is read on stdin it is treated as + end of file. + I don't like this - it should default to NULL. */ +static char *eof_str = "_"; + +/* If nonzero, the maximum number of nonblank lines from stdin to use + per command line. */ +static long lines_per_exec = 0; + +/* The maximum number of arguments to use per command line. */ +static long args_per_exec = 1024; + +/* If true, exit if lines_per_exec or args_per_exec is exceeded. */ +static boolean exit_if_size_exceeded = false; + +/* The maximum number of characters that can be used per command line. */ +static long arg_max; + +/* Storage for elements of `cmd_argv'. */ +static char *argbuf; + +/* The list of args being built. */ +static char **cmd_argv = NULL; + +/* Number of elements allocated for `cmd_argv'. */ +static int cmd_argv_alloc = 0; + +/* Number of valid elements in `cmd_argv'. */ +static int cmd_argc = 0; + +/* Number of chars being used in `cmd_argv'. */ +static int cmd_argv_chars = 0; + +/* Number of initial arguments given on the command line. */ +static int initial_argc = 0; + +/* Number of chars in the initial args. */ +static int initial_argv_chars = 0; + +/* true when building up initial arguments in `cmd_argv'. */ +static boolean initial_args = true; + +/* If nonzero, the maximum number of child processes that can be running + at once. */ +static int proc_max = 1; + +/* Total number of child processes that have been executed. */ +static int procs_executed = 0; + +/* The number of elements in `pids'. */ +static int procs_executing = 0; + +/* List of child processes currently executing. */ +static pid_t *pids = NULL; + +/* The number of allocated elements in `pids'. */ +static int pids_alloc = 0; + +/* Exit status; nonzero if any child process exited with a + status of 1-125. */ +static int child_error = 0; + +/* If true, print each command on stderr before executing it. */ +static boolean print_command = false; + +/* If true, query the user before executing each command, and only + execute the command if the user responds affirmatively. */ +static boolean query_before_executing = false; + +static struct option const longopts[] = +{ + {"null", no_argument, NULL, '0'}, + {"eof", optional_argument, NULL, 'e'}, + {"replace", optional_argument, NULL, 'i'}, + {"max-lines", optional_argument, NULL, 'l'}, + {"max-args", required_argument, NULL, 'n'}, + {"interactive", no_argument, NULL, 'p'}, + {"no-run-if-empty", no_argument, NULL, 'r'}, + {"max-chars", required_argument, NULL, 's'}, + {"verbose", no_argument, NULL, 't'}, + {"exit", no_argument, NULL, 'x'}, + {"max-procs", required_argument, NULL, 'P'}, + {"help", no_argument, NULL, 'h'}, + {NULL, no_argument, NULL, 0} +}; + +static int read_line P_ ((void)); +static int read_string P_ ((void)); +static void do_insert P_ ((char *arg, size_t arglen, size_t lblen)); +static void push_arg P_ ((char *arg, size_t len)); +static boolean print_args P_ ((boolean ask)); +static void do_exec P_ ((void)); +static void add_proc P_ ((pid_t pid)); +static void wait_for_proc P_ ((boolean all)); +static long parse_num P_ ((char *str, int option, long min, long max)); +static long env_size P_ ((char **envp)); + +int xargs_main (argc, argv) + int argc; + char **argv; +{ + int optc; + int always_run_command = 1; + long orig_arg_max; + char *default_cmd = "/bin/echo"; + int (*read_args) P_ ((void)) = read_line; + + program_name = argv[0]; + + orig_arg_max = ARG_MAX; + if (orig_arg_max == -1) + orig_arg_max = LONG_MAX; + orig_arg_max -= 2048; /* POSIX.2 requires subtracting 2048. */ + arg_max = orig_arg_max; + + /* 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 (arg_max > 20 * 1024) + arg_max = 20 * 1024; + + /* Take the size of the environment into account. */ + arg_max -= env_size (environ); + if (arg_max <= 0) + fatalError("environment is too large for exec"); + + while ((optc = getopt_long (argc, argv, "+0e::i::l::n:prs:txP:", + longopts, (int *) 0)) != -1) + { + switch (optc) + { + case '0': + read_args = read_string; + break; + + case 'e': + if (optarg) + eof_str = optarg; + else + eof_str = 0; + break; + + case 'h': + usage (xargs_usage); + + case 'i': + if (optarg) + replace_pat = optarg; + else + replace_pat = "{}"; + /* -i excludes -n -l. */ + args_per_exec = 0; + lines_per_exec = 0; + break; + + case 'l': + if (optarg) + lines_per_exec = parse_num (optarg, 'l', 1L, -1L); + else + lines_per_exec = 1; + /* -l excludes -i -n. */ + args_per_exec = 0; + replace_pat = NULL; + break; + + case 'n': + args_per_exec = parse_num (optarg, 'n', 1L, -1L); + /* -n excludes -i -l. */ + lines_per_exec = 0; + replace_pat = NULL; + break; + + case 's': + arg_max = parse_num (optarg, 's', 1L, orig_arg_max); + break; + + case 't': + print_command = true; + break; + + case 'x': + exit_if_size_exceeded = true; + break; + + case 'p': + query_before_executing = true; + print_command = true; + break; + + case 'r': + always_run_command = 0; + break; + + case 'P': + proc_max = parse_num (optarg, 'P', 0L, -1L); + break; + + default: + usage (xargs_usage); + } + } + + if (replace_pat || lines_per_exec) + exit_if_size_exceeded = true; + + if (optind == argc) + { + optind = 0; + argc = 1; + argv = &default_cmd; + } + + linebuf = (char *) xmalloc (arg_max + 1); + argbuf = (char *) xmalloc (arg_max + 1); + + /* Make sure to listen for the kids. */ + signal (SIGCHLD, SIG_DFL); + + if (!replace_pat) + { + for (; optind < argc; optind++) + push_arg (argv[optind], strlen (argv[optind]) + 1); + initial_args = false; + initial_argc = cmd_argc; + initial_argv_chars = cmd_argv_chars; + + while ((*read_args) () != -1) + if (lines_per_exec && lineno >= lines_per_exec) + { + do_exec (); + lineno = 0; + } + + /* SYSV xargs seems to do at least one exec, even if the + input is empty. */ + if (cmd_argc != initial_argc + || (always_run_command && procs_executed == 0)) + do_exec (); + } + else + { + int i; + size_t len; + size_t *arglen = (size_t *) xmalloc (sizeof (size_t) * argc); + + for (i = optind; i < argc; i++) + arglen[i] = strlen(argv[i]); + rplen = strlen (replace_pat); + while ((len = (*read_args) ()) != -1) + { + /* Don't do insert on the command name. */ + push_arg (argv[optind], arglen[optind] + 1); + len--; + for (i = optind + 1; i < argc; i++) + do_insert (argv[i], arglen[i], len); + do_exec (); + } + } + + wait_for_proc (true); + exit (child_error); +} + +/* Read a line of arguments from stdin and add them to the list of + arguments to pass to the command. Ignore blank lines and initial blanks. + Single and double quotes and backslashes quote metacharacters and blanks + as they do in the shell. + Return -1 if eof (either physical or logical) is reached, + otherwise the length of the last string read (including the null). */ + +static int +read_line () +{ + static boolean eof = false; + /* Start out in mode SPACE to always strip leading spaces (even with -i). */ + int state = SPACE; /* The type of character we last read. */ + int prevc; /* The previous value of c. */ + int quotc = 0; /* The last quote character read. */ + int c = EOF; + boolean first = true; /* true if reading first arg on line. */ + int len; + char *p = linebuf; + /* Including the NUL, the args must not grow past this point. */ + char *endbuf = linebuf + arg_max - initial_argv_chars - 1; + + if (eof) + return -1; + while (1) + { + prevc = c; + c = getc (stdin); + if (c == EOF) + { + /* COMPAT: SYSV seems to ignore stuff on a line that + ends without a \n; we don't. */ + eof = true; + if (p == linebuf) + return -1; + *p++ = '\0'; + len = p - linebuf; + /* FIXME we don't check for unterminated quotes here. */ + if (first && EOF_STR (linebuf)) + return -1; + if (!replace_pat) + push_arg (linebuf, len); + return len; + } + switch (state) + { + case SPACE: + if (ISSPACE (c)) + continue; + state = NORM; + /* aaahhhh.... */ + + case NORM: + if (c == '\n') + { + if (!ISBLANK (prevc)) + lineno++; /* For -l. */ + if (p == linebuf) + { + /* Blank line. */ + state = SPACE; + continue; + } + *p++ = '\0'; + len = p - linebuf; + if (EOF_STR (linebuf)) + { + eof = true; + return first ? -1 : len; + } + if (!replace_pat) + push_arg (linebuf, len); + return len; + } + if (!replace_pat && ISSPACE (c)) + { + *p++ = '\0'; + len = p - linebuf; + if (EOF_STR (linebuf)) + { + eof = true; + return first ? -1 : len; + } + push_arg (linebuf, len); + p = linebuf; + state = SPACE; + first = false; + continue; + } + switch (c) + { + case '\\': + state = BACKSLASH; + continue; + + case '\'': + case '"': + state = QUOTE; + quotc = c; + continue; + } + break; + + case QUOTE: + if (c == '\n') + fatalError ("unmatched %s quote", quotc == '"' ? "double" : "single"); + if (c == quotc) + { + state = NORM; + continue; + } + break; + + case BACKSLASH: + state = NORM; + break; + } + if (p >= endbuf) + fatalError ("argument line too long"); + *p++ = c; + } +} + +/* Read a null-terminated string from stdin and add it to the list of + arguments to pass to the command. + Return -1 if eof (either physical or logical) is reached, + otherwise the length of the string read (including the null). */ + +static int +read_string () +{ + static boolean eof = false; + int len; + char *p = linebuf; + /* Including the NUL, the args must not grow past this point. */ + char *endbuf = linebuf + arg_max - initial_argv_chars - 1; + + if (eof) + return -1; + while (1) + { + int c = getc (stdin); + if (c == EOF) + { + eof = true; + if (p == linebuf) + return -1; + *p++ = '\0'; + len = p - linebuf; + if (!replace_pat) + push_arg (linebuf, len); + return len; + } + if (c == '\0') + { + lineno++; /* For -l. */ + *p++ = '\0'; + len = p - linebuf; + if (!replace_pat) + push_arg (linebuf, len); + return len; + } + if (p >= endbuf) + fatalError ("argument line too long"); + *p++ = c; + } +} + +/* Replace all instances of `replace_pat' in ARG with `linebuf', + and add the resulting string to the list of arguments for the command + to execute. + ARGLEN is the length of ARG, not including the null. + LBLEN is the length of `linebuf', not including the null. + + COMPAT: insertions on the SYSV version are limited to 255 chars per line, + and a max of 5 occurences of replace_pat in the initial-arguments. + Those restrictions do not exist here. */ + +static void +do_insert (arg, arglen, lblen) + char *arg; + size_t arglen; + size_t lblen; +{ + /* Temporary copy of each arg with the replace pattern replaced by the + real arg. */ + static char *insertbuf; + char *p; + int bytes_left = arg_max - 1; /* Bytes left on the command line. */ + + if (!insertbuf) + insertbuf = (char *) xmalloc (arg_max + 1); + p = insertbuf; + + do + { + size_t len; /* Length in ARG before `replace_pat'. */ + char *s = strstr (arg, replace_pat); + if (s) + len = s - arg; + else + len = arglen; + bytes_left -= len; + if (bytes_left <= 0) + break; + + strncpy (p, arg, len); + p += len; + arg += len; + arglen -= len; + + if (s) + { + bytes_left -= lblen; + if (bytes_left <= 0) + break; + strcpy (p, linebuf); + arg += rplen; + arglen -= rplen; + p += lblen; + } + } + while (*arg); + if (*arg) + fatalError ("command too long"); + *p++ = '\0'; + push_arg (insertbuf, p - insertbuf); +} + +/* Add ARG to the end of the list of arguments `cmd_argv' to pass + to the command. + LEN is the length of ARG, including the terminating null. + If this brings the list up to its maximum size, execute the command. */ + +static void +push_arg (arg, len) + char *arg; + size_t len; +{ + if (arg) + { + if (cmd_argv_chars + len > arg_max) + { + if (initial_args || cmd_argc == initial_argc) + fatalError ("can not fit single argument within argument list size limit"); + if (replace_pat + || (exit_if_size_exceeded && + (lines_per_exec || args_per_exec))) + fatalError ("argument list too long"); + do_exec (); + } + if (!initial_args && args_per_exec && + cmd_argc - initial_argc == args_per_exec) + do_exec (); + } + + if (cmd_argc >= cmd_argv_alloc) + { + if (!cmd_argv) + { + cmd_argv_alloc = 64; + cmd_argv = (char **) xmalloc (sizeof (char *) * cmd_argv_alloc); + } + else + { + cmd_argv_alloc *= 2; + cmd_argv = (char **) xrealloc (cmd_argv, + sizeof (char *) * cmd_argv_alloc); + } + } + + if (!arg) + cmd_argv[cmd_argc++] = NULL; + else + { + cmd_argv[cmd_argc++] = argbuf + cmd_argv_chars; + strcpy (argbuf + cmd_argv_chars, arg); + cmd_argv_chars += len; + } +} + +/* Print the arguments of the command to execute. + If ASK is nonzero, prompt the user for a response, and + if the user responds affirmatively, return true; + otherwise, return false. */ + +static boolean +print_args (ask) + boolean ask; +{ + int i; + + for (i = 0; i < cmd_argc - 1; i++) + fprintf (stderr, "%s ", cmd_argv[i]); + if (ask) + { + static FILE *tty_stream; + int c, savec; + + if (!tty_stream) + { + tty_stream = fopen ("/dev/tty", "r"); + if (!tty_stream) + fatalError (" Could not open /dev/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 true; + } + else + putc ('\n', stderr); + + return false; +} + +/* Execute the command that has been built in `cmd_argv'. This may involve + waiting for processes that were previously executed. */ + +static void +do_exec () +{ + pid_t child; + + push_arg ((char *) NULL, 0); /* Null terminate the arg list. */ + if (!query_before_executing || print_args (true)) + { + if (proc_max && procs_executing >= proc_max) + wait_for_proc (false); + if (!query_before_executing && print_command) + print_args (false); + /* If we run out of processes, wait for a child to return and + try again. */ + while ((child = fork ()) < 0 && errno == EAGAIN && procs_executing) + wait_for_proc (false); + switch (child) + { + case -1: + fatalError ("cannot fork"); + + case 0: /* Child. */ + execvp (cmd_argv[0], cmd_argv); + errorMsg ("failed to exec '%s'", cmd_argv[0]); + _exit (errno == ENOENT ? 127 : 126); + } + add_proc (child); + } + + cmd_argc = initial_argc; + cmd_argv_chars = initial_argv_chars; +} + +/* Add the process with id PID to the list of processes that have + been executed. */ + +static void +add_proc (pid) + pid_t pid; +{ + int i; + + /* Find an empty slot. */ + for (i = 0; i < pids_alloc && pids[i]; i++) + ; + if (i == pids_alloc) + { + if (pids_alloc == 0) + { + pids_alloc = proc_max ? proc_max : 64; + pids = (pid_t *) xmalloc (sizeof (pid_t) * pids_alloc); + } + else + { + pids_alloc *= 2; + pids = (pid_t *) xrealloc (pids, + sizeof (pid_t) * pids_alloc); + } + memset (&pids[i], '\0', sizeof (pid_t) * (pids_alloc - i)); + } + pids[i] = pid; + procs_executing++; + procs_executed++; +} + +/* If ALL is true, wait for all child processes to finish; + otherwise, wait for one child process to finish. + Remove the processes that finish from the list of executing processes. */ + +static void +wait_for_proc (all) + boolean all; +{ + while (procs_executing) + { + int i, status; + + do + { + pid_t pid; + + pid = wait (&status); + if (pid < 0) + fatalError ("error waiting for child process"); + + /* Find the entry in `pids' for the child process + that exited. */ + for (i = 0; i < pids_alloc && pid != pids[i]; i++) + ; + } + while (i == pids_alloc); /* A child died that we didn't start? */ + + /* Remove the child from the list. */ + pids[i] = 0; + procs_executing--; + + if (WEXITSTATUS (status) == 126 || WEXITSTATUS (status) == 127) + exit (WEXITSTATUS (status)); /* Can't find or run the command. */ + if (WEXITSTATUS (status) == 255) + fatalError ( "%s: exited with status 255; aborting", cmd_argv[0]); + if (WIFSTOPPED (status)) + fatalError ( "%s: stopped by signal %d", cmd_argv[0], WSTOPSIG (status)); + if (WIFSIGNALED (status)) + fatalError ("%s: terminated by signal %d", cmd_argv[0], WTERMSIG (status)); + if (WEXITSTATUS (status) != 0) + child_error = 123; + + if (!all) + break; + } +} + +/* Return the value of the number represented in STR. + OPTION is the command line option to which STR is the argument. + If the value does not fall within the boundaries MIN and MAX, + Print an error message mentioning OPTION and exit. */ + +static long +parse_num (str, option, min, max) + char *str; + int option; + long min; + long max; +{ + char *eptr; + long val; + + val = strtol (str, &eptr, 10); + if (eptr == str || *eptr) + { + fprintf (stderr, "%s: invalid number for -%c option\n", + program_name, option); + usage (xargs_usage); + } + else if (val < min) + { + fprintf (stderr, "%s: value for -%c option must be >= %ld\n", + program_name, option, min); + usage (xargs_usage); + } + else if (max >= 0 && val > max) + { + fprintf (stderr, "%s: value for -%c option must be < %ld\n", + program_name, option, max); + usage (xargs_usage); + } + return val; +} + +/* Return how much of ARG_MAX is used by the environment. */ + +static long +env_size (envp) + char **envp; +{ + long len = 0; + + while (*envp) + len += strlen (*envp++) + 1; + + return len; +} + |