2000-09-22 20:02:34 +00:00
|
|
|
/* xargs for busybox -- using GNU xargs till we can get something
|
|
|
|
* better. minix xargs is a bit smaller... */
|
2000-09-22 20:01:23 +00:00
|
|
|
|
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
|