OpenSolaris_b135/cmd/xargs/xargs.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
#pragma ident "%Z%%M% %I% %E% SMI"
#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <stdarg.h>
#include <stdlib.h>
#include <limits.h>
#include <wchar.h>
#include <locale.h>
#include <langinfo.h>
#include <stropts.h>
#include <poll.h>
#include <errno.h>
#include <stdarg.h>
#include "getresponse.h"
#define HEAD 0
#define TAIL 1
#define FALSE 0
#define TRUE 1
#define MAXSBUF 255
#define MAXIBUF 512
#define MAXINSERTS 5
#define BUFSIZE LINE_MAX
#define MAXARGS 255
#define INSPAT_STR "{}" /* default replstr string for -[Ii] */
#define FORK_RETRY 5
#define QBUF_STARTLEN 255 /* start size of growable string buffer */
#define QBUF_INC 100 /* how much to grow a growable string by */
static wctype_t blank;
static char *arglist[MAXARGS+1];
static char argbuf[BUFSIZE+1];
static char *next = argbuf;
static char *lastarg = "";
static char **ARGV = arglist;
static char *LEOF = "_";
static char *INSPAT = INSPAT_STR;
static char ins_buf[MAXIBUF];
static char *p_ibuf;
static struct inserts {
char **p_ARGV; /* where to put newarg ptr in arg list */
char *p_skel; /* ptr to arg template */
} saveargv[MAXINSERTS];
static off_t file_offset = 0;
static int PROMPT = -1;
static int BUFLIM = BUFSIZE;
static int N_ARGS = 0;
static int N_args = 0;
static int N_lines = 0;
static int DASHX = FALSE;
static int MORE = TRUE;
static int PER_LINE = FALSE;
static int ERR = FALSE;
static int OK = TRUE;
static int LEGAL = FALSE;
static int TRACE = FALSE;
static int INSERT = FALSE;
static int linesize = 0;
static int ibufsize = 0;
static int exitstat = 0; /* our exit status */
static int mac; /* modified argc, after parsing */
static char **mav; /* modified argv, after parsing */
static int n_inserts; /* # of insertions. */
static int inquote = 0; /* processing a quoted string */
static int save_index = 0;
/*
* the pio structure is used to save any pending input before the
* user replies to a prompt. the pending input is saved here,
* for the appropriate processing later.
*/
typedef struct pio {
struct pio *next; /* next in stack */
char *start; /* starting addr of the buffer */
char *cur; /* ptr to current char in buf */
size_t length; /* number of bytes remaining */
} pio;
static pio *queued_data = NULL;
/* our usage message: */
#define USAGEMSG "Usage: xargs: [-t] [-p] [-e[eofstr]] [-E eofstr] "\
"[-I replstr] [-i[replstr]] [-L #] [-l[#]] [-n # [-x]] [-s size] "\
"[cmd [args ...]]\n"
static int echoargs();
static int getchr(void);
static wchar_t getwchr(void);
static void ungetwchr(wchar_t);
static int lcall(char *sub, char **subargs);
static int xindex(char *as1, char *as2);
static void addibuf(struct inserts *p);
static void ermsg(char *messages, ...);
static char *addarg(char *arg);
static char *checklen(char *arg);
static size_t store_wchr(char **, size_t *, size_t, wchar_t);
static char *getarg();
static char *insert(char *pattern, char *subst);
static void usage();
static void parseargs();
static void saveinput();
int
main(int argc, char **argv)
{
int j;
struct inserts *psave;
int c;
int initsize;
char *cmdname, *initbuf, **initlist;
/* initialization */
blank = wctype("blank");
n_inserts = 0;
psave = saveargv;
(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
#define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */
#endif
(void) textdomain(TEXT_DOMAIN);
if (init_yes() < 0) {
ermsg(gettext(ERR_MSG_INIT_YES), strerror(errno));
exit(1);
}
parseargs(argc, argv);
/* handling all of xargs arguments: */
while ((c = getopt(mac, mav, "tpe:E:I:i:L:l:n:s:x")) != EOF) {
switch (c) {
case 't': /* -t: turn trace mode on */
TRACE = TRUE;
break;
case 'p': /* -p: turn on prompt mode. */
if ((PROMPT = open("/dev/tty", O_RDONLY)) == -1) {
perror(gettext("can't read from tty for -p"));
} else {
TRACE = TRUE;
}
break;
case 'e':
/*
* -e[eofstr]: set/disable end-of-file.
* N.B. that an argument *isn't* required here; but
* parseargs forced an argument if not was given. The
* forced argument is the default...
*/
LEOF = optarg; /* can be empty */
break;
case 'E':
/*
* -E eofstr: change end-of-file string.
* eofstr *is* required here, but can be empty:
*/
LEOF = optarg;
break;
case 'I':
/* -I replstr: Insert mode. replstr *is* required. */
INSERT = PER_LINE = LEGAL = TRUE;
N_ARGS = 0;
INSPAT = optarg;
if (*optarg == '\0') {
ermsg(gettext(
"Option requires an argument: -%c\n"), c);
}
break;
case 'i':
/*
* -i [replstr]: insert mode, with *optional* replstr.
* N.B. that an argument *isn't* required here; if
* it's not given, then the string INSPAT_STR will
* be assumed.
*
* Since getopts(3C) doesn't handle the case of an
* optional variable argument at all, we have to
* parse this by hand:
*/
INSERT = PER_LINE = LEGAL = TRUE;
N_ARGS = 0;
if ((optarg != NULL) && (*optarg != '\0')) {
INSPAT = optarg;
} else {
/*
* here, there is no next argument. so
* we reset INSPAT to the INSPAT_STR.
* we *have* to do this, as -i/I may have
* been given previously, and XCU4 requires
* that only "the last one specified takes
* effect".
*/
INSPAT = INSPAT_STR;
}
break;
case 'L':
/*
* -L number: # of times cmd is executed
* number *is* required here:
*/
PER_LINE = TRUE;
N_ARGS = 0;
INSERT = FALSE;
if ((PER_LINE = atoi(optarg)) <= 0) {
ermsg(gettext("#lines must be positive "
"int: %s\n"), optarg);
}
break;
case 'l':
/*
* -l [number]: # of times cmd is executed
* N.B. that an argument *isn't* required here; if
* it's not given, then 1 is assumed.
*
* parseargs handles the optional arg processing.
*/
PER_LINE = LEGAL = TRUE; /* initialization */
N_ARGS = 0;
INSERT = FALSE;
if ((optarg != NULL) && (*optarg != '\0')) {
if ((PER_LINE = atoi(optarg)) <= 0)
PER_LINE = 1;
}
break;
case 'n': /* -n number: # stdin args */
/*
* -n number: # stdin args.
* number *is* required here:
*/
if ((N_ARGS = atoi(optarg)) <= 0) {
ermsg(gettext("#args must be positive "
"int: %s\n"), optarg);
} else {
LEGAL = DASHX || N_ARGS == 1;
INSERT = PER_LINE = FALSE;
}
break;
case 's': /* -s size: set max size of each arg list */
BUFLIM = atoi(optarg);
if (BUFLIM > BUFSIZE || BUFLIM <= 0) {
ermsg(gettext(
"0 < max-cmd-line-size <= %d: "
"%s\n"), BUFSIZE, optarg);
}
break;
case 'x': /* -x: terminate if args > size limit */
DASHX = LEGAL = TRUE;
break;
default:
/*
* bad argument. complain and get ready to die.
*/
ERR = TRUE;
usage();
exit(2);
break;
}
}
/*
* if anything called ermsg(), something screwed up, so
* we exit early.
*/
if (OK == FALSE) {
ERR = TRUE;
usage();
exit(2);
}
/*
* we're finished handling xargs's options, so now pick up
* the command name (if any), and it's options.
*/
mac -= optind; /* dec arg count by what we've processed */
mav += optind; /* inc to current mav */
if (mac <= 0) { /* if there're no more args to process, */
cmdname = "/usr/bin/echo"; /* our default command */
*ARGV++ = addarg(cmdname); /* use the default cmd. */
} else { /* otherwise keep parsing rest of the string. */
/*
* note that we can't use getopts(3C), and *must* parse
* this by hand, as we don't know apriori what options the
* command will take.
*/
cmdname = *mav; /* get the command name */
/* pick up the remaining args from the command line: */
while ((OK == TRUE) && (mac-- > 0)) {
/*
* while we haven't crapped out, and there's
* work to do:
*/
if (INSERT && ! ERR) {
if (xindex(*mav, INSPAT) != -1) {
if (++n_inserts > MAXINSERTS) {
ermsg(gettext("too many args "
"with %s\n"), INSPAT);
ERR = TRUE;
}
psave->p_ARGV = ARGV;
(psave++)->p_skel = *mav;
}
}
*ARGV++ = addarg(*mav++);
}
}
/* pick up args from standard input */
initbuf = next;
initlist = ARGV;
initsize = linesize;
while (OK && MORE) {
N_args = 0;
N_lines = 0;
next = initbuf;
ARGV = initlist;
linesize = initsize;
if (*lastarg) {
*ARGV++ = addarg(lastarg);
lastarg = "";
}
while (((*ARGV++ = getarg()) != NULL) && OK) {
if ((ARGV - arglist) == MAXARGS) {
save_index = ARGV - arglist;
break;
}
}
if ((save_index == MAXARGS) && !MORE && (N_args == 0)) {
/* there were no more args after filling arglist */
exit(exitstat);
}
/* insert arg if requested */
if (!ERR && INSERT) {
if ((!MORE) && (N_lines == 0)) {
exit(exitstat);
}
/* no more input lines */
p_ibuf = ins_buf;
ARGV--;
j = ibufsize = 0;
for (psave = saveargv; ++j <= n_inserts; ++psave) {
addibuf(psave);
if (ERR)
break;
}
}
*ARGV = 0;
if (n_inserts > 0) {
int t_ninserts;
/*
* if we've done any insertions, re-calculate the
* linesize. bomb out if we've exceeded our length.
*/
t_ninserts = n_inserts;
n_inserts = 0; /* inserts have been done */
linesize = 0; /* recalculate this */
/* for each current argument in the list: */
for (ARGV = arglist; *ARGV != NULL; ARGV++) {
/* recalculate everything. */
if (checklen(*ARGV) != 0) {
if (N_ARGS && (N_args >= N_ARGS)) {
N_lines = N_args = 0;
OK = FALSE;
ERR = TRUE;
}
}
}
n_inserts = t_ninserts;
}
/* exec command */
if (!ERR) {
if (!MORE &&
(PER_LINE && N_lines == 0 || N_ARGS && N_args == 0))
exit(exitstat);
OK = TRUE;
j = TRACE ? echoargs() : TRUE;
if (j) {
/*
* for xcu4, all invocations of cmdname must
* return 0, in order for us to return 0.
* so if we have a non-zero status here,
* quit immediately.
*/
if ((exitstat |= lcall(cmdname, arglist)) == 0)
continue;
}
}
}
(void) lseek(0, file_offset, SEEK_SET);
if (OK) {
return (exitstat);
} else {
/*
* if exitstat was set, to match XCU4 complience,
* return that value, otherwise, return 1.
*/
return (exitstat ? exitstat : 1);
}
}
static void
queue(char *buffer, int len, int where)
{
pio *new, *element;
if ((new = malloc(sizeof (pio))) == NULL) {
perror(gettext("xargs: Memory allocation failure"));
exit(1);
}
new->cur = new->start = buffer;
new->length = len;
if (where == TAIL) {
new->next = NULL;
if (queued_data == NULL) {
queued_data = new;
} else {
element = queued_data;
while (element->next != NULL) {
element = element->next;
}
element->next = new;
}
} else {
file_offset -= len;
new->next = queued_data;
queued_data = new;
}
}
static char *
checklen(char *arg)
{
int oklen;
oklen = TRUE;
linesize += strlen(arg) + 1;
if (linesize >= BUFLIM) {
/*
* we skip this if there're inserts. we'll handle the
* argument counting after all the insertions have
* been done.
*/
if (n_inserts == 0) {
lastarg = arg;
oklen = OK = FALSE;
if (LEGAL) {
ERR = TRUE;
ermsg(gettext("arg list too long\n"));
} else if (N_args > 1) {
N_args = 1;
} else {
ermsg(gettext("a single arg was greater than "
"the max arglist size of %d characters\n"),
BUFLIM);
ERR = TRUE;
}
}
}
return (oklen ? arg : 0);
}
static char *
addarg(char *arg)
{
if (checklen(arg) != 0) {
(void) strcpy(next, arg);
arg = next;
next += strlen(arg) + 1;
return (arg);
}
return ((char *)0);
}
/*
* store_wchr() : append a wchar_t to a char buffer, resize buffer if required.
*
* Given a pointer to the beginning of a string buffer, the length of the
* buffer and an offset indicating the next place to write within that
* buffer, the passed wchar_t will be appended to the buffer if there is
* enough space. If there is not enough space, an attempt to reallocate the
* buffer will be made and if successful the passed pointer and size will be
* updated to describe the reallocated block. Returns the new value for
* 'offset' (it will be incremented by the number of bytes written).
*/
static size_t
store_wchr(char **buffer, size_t *buflen, size_t offset, wchar_t c)
{
int bytes;
/*
* Make sure that there is enough room in the buffer to store the
* maximum length of c.
*/
if ((offset + MB_CUR_MAX) > *buflen) {
/*
* Not enough room so attempt to reallocate. Add 'MB_CUR_MAX' to
* buffer length to ensure that there is always enough room to
* store 'c' if realloc succeeds, no matter what QBUF_INC is
* defined as.
*/
*buflen += (QBUF_INC + MB_CUR_MAX);
if ((*buffer = realloc(*buffer, *buflen)) == NULL) {
perror(gettext("xargs: Memory allocation failure"));
exit(1);
}
}
/* store bytes from wchar into buffer */
bytes = wctomb(*buffer + offset, c);
if (bytes == -1) {
/* char was invalid */
bytes = 1;
*(*buffer + offset) = (char)c;
}
/* return new value for offset */
return (offset + bytes);
}
static char *
getarg()
{
int bytes;
wchar_t c;
char *arg;
char *retarg, *requeue_buf;
size_t requeue_offset = 0, requeue_len;
char mbc[MB_LEN_MAX];
while (iswspace(c = getwchr()) || c == '\n')
;
if (c == '\0') {
MORE = FALSE;
return (0);
}
/*
* While we are reading in an argument, it is possible that we will
* reach the maximum length of the overflow buffer and we'll have to
* requeue what we have read so far. To handle this we allocate an
* initial buffer here which will keep an unprocessed copy of the data
* that we read in (this buffer will grow as required).
*/
requeue_len = (size_t)QBUF_STARTLEN;
if ((requeue_buf = (char *)malloc(requeue_len)) == NULL) {
perror(gettext("xargs: Memory allocation failure"));
exit(1);
}
for (arg = next; ; c = getwchr()) {
bytes = wctomb(mbc, c);
/*
* Store the char that we have read before processing it in case
* the current argument needs to be requeued.
*/
requeue_offset = store_wchr(&requeue_buf, &requeue_len,
requeue_offset, c);
/* Check for overflow the input buffer */
if ((next + ((bytes == -1) ? 1 : bytes)) >= &argbuf[BUFLIM]) {
/*
* It's only an error if there are no Args in buffer
* already.
*/
if ((N_ARGS || PER_LINE) && LEGAL) {
ERR = TRUE;
ermsg(gettext("Argument list too long\n"));
free(requeue_buf);
return (0);
} else if (N_args == 0) {
lastarg = "";
ERR = TRUE;
ermsg(gettext("A single arg was greater than "
"the max arglist size of %d characters\n"),
BUFSIZE);
free(requeue_buf);
return (0);
}
/*
* Otherwise we put back the current argument
* and use what we have collected so far...
*/
queue(requeue_buf, requeue_offset, HEAD);
/* reset inquote because we have requeued the quotes */
inquote = 0;
return (NULL);
}
if (iswctype(c, blank) && inquote == 0) {
if (INSERT) {
if (bytes == -1) {
*next++ = (char)c;
} else {
(void) wctomb(next, c);
next += bytes;
}
continue;
}
/* skip over trailing whitespace till next arg */
while (iswctype((c = getwchr()), blank) &&
(c != '\n') && (c != '\0'))
;
/*
* if there was space till end of line then the last
* character was really a newline...
*/
if (c == L'\n' || c == L'\0') {
ungetwchr(L'\n');
} else {
/* later code needs to know this was a space */
ungetwchr(c);
c = L' ';
}
goto end_arg;
}
switch (c) {
case L'\0':
case L'\n':
if (inquote) {
*next++ = '\0';
ermsg(gettext("Missing quote: %s\n"), arg);
ERR = TRUE;
free(requeue_buf);
return (0);
}
N_lines++;
end_arg: *next++ = '\0';
/* we finished without requeuing so free requeue_buf */
free(requeue_buf);
if ((strcmp(arg, LEOF) == 0 && *LEOF != '\0') ||
(c == '\0' && strlen(arg) == 0)) {
MORE = FALSE;
/* absorb the rest of the line */
if ((c != '\n') && (c != '\0'))
while (c = getwchr())
if ((c == '\n') || (c == '\0'))
break;
if (strcmp(arg, LEOF) == 0 && *LEOF != '\0') {
/*
* Encountered EOF string.
* Don't read any more lines.
*/
N_lines = 0;
}
return (0);
} else {
++N_args;
if (retarg = checklen(arg)) {
if ((PER_LINE &&
N_lines >= PER_LINE &&
(c == '\0' || c == '\n')) ||
(N_ARGS && N_args >= N_ARGS)) {
N_lines = N_args = 0;
lastarg = "";
OK = FALSE;
}
}
return (retarg);
}
case '"':
if (inquote == 1) /* in single quoted string */
goto is_default;
if (inquote == 2) /* terminating double quote */
inquote = 0;
else /* starting quoted string */
inquote = 2;
break;
case '\'':
if (inquote == 2) /* in double quoted string */
goto is_default;
if (inquote == 1) /* terminating single quote */
inquote = 0;
else /* starting quoted string */
inquote = 1;
break;
case L'\\':
/*
* Any unquoted character can be escaped by
* preceding it with a backslash.
*/
if (inquote == 0) {
c = getwchr();
/* store quoted char for potential requeueing */
requeue_offset = store_wchr(&requeue_buf,
&requeue_len, requeue_offset, c);
}
default:
is_default: if (bytes == -1) {
*next++ = (char)c;
} else {
(void) wctomb(next, c);
next += bytes;
}
break;
}
}
}
/*
* ermsg(): print out an error message, and indicate failure globally.
*
* Assumes that message has already been gettext()'d. It would be
* nice if we could just do the gettext() here, but we can't, since
* since xgettext(1M) wouldn't be able to pick up our error message.
*/
/* PRINTFLIKE1 */
static void
ermsg(char *messages, ...)
{
va_list ap;
va_start(ap, messages);
(void) fprintf(stderr, "xargs: ");
(void) vfprintf(stderr, messages, ap);
va_end(ap);
OK = FALSE;
}
static int
echoargs()
{
char **anarg;
char **tanarg; /* tmp ptr */
int i;
char reply[LINE_MAX];
tanarg = anarg = arglist-1;
/*
* write out each argument, separated by a space. the tanarg
* nonsense is for xcu4 testsuite compliance - so that an
* extra space isn't echoed after the last argument.
*/
while (*++anarg) { /* while there's an argument */
++tanarg; /* follow anarg */
(void) write(2, *anarg, strlen(*anarg));
if (*++tanarg) { /* if there's another argument: */
(void) write(2, " ", 1); /* add a space */
--tanarg; /* reset back to anarg */
}
}
if (PROMPT == -1) {
(void) write(2, "\n", 1);
return (TRUE);
}
/*
* at this point, there may be unexpected input pending on stdin,
* if one has used the -n flag. this presents a problem, because
* if we simply do a read(), we'll get the extra input, instead
* of our desired y/n input. so, we see if there's any extra
* input, and if there is, then we will store it.
*/
saveinput();
(void) write(2, "?...", 4); /* ask the user for input */
for (i = 0; i < LINE_MAX && read(PROMPT, &reply[i], 1) > 0; i++) {
if (reply[i] == '\n') {
if (i == 0)
return (FALSE);
break;
}
}
reply[i] = 0;
/* flush remainder of line if necessary */
if (i == LINE_MAX) {
char bitbucket;
while ((read(PROMPT, &bitbucket, 1) > 0) && (bitbucket != '\n'))
;
}
return (yes_check(reply));
}
static char *
insert(char *pattern, char *subst)
{
static char buffer[MAXSBUF+1];
int len, ipatlen;
char *pat;
char *bufend;
char *pbuf;
len = strlen(subst);
ipatlen = strlen(INSPAT) - 1;
pat = pattern - 1;
pbuf = buffer;
bufend = &buffer[MAXSBUF];
while (*++pat) {
if (xindex(pat, INSPAT) == 0) {
if (pbuf + len >= bufend) {
break;
} else {
(void) strcpy(pbuf, subst);
pat += ipatlen;
pbuf += len;
}
} else {
*pbuf++ = *pat;
if (pbuf >= bufend)
break;
}
}
if (!*pat) {
*pbuf = '\0';
return (buffer);
} else {
ermsg(gettext("Maximum argument size with insertion via %s's "
"exceeded\n"), INSPAT);
ERR = TRUE;
return (0);
}
}
static void
addibuf(struct inserts *p)
{
char *newarg, *skel, *sub;
int l;
skel = p->p_skel;
sub = *ARGV;
linesize -= strlen(skel) + 1;
newarg = insert(skel, sub);
if (ERR)
return;
if (checklen(newarg)) {
if ((ibufsize += (l = strlen(newarg) + 1)) > MAXIBUF) {
ermsg(gettext("Insert buffer overflow\n"));
ERR = TRUE;
}
(void) strcpy(p_ibuf, newarg);
*(p->p_ARGV) = p_ibuf;
p_ibuf += l;
}
}
/*
* getchr(): get the next character.
* description:
* we get the next character from pio.structure, if there's a character
* to get. this may happen when we've had to flush stdin=/dev/tty,
* but still wanted to preserve the characters for later processing.
*
* otherwise we just get the character from stdin.
*/
static int
getchr(void)
{
char c;
do {
if (queued_data == NULL) {
char *buffer;
int len;
if ((buffer = malloc(BUFSIZE)) == NULL) {
perror(gettext(
"xargs: Memory allocation failure"));
exit(1);
}
if ((len = read(0, buffer, BUFSIZE)) == 0)
return (0);
if (len == -1) {
perror(gettext("xargs: Read failure"));
exit(1);
}
queue(buffer, len, TAIL);
}
file_offset++;
c = *queued_data->cur++; /* get the next character */
if (--queued_data->length == 0) { /* at the end of buffer? */
pio *nxt = queued_data->next;
free(queued_data->start);
free(queued_data);
queued_data = nxt;
}
} while (c == '\0');
return (c);
}
static wchar_t
getwchr(void)
{
int i;
wchar_t wch;
unsigned char buffer[MB_LEN_MAX + 1];
for (i = 0; i < (int)MB_CUR_MAX; ) {
if ((buffer[i++] = getchr()) == NULL) {
/* We have reached EOF */
if (i == 1) {
/* TRUE EOF has been reached */
return (NULL);
}
/*
* We have some characters in our buffer still so it
* must be an invalid character right before EOF.
*/
break;
}
/* If this succeeds then we are done */
if (mbtowc(&wch, (char *)buffer, i) != -1)
return (wch);
}
/*
* We have now encountered an illegal character sequence.
* There is nothing much we can do at this point but
* return an error. If we attempt to recover we may in fact
* return garbage as arguments, from the customer's point
* of view. After all what if they are feeding us a file
* generated in another locale?
*/
errno = EILSEQ;
perror(gettext("xargs: Corrupt input file"));
exit(1);
/* NOTREACHED */
}
static void
ungetwchr(wchar_t wch)
{
char *buffer;
int bytes;
if ((buffer = malloc(MB_LEN_MAX)) == NULL) {
perror(gettext("xargs: Memory allocation failure"));
exit(1);
}
bytes = wctomb(buffer, wch);
queue(buffer, bytes, HEAD);
}
static int
lcall(char *sub, char **subargs)
{
int retcode, retry = 0;
pid_t iwait, child;
for (; ; ) {
switch (child = fork()) {
default:
while ((iwait = wait(&retcode)) != child &&
iwait != (pid_t)-1)
;
if (iwait == (pid_t)-1) {
perror(gettext("xargs: Wait failure"));
exit(122);
/* NOTREACHED */
}
if (WIFSIGNALED(retcode)) {
ermsg(gettext("Child killed with signal %d\n"),
WTERMSIG(retcode));
exit(125);
/* NOTREACHED */
}
if ((WEXITSTATUS(retcode) & 0377) == 0377) {
ermsg(gettext("Command could not continue "
"processing data\n"));
exit(124);
/* NOTREACHED */
}
return (WEXITSTATUS(retcode));
case 0:
(void) execvp(sub, subargs);
perror(gettext("xargs: Could not exec command"));
if (errno == EACCES)
exit(126);
exit(127);
/* NOTREACHED */
case -1:
if (errno != EAGAIN && retry++ < FORK_RETRY) {
perror(gettext("xargs: Could not fork child"));
exit(123);
}
(void) sleep(1);
}
}
}
/*
* If `s2' is a substring of `s1' return the offset of the first
* occurrence of `s2' in `s1', else return -1.
*/
static int
xindex(char *as1, char *as2)
{
char *s1, *s2, c;
int offset;
s1 = as1;
s2 = as2;
c = *s2;
while (*s1) {
if (*s1++ == c) {
offset = s1 - as1 - 1;
s2++;
while ((c = *s2++) == *s1++ && c)
;
if (c == 0)
return (offset);
s1 = offset + as1 + 1;
s2 = as2;
c = *s2;
}
}
return (-1);
}
static void
usage()
{
ermsg(gettext(USAGEMSG));
OK = FALSE;
}
/*
* parseargs(): modify the args
* since the -e, -i and -l flags all take optional subarguments,
* and getopts(3C) is clueless about this nonsense, we change the
* our local argument count and strings to separate this out,
* and make it easier to handle via getopts(3c).
*
* -e -> "-e ""
* -e3 -> "-e "3"
* -Estr -> "-E "str"
* -i -> "-i "{}"
* -irep -> "-i "rep"
* -l -> "-i "1"
* -l10 -> "-i "10"
*
* since the -e, -i and -l flags all take optional subarguments,
*/
static void
parseargs(int ac, char **av)
{
int i; /* current argument */
int cflag; /* 0 = not processing cmd arg */
if ((mav = malloc((ac * 2 + 1) * sizeof (char *))) == NULL) {
perror(gettext("xargs: Memory allocation failure"));
exit(1);
}
/* for each argument, see if we need to change things: */
for (i = mac = cflag = 0; (av[i] != NULL) && i < ac; i++, mac++) {
if ((mav[mac] = strdup(av[i])) == NULL) {
perror(gettext("xargs: Memory allocation failure"));
exit(1);
}
/* -- has been found or argument list is fully processes */
if (cflag)
continue;
/*
* if we're doing special processing, and we've got a flag
*/
else if ((av[i][0] == '-') && (av[i][1] != NULL)) {
char *def;
switch (av[i][1]) {
case 'e':
def = ""; /* -e with no arg turns off eof */
goto process_special;
case 'i':
def = INSPAT_STR;
goto process_special;
case 'l':
def = "1";
process_special:
/*
* if there's no sub-option, we *must* add
* a default one. this is because xargs must
* be able to distinguish between a valid
* suboption, and a command name.
*/
if (av[i][2] == NULL) {
mav[++mac] = strdup(def);
} else {
/* clear out our version: */
mav[mac][2] = NULL;
mav[++mac] = strdup(&av[i][2]);
}
if (mav[mac] == NULL) {
perror(gettext("xargs: Memory"
" allocation failure"));
exit(1);
}
break;
/* flags with required subarguments: */
/*
* there are two separate cases here. either the
* flag can have the normal XCU4 handling
* (of the form: -X subargument); or it can have
* the old solaris 2.[0-4] handling (of the
* form: -Xsubargument). in order to maintain
* backwards compatibility, we must support the
* latter case. we handle the latter possibility
* first so both the old solaris way of handling
* and the new XCU4 way of handling things are allowed.
*/
case 'n': /* FALLTHROUGH */
case 's': /* FALLTHROUGH */
case 'E': /* FALLTHROUGH */
case 'I': /* FALLTHROUGH */
case 'L':
/*
* if the second character isn't null, then
* the user has specified the old syntax.
* we move the subargument into our
* mod'd argument list.
*/
if (av[i][2] != NULL) {
/* first clean things up: */
mav[mac][2] = NULL;
/* now add the separation: */
++mac; /* inc to next mod'd arg */
if ((mav[mac] = strdup(&av[i][2])) ==
NULL) {
perror(gettext("xargs: Memory"
" allocation failure"));
exit(1);
}
break;
}
i++;
mac++;
if (av[i] == NULL) {
mav[mac] = NULL;
return;
}
if ((mav[mac] = strdup(av[i])) == NULL) {
perror(gettext("xargs: Memory"
" allocation failure"));
exit(1);
}
break;
/* flags */
case 'p' :
case 't' :
case 'x' :
break;
case '-' :
default:
/*
* here we've hit the cmd argument. so
* we'll stop special processing, as the
* cmd may have a "-i" etc., argument,
* and we don't want to add a "" to it.
*/
cflag = 1;
break;
}
} else if (i > 0) { /* if we're not the 1st arg */
/*
* if it's not a flag, then it *must* be the cmd.
* set cflag, so we don't mishandle the -[eil] flags.
*/
cflag = 1;
}
}
mav[mac] = NULL;
}
/*
* saveinput(): pick up any pending input, so it can be processed later.
*
* description:
* the purpose of this routine is to allow us to handle the user
* typing in a 'y' or 'n', when there's existing characters already
* in stdin. this happens when one gives the "-n" option along with
* "-p". the problem occurs when the user first types in more arguments
* than specified by the -n number. echoargs() wants to read stdin
* in order to get the user's response, but if there's already stuff
* there, echoargs() won't read the proper character.
*
* the solution provided by this routine is to pick up all characters
* (if any), and store them for later processing.
*/
void
saveinput()
{
char *buffer; /* ptr to the floating data buffer */
struct strpeek speek; /* to see what's on the queue */
struct strpeek *ps;
/* if we're not in -p mode, skip */
if (PROMPT == -1) {
return;
}
/* now see if there's any activity pending: */
ps = &speek;
ps->ctlbuf.maxlen = 0;
ps->ctlbuf.len = 0;
ps->ctlbuf.buf = NULL;
ps->flags = 0;
ps->databuf.maxlen = MAX_INPUT;
ps->databuf.len = 0;
if ((buffer = malloc((size_t)MAX_INPUT)) == NULL) {
perror(gettext("xargs: Memory allocation failure"));
exit(1);
}
ps->databuf.buf = (char *)buffer;
if (ioctl(PROMPT, I_PEEK, ps) == -1) {
perror(gettext("xargs: I_PEEK failure"));
exit(1);
}
if (ps->databuf.len > 0) {
int len;
if ((len = read(PROMPT, buffer, ps->databuf.len)) == -1) {
perror(gettext("xargs: read failure"));
exit(1);
}
queue(buffer, len, TAIL);
}
}