diff options
| -rw-r--r-- | usr.bin/xargs/Makefile | 3 | ||||
| -rw-r--r-- | usr.bin/xargs/strnsubst.c | 100 | ||||
| -rw-r--r-- | usr.bin/xargs/xargs.1 | 188 | ||||
| -rw-r--r-- | usr.bin/xargs/xargs.c | 598 |
4 files changed, 707 insertions, 182 deletions
diff --git a/usr.bin/xargs/Makefile b/usr.bin/xargs/Makefile index 0118885f85b..a9bf6c6713c 100644 --- a/usr.bin/xargs/Makefile +++ b/usr.bin/xargs/Makefile @@ -1,5 +1,6 @@ -# $OpenBSD: Makefile,v 1.3 1997/09/21 11:52:09 deraadt Exp $ +# $OpenBSD: Makefile,v 1.4 2003/06/12 01:09:22 millert Exp $ PROG= xargs +SRCS= xargs.c strnsubst.c .include <bsd.prog.mk> diff --git a/usr.bin/xargs/strnsubst.c b/usr.bin/xargs/strnsubst.c new file mode 100644 index 00000000000..01405717ba4 --- /dev/null +++ b/usr.bin/xargs/strnsubst.c @@ -0,0 +1,100 @@ +/* $OpenBSD: strnsubst.c,v 1.1 2003/06/12 01:09:23 millert Exp $ */ +/* $FreeBSD: strnsubst.c,v 1.6 2002/06/22 12:58:42 jmallett Exp $ */ + +/* + * Copyright (c) 2002 J. Mallett. All rights reserved. + * You may do whatever you want with this file as long as + * the above copyright and this notice remain intact, along + * with the following statement: + * For the man who taught me vi, and who got too old, too young. + */ + +#ifndef lint +static const char rcsid[] = "$OpenBSD: strnsubst.c,v 1.1 2003/06/12 01:09:23 millert Exp $"; +#endif /* not lint */ + +#include <err.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +void strnsubst(char **, const char *, const char *, size_t); + +/* + * Replaces str with a string consisting of str with match replaced with + * replstr as many times as can be done before the constructed string is + * maxsize bytes large. It does not free the string pointed to by str, it + * is up to the calling program to be sure that the original contents of + * str as well as the new contents are handled in an appropriate manner. + * If replstr is NULL, then that internally is changed to a nil-string, so + * that we can still pretend to do somewhat meaningful substitution. + * No value is returned. + */ +void +strnsubst(char **str, const char *match, const char *replstr, size_t maxsize) +{ + char *s1, *s2, *this; + size_t matchlen, repllen, s2len, n; + + if ((s1 = *str) == NULL) + return; + if ((s2 = malloc(maxsize)) == NULL) + err(1, NULL); + + if (replstr == NULL) + replstr = ""; + + if (match == NULL || *match == '\0' || strlen(s1) >= maxsize) { + strlcpy(s2, s1, maxsize); + goto done; + } + + *s2 = '\0'; + s2len = 0; + matchlen = strlen(match); + repllen = strlen(replstr); + for (;;) { + if ((this = strstr(s1, match)) == NULL) + break; + n = snprintf(s2 + s2len, maxsize - s2len, "%.*s%s", + (int)(this - s1), s1, replstr); + if (n + s2len + strlen(this + matchlen) >= maxsize) + break; /* out of room */ + s2len += n; + s1 = this + matchlen; + } + strlcpy(s2 + s2len, s1, maxsize - s2len); +done: + *str = s2; + return; +} + +#ifdef TEST +#include <stdio.h> + +int +main(void) +{ + char *x, *y, *z, *za; + + x = "{}%$"; + strnsubst(&x, "%$", "{} enpury!", 255); + y = x; + strnsubst(&y, "}{}", "ybir", 255); + z = y; + strnsubst(&z, "{", "v ", 255); + za = z; + strnsubst(&z, NULL, za, 255); + if (strcmp(z, "v ybir enpury!") == 0) + printf("strnsubst() seems to work!\n"); + else + printf("strnsubst() is broken.\n"); + printf("%s\n", z); + free(x); + free(y); + free(z); + free(za); + return 0; +} +#endif diff --git a/usr.bin/xargs/xargs.1 b/usr.bin/xargs/xargs.1 index 45e52816e76..54cd46901c5 100644 --- a/usr.bin/xargs/xargs.1 +++ b/usr.bin/xargs/xargs.1 @@ -1,5 +1,5 @@ -.\" $OpenBSD: xargs.1,v 1.11 2003/06/03 02:56:24 millert Exp $ -.\" $NetBSD: xargs.1,v 1.6 1994/11/14 06:51:40 jtc Exp $ +.\" $OpenBSD: xargs.1,v 1.12 2003/06/12 01:09:23 millert Exp $ +.\" $FreeBSD: xargs.1,v 1.30 2003/05/21 21:07:28 ru Exp $$ .\" .\" Copyright (c) 1990, 1991, 1993 .\" The Regents of the University of California. All rights reserved. @@ -34,32 +34,39 @@ .\" .\" @(#)xargs.1 8.1 (Berkeley) 6/6/93 .\" -.Dd June 6, 1993 +.Dd May 7, 2001 .Dt XARGS 1 .Os .Sh NAME .Nm xargs .Nd "construct argument list(s) and execute utility" .Sh SYNOPSIS -.Nm xargs -.Op Fl 0 -.Op Fl t -.Oo Op Fl x +.Nm +.Op Fl 0opt +.Op Fl E Ar eofstr +.Oo +.Fl I Ar replstr +.Op Fl R Ar replacements +.Oc +.Op Fl J Ar replstr +.Op Fl L Ar number +.Oo .Fl n Ar number +.Op Fl x .Oc +.Op Fl P Ar maxjobs .Op Fl s Ar size -.Op Ar utility Op Ar arguments ... +.Op Ar utility Op Ar argument ... .Sh DESCRIPTION The .Nm -utility reads space, tab, newline, and end-of-file delimited arguments +utility reads space, tab, newline, and end-of-file delimited strings from the standard input and executes the specified .Ar utility -with them as +with the strings as arguments. .Pp -The utility and any arguments specified on the command line are given -to the +Any arguments specified on the command line are given to the .Ar utility upon each invocation, followed by some number of the arguments read from standard input. @@ -82,7 +89,7 @@ Any single character, including newlines, may be escaped by a backslash. The options are as follows: .Bl -tag -width Ds .It Fl 0 -Changes +Change .Nm to expect NUL .Pq Ql \e0 @@ -91,9 +98,84 @@ This is expected to be used in concert with the .Fl print0 function in .Xr find 1 . +.It Fl E Ar eofstr +Use +.Ar eofstr +as a logical EOF marker. +.It Fl I Ar replstr +Execute +.Ar utility +for each input line, replacing one or more occurrences of +.Ar replstr +in up to +.Ar replacements +(or 5 if no +.Fl R +flag is specified) arguments to +.Ar utility +with the entire line of input. +The resulting arguments, after replacement is done, will not be allowed to grow +beyond 255 bytes; this is implemented by concatenating as much of the argument +containing +.Ar replstr +as possible, to the constructed arguments to +.Ar utility , +up to 255 bytes. +The 255 byte limit does not apply to arguments to +.Ar utility +which do not contain +.Ar replstr , +and furthermore, no replacement will be done on +.Ar utility +itself. +Implies +.Fl x . +.It Fl J Ar replstr +If this option is specified, +.Nm +will use the data read from standard input to replace the first occurrence of +.Ar replstr +instead of appending that data after all other arguments. +This option will not effect how many arguments will be read from input +.Pq Fl n , +or the size of the command(s) +.Nm +will generate +.Pq Fl s . +The option just moves where those arguments will be placed in the command(s) +that are executed. +The +.Ar replstr +must show up as a distinct +.Ar argument +to +.Nm xargs . +It will not be recognized if, for instance, it is in the middle of a +quoted string. +Furthermore, only the first occurrence of the +.Ar replstr +will be replaced. +For example, the following command will copy the list of files and +directories which start with an uppercase letter in the current +directory to +.Pa destdir : +.Pp +.Dl /bin/ls -1d [A-Z]* | xargs -J % cp -rp % destdir +.It Fl L Ar number +Call +.Ar utility +for every +.Ar number +of lines read. +If EOF is reached and fewer than +.Ar number +lines have been read then +.Ar utility +will be called with the available lines. .It Fl n Ar number Set the maximum number of arguments taken from standard input for each -invocation of the utility. +invocation of +.Ar utility . An invocation of .Ar utility will use less than @@ -109,12 +191,44 @@ arguments remaining for the last invocation of The current default value for .Ar number is 5000. +.It Fl o +Reopen stdin as +.Pa /dev/tty +in the child process before executing the command. +This is useful if you want +.Nm +to run an interactive application. +.It Fl P Ar maxprocs +Parallel mode: run at most +.Ar maxprocs +invocations of +.Ar utility +at once. +.It Fl p +Echo each command to be executed and ask the user whether it should be +executed. +An affirmative response, +.Ql y +in the POSIX locale, +causes the command to be executed, any other response causes it to be +skipped. +No commands are executed if the process is not attached to a terminal. +.It Fl R Ar replacements +Specify the maximum number of arguments that +.Fl I +will do replacement in. +If +.Ar replacements +is negative, the number of arguments in which to replace is unbounded. .It Fl s Ar size -Set the maximum number of bytes for the command-line length provided to +Set the maximum number of bytes for the command line length provided to .Ar utility . -The sum of the length of the utility name and the arguments passed to +The sum of the length of the utility name, the arguments passed to .Ar utility -(including null terminators) will be less than or equal to this number. +(including +.Dv NUL +terminators) and the current environment will be less than or equal to +this number. The current default value for .Ar size is @@ -128,7 +242,7 @@ Force .Nm to terminate immediately if a command line containing .Ar number -arguments will not fit in the specified (or default) command-line length. +arguments will not fit in the specified (or default) command line length. .El .Pp If no @@ -146,9 +260,13 @@ The utility exits immediately (without processing any further input) if a command line cannot be assembled, .Ar utility -cannot be invoked, an invocation of the utility is terminated by a signal, -or an invocation of the utility exits with a value of 255. -.Pp +cannot be invoked, an invocation of +.Ar utility +is terminated by a signal, +or an invocation of +.Ar utility +exits with a value of 255. +.Sh DIAGNOSTICS .Nm exits with one of the following values: .Pp @@ -172,7 +290,7 @@ was killed or stopped by a signal. .It 126 The .Ar utility -was found but could not be invoked. +was found but could not be executed. .It 127 The .Ar utility @@ -182,13 +300,33 @@ Some other error occurred. .El .Sh SEE ALSO .Xr echo 1 , -.Xr find 1 +.Xr find 1 , +.Xr execvp 3 .Sh STANDARDS The .Nm utility is expected to be .St -p1003.2 compliant. -.Sh HISTORY -The meaning of 123, 124, and 125 exit values were taken from GNU +The +.Fl J , o , P +and +.Fl R +options are non-standard +extensions which may not be available on other operating systems. +.Pp +The meanings of the 123, 124, and 125 exit values were taken from +.Tn GNU .Nm xargs . +.Sh HISTORY +The +.Nm +command appeared in PWB UNIX. +.Sh BUGS +If +.Ar utility +attempts to invoke another command such that the number of arguments or the +size of the environment is increased, it risks +.Xr execvp 3 +failing with +.Er E2BIG . diff --git a/usr.bin/xargs/xargs.c b/usr.bin/xargs/xargs.c index 8db095a67b4..ff2272446dc 100644 --- a/usr.bin/xargs/xargs.c +++ b/usr.bin/xargs/xargs.c @@ -1,5 +1,5 @@ -/* $OpenBSD: xargs.c,v 1.13 2003/06/10 22:20:54 deraadt Exp $ */ -/* $NetBSD: xargs.c,v 1.7 1994/11/14 06:51:41 jtc Exp $ */ +/* $OpenBSD: xargs.c,v 1.14 2003/06/12 01:09:23 millert Exp $ */ +/* $FreeBSD: xargs.c,v 1.51 2003/05/03 19:09:11 obrien Exp $ */ /*- * Copyright (c) 1990, 1993 @@ -31,50 +31,76 @@ * 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 $ */ #ifndef lint -static char copyright[] = +static const char copyright[] = "@(#) Copyright (c) 1990, 1993\n\ The Regents of the University of California. All rights reserved.\n"; #endif /* not lint */ #ifndef lint #if 0 -static char sccsid[] = "@(#)xargs.c 8.1 (Berkeley) 6/6/93"; +static const char sccsid[] = "@(#)xargs.c 8.1 (Berkeley) 6/6/93"; +#else +static const char rcsid[] = "$OpenBSD: xargs.c,v 1.14 2003/06/12 01:09:23 millert Exp $"; #endif -static char rcsid[] = "$OpenBSD: xargs.c,v 1.13 2003/06/10 22:20:54 deraadt Exp $"; #endif /* not lint */ -#include <sys/types.h> +#include <sys/param.h> #include <sys/wait.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 <locale.h> -#include <signal.h> -#include <err.h> + #include "pathnames.h" -int tflag, rval; -int zflag; +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; +static int curprocs, maxprocs; +static size_t inpsize; + +static volatile int childerr; -void run(char **); -void usage(void); +extern char **environ; int main(int argc, char *argv[]) { - int ch; - char *p, *bbp, *ebp, **bxp, **exp, **xp; - int cnt, indouble, insingle, nargs, nflag, nline, xflag; - char **av, *argp; - int arg_max; + long arg_max; + int ch, Jflag, nargs, nflag, nline; + size_t linelen; + char *endptr; - setlocale(LC_ALL, ""); + 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 @@ -93,14 +119,50 @@ main(int argc, char *argv[]) if ((arg_max = sysconf(_SC_ARG_MAX)) == -1) errx(1, "sysconf(_SC_ARG_MAX) failed"); nline = arg_max - 4 * 1024; - nflag = xflag = 0; - while ((ch = getopt(argc, argv, "0n:s:tx")) != -1) + 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:P:pR:s: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 = atoi(optarg); + break; case 'n': nflag = 1; if ((nargs = atoi(optarg)) <= 0) errx(1, "illegal argument count"); break; + case 'o': + oflag = 1; + break; + case 'P': + if ((maxprocs = atoi(optarg)) <= 0) + errx(1, "max. processes must be >0"); + break; + case 'p': + pflag = 1; + break; + case 'R': + Rflag = strtol(optarg, &endptr, 10); + if (*endptr != '\0') + errx(1, "replacements must be a number"); + break; case 's': nline = atoi(optarg); break; @@ -120,13 +182,24 @@ main(int argc, char *argv[]) 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. */ - if (!(av = bxp = - malloc((u_int)(1 + argc + nargs + 1) * sizeof(char **)))) + linelen = 1 + argc + nargs + 1; + if ((av = bxp = malloc(linelen * sizeof(char **))) == NULL) err(1, NULL); /* @@ -134,13 +207,20 @@ main(int argc, char *argv[]) * shell. Echo is the default. Set up pointers for the user's * arguments. */ - if (!*argv) + if (*argv == NULL) cnt = strlen(*bxp++ = _PATH_ECHO); else { - cnt = 0; 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); + } while (*++argv != NULL); } /* @@ -148,7 +228,7 @@ main(int argc, char *argv[]) * count doesn't include the trailing NULL pointer, so the malloc * added in an extra slot. */ - exp = (xp = bxp) + nargs; + endxp = (xp = bxp) + nargs; /* * Allocate buffer space for the arguments read from stdin and the @@ -162,176 +242,382 @@ main(int argc, char *argv[]) if (nline <= 0) errx(1, "insufficient space for command"); - if (!(bbp = malloc((u_int)nline + 1))) - err(1, NULL); + if ((bbp = malloc((size_t)(nline + 1))) == NULL) + errx(1, NULL); ebp = (argp = p = bbp) + nline - 1; + for (;;) + parse_input(argc, argv); +} - for (insingle = indouble = 0;;) - switch(ch = getchar()) { - case EOF: - /* No arguments since last exec. */ - if (p == bbp) - exit(rval); +static void +parse_input(int argc, char *argv[]) +{ + int ch, foundeof; + char **avj; - /* Nothing since end of last argument. */ - if (argp == p) { - *xp = NULL; - run(av); - exit(rval); - } - goto arg1; - case ' ': - case '\t': - /* Quotes escape tabs and spaces. */ - if (insingle || indouble || zflag) - goto addch; + foundeof = 0; + + switch(ch = getchar()) { + case EOF: + /* No arguments since last exec. */ + if (p == bbp) { + waitchildren(*argv, 1); + exit(rval); + } + goto arg1; + case ' ': + case '\t': + /* Quotes escape tabs and spaces. */ + if (insingle || indouble || zflag) + goto addch; + goto arg2; + case '\0': + if (zflag) goto arg2; - case '\0': - if (zflag) - goto arg2; + goto addch; + case '\n': + count++; + if (zflag) goto addch; - case '\n': - if (zflag) - goto addch; - - /* Empty lines are skipped. */ - if (argp == p) - continue; - /* Quotes do not escape newlines. */ -arg1: if (insingle || indouble) - errx(1, "unterminated quote"); + /* Quotes do not escape newlines. */ +arg1: if (insingle || indouble) + errx(1, "unterminated quote"); +arg2: + foundeof = *eofstr != '\0' && + strcmp(argp, eofstr) == 0; -arg2: *p = '\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 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. - */ - if (xp == exp || p == ebp || ch == EOF) { - if (xflag && xp != exp && p == ebp) - errx(1, "insufficient space for arguments"); - *xp = NULL; - run(av); - if (ch == EOF) - exit(rval); - p = bbp; - xp = bxp; - } else - ++p; - argp = p; - break; - case '\'': - if (indouble || zflag) - goto addch; - insingle = !insingle; - break; - case '"': - if (insingle || zflag) - goto addch; - indouble = !indouble; - 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 (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 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) + /* + * 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"); - - *xp = NULL; - run(av); + 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; - cnt = ebp - argp; - bcopy(argp, bbp, cnt); - p = (argp = bbp) + cnt; + 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; } - /* NOTREACHED */ + + /* 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; + } +} + +/* + * 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; + + 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 = malloc((argc + 1) * sizeof(char**)); + if (tmp == NULL) + errx(1, NULL); + tmp2 = tmp; + + /* + * Save the first argument and iterate over it, we + * cannot do strnsubst() to it. + */ + if ((*tmp++ = strdup(*avj++)) == NULL) + errx(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) + errx(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. + */ + if (inpline != NULL) { + free(inpline); + inpline = NULL; + } } -void +static void run(char **argv) { - volatile int noinvoke; - char **p; pid_t pid; - int status; + int fd; + char **avec; - if (tflag) { + /* + * 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 (p = argv + 1; *p; ++p) - (void)fprintf(stderr, " %s", *p); + 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); } - noinvoke = 0; +exec: + childerr = 0; switch(pid = vfork()) { case -1: err(1, "vfork"); case 0: + if (oflag) { + if ((fd = open(_PATH_TTY, O_RDONLY)) == -1) + err(1, "can't open /dev/tty"); + } else { + fd = open(_PATH_DEVNULL, O_RDONLY); + } + if (fd > STDIN_FILENO) { + if (dup2(fd, STDIN_FILENO) != 0) + err(1, "can't dup2 to stdin"); + close(STDIN_FILENO); + } execvp(argv[0], argv); - noinvoke = (errno == ENOENT) ? 127 : 126; - warn("%s", argv[0]); + childerr = errno; _exit(1); } - pid = waitpid(pid, &status, 0); - if (pid == -1) - err(1, "waitpid"); + curprocs++; + waitchildren(*argv, 0); +} - /* - * If we couldn't invoke the utility or the utility didn't exit - * properly, quit with 127 or 126 respectively. - */ - if (noinvoke) - exit(noinvoke); +static void +waitchildren(const char *name, int waitall) +{ + pid_t pid; + int status; - /* - * According to POSIX, we have to exit if the utility exits with - * a 255 status, or is interrupted by a signal. xargs is 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", argv[0]); - exit(124); - } else if (WEXITSTATUS(status) != 0) { - rval = 123; + while ((pid = waitpid(-1, &status, !waitall && curprocs < maxprocs ? + WNOHANG : 0)) > 0) { + curprocs--; + /* If we couldn't invoke the utility, exit. */ + if (childerr != 0) { + errno = childerr; + err(errno == ENOENT ? 127 : 126, "%s", name); } - } else if (WIFSIGNALED(status)) { - if (WTERMSIG(status) != SIGPIPE) { - if (WTERMSIG(status) < NSIG) - warnx("%s terminated by SIG%s", argv[0], - sys_signame[WTERMSIG(status)]); - else - warnx("%s terminated by signal %d", argv[0], - WTERMSIG(status)); + /* + * 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) != 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); } - 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); + } + match = regexec(&cre, response, 0, NULL, 0); + (void)fclose(ttyfp); + regfree(&cre); + return (match == 0); } -void +static void usage(void) { fprintf(stderr, - "usage: xargs [-0] [-t] [-n number [-x]] [-s size] " - "[utility [argument ...]]\n"); +"usage: xargs [-0opt] [-E eofstr] [-I replstr [-R replacements]] [-J replstr]\n" +" [-L number] [-n number [-x]] [-P maxprocs] [-s size]\n" +" [utility [argument ...]]\n"); exit(1); } |