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 * 4. 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 MKINIT 68 struct strpush { 69 struct strpush *prev; /* preceding string on stack */ 70 char *prevstring; 71 int prevnleft; 72 int prevlleft; 73 struct alias *ap; /* if push was associated with an alias */ 74 }; 75 76 /* 77 * The parsefile structure pointed to by the global variable parsefile 78 * contains information about the current file being read. 79 */ 80 81 MKINIT 82 struct parsefile { 83 struct parsefile *prev; /* preceding file on stack */ 84 int linno; /* current line */ 85 int fd; /* file descriptor (or -1 if string) */ 86 int nleft; /* number of chars left in this line */ 87 int lleft; /* number of lines left in this buffer */ 88 char *nextc; /* next char in buffer */ 89 char *buf; /* input buffer */ 90 struct strpush *strpush; /* for pushing strings at this level */ 91 struct strpush basestrpush; /* so pushing one is fast */ 92 }; 93 94 95 int plinno = 1; /* input line number */ 96 MKINIT int parsenleft; /* copy of parsefile->nleft */ 97 MKINIT int parselleft; /* copy of parsefile->lleft */ 98 char *parsenextc; /* copy of parsefile->nextc */ 99 MKINIT struct parsefile basepf; /* top level input file */ 100 char basebuf[BUFSIZ]; /* buffer for top level input file */ 101 STATIC struct parsefile *parsefile = &basepf; /* current input file */ 102 int init_editline = 0; /* editline library initialized? */ 103 int whichprompt; /* 1 == PS1, 2 == PS2 */ 104 105 EditLine *el; /* cookie for editline package */ 106 107 STATIC void pushfile(void); 108 static int preadfd(void); 109 110 #ifdef mkinit 111 INCLUDE "input.h" 112 INCLUDE "error.h" 113 114 INIT { 115 extern char basebuf[]; 116 117 basepf.nextc = basepf.buf = basebuf; 118 } 119 120 RESET { 121 if (exception != EXSHELLPROC) 122 parselleft = parsenleft = 0; /* clear input buffer */ 123 popallfiles(); 124 } 125 126 SHELLPROC { 127 popallfiles(); 128 } 129 #endif 130 131 132 /* 133 * Read a line from the script. 134 */ 135 136 char * 137 pfgets(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 165 int 166 pgetc(void) 167 { 168 return pgetc_macro(); 169 } 170 171 172 static int 173 preadfd(void) 174 { 175 int nr; 176 parsenextc = parsefile->buf; 177 178 #ifndef NO_HISTORY 179 if (el != NULL && gotwinch) { 180 gotwinch = 0; 181 el_resize(el); 182 } 183 #endif 184 retry: 185 #ifndef NO_HISTORY 186 if (parsefile->fd == 0 && el) { 187 static const char *rl_cp; 188 static int el_len; 189 190 if (rl_cp == NULL) 191 rl_cp = el_gets(el, &el_len); 192 if (rl_cp == NULL) 193 nr = 0; 194 else { 195 nr = el_len; 196 if (nr > BUFSIZ - 1) 197 nr = BUFSIZ - 1; 198 memcpy(parsenextc, rl_cp, nr); 199 if (nr != el_len) { 200 el_len -= nr; 201 rl_cp += nr; 202 } else 203 rl_cp = NULL; 204 } 205 } else 206 #endif 207 nr = read(parsefile->fd, parsenextc, BUFSIZ - 1); 208 209 if (nr <= 0) { 210 if (nr < 0) { 211 if (errno == EINTR) 212 goto retry; 213 if (parsefile->fd == 0 && errno == EWOULDBLOCK) { 214 int flags = fcntl(0, F_GETFL, 0); 215 if (flags >= 0 && flags & O_NONBLOCK) { 216 flags &=~ O_NONBLOCK; 217 if (fcntl(0, F_SETFL, flags) >= 0) { 218 out2str("sh: turning off NDELAY mode\n"); 219 goto retry; 220 } 221 } 222 } 223 } 224 nr = -1; 225 } 226 return nr; 227 } 228 229 /* 230 * Refill the input buffer and return the next input character: 231 * 232 * 1) If a string was pushed back on the input, pop it; 233 * 2) If an EOF was pushed back (parsenleft == EOF_NLEFT) or we are reading 234 * from a string so we can't refill the buffer, return EOF. 235 * 3) If there is more in this buffer, use it else call read to fill it. 236 * 4) Process input up to the next newline, deleting nul characters. 237 */ 238 239 int 240 preadbuffer(void) 241 { 242 char *p, *q; 243 int more; 244 int something; 245 char savec; 246 247 if (parsefile->strpush) { 248 popstring(); 249 if (--parsenleft >= 0) 250 return (*parsenextc++); 251 } 252 if (parsenleft == EOF_NLEFT || parsefile->buf == NULL) 253 return PEOF; 254 flushout(&output); 255 flushout(&errout); 256 257 again: 258 if (parselleft <= 0) { 259 if ((parselleft = preadfd()) == -1) { 260 parselleft = parsenleft = EOF_NLEFT; 261 return PEOF; 262 } 263 } 264 265 q = p = parsenextc; 266 267 /* delete nul characters */ 268 something = 0; 269 for (more = 1; more;) { 270 switch (*p) { 271 case '\0': 272 p++; /* Skip nul */ 273 goto check; 274 275 case '\t': 276 case ' ': 277 break; 278 279 case '\n': 280 parsenleft = q - parsenextc; 281 more = 0; /* Stop processing here */ 282 break; 283 284 default: 285 something = 1; 286 break; 287 } 288 289 *q++ = *p++; 290 check: 291 if (--parselleft <= 0) { 292 parsenleft = q - parsenextc - 1; 293 if (parsenleft < 0) 294 goto again; 295 *q = '\0'; 296 more = 0; 297 } 298 } 299 300 savec = *q; 301 *q = '\0'; 302 303 #ifndef NO_HISTORY 304 if (parsefile->fd == 0 && hist && something) { 305 HistEvent he; 306 INTOFF; 307 history(hist, &he, whichprompt == 1 ? H_ENTER : H_ADD, 308 parsenextc); 309 INTON; 310 } 311 #endif 312 313 if (vflag) { 314 out2str(parsenextc); 315 flushout(out2); 316 } 317 318 *q = savec; 319 320 return *parsenextc++; 321 } 322 323 /* 324 * Undo the last call to pgetc. Only one character may be pushed back. 325 * PEOF may be pushed back. 326 */ 327 328 void 329 pungetc(void) 330 { 331 parsenleft++; 332 parsenextc--; 333 } 334 335 /* 336 * Push a string back onto the input at this current parsefile level. 337 * We handle aliases this way. 338 */ 339 void 340 pushstring(char *s, int len, void *ap) 341 { 342 struct strpush *sp; 343 344 INTOFF; 345 /*dprintf("*** calling pushstring: %s, %d\n", s, len);*/ 346 if (parsefile->strpush) { 347 sp = ckmalloc(sizeof (struct strpush)); 348 sp->prev = parsefile->strpush; 349 parsefile->strpush = sp; 350 } else 351 sp = parsefile->strpush = &(parsefile->basestrpush); 352 sp->prevstring = parsenextc; 353 sp->prevnleft = parsenleft; 354 sp->prevlleft = parselleft; 355 sp->ap = (struct alias *)ap; 356 if (ap) 357 ((struct alias *)ap)->flag |= ALIASINUSE; 358 parsenextc = s; 359 parsenleft = len; 360 INTON; 361 } 362 363 void 364 popstring(void) 365 { 366 struct strpush *sp = parsefile->strpush; 367 368 INTOFF; 369 parsenextc = sp->prevstring; 370 parsenleft = sp->prevnleft; 371 parselleft = sp->prevlleft; 372 /*dprintf("*** calling popstring: restoring to '%s'\n", parsenextc);*/ 373 if (sp->ap) 374 sp->ap->flag &= ~ALIASINUSE; 375 parsefile->strpush = sp->prev; 376 if (sp != &(parsefile->basestrpush)) 377 ckfree(sp); 378 INTON; 379 } 380 381 /* 382 * Set the input to take input from a file. If push is set, push the 383 * old input onto the stack first. 384 */ 385 386 void 387 setinputfile(char *fname, int push) 388 { 389 int fd; 390 int fd2; 391 392 INTOFF; 393 if ((fd = open(fname, O_RDONLY)) < 0) 394 error("Can't open %s: %s", fname, strerror(errno)); 395 if (fd < 10) { 396 fd2 = fcntl(fd, F_DUPFD, 10); 397 close(fd); 398 if (fd2 < 0) 399 error("Out of file descriptors"); 400 fd = fd2; 401 } 402 setinputfd(fd, push); 403 INTON; 404 } 405 406 407 /* 408 * Like setinputfile, but takes an open file descriptor. Call this with 409 * interrupts off. 410 */ 411 412 void 413 setinputfd(int fd, int push) 414 { 415 (void)fcntl(fd, F_SETFD, FD_CLOEXEC); 416 if (push) { 417 pushfile(); 418 parsefile->buf = ckmalloc(BUFSIZ); 419 } 420 if (parsefile->fd > 0) 421 close(parsefile->fd); 422 parsefile->fd = fd; 423 if (parsefile->buf == NULL) 424 parsefile->buf = ckmalloc(BUFSIZ); 425 parselleft = parsenleft = 0; 426 plinno = 1; 427 } 428 429 430 /* 431 * Like setinputfile, but takes input from a string. 432 */ 433 434 void 435 setinputstring(char *string, int push) 436 { 437 INTOFF; 438 if (push) 439 pushfile(); 440 parsenextc = string; 441 parselleft = parsenleft = strlen(string); 442 parsefile->buf = NULL; 443 plinno = 1; 444 INTON; 445 } 446 447 448 449 /* 450 * To handle the "." command, a stack of input files is used. Pushfile 451 * adds a new entry to the stack and popfile restores the previous level. 452 */ 453 454 STATIC void 455 pushfile(void) 456 { 457 struct parsefile *pf; 458 459 parsefile->nleft = parsenleft; 460 parsefile->lleft = parselleft; 461 parsefile->nextc = parsenextc; 462 parsefile->linno = plinno; 463 pf = (struct parsefile *)ckmalloc(sizeof (struct parsefile)); 464 pf->prev = parsefile; 465 pf->fd = -1; 466 pf->strpush = NULL; 467 pf->basestrpush.prev = NULL; 468 parsefile = pf; 469 } 470 471 472 void 473 popfile(void) 474 { 475 struct parsefile *pf = parsefile; 476 477 INTOFF; 478 if (pf->fd >= 0) 479 close(pf->fd); 480 if (pf->buf) 481 ckfree(pf->buf); 482 while (pf->strpush) 483 popstring(); 484 parsefile = pf->prev; 485 ckfree(pf); 486 parsenleft = parsefile->nleft; 487 parselleft = parsefile->lleft; 488 parsenextc = parsefile->nextc; 489 plinno = parsefile->linno; 490 INTON; 491 } 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