input.c revision 213811
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 35static char sccsid[] = "@(#)input.c 8.3 (Berkeley) 6/9/95"; 36#endif 37#endif /* not lint */ 38#include <sys/cdefs.h> 39__FBSDID("$FreeBSD: head/bin/sh/input.c 213811 2010-10-13 22:18:03Z obrien $"); 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 67MKINIT 68struct 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 81MKINIT 82struct 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 95int plinno = 1; /* input line number */ 96int parsenleft; /* copy of parsefile->nleft */ 97MKINIT int parselleft; /* copy of parsefile->lleft */ 98char *parsenextc; /* copy of parsefile->nextc */ 99MKINIT struct parsefile basepf; /* top level input file */ 100char basebuf[BUFSIZ]; /* buffer for top level input file */ 101static struct parsefile *parsefile = &basepf; /* current input file */ 102int init_editline = 0; /* editline library initialized? */ 103int whichprompt; /* 1 == PS1, 2 == PS2 */ 104 105EditLine *el; /* cookie for editline package */ 106 107static void pushfile(void); 108static int preadfd(void); 109 110#ifdef mkinit 111INCLUDE "input.h" 112INCLUDE "error.h" 113 114MKINIT char basebuf[]; 115 116INIT { 117 basepf.nextc = basepf.buf = basebuf; 118} 119 120RESET { 121 popallfiles(); 122 if (exception != EXSHELLPROC) 123 parselleft = parsenleft = 0; /* clear input buffer */ 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 parsenextc = parsefile->buf; 177 178#ifndef NO_HISTORY 179 if (el != NULL && gotwinch) { 180 gotwinch = 0; 181 el_resize(el); 182 } 183#endif 184retry: 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 out2fmt_flush("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 239int 240preadbuffer(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 257again: 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++; 290check: 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 * Returns if we are certain we are at EOF. Does not cause any more input 325 * to be read from the outside world. 326 */ 327 328int 329preadateof(void) 330{ 331 if (parsenleft > 0) 332 return 0; 333 if (parsefile->strpush) 334 return 0; 335 if (parsenleft == EOF_NLEFT || parsefile->buf == NULL) 336 return 1; 337 return 0; 338} 339 340/* 341 * Undo the last call to pgetc. Only one character may be pushed back. 342 * PEOF may be pushed back. 343 */ 344 345void 346pungetc(void) 347{ 348 parsenleft++; 349 parsenextc--; 350} 351 352/* 353 * Push a string back onto the input at this current parsefile level. 354 * We handle aliases this way. 355 */ 356void 357pushstring(char *s, int len, void *ap) 358{ 359 struct strpush *sp; 360 361 INTOFF; 362/*out2fmt_flush("*** calling pushstring: %s, %d\n", s, len);*/ 363 if (parsefile->strpush) { 364 sp = ckmalloc(sizeof (struct strpush)); 365 sp->prev = parsefile->strpush; 366 parsefile->strpush = sp; 367 } else 368 sp = parsefile->strpush = &(parsefile->basestrpush); 369 sp->prevstring = parsenextc; 370 sp->prevnleft = parsenleft; 371 sp->prevlleft = parselleft; 372 sp->ap = (struct alias *)ap; 373 if (ap) 374 ((struct alias *)ap)->flag |= ALIASINUSE; 375 parsenextc = s; 376 parsenleft = len; 377 INTON; 378} 379 380void 381popstring(void) 382{ 383 struct strpush *sp = parsefile->strpush; 384 385 INTOFF; 386 parsenextc = sp->prevstring; 387 parsenleft = sp->prevnleft; 388 parselleft = sp->prevlleft; 389/*out2fmt_flush("*** calling popstring: restoring to '%s'\n", parsenextc);*/ 390 if (sp->ap) 391 sp->ap->flag &= ~ALIASINUSE; 392 parsefile->strpush = sp->prev; 393 if (sp != &(parsefile->basestrpush)) 394 ckfree(sp); 395 INTON; 396} 397 398/* 399 * Set the input to take input from a file. If push is set, push the 400 * old input onto the stack first. 401 */ 402 403void 404setinputfile(const char *fname, int push) 405{ 406 int fd; 407 int fd2; 408 409 INTOFF; 410 if ((fd = open(fname, O_RDONLY)) < 0) 411 error("Can't open %s: %s", fname, strerror(errno)); 412 if (fd < 10) { 413 fd2 = fcntl(fd, F_DUPFD, 10); 414 close(fd); 415 if (fd2 < 0) 416 error("Out of file descriptors"); 417 fd = fd2; 418 } 419 setinputfd(fd, push); 420 INTON; 421} 422 423 424/* 425 * Like setinputfile, but takes an open file descriptor. Call this with 426 * interrupts off. 427 */ 428 429void 430setinputfd(int fd, int push) 431{ 432 (void)fcntl(fd, F_SETFD, FD_CLOEXEC); 433 if (push) { 434 pushfile(); 435 parsefile->buf = ckmalloc(BUFSIZ); 436 } 437 if (parsefile->fd > 0) 438 close(parsefile->fd); 439 parsefile->fd = fd; 440 if (parsefile->buf == NULL) 441 parsefile->buf = ckmalloc(BUFSIZ); 442 parselleft = parsenleft = 0; 443 plinno = 1; 444} 445 446 447/* 448 * Like setinputfile, but takes input from a string. 449 */ 450 451void 452setinputstring(char *string, int push) 453{ 454 INTOFF; 455 if (push) 456 pushfile(); 457 parsenextc = string; 458 parselleft = parsenleft = strlen(string); 459 parsefile->buf = NULL; 460 plinno = 1; 461 INTON; 462} 463 464 465 466/* 467 * To handle the "." command, a stack of input files is used. Pushfile 468 * adds a new entry to the stack and popfile restores the previous level. 469 */ 470 471static void 472pushfile(void) 473{ 474 struct parsefile *pf; 475 476 parsefile->nleft = parsenleft; 477 parsefile->lleft = parselleft; 478 parsefile->nextc = parsenextc; 479 parsefile->linno = plinno; 480 pf = (struct parsefile *)ckmalloc(sizeof (struct parsefile)); 481 pf->prev = parsefile; 482 pf->fd = -1; 483 pf->strpush = NULL; 484 pf->basestrpush.prev = NULL; 485 parsefile = pf; 486} 487 488 489void 490popfile(void) 491{ 492 struct parsefile *pf = parsefile; 493 494 INTOFF; 495 if (pf->fd >= 0) 496 close(pf->fd); 497 if (pf->buf) 498 ckfree(pf->buf); 499 while (pf->strpush) 500 popstring(); 501 parsefile = pf->prev; 502 ckfree(pf); 503 parsenleft = parsefile->nleft; 504 parselleft = parsefile->lleft; 505 parsenextc = parsefile->nextc; 506 plinno = parsefile->linno; 507 INTON; 508} 509 510 511/* 512 * Return current file (to go back to it later using popfilesupto()). 513 */ 514 515struct parsefile * 516getcurrentfile(void) 517{ 518 return parsefile; 519} 520 521 522/* 523 * Pop files until the given file is on top again. Useful for regular 524 * builtins that read shell commands from files or strings. 525 * If the given file is not an active file, an error is raised. 526 */ 527 528void 529popfilesupto(struct parsefile *file) 530{ 531 while (parsefile != file && parsefile != &basepf) 532 popfile(); 533 if (parsefile != file) 534 error("popfilesupto() misused"); 535} 536 537/* 538 * Return to top level. 539 */ 540 541void 542popallfiles(void) 543{ 544 while (parsefile != &basepf) 545 popfile(); 546} 547 548 549 550/* 551 * Close the file(s) that the shell is reading commands from. Called 552 * after a fork is done. 553 */ 554 555void 556closescript(void) 557{ 558 popallfiles(); 559 if (parsefile->fd > 0) { 560 close(parsefile->fd); 561 parsefile->fd = 0; 562 } 563} 564