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