From 18d82938b5ff9a23a7efbf83ae8a11128627503e Mon Sep 17 00:00:00 2001 From: obrien Date: Fri, 2 Nov 2001 21:44:42 +0000 Subject: We use the stock 3.1.0 file. --- contrib/awk/io.c | 1303 +++++++++++++++++++++++++++++++++++------------------- 1 file changed, 859 insertions(+), 444 deletions(-) (limited to 'contrib/awk') diff --git a/contrib/awk/io.c b/contrib/awk/io.c index a83fc9d..8d741e2 100644 --- a/contrib/awk/io.c +++ b/contrib/awk/io.c @@ -3,7 +3,7 @@ */ /* - * Copyright (C) 1976, 1988, 1989, 1991-2000 the Free Software Foundation, Inc. + * Copyright (C) 1976, 1988, 1989, 1991-2001 the Free Software Foundation, Inc. * * This file is part of GAWK, the GNU implementation of the * AWK Programming Language. @@ -26,7 +26,6 @@ */ #include "awk.h" -#undef HAVE_MMAP /* for now, probably forever */ #ifdef HAVE_SYS_PARAM_H #undef RE_DUP_MAX /* avoid spurious conflict w/regex.h */ @@ -37,13 +36,6 @@ #include #endif /* HAVE_SYS_WAIT_H */ -#ifdef HAVE_MMAP -#include -#ifndef MAP_FAILED -#define MAP_FAILED ((caddr_t) -1) -#endif /* ! defined (MAP_FAILED) */ -#endif /* HAVE_MMAP */ - #ifndef O_RDONLY #include #endif @@ -51,32 +43,65 @@ #define O_ACCMODE (O_RDONLY|O_WRONLY|O_RDWR) #endif +#ifdef HAVE_SOCKETS +#ifdef HAVE_SYS_SOCKET_H +#include +#else +#include +#endif /* HAVE_SYS_SOCKET_H */ +#ifdef HAVE_NETINET_IN_H +#include +#else +#include +#endif /* HAVE_NETINET_IN_H */ +#ifdef HAVE_NETDB_H +#include +#endif /* HAVE_NETDB_H */ +#endif /* HAVE_SOCKETS */ + #if ! defined(S_ISREG) && defined(S_IFREG) #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG) #endif -#if ! defined(S_ISDIR) && defined(S_IFDIR) -#define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR) -#endif - #ifndef ENFILE #define ENFILE EMFILE #endif +extern int MRL; + +#ifdef HAVE_SOCKETS +enum inet_prot { INET_NONE, INET_TCP, INET_UDP, INET_RAW }; + +#ifndef SHUT_RD +#define SHUT_RD 0 +#endif + +#ifndef SHUT_WR +#define SHUT_WR 1 +#endif + +#ifndef SHUT_RDWR +#define SHUT_RDWR 2 +#endif + +#endif /* HAVE_SOCKETS */ + #ifdef atarist #include #endif -#if defined(MSDOS) || defined(OS2) || defined(WIN32) +#if defined(MSDOS) || defined(OS2) || defined(WIN32) || defined(TANDEM) #define PIPES_SIMULATED #endif +typedef enum { CLOSE_ALL, CLOSE_TO, CLOSE_FROM } two_way_close_type; + static IOBUF *nextfile P((int skipping)); static int inrec P((IOBUF *iop)); static int iop_close P((IOBUF *iop)); struct redirect *redirect P((NODE *tree, int *errflg)); static void close_one P((void)); -static int close_redir P((struct redirect *rp, int exitwarn)); +static int close_redir P((struct redirect *rp, int exitwarn, two_way_close_type how)); #ifndef PIPES_SIMULATED static int wait_any P((int interesting)); #endif @@ -86,16 +111,14 @@ static IOBUF *iop_alloc P((int fd, const char *name, IOBUF *buf)); static int gawk_pclose P((struct redirect *rp)); static int do_pathopen P((const char *file)); static int get_a_record P((char **out, IOBUF *iop, int rs, Regexp *RSre, int *errcode)); -#ifdef HAVE_MMAP -static int mmap_get_record P((char **out, IOBUF *iop, int rs, Regexp *RSre, int *errcode)); -#endif /* HAVE_MMAP */ static int str2mode P((const char *mode)); static void spec_setup P((IOBUF *iop, int len, int allocate)); static int specfdopen P((IOBUF *iop, const char *name, const char *mode)); static int pidopen P((IOBUF *iop, const char *name, const char *mode)); static int useropen P((IOBUF *iop, const char *name, const char *mode)); +static int two_way_open P((char *str, struct redirect *rp)); -#if defined (HAVE_POPEN_H) +#if defined(HAVE_POPEN_H) #include "popen.h" #endif @@ -114,6 +137,27 @@ extern NODE **fields_arr; static jmp_buf filebuf; /* for do_nextfile() */ +#if defined(MSDOS) || defined(OS2) +static const char * +binmode(char *mode) +{ + switch (mode[0]) { + case 'r': + if ((BINMODE & 1) != 0) + mode = "rb"; + break; + case 'w': + case 'a': + if ((BINMODE & 2) != 0) + mode = (mode[0] == 'w' ? "wb" : "ab"); + break; + } + return mode; +} +#else +#define binmode(mode) (mode) +#endif + #ifdef VMS /* File pointers have an extra level of indirection, and there are cases where `stdin' can be null. That can crash gawk if fileno() is used as-is. */ @@ -135,8 +179,7 @@ do_nextfile() /* nextfile --- move to the next input data file */ static IOBUF * -nextfile(skipping) -int skipping; +nextfile(int skipping) { static long i = 1; static int files = 0; @@ -159,7 +202,7 @@ int skipping; return curfile; } for (; i < (long) (ARGC_node->lnode->numbr); i++) { - arg = *assoc_lookup(ARGV_node, tmp_number((AWKNUM) i)); + arg = *assoc_lookup(ARGV_node, tmp_number((AWKNUM) i), FALSE); if (arg->stlen == 0) continue; arg->stptr[arg->stlen] = '\0'; @@ -170,7 +213,7 @@ int skipping; if (! arg_assign(arg->stptr)) { files++; fname = arg->stptr; - curfile = iop_open(fname, "r", &mybuf); + curfile = iop_open(fname, binmode("r"), &mybuf); if (curfile == NULL) goto give_up; curfile->flag |= IOP_NOFREE_OBJ; @@ -188,7 +231,7 @@ int skipping; /* FNR is init'ed to 0 */ FILENAME_node->var_value = make_string("-", 1); fname = "-"; - curfile = iop_open(fname, "r", &mybuf); + curfile = iop_open(fname, binmode("r"), &mybuf); if (curfile == NULL) goto give_up; curfile->flag |= IOP_NOFREE_OBJ; @@ -196,7 +239,7 @@ int skipping; return curfile; give_up: - fatal("cannot open file `%s' for reading (%s)", + fatal(_("cannot open file `%s' for reading (%s)"), fname, strerror(errno)); /* NOTREACHED */ return 0; @@ -221,16 +264,14 @@ set_NR() /* inrec --- This reads in a record from the input file */ static int -inrec(iop) -IOBUF *iop; +inrec(IOBUF *iop) { char *begin; register int cnt; int retval = 0; if ((cnt = iop->cnt) != EOF) - cnt = (*(iop->getrec)) - (&begin, iop, RS->stptr[0], RS_regexp, NULL); + cnt = get_a_record(&begin, iop, RS->stptr[0], RS_regexp, NULL); if (cnt == EOF) { cnt = 0; retval = 1; @@ -246,8 +287,7 @@ IOBUF *iop; /* iop_close --- close an open IOP */ static int -iop_close(iop) -IOBUF *iop; +iop_close(IOBUF *iop) { int ret; @@ -273,14 +313,13 @@ IOBUF *iop; /* Don't close standard files or else crufty code elsewhere will lose */ if (iop->fd == fileno(stdin) || iop->fd == fileno(stdout) - || iop->fd == fileno(stderr) - || (iop->flag & IOP_MMAPPED) != 0) + || iop->fd == fileno(stderr)) ret = 0; else ret = close(iop->fd); if (ret == -1) - warning("close of fd %d (`%s') failed (%s)", iop->fd, + warning(_("close of fd %d (`%s') failed (%s)"), iop->fd, iop->name, strerror(errno)); if ((iop->flag & IOP_NO_FREE) == 0) { /* @@ -299,12 +338,7 @@ IOBUF *iop; fields_arr[0] = t; reset_record(); } - if ((iop->flag & IOP_MMAPPED) == 0) - free(iop->buf); -#ifdef HAVE_MMAP - else - (void) munmap(iop->buf, iop->size); -#endif + free(iop->buf); } if ((iop->flag & IOP_NOFREE_OBJ) == 0) free((char *) iop); @@ -326,21 +360,37 @@ do_input() if (inrec(iop) == 0) while (interpret(expression_value) && inrec(iop) == 0) continue; -#ifdef C_ALLOCA - /* recover any space from C based alloca */ - (void) alloca(0); -#endif if (exiting) break; } } +/* redflags2str --- turn redirection flags into a string, for debugging */ + +char * +redflags2str(int flags) +{ + static struct flagtab redtab[] = { + { RED_FILE, "RED_FILE" }, + { RED_PIPE, "RED_PIPE" }, + { RED_READ, "RED_READ" }, + { RED_WRITE, "RED_WRITE" }, + { RED_APPEND, "RED_APPEND" }, + { RED_NOBUF, "RED_NOBUF" }, + { RED_EOF, "RED_EOF" }, + { RED_TWOWAY, "RED_TWOWAY" }, + { RED_SOCKET, "RED_SOCKET" }, + { RED_TCP, "RED_TCP" }, + { 0, NULL } + }; + + return genflags2str(flags, redtab); +} + /* redirect --- Redirection for printf and print commands */ struct redirect * -redirect(tree, errflg) -NODE *tree; -int *errflg; +redirect(NODE *tree, int *errflg) { register NODE *tmp; register struct redirect *rp; @@ -376,31 +426,57 @@ int *errflg; tflag = (RED_FILE|RED_READ); what = "<"; break; + case Node_redirect_twoway: + tflag = (RED_READ|RED_WRITE|RED_TWOWAY); + what = "|&"; + break; default: - fatal("invalid tree type %d in redirect()", tree->type); + fatal(_("invalid tree type %s in redirect()"), + nodetype2str(tree->type)); break; } tmp = tree_eval(tree->subnode); if (do_lint && (tmp->flags & STR) == 0) - warning("expression in `%s' redirection only has numeric value", + lintwarn(_("expression in `%s' redirection only has numeric value"), what); tmp = force_string(tmp); str = tmp->stptr; if (str == NULL || *str == '\0') - fatal("expression for `%s' redirection has null string value", + fatal(_("expression for `%s' redirection has null string value"), what); if (do_lint && (STREQN(str, "0", tmp->stlen) || STREQN(str, "1", tmp->stlen))) - warning("filename `%s' for `%s' redirection may be result of logical expression", str, what); - for (rp = red_head; rp != NULL; rp = rp->next) + lintwarn(_("filename `%s' for `%s' redirection may be result of logical expression"), str, what); + +#ifdef HAVE_SOCKETS + if (STREQN(str, "/inet/", 6)) { + tflag |= RED_SOCKET; + if (STREQN(str + 6, "tcp/", 4)) + tflag |= RED_TCP; /* use shutdown when closing */ + } +#endif /* HAVE_SOCKETS */ + + for (rp = red_head; rp != NULL; rp = rp->next) { if (strlen(rp->value) == tmp->stlen && STREQN(rp->value, str, tmp->stlen) && ((rp->flag & ~(RED_NOBUF|RED_EOF)) == tflag || (outflag != 0 - && (rp->flag & (RED_FILE|RED_WRITE)) == outflag))) + && (rp->flag & (RED_FILE|RED_WRITE)) == outflag))) { + + int rpflag = (rp->flag & ~(RED_NOBUF|RED_EOF)); + int newflag = (tflag & ~(RED_NOBUF|RED_EOF)); + + if (do_lint && rpflag != newflag) + lintwarn( + _("unnecessary mixing of `>' and `>>' for file `%.*s'"), + tmp->stlen, rp->value); + break; + } + } + if (rp == NULL) { emalloc(rp, struct redirect *, sizeof(struct redirect), "redirect"); @@ -421,6 +497,7 @@ int *errflg; red_head = rp; } else str = rp->value; /* get \0 terminated string */ + while (rp->fp == NULL && rp->iop == NULL) { if (rp->flag & RED_EOF) /* @@ -432,31 +509,48 @@ int *errflg; errno = 0; switch (tree->type) { case Node_redirect_output: - mode = "w"; + mode = binmode("w"); if ((rp->flag & RED_USED) != 0) - mode = "a"; + mode = (rp->mode[1] == 'b') ? "ab" : "a"; break; case Node_redirect_append: - mode = "a"; + mode = binmode("a"); break; case Node_redirect_pipe: /* synchronize output before new pipe */ (void) flush_io(); - if ((rp->fp = popen(str, "w")) == NULL) - fatal("can't open pipe (\"%s\") for output (%s)", + os_restore_mode(fileno(stdin)); + if ((rp->fp = popen(str, binmode("w"))) == NULL) + fatal(_("can't open pipe `%s' for output (%s)"), str, strerror(errno)); + /* set close-on-exec */ + os_close_on_exec(fileno(rp->fp), str, "pipe", "to"); rp->flag |= RED_NOBUF; break; case Node_redirect_pipein: direction = "from"; if (gawk_popen(str, rp) == NULL) - fatal("can't open pipe (\"%s\") for input (%s)", + fatal(_("can't open pipe `%s' for input (%s)"), str, strerror(errno)); break; case Node_redirect_input: direction = "from"; - rp->iop = iop_open(str, "r", NULL); + rp->iop = iop_open(str, binmode("r"), NULL); + break; + case Node_redirect_twoway: + direction = "to/from"; + if (!two_way_open(str, rp)) { +#ifdef HAVE_SOCKETS + /* multiple messages make life easier for translators */ + if (STREQN(str, "/inet/", 6)) + fatal(_("can't open two way socket `%s' for input/output (%s)"), + str, strerror(errno)); + else +#endif + fatal(_("can't open two way pipe `%s' for input/output (%s)"), + str, strerror(errno)); + } break; default: cant_happen(); @@ -472,7 +566,16 @@ int *errflg; else if (fd == fileno(stderr)) rp->fp = stderr; else { - rp->fp = fdopen(fd, (char *) mode); +#if defined(F_GETFL) && defined(O_APPEND) + int fd_flags; + + fd_flags = fcntl(fd, F_GETFL); + if (fd_flags != -1 && (fd_flags & O_APPEND) == O_APPEND) + rp->fp = fdopen(fd, binmode("a")); + else +#endif + rp->fp = fdopen(fd, (char *) mode); + rp->mode = (char *) mode; /* don't leak file descriptors */ if (rp->fp == NULL) close(fd); @@ -494,9 +597,7 @@ int *errflg; /* too many files open -- close one and try again */ if (errno == EMFILE || errno == ENFILE) close_one(); -#if defined __MINGW32__ || defined HAVE_MMAP - /* this works for solaris 2.5, not sunos */ - /* it is also needed for MINGW32 */ +#if defined __MINGW32__ || defined solaris else if (errno == 0) /* HACK! */ close_one(); #endif @@ -520,10 +621,15 @@ int *errflg; if (errflg != NULL) *errflg = errno; if (tree->type == Node_redirect_output - || tree->type == Node_redirect_append) - fatal("can't redirect %s `%s' (%s)", - direction, str, strerror(errno)); - else { + || tree->type == Node_redirect_append) { + /* multiple messages make life easier for translators */ + if (*direction == 'f') + fatal(_("can't redirect from `%s' (%s)"), + str, strerror(errno)); + else + fatal(_("can't redirect to `%s' (%s)"), + str, strerror(errno)); + } else { free_temp(tmp); return NULL; } @@ -537,9 +643,7 @@ int *errflg; /* getredirect --- find the struct redirect for this file or pipe */ struct redirect * -getredirect(str, len) -char *str; -int len; +getredirect(char *str, int len) { struct redirect *rp; @@ -558,6 +662,13 @@ close_one() register struct redirect *rp; register struct redirect *rplast = NULL; + static short warned = FALSE; + + if (do_lint && ! warned) { + warned = TRUE; + lintwarn(_("reached system limit for open files: starting to multiplex file descriptors")); + } + /* go to end of list first, to pick up least recently used entry */ for (rp = red_head; rp != NULL; rp = rp->next) rplast = rp; @@ -567,26 +678,39 @@ close_one() rp->flag |= RED_USED; errno = 0; if (/* do_lint && */ fclose(rp->fp) != 0) - warning("close of \"%s\" failed (%s).", + warning(_("close of `%s' failed (%s)."), rp->value, strerror(errno)); rp->fp = NULL; break; } if (rp == NULL) /* surely this is the only reason ??? */ - fatal("too many pipes or input files open"); + fatal(_("too many pipes or input files open")); } /* do_close --- completely close an open file or pipe */ NODE * -do_close(tree) -NODE *tree; +do_close(NODE *tree) { - NODE *tmp; + NODE *tmp, *tmp2; register struct redirect *rp; - - tmp = force_string(tree_eval(tree->subnode)); + two_way_close_type how = CLOSE_ALL; /* default */ + + tmp = force_string(tree_eval(tree->lnode)); /* 1st arg: redir to close */ + + if (tree->rnode != NULL) { + /* 2nd arg if present: "to" or "from" for two-way pipe */ + /* DO NOT use _() on the strings here! */ + tmp2 = force_string(tree->rnode->lnode); + if (strcasecmp(tmp2->stptr, "to") == 0) + how = CLOSE_TO; + else if (strcasecmp(tmp2->stptr, "from") == 0) + how = CLOSE_FROM; + else + fatal(_("close: second argument must be `to' or `from'")); + free_temp(tmp2); + } for (rp = red_head; rp != NULL; rp = rp->next) { if (strlen(rp->value) == tmp->stlen @@ -594,22 +718,24 @@ NODE *tree; break; } - if (rp == NULL) { /* no match */ - /* icky special case: close(FILENAME) called. */ - if (tree->subnode == FILENAME_node - || (tmp->stlen == FILENAME_node->var_value->stlen - && STREQN(tmp->stptr, FILENAME_node->var_value->stptr, tmp->stlen))) { - (void) nextfile(TRUE); - } else if (do_lint) - warning("close: `%.*s' is not an open file or pipe", + if (rp == NULL) { /* no match, return -1 */ + char *cp; + + if (do_lint) + lintwarn(_("close: `%.*s' is not an open file, pipe or co-process"), tmp->stlen, tmp->stptr); + /* update ERRNO manually, using errno = ENOENT is a stretch. */ + cp = _("close of redirection that was never opened"); + unref(ERRNO_node->var_value); + ERRNO_node->var_value = make_string(cp, strlen(cp)); + free_temp(tmp); - return tmp_number((AWKNUM) 0.0); + return tmp_number((AWKNUM) -1.0); } free_temp(tmp); fflush(stdout); /* synchronize regular output */ - tmp = tmp_number((AWKNUM) close_redir(rp, FALSE)); + tmp = tmp_number((AWKNUM) close_redir(rp, FALSE, how)); rp = NULL; return tmp; } @@ -617,33 +743,63 @@ NODE *tree; /* close_redir --- close an open file or pipe */ static int -close_redir(rp, exitwarn) -register struct redirect *rp; -int exitwarn; +close_redir(register struct redirect *rp, int exitwarn, two_way_close_type how) { int status = 0; - char *what; if (rp == NULL) return 0; if (rp->fp == stdout || rp->fp == stderr) return 0; + + if (do_lint && (rp->flag & RED_TWOWAY) == 0 && how != CLOSE_ALL) + lintwarn(_("close: redirection `%s' not opened with `|&', second argument ignored"), + rp->value); + errno = 0; - if ((rp->flag & (RED_PIPE|RED_WRITE)) == (RED_PIPE|RED_WRITE)) + if ((rp->flag & RED_TWOWAY) != 0) { /* two-way pipe */ + /* write end: */ + if ((how == CLOSE_ALL || how == CLOSE_TO) && rp->fp != NULL) { +#ifdef HAVE_SOCKETS + if ((rp->flag & RED_TCP) != 0) + (void) shutdown(fileno(rp->fp), SHUT_WR); +#endif /* HAVE_SOCKETS */ + status = fclose(rp->fp); + rp->fp = NULL; + } + + /* read end: */ + if (how == CLOSE_ALL || how == CLOSE_FROM) { + if ((rp->flag & RED_SOCKET) != 0 && rp->iop != NULL) { +#ifdef HAVE_SOCKETS + if ((rp->flag & RED_TCP) != 0) + (void) shutdown(rp->iop->fd, SHUT_RD); +#endif /* HAVE_SOCKETS */ + (void) iop_close(rp->iop); + } else + status = gawk_pclose(rp); + + rp->iop = NULL; + } + } else if ((rp->flag & (RED_PIPE|RED_WRITE)) == (RED_PIPE|RED_WRITE)) { /* write to pipe */ status = pclose(rp->fp); - else if (rp->fp != NULL) + if ((BINMODE & 1) != 0) + os_setbinmode(fileno(stdin), O_BINARY); + + rp->fp = NULL; + } else if (rp->fp != NULL) { /* write to file */ status = fclose(rp->fp); - else if (rp->iop != NULL) { - if ((rp->flag & RED_PIPE) != 0) + rp->fp = NULL; + } else if (rp->iop != NULL) { /* read from pipe/file */ + if ((rp->flag & RED_PIPE) != 0) /* read from pipe */ status = gawk_pclose(rp); - else { + /* gawk_pclose sets rp->iop to null */ + else { /* read from file */ status = iop_close(rp->iop); rp->iop = NULL; } } - what = ((rp->flag & RED_PIPE) != 0) ? "pipe" : "file"; - /* SVR4 awk checks and warns about status of close */ if (status != 0) { char *s = strerror(errno); @@ -652,29 +808,55 @@ int exitwarn; * Too many people have complained about this. * As of 2.15.6, it is now under lint control. */ - if (do_lint) - warning("failure status (%d) on %s close of \"%s\" (%s)", - status, what, rp->value, s); + if (do_lint) { + if ((rp->flag & RED_PIPE) != 0) + lintwarn(_("failure status (%d) on pipe close of `%s' (%s)"), + status, rp->value, s); + else + lintwarn(_("failure status (%d) on file close of `%s' (%s)"), + status, rp->value, s); + } if (! do_traditional) { /* set ERRNO too so that program can get at it */ - unref(ERRNO_node->var_value); - ERRNO_node->var_value = make_string(s, strlen(s)); + update_ERRNO(); } } - if (exitwarn) - warning("no explicit close of %s `%s' provided", - what, rp->value); + if (exitwarn) { + /* + * Don't use lintwarn() here. If lint warnings are fatal, + * doing so prevents us from closing other open redirections. + * + * Using multiple full messages instead of string parameters + * for the types makes message translation easier. + */ + if ((rp->flag & RED_SOCKET) != 0) + warning(_("no explicit close of socket `%s' provided"), + rp->value); + else if ((rp->flag & RED_TWOWAY) != 0) + warning(_("no explicit close of co-process `%s' provided"), + rp->value); + else if ((rp->flag & RED_PIPE) != 0) + warning(_("no explicit close of pipe `%s' provided"), + rp->value); + else + warning(_("no explicit close of file `%s' provided"), + rp->value); + } + + /* remove it from the list if closing both or both ends have been closed */ + if (how == CLOSE_ALL || (rp->iop == NULL && rp->fp == NULL)) { + if (rp->next != NULL) + rp->next->prev = rp->prev; + if (rp->prev != NULL) + rp->prev->next = rp->next; + else + red_head = rp->next; + free(rp->value); + free((char *) rp); + } - if (rp->next != NULL) - rp->next->prev = rp->prev; - if (rp->prev != NULL) - rp->prev->next = rp->next; - else - red_head = rp->next; - free(rp->value); - free((char *) rp); return status; } @@ -688,23 +870,31 @@ flush_io() errno = 0; if (fflush(stdout)) { - warning("error writing standard output (%s)", strerror(errno)); + warning(_("error writing standard output (%s)"), strerror(errno)); status++; } if (fflush(stderr)) { - warning("error writing standard error (%s)", strerror(errno)); + warning(_("error writing standard error (%s)"), strerror(errno)); status++; } for (rp = red_head; rp != NULL; rp = rp->next) /* flush both files and pipes, what the heck */ if ((rp->flag & RED_WRITE) && rp->fp != NULL) { if (fflush(rp->fp)) { - warning("%s flush of \"%s\" failed (%s).", - (rp->flag & RED_PIPE) ? "pipe" : - "file", rp->value, strerror(errno)); + if (rp->flag & RED_PIPE) + warning(_("pipe flush of `%s' failed (%s)."), + rp->value, strerror(errno)); + else if (rp->flag & RED_TWOWAY) + warning(_("co-process flush of pipe to `%s' failed (%s)."), + rp->value, strerror(errno)); + else + warning(_("file flush of `%s' failed (%s)."), + rp->value, strerror(errno)); status++; } } + if (status != 0) + status = -1; /* canonicalize it */ return status; } @@ -724,7 +914,7 @@ close_io() * close_redir() will print a message if needed * if do_lint, warn about lack of explicit close */ - if (close_redir(rp, do_lint)) + if (close_redir(rp, do_lint, CLOSE_ALL)) status++; rp = NULL; } @@ -734,11 +924,11 @@ close_io() * them, we just flush them, and do that across the board. */ if (fflush(stdout)) { - warning("error writing standard output (%s)", strerror(errno)); + warning(_("error writing standard output (%s)"), strerror(errno)); status++; } if (fflush(stderr)) { - warning("error writing standard error (%s)", strerror(errno)); + warning(_("error writing standard error (%s)"), strerror(errno)); status++; } return status; @@ -747,31 +937,167 @@ close_io() /* str2mode --- convert a string mode to an integer mode */ static int -str2mode(mode) -const char *mode; +str2mode(const char *mode) { int ret; + const char *second = & mode[1]; + + if (*second == 'b') + second++; switch(mode[0]) { case 'r': ret = O_RDONLY; + if (*second == '+' || *second == 'w') + ret = O_RDWR; break; case 'w': ret = O_WRONLY|O_CREAT|O_TRUNC; + if (*second == '+' || *second == 'r') + ret = O_RDWR|O_CREAT|O_TRUNC; break; case 'a': ret = O_WRONLY|O_APPEND|O_CREAT; + if (*second == '+') + ret = O_RDWR|O_APPEND|O_CREAT; break; default: ret = 0; /* lint */ cant_happen(); } + if (strchr(mode, 'b') != NULL) + ret |= O_BINARY; return ret; } +#ifdef HAVE_SOCKETS +/* socketopen --- open a socket and set it into connected state */ + +int +socketopen(enum inet_prot type, int localport, int remoteport, char *remotehostname) +{ + struct hostent *hp = gethostbyname(remotehostname); + struct sockaddr_in local_addr, remote_addr; + int socket_fd; + int any_remote_host = strcmp(remotehostname, "0"); + + socket_fd = INVALID_HANDLE; + switch (type) { + case INET_TCP: + if (localport != 0 || remoteport != 0) { + int on = 1; +#ifdef SO_LINGER + struct linger linger; + + memset(& linger, '\0', sizeof(linger)); +#endif + socket_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR, + (char *) & on, sizeof(on)); +#ifdef SO_LINGER + linger.l_onoff = 1; + linger.l_linger = 30; /* linger for 30/100 second */ + setsockopt(socket_fd, SOL_SOCKET, SO_LINGER, + (char *) & linger, sizeof(linger)); +#endif + } + break; + case INET_UDP: + if (localport != 0 || remoteport != 0) + socket_fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); + break; + case INET_RAW: +#ifdef SOCK_RAW + if (localport == 0 && remoteport == 0) + socket_fd = socket(AF_INET, SOCK_RAW, IPPROTO_RAW); +#endif + break; + case INET_NONE: + /* fall through */ + default: + cant_happen(); + break; + } + + if (socket_fd < 0 || socket_fd == INVALID_HANDLE + || (hp == NULL && any_remote_host != 0)) + return INVALID_HANDLE; + + local_addr.sin_family = remote_addr.sin_family = AF_INET; + local_addr.sin_addr.s_addr = htonl(INADDR_ANY); + remote_addr.sin_addr.s_addr = htonl(INADDR_ANY); + local_addr.sin_port = htons(localport); + remote_addr.sin_port = htons(remoteport); + if (bind(socket_fd, (struct sockaddr *) &local_addr, sizeof(local_addr)) == 0) { + if (any_remote_host != 0) { /* not ANY => create a client */ + if (type == INET_TCP || type == INET_UDP) { + memcpy(&remote_addr.sin_addr, hp->h_addr, + sizeof(remote_addr.sin_addr)); + if (connect(socket_fd, + (struct sockaddr *) &remote_addr, + sizeof(remote_addr)) != 0) { + close(socket_fd); + if (localport == 0) + socket_fd = INVALID_HANDLE; + else + socket_fd = socketopen(type, localport, 0, "0"); + } + } else { + /* /inet/raw client not ready yet */ + fatal(_("/inet/raw client not ready yet, sorry")); + if (geteuid() != 0) + fatal(_("only root may use `/inet/raw'.")); + } + } else { /* remote host is ANY => create a server */ + if (type == INET_TCP) { + int clientsocket_fd = INVALID_HANDLE; + int namelen = sizeof(remote_addr); + + if (listen(socket_fd, 1) >= 0 + && (clientsocket_fd = accept(socket_fd, + (struct sockaddr *) &remote_addr, + &namelen)) >= 0) { + close(socket_fd); + socket_fd = clientsocket_fd; + } else { + close(socket_fd); + socket_fd = INVALID_HANDLE; + } + } else if (type == INET_UDP) { + char buf[10]; + int readle; + +#ifdef MSG_PEEK + if (recvfrom(socket_fd, buf, 1, MSG_PEEK, + (struct sockaddr *) & remote_addr, + & readle) < 1 + || readle != sizeof(remote_addr) + || connect(socket_fd, + (struct sockaddr *)& remote_addr, + readle) != 0) { + close(socket_fd); + socket_fd = INVALID_HANDLE; + } +#endif + } else { + /* /inet/raw server not ready yet */ + fatal(_("/inet/raw server not ready yet, sorry")); + if (geteuid() != 0) + fatal(_("only root may use `/inet/raw'.")); + } + } + } else { + close(socket_fd); + socket_fd = INVALID_HANDLE; + } + + return socket_fd; +} +#endif /* HAVE_SOCKETS */ + /* devopen --- handle /dev/std{in,out,err}, /dev/fd/N, regular files */ /* @@ -781,33 +1107,38 @@ const char *mode; * no sense to use them for output. */ +/* + * Strictly speaking, "name" is not a "const char *" because we temporarily + * change the string. + */ + int -devopen(name, mode) -const char *name, *mode; +devopen(const char *name, const char *mode) { int openfd; - const char *cp; + char *cp; char *ptr; int flag = 0; - struct stat buf; extern double strtod(); flag = str2mode(mode); if (STREQ(name, "-")) - openfd = fileno(stdin); - else - openfd = INVALID_HANDLE; + return fileno(stdin); + + openfd = INVALID_HANDLE; if (do_traditional) goto strictopen; - if ((openfd = os_devopen(name, flag)) >= 0) + if ((openfd = os_devopen(name, flag)) != INVALID_HANDLE) { + os_close_on_exec(openfd, name, "file", ""); return openfd; + } + + if (STREQN(name, "/dev/", 5)) { + cp = (char *) name + 5; - if (STREQN(name, "/dev/", 5) && stat((char *) name, &buf) == -1) { - cp = name + 5; - if (STREQ(cp, "stdin") && (flag & O_ACCMODE) == O_RDONLY) openfd = fileno(stdin); else if (STREQ(cp, "stdout") && (flag & O_ACCMODE) == O_WRONLY) @@ -820,14 +1151,115 @@ const char *name, *mode; if (openfd <= INVALID_HANDLE || ptr == cp) openfd = INVALID_HANDLE; } + /* do not set close-on-exec for inherited fd's */ + if (openfd != INVALID_HANDLE) + return openfd; + } else if (STREQN(name, "/inet/", 6)) { +#ifdef HAVE_SOCKETS + /* /inet/protocol/localport/hostname/remoteport */ + enum inet_prot protocol = INET_NONE; + int localport, remoteport; + char *hostname; + char *hostnameslastcharp; + char *localpname; + char proto[4]; + struct servent *service; + + cp = (char *) name + 6; + /* which protocol? */ + if (STREQN(cp, "tcp/", 4)) + protocol = INET_TCP; + else if (STREQN(cp, "udp/", 4)) + protocol = INET_UDP; + else if (STREQN(cp, "raw/", 4)) + protocol = INET_RAW; + else + fatal(_("no (known) protocol supplied in special filename `%s'"), + name); + + proto[0] = cp[0]; + proto[1] = cp[1]; + proto[2] = cp[2]; + proto[3] = '\0'; + cp += 4; + + /* which localport? */ + localpname = cp; + while (*cp != '/' && *cp != '\0') + cp++; + /* + * Require a port, let them explicitly put 0 if + * they don't care. + */ + if (*cp != '/' || cp == localpname) + fatal(_("special file name `%s' is incomplete"), name); + /* We change the special file name temporarily because we + * need a 0-terminated string here for conversion with atoi(). + * By using atoi() the use of decimal numbers is enforced. + */ + *cp = '\0'; + + localport = atoi(localpname); + if (strcmp(localpname, "0") != 0 + && (localport <= 0 || localport > 65535)) { + service = getservbyname(localpname, proto); + if (service == NULL) + fatal(_("local port invalid in `%s'"), name); + else + localport = ntohs(service->s_port); + } + *cp = '/'; + + /* which hostname? */ + cp++; + hostname = cp; + while (*cp != '/' && *cp != '\0') + cp++; + if (*cp != '/' || cp == hostname) + fatal(_("must supply a remote hostname to `/inet'")); + *cp = '\0'; + hostnameslastcharp = cp; + + /* which remoteport? */ + cp++; + /* + * The remote port ends the special file name. + * This means there already is a 0 at the end of the string. + * Therefore no need to patch any string ending. + * + * Here too, require a port, let them explicitly put 0 if + * they don't care. + */ + if (*cp == '\0') + fatal(_("must supply a remote port to `/inet'")); + remoteport = atoi(cp); + if (strcmp(cp, "0") != 0 + && (remoteport <= 0 || remoteport > 65535)) { + service = getservbyname(cp, proto); + if (service == NULL) + fatal(_("remote port invalid in `%s'"), name); + else + remoteport = ntohs(service->s_port); + } + + /* Open Sesame! */ + openfd = socketopen(protocol, localport, remoteport, hostname); + *hostnameslastcharp = '/'; + +#else /* ! HAVE_SOCKETS */ + fatal(_("TCP/IP communications are not supported")); +#endif /* HAVE_SOCKETS */ } strictopen: if (openfd == INVALID_HANDLE) openfd = open(name, flag, 0666); - if (openfd != INVALID_HANDLE && fstat(openfd, &buf) > 0) - if (S_ISDIR(buf.st_mode)) - fatal("file `%s' is a directory", name); + if (openfd != INVALID_HANDLE) { + if (os_isdir(openfd)) + fatal(_("file `%s' is a directory"), name); + + os_close_on_exec(openfd, name, "file", ""); + } return openfd; } @@ -835,10 +1267,7 @@ strictopen: /* spec_setup --- setup an IOBUF for a special internal file */ static void -spec_setup(iop, len, allocate) -IOBUF *iop; -int len; -int allocate; +spec_setup(IOBUF *iop, int len, int allocate) { char *cp; @@ -857,15 +1286,12 @@ int allocate; iop->end = iop->buf + len; iop->fd = -1; iop->flag = IOP_IS_INTERNAL; - iop->getrec = get_a_record; } /* specfdopen --- open an fd special file */ static int -specfdopen(iop, name, mode) -IOBUF *iop; -const char *name, *mode; +specfdopen(IOBUF *iop, const char *name, const char *mode) { int fd; IOBUF *tp; @@ -894,12 +1320,13 @@ const char *name, *mode; /* pidopen --- "open" /dev/pid, /dev/ppid, and /dev/pgrpid */ static int -pidopen(iop, name, mode) -IOBUF *iop; -const char *name, *mode; +pidopen(IOBUF *iop, const char *name, const char *mode) { char tbuf[BUFSIZ]; int i; + const char *cp = name + 5; + + warning(_("use `PROCINFO[\"%s\"]' instead of `%s'"), cp, name); if (name[6] == 'g') sprintf(tbuf, "%d\n", (int) getpgrp(getpgrp_arg())); @@ -926,9 +1353,7 @@ const char *name, *mode; */ static int -useropen(iop, name, mode) -IOBUF *iop; -const char *name, *mode; +useropen(IOBUF *iop, const char *name, const char *mode) { char tbuf[BUFSIZ], *cp; int i; @@ -937,13 +1362,15 @@ const char *name, *mode; int ngroups; #endif + warning(_("use `PROCINFO[...]' instead of `/dev/user'")); + sprintf(tbuf, "%d %d %d %d", (int) getuid(), (int) geteuid(), (int) getgid(), (int) getegid()); cp = tbuf + strlen(tbuf); #if defined(NGROUPS_MAX) && NGROUPS_MAX > 0 ngroups = getgroups(NGROUPS_MAX, groupset); if (ngroups == -1) - fatal("could not find groups: %s", strerror(errno)); + fatal(_("could not find groups: %s"), strerror(errno)); for (i = 0; i < ngroups; i++) { *cp++ = ' '; @@ -963,13 +1390,10 @@ const char *name, *mode; /* iop_open --- handle special and regular files for input */ static IOBUF * -iop_open(name, mode, iop) -const char *name, *mode; -IOBUF *iop; +iop_open(const char *name, const char *mode, IOBUF *iop) { int openfd = INVALID_HANDLE; int flag = 0; - struct stat buf; static struct internal { const char *name; int compare; @@ -980,6 +1404,7 @@ IOBUF *iop; { "/dev/stdin", 10, specfdopen }, { "/dev/stdout", 11, specfdopen }, { "/dev/stderr", 11, specfdopen }, + { "/inet/", 6, specfdopen }, { "/dev/pid", 8, pidopen }, { "/dev/ppid", 9, pidopen }, { "/dev/pgrpid", 11, pidopen }, @@ -989,15 +1414,11 @@ IOBUF *iop; flag = str2mode(mode); - /* - * FIXME: remove the stat call, and always process these files - * internally. - */ if (STREQ(name, "-")) openfd = fileno(stdin); else if (do_traditional) goto strictopen; - else if (STREQN(name, "/dev/", 5) && stat((char *) name, &buf) == -1) { + else if (STREQN(name, "/dev/", 5) || STREQN(name, "/inet/", 6)) { int i; for (i = 0; i < devcount; i++) { @@ -1010,30 +1431,185 @@ IOBUF *iop; } else if ((*table[i].fp)(iop, name, mode) == 0) return iop; else { - warning("could not open %s, mode `%s'", + warning(_("could not open `%s', mode `%s'"), name, mode); return NULL; } } } + /* not in table, fall through to regular code */ } strictopen: if (openfd == INVALID_HANDLE) openfd = open(name, flag, 0666); - if (openfd != INVALID_HANDLE && fstat(openfd, &buf) > 0) - if (S_ISDIR(buf.st_mode)) - fatal("file `%s' is a directory", name); + if (openfd != INVALID_HANDLE) { + if (os_isdir(openfd)) + fatal(_("file `%s' is a directory"), name); + + os_close_on_exec(openfd, name, "file", ""); + } return iop_alloc(openfd, name, iop); } +/* two_way_open --- open a two way communications channel */ + +static int +two_way_open(char *str, struct redirect *rp) +{ +#ifdef HAVE_SOCKETS + /* case 1: socket */ + if (STREQN(str, "/inet/", 6)) { + int fd, newfd; + + fd = devopen(str, "rw"); + if (fd == INVALID_HANDLE) + return FALSE; + rp->fp = fdopen(fd, "w"); + if (rp->fp == NULL) { + close(fd); + return FALSE; + } + newfd = dup(fd); + if (newfd < 0) { + fclose(rp->fp); + return FALSE; + } + os_close_on_exec(newfd, str, "socket", "to/from"); + rp->iop = iop_alloc(newfd, str, NULL); + if (rp->iop == NULL) { + fclose(rp->fp); + return FALSE; + } + rp->flag |= RED_SOCKET; + return TRUE; + } +#endif /* HAVE_SOCKETS */ + +#ifdef HAVE_PORTALS + /* case 1.5: portal */ + if (STREQN(str, "/p/", 3)) { + int fd, newfd; + + fd = open(str, O_RDWR); + if (fd == INVALID_HANDLE) + return FALSE; + rp->fp = fdopen(fd, "w"); + if (rp->fp == NULL) { + close(fd); + return FALSE; + } + newfd = dup(fd); + if (newfd < 0) { + fclose(rp->fp); + return FALSE; + } + os_close_on_exec(newfd, str, "portal", "to/from"); + rp->iop = iop_alloc(newfd, str, NULL); + if (rp->iop == NULL) { + fclose(rp->fp); + return FALSE; + } + rp->flag |= RED_SOCKET; + return TRUE; + } +#endif /* HAVE_PORTALS */ + +#ifndef PIPES_SIMULATED /* real pipes */ + /* case 2: two way pipe to a child process */ + { + int ptoc[2], ctop[2]; + int pid; + int save_errno; + + if (pipe(ptoc) < 0) + return FALSE; /* errno set, diagnostic from caller */ + + if (pipe(ctop) < 0) { + save_errno = errno; + close(ptoc[0]); + close(ptoc[1]); + errno = save_errno; + return FALSE; + } + + if ((pid = fork()) < 0) { + save_errno = errno; + close(ptoc[0]); close(ptoc[1]); + close(ctop[0]); close(ctop[1]); + errno = save_errno; + return FALSE; + } + + if (pid == 0) { /* child */ + if (close(1) == -1) + fatal(_("close of stdout in child failed (%s)"), + strerror(errno)); + if (dup(ctop[1]) != 1) + fatal(_("moving pipe to stdout in child failed (dup: %s)"), strerror(errno)); + if (close(0) == -1) + fatal(_("close of stdin in child failed (%s)"), + strerror(errno)); + if (dup(ptoc[0]) != 0) + fatal(_("moving pipe to stdin in child failed (dup: %s)"), strerror(errno)); + if ( close(ptoc[0]) == -1 || close(ptoc[1]) == -1 + || close(ctop[0]) == -1 || close(ctop[1]) == -1) + fatal(_("close of pipe failed (%s)"), strerror(errno)); + /* stderr does NOT get dup'ed onto child's stdout */ + execl("/bin/sh", "sh", "-c", str, NULL); + _exit(127); + } + + /* parent */ + rp->pid = pid; + rp->iop = iop_alloc(ctop[0], str, NULL); + if (rp->iop == NULL) { + (void) close(ctop[0]); + (void) close(ctop[1]); + (void) close(ptoc[0]); + (void) close(ptoc[1]); + (void) kill(pid, SIGKILL); /* overkill? (pardon pun) */ + return FALSE; + } + rp->fp = fdopen(ptoc[1], "w"); + if (rp->fp == NULL) { + iop_close(rp->iop); + rp->iop = NULL; + (void) close(ctop[0]); + (void) close(ctop[1]); + (void) close(ptoc[0]); + (void) close(ptoc[1]); + (void) kill(pid, SIGKILL); /* overkill? (pardon pun) */ + return FALSE; + } + if (fcntl(ctop[0], F_SETFD, 1) < 0) { + warning(_("pipe from `%s': could not set close-on-exec (fcntl: %s)"), + str, strerror(errno));; + } + if (fcntl(ptoc[1], F_SETFD, 1) < 0) { + warning(_("pipe to `%s': could not set close-on-exec (fcntl: %s)"), + str, strerror(errno));; + } + (void) close(ptoc[0]); + (void) close(ctop[1]); + return TRUE; + } + +#else /*PIPES_SIMULATED*/ + + fatal(_("`|&' not supported")); + /*NOTREACHED*/ + return FALSE; + +#endif +} + #ifndef PIPES_SIMULATED /* real pipes */ /* wait_any --- wait for a child process, close associated pipe */ static int -wait_any(interesting) -int interesting; /* pid of interest, if any */ +wait_any(int interesting) /* pid of interest, if any */ { RETSIGTYPE (*hstat)(), (*istat)(), (*qstat)(); int pid; @@ -1072,9 +1648,7 @@ int interesting; /* pid of interest, if any */ /* gawk_popen --- open an IOBUF on a child process */ static IOBUF * -gawk_popen(cmd, rp) -char *cmd; -struct redirect *rp; +gawk_popen(char *cmd, struct redirect *rp) { int p[2]; register int pid; @@ -1087,23 +1661,24 @@ struct redirect *rp; /*(void) wait_any(0);*/ /* wait for outstanding processes */ if (pipe(p) < 0) - fatal("cannot open pipe \"%s\" (%s)", cmd, strerror(errno)); + fatal(_("cannot open pipe `%s' (%s)"), cmd, strerror(errno)); if ((pid = fork()) == 0) { if (close(1) == -1) - fatal("close of stdout in child failed (%s)", + fatal(_("close of stdout in child failed (%s)"), strerror(errno)); if (dup(p[1]) != 1) - fatal("dup of pipe failed (%s)", strerror(errno)); + fatal(_("moving pipe to stdout in child failed (dup: %s)"), strerror(errno)); if (close(p[0]) == -1 || close(p[1]) == -1) - fatal("close of pipe failed (%s)", strerror(errno)); + fatal(_("close of pipe failed (%s)"), strerror(errno)); execl("/bin/sh", "sh", "-c", cmd, NULL); _exit(127); } if (pid == -1) - fatal("cannot fork for \"%s\" (%s)", cmd, strerror(errno)); + fatal(_("cannot create child process for `%s' (fork: %s)"), cmd, strerror(errno)); rp->pid = pid; if (close(p[1]) == -1) - fatal("close of pipe failed (%s)", strerror(errno)); + fatal(_("close of pipe failed (%s)"), strerror(errno)); + os_close_on_exec(p[0], cmd, "pipe", "from"); rp->iop = iop_alloc(p[0], cmd, NULL); if (rp->iop == NULL) (void) close(p[0]); @@ -1113,18 +1688,18 @@ struct redirect *rp; /* gawk_pclose --- close an open child pipe */ static int -gawk_pclose(rp) -struct redirect *rp; +gawk_pclose(struct redirect *rp) { - (void) iop_close(rp->iop); + if (rp->iop != NULL) + (void) iop_close(rp->iop); rp->iop = NULL; /* process previously found, return stored status */ if (rp->pid == -1) - return (rp->status >> 8) & 0xFF; + return (rp->status >> 8) + ((rp->status &0xFF) ? 128 + (rp->status & 0xF) : 0); rp->status = wait_any(rp->pid); rp->pid = -1; - return (rp->status >> 8) & 0xFF; + return (rp->status >> 8) + ((rp->status &0xFF) ? 128 + (rp->status & 0xF) : 0); } #else /* PIPES_SIMULATED */ @@ -1134,19 +1709,22 @@ struct redirect *rp; * except if popen() provides real pipes too */ -#if defined(VMS) || defined(OS2) || defined (MSDOS) || defined(WIN32) +#if defined(VMS) || defined(OS2) || defined (MSDOS) || defined(WIN32) || defined(TANDEM) /* gawk_popen --- open an IOBUF on a child process */ static IOBUF * -gawk_popen(cmd, rp) -char *cmd; -struct redirect *rp; +gawk_popen(char *cmd, struct redirect *rp) { FILE *current; - if ((current = popen(cmd, "r")) == NULL) + os_restore_mode(fileno(stdin)); + current = popen(cmd, binmode("r")); + if ((BINMODE & 1) != 0) + os_setbinmode(fileno(stdin), O_BINARY); + if (current == NULL) return NULL; + os_close_on_exec(fileno(current), cmd, "pipe", "from"); rp->iop = iop_alloc(fileno(current), cmd, NULL); if (rp->iop == NULL) { (void) pclose(current); @@ -1159,19 +1737,20 @@ struct redirect *rp; /* gawk_pclose --- close an open child pipe */ static int -gawk_pclose(rp) -struct redirect *rp; +gawk_pclose(struct redirect *rp) { int rval, aval, fd = rp->iop->fd; - rp->iop->fd = dup(fd); /* kludge to allow close() + pclose() */ - rval = iop_close(rp->iop); + if (rp->iop != NULL) { + rp->iop->fd = dup(fd); /* kludge to allow close() + pclose() */ + rval = iop_close(rp->iop); + } rp->iop = NULL; aval = pclose(rp->ifp); rp->ifp = NULL; return (rval < 0 ? rval : aval); } -#else /* not (VMS || OS2 || MSDOS) */ +#else /* not (VMS || OS2 || MSDOS || TANDEM) */ static struct pipeinfo { char *command; @@ -1181,9 +1760,7 @@ static struct pipeinfo { /* gawk_popen --- open an IOBUF on a child process */ static IOBUF * -gawk_popen(cmd, rp) -char *cmd; -struct redirect *rp; +gawk_popen(char *cmd, struct redirect *rp) { extern char *strdup P((const char *)); int current; @@ -1199,6 +1776,7 @@ struct redirect *rp; return NULL; pipes[current].name = name; pipes[current].command = strdup(cmd); + os_close_on_exec(current, cmd, "pipe", "from"); rp->iop = iop_alloc(current, name, NULL); if (rp->iop == NULL) (void) close(current); @@ -1208,13 +1786,13 @@ struct redirect *rp; /* gawk_pclose --- close an open child pipe */ static int -gawk_pclose(rp) -struct redirect *rp; +gawk_pclose(struct redirect *rp) { int cur = rp->iop->fd; - int rval; + int rval = 0; - rval = iop_close(rp->iop); + if (rp->iop != NULL) + rval = iop_close(rp->iop); rp->iop = NULL; /* check for an open file */ @@ -1226,15 +1804,14 @@ struct redirect *rp; free(pipes[cur].command); return rval; } -#endif /* not (VMS || OS2 || MSDOS) */ +#endif /* not (VMS || OS2 || MSDOS || TANDEM) */ #endif /* PIPES_SIMULATED */ /* do_getline --- read in a line, into var and with redirection, as needed */ NODE * -do_getline(tree) -NODE *tree; +do_getline(NODE *tree) { struct redirect *rp = NULL; IOBUF *iop; @@ -1252,13 +1829,9 @@ NODE *tree; rp = redirect(tree->rnode, &redir_error); if (rp == NULL && redir_error) { /* failed redirect */ - if (! do_traditional) { - s = strerror(redir_error); + if (! do_traditional) + update_ERRNO(); - unref(ERRNO_node->var_value); - ERRNO_node->var_value = - make_string(s, strlen(s)); - } return tmp_number((AWKNUM) -1.0); } iop = rp->iop; @@ -1266,14 +1839,11 @@ NODE *tree; return tmp_number((AWKNUM) 0.0); } errcode = 0; - cnt = (*(iop->getrec))(&s, iop, RS->stptr[0], RS_regexp, &errcode); + cnt = get_a_record(&s, iop, RS->stptr[0], RS_regexp, &errcode); if (errcode != 0) { - if (! do_traditional) { - s = strerror(errcode); + if (! do_traditional) + update_ERRNO(); - unref(ERRNO_node->var_value); - ERRNO_node->var_value = make_string(s, strlen(s)); - } return tmp_number((AWKNUM) -1.0); } if (cnt == EOF) { @@ -1283,7 +1853,7 @@ NODE *tree; * reading from a pipe; otherwise * gawk_pclose will not be called. */ - if ((rp->flag & RED_PIPE) == 0) { + if ((rp->flag & (RED_PIPE|RED_TWOWAY)) == 0) { (void) iop_close(iop); rp->iop = NULL; } @@ -1302,7 +1872,7 @@ NODE *tree; Func_ptr after_assign = NULL; NODE **lhs; - lhs = get_lhs(tree->lnode, &after_assign); + lhs = get_lhs(tree->lnode, &after_assign, FALSE); unref(*lhs); *lhs = make_string(s, cnt); (*lhs)->flags |= MAYBE_NUM; @@ -1317,8 +1887,7 @@ NODE *tree; /* pathopen --- pathopen with default file extension handling */ int -pathopen(file) -const char *file; +pathopen(const char *file) { int fd = do_pathopen(file); @@ -1351,8 +1920,7 @@ const char *file; /* do_pathopen --- search $AWKPATH for source file */ static int -do_pathopen(file) -const char *file; +do_pathopen(const char *file) { static const char *savepath = NULL; static int first = TRUE; @@ -1412,8 +1980,7 @@ const char *file; int bufsize = 8192; void -fatal(s) -char *s; +fatal(char *s) { printf("%s\n", s); exit(1); @@ -1423,10 +1990,7 @@ char *s; /* iop_alloc --- allocate an IOBUF structure for an open fd */ static IOBUF * -iop_alloc(fd, name, iop) -int fd; -const char *name; -IOBUF *iop; +iop_alloc(int fd, const char *name, IOBUF *iop) { struct stat sbuf; @@ -1439,63 +2003,16 @@ IOBUF *iop; iop->flag |= IOP_IS_TTY; iop->size = optimal_bufsize(fd, & sbuf); if (do_lint && S_ISREG(sbuf.st_mode) && sbuf.st_size == 0) - warning("data file `%s' is empty", name); + lintwarn(_("data file `%s' is empty"), name); iop->secsiz = -2; errno = 0; iop->fd = fd; iop->off = iop->buf = NULL; iop->cnt = 0; iop->name = name; - iop->getrec = get_a_record; -#ifdef HAVE_MMAP - /* Use mmap only for regular files with positive sizes. - The size must fit into size_t, so that mmap works correctly. - Also, it must fit into int, so that iop->cnt won't overflow. */ - if (S_ISREG(sbuf.st_mode) && sbuf.st_size > 0 - && sbuf.st_size == (size_t) sbuf.st_size - && sbuf.st_size == (int) sbuf.st_size) { - register char *cp; - - iop->buf = iop->off = mmap((caddr_t) 0, sbuf.st_size, - PROT_READ|PROT_WRITE, MAP_PRIVATE, - fd, 0L); - /* cast is for buggy compilers (e.g. DEC OSF/1) */ - if (iop->buf == (caddr_t)MAP_FAILED) { - iop->buf = iop->off = NULL; - goto out; - } - - iop->flag |= IOP_MMAPPED; - iop->size = sbuf.st_size; - iop->secsiz = 0; - iop->end = iop->buf + iop->size; - iop->cnt = sbuf.st_size; - iop->getrec = mmap_get_record; - (void) close(fd); - iop->fd = INVALID_HANDLE; - -#if defined(HAVE_MADVISE) && defined(MADV_SEQUENTIAL) - madvise(iop->buf, iop->size, MADV_SEQUENTIAL); -#endif - /* - * The following is a really gross hack. - * We want to ensure that we have a copy of the input - * data that won't go away, on the off chance that someone - * will truncate the data file we've just mmap'ed. - * So, we go through and touch each page, forcing the - * system to give us a private copy. A page size of 512 - * guarantees this will work, even on the least common - * denominator system (like, oh say, a VAX). - */ - for (cp = iop->buf; cp < iop->end; cp += 512) - *cp = *cp; - } -out: -#endif /* HAVE_MMAP */ return iop; } -/* These macros used by both record reading routines */ #define set_RT_to_null() \ (void)(! do_traditional && (unref(RT_node->var_value), \ RT_node->var_value = Nnull_string)) @@ -1524,12 +2041,11 @@ out: */ static int -get_a_record(out, iop, grRS, RSre, errcode) -char **out; /* pointer to pointer to data */ -IOBUF *iop; /* input IOP */ -register int grRS; /* first char in RS->stptr */ -Regexp *RSre; /* regexp for RS */ -int *errcode; /* pointer to error variable */ +get_a_record(char **out, /* pointer to pointer to data */ + IOBUF *iop, /* input IOP */ + register int grRS, /* first char in RS->stptr */ + Regexp *RSre, /* regexp for RS */ + int *errcode) /* pointer to error variable */ { register char *bp = iop->off; char *bufend; @@ -1540,11 +2056,21 @@ int *errcode; /* pointer to error variable */ int continuing = FALSE, continued = FALSE; /* used for re matching */ int onecase; +#ifdef TANDEM + char *mend; +#endif + +#ifdef TANDEM +#define not_past_end() (bp < mend) +#else +#define not_past_end() (1) +#endif + /* first time through */ if (RS_null_re == NULL) { RS_null_re = make_regexp("\n\n+", 3, TRUE, TRUE); if (RS_null_re == NULL) - fatal("internal error: file `%s', line %d\n", + fatal(_("internal error: file `%s', line %d\n"), __FILE__, __LINE__); } @@ -1554,14 +2080,21 @@ int *errcode; /* pointer to error variable */ return EOF; } +#ifdef TANDEM + if (MRL) + mend = start + MRL; + else + mend = (char *) LONG_MAX; +#endif + if (RS_is_null) /* special case: RS == "" */ rs = '\n'; else rs = (char) grRS; - onecase = (IGNORECASE && isalpha(rs)); + onecase = (IGNORECASE && ISALPHA(rs)); if (onecase) - rs = casetable[rs]; + rs = casetable[(unsigned char) rs]; /* set up sentinel */ if (iop->buf) { @@ -1611,6 +2144,10 @@ int *errcode; /* pointer to error variable */ } bp = iop->end = iop->off = iop->buf + iop->secsiz; start = bp - len; +#ifdef TANDEM + if (MRL) + mend = start + MRL; +#endif if (oldbuf != NULL) { free(oldbuf); oldbuf = NULL; @@ -1635,7 +2172,7 @@ int *errcode; /* pointer to error variable */ iop->cnt = EOF; break; } else - fatal("error reading input file `%s': %s", + fatal(_("error reading input file `%s': %s"), iop->name, strerror(errno)); } else if (iop->cnt == 0) { /* @@ -1687,6 +2224,14 @@ int *errcode; /* pointer to error variable */ * that until we try to add more to the buffer. Thus, we * set a flag to indicate, that if eof really does happen, * don't break early. + * + * Still more subtlety. Suppose RS is a multi-character regexp, + * but it doesn't have the metacharacters that would let it + * match an arbitrary number of characters. So it's an exact + * string match. We need to check for this, in the case where + * there is an exact match at the end, and NOT read more + * data. Otherwise, this might bite us for an interactive + * networking program that uses CR-LF as the line terminator. */ continuing = FALSE; if (rsre != NULL) { @@ -1715,20 +2260,34 @@ int *errcode; /* pointer to error variable */ /* case 3, regex match at exact end */ if (start + REEND(rsre, start) >= iop->end) { if (iop->cnt != EOF) { - bp = iop->end; - continuing = continued = TRUE; - continue; + /* + * Only do the test if not at EOF + */ + int isstring; + + isstring = reisstring(RS->stptr, + RS->stlen, rsre, start); + if (isstring == FALSE) { + bp = iop->end; + continuing = continued = TRUE; + continue; + } } } /* got a match! */ /* * Leading newlines at the beginning of the file * should be ignored. Whew! - * - * Is this code ever executed? */ - if (RS_is_null && RESTART(rsre, start) == 0) { - start += REEND(rsre, start); + if (RS_is_null && *start == '\n') { + /* + * have to catch the case of a + * single newline at the front of + * the record, which the regex + * doesn't. gurr. + */ + while (*start == '\n' && start < iop->end) + start++; goto again; } bp = start + RESTART(rsre, start); @@ -1739,10 +2298,10 @@ int *errcode; /* pointer to error variable */ } /* search for RS, #2, RS = */ if (onecase) { - while (casetable[(int) *bp++] != rs) + while (casetable[(unsigned char) *bp++] != rs && not_past_end()) continue; } else { - while (*bp++ != rs) + while (*bp++ != rs && not_past_end()) continue; } set_RT(bp - 1, 1); @@ -1764,15 +2323,12 @@ int *errcode; /* pointer to error variable */ } if (do_traditional || rsre == NULL) { - char *bstart; - - bstart = iop->off = bp; + iop->off = bp; bp--; - if (onecase ? casetable[(int) *bp] != rs : *bp != rs) { + if (onecase ? casetable[(unsigned char) *bp] != rs : *bp != rs) bp++; - bstart = bp; - } - *bp = '\0'; + if (MRL == 0) + *bp = '\0'; } else if (RS_is_null && iop->cnt == EOF) { /* * special case, delete trailing newlines, @@ -1789,9 +2345,7 @@ int *errcode; /* pointer to error variable */ #ifdef TEST int -main(argc, argv) -int argc; -char *argv[]; +main(int argc, char *argv[]) { IOBUF *iop; char *out; @@ -1812,145 +2366,6 @@ char *argv[]; } #endif -#ifdef HAVE_MMAP -/* mmap_get_record --- pull a record out of a memory-mapped file */ - -static int -mmap_get_record(out, iop, grRS, RSre, errcode) -char **out; /* pointer to pointer to data */ -IOBUF *iop; /* input IOP */ -register int grRS; /* first char in RS->stptr */ -Regexp *RSre; /* regexp for RS */ -int *errcode; /* pointer to error variable */ -{ - register char *bp = iop->off; - char *start = iop->off; /* beginning of record */ - int rs; - static Regexp *RS_null_re = NULL; - Regexp *rsre = NULL; - int onecase; - register char *end = iop->end; - int cnt; - - /* first time through */ - if (RS_null_re == NULL) { - RS_null_re = make_regexp("\n\n+", 3, TRUE, TRUE); - if (RS_null_re == NULL) - fatal("internal error: file `%s', line %d\n", - __FILE__, __LINE__); - } - - if (iop->off >= iop->end) { /* previous record was last */ - *out = NULL; - set_RT_to_null(); - iop->cnt = EOF; /* tested by higher level code */ - return EOF; - } - - if (RS_is_null) /* special case: RS == "" */ - rs = '\n'; - else - rs = (char) grRS; - - onecase = (IGNORECASE && isalpha(rs)); - if (onecase) - rs = casetable[rs]; - - /* if RS = "", skip leading newlines at the front of the file */ - if (RS_is_null && iop->off == iop->buf) { - for (bp = iop->off; *bp == '\n'; bp++) - continue; - - if (bp != iop->off) - iop->off = start = bp; - } - - /* - * Regexp based searching. Either RS = "" or RS = - * See comments in get_a_record. - */ - if (! do_traditional && RSre != NULL) /* regexp */ - rsre = RSre; - else if (RS_is_null) /* RS = "" */ - rsre = RS_null_re; - else - rsre = NULL; - - /* - * Look for regexp match of RS. Non-match conditions are: - * 1. No match at all - * 2. Match of a null string - * 3. Match ends at exact end of buffer - * - * #1 means that the record ends the file - * and there is no text that actually matched RS. - * - * #2: is probably like #1. - * - * #3 is simple; since we have the whole file mapped, it's - * the last record in the file. - */ - if (rsre != NULL) { - if (research(rsre, start, 0, iop->end - start, TRUE) == -1 - || RESTART(rsre, start) == REEND(rsre, start)) { - /* no matching text, we have the record */ - *out = start; - iop->off = iop->end; /* all done with the record */ - set_RT_to_null(); - /* special case, don't allow trailing newlines */ - if (RS_is_null && *(iop->end - 1) == '\n') - return iop->end - start - 1; - else - return iop->end - start; - - } - /* have a match */ - *out = start; - bp = start + RESTART(rsre, start); - set_RT(bp, REEND(rsre, start) - RESTART(rsre, start)); - *bp = '\0'; - iop->off = start + REEND(rsre, start); - return bp - start; - } - - /* - * RS = "?", i.e., one character based searching. - * - * Alas, we can't just plug the sentinel character in at - * the end of the mmapp'ed file ( *(iop->end) = rs; ). This - * works if we're lucky enough to have a file that does not - * take up all of its last disk block. But if we end up with - * file whose size is an even multiple of the disk block size, - * assigning past the end of it delivers a SIGBUS. So, we have to - * add the extra test in the while loop at the front that looks - * for going past the end of the mapped object. Sigh. - */ - /* search for RS, #2, RS = */ - if (onecase) { - while (bp < end && casetable[*bp++] != rs) - continue; - } else { - while (bp < end && *bp++ != rs) - continue; - } - cnt = (bp - start) - 1; - if (bp >= iop->end) { - /* at end, may have actually seen rs, or may not */ - if (*(bp-1) == rs) - set_RT(bp - 1, 1); /* real RS seen */ - else { - cnt++; - set_RT_to_null(); - } - } else - set_RT(bp - 1, 1); - - iop->off = bp; - *out = start; - return cnt; -} -#endif /* HAVE_MMAP */ - /* set_RS --- update things as appropriate when RS is set */ void @@ -1976,7 +2391,7 @@ set_RS() RS_regexp = make_regexp(RS->stptr, RS->stlen, IGNORECASE, TRUE); if (do_lint && ! warned) { - warning("multicharacter value of `RS' is not portable"); + lintwarn(_("multicharacter value of `RS' is a gawk extension")); warned = TRUE; } } -- cgit v1.1