Home | History | Annotate | Line # | Download | only in sh 
      1 /*	$NetBSD: input.c,v 1.76 2024/10/14 08:15:43 kre Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 1991, 1993
      5  *	The Regents of the University of California.  All rights reserved.
      6  *
      7  * This code is derived from software contributed to Berkeley by
      8  * Kenneth Almquist.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  * 3. Neither the name of the University nor the names of its contributors
     19  *    may be used to endorse or promote products derived from this software
     20  *    without specific prior written permission.
     21  *
     22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     32  * SUCH DAMAGE.
     33  */
     34 
     35 #include <sys/cdefs.h>
     36 #ifndef lint
     37 #if 0
     38 static char sccsid[] = "@(#)input.c	8.3 (Berkeley) 6/9/95";
     39 #else
     40 __RCSID("$NetBSD: input.c,v 1.76 2024/10/14 08:15:43 kre Exp $");
     41 #endif
     42 #endif /* not lint */
     43 
     44 #include <stdio.h>	/* defines BUFSIZ */
     45 #include <fcntl.h>
     46 #include <errno.h>
     47 #include <unistd.h>
     48 #include <limits.h>
     49 #include <stdlib.h>
     50 #include <string.h>
     51 #include <sys/stat.h>
     52 
     53 /*
     54  * This file implements the input routines used by the parser.
     55  */
     56 
     57 #include "shell.h"
     58 #include "redir.h"
     59 #include "syntax.h"
     60 #include "input.h"
     61 #include "output.h"
     62 #include "options.h"
     63 #include "memalloc.h"
     64 #include "error.h"
     65 #include "alias.h"
     66 #include "parser.h"
     67 #include "myhistedit.h"
     68 #include "show.h"
     69 
     70 #define EOF_NLEFT -99		/* value of parsenleft when EOF pushed back */
     71 
     72 MKINIT
     73 struct strpush {
     74 	struct strpush *prev;	/* preceding string on stack */
     75 	const char *prevstring;
     76 	int prevnleft;
     77 	int prevlleft;
     78 	struct alias *ap;	/* if push was associated with an alias */
     79 };
     80 
     81 /*
     82  * The parsefile structure pointed to by the global variable parsefile
     83  * contains information about the current file being read.
     84  */
     85 
     86 MKINIT
     87 struct parsefile {
     88 	struct parsefile *prev;	/* preceding file on stack */
     89 	int linno;		/* current line */
     90 	int fd;			/* file descriptor (or -1 if string) */
     91 	int nleft;		/* number of chars left in this line */
     92 	int lleft;		/* number of chars left in this buffer */
     93 	int nskip;		/* number of \0's dropped in previous line */
     94 	const char *nextc;	/* next char in buffer */
     95 	char *buf;		/* input buffer */
     96 	struct strpush *strpush; /* for pushing strings at this level */
     97 	struct strpush basestrpush; /* so pushing one is fast */
     98 };
     99 
    100 
    101 int plinno = 1;			/* input line number */
    102 int parsenleft;			/* copy of parsefile->nleft */
    103 MKINIT int parselleft;		/* copy of parsefile->lleft */
    104 const char *parsenextc;		/* copy of parsefile->nextc */
    105 MKINIT struct parsefile basepf;	/* top level input file */
    106 MKINIT char basebuf[BUFSIZ];	/* buffer for top level input file */
    107 struct parsefile *parsefile = &basepf;	/* current input file */
    108 int init_editline = 0;		/* editline library initialized? */
    109 int whichprompt;		/* 1 == PS1, 2 == PS2 */
    110 
    111 STATIC void pushfile(void);
    112 static int preadfd(void);
    113 
    114 #ifdef mkinit
    115 INCLUDE <stdio.h>
    116 INCLUDE "input.h"
    117 INCLUDE "error.h"
    118 
    119 INIT {
    120 	basepf.nextc = basepf.buf = basebuf;
    121 }
    122 
    123 RESET {
    124 	if (exception != EXSHELLPROC)
    125 		parselleft = parsenleft = 0;	/* clear input buffer */
    126 	popallfiles();
    127 }
    128 
    129 SHELLPROC {
    130 	popallfiles();
    131 }
    132 #endif
    133 
    134 
    135 #if 0		/* this is unused */
    136 /*
    137  * Read a line from the script.
    138  */
    139 
    140 char *
    141 pfgets(char *line, int len)
    142 {
    143 	char *p = line;
    144 	int nleft = len;
    145 	int c;
    146 
    147 	while (--nleft > 0) {
    148 		c = pgetc_macro();
    149 		if (c == PFAKE)		/* consecutive PFAKEs is impossible */
    150 			c = pgetc_macro();
    151 		if (c == PEOF) {
    152 			if (p == line)
    153 				return NULL;
    154 			break;
    155 		}
    156 		*p++ = c;
    157 		if (c == '\n') {
    158 			plinno++;
    159 			break;
    160 		}
    161 	}
    162 	*p = '\0';
    163 	return line;
    164 }
    165 #endif
    166 
    167 
    168 /*
    169  * Read a character from the script, returning PEOF on end of file.
    170  * Nul characters in the input are silently discarded.
    171  */
    172 
    173 int
    174 pgetc(void)
    175 {
    176 	int c;
    177 
    178 	c = pgetc_macro();
    179 	if (c == PFAKE)
    180 		c = pgetc_macro();
    181 	return c;
    182 }
    183 
    184 
    185 static int
    186 preadfd(void)
    187 {
    188 	int nr;
    189 	char *buf =  parsefile->buf;
    190 	parsenextc = buf;
    191 
    192  retry:
    193 #ifndef SMALL
    194 	if (parsefile->fd == 0 && el) {
    195 		static const char *rl_cp;
    196 		static int el_len;
    197 
    198 		if (rl_cp == NULL)
    199 			rl_cp = el_gets(el, &el_len);
    200 		if (rl_cp == NULL)
    201 			nr = el_len == 0 ? 0 : -1;
    202 		else {
    203 			nr = el_len;
    204 			if (nr > BUFSIZ - 8)
    205 				nr = BUFSIZ - 8;
    206 			memcpy(buf, rl_cp, nr);
    207 			if (nr != el_len) {
    208 				el_len -= nr;
    209 				rl_cp += nr;
    210 			} else
    211 				rl_cp = 0;
    212 		}
    213 
    214 	} else
    215 #endif
    216 		nr = read(parsefile->fd, buf, BUFSIZ - 8);
    217 
    218 
    219 	if (nr <= 0) {
    220 		if (nr < 0) {
    221 			if (errno == EINTR)
    222 				goto retry;
    223 			if (parsefile->fd == 0 && errno == EWOULDBLOCK) {
    224 				int flags = fcntl(0, F_GETFL, 0);
    225 
    226 				if (flags >= 0 && flags & O_NONBLOCK) {
    227 					flags &=~ O_NONBLOCK;
    228 					if (fcntl(0, F_SETFL, flags) >= 0) {
    229 						out2str("sh: turning off NDELAY mode\n");
    230 						goto retry;
    231 					}
    232 				}
    233 			}
    234 		}
    235 		nr = -1;
    236 	}
    237 	return nr;
    238 }
    239 
    240 /*
    241  * Refill the input buffer and return the next input character:
    242  *
    243  * 1) If a string was pushed back on the input, pop it;
    244  * 2) If an EOF was pushed back (parsenleft == EOF_NLEFT) or we are reading
    245  *    from a string so we can't refill the buffer, return EOF.
    246  * 3) If there is more stuff in this buffer, use it else call read to fill it.
    247  * 4) Process input up to the next newline, deleting nul characters.
    248  */
    249 
    250 int
    251 preadbuffer(void)
    252 {
    253 	char *p, *q;
    254 	int more;
    255 #ifndef SMALL
    256 	int something;
    257 #endif
    258 	char savec;
    259 
    260 	while (parsefile->strpush) {
    261 		if (parsenleft == -1 && parsefile->strpush->ap != NULL)
    262 			return PFAKE;
    263 		popstring();
    264 		if (--parsenleft >= 0)
    265 			return (*parsenextc++);
    266 	}
    267 	if (parsenleft == EOF_NLEFT || parsefile->buf == NULL)
    268 		return PEOF;
    269 	flushout(&output);
    270 	flushout(&errout);
    271 
    272  again:
    273 	if (parselleft <= 0) {
    274 		if ((parselleft = preadfd()) == -1) {
    275 			parselleft = parsenleft = EOF_NLEFT;
    276 			return PEOF;
    277 		}
    278 		parsefile->nskip = 0;
    279 	}
    280 
    281 		/* jump over slots for any \0 chars that were dropped */
    282 	parsenextc += parsefile->nskip;
    283 	parsefile->nskip = 0;
    284 
    285 		/* p = (not const char *)parsenextc; */
    286 	p = parsefile->buf + (parsenextc - parsefile->buf);
    287 	q = p;
    288 
    289 	/* delete nul characters */
    290 #ifndef SMALL
    291 	something = 0;
    292 #endif
    293 	for (more = 1; more;) {
    294 		switch (*p) {
    295 		case '\0':
    296 #ifdef REJECT_NULS
    297 			parsenleft = parselleft = 0;
    298 			error("nul ('\\0') in shell input");
    299 			/* NOTREACHED */
    300 #else
    301 			p++;	/* Skip nul */
    302 			parsefile->nskip++;
    303 			goto check;
    304 #endif
    305 
    306 		case '\t':
    307 		case ' ':
    308 			break;
    309 
    310 		case '\n':
    311 			parsenleft = q - parsenextc;
    312 			more = 0; /* Stop processing here */
    313 			break;
    314 
    315 		default:
    316 #ifndef SMALL
    317 			something = 1;
    318 #endif
    319 			break;
    320 		}
    321 
    322 		if (parsefile->nskip)
    323 			*q++ = *p++;
    324 		else
    325 			q = ++p;
    326 
    327 #ifndef REJECT_NULS
    328  check:;
    329 #endif
    330 		if (--parselleft <= 0) {
    331 			parsenleft = q - parsenextc - 1;
    332 			if (parsenleft < 0)
    333 				goto again;
    334 			*q = '\0';
    335 			more = 0;
    336 		}
    337 	}
    338 
    339 	savec = *q;
    340 	*q = '\0';
    341 
    342 #ifndef SMALL
    343 	if (parsefile->fd == 0 && hist && (something || whichprompt == 2)) {
    344 		HistEvent he;
    345 
    346 		INTOFF;
    347 		history(hist, &he, whichprompt != 2 ? H_ENTER : H_APPEND,
    348 		    parsenextc);
    349 		if (whichprompt != 2 && HistFP != NULL) {
    350 			history(hist, &he, H_NSAVE_FP, (size_t)0, HistFP);
    351 			fflush(HistFP);
    352 		}
    353 		INTON;
    354 	}
    355 #endif
    356 
    357 	if (vflag) {
    358 		out2str(parsenextc);
    359 		flushout(out2);
    360 	}
    361 
    362 	*q = savec;
    363 
    364 	return *parsenextc++;
    365 }
    366 
    367 /*
    368  * Test whether we have reached EOF on input stream.
    369  * Return true only if certain (without attempting a read).
    370  *
    371  * Note the similarity to the opening section of preadbuffer()
    372  */
    373 int
    374 at_eof(void)
    375 {
    376 	struct strpush *sp = parsefile->strpush;
    377 
    378 	if (parsenleft > 0)	/* more chars are in the buffer */
    379 		return 0;
    380 
    381 	while (sp != NULL) {
    382 		/*
    383 		 * If any pushed string has any remaining data,
    384 		 * then we are not at EOF  (simulating popstring())
    385 		 */
    386 		if (sp->prevnleft > 0)
    387 			return 0;
    388 		sp = sp->prev;
    389 	}
    390 
    391 	/*
    392 	 * If we reached real EOF and pushed it back,
    393 	 * or if we are just processing a string (not reading a file)
    394 	 * then there is no more.   Note that if a file pushes a
    395 	 * string, the file's ->buf remains present.
    396 	 */
    397 	if (parsenleft == EOF_NLEFT || parsefile->buf == NULL)
    398 		return 1;
    399 
    400 	/*
    401 	 * In other cases, there might be more
    402 	 */
    403 	return 0;
    404 }
    405 
    406 /*
    407  * Undo the last call to pgetc.  Only one character may be pushed back.
    408  * PEOF may be pushed back.
    409  */
    410 
    411 void
    412 pungetc(void)
    413 {
    414 	parsenleft++;
    415 	parsenextc--;
    416 }
    417 
    418 /*
    419  * Push a string back onto the input at this current parsefile level.
    420  * We handle aliases this way.
    421  */
    422 void
    423 pushstring(const char *s, int len, struct alias *ap)
    424 {
    425 	struct strpush *sp;
    426 
    427 	VTRACE(DBG_INPUT,
    428 	    ("pushstring(\"%.*s\", %d)%s%s%s had: nl=%d ll=%d \"%.*s\"\n",
    429 	    len, s, len, ap ? " for alias:'" : "",
    430 	    ap ? ap->name : "", ap ? "'" : "",
    431 	    parsenleft, parselleft, parsenleft, parsenextc));
    432 
    433 	INTOFF;
    434 	if (parsefile->strpush) {
    435 		sp = ckmalloc(sizeof (struct strpush));
    436 		sp->prev = parsefile->strpush;
    437 		parsefile->strpush = sp;
    438 	} else
    439 		sp = parsefile->strpush = &(parsefile->basestrpush);
    440 
    441 	sp->prevstring = parsenextc;
    442 	sp->prevnleft = parsenleft;
    443 	sp->prevlleft = parselleft;
    444 	sp->ap = ap;
    445 	if (ap)
    446 		ap->flag |= ALIASINUSE;
    447 	parsenextc = s;
    448 	parsenleft = len;
    449 	INTON;
    450 }
    451 
    452 void
    453 popstring(void)
    454 {
    455 	struct strpush *sp = parsefile->strpush;
    456 
    457 	INTOFF;
    458 	if (sp->ap) {
    459 		int alen;
    460 
    461 		if ((alen = strlen(sp->ap->val)) > 0 &&
    462 		    (sp->ap->val[alen - 1] == ' ' ||
    463 		     sp->ap->val[alen - 1] == '\t'))
    464 			checkkwd |= CHKALIAS;
    465 		sp->ap->flag &= ~ALIASINUSE;
    466 	}
    467 	parsenextc = sp->prevstring;
    468 	parsenleft = sp->prevnleft;
    469 	parselleft = sp->prevlleft;
    470 
    471 	VTRACE(DBG_INPUT, ("popstring()%s%s%s nl=%d ll=%d \"%.*s\"\n",
    472 	    sp->ap ? " from alias:'" : "", sp->ap ? sp->ap->name : "",
    473 	    sp->ap ? "'" : "", parsenleft, parselleft, parsenleft, parsenextc));
    474 
    475 	parsefile->strpush = sp->prev;
    476 	if (sp != &(parsefile->basestrpush))
    477 		ckfree(sp);
    478 	INTON;
    479 }
    480 
    481 /*
    482  * Set the input to take input from a file.  If push is set, push the
    483  * old input onto the stack first.
    484  */
    485 
    486 void
    487 setinputfile(const char *fname, int push)
    488 {
    489 	unsigned char magic[4];
    490 	int fd;
    491 	int fd2;
    492 	struct stat sb;
    493 
    494 	CTRACE(DBG_INPUT,("setinputfile(\"%s\", %spush)\n",fname,push?"":"no"));
    495 
    496 	INTOFF;
    497 	if ((fd = open(fname, O_RDONLY)) < 0)
    498 		error("Can't open %s", fname);
    499 
    500 	/* Since the message "Syntax error: "(" unexpected" is not very
    501 	 * helpful, we check if the file starts with the ELF magic to
    502 	 * avoid that message. The first lseek tries to make sure that
    503 	 * we can later rewind the file.
    504 	 */
    505 	if (fstat(fd, &sb) == 0 && S_ISREG(sb.st_mode) &&
    506 	    lseek(fd, 0, SEEK_SET) == 0) {
    507 		if (read(fd, magic, 4) == 4) {
    508 			if (memcmp(magic, "\177ELF", 4) == 0) {
    509 				(void)close(fd);
    510 				error("Cannot execute ELF binary %s", fname);
    511 			}
    512 		}
    513 		if (lseek(fd, 0, SEEK_SET) != 0) {
    514 			(void)close(fd);
    515 			error("Cannot rewind the file %s", fname);
    516 		}
    517 	}
    518 
    519 	fd2 = to_upper_fd(fd);	/* closes fd, returns higher equiv */
    520 	if (fd2 == fd) {
    521 		(void) close(fd);
    522 		error("Out of file descriptors");
    523 	}
    524 
    525 	setinputfd(fd2, push);
    526 	INTON;
    527 }
    528 
    529 /*
    530  * When a shell fd needs to be altered (when the user wants to use
    531  * the same fd - rare, but happens - we need to locate the ref to
    532  * the fd, and update it.  This happens via a callback.
    533  * This is the callback func for fd's used for shell input
    534  */
    535 static void
    536 input_fd_swap(int from, int to)
    537 {
    538 	struct parsefile *pf;
    539 
    540 	pf = parsefile;
    541 	while (pf != NULL) {		/* don't need to stop at basepf */
    542 		if (pf->fd == from)
    543 			pf->fd = to;
    544 		pf = pf->prev;
    545 	}
    546 }
    547 
    548 /*
    549  * Like setinputfile, but takes an open file descriptor.  Call this with
    550  * interrupts off.
    551  */
    552 
    553 void
    554 setinputfd(int fd, int push)
    555 {
    556 	VTRACE(DBG_INPUT, ("setinputfd(%d, %spush)\n", fd, push?"":"no"));
    557 
    558 	INTOFF;
    559 	register_sh_fd(fd, input_fd_swap);
    560 	(void) fcntl(fd, F_SETFD, FD_CLOEXEC);
    561 	if (push)
    562 		pushfile();
    563 	if (parsefile->fd > 0)
    564 		sh_close(parsefile->fd);
    565 	parsefile->fd = fd;
    566 	if (parsefile->buf == NULL)
    567 		parsefile->buf = ckmalloc(BUFSIZ);
    568 	parselleft = parsenleft = 0;
    569 	plinno = 1;
    570 	INTON;
    571 
    572 	CTRACE(DBG_INPUT, ("setinputfd(%d, %spush) done; plinno=1\n", fd,
    573 	    push ? "" : "no"));
    574 }
    575 
    576 
    577 /*
    578  * Like setinputfile, but takes input from a string.
    579  */
    580 
    581 void
    582 setinputstring(const char *string, int push, int line1)
    583 {
    584 
    585 	INTOFF;
    586 	if (push)		/* XXX: always, as it happens */
    587 		pushfile();
    588 	parsenextc = string;
    589 	parselleft = parsenleft = strlen(string);
    590 	plinno = line1;
    591 	INTON;
    592 
    593 	CTRACE(DBG_INPUT,
    594 	    ("setinputstring(\"%.20s%s\" (%d), %spush, @ %d)\n", string,
    595 	    (parsenleft > 20 ? "..." : ""), parsenleft, push?"":"no", line1));
    596 }
    597 
    598 
    599 
    600 /*
    601  * To handle the "." command, a stack of input files is used.  Pushfile
    602  * adds a new entry to the stack and popfile restores the previous level.
    603  */
    604 
    605 STATIC void
    606 pushfile(void)
    607 {
    608 	struct parsefile *pf;
    609 
    610 	VTRACE(DBG_INPUT,
    611 	    ("pushfile(): fd=%d buf=%p nl=%d ll=%d \"%.*s\" plinno=%d\n",
    612 	    parsefile->fd, parsefile->buf, parsenleft, parselleft,
    613 	    parsenleft, parsenextc, plinno));
    614 
    615 	parsefile->nleft = parsenleft;
    616 	parsefile->lleft = parselleft;
    617 	parsefile->nextc = parsenextc;
    618 	parsefile->linno = plinno;
    619 	pf = (struct parsefile *)ckmalloc(sizeof (struct parsefile));
    620 	pf->prev = parsefile;
    621 	pf->fd = -1;
    622 	pf->strpush = NULL;
    623 	pf->basestrpush.prev = NULL;
    624 	pf->buf = NULL;
    625 	parsefile = pf;
    626 }
    627 
    628 
    629 void
    630 popfile(void)
    631 {
    632 	struct parsefile *pf = parsefile;
    633 
    634 	INTOFF;
    635 	if (pf->fd >= 0)
    636 		sh_close(pf->fd);
    637 	if (pf->buf)
    638 		ckfree(pf->buf);
    639 	while (pf->strpush)
    640 		popstring();
    641 	parsefile = pf->prev;
    642 	ckfree(pf);
    643 	parsenleft = parsefile->nleft;
    644 	parselleft = parsefile->lleft;
    645 	parsenextc = parsefile->nextc;
    646 
    647 	VTRACE(DBG_INPUT,
    648 	    ("popfile(): fd=%d buf=%p nl=%d ll=%d \"%.*s\" plinno:%d->%d\n",
    649 	    parsefile->fd, parsefile->buf, parsenleft, parselleft,
    650 	    parsenleft, parsenextc, plinno, parsefile->linno));
    651 
    652 	plinno = parsefile->linno;
    653 	INTON;
    654 }
    655 
    656 /*
    657  * Return current file (to go back to it later using popfilesupto()).
    658  */
    659 
    660 struct parsefile *
    661 getcurrentfile(void)
    662 {
    663 	return parsefile;
    664 }
    665 
    666 
    667 /*
    668  * Pop files until the given file is on top again. Useful for regular
    669  * builtins that read shell commands from files or strings.
    670  * If the given file is not an active file, an error is raised.
    671  */
    672 
    673 void
    674 popfilesupto(struct parsefile *file)
    675 {
    676 	while (parsefile != file && parsefile != &basepf)
    677 		popfile();
    678 	if (parsefile != file)
    679 		error("popfilesupto() misused");
    680 }
    681 
    682 
    683 /*
    684  * Return to top level.
    685  */
    686 
    687 void
    688 popallfiles(void)
    689 {
    690 	while (parsefile != &basepf)
    691 		popfile();
    692 }
    693 
    694 
    695 
    696 /*
    697  * Close the file(s) that the shell is reading commands from.  Called
    698  * after a fork is done.
    699  *
    700  * Takes one arg, vfork, which tells it to not modify its global vars
    701  * as it is still running in the parent.
    702  *
    703  * This code is (probably) unnecessary as the 'close on exec' flag is
    704  * set and should be enough.  In the vfork case it is definitely wrong
    705  * to close the fds as another fork() may be done later to feed data
    706  * from a 'here' document into a pipe and we don't want to close the
    707  * pipe!
    708  */
    709 
    710 void
    711 closescript(int vforked)
    712 {
    713 	if (vforked)
    714 		return;
    715 	popallfiles();
    716 	if (parsefile->fd > 0) {
    717 		sh_close(parsefile->fd);
    718 		parsefile->fd = 0;
    719 	}
    720 }
    721