1 /*- 2 * SPDX-License-Identifier: BSD-3-Clause 3 * 4 * Copyright (c) 1990, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * This code is derived from software contributed to Berkeley by 8 * John B. Roll Jr. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. Neither the name of the University nor the names of its contributors 19 * may be used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 * 34 * $xMach: xargs.c,v 1.6 2002/02/23 05:27:47 tim Exp $ 35 */ 36 37 #if 0 38 #ifndef lint 39 static const char copyright[] = 40 "@(#) Copyright (c) 1990, 1993\n\ 41 The Regents of the University of California. All rights reserved.\n"; 42 #endif /* not lint */ 43 44 #ifndef lint 45 static char sccsid[] = "@(#)xargs.c 8.1 (Berkeley) 6/6/93"; 46 #endif /* not lint */ 47 #endif 48 #include <sys/cdefs.h> 49 __FBSDID("$FreeBSD$"); 50 51 #include <sys/types.h> 52 #include <sys/wait.h> 53 #include <sys/time.h> 54 #include <sys/limits.h> 55 #include <sys/resource.h> 56 #include <err.h> 57 #include <errno.h> 58 #include <fcntl.h> 59 #include <getopt.h> 60 #include <langinfo.h> 61 #include <locale.h> 62 #include <paths.h> 63 #include <regex.h> 64 #include <stdbool.h> 65 #include <stdio.h> 66 #include <stdlib.h> 67 #include <string.h> 68 #include <unistd.h> 69 70 #include "pathnames.h" 71 72 static void parse_input(int, char *[]); 73 static void prerun(int, char *[]); 74 static int prompt(void); 75 static void run(char **); 76 static void usage(void); 77 bool strnsubst(char **, const char *, const char *, size_t); 78 static pid_t xwait(int block, int *status); 79 static void xexit(const char *, const int); 80 static void waitchildren(const char *, int); 81 static void pids_init(void); 82 static int pids_empty(void); 83 static int pids_full(void); 84 static void pids_add(pid_t pid); 85 static int pids_remove(pid_t pid); 86 static int findslot(pid_t pid); 87 static int findfreeslot(void); 88 static void clearslot(int slot); 89 90 static char echo[] = _PATH_ECHO; 91 static char **av, **bxp, **ep, **endxp, **xp; 92 static char *argp, *bbp, *ebp, *inpline, *p, *replstr; 93 static const char *eofstr; 94 static int count, insingle, indouble, oflag, pflag, tflag, Rflag, rval, zflag; 95 static int cnt, Iflag, jfound, Lflag, Sflag, wasquoted, xflag; 96 static int curprocs, maxprocs; 97 static pid_t *childpids; 98 99 static volatile int childerr; 100 101 extern char **environ; 102 103 static const char *optstr = "+0E:I:J:L:n:oP:pR:S:s:rtx"; 104 105 static const struct option long_options[] = 106 { 107 {"exit", no_argument, NULL, 'x'}, 108 {"interactive", no_argument, NULL, 'p'}, 109 {"max-args", required_argument, NULL, 'n'}, 110 {"max-chars", required_argument, NULL, 's'}, 111 {"max-procs", required_argument, NULL, 'P'}, 112 {"no-run-if-empty", no_argument, NULL, 'r'}, 113 {"null", no_argument, NULL, '0'}, 114 {"verbose", no_argument, NULL, 't'}, 115 116 {NULL, no_argument, NULL, 0}, 117 }; 118 119 int 120 main(int argc, char *argv[]) 121 { 122 long arg_max; 123 int ch, Jflag, nargs, nflag, nline; 124 size_t linelen; 125 struct rlimit rl; 126 char *endptr; 127 const char *errstr; 128 129 inpline = replstr = NULL; 130 ep = environ; 131 eofstr = ""; 132 Jflag = nflag = 0; 133 134 (void)setlocale(LC_ALL, ""); 135 136 /* 137 * POSIX.2 limits the exec line length to ARG_MAX - 2K. Running that 138 * caused some E2BIG errors, so it was changed to ARG_MAX - 4K. Given 139 * that the smallest argument is 2 bytes in length, this means that 140 * the number of arguments is limited to: 141 * 142 * (ARG_MAX - 4K - LENGTH(utility + arguments)) / 2. 143 * 144 * We arbitrarily limit the number of arguments to 5000. This is 145 * allowed by POSIX.2 as long as the resulting minimum exec line is 146 * at least LINE_MAX. Realloc'ing as necessary is possible, but 147 * probably not worthwhile. 148 */ 149 nargs = 5000; 150 if ((arg_max = sysconf(_SC_ARG_MAX)) == -1) 151 errx(1, "sysconf(_SC_ARG_MAX) failed"); 152 nline = arg_max - 4 * 1024; 153 while (*ep != NULL) { 154 /* 1 byte for each '\0' */ 155 nline -= strlen(*ep++) + 1 + sizeof(*ep); 156 } 157 maxprocs = 1; 158 while ((ch = getopt_long(argc, argv, optstr, long_options, NULL)) != -1) 159 switch (ch) { 160 case 'E': 161 eofstr = optarg; 162 break; 163 case 'I': 164 Jflag = 0; 165 Iflag = 1; 166 Lflag = 1; 167 replstr = optarg; 168 break; 169 case 'J': 170 Iflag = 0; 171 Jflag = 1; 172 replstr = optarg; 173 break; 174 case 'L': 175 Lflag = strtonum(optarg, 0, INT_MAX, &errstr); 176 if (errstr) 177 errx(1, "-L %s: %s", optarg, errstr); 178 break; 179 case 'n': 180 nflag = 1; 181 nargs = strtonum(optarg, 1, INT_MAX, &errstr); 182 if (errstr) 183 errx(1, "-n %s: %s", optarg, errstr); 184 break; 185 case 'o': 186 oflag = 1; 187 break; 188 case 'P': 189 maxprocs = strtonum(optarg, 0, INT_MAX, &errstr); 190 if (errstr) 191 errx(1, "-P %s: %s", optarg, errstr); 192 if (getrlimit(RLIMIT_NPROC, &rl) != 0) 193 errx(1, "getrlimit failed"); 194 if (maxprocs == 0 || maxprocs > rl.rlim_cur) 195 maxprocs = rl.rlim_cur; 196 break; 197 case 'p': 198 pflag = 1; 199 break; 200 case 'R': 201 Rflag = strtol(optarg, &endptr, 10); 202 if (*endptr != '\0') 203 errx(1, "replacements must be a number"); 204 break; 205 case 'r': 206 /* GNU compatibility */ 207 break; 208 case 'S': 209 Sflag = strtoul(optarg, &endptr, 10); 210 if (*endptr != '\0') 211 errx(1, "replsize must be a number"); 212 break; 213 case 's': 214 nline = strtonum(optarg, 0, INT_MAX, &errstr); 215 if (errstr) 216 errx(1, "-s %s: %s", optarg, errstr); 217 break; 218 case 't': 219 tflag = 1; 220 break; 221 case 'x': 222 xflag = 1; 223 break; 224 case '0': 225 zflag = 1; 226 break; 227 case '?': 228 default: 229 usage(); 230 } 231 argc -= optind; 232 argv += optind; 233 234 if (!Iflag && Rflag) 235 usage(); 236 if (!Iflag && Sflag) 237 usage(); 238 if (Iflag && !Rflag) 239 Rflag = 5; 240 if (Iflag && !Sflag) 241 Sflag = 255; 242 if (xflag && !nflag) 243 usage(); 244 if (Iflag || Lflag) 245 xflag = 1; 246 if (replstr != NULL && *replstr == '\0') 247 errx(1, "replstr may not be empty"); 248 249 pids_init(); 250 251 /* 252 * Allocate pointers for the utility name, the utility arguments, 253 * the maximum arguments to be read from stdin and the trailing 254 * NULL. 255 */ 256 linelen = 1 + argc + nargs + 1; 257 if ((av = bxp = malloc(linelen * sizeof(char *))) == NULL) 258 errx(1, "malloc failed"); 259 260 /* 261 * Use the user's name for the utility as argv[0], just like the 262 * shell. Echo is the default. Set up pointers for the user's 263 * arguments. 264 */ 265 if (*argv == NULL) 266 cnt = strlen(*bxp++ = echo); 267 else { 268 do { 269 if (Jflag && strcmp(*argv, replstr) == 0) { 270 char **avj; 271 jfound = 1; 272 argv++; 273 for (avj = argv; *avj; avj++) 274 cnt += strlen(*avj) + 1; 275 break; 276 } 277 cnt += strlen(*bxp++ = *argv) + 1; 278 } while (*++argv != NULL); 279 } 280 281 /* 282 * Set up begin/end/traversing pointers into the array. The -n 283 * count doesn't include the trailing NULL pointer, so the malloc 284 * added in an extra slot. 285 */ 286 endxp = (xp = bxp) + nargs; 287 288 /* 289 * Allocate buffer space for the arguments read from stdin and the 290 * trailing NULL. Buffer space is defined as the default or specified 291 * space, minus the length of the utility name and arguments. Set up 292 * begin/end/traversing pointers into the array. The -s count does 293 * include the trailing NULL, so the malloc didn't add in an extra 294 * slot. 295 */ 296 nline -= cnt; 297 if (nline <= 0) 298 errx(1, "insufficient space for command"); 299 300 if ((bbp = malloc((size_t)(nline + 1))) == NULL) 301 errx(1, "malloc failed"); 302 ebp = (argp = p = bbp) + nline - 1; 303 for (;;) 304 parse_input(argc, argv); 305 } 306 307 static void 308 parse_input(int argc, char *argv[]) 309 { 310 int ch, foundeof; 311 char **avj; 312 313 foundeof = 0; 314 315 switch (ch = getchar()) { 316 case EOF: 317 /* No arguments since last exec. */ 318 if (p == bbp) 319 xexit(*av, rval); 320 goto arg1; 321 case ' ': 322 case '\t': 323 /* Quotes escape tabs and spaces. */ 324 if (insingle || indouble || zflag) 325 goto addch; 326 goto arg2; 327 case '\0': 328 if (zflag) { 329 /* 330 * Increment 'count', so that nulls will be treated 331 * as end-of-line, as well as end-of-argument. This 332 * is needed so -0 works properly with -I and -L. 333 */ 334 count++; 335 goto arg2; 336 } 337 goto addch; 338 case '\n': 339 if (zflag) 340 goto addch; 341 count++; /* Indicate end-of-line (used by -L) */ 342 343 /* Quotes do not escape newlines. */ 344 arg1: if (insingle || indouble) { 345 warnx("unterminated quote"); 346 xexit(*av, 1); 347 } 348 arg2: 349 foundeof = *eofstr != '\0' && 350 strncmp(argp, eofstr, p - argp) == 0; 351 352 /* Do not make empty args unless they are quoted */ 353 if ((argp != p || wasquoted) && !foundeof) { 354 *p++ = '\0'; 355 *xp++ = argp; 356 if (Iflag) { 357 size_t curlen; 358 359 if (inpline == NULL) 360 curlen = 0; 361 else { 362 /* 363 * If this string is not zero 364 * length, append a space for 365 * separation before the next 366 * argument. 367 */ 368 if ((curlen = strlen(inpline))) 369 strcat(inpline, " "); 370 } 371 curlen++; 372 /* 373 * Allocate enough to hold what we will 374 * be holding in a second, and to append 375 * a space next time through, if we have 376 * to. 377 */ 378 inpline = realloc(inpline, curlen + 2 + 379 strlen(argp)); 380 if (inpline == NULL) { 381 warnx("realloc failed"); 382 xexit(*av, 1); 383 } 384 if (curlen == 1) 385 strcpy(inpline, argp); 386 else 387 strcat(inpline, argp); 388 } 389 } 390 391 /* 392 * If max'd out on args or buffer, or reached EOF, 393 * run the command. If xflag and max'd out on buffer 394 * but not on args, object. Having reached the limit 395 * of input lines, as specified by -L is the same as 396 * maxing out on arguments. 397 */ 398 if (xp == endxp || p > ebp || ch == EOF || 399 (Lflag <= count && xflag) || foundeof) { 400 if (xflag && xp != endxp && p > ebp) { 401 warnx("insufficient space for arguments"); 402 xexit(*av, 1); 403 } 404 if (jfound) { 405 for (avj = argv; *avj; avj++) 406 *xp++ = *avj; 407 } 408 prerun(argc, av); 409 if (ch == EOF || foundeof) 410 xexit(*av, rval); 411 p = bbp; 412 xp = bxp; 413 count = 0; 414 } 415 argp = p; 416 wasquoted = 0; 417 break; 418 case '\'': 419 if (indouble || zflag) 420 goto addch; 421 insingle = !insingle; 422 wasquoted = 1; 423 break; 424 case '"': 425 if (insingle || zflag) 426 goto addch; 427 indouble = !indouble; 428 wasquoted = 1; 429 break; 430 case '\\': 431 if (zflag) 432 goto addch; 433 /* Backslash escapes anything, is escaped by quotes. */ 434 if (!insingle && !indouble && (ch = getchar()) == EOF) { 435 warnx("backslash at EOF"); 436 xexit(*av, 1); 437 } 438 /* FALLTHROUGH */ 439 default: 440 addch: if (p < ebp) { 441 *p++ = ch; 442 break; 443 } 444 445 /* If only one argument, not enough buffer space. */ 446 if (bxp == xp) { 447 warnx("insufficient space for argument"); 448 xexit(*av, 1); 449 } 450 /* Didn't hit argument limit, so if xflag object. */ 451 if (xflag) { 452 warnx("insufficient space for arguments"); 453 xexit(*av, 1); 454 } 455 456 if (jfound) { 457 for (avj = argv; *avj; avj++) 458 *xp++ = *avj; 459 } 460 prerun(argc, av); 461 xp = bxp; 462 cnt = ebp - argp; 463 memcpy(bbp, argp, (size_t)cnt); 464 p = (argp = bbp) + cnt; 465 *p++ = ch; 466 break; 467 } 468 } 469 470 /* 471 * Do things necessary before run()'ing, such as -I substitution, 472 * and then call run(). 473 */ 474 static void 475 prerun(int argc, char *argv[]) 476 { 477 char **tmp, **tmp2, **avj; 478 int repls; 479 480 repls = Rflag; 481 482 if (argc == 0 || repls == 0) { 483 *xp = NULL; 484 run(argv); 485 return; 486 } 487 488 avj = argv; 489 490 /* 491 * Allocate memory to hold the argument list, and 492 * a NULL at the tail. 493 */ 494 tmp = malloc((argc + 1) * sizeof(char *)); 495 if (tmp == NULL) { 496 warnx("malloc failed"); 497 xexit(*argv, 1); 498 } 499 tmp2 = tmp; 500 501 /* 502 * Save the first argument and iterate over it, we 503 * cannot do strnsubst() to it. 504 */ 505 if ((*tmp++ = strdup(*avj++)) == NULL) { 506 warnx("strdup failed"); 507 xexit(*argv, 1); 508 } 509 510 /* 511 * For each argument to utility, if we have not used up 512 * the number of replacements we are allowed to do, and 513 * if the argument contains at least one occurrence of 514 * replstr, call strnsubst(), else just save the string. 515 * Iterations over elements of avj and tmp are done 516 * where appropriate. 517 */ 518 while (--argc) { 519 *tmp = *avj++; 520 if (repls && strstr(*tmp, replstr) != NULL) { 521 if (strnsubst(tmp++, replstr, inpline, (size_t)Sflag)) { 522 warnx("comamnd line cannot be assembled, too long"); 523 xexit(*argv, 1); 524 } 525 if (repls > 0) 526 repls--; 527 } else { 528 if ((*tmp = strdup(*tmp)) == NULL) { 529 warnx("strdup failed"); 530 xexit(*argv, 1); 531 } 532 tmp++; 533 } 534 } 535 536 /* 537 * Run it. 538 */ 539 *tmp = NULL; 540 run(tmp2); 541 542 /* 543 * Walk from the tail to the head, free along the way. 544 */ 545 for (; tmp2 != tmp; tmp--) 546 free(*tmp); 547 /* 548 * Now free the list itself. 549 */ 550 free(tmp2); 551 552 /* 553 * Free the input line buffer, if we have one. 554 */ 555 if (inpline != NULL) { 556 free(inpline); 557 inpline = NULL; 558 } 559 } 560 561 static void 562 run(char **argv) 563 { 564 pid_t pid; 565 int fd; 566 char **avec; 567 568 /* 569 * If the user wants to be notified of each command before it is 570 * executed, notify them. If they want the notification to be 571 * followed by a prompt, then prompt them. 572 */ 573 if (tflag || pflag) { 574 (void)fprintf(stderr, "%s", *argv); 575 for (avec = argv + 1; *avec != NULL; ++avec) 576 (void)fprintf(stderr, " %s", *avec); 577 /* 578 * If the user has asked to be prompted, do so. 579 */ 580 if (pflag) 581 /* 582 * If they asked not to exec, return without execution 583 * but if they asked to, go to the execution. If we 584 * could not open their tty, break the switch and drop 585 * back to -t behaviour. 586 */ 587 switch (prompt()) { 588 case 0: 589 return; 590 case 1: 591 goto exec; 592 case 2: 593 break; 594 } 595 (void)fprintf(stderr, "\n"); 596 (void)fflush(stderr); 597 } 598 exec: 599 childerr = 0; 600 switch (pid = vfork()) { 601 case -1: 602 warn("vfork"); 603 xexit(*argv, 1); 604 case 0: 605 if (oflag) { 606 if ((fd = open(_PATH_TTY, O_RDONLY)) == -1) 607 err(1, "can't open /dev/tty"); 608 } else { 609 fd = open(_PATH_DEVNULL, O_RDONLY); 610 } 611 if (fd > STDIN_FILENO) { 612 if (dup2(fd, STDIN_FILENO) != 0) 613 err(1, "can't dup2 to stdin"); 614 close(fd); 615 } 616 execvp(argv[0], argv); 617 childerr = errno; 618 _exit(1); 619 } 620 pids_add(pid); 621 waitchildren(*argv, 0); 622 } 623 624 /* 625 * Wait for a tracked child to exit and return its pid and exit status. 626 * 627 * Ignores (discards) all untracked child processes. 628 * Returns -1 and sets errno to ECHILD if no tracked children exist. 629 * If block is set, waits indefinitely for a child process to exit. 630 * If block is not set and no children have exited, returns 0 immediately. 631 */ 632 static pid_t 633 xwait(int block, int *status) { 634 pid_t pid; 635 636 if (pids_empty()) { 637 errno = ECHILD; 638 return (-1); 639 } 640 641 while ((pid = waitpid(-1, status, block ? 0 : WNOHANG)) > 0) 642 if (pids_remove(pid)) 643 break; 644 645 return (pid); 646 } 647 648 static void 649 xexit(const char *name, const int exit_code) { 650 waitchildren(name, 1); 651 exit(exit_code); 652 } 653 654 static void 655 waitchildren(const char *name, int waitall) 656 { 657 pid_t pid; 658 int status; 659 int cause_exit = 0; 660 661 while ((pid = xwait(waitall || pids_full(), &status)) > 0) { 662 /* 663 * If we couldn't invoke the utility or if utility exited 664 * because of a signal or with a value of 255, warn (per 665 * POSIX), and then wait until all other children have 666 * exited before exiting 1-125. POSIX requires us to stop 667 * reading if child exits because of a signal or with 255, 668 * but it does not require us to exit immediately; waiting 669 * is preferable to orphaning. 670 */ 671 if (childerr != 0 && cause_exit == 0) { 672 errno = childerr; 673 waitall = 1; 674 cause_exit = errno == ENOENT ? 127 : 126; 675 warn("%s", name); 676 } else if (WIFSIGNALED(status)) { 677 waitall = cause_exit = 1; 678 warnx("%s: terminated with signal %d; aborting", 679 name, WTERMSIG(status)); 680 } else if (WEXITSTATUS(status) == 255) { 681 waitall = cause_exit = 1; 682 warnx("%s: exited with status 255; aborting", name); 683 } else if (WEXITSTATUS(status)) 684 rval = 1; 685 } 686 687 if (cause_exit) 688 exit(cause_exit); 689 if (pid == -1 && errno != ECHILD) 690 err(1, "waitpid"); 691 } 692 693 #define NOPID (0) 694 695 static void 696 pids_init(void) 697 { 698 int i; 699 700 if ((childpids = malloc(maxprocs * sizeof(*childpids))) == NULL) 701 errx(1, "malloc failed"); 702 703 for (i = 0; i < maxprocs; i++) 704 clearslot(i); 705 } 706 707 static int 708 pids_empty(void) 709 { 710 711 return (curprocs == 0); 712 } 713 714 static int 715 pids_full(void) 716 { 717 718 return (curprocs >= maxprocs); 719 } 720 721 static void 722 pids_add(pid_t pid) 723 { 724 int slot; 725 726 slot = findfreeslot(); 727 childpids[slot] = pid; 728 curprocs++; 729 } 730 731 static int 732 pids_remove(pid_t pid) 733 { 734 int slot; 735 736 if ((slot = findslot(pid)) < 0) 737 return (0); 738 739 clearslot(slot); 740 curprocs--; 741 return (1); 742 } 743 744 static int 745 findfreeslot(void) 746 { 747 int slot; 748 749 if ((slot = findslot(NOPID)) < 0) 750 errx(1, "internal error: no free pid slot"); 751 return (slot); 752 } 753 754 static int 755 findslot(pid_t pid) 756 { 757 int slot; 758 759 for (slot = 0; slot < maxprocs; slot++) 760 if (childpids[slot] == pid) 761 return (slot); 762 return (-1); 763 } 764 765 static void 766 clearslot(int slot) 767 { 768 769 childpids[slot] = NOPID; 770 } 771 772 /* 773 * Prompt the user about running a command. 774 */ 775 static int 776 prompt(void) 777 { 778 regex_t cre; 779 size_t rsize; 780 int match; 781 char *response; 782 FILE *ttyfp; 783 784 if ((ttyfp = fopen(_PATH_TTY, "r")) == NULL) 785 return (2); /* Indicate that the TTY failed to open. */ 786 (void)fprintf(stderr, "?..."); 787 (void)fflush(stderr); 788 if ((response = fgetln(ttyfp, &rsize)) == NULL || 789 regcomp(&cre, nl_langinfo(YESEXPR), REG_EXTENDED) != 0) { 790 (void)fclose(ttyfp); 791 return (0); 792 } 793 response[rsize - 1] = '\0'; 794 match = regexec(&cre, response, 0, NULL, 0); 795 (void)fclose(ttyfp); 796 regfree(&cre); 797 return (match == 0); 798 } 799 800 static void 801 usage(void) 802 { 803 804 fprintf(stderr, 805 "usage: xargs [-0opt] [-E eofstr] [-I replstr [-R replacements] [-S replsize]]\n" 806 " [-J replstr] [-L number] [-n number [-x]] [-P maxprocs]\n" 807 " [-s size] [utility [argument ...]]\n"); 808 exit(1); 809 } 810