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