input.c revision 1.47 
1/*	$NetBSD: input.c,v 1.47 2016/01/04 03:00:24 christos 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
38static char sccsid[] = "@(#)input.c	8.3 (Berkeley) 6/9/95";
39#else
40__RCSID("$NetBSD: input.c,v 1.47 2016/01/04 03:00:24 christos 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
52/*
53 * This file implements the input routines used by the parser.
54 */
55
56#include "shell.h"
57#include "redir.h"
58#include "syntax.h"
59#include "input.h"
60#include "output.h"
61#include "options.h"
62#include "memalloc.h"
63#include "error.h"
64#include "alias.h"
65#include "parser.h"
66#include "myhistedit.h"
67
68#define EOF_NLEFT -99		/* value of parsenleft when EOF pushed back */
69
70MKINIT
71struct strpush {
72	struct strpush *prev;	/* preceding string on stack */
73	char *prevstring;
74	int prevnleft;
75	int prevlleft;
76	struct alias *ap;	/* if push was associated with an alias */
77};
78
79/*
80 * The parsefile structure pointed to by the global variable parsefile
81 * contains information about the current file being read.
82 */
83
84MKINIT
85struct parsefile {
86	struct parsefile *prev;	/* preceding file on stack */
87	int linno;		/* current line */
88	int fd;			/* file descriptor (or -1 if string) */
89	int nleft;		/* number of chars left in this line */
90	int lleft;		/* number of chars left in this buffer */
91	char *nextc;		/* next char in buffer */
92	char *buf;		/* input buffer */
93	struct strpush *strpush; /* for pushing strings at this level */
94	struct strpush basestrpush; /* so pushing one is fast */
95};
96
97
98int plinno = 1;			/* input line number */
99int parsenleft;			/* copy of parsefile->nleft */
100MKINIT int parselleft;		/* copy of parsefile->lleft */
101char *parsenextc;		/* copy of parsefile->nextc */
102MKINIT struct parsefile basepf;	/* top level input file */
103MKINIT char basebuf[BUFSIZ];	/* buffer for top level input file */
104struct parsefile *parsefile = &basepf;	/* current input file */
105int init_editline = 0;		/* editline library initialized? */
106int whichprompt;		/* 1 == PS1, 2 == PS2 */
107
108STATIC void pushfile(void);
109static int preadfd(void);
110
111#ifdef mkinit
112INCLUDE <stdio.h>
113INCLUDE "input.h"
114INCLUDE "error.h"
115
116INIT {
117	basepf.nextc = basepf.buf = basebuf;
118}
119
120RESET {
121	if (exception != EXSHELLPROC)
122		parselleft = parsenleft = 0;	/* clear input buffer */
123	popallfiles();
124}
125
126SHELLPROC {
127	popallfiles();
128}
129#endif
130
131
132/*
133 * Read a line from the script.
134 */
135
136char *
137pfgets(char *line, int len)
138{
139	char *p = line;
140	int nleft = len;
141	int c;
142
143	while (--nleft > 0) {
144		c = pgetc_macro();
145		if (c == PEOF) {
146			if (p == line)
147				return NULL;
148			break;
149		}
150		*p++ = c;
151		if (c == '\n')
152			break;
153	}
154	*p = '\0';
155	return line;
156}
157
158
159
160/*
161 * Read a character from the script, returning PEOF on end of file.
162 * Nul characters in the input are silently discarded.
163 */
164
165int
166pgetc(void)
167{
168	return pgetc_macro();
169}
170
171
172static int
173preadfd(void)
174{
175	int nr;
176	char *buf =  parsefile->buf;
177	parsenextc = buf;
178
179retry:
180#ifndef SMALL
181	if (parsefile->fd == 0 && el) {
182		static const char *rl_cp;
183		static int el_len;
184
185		if (rl_cp == NULL)
186			rl_cp = el_gets(el, &el_len);
187		if (rl_cp == NULL)
188			nr = el_len == 0 ? 0 : -1;
189		else {
190			nr = el_len;
191			if (nr > BUFSIZ - 8)
192				nr = BUFSIZ - 8;
193			memcpy(buf, rl_cp, nr);
194			if (nr != el_len) {
195				el_len -= nr;
196				rl_cp += nr;
197			} else
198				rl_cp = 0;
199		}
200
201	} else
202#endif
203		nr = read(parsefile->fd, buf, BUFSIZ - 8);
204
205
206	if (nr <= 0) {
207                if (nr < 0) {
208                        if (errno == EINTR)
209                                goto retry;
210                        if (parsefile->fd == 0 && errno == EWOULDBLOCK) {
211                                int flags = fcntl(0, F_GETFL, 0);
212                                if (flags >= 0 && flags & O_NONBLOCK) {
213                                        flags &=~ O_NONBLOCK;
214                                        if (fcntl(0, F_SETFL, flags) >= 0) {
215						out2str("sh: turning off NDELAY mode\n");
216                                                goto retry;
217                                        }
218                                }
219                        }
220                }
221                nr = -1;
222	}
223	return nr;
224}
225
226/*
227 * Refill the input buffer and return the next input character:
228 *
229 * 1) If a string was pushed back on the input, pop it;
230 * 2) If an EOF was pushed back (parsenleft == EOF_NLEFT) or we are reading
231 *    from a string so we can't refill the buffer, return EOF.
232 * 3) If the is more stuff in this buffer, use it else call read to fill it.
233 * 4) Process input up to the next newline, deleting nul characters.
234 */
235
236int
237preadbuffer(void)
238{
239	char *p, *q;
240	int more;
241#ifndef SMALL
242	int something;
243#endif
244	char savec;
245
246	if (parsefile->strpush) {
247		popstring();
248		if (--parsenleft >= 0)
249			return (*parsenextc++);
250	}
251	if (parsenleft == EOF_NLEFT || parsefile->buf == NULL)
252		return PEOF;
253	flushout(&output);
254	flushout(&errout);
255
256again:
257	if (parselleft <= 0) {
258		if ((parselleft = preadfd()) == -1) {
259			parselleft = parsenleft = EOF_NLEFT;
260			return PEOF;
261		}
262	}
263
264	q = p = parsenextc;
265
266	/* delete nul characters */
267#ifndef SMALL
268	something = 0;
269#endif
270	for (more = 1; more;) {
271		switch (*p) {
272		case '\0':
273			p++;	/* Skip nul */
274			goto check;
275
276		case '\t':
277		case ' ':
278			break;
279
280		case '\n':
281			parsenleft = q - parsenextc;
282			more = 0; /* Stop processing here */
283			break;
284
285		default:
286#ifndef SMALL
287			something = 1;
288#endif
289			break;
290		}
291
292		*q++ = *p++;
293check:
294		if (--parselleft <= 0) {
295			parsenleft = q - parsenextc - 1;
296			if (parsenleft < 0)
297				goto again;
298			*q = '\0';
299			more = 0;
300		}
301	}
302
303	savec = *q;
304	*q = '\0';
305
306#ifndef SMALL
307	if (parsefile->fd == 0 && hist && something) {
308		HistEvent he;
309		INTOFF;
310		history(hist, &he, whichprompt == 1? H_ENTER : H_APPEND,
311		    parsenextc);
312		INTON;
313	}
314#endif
315
316	if (vflag) {
317		out2str(parsenextc);
318		flushout(out2);
319	}
320
321	*q = savec;
322
323	return *parsenextc++;
324}
325
326/*
327 * Undo the last call to pgetc.  Only one character may be pushed back.
328 * PEOF may be pushed back.
329 */
330
331void
332pungetc(void)
333{
334	parsenleft++;
335	parsenextc--;
336}
337
338/*
339 * Push a string back onto the input at this current parsefile level.
340 * We handle aliases this way.
341 */
342void
343pushstring(char *s, int len, void *ap)
344{
345	struct strpush *sp;
346
347	INTOFF;
348/*debugprintf("*** calling pushstring: %s, %d\n", s, len);*/
349	if (parsefile->strpush) {
350		sp = ckmalloc(sizeof (struct strpush));
351		sp->prev = parsefile->strpush;
352		parsefile->strpush = sp;
353	} else
354		sp = parsefile->strpush = &(parsefile->basestrpush);
355	sp->prevstring = parsenextc;
356	sp->prevnleft = parsenleft;
357	sp->prevlleft = parselleft;
358	sp->ap = (struct alias *)ap;
359	if (ap)
360		((struct alias *)ap)->flag |= ALIASINUSE;
361	parsenextc = s;
362	parsenleft = len;
363	INTON;
364}
365
366void
367popstring(void)
368{
369	struct strpush *sp = parsefile->strpush;
370
371	INTOFF;
372	parsenextc = sp->prevstring;
373	parsenleft = sp->prevnleft;
374	parselleft = sp->prevlleft;
375/*debugprintf("*** calling popstring: restoring to '%s'\n", parsenextc);*/
376	if (sp->ap)
377		sp->ap->flag &= ~ALIASINUSE;
378	parsefile->strpush = sp->prev;
379	if (sp != &(parsefile->basestrpush))
380		ckfree(sp);
381	INTON;
382}
383
384/*
385 * Set the input to take input from a file.  If push is set, push the
386 * old input onto the stack first.
387 */
388
389void
390setinputfile(const char *fname, int push)
391{
392	unsigned char magic[4];
393	int fd;
394	int fd2;
395
396	INTOFF;
397	if ((fd = open(fname, O_RDONLY)) < 0)
398		error("Can't open %s", fname);
399
400	/* Since the message "Syntax error: "(" unexpected" is not very
401	 * helpful, we check if the file starts with the ELF magic to
402	 * avoid that message. The first lseek tries to make sure that
403	 * we can later rewind the file.
404	 */
405	if (lseek(fd, 0, SEEK_SET) == 0) {
406		if (read(fd, magic, 4) == 4) {
407			if (memcmp(magic, "\177ELF", 4) == 0)
408				error("Cannot execute ELF binary %s", fname);
409		}
410		if (lseek(fd, 0, SEEK_SET) != 0)
411			error("Cannot rewind the file %s", fname);
412	}
413
414	if (fd < 10) {
415		fd2 = copyfd(fd, 10, 0, 0);
416		close(fd);
417		if (fd2 < 0)
418			error("Out of file descriptors");
419		fd = fd2;
420	}
421	setinputfd(fd, push);
422	INTON;
423}
424
425
426/*
427 * Like setinputfile, but takes an open file descriptor.  Call this with
428 * interrupts off.
429 */
430
431void
432setinputfd(int fd, int push)
433{
434	(void) fcntl(fd, F_SETFD, FD_CLOEXEC);
435	if (push) {
436		pushfile();
437		parsefile->buf = ckmalloc(BUFSIZ);
438	}
439	if (parsefile->fd > 0)
440		close(parsefile->fd);
441	parsefile->fd = fd;
442	if (parsefile->buf == NULL)
443		parsefile->buf = ckmalloc(BUFSIZ);
444	parselleft = parsenleft = 0;
445	plinno = 1;
446}
447
448
449/*
450 * Like setinputfile, but takes input from a string.
451 */
452
453void
454setinputstring(char *string, int push)
455{
456	INTOFF;
457	if (push)
458		pushfile();
459	parsenextc = string;
460	parselleft = parsenleft = strlen(string);
461	parsefile->buf = NULL;
462	plinno = 1;
463	INTON;
464}
465
466
467
468/*
469 * To handle the "." command, a stack of input files is used.  Pushfile
470 * adds a new entry to the stack and popfile restores the previous level.
471 */
472
473STATIC void
474pushfile(void)
475{
476	struct parsefile *pf;
477
478	parsefile->nleft = parsenleft;
479	parsefile->lleft = parselleft;
480	parsefile->nextc = parsenextc;
481	parsefile->linno = plinno;
482	pf = (struct parsefile *)ckmalloc(sizeof (struct parsefile));
483	pf->prev = parsefile;
484	pf->fd = -1;
485	pf->strpush = NULL;
486	pf->basestrpush.prev = NULL;
487	parsefile = pf;
488}
489
490
491void
492popfile(void)
493{
494	struct parsefile *pf = parsefile;
495
496	INTOFF;
497	if (pf->fd >= 0)
498		close(pf->fd);
499	if (pf->buf)
500		ckfree(pf->buf);
501	while (pf->strpush)
502		popstring();
503	parsefile = pf->prev;
504	ckfree(pf);
505	parsenleft = parsefile->nleft;
506	parselleft = parsefile->lleft;
507	parsenextc = parsefile->nextc;
508	plinno = parsefile->linno;
509	INTON;
510}
511
512
513/*
514 * Return to top level.
515 */
516
517void
518popallfiles(void)
519{
520	while (parsefile != &basepf)
521		popfile();
522}
523
524
525
526/*
527 * Close the file(s) that the shell is reading commands from.  Called
528 * after a fork is done.
529 *
530 * Takes one arg, vfork, which tells it to not modify its global vars
531 * as it is still running in the parent.
532 *
533 * This code is (probably) unnecessary as the 'close on exec' flag is
534 * set and should be enough.  In the vfork case it is definitely wrong
535 * to close the fds as another fork() may be done later to feed data
536 * from a 'here' document into a pipe and we don't want to close the
537 * pipe!
538 */
539
540void
541closescript(int vforked)
542{
543	if (vforked)
544		return;
545	popallfiles();
546	if (parsefile->fd > 0) {
547		close(parsefile->fd);
548		parsefile->fd = 0;
549	}
550}
551