| /* xargs for busybox -- using GNU xargs till we can get something |
| * better. minix xargs is a bit smaller... */ |
| |
| /* 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; |
| } |
| |