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