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