xref: /freebsd/bin/sh/input.c (revision e17f5b1d) 
1 /*-
2  * Copyright (c) 1991, 1993
3  *	The Regents of the University of California.  All rights reserved.
4  *
5  * This code is derived from software contributed to Berkeley by
6  * Kenneth Almquist.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. Neither the name of the University nor the names of its contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  */
32 
33 #ifndef lint
34 #if 0
35 static char sccsid[] = "@(#)input.c	8.3 (Berkeley) 6/9/95";
36 #endif
37 #endif /* not lint */
38 #include <sys/cdefs.h>
39 __FBSDID("$FreeBSD$");
40 
41 #include <stdio.h>	/* defines BUFSIZ */
42 #include <fcntl.h>
43 #include <errno.h>
44 #include <unistd.h>
45 #include <stdlib.h>
46 #include <string.h>
47 
48 /*
49  * This file implements the input routines used by the parser.
50  */
51 
52 #include "shell.h"
53 #include "redir.h"
54 #include "syntax.h"
55 #include "input.h"
56 #include "output.h"
57 #include "options.h"
58 #include "memalloc.h"
59 #include "error.h"
60 #include "alias.h"
61 #include "parser.h"
62 #include "myhistedit.h"
63 #include "trap.h"
64 
65 #define EOF_NLEFT -99		/* value of parsenleft when EOF pushed back */
66 
67 struct strpush {
68 	struct strpush *prev;	/* preceding string on stack */
69 	const char *prevstring;
70 	int prevnleft;
71 	int prevlleft;
72 	struct alias *ap;	/* if push was associated with an alias */
73 };
74 
75 /*
76  * The parsefile structure pointed to by the global variable parsefile
77  * contains information about the current file being read.
78  */
79 
80 struct parsefile {
81 	struct parsefile *prev;	/* preceding file on stack */
82 	int linno;		/* current line */
83 	int fd;			/* file descriptor (or -1 if string) */
84 	int nleft;		/* number of chars left in this line */
85 	int lleft;		/* number of lines left in this buffer */
86 	const char *nextc;	/* next char in buffer */
87 	char *buf;		/* input buffer */
88 	struct strpush *strpush; /* for pushing strings at this level */
89 	struct strpush basestrpush; /* so pushing one is fast */
90 };
91 
92 
93 int plinno = 1;			/* input line number */
94 int parsenleft;			/* copy of parsefile->nleft */
95 static int parselleft;		/* copy of parsefile->lleft */
96 const char *parsenextc;		/* copy of parsefile->nextc */
97 static char basebuf[BUFSIZ + 1];/* buffer for top level input file */
98 static struct parsefile basepf = {	/* top level input file */
99 	.nextc = basebuf,
100 	.buf = basebuf
101 };
102 static struct parsefile *parsefile = &basepf;	/* current input file */
103 int whichprompt;		/* 1 == PS1, 2 == PS2 */
104 
105 static void pushfile(void);
106 static int preadfd(void);
107 static void popstring(void);
108 
109 void
110 resetinput(void)
111 {
112 	popallfiles();
113 	parselleft = parsenleft = 0;	/* clear input buffer */
114 }
115 
116 
117 
118 /*
119  * Read a character from the script, returning PEOF on end of file.
120  * Nul characters in the input are silently discarded.
121  */
122 
123 int
124 pgetc(void)
125 {
126 	return pgetc_macro();
127 }
128 
129 
130 static int
131 preadfd(void)
132 {
133 	int nr;
134 	parsenextc = parsefile->buf;
135 
136 retry:
137 #ifndef NO_HISTORY
138 	if (parsefile->fd == 0 && el) {
139 		static const char *rl_cp;
140 		static int el_len;
141 
142 		if (rl_cp == NULL) {
143 			el_resize(el);
144 			rl_cp = el_gets(el, &el_len);
145 		}
146 		if (rl_cp == NULL)
147 			nr = el_len == 0 ? 0 : -1;
148 		else {
149 			nr = el_len;
150 			if (nr > BUFSIZ)
151 				nr = BUFSIZ;
152 			memcpy(parsefile->buf, rl_cp, nr);
153 			if (nr != el_len) {
154 				el_len -= nr;
155 				rl_cp += nr;
156 			} else
157 				rl_cp = NULL;
158 		}
159 	} else
160 #endif
161 		nr = read(parsefile->fd, parsefile->buf, BUFSIZ);
162 
163 	if (nr <= 0) {
164                 if (nr < 0) {
165                         if (errno == EINTR)
166                                 goto retry;
167                         if (parsefile->fd == 0 && errno == EWOULDBLOCK) {
168                                 int flags = fcntl(0, F_GETFL, 0);
169                                 if (flags >= 0 && flags & O_NONBLOCK) {
170                                         flags &=~ O_NONBLOCK;
171                                         if (fcntl(0, F_SETFL, flags) >= 0) {
172 						out2fmt_flush("sh: turning off NDELAY mode\n");
173                                                 goto retry;
174                                         }
175                                 }
176                         }
177                 }
178                 nr = -1;
179 	}
180 	return nr;
181 }
182 
183 /*
184  * Refill the input buffer and return the next input character:
185  *
186  * 1) If a string was pushed back on the input, pop it;
187  * 2) If an EOF was pushed back (parsenleft == EOF_NLEFT) or we are reading
188  *    from a string so we can't refill the buffer, return EOF.
189  * 3) If there is more in this buffer, use it else call read to fill it.
190  * 4) Process input up to the next newline, deleting nul characters.
191  */
192 
193 int
194 preadbuffer(void)
195 {
196 	char *p, *q, *r, *end;
197 	char savec;
198 
199 	while (parsefile->strpush) {
200 		/*
201 		 * Add a space to the end of an alias to ensure that the
202 		 * alias remains in use while parsing its last word.
203 		 * This avoids alias recursions.
204 		 */
205 		if (parsenleft == -1 && parsefile->strpush->ap != NULL)
206 			return ' ';
207 		popstring();
208 		if (--parsenleft >= 0)
209 			return (*parsenextc++);
210 	}
211 	if (parsenleft == EOF_NLEFT || parsefile->buf == NULL)
212 		return PEOF;
213 
214 again:
215 	if (parselleft <= 0) {
216 		if ((parselleft = preadfd()) == -1) {
217 			parselleft = parsenleft = EOF_NLEFT;
218 			return PEOF;
219 		}
220 	}
221 
222 	p = parsefile->buf + (parsenextc - parsefile->buf);
223 	end = p + parselleft;
224 	*end = '\0';
225 	q = strchrnul(p, '\n');
226 	if (q != end && *q == '\0') {
227 		/* delete nul characters */
228 		for (r = q; q != end; q++) {
229 			if (*q != '\0')
230 				*r++ = *q;
231 		}
232 		parselleft -= end - r;
233 		if (parselleft == 0)
234 			goto again;
235 		end = p + parselleft;
236 		*end = '\0';
237 		q = strchrnul(p, '\n');
238 	}
239 	if (q == end) {
240 		parsenleft = parselleft;
241 		parselleft = 0;
242 	} else /* *q == '\n' */ {
243 		q++;
244 		parsenleft = q - parsenextc;
245 		parselleft -= parsenleft;
246 	}
247 	parsenleft--;
248 
249 	savec = *q;
250 	*q = '\0';
251 
252 #ifndef NO_HISTORY
253 	if (parsefile->fd == 0 && hist &&
254 	    parsenextc[strspn(parsenextc, " \t\n")] != '\0') {
255 		HistEvent he;
256 		INTOFF;
257 		history(hist, &he, whichprompt == 1 ? H_ENTER : H_ADD,
258 		    parsenextc);
259 		INTON;
260 	}
261 #endif
262 
263 	if (vflag) {
264 		out2str(parsenextc);
265 		flushout(out2);
266 	}
267 
268 	*q = savec;
269 
270 	return *parsenextc++;
271 }
272 
273 /*
274  * Returns if we are certain we are at EOF. Does not cause any more input
275  * to be read from the outside world.
276  */
277 
278 int
279 preadateof(void)
280 {
281 	if (parsenleft > 0)
282 		return 0;
283 	if (parsefile->strpush)
284 		return 0;
285 	if (parsenleft == EOF_NLEFT || parsefile->buf == NULL)
286 		return 1;
287 	return 0;
288 }
289 
290 /*
291  * Undo the last call to pgetc.  Only one character may be pushed back.
292  * PEOF may be pushed back.
293  */
294 
295 void
296 pungetc(void)
297 {
298 	parsenleft++;
299 	parsenextc--;
300 }
301 
302 /*
303  * Push a string back onto the input at this current parsefile level.
304  * We handle aliases this way.
305  */
306 void
307 pushstring(const char *s, int len, struct alias *ap)
308 {
309 	struct strpush *sp;
310 
311 	INTOFF;
312 /*out2fmt_flush("*** calling pushstring: %s, %d\n", s, len);*/
313 	if (parsefile->strpush) {
314 		sp = ckmalloc(sizeof (struct strpush));
315 		sp->prev = parsefile->strpush;
316 		parsefile->strpush = sp;
317 	} else
318 		sp = parsefile->strpush = &(parsefile->basestrpush);
319 	sp->prevstring = parsenextc;
320 	sp->prevnleft = parsenleft;
321 	sp->prevlleft = parselleft;
322 	sp->ap = ap;
323 	if (ap)
324 		ap->flag |= ALIASINUSE;
325 	parsenextc = s;
326 	parsenleft = len;
327 	INTON;
328 }
329 
330 static void
331 popstring(void)
332 {
333 	struct strpush *sp = parsefile->strpush;
334 
335 	INTOFF;
336 	if (sp->ap) {
337 		if (parsenextc != sp->ap->val &&
338 		    (parsenextc[-1] == ' ' || parsenextc[-1] == '\t'))
339 			forcealias();
340 		sp->ap->flag &= ~ALIASINUSE;
341 	}
342 	parsenextc = sp->prevstring;
343 	parsenleft = sp->prevnleft;
344 	parselleft = sp->prevlleft;
345 /*out2fmt_flush("*** calling popstring: restoring to '%s'\n", parsenextc);*/
346 	parsefile->strpush = sp->prev;
347 	if (sp != &(parsefile->basestrpush))
348 		ckfree(sp);
349 	INTON;
350 }
351 
352 /*
353  * Set the input to take input from a file.  If push is set, push the
354  * old input onto the stack first.
355  */
356 
357 void
358 setinputfile(const char *fname, int push)
359 {
360 	int e;
361 	int fd;
362 	int fd2;
363 
364 	INTOFF;
365 	if ((fd = open(fname, O_RDONLY | O_CLOEXEC)) < 0) {
366 		e = errno;
367 		errorwithstatus(e == ENOENT || e == ENOTDIR ? 127 : 126,
368 		    "cannot open %s: %s", fname, strerror(e));
369 	}
370 	if (fd < 10) {
371 		fd2 = fcntl(fd, F_DUPFD_CLOEXEC, 10);
372 		close(fd);
373 		if (fd2 < 0)
374 			error("Out of file descriptors");
375 		fd = fd2;
376 	}
377 	setinputfd(fd, push);
378 	INTON;
379 }
380 
381 
382 /*
383  * Like setinputfile, but takes an open file descriptor (which should have
384  * its FD_CLOEXEC flag already set).  Call this with interrupts off.
385  */
386 
387 void
388 setinputfd(int fd, int push)
389 {
390 	if (push) {
391 		pushfile();
392 		parsefile->buf = ckmalloc(BUFSIZ + 1);
393 	}
394 	if (parsefile->fd > 0)
395 		close(parsefile->fd);
396 	parsefile->fd = fd;
397 	if (parsefile->buf == NULL)
398 		parsefile->buf = ckmalloc(BUFSIZ + 1);
399 	parselleft = parsenleft = 0;
400 	plinno = 1;
401 }
402 
403 
404 /*
405  * Like setinputfile, but takes input from a string.
406  */
407 
408 void
409 setinputstring(const char *string, int push)
410 {
411 	INTOFF;
412 	if (push)
413 		pushfile();
414 	parsenextc = string;
415 	parselleft = parsenleft = strlen(string);
416 	parsefile->buf = NULL;
417 	plinno = 1;
418 	INTON;
419 }
420 
421 
422 
423 /*
424  * To handle the "." command, a stack of input files is used.  Pushfile
425  * adds a new entry to the stack and popfile restores the previous level.
426  */
427 
428 static void
429 pushfile(void)
430 {
431 	struct parsefile *pf;
432 
433 	parsefile->nleft = parsenleft;
434 	parsefile->lleft = parselleft;
435 	parsefile->nextc = parsenextc;
436 	parsefile->linno = plinno;
437 	pf = (struct parsefile *)ckmalloc(sizeof (struct parsefile));
438 	pf->prev = parsefile;
439 	pf->fd = -1;
440 	pf->strpush = NULL;
441 	pf->basestrpush.prev = NULL;
442 	parsefile = pf;
443 }
444 
445 
446 void
447 popfile(void)
448 {
449 	struct parsefile *pf = parsefile;
450 
451 	INTOFF;
452 	if (pf->fd >= 0)
453 		close(pf->fd);
454 	if (pf->buf)
455 		ckfree(pf->buf);
456 	while (pf->strpush)
457 		popstring();
458 	parsefile = pf->prev;
459 	ckfree(pf);
460 	parsenleft = parsefile->nleft;
461 	parselleft = parsefile->lleft;
462 	parsenextc = parsefile->nextc;
463 	plinno = parsefile->linno;
464 	INTON;
465 }
466 
467 
468 /*
469  * Return current file (to go back to it later using popfilesupto()).
470  */
471 
472 struct parsefile *
473 getcurrentfile(void)
474 {
475 	return parsefile;
476 }
477 
478 
479 /*
480  * Pop files until the given file is on top again. Useful for regular
481  * builtins that read shell commands from files or strings.
482  * If the given file is not an active file, an error is raised.
483  */
484 
485 void
486 popfilesupto(struct parsefile *file)
487 {
488 	while (parsefile != file && parsefile != &basepf)
489 		popfile();
490 	if (parsefile != file)
491 		error("popfilesupto() misused");
492 }
493 
494 /*
495  * Return to top level.
496  */
497 
498 void
499 popallfiles(void)
500 {
501 	while (parsefile != &basepf)
502 		popfile();
503 }
504 
505 
506 
507 /*
508  * Close the file(s) that the shell is reading commands from.  Called
509  * after a fork is done.
510  */
511 
512 void
513 closescript(void)
514 {
515 	popallfiles();
516 	if (parsefile->fd > 0) {
517 		close(parsefile->fd);
518 		parsefile->fd = 0;
519 	}
520 }
521