Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/xargs/xargs.c	Lines:	104	265	39.2 %
Date:	2017-11-07	Branches:	82	216	38.0 %


/*	$OpenBSD: xargs.c,v 1.32 2017/01/19 17:08:41 millert Exp $	*/
/*	$FreeBSD: xargs.c,v 1.51 2003/05/03 19:09:11 obrien Exp $	*/

/*-
 * Copyright (c) 1990, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * John B. Roll Jr.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * $xMach: xargs.c,v 1.6 2002/02/23 05:27:47 tim Exp $
 */

#include <sys/wait.h>

#include <ctype.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <langinfo.h>
#include <locale.h>
#include <paths.h>
#include <regex.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <limits.h>

#include "pathnames.h"

static void	parse_input(int, char *[]);
static void	prerun(int, char *[]);
static int	prompt(void);
static void	run(char **);
static void	usage(void);
void		strnsubst(char **, const char *, const char *, size_t);
static void	waitchildren(const char *, int);

static char **av, **bxp, **ep, **endxp, **xp;
static char *argp, *bbp, *ebp, *inpline, *p, *replstr;
static const char *eofstr;
static int count, insingle, indouble, oflag, pflag, tflag, Rflag, rval, zflag;
static int cnt, Iflag, jfound, Lflag, wasquoted, xflag, runeof = 1;
static int curprocs, maxprocs;
static size_t inpsize;

extern char **environ;

int
main(int argc, char *argv[])
{
	long arg_max;
	int ch, Jflag, nargs, nflag, nline;
	size_t linelen;
	char *endptr;
	const char *errstr;

	inpline = replstr = NULL;
	ep = environ;
	eofstr = "";
	Jflag = nflag = 0;

	(void)setlocale(LC_MESSAGES, "");

	/*
	 * POSIX.2 limits the exec line length to ARG_MAX - 2K.  Running that
	 * caused some E2BIG errors, so it was changed to ARG_MAX - 4K.  Given
	 * that the smallest argument is 2 bytes in length, this means that
	 * the number of arguments is limited to:
	 *
	 *	 (ARG_MAX - 4K - LENGTH(utility + arguments)) / 2.
	 *
	 * We arbitrarily limit the number of arguments to 5000.  This is
	 * allowed by POSIX.2 as long as the resulting minimum exec line is
	 * at least LINE_MAX.  Realloc'ing as necessary is possible, but
	 * probably not worthwhile.
	 */
	nargs = 5000;
	if ((arg_max = sysconf(_SC_ARG_MAX)) == -1)
		errx(1, "sysconf(_SC_ARG_MAX) failed");

	if (pledge("stdio rpath proc exec flock cpath wpath", NULL) == -1)
		err(1, "pledge");

	nline = arg_max - 4 * 1024;
	while (*ep != NULL) {
		/* 1 byte for each '\0' */
		nline -= strlen(*ep++) + 1 + sizeof(*ep);
	}
	maxprocs = 1;
	while ((ch = getopt(argc, argv, "0E:I:J:L:n:oP:pR:rs:tx")) != -1)
		switch (ch) {
		case 'E':
			eofstr = optarg;
			break;
		case 'I':
			Jflag = 0;
			Iflag = 1;
			Lflag = 1;
			replstr = optarg;
			break;
		case 'J':
			Iflag = 0;
			Jflag = 1;
			replstr = optarg;
			break;
		case 'L':
			Lflag = strtonum(optarg, 0, INT_MAX, &errstr);
			if (errstr)
				errx(1, "-L %s: %s", optarg, errstr);
			break;
		case 'n':
			nflag = 1;
			nargs = strtonum(optarg, 1, INT_MAX, &errstr);
			if (errstr)
				errx(1, "-n %s: %s", optarg, errstr);
			break;
		case 'o':
			oflag = 1;
			break;
		case 'P':
			maxprocs = strtonum(optarg, 1, INT_MAX, &errstr);
			if (errstr)
				errx(1, "-P %s: %s", optarg, errstr);
			break;
		case 'p':
			pflag = 1;
			break;
		case 'r':
			runeof = 0;
			break;
		case 'R':
			Rflag = strtol(optarg, &endptr, 10);
			if (*endptr != '\0')
				errx(1, "replacements must be a number");
			break;
		case 's':
			nline = strtonum(optarg, 0, INT_MAX, &errstr);
			if (errstr)
				errx(1, "-s %s: %s", optarg, errstr);
			break;
		case 't':
			tflag = 1;
			break;
		case 'x':
			xflag = 1;
			break;
		case '0':
			zflag = 1;
			break;
		case '?':
		default:
			usage();
	}
	argc -= optind;
	argv += optind;

	if (!Iflag && Rflag)
		usage();
	if (Iflag && !Rflag)
		Rflag = 5;
	if (xflag && !nflag)
		usage();
	if (Iflag || Lflag)
		xflag = 1;
	if (replstr != NULL && *replstr == '\0')
		errx(1, "replstr may not be empty");

	/*
	 * Allocate pointers for the utility name, the utility arguments,
	 * the maximum arguments to be read from stdin and the trailing
	 * NULL.
	 */
	linelen = 1 + argc + nargs + 1;
	if ((av = bxp = calloc(linelen, sizeof(char **))) == NULL)
		err(1, NULL);

	/*
	 * Use the user's name for the utility as argv[0], just like the
	 * shell.  Echo is the default.  Set up pointers for the user's
	 * arguments.
	 */
	if (*argv == NULL)
		cnt = strlen(*bxp++ = _PATH_ECHO);
	else {
		do {
			if (Jflag && strcmp(*argv, replstr) == 0) {
				char **avj;
				jfound = 1;
				argv++;
				for (avj = argv; *avj; avj++)
					cnt += strlen(*avj) + 1;
				break;
			}
			cnt += strlen(*bxp++ = *argv) + 1;
		} while (*++argv != NULL);
	}

	/*
	 * Set up begin/end/traversing pointers into the array.  The -n
	 * count doesn't include the trailing NULL pointer, so the malloc
	 * added in an extra slot.
	 */
	endxp = (xp = bxp) + nargs;

	/*
	 * Allocate buffer space for the arguments read from stdin and the
	 * trailing NULL.  Buffer space is defined as the default or specified
	 * space, minus the length of the utility name and arguments.  Set up
	 * begin/end/traversing pointers into the array.  The -s count does
	 * include the trailing NULL, so the malloc didn't add in an extra
	 * slot.
	 */
	nline -= cnt;
	if (nline <= 0)
		errx(1, "insufficient space for command");

	if ((bbp = malloc((size_t)(nline + 1))) == NULL)
		err(1, NULL);
	ebp = (argp = p = bbp) + nline - 1;
	for (;;)
		parse_input(argc, argv);
}

static void
parse_input(int argc, char *argv[])
{
	int hasblank = 0;
	static int hadblank = 0;
	int ch, foundeof = 0;
	char **avj;

	ch = getchar();
	if (isblank(ch)) {
		/* Quotes escape tabs and spaces. */
		if (insingle || indouble)
			goto addch;
		hasblank = 1;
		if (zflag)
			goto addch;
		goto arg2;
	}

	switch (ch) {
	case EOF:
		/* No arguments since last exec. */
		if (p == bbp) {
			if (runeof)
				prerun(0, av);
			waitchildren(*argv, 1);
			exit(rval);
		}
		goto arg1;
	case '\0':
		if (zflag) {
			/*
			 * Increment 'count', so that nulls will be treated
			 * as end-of-line, as well as end-of-argument.  This
			 * is needed so -0 works properly with -I and -L.
			 */
			count++;
			goto arg2;
		}
		goto addch;
	case '\n':
		if (zflag)
			goto addch;
		hasblank = 1;
		if (hadblank == 0)
			count++;

		/* Quotes do not escape newlines. */
arg1:		if (insingle || indouble)
			errx(1, "unterminated quote");
arg2:
		foundeof = *eofstr != '\0' &&
		    strcmp(argp, eofstr) == 0;

		/* Do not make empty args unless they are quoted */
		if ((argp != p || wasquoted) && !foundeof) {
			*p++ = '\0';
			*xp++ = argp;
			if (Iflag) {
				size_t curlen;

				if (inpline == NULL)
					curlen = 0;
				else {
					/*
					 * If this string is not zero
					 * length, append a space for
					 * separation before the next
					 * argument.
					 */
					if ((curlen = strlen(inpline)))
						strlcat(inpline, " ", inpsize);
				}
				curlen++;
				/*
				 * Allocate enough to hold what we will
				 * be holding in a second, and to append
				 * a space next time through, if we have
				 * to.
				 */
				inpsize = curlen + 2 + strlen(argp);
				inpline = realloc(inpline, inpsize);
				if (inpline == NULL)
					errx(1, "realloc failed");
				if (curlen == 1)
					strlcpy(inpline, argp, inpsize);
				else
					strlcat(inpline, argp, inpsize);
			}
		}

		/*
		 * If max'd out on args or buffer, or reached EOF,
		 * run the command.  If xflag and max'd out on buffer
		 * but not on args, object.  Having reached the limit
		 * of input lines, as specified by -L is the same as
		 * maxing out on arguments.
		 */
		if (xp == endxp || p > ebp || ch == EOF ||
		    (Lflag <= count && xflag) || foundeof) {
			if (xflag && xp != endxp && p > ebp)
				errx(1, "insufficient space for arguments");
			if (jfound) {
				for (avj = argv; *avj; avj++)
					*xp++ = *avj;
			}
			prerun(argc, av);
			if (ch == EOF || foundeof) {
				waitchildren(*argv, 1);
				exit(rval);
			}
			p = bbp;
			xp = bxp;
			count = 0;
		}
		argp = p;
		wasquoted = 0;
		break;
	case '\'':
		if (indouble || zflag)
			goto addch;
		insingle = !insingle;
		wasquoted = 1;
		break;
	case '"':
		if (insingle || zflag)
			goto addch;
		indouble = !indouble;
		wasquoted = 1;
		break;
	case '\\':
		if (zflag)
			goto addch;
		/* Backslash escapes anything, is escaped by quotes. */
		if (!insingle && !indouble && (ch = getchar()) == EOF)
			errx(1, "backslash at EOF");
		/* FALLTHROUGH */
	default:
addch:		if (p < ebp) {
			*p++ = ch;
			break;
		}

		/* If only one argument, not enough buffer space. */
		if (bxp == xp)
			errx(1, "insufficient space for argument");
		/* Didn't hit argument limit, so if xflag object. */
		if (xflag)
			errx(1, "insufficient space for arguments");

		if (jfound) {
			for (avj = argv; *avj; avj++)
				*xp++ = *avj;
		}
		prerun(argc, av);
		xp = bxp;
		cnt = ebp - argp;
		memcpy(bbp, argp, (size_t)cnt);
		p = (argp = bbp) + cnt;
		*p++ = ch;
		break;
	}
	hadblank = hasblank;
}

/*
 * Do things necessary before run()'ing, such as -I substitution,
 * and then call run().
 */
static void
prerun(int argc, char *argv[])
{
	char **tmp, **tmp2, **avj;
	int repls;

	repls = Rflag;
	runeof = 0;

	if (argc == 0 || repls == 0) {
		*xp = NULL;
		run(argv);
		return;
	}

	avj = argv;

	/*
	 * Allocate memory to hold the argument list, and
	 * a NULL at the tail.
	 */
	tmp = calloc(argc + 1, sizeof(char**));
	if (tmp == NULL)
		err(1, NULL);
	tmp2 = tmp;

	/*
	 * Save the first argument and iterate over it, we
	 * cannot do strnsubst() to it.
	 */
	if ((*tmp++ = strdup(*avj++)) == NULL)
		err(1, NULL);

	/*
	 * For each argument to utility, if we have not used up
	 * the number of replacements we are allowed to do, and
	 * if the argument contains at least one occurrence of
	 * replstr, call strnsubst(), else just save the string.
	 * Iterations over elements of avj and tmp are done
	 * where appropriate.
	 */
	while (--argc) {
		*tmp = *avj++;
		if (repls && strstr(*tmp, replstr) != NULL) {
			strnsubst(tmp++, replstr, inpline, (size_t)255);
			if (repls > 0)
				repls--;
		} else {
			if ((*tmp = strdup(*tmp)) == NULL)
				err(1, NULL);
			tmp++;
		}
	}

	/*
	 * Run it.
	 */
	*tmp = NULL;
	run(tmp2);

	/*
	 * Walk from the tail to the head, free along the way.
	 */
	for (; tmp2 != tmp; tmp--)
		free(*tmp);
	/*
	 * Now free the list itself.
	 */
	free(tmp2);

	/*
	 * Free the input line buffer, if we have one.
	 */
	free(inpline);
	inpline = NULL;
}

static void
run(char **argv)
{
	pid_t pid;
	int fd;
	char **avec;

	/*
	 * If the user wants to be notified of each command before it is
	 * executed, notify them.  If they want the notification to be
	 * followed by a prompt, then prompt them.
	 */
	if (tflag || pflag) {
		(void)fprintf(stderr, "%s", *argv);
		for (avec = argv + 1; *avec != NULL; ++avec)
			(void)fprintf(stderr, " %s", *avec);
		/*
		 * If the user has asked to be prompted, do so.
		 */
		if (pflag)
			/*
			 * If they asked not to exec, return without execution
			 * but if they asked to, go to the execution.  If we
			 * could not open their tty, break the switch and drop
			 * back to -t behaviour.
			 */
			switch (prompt()) {
			case 0:
				return;
			case 1:
				goto exec;
			case 2:
				break;
			}
		(void)fprintf(stderr, "\n");
		(void)fflush(stderr);
	}
exec:
	switch (pid = vfork()) {
	case -1:
		err(1, "vfork");
	case 0:
		if (oflag) {
			if ((fd = open(_PATH_TTY, O_RDONLY)) == -1) {
				warn("can't open /dev/tty");
				_exit(1);
			}
		} else {
			fd = open(_PATH_DEVNULL, O_RDONLY);
		}
		if (fd > STDIN_FILENO) {
			if (dup2(fd, STDIN_FILENO) != 0) {
				warn("can't dup2 to stdin");
				_exit(1);
			}
			close(fd);
		}
		execvp(argv[0], argv);
		warn("%s", argv[0]);
		_exit(errno == ENOENT ? 127 : 126);
	}
	curprocs++;
	waitchildren(*argv, 0);
}

static void
waitchildren(const char *name, int waitall)
{
	pid_t pid;
	int status;

	while ((pid = waitpid(-1, &status, !waitall && curprocs < maxprocs ?
	    WNOHANG : 0)) > 0) {
		curprocs--;
		/*
		 * According to POSIX, we have to exit if the utility exits
		 * with a 255 status, or is interrupted by a signal.
		 * We are allowed to return any exit status between 1 and
		 * 125 in these cases, but we'll use 124 and 125, the same
		 * values used by GNU xargs.
		 */
		if (WIFEXITED(status)) {
			if (WEXITSTATUS(status) == 255) {
				warnx("%s exited with status 255", name);
				exit(124);
			} else if (WEXITSTATUS(status) == 127 ||
			    WEXITSTATUS(status) == 126) {
				exit(WEXITSTATUS(status));
			} else if (WEXITSTATUS(status) != 0) {
				rval = 123;
			}
		} else if (WIFSIGNALED(status)) {
			if (WTERMSIG(status) != SIGPIPE) {
				if (WTERMSIG(status) < NSIG)
					warnx("%s terminated by SIG%s", name,
					    sys_signame[WTERMSIG(status)]);
				else
					warnx("%s terminated by signal %d",
					    name, WTERMSIG(status));
			}
			exit(125);
		}
	}
	if (pid == -1 && errno != ECHILD)
		err(1, "waitpid");
}

/*
 * Prompt the user about running a command.
 */
static int
prompt(void)
{
	regex_t cre;
	size_t rsize;
	int match;
	char *response;
	FILE *ttyfp;

	if ((ttyfp = fopen(_PATH_TTY, "r")) == NULL)
		return (2);	/* Indicate that the TTY failed to open. */
	(void)fprintf(stderr, "?...");
	(void)fflush(stderr);
	if ((response = fgetln(ttyfp, &rsize)) == NULL ||
	    regcomp(&cre, nl_langinfo(YESEXPR), REG_BASIC) != 0) {
		(void)fclose(ttyfp);
		return (0);
	}
	response[rsize - 1] = '\0';
	match = regexec(&cre, response, 0, NULL, 0);
	(void)fclose(ttyfp);
	regfree(&cre);
	return (match == 0);
}

static void
usage(void)
{
	fprintf(stderr,
"usage: xargs [-0oprt] [-E eofstr] [-I replstr [-R replacements]] [-J replstr]\n"
"             [-L number] [-n number [-x]] [-P maxprocs] [-s size]\n"
"             [utility [argument ...]]\n");
	exit(1);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: xargs.c,v 1.32 2017/01/19 17:08:41 millert Exp $ */
2			/* $FreeBSD: xargs.c,v 1.51 2003/05/03 19:09:11 obrien Exp $ */
3
4			/*-
5			* Copyright (c) 1990, 1993
6			* The Regents of the University of California. All rights reserved.
7			*
8			* This code is derived from software contributed to Berkeley by
9			* John B. Roll Jr.
10			*
11			* Redistribution and use in source and binary forms, with or without
12			* modification, are permitted provided that the following conditions
13			* are met:
14			* 1. Redistributions of source code must retain the above copyright
15			* notice, this list of conditions and the following disclaimer.
16			* 2. Redistributions in binary form must reproduce the above copyright
17			* notice, this list of conditions and the following disclaimer in the
18			* documentation and/or other materials provided with the distribution.
19			* 3. Neither the name of the University nor the names of its contributors
20			* may be used to endorse or promote products derived from this software
21			* without specific prior written permission.
22			*
23			* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26			* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33			* SUCH DAMAGE.
34			*
35			* $xMach: xargs.c,v 1.6 2002/02/23 05:27:47 tim Exp $
36			*/
37
38			#include <sys/wait.h>
39
40			#include <ctype.h>
41			#include <err.h>
42			#include <errno.h>
43			#include <fcntl.h>
44			#include <langinfo.h>
45			#include <locale.h>
46			#include <paths.h>
47			#include <regex.h>
48			#include <signal.h>
49			#include <stdio.h>
50			#include <stdlib.h>
51			#include <string.h>
52			#include <unistd.h>
53			#include <limits.h>
54
55			#include "pathnames.h"
56
57			static void parse_input(int, char *[]);
58			static void prerun(int, char *[]);
59			static int prompt(void);
60			static void run(char **);
61			static void usage(void);
62			void strnsubst(char *, const char , const char *, size_t);
63			static void waitchildren(const char *, int);
64
65			static char av, bxp, ep, endxp, **xp;
66			static char argp, bbp, ebp, inpline, p, replstr;
67			static const char *eofstr;
68			static int count, insingle, indouble, oflag, pflag, tflag, Rflag, rval, zflag;
69			static int cnt, Iflag, jfound, Lflag, wasquoted, xflag, runeof = 1;
70			static int curprocs, maxprocs;
71			static size_t inpsize;
72
73			extern char **environ;
74
75			int
76			main(int argc, char *argv[])
77			{
78			long arg_max;
79			int ch, Jflag, nargs, nflag, nline;
80			size_t linelen;
81		1006	char *endptr;
82		503	const char *errstr;
83
84		503	inpline = replstr = NULL;
85		503	ep = environ;
86		503	eofstr = "";
87			Jflag = nflag = 0;
88
89		503	(void)setlocale(LC_MESSAGES, "");
90
91			/*
92			* POSIX.2 limits the exec line length to ARG_MAX - 2K. Running that
93			* caused some E2BIG errors, so it was changed to ARG_MAX - 4K. Given
94			* that the smallest argument is 2 bytes in length, this means that
95			* the number of arguments is limited to:
96			*
97			* (ARG_MAX - 4K - LENGTH(utility + arguments)) / 2.
98			*
99			* We arbitrarily limit the number of arguments to 5000. This is
100			* allowed by POSIX.2 as long as the resulting minimum exec line is
101			* at least LINE_MAX. Realloc'ing as necessary is possible, but
102			* probably not worthwhile.
103			*/
104			nargs = 5000;
105	✗✓	503	if ((arg_max = sysconf(_SC_ARG_MAX)) == -1)
106			errx(1, "sysconf(_SC_ARG_MAX) failed");
107
108	✗✓	503	if (pledge("stdio rpath proc exec flock cpath wpath", NULL) == -1)
109			err(1, "pledge");
110
111		503	nline = arg_max - 4 * 1024;
112	✓✓	25778	while (*ep != NULL) {
113			/* 1 byte for each '\0' */
114		12386	nline -= strlen(ep++) + 1 + sizeof(ep);
115			}
116		503	maxprocs = 1;
117	✓✓	1504	while ((ch = getopt(argc, argv, "0E:I:J:L:n:oP:pR:rs:tx")) != -1)
118	✗✗✗✓ ✓✗✗✗ ✓✗✗✗ ✗✓✗	498	switch (ch) {
119			case 'E':
120			eofstr = optarg;
121			break;
122			case 'I':
123			Jflag = 0;
124			Iflag = 1;
125			Lflag = 1;
126			replstr = optarg;
127			break;
128			case 'J':
129			Iflag = 0;
130			Jflag = 1;
131			replstr = optarg;
132			break;
133			case 'L':
134		238	Lflag = strtonum(optarg, 0, INT_MAX, &errstr);
135	✓✗	238	if (errstr)
136			errx(1, "-L %s: %s", optarg, errstr);
137			break;
138			case 'n':
139			nflag = 1;
140		2	nargs = strtonum(optarg, 1, INT_MAX, &errstr);
141	✓✗	2	if (errstr)
142			errx(1, "-n %s: %s", optarg, errstr);
143			break;
144			case 'o':
145			oflag = 1;
146			break;
147			case 'P':
148			maxprocs = strtonum(optarg, 1, INT_MAX, &errstr);
149			if (errstr)
150			errx(1, "-P %s: %s", optarg, errstr);
151			break;
152			case 'p':
153			pflag = 1;
154			break;
155			case 'r':
156		10	runeof = 0;
157		10	break;
158			case 'R':
159			Rflag = strtol(optarg, &endptr, 10);
160			if (*endptr != '\0')
161			errx(1, "replacements must be a number");
162			break;
163			case 's':
164			nline = strtonum(optarg, 0, INT_MAX, &errstr);
165			if (errstr)
166			errx(1, "-s %s: %s", optarg, errstr);
167			break;
168			case 't':
169			tflag = 1;
170			break;
171			case 'x':
172			xflag = 1;
173			break;
174			case '0':
175		248	zflag = 1;
176		248	break;
177			case '?':
178			default:
179			usage();
180			}
181		503	argc -= optind;
182		503	argv += optind;
183
184	✗✓	503	if (!Iflag && Rflag)
185			usage();
186	✗✓	503	if (Iflag && !Rflag)
187			Rflag = 5;
188	✗✓	503	if (xflag && !nflag)
189			usage();
190	✓✓	503	if (Iflag \|\| Lflag)
191		238	xflag = 1;
192	✗✓✗✗	503	if (replstr != NULL && *replstr == '\0')
193			errx(1, "replstr may not be empty");
194
195			/*
196			* Allocate pointers for the utility name, the utility arguments,
197			* the maximum arguments to be read from stdin and the trailing
198			* NULL.
199			*/
200		503	linelen = 1 + argc + nargs + 1;
201	✗✓	503	if ((av = bxp = calloc(linelen, sizeof(char **))) == NULL)
202			err(1, NULL);
203
204			/*
205			* Use the user's name for the utility as argv[0], just like the
206			* shell. Echo is the default. Set up pointers for the user's
207			* arguments.
208			*/
209	✗✓	503	if (*argv == NULL)
210			cnt = strlen(*bxp++ = _PATH_ECHO);
211			else {
212			do {
213	✗✓✗✗	521	if (Jflag && strcmp(*argv, replstr) == 0) {
214			char **avj;
215			jfound = 1;
216			argv++;
217			for (avj = argv; *avj; avj++)
218			cnt += strlen(*avj) + 1;
219			break;
220			}
221		521	cnt += strlen(bxp++ = argv) + 1;
222	✓✓	521	} while (*++argv != NULL);
223			}
224
225			/*
226			* Set up begin/end/traversing pointers into the array. The -n
227			* count doesn't include the trailing NULL pointer, so the malloc
228			* added in an extra slot.
229			*/
230		503	endxp = (xp = bxp) + nargs;
231
232			/*
233			* Allocate buffer space for the arguments read from stdin and the
234			* trailing NULL. Buffer space is defined as the default or specified
235			* space, minus the length of the utility name and arguments. Set up
236			* begin/end/traversing pointers into the array. The -s count does
237			* include the trailing NULL, so the malloc didn't add in an extra
238			* slot.
239			*/
240		503	nline -= cnt;
241	✗✓	503	if (nline <= 0)
242			errx(1, "insufficient space for command");
243
244	✗✓	503	if ((bbp = malloc((size_t)(nline + 1))) == NULL)
245			err(1, NULL);
246		503	ebp = (argp = p = bbp) + nline - 1;
247		397879	for (;;)
248		397376	parse_input(argc, argv);
249			}
250
251			static void
252			parse_input(int argc, char *argv[])
253			{
254			int hasblank = 0;
255			static int hadblank = 0;
256			int ch, foundeof = 0;
257			char **avj;
258
259	✓✗✓✓	1986880	ch = getchar();
260	✓✓	397376	if (isblank(ch)) {
261			/* Quotes escape tabs and spaces. */
262	✓✗	406	if (insingle \|\| indouble)
263			goto addch;
264			hasblank = 1;
265	✓✓	406	if (zflag)
266			goto addch;
267			goto arg2;
268			}
269
270	✓✓✓✗ ✗✓✓	397670	switch (ch) {
271			case EOF:
272			/* No arguments since last exec. */
273	✗✓	503	if (p == bbp) {
274			if (runeof)
275			prerun(0, av);
276			waitchildren(*argv, 1);
277			exit(rval);
278			}
279			goto arg1;
280			case '\0':
281	✓✗	10167	if (zflag) {
282			/*
283			* Increment 'count', so that nulls will be treated
284			* as end-of-line, as well as end-of-argument. This
285			* is needed so -0 works properly with -I and -L.
286			*/
287		10167	count++;
288		10167	goto arg2;
289			}
290			goto addch;
291			case '\n':
292	✓✓	1287	if (zflag)
293			goto addch;
294			hasblank = 1;
295	✓✓	1035	if (hadblank == 0)
296		947	count++;
297
298			/* Quotes do not escape newlines. */
299	✗✓	1538	arg1: if (insingle \|\| indouble)
300			errx(1, "unterminated quote");
301			arg2:
302	✗✓	23774	foundeof = *eofstr != '\0' &&
303			strcmp(argp, eofstr) == 0;
304
305			/* Do not make empty args unless they are quoted */
306	✓✓	11887	if ((argp != p \|\| wasquoted) && !foundeof) {
307		11716	*p++ = '\0';
308		11716	*xp++ = argp;
309	✗✓	11716	if (Iflag) {
310			size_t curlen;
311
312			if (inpline == NULL)
313			curlen = 0;
314			else {
315			/*
316			* If this string is not zero
317			* length, append a space for
318			* separation before the next
319			* argument.
320			*/
321			if ((curlen = strlen(inpline)))
322			strlcat(inpline, " ", inpsize);
323			}
324			curlen++;
325			/*
326			* Allocate enough to hold what we will
327			* be holding in a second, and to append
328			* a space next time through, if we have
329			* to.
330			*/
331			inpsize = curlen + 2 + strlen(argp);
332			inpline = realloc(inpline, inpsize);
333			if (inpline == NULL)
334			errx(1, "realloc failed");
335			if (curlen == 1)
336			strlcpy(inpline, argp, inpsize);
337			else
338			strlcat(inpline, argp, inpsize);
339			}
340			}
341
342			/*
343			* If max'd out on args or buffer, or reached EOF,
344			* run the command. If xflag and max'd out on buffer
345			* but not on args, object. Having reached the limit
346			* of input lines, as specified by -L is the same as
347			* maxing out on arguments.
348			*/
349	✓✗✓✓	23774	if (xp == endxp \|\| p > ebp \|\| ch == EOF \|\|
350	✓✓	11384	(Lflag <= count && xflag) \|\| foundeof) {
351	✓✓✓✗ ✗✓	1483	if (xflag && xp != endxp && p > ebp)
352			errx(1, "insufficient space for arguments");
353	✗✓	671	if (jfound) {
354			for (avj = argv; *avj; avj++)
355			xp++ = avj;
356			}
357		671	prerun(argc, av);
358	✓✓	671	if (ch == EOF \|\| foundeof) {
359			waitchildren(*argv, 1);
360			exit(rval);
361			}
362		168	p = bbp;
363		168	xp = bxp;
364		168	count = 0;
365		168	}
366		11384	argp = p;
367		11384	wasquoted = 0;
368		11384	break;
369			case '\'':
370			if (indouble \|\| zflag)
371			goto addch;
372			insingle = !insingle;
373			wasquoted = 1;
374			break;
375			case '"':
376			if (insingle \|\| zflag)
377			goto addch;
378			indouble = !indouble;
379			wasquoted = 1;
380			break;
381			case '\\':
382	✓✓	224	if (zflag)
383			goto addch;
384			/* Backslash escapes anything, is escaped by quotes. */
385	✓✗✓✗ ✗✓✗✓	560	if (!insingle && !indouble && (ch = getchar()) == EOF)
386			errx(1, "backslash at EOF");
387			/* FALLTHROUGH */
388			default:
389	✓✗	385489	addch: if (p < ebp) {
390		385489	*p++ = ch;
391		385489	break;
392			}
393
394			/* If only one argument, not enough buffer space. */
395			if (bxp == xp)
396			errx(1, "insufficient space for argument");
397			/* Didn't hit argument limit, so if xflag object. */
398			if (xflag)
399			errx(1, "insufficient space for arguments");
400
401			if (jfound) {
402			for (avj = argv; *avj; avj++)
403			xp++ = avj;
404			}
405			prerun(argc, av);
406			xp = bxp;
407			cnt = ebp - argp;
408			memcpy(bbp, argp, (size_t)cnt);
409			p = (argp = bbp) + cnt;
410			*p++ = ch;
411			break;
412			}
413		396873	hadblank = hasblank;
414		396873	}
415
416			/*
417			* Do things necessary before run()'ing, such as -I substitution,
418			* and then call run().
419			*/
420			static void
421			prerun(int argc, char *argv[])
422			{
423			char tmp, tmp2, **avj;
424			int repls;
425
426		1342	repls = Rflag;
427		671	runeof = 0;
428
429	✓✗	671	if (argc == 0 \|\| repls == 0) {
430		671	*xp = NULL;
431		671	run(argv);
432		671	return;
433			}
434
435			avj = argv;
436
437			/*
438			* Allocate memory to hold the argument list, and
439			* a NULL at the tail.
440			*/
441			tmp = calloc(argc + 1, sizeof(char**));
442			if (tmp == NULL)
443			err(1, NULL);
444			tmp2 = tmp;
445
446			/*
447			* Save the first argument and iterate over it, we
448			* cannot do strnsubst() to it.
449			*/
450			if ((tmp++ = strdup(avj++)) == NULL)
451			err(1, NULL);
452
453			/*
454			* For each argument to utility, if we have not used up
455			* the number of replacements we are allowed to do, and
456			* if the argument contains at least one occurrence of
457			* replstr, call strnsubst(), else just save the string.
458			* Iterations over elements of avj and tmp are done
459			* where appropriate.
460			*/
461			while (--argc) {
462			tmp = avj++;
463			if (repls && strstr(*tmp, replstr) != NULL) {
464			strnsubst(tmp++, replstr, inpline, (size_t)255);
465			if (repls > 0)
466			repls--;
467			} else {
468			if ((tmp = strdup(tmp)) == NULL)
469			err(1, NULL);
470			tmp++;
471			}
472			}
473
474			/*
475			* Run it.
476			*/
477			*tmp = NULL;
478			run(tmp2);
479
480			/*
481			* Walk from the tail to the head, free along the way.
482			*/
483			for (; tmp2 != tmp; tmp--)
484			free(*tmp);
485			/*
486			* Now free the list itself.
487			*/
488			free(tmp2);
489
490			/*
491			* Free the input line buffer, if we have one.
492			*/
493			free(inpline);
494			inpline = NULL;
495		671	}
496
497			static void
498			run(char **argv)
499			{
500			pid_t pid;
501			int fd;
502			char **avec;
503
504			/*
505			* If the user wants to be notified of each command before it is
506			* executed, notify them. If they want the notification to be
507			* followed by a prompt, then prompt them.
508			*/
509	✗✓	1342	if (tflag \|\| pflag) {
510			(void)fprintf(stderr, "%s", *argv);
511			for (avec = argv + 1; *avec != NULL; ++avec)
512			(void)fprintf(stderr, " %s", *avec);
513			/*
514			* If the user has asked to be prompted, do so.
515			*/
516			if (pflag)
517			/*
518			* If they asked not to exec, return without execution
519			* but if they asked to, go to the execution. If we
520			* could not open their tty, break the switch and drop
521			* back to -t behaviour.
522			*/
523			switch (prompt()) {
524			case 0:
525			return;
526			case 1:
527			goto exec;
528			case 2:
529			break;
530			}
531			(void)fprintf(stderr, "\n");
532			(void)fflush(stderr);
533			}
534			exec:
535	✗✗✓	671	switch (pid = vfork()) {
536			case -1:
537			err(1, "vfork");
538			case 0:
539			if (oflag) {
540			if ((fd = open(_PATH_TTY, O_RDONLY)) == -1) {
541			warn("can't open /dev/tty");
542			_exit(1);
543			}
544			} else {
545			fd = open(_PATH_DEVNULL, O_RDONLY);
546			}
547			if (fd > STDIN_FILENO) {
548			if (dup2(fd, STDIN_FILENO) != 0) {
549			warn("can't dup2 to stdin");
550			_exit(1);
551			}
552			close(fd);
553			}
554			execvp(argv[0], argv);
555			warn("%s", argv[0]);
556			_exit(errno == ENOENT ? 127 : 126);
557			}
558		671	curprocs++;
559		671	waitchildren(*argv, 0);
560		1342	}
561
562			static void
563			waitchildren(const char *name, int waitall)
564			{
565			pid_t pid;
566		2348	int status;
567
568	✓✓✓✓	8051	while ((pid = waitpid(-1, &status, !waitall && curprocs < maxprocs ?
569		1845	WNOHANG : 0)) > 0) {
570		671	curprocs--;
571			/*
572			* According to POSIX, we have to exit if the utility exits
573			* with a 255 status, or is interrupted by a signal.
574			* We are allowed to return any exit status between 1 and
575			* 125 in these cases, but we'll use 124 and 125, the same
576			* values used by GNU xargs.
577			*/
578	✓✗	671	if (WIFEXITED(status)) {
579	✗✓	671	if (WEXITSTATUS(status) == 255) {
580			warnx("%s exited with status 255", name);
581			exit(124);
582	✓✗✗✓	1342	} else if (WEXITSTATUS(status) == 127 \|\|
583		671	WEXITSTATUS(status) == 126) {
584			exit(WEXITSTATUS(status));
585	✓✗	671	} else if (WEXITSTATUS(status) != 0) {
586			rval = 123;
587			}
588			} else if (WIFSIGNALED(status)) {
589			if (WTERMSIG(status) != SIGPIPE) {
590			if (WTERMSIG(status) < NSIG)
591			warnx("%s terminated by SIG%s", name,
592			sys_signame[WTERMSIG(status)]);
593			else
594			warnx("%s terminated by signal %d",
595			name, WTERMSIG(status));
596			}
597			exit(125);
598			}
599			}
600	✓✗✗✓	2348	if (pid == -1 && errno != ECHILD)
601			err(1, "waitpid");
602		1174	}
603
604			/*
605			* Prompt the user about running a command.
606			*/
607			static int
608			prompt(void)
609			{
610			regex_t cre;
611			size_t rsize;
612			int match;
613			char *response;
614			FILE *ttyfp;
615
616			if ((ttyfp = fopen(_PATH_TTY, "r")) == NULL)
617			return (2); /* Indicate that the TTY failed to open. */
618			(void)fprintf(stderr, "?...");
619			(void)fflush(stderr);
620			if ((response = fgetln(ttyfp, &rsize)) == NULL \|\|
621			regcomp(&cre, nl_langinfo(YESEXPR), REG_BASIC) != 0) {
622			(void)fclose(ttyfp);
623			return (0);
624			}
625			response[rsize - 1] = '\0';
626			match = regexec(&cre, response, 0, NULL, 0);
627			(void)fclose(ttyfp);
628			regfree(&cre);
629			return (match == 0);
630			}
631
632			static void
633			usage(void)
634			{
635			fprintf(stderr,
636			"usage: xargs [-0oprt] [-E eofstr] [-I replstr [-R replacements]] [-J replstr]\n"
637			" [-L number] [-n number [-x]] [-P maxprocs] [-s size]\n"
638			" [utility [argument ...]]\n");
639			exit(1);
640			}