1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2012 DEY Storage Systems, Inc. All rights reserved. 23 * 24 * Portions of this file developed by DEY Storage Systems, Inc. are licensed 25 * under the terms of the Common Development and Distribution License (CDDL) 26 * version 1.0 only. The use of subsequent versions of the License are 27 * is specifically prohibited unless those terms are not in conflict with 28 * version 1.0 of the License. You can find this license on-line at 29 * http://www.illumos.org/license/CDDL 30 */ 31 /* 32 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 33 * Use is subject to license terms. 34 */ 35 36 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 37 /* All Rights Reserved */ 38 39 40 #include <stdio.h> 41 #include <sys/types.h> 42 #include <sys/wait.h> 43 #include <unistd.h> 44 #include <fcntl.h> 45 #include <string.h> 46 #include <stdarg.h> 47 #include <stdlib.h> 48 #include <limits.h> 49 #include <wchar.h> 50 #include <locale.h> 51 #include <langinfo.h> 52 #include <stropts.h> 53 #include <poll.h> 54 #include <errno.h> 55 #include <stdarg.h> 56 #include "getresponse.h" 57 58 #define HEAD 0 59 #define TAIL 1 60 #define FALSE 0 61 #define TRUE 1 62 #define MAXSBUF 255 63 #define MAXIBUF 512 64 #define MAXINSERTS 5 65 #define BUFSIZE LINE_MAX 66 #define MAXARGS 255 67 #define INSPAT_STR "{}" /* default replstr string for -[Ii] */ 68 #define FORK_RETRY 5 69 70 #define QBUF_STARTLEN 255 /* start size of growable string buffer */ 71 #define QBUF_INC 100 /* how much to grow a growable string by */ 72 73 /* We use these macros to help make formatting look "consistent" */ 74 #define EMSG(s) ermsg(gettext(s "\n")) 75 #define EMSG2(s, a) ermsg(gettext(s "\n"), a) 76 #define PERR(s) perror(gettext("xargs: " s)) 77 78 /* Some common error messages */ 79 80 #define LIST2LONG "Argument list too long" 81 #define ARG2LONG "A single argument was greater than %d bytes" 82 #define MALLOCFAIL "Memory allocation failure" 83 #define CORRUPTFILE "Corrupt input file" 84 #define WAITFAIL "Wait failure" 85 #define CHILDSIG "Child killed with signal %d" 86 #define CHILDFAIL "Command could not continue processing data" 87 #define FORKFAIL "Could not fork child" 88 #define EXECFAIL "Could not exec command" 89 #define MISSQUOTE "Missing quote" 90 #define BADESCAPE "Incomplete escape" 91 #define IBUFOVERFLOW "Insert buffer overflow" 92 93 #define _(x) gettext(x) 94 95 static wctype_t blank; 96 static char *arglist[MAXARGS+1]; 97 static char argbuf[BUFSIZE * 2 + 1]; 98 static char lastarg[BUFSIZE + 1]; 99 static char **ARGV = arglist; 100 static char *LEOF = "_"; 101 static char *INSPAT = INSPAT_STR; 102 static char ins_buf[MAXIBUF]; 103 static char *p_ibuf; 104 105 static struct inserts { 106 char **p_ARGV; /* where to put newarg ptr in arg list */ 107 char *p_skel; /* ptr to arg template */ 108 } saveargv[MAXINSERTS]; 109 110 static int PROMPT = -1; 111 static int BUFLIM = BUFSIZE; 112 static int N_ARGS = 0; 113 static int N_args = 0; 114 static int N_lines = 0; 115 static int DASHX = FALSE; 116 static int MORE = TRUE; 117 static int PER_LINE = FALSE; 118 static int ERR = FALSE; 119 static int OK = TRUE; 120 static int LEGAL = FALSE; 121 static int TRACE = FALSE; 122 static int INSERT = FALSE; 123 static int ZERO = FALSE; 124 static int linesize = 0; 125 static int ibufsize = 0; 126 static int exitstat = 0; /* our exit status */ 127 static int mac; /* modified argc, after parsing */ 128 static char **mav; /* modified argv, after parsing */ 129 static int n_inserts; /* # of insertions. */ 130 131 /* our usage message: */ 132 #define USAGEMSG "Usage: xargs: [-t] [-p] [-0] [-e[eofstr]] [-E eofstr] "\ 133 "[-I replstr] [-i[replstr]] [-L #] [-l[#]] [-n # [-x]] [-s size] "\ 134 "[cmd [args ...]]\n" 135 136 static int echoargs(); 137 static wint_t getwchr(char *, size_t *); 138 static int lcall(char *sub, char **subargs); 139 static void addibuf(struct inserts *p); 140 static void ermsg(char *messages, ...); 141 static char *addarg(char *arg); 142 static void store_str(char **, char *, size_t); 143 static char *getarg(char *); 144 static char *insert(char *pattern, char *subst); 145 static void usage(); 146 static void parseargs(); 147 148 int 149 main(int argc, char **argv) 150 { 151 int j; 152 struct inserts *psave; 153 int c; 154 int initsize; 155 char *cmdname, **initlist; 156 char *arg; 157 char *next; 158 159 /* initialization */ 160 blank = wctype("blank"); 161 n_inserts = 0; 162 psave = saveargv; 163 (void) setlocale(LC_ALL, ""); 164 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ 165 #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */ 166 #endif 167 (void) textdomain(TEXT_DOMAIN); 168 if (init_yes() < 0) { 169 ermsg(_(ERR_MSG_INIT_YES), strerror(errno)); 170 exit(1); 171 } 172 173 parseargs(argc, argv); 174 175 /* handling all of xargs arguments: */ 176 while ((c = getopt(mac, mav, "0tpe:E:I:i:L:l:n:s:x")) != EOF) { 177 switch (c) { 178 case '0': 179 ZERO = TRUE; 180 break; 181 182 case 't': /* -t: turn trace mode on */ 183 TRACE = TRUE; 184 break; 185 186 case 'p': /* -p: turn on prompt mode. */ 187 if ((PROMPT = open("/dev/tty", O_RDONLY)) == -1) { 188 PERR("can't read from tty for -p"); 189 } else { 190 TRACE = TRUE; 191 } 192 break; 193 194 case 'e': 195 /* 196 * -e[eofstr]: set/disable end-of-file. 197 * N.B. that an argument *isn't* required here; but 198 * parseargs forced an argument if not was given. The 199 * forced argument is the default... 200 */ 201 LEOF = optarg; /* can be empty */ 202 break; 203 204 case 'E': 205 /* 206 * -E eofstr: change end-of-file string. 207 * eofstr *is* required here, but can be empty: 208 */ 209 LEOF = optarg; 210 break; 211 212 case 'I': 213 /* -I replstr: Insert mode. replstr *is* required. */ 214 INSERT = PER_LINE = LEGAL = TRUE; 215 N_ARGS = 0; 216 INSPAT = optarg; 217 if (*optarg == '\0') { 218 ermsg(_("Option requires an argument: -%c\n"), 219 c); 220 } 221 break; 222 223 case 'i': 224 /* 225 * -i [replstr]: insert mode, with *optional* replstr. 226 * N.B. that an argument *isn't* required here; if 227 * it's not given, then the string INSPAT_STR will 228 * be assumed. 229 * 230 * Since getopts(3C) doesn't handle the case of an 231 * optional variable argument at all, we have to 232 * parse this by hand: 233 */ 234 235 INSERT = PER_LINE = LEGAL = TRUE; 236 N_ARGS = 0; 237 if ((optarg != NULL) && (*optarg != '\0')) { 238 INSPAT = optarg; 239 } else { 240 /* 241 * here, there is no next argument. so 242 * we reset INSPAT to the INSPAT_STR. 243 * we *have* to do this, as -i/I may have 244 * been given previously, and XCU4 requires 245 * that only "the last one specified takes 246 * effect". 247 */ 248 INSPAT = INSPAT_STR; 249 } 250 break; 251 252 case 'L': 253 /* 254 * -L number: # of times cmd is executed 255 * number *is* required here: 256 */ 257 PER_LINE = TRUE; 258 N_ARGS = 0; 259 INSERT = FALSE; 260 if ((PER_LINE = atoi(optarg)) <= 0) { 261 ermsg(_("#lines must be positive int: %s\n"), 262 optarg); 263 } 264 break; 265 266 case 'l': 267 /* 268 * -l [number]: # of times cmd is executed 269 * N.B. that an argument *isn't* required here; if 270 * it's not given, then 1 is assumed. 271 * 272 * parseargs handles the optional arg processing. 273 */ 274 275 PER_LINE = LEGAL = TRUE; /* initialization */ 276 N_ARGS = 0; 277 INSERT = FALSE; 278 279 if ((optarg != NULL) && (*optarg != '\0')) { 280 if ((PER_LINE = atoi(optarg)) <= 0) 281 PER_LINE = 1; 282 } 283 break; 284 285 case 'n': /* -n number: # stdin args */ 286 /* 287 * -n number: # stdin args. 288 * number *is* required here: 289 */ 290 if ((N_ARGS = atoi(optarg)) <= 0) { 291 ermsg(_("#args must be positive int: %s\n"), 292 optarg); 293 } else { 294 LEGAL = DASHX || N_ARGS == 1; 295 INSERT = PER_LINE = FALSE; 296 } 297 break; 298 299 case 's': /* -s size: set max size of each arg list */ 300 BUFLIM = atoi(optarg); 301 if (BUFLIM > BUFSIZE || BUFLIM <= 0) { 302 ermsg(_("0 < max-cmd-line-size <= %d: %s\n"), 303 BUFSIZE, optarg); 304 } 305 break; 306 307 case 'x': /* -x: terminate if args > size limit */ 308 DASHX = LEGAL = TRUE; 309 break; 310 311 default: 312 /* 313 * bad argument. complain and get ready to die. 314 */ 315 usage(); 316 exit(2); 317 break; 318 } 319 } 320 321 /* 322 * if anything called ermsg(), something screwed up, so 323 * we exit early. 324 */ 325 if (OK == FALSE) { 326 usage(); 327 exit(2); 328 } 329 330 /* 331 * we're finished handling xargs's options, so now pick up 332 * the command name (if any), and it's options. 333 */ 334 335 336 mac -= optind; /* dec arg count by what we've processed */ 337 mav += optind; /* inc to current mav */ 338 339 if (mac <= 0) { /* if there're no more args to process, */ 340 cmdname = "/usr/bin/echo"; /* our default command */ 341 *ARGV++ = addarg(cmdname); /* use the default cmd. */ 342 } else { /* otherwise keep parsing rest of the string. */ 343 /* 344 * note that we can't use getopts(3C), and *must* parse 345 * this by hand, as we don't know apriori what options the 346 * command will take. 347 */ 348 cmdname = *mav; /* get the command name */ 349 350 351 /* pick up the remaining args from the command line: */ 352 while ((OK == TRUE) && (mac-- > 0)) { 353 /* 354 * while we haven't crapped out, and there's 355 * work to do: 356 */ 357 if (INSERT && ! ERR) { 358 if (strstr(*mav, INSPAT) != NULL) { 359 if (++n_inserts > MAXINSERTS) { 360 ermsg(_("too many args " 361 "with %s\n"), INSPAT); 362 ERR = TRUE; 363 } 364 psave->p_ARGV = ARGV; 365 (psave++)->p_skel = *mav; 366 } 367 } 368 *ARGV++ = addarg(*mav++); 369 } 370 } 371 372 /* pick up args from standard input */ 373 374 initlist = ARGV; 375 initsize = linesize; 376 lastarg[0] = '\0'; 377 378 while (OK) { 379 N_args = 0; 380 N_lines = 0; 381 ARGV = initlist; 382 linesize = initsize; 383 next = argbuf; 384 385 while (MORE || (lastarg[0] != '\0')) { 386 int l; 387 388 if (*lastarg != '\0') { 389 arg = strcpy(next, lastarg); 390 *lastarg = '\0'; 391 } else if ((arg = getarg(next)) == NULL) { 392 break; 393 } 394 395 l = strlen(arg) + 1; 396 linesize += l; 397 next += l; 398 399 /* Inserts are handled specially later. */ 400 if ((n_inserts == 0) && (linesize >= BUFLIM)) { 401 /* 402 * Legal indicates hard fail if the list is 403 * truncated due to size. So fail, or if we 404 * cannot create any list because it would be 405 * too big. 406 */ 407 if (LEGAL || N_args == 0) { 408 EMSG(LIST2LONG); 409 exit(2); 410 /* NOTREACHED */ 411 } 412 413 /* 414 * Otherwise just save argument for later. 415 */ 416 (void) strcpy(lastarg, arg); 417 break; 418 } 419 420 *ARGV++ = arg; 421 422 N_args++; 423 424 if ((PER_LINE && N_lines >= PER_LINE) || 425 (N_ARGS && (N_args) >= N_ARGS)) { 426 break; 427 } 428 429 430 if ((ARGV - arglist) == MAXARGS) { 431 break; 432 } 433 } 434 435 *ARGV = NULL; 436 if (N_args == 0) { 437 /* Reached the end with no more work. */ 438 exit(exitstat); 439 } 440 441 /* insert arg if requested */ 442 443 if (!ERR && INSERT) { 444 445 p_ibuf = ins_buf; 446 ARGV--; 447 j = ibufsize = 0; 448 for (psave = saveargv; ++j <= n_inserts; ++psave) { 449 addibuf(psave); 450 if (ERR) 451 break; 452 } 453 } 454 *ARGV = NULL; 455 456 if (n_inserts > 0) { 457 /* 458 * if we've done any insertions, re-calculate the 459 * linesize. bomb out if we've exceeded our length. 460 */ 461 linesize = 0; 462 for (ARGV = arglist; *ARGV != NULL; ARGV++) { 463 linesize += strlen(*ARGV) + 1; 464 } 465 if (linesize >= BUFLIM) { 466 EMSG(LIST2LONG); 467 exit(2); 468 /* NOTREACHED */ 469 } 470 } 471 472 /* exec command */ 473 474 if (!ERR) { 475 if (!MORE && 476 (PER_LINE && N_lines == 0 || N_ARGS && N_args == 0)) 477 exit(exitstat); 478 OK = TRUE; 479 j = TRACE ? echoargs() : TRUE; 480 if (j) { 481 /* 482 * for xcu4, all invocations of cmdname must 483 * return 0, in order for us to return 0. 484 * so if we have a non-zero status here, 485 * quit immediately. 486 */ 487 exitstat |= lcall(cmdname, arglist); 488 } 489 } 490 } 491 492 if (OK) 493 return (exitstat); 494 495 /* 496 * if exitstat was set, to match XCU4 complience, 497 * return that value, otherwise, return 1. 498 */ 499 return (exitstat ? exitstat : 1); 500 } 501 502 static char * 503 addarg(char *arg) 504 { 505 linesize += (strlen(arg) + 1); 506 return (arg); 507 } 508 509 510 static void 511 store_str(char **buffer, char *str, size_t len) 512 { 513 (void) memcpy(*buffer, str, len); 514 (*buffer)[len] = '\0'; 515 *buffer += len; 516 } 517 518 519 static char * 520 getarg(char *arg) 521 { 522 char *xarg = arg; 523 wchar_t c; 524 char mbc[MB_LEN_MAX]; 525 size_t len; 526 int escape = 0; 527 int inquote = 0; 528 529 arg[0] = '\0'; 530 531 while (MORE) { 532 533 len = 0; 534 c = getwchr(mbc, &len); 535 536 if (((arg - xarg) + len) > BUFLIM) { 537 EMSG2(ARG2LONG, BUFLIM); 538 exit(2); 539 ERR = TRUE; 540 return (NULL); 541 } 542 543 switch (c) { 544 case '\n': 545 if (ZERO) { 546 store_str(&arg, mbc, len); 547 continue; 548 } 549 /* FALLTHRU */ 550 551 case '\0': 552 case WEOF: /* Note WEOF == EOF */ 553 554 if (escape) { 555 EMSG(BADESCAPE); 556 ERR = TRUE; 557 return (NULL); 558 } 559 if (inquote) { 560 EMSG(MISSQUOTE); 561 ERR = TRUE; 562 return (NULL); 563 } 564 565 N_lines++; 566 break; 567 568 case '"': 569 if (ZERO || escape || (inquote == 1)) { 570 /* treat it literally */ 571 escape = 0; 572 store_str(&arg, mbc, len); 573 574 } else if (inquote == 2) { 575 /* terminating double quote */ 576 inquote = 0; 577 578 } else { 579 /* starting quoted string */ 580 inquote = 2; 581 } 582 continue; 583 584 case '\'': 585 if (ZERO || escape || (inquote == 2)) { 586 /* treat it literally */ 587 escape = 0; 588 store_str(&arg, mbc, len); 589 590 } else if (inquote == 1) { 591 /* terminating single quote */ 592 inquote = 0; 593 594 } else { 595 /* starting quoted string */ 596 inquote = 1; 597 } 598 continue; 599 600 case '\\': 601 /* 602 * Any unquoted character can be escaped by 603 * preceding it with a backslash. 604 */ 605 if (ZERO || inquote || escape) { 606 escape = 0; 607 store_str(&arg, mbc, len); 608 } else { 609 escape = 1; 610 } 611 continue; 612 613 default: 614 /* most times we will just want to store it */ 615 if (inquote || escape || ZERO || !iswctype(c, blank)) { 616 escape = 0; 617 store_str(&arg, mbc, len); 618 continue; 619 } 620 /* unquoted blank */ 621 break; 622 } 623 624 /* 625 * At this point we are processing a complete argument. 626 */ 627 if (strcmp(xarg, LEOF) == 0 && *LEOF != '\0') { 628 MORE = FALSE; 629 return (NULL); 630 } 631 if (c == WEOF) { 632 MORE = FALSE; 633 } 634 if (xarg[0] == '\0') 635 continue; 636 break; 637 } 638 639 return (xarg[0] == '\0' ? NULL : xarg); 640 } 641 642 /* 643 * ermsg(): print out an error message, and indicate failure globally. 644 * 645 * Assumes that message has already been gettext()'d. It would be 646 * nice if we could just do the gettext() here, but we can't, since 647 * since xgettext(1M) wouldn't be able to pick up our error message. 648 */ 649 /* PRINTFLIKE1 */ 650 static void 651 ermsg(char *messages, ...) 652 { 653 va_list ap; 654 655 va_start(ap, messages); 656 657 (void) fprintf(stderr, "xargs: "); 658 (void) vfprintf(stderr, messages, ap); 659 660 va_end(ap); 661 OK = FALSE; 662 } 663 664 static int 665 echoargs() 666 { 667 char **anarg; 668 char **tanarg; /* tmp ptr */ 669 int i; 670 char reply[LINE_MAX]; 671 672 tanarg = anarg = arglist-1; 673 674 /* 675 * write out each argument, separated by a space. the tanarg 676 * nonsense is for xcu4 testsuite compliance - so that an 677 * extra space isn't echoed after the last argument. 678 */ 679 while (*++anarg) { /* while there's an argument */ 680 ++tanarg; /* follow anarg */ 681 (void) write(2, *anarg, strlen(*anarg)); 682 683 if (*++tanarg) { /* if there's another argument: */ 684 (void) write(2, " ", 1); /* add a space */ 685 --tanarg; /* reset back to anarg */ 686 } 687 } 688 if (PROMPT == -1) { 689 (void) write(2, "\n", 1); 690 return (TRUE); 691 } 692 693 (void) write(2, "?...", 4); /* ask the user for input */ 694 695 for (i = 0; i < LINE_MAX && read(PROMPT, &reply[i], 1) > 0; i++) { 696 if (reply[i] == '\n') { 697 if (i == 0) 698 return (FALSE); 699 break; 700 } 701 } 702 reply[i] = 0; 703 704 /* flush remainder of line if necessary */ 705 if (i == LINE_MAX) { 706 char bitbucket; 707 708 while ((read(PROMPT, &bitbucket, 1) > 0) && (bitbucket != '\n')) 709 ; 710 } 711 712 return (yes_check(reply)); 713 } 714 715 716 static char * 717 insert(char *pattern, char *subst) 718 { 719 static char buffer[MAXSBUF+1]; 720 int len, ipatlen; 721 char *pat; 722 char *bufend; 723 char *pbuf; 724 725 len = strlen(subst); 726 ipatlen = strlen(INSPAT) - 1; 727 pat = pattern - 1; 728 pbuf = buffer; 729 bufend = &buffer[MAXSBUF]; 730 731 while (*++pat) { 732 if (strncmp(pat, INSPAT, ipatlen) == 0) { 733 if (pbuf + len >= bufend) { 734 break; 735 } else { 736 (void) strcpy(pbuf, subst); 737 pat += ipatlen; 738 pbuf += len; 739 } 740 } else { 741 *pbuf++ = *pat; 742 if (pbuf >= bufend) 743 break; 744 } 745 } 746 747 if (!*pat) { 748 *pbuf = '\0'; 749 return (buffer); 750 } else { 751 ermsg(gettext("Maximum argument size with insertion via %s's " 752 "exceeded\n"), INSPAT); 753 ERR = TRUE; 754 return (NULL); 755 } 756 } 757 758 759 static void 760 addibuf(struct inserts *p) 761 { 762 char *newarg, *skel, *sub; 763 int l; 764 765 skel = p->p_skel; 766 sub = *ARGV; 767 newarg = insert(skel, sub); 768 if (ERR) 769 return; 770 771 l = strlen(newarg) + 1; 772 if ((ibufsize += l) > MAXIBUF) { 773 EMSG(IBUFOVERFLOW); 774 ERR = TRUE; 775 } 776 (void) strcpy(p_ibuf, newarg); 777 *(p->p_ARGV) = p_ibuf; 778 p_ibuf += l; 779 } 780 781 782 /* 783 * getwchr(): get the next wide character. 784 * description: 785 * we get the next character from stdin. This returns WEOF if no 786 * character is present. If ZERO is set, it gets a single byte instead 787 * a wide character. 788 */ 789 static wint_t 790 getwchr(char *mbc, size_t *sz) 791 { 792 size_t i; 793 int c; 794 wchar_t wch; 795 796 i = 0; 797 while (i < MB_CUR_MAX) { 798 799 if ((c = fgetc(stdin)) == EOF) { 800 801 if (i == 0) { 802 /* TRUE EOF has been reached */ 803 return (WEOF); 804 } 805 806 /* 807 * We have some characters in our buffer still so it 808 * must be an invalid character right before EOF. 809 */ 810 break; 811 } 812 mbc[i++] = (char)c; 813 814 /* If this succeeds then we are done */ 815 if (ZERO) { 816 *sz = i; 817 return ((char)c); 818 } 819 if (mbtowc(&wch, mbc, i) != -1) { 820 *sz = i; 821 return ((wint_t)wch); 822 } 823 } 824 825 /* 826 * We have now encountered an illegal character sequence. 827 * There is nothing much we can do at this point but 828 * return an error. If we attempt to recover we may in fact 829 * return garbage as arguments, from the customer's point 830 * of view. After all what if they are feeding us a file 831 * generated in another locale? 832 */ 833 errno = EILSEQ; 834 PERR(CORRUPTFILE); 835 exit(1); 836 /* NOTREACHED */ 837 } 838 839 840 static int 841 lcall(char *sub, char **subargs) 842 { 843 int retcode, retry = 0; 844 pid_t iwait, child; 845 846 for (;;) { 847 switch (child = fork()) { 848 default: 849 while ((iwait = wait(&retcode)) != child && 850 iwait != (pid_t)-1) 851 ; 852 if (iwait == (pid_t)-1) { 853 PERR(WAITFAIL); 854 exit(122); 855 /* NOTREACHED */ 856 } 857 if (WIFSIGNALED(retcode)) { 858 EMSG2(CHILDSIG, WTERMSIG(retcode)); 859 exit(125); 860 /* NOTREACHED */ 861 } 862 if ((WEXITSTATUS(retcode) & 0377) == 0377) { 863 EMSG(CHILDFAIL); 864 exit(124); 865 /* NOTREACHED */ 866 } 867 return (WEXITSTATUS(retcode)); 868 case 0: 869 (void) execvp(sub, subargs); 870 PERR(EXECFAIL); 871 if (errno == EACCES) 872 exit(126); 873 exit(127); 874 /* NOTREACHED */ 875 case -1: 876 if (errno != EAGAIN && retry++ < FORK_RETRY) { 877 PERR(FORKFAIL); 878 exit(123); 879 } 880 (void) sleep(1); 881 } 882 } 883 } 884 885 886 static void 887 usage() 888 { 889 ermsg(_(USAGEMSG)); 890 OK = FALSE; 891 } 892 893 894 895 /* 896 * parseargs(): modify the args 897 * since the -e, -i and -l flags all take optional subarguments, 898 * and getopts(3C) is clueless about this nonsense, we change the 899 * our local argument count and strings to separate this out, 900 * and make it easier to handle via getopts(3c). 901 * 902 * -e -> "-e "" 903 * -e3 -> "-e "3" 904 * -Estr -> "-E "str" 905 * -i -> "-i "{}" 906 * -irep -> "-i "rep" 907 * -l -> "-i "1" 908 * -l10 -> "-i "10" 909 * 910 * since the -e, -i and -l flags all take optional subarguments, 911 */ 912 static void 913 parseargs(int ac, char **av) 914 { 915 int i; /* current argument */ 916 int cflag; /* 0 = not processing cmd arg */ 917 918 if ((mav = malloc((ac * 2 + 1) * sizeof (char *))) == NULL) { 919 PERR(MALLOCFAIL); 920 exit(1); 921 } 922 923 /* for each argument, see if we need to change things: */ 924 for (i = mac = cflag = 0; (av[i] != NULL) && i < ac; i++, mac++) { 925 if ((mav[mac] = strdup(av[i])) == NULL) { 926 PERR(MALLOCFAIL); 927 exit(1); 928 } 929 930 /* -- has been found or argument list is fully processes */ 931 if (cflag) 932 continue; 933 934 /* 935 * if we're doing special processing, and we've got a flag 936 */ 937 else if ((av[i][0] == '-') && (av[i][1] != NULL)) { 938 char *def; 939 940 switch (av[i][1]) { 941 case 'e': 942 def = ""; /* -e with no arg turns off eof */ 943 goto process_special; 944 case 'i': 945 def = INSPAT_STR; 946 goto process_special; 947 case 'l': 948 def = "1"; 949 process_special: 950 /* 951 * if there's no sub-option, we *must* add 952 * a default one. this is because xargs must 953 * be able to distinguish between a valid 954 * suboption, and a command name. 955 */ 956 if (av[i][2] == NULL) { 957 mav[++mac] = strdup(def); 958 } else { 959 /* clear out our version: */ 960 mav[mac][2] = NULL; 961 mav[++mac] = strdup(&av[i][2]); 962 } 963 if (mav[mac] == NULL) { 964 PERR(MALLOCFAIL); 965 exit(1); 966 } 967 break; 968 969 /* flags with required subarguments: */ 970 971 /* 972 * there are two separate cases here. either the 973 * flag can have the normal XCU4 handling 974 * (of the form: -X subargument); or it can have 975 * the old solaris 2.[0-4] handling (of the 976 * form: -Xsubargument). in order to maintain 977 * backwards compatibility, we must support the 978 * latter case. we handle the latter possibility 979 * first so both the old solaris way of handling 980 * and the new XCU4 way of handling things are allowed. 981 */ 982 case 'n': /* FALLTHROUGH */ 983 case 's': /* FALLTHROUGH */ 984 case 'E': /* FALLTHROUGH */ 985 case 'I': /* FALLTHROUGH */ 986 case 'L': 987 /* 988 * if the second character isn't null, then 989 * the user has specified the old syntax. 990 * we move the subargument into our 991 * mod'd argument list. 992 */ 993 if (av[i][2] != NULL) { 994 /* first clean things up: */ 995 mav[mac][2] = NULL; 996 997 /* now add the separation: */ 998 ++mac; /* inc to next mod'd arg */ 999 if ((mav[mac] = strdup(&av[i][2])) == 1000 NULL) { 1001 PERR(MALLOCFAIL); 1002 exit(1); 1003 } 1004 break; 1005 } 1006 i++; 1007 mac++; 1008 1009 if (av[i] == NULL) { 1010 mav[mac] = NULL; 1011 return; 1012 } 1013 if ((mav[mac] = strdup(av[i])) == NULL) { 1014 PERR(MALLOCFAIL); 1015 exit(1); 1016 } 1017 break; 1018 1019 /* flags */ 1020 case 'p' : 1021 case 't' : 1022 case 'x' : 1023 case '0' : 1024 break; 1025 1026 case '-' : 1027 default: 1028 /* 1029 * here we've hit the cmd argument. so 1030 * we'll stop special processing, as the 1031 * cmd may have a "-i" etc., argument, 1032 * and we don't want to add a "" to it. 1033 */ 1034 cflag = 1; 1035 break; 1036 } 1037 } else if (i > 0) { /* if we're not the 1st arg */ 1038 /* 1039 * if it's not a flag, then it *must* be the cmd. 1040 * set cflag, so we don't mishandle the -[eil] flags. 1041 */ 1042 cflag = 1; 1043 } 1044 } 1045 1046 mav[mac] = NULL; 1047 } 1048