--- a/usr/src/cmd/xargs/xargs.c Fri Aug 23 15:33:55 2013 -0400
+++ b/usr/src/cmd/xargs/xargs.c Tue Aug 27 13:00:09 2013 -0700
@@ -19,6 +19,16 @@
* CDDL HEADER END
*/
/*
+ * Copyright 2012 DEY Storage Systems, Inc. All rights reserved.
+ *
+ * Portions of this file developed by DEY Storage Systems, Inc. are licensed
+ * under the terms of the Common Development and Distribution License (CDDL)
+ * version 1.0 only. The use of subsequent versions of the License are
+ * is specifically prohibited unless those terms are not in conflict with
+ * version 1.0 of the License. You can find this license on-line at
+ * http://www.illumos.org/license/CDDL
+ */
+/*
* Copyright 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
@@ -27,8 +37,6 @@
/* All Rights Reserved */
-#pragma ident "%Z%%M% %I% %E% SMI"
-
#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
@@ -62,11 +70,32 @@
#define QBUF_STARTLEN 255 /* start size of growable string buffer */
#define QBUF_INC 100 /* how much to grow a growable string by */
+/* We use these macros to help make formatting look "consistent" */
+#define EMSG(s) ermsg(gettext(s "\n"))
+#define EMSG2(s, a) ermsg(gettext(s "\n"), a)
+#define PERR(s) perror(gettext("xargs: " s))
+
+/* Some common error messages */
+
+#define LIST2LONG "Argument list too long"
+#define ARG2LONG "A single argument was greater than %d bytes"
+#define MALLOCFAIL "Memory allocation failure"
+#define CORRUPTFILE "Corrupt input file"
+#define WAITFAIL "Wait failure"
+#define CHILDSIG "Child killed with signal %d"
+#define CHILDFAIL "Command could not continue processing data"
+#define FORKFAIL "Could not fork child"
+#define EXECFAIL "Could not exec command"
+#define MISSQUOTE "Missing quote"
+#define BADESCAPE "Incomplete escape"
+#define IBUFOVERFLOW "Insert buffer overflow"
+
+#define _(x) gettext(x)
+
static wctype_t blank;
static char *arglist[MAXARGS+1];
-static char argbuf[BUFSIZE+1];
-static char *next = argbuf;
-static char *lastarg = "";
+static char argbuf[BUFSIZE * 2 + 1];
+static char lastarg[BUFSIZE + 1];
static char **ARGV = arglist;
static char *LEOF = "_";
static char *INSPAT = INSPAT_STR;
@@ -78,7 +107,6 @@
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;
@@ -92,28 +120,13 @@
static int LEGAL = FALSE;
static int TRACE = FALSE;
static int INSERT = FALSE;
+static int ZERO = 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] "\
@@ -121,21 +134,16 @@
"[cmd [args ...]]\n"
static int echoargs();
-static int getchr(void);
-static wchar_t getwchr(void);
-static void ungetwchr(wchar_t);
+static wint_t getwchr(char *, size_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 void store_str(char **, char *, size_t);
+static char *getarg(char *);
static char *insert(char *pattern, char *subst);
static void usage();
static void parseargs();
-static void saveinput();
int
main(int argc, char **argv)
@@ -144,8 +152,9 @@
struct inserts *psave;
int c;
int initsize;
- char *cmdname, *initbuf, **initlist;
-
+ char *cmdname, **initlist;
+ char *arg;
+ char *next;
/* initialization */
blank = wctype("blank");
@@ -157,22 +166,26 @@
#endif
(void) textdomain(TEXT_DOMAIN);
if (init_yes() < 0) {
- ermsg(gettext(ERR_MSG_INIT_YES), strerror(errno));
+ ermsg(_(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) {
+ while ((c = getopt(mac, mav, "0tpe:E:I:i:L:l:n:s:x")) != EOF) {
switch (c) {
+ case '0':
+ ZERO = TRUE;
+ break;
+
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"));
+ PERR("can't read from tty for -p");
} else {
TRACE = TRUE;
}
@@ -202,8 +215,8 @@
N_ARGS = 0;
INSPAT = optarg;
if (*optarg == '\0') {
- ermsg(gettext(
- "Option requires an argument: -%c\n"), c);
+ ermsg(_("Option requires an argument: -%c\n"),
+ c);
}
break;
@@ -245,8 +258,8 @@
N_ARGS = 0;
INSERT = FALSE;
if ((PER_LINE = atoi(optarg)) <= 0) {
- ermsg(gettext("#lines must be positive "
- "int: %s\n"), optarg);
+ ermsg(_("#lines must be positive int: %s\n"),
+ optarg);
}
break;
@@ -275,8 +288,8 @@
* number *is* required here:
*/
if ((N_ARGS = atoi(optarg)) <= 0) {
- ermsg(gettext("#args must be positive "
- "int: %s\n"), optarg);
+ ermsg(_("#args must be positive int: %s\n"),
+ optarg);
} else {
LEGAL = DASHX || N_ARGS == 1;
INSERT = PER_LINE = FALSE;
@@ -286,9 +299,8 @@
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);
+ ermsg(_("0 < max-cmd-line-size <= %d: %s\n"),
+ BUFSIZE, optarg);
}
break;
@@ -300,9 +312,7 @@
/*
* bad argument. complain and get ready to die.
*/
- ERR = TRUE;
usage();
-
exit(2);
break;
}
@@ -313,7 +323,6 @@
* we exit early.
*/
if (OK == FALSE) {
- ERR = TRUE;
usage();
exit(2);
}
@@ -346,9 +355,9 @@
* work to do:
*/
if (INSERT && ! ERR) {
- if (xindex(*mav, INSPAT) != -1) {
+ if (strstr(*mav, INSPAT) != NULL) {
if (++n_inserts > MAXINSERTS) {
- ermsg(gettext("too many args "
+ ermsg(_("too many args "
"with %s\n"), INSPAT);
ERR = TRUE;
}
@@ -362,39 +371,77 @@
/* pick up args from standard input */
- initbuf = next;
initlist = ARGV;
initsize = linesize;
+ lastarg[0] = '\0';
- while (OK && MORE) {
+ while (OK) {
N_args = 0;
N_lines = 0;
- next = initbuf;
ARGV = initlist;
linesize = initsize;
- if (*lastarg) {
- *ARGV++ = addarg(lastarg);
- lastarg = "";
- }
+ next = argbuf;
+
+ while (MORE || (lastarg[0] != '\0')) {
+ int l;
+
+ if (*lastarg != '\0') {
+ arg = strcpy(next, lastarg);
+ *lastarg = '\0';
+ } else if ((arg = getarg(next)) == NULL) {
+ break;
+ }
+
+ l = strlen(arg) + 1;
+ linesize += l;
+ next += l;
- while (((*ARGV++ = getarg()) != NULL) && OK) {
+ /* Inserts are handled specially later. */
+ if ((n_inserts == 0) && (linesize >= BUFLIM)) {
+ /*
+ * Legal indicates hard fail if the list is
+ * truncated due to size. So fail, or if we
+ * cannot create any list because it would be
+ * too big.
+ */
+ if (LEGAL || N_args == 0) {
+ EMSG(LIST2LONG);
+ exit(2);
+ /* NOTREACHED */
+ }
+
+ /*
+ * Otherwise just save argument for later.
+ */
+ (void) strcpy(lastarg, arg);
+ break;
+ }
+
+ *ARGV++ = arg;
+
+ N_args++;
+
+ if ((PER_LINE && N_lines >= PER_LINE) ||
+ (N_ARGS && (N_args) >= N_ARGS)) {
+ break;
+ }
+
+
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 */
+
+ *ARGV = NULL;
+ if (N_args == 0) {
+ /* Reached the end with no more work. */
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;
@@ -404,31 +451,22 @@
break;
}
}
- *ARGV = 0;
+ *ARGV = NULL;
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: */
+ linesize = 0;
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;
- }
- }
+ linesize += strlen(*ARGV) + 1;
}
- n_inserts = t_ninserts;
+ if (linesize >= BUFLIM) {
+ EMSG(LIST2LONG);
+ exit(2);
+ /* NOTREACHED */
+ }
}
/* exec command */
@@ -446,334 +484,161 @@
* so if we have a non-zero status here,
* quit immediately.
*/
- if ((exitstat |= lcall(cmdname, arglist)) == 0)
- continue;
+ exitstat |= lcall(cmdname, arglist);
}
}
}
- (void) lseek(0, file_offset, SEEK_SET);
- if (OK) {
+ 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);
+ /*
+ * if exitstat was set, to match XCU4 complience,
+ * return that value, otherwise, return 1.
+ */
+ return (exitstat ? exitstat : 1);
}
static char *
addarg(char *arg)
{
- if (checklen(arg) != 0) {
- (void) strcpy(next, arg);
- arg = next;
- next += strlen(arg) + 1;
- return (arg);
- }
- return ((char *)0);
+ linesize += (strlen(arg) + 1);
+ return (arg);
}
-/*
- * 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;
- }
+static void
+store_str(char **buffer, char *str, size_t len)
+{
+ (void) memcpy(*buffer, str, len);
+ (*buffer)[len] = '\0';
+ *buffer += len;
+}
- /* return new value for offset */
- return (offset + bytes);
-}
static char *
-getarg()
+getarg(char *arg)
{
- int bytes;
+ char *xarg = arg;
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);
+ size_t len;
+ int escape = 0;
+ int inquote = 0;
- /*
- * 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);
+ arg[0] = '\0';
+
+ while (MORE) {
- /* 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;
+ len = 0;
+ c = getwchr(mbc, &len);
+
+ if (((arg - xarg) + len) > BUFLIM) {
+ EMSG2(ARG2LONG, BUFLIM);
+ exit(2);
+ ERR = TRUE;
return (NULL);
}
-
- if (iswctype(c, blank) && inquote == 0) {
- if (INSERT) {
- if (bytes == -1) {
- *next++ = (char)c;
- } else {
- (void) wctomb(next, c);
- next += bytes;
- }
+ switch (c) {
+ case '\n':
+ if (ZERO) {
+ store_str(&arg, mbc, len);
continue;
}
+ /* FALLTHRU */
- /* skip over trailing whitespace till next arg */
- while (iswctype((c = getwchr()), blank) &&
- (c != '\n') && (c != '\0'))
- ;
+ case '\0':
+ case WEOF: /* Note WEOF == EOF */
- /*
- * 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' ';
+ if (escape) {
+ EMSG(BADESCAPE);
+ ERR = TRUE;
+ return (NULL);
}
- goto end_arg;
- }
- switch (c) {
- case L'\0':
- case L'\n':
if (inquote) {
- *next++ = '\0';
- ermsg(gettext("Missing quote: %s\n"), arg);
+ EMSG(MISSQUOTE);
ERR = TRUE;
- free(requeue_buf);
- return (0);
+ return (NULL);
}
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);
- }
+ break;
case '"':
- if (inquote == 1) /* in single quoted string */
- goto is_default;
- if (inquote == 2) /* terminating double quote */
+ if (ZERO || escape || (inquote == 1)) {
+ /* treat it literally */
+ escape = 0;
+ store_str(&arg, mbc, len);
+
+ } else if (inquote == 2) {
+ /* terminating double quote */
inquote = 0;
- else /* starting quoted string */
+
+ } else {
+ /* starting quoted string */
inquote = 2;
- break;
+ }
+ continue;
case '\'':
- if (inquote == 2) /* in double quoted string */
- goto is_default;
- if (inquote == 1) /* terminating single quote */
+ if (ZERO || escape || (inquote == 2)) {
+ /* treat it literally */
+ escape = 0;
+ store_str(&arg, mbc, len);
+
+ } else if (inquote == 1) {
+ /* terminating single quote */
inquote = 0;
- else /* starting quoted string */
+
+ } else {
+ /* starting quoted string */
inquote = 1;
- break;
+ }
+ continue;
- case L'\\':
+ case '\\':
/*
* 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);
+ if (ZERO || inquote || escape) {
+ escape = 0;
+ store_str(&arg, mbc, len);
+ } else {
+ escape = 1;
}
+ continue;
default:
-is_default: if (bytes == -1) {
- *next++ = (char)c;
- } else {
- (void) wctomb(next, c);
- next += bytes;
+ /* most times we will just want to store it */
+ if (inquote || escape || ZERO || !iswctype(c, blank)) {
+ escape = 0;
+ store_str(&arg, mbc, len);
+ continue;
}
+ /* unquoted blank */
break;
}
+
+ /*
+ * At this point we are processing a complete argument.
+ */
+ if (strcmp(xarg, LEOF) == 0 && *LEOF != '\0') {
+ MORE = FALSE;
+ return (NULL);
+ }
+ if (c == WEOF) {
+ MORE = FALSE;
+ }
+ if (xarg[0] == '\0')
+ continue;
+ break;
}
+
+ return (xarg[0] == '\0' ? NULL : xarg);
}
-
/*
* ermsg(): print out an error message, and indicate failure globally.
*
@@ -825,15 +690,6 @@
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++) {
@@ -873,7 +729,7 @@
bufend = &buffer[MAXSBUF];
while (*++pat) {
- if (xindex(pat, INSPAT) == 0) {
+ if (strncmp(pat, INSPAT, ipatlen) == 0) {
if (pbuf + len >= bufend) {
break;
} else {
@@ -895,7 +751,7 @@
ermsg(gettext("Maximum argument size with insertion via %s's "
"exceeded\n"), INSPAT);
ERR = TRUE;
- return (0);
+ return (NULL);
}
}
@@ -908,96 +764,62 @@
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;
+ l = strlen(newarg) + 1;
+ if ((ibufsize += l) > MAXIBUF) {
+ EMSG(IBUFOVERFLOW);
+ ERR = TRUE;
}
+ (void) strcpy(p_ibuf, newarg);
+ *(p->p_ARGV) = p_ibuf;
+ p_ibuf += l;
}
/*
- * getchr(): get the next character.
+ * getwchr(): get the next wide 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.
+ * we get the next character from stdin. This returns WEOF if no
+ * character is present. If ZERO is set, it gets a single byte instead
+ * a wide character.
*/
-static int
-getchr(void)
+static wint_t
+getwchr(char *mbc, size_t *sz)
{
- char c;
+ size_t i;
+ int c;
+ wchar_t wch;
- do {
- if (queued_data == NULL) {
- char *buffer;
- int len;
+ i = 0;
+ while (i < MB_CUR_MAX) {
- if ((buffer = malloc(BUFSIZE)) == NULL) {
- perror(gettext(
- "xargs: Memory allocation failure"));
- exit(1);
- }
+ if ((c = fgetc(stdin)) == EOF) {
- if ((len = read(0, buffer, BUFSIZE)) == 0)
- return (0);
- if (len == -1) {
- perror(gettext("xargs: Read failure"));
- exit(1);
+ if (i == 0) {
+ /* TRUE EOF has been reached */
+ return (WEOF);
}
- 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;
}
+ mbc[i++] = (char)c;
/* If this succeeds then we are done */
- if (mbtowc(&wch, (char *)buffer, i) != -1)
- return (wch);
+ if (ZERO) {
+ *sz = i;
+ return ((char)c);
+ }
+ if (mbtowc(&wch, mbc, i) != -1) {
+ *sz = i;
+ return ((wint_t)wch);
+ }
}
/*
@@ -1009,67 +831,50 @@
* generated in another locale?
*/
errno = EILSEQ;
- perror(gettext("xargs: Corrupt input file"));
+ PERR(CORRUPTFILE);
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 (; ; ) {
+ for (;;) {
switch (child = fork()) {
default:
while ((iwait = wait(&retcode)) != child &&
iwait != (pid_t)-1)
;
if (iwait == (pid_t)-1) {
- perror(gettext("xargs: Wait failure"));
+ PERR(WAITFAIL);
exit(122);
/* NOTREACHED */
}
if (WIFSIGNALED(retcode)) {
- ermsg(gettext("Child killed with signal %d\n"),
- WTERMSIG(retcode));
+ EMSG2(CHILDSIG, WTERMSIG(retcode));
exit(125);
/* NOTREACHED */
}
if ((WEXITSTATUS(retcode) & 0377) == 0377) {
- ermsg(gettext("Command could not continue "
- "processing data\n"));
+ EMSG(CHILDFAIL);
exit(124);
/* NOTREACHED */
}
return (WEXITSTATUS(retcode));
case 0:
(void) execvp(sub, subargs);
- perror(gettext("xargs: Could not exec command"));
+ PERR(EXECFAIL);
if (errno == EACCES)
exit(126);
exit(127);
/* NOTREACHED */
case -1:
if (errno != EAGAIN && retry++ < FORK_RETRY) {
- perror(gettext("xargs: Could not fork child"));
+ PERR(FORKFAIL);
exit(123);
}
(void) sleep(1);
@@ -1078,41 +883,10 @@
}
-/*
- * 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));
+ ermsg(_(USAGEMSG));
OK = FALSE;
}
@@ -1142,14 +916,14 @@
int cflag; /* 0 = not processing cmd arg */
if ((mav = malloc((ac * 2 + 1) * sizeof (char *))) == NULL) {
- perror(gettext("xargs: Memory allocation failure"));
+ PERR(MALLOCFAIL);
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"));
+ PERR(MALLOCFAIL);
exit(1);
}
@@ -1187,8 +961,7 @@
mav[++mac] = strdup(&av[i][2]);
}
if (mav[mac] == NULL) {
- perror(gettext("xargs: Memory"
- " allocation failure"));
+ PERR(MALLOCFAIL);
exit(1);
}
break;
@@ -1225,8 +998,7 @@
++mac; /* inc to next mod'd arg */
if ((mav[mac] = strdup(&av[i][2])) ==
NULL) {
- perror(gettext("xargs: Memory"
- " allocation failure"));
+ PERR(MALLOCFAIL);
exit(1);
}
break;
@@ -1239,8 +1011,7 @@
return;
}
if ((mav[mac] = strdup(av[i])) == NULL) {
- perror(gettext("xargs: Memory"
- " allocation failure"));
+ PERR(MALLOCFAIL);
exit(1);
}
break;
@@ -1273,63 +1044,3 @@
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);
- }
-}