1 /*- 2 * Copyright (c) 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. All advertising materials mentioning features or use of this software 17 * must display the following acknowledgement: 18 * This product includes software developed by the University of 19 * California, Berkeley and its contributors. 20 * 4. Neither the name of the University nor the names of its contributors 21 * may be used to endorse or promote products derived from this software 22 * without specific prior written permission. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 34 * SUCH DAMAGE. 35 * 36 * @(#)eval.c 8.9 (Berkeley) 6/8/95 37 * $FreeBSD: src/bin/sh/eval.c,v 1.27.2.5 2002/08/27 01:36:28 tjr Exp $ 38 * $DragonFly: src/bin/sh/eval.c,v 1.8 2006/07/20 17:01:22 corecode Exp $ 39 */ 40 41 #include <sys/wait.h> /* For WIFSIGNALED(status) */ 42 43 #include <errno.h> 44 #include <paths.h> 45 #include <signal.h> 46 #include <stdlib.h> 47 #include <unistd.h> 48 49 /* 50 * Evaluate a command. 51 */ 52 53 #include "shell.h" 54 #include "nodes.h" 55 #include "syntax.h" 56 #include "expand.h" 57 #include "parser.h" 58 #include "jobs.h" 59 #include "eval.h" 60 #include "builtins.h" 61 #include "options.h" 62 #include "exec.h" 63 #include "redir.h" 64 #include "input.h" 65 #include "output.h" 66 #include "trap.h" 67 #include "var.h" 68 #include "memalloc.h" 69 #include "error.h" 70 #include "show.h" 71 #include "mystring.h" 72 #ifndef NO_HISTORY 73 #include "myhistedit.h" 74 #endif 75 76 77 /* flags in argument to evaltree */ 78 #define EV_EXIT 01 /* exit after evaluating tree */ 79 #define EV_TESTED 02 /* exit status is checked; ignore -e flag */ 80 #define EV_BACKCMD 04 /* command executing within back quotes */ 81 82 MKINIT int evalskip; /* set if we are skipping commands */ 83 STATIC int skipcount; /* number of levels to skip */ 84 MKINIT int loopnest; /* current loop nesting level */ 85 int funcnest; /* depth of function calls */ 86 87 88 const char *commandname; 89 struct strlist *cmdenviron; 90 int exitstatus; /* exit status of last command */ 91 int oexitstatus; /* saved exit status */ 92 93 94 STATIC void evalloop(union node *, int); 95 STATIC void evalfor(union node *, int); 96 STATIC void evalcase(union node *, int); 97 STATIC void evalsubshell(union node *, int); 98 STATIC void expredir(union node *); 99 STATIC void evalpipe(union node *); 100 STATIC void evalcommand(union node *, int, struct backcmd *); 101 STATIC void prehash(union node *); 102 103 104 /* 105 * Called to reset things after an exception. 106 */ 107 108 #ifdef mkinit 109 INCLUDE "eval.h" 110 111 RESET { 112 evalskip = 0; 113 loopnest = 0; 114 funcnest = 0; 115 } 116 117 SHELLPROC { 118 exitstatus = 0; 119 } 120 #endif 121 122 123 124 /* 125 * The eval command. 126 */ 127 128 int 129 evalcmd(int argc, char **argv) 130 { 131 char *p; 132 char *concat; 133 char **ap; 134 135 if (argc > 1) { 136 p = argv[1]; 137 if (argc > 2) { 138 STARTSTACKSTR(concat); 139 ap = argv + 2; 140 for (;;) { 141 while (*p) 142 STPUTC(*p++, concat); 143 if ((p = *ap++) == NULL) 144 break; 145 STPUTC(' ', concat); 146 } 147 STPUTC('\0', concat); 148 p = grabstackstr(concat); 149 } 150 evalstring(p); 151 } 152 return exitstatus; 153 } 154 155 156 /* 157 * Execute a command or commands contained in a string. 158 */ 159 160 void 161 evalstring(char *s) 162 { 163 union node *n; 164 struct stackmark smark; 165 166 setstackmark(&smark); 167 setinputstring(s, 1); 168 while ((n = parsecmd(0)) != NEOF) { 169 evaltree(n, 0); 170 popstackmark(&smark); 171 } 172 popfile(); 173 popstackmark(&smark); 174 } 175 176 177 178 /* 179 * Evaluate a parse tree. The value is left in the global variable 180 * exitstatus. 181 */ 182 183 void 184 evaltree(union node *n, int flags) 185 { 186 int do_etest; 187 188 do_etest = 0; 189 if (n == NULL) { 190 TRACE(("evaltree(NULL) called\n")); 191 exitstatus = 0; 192 goto out; 193 } 194 #ifndef NO_HISTORY 195 displayhist = 1; /* show history substitutions done with fc */ 196 #endif 197 TRACE(("evaltree(0x%lx: %d) called\n", (long)n, n->type)); 198 switch (n->type) { 199 case NSEMI: 200 evaltree(n->nbinary.ch1, flags & ~EV_EXIT); 201 if (evalskip) 202 goto out; 203 evaltree(n->nbinary.ch2, flags); 204 break; 205 case NAND: 206 evaltree(n->nbinary.ch1, EV_TESTED); 207 if (evalskip || exitstatus != 0) { 208 goto out; 209 } 210 evaltree(n->nbinary.ch2, flags); 211 break; 212 case NOR: 213 evaltree(n->nbinary.ch1, EV_TESTED); 214 if (evalskip || exitstatus == 0) 215 goto out; 216 evaltree(n->nbinary.ch2, flags); 217 break; 218 case NREDIR: 219 expredir(n->nredir.redirect); 220 redirect(n->nredir.redirect, REDIR_PUSH); 221 evaltree(n->nredir.n, flags); 222 popredir(); 223 break; 224 case NSUBSHELL: 225 evalsubshell(n, flags); 226 do_etest = !(flags & EV_TESTED); 227 break; 228 case NBACKGND: 229 evalsubshell(n, flags); 230 break; 231 case NIF: { 232 evaltree(n->nif.test, EV_TESTED); 233 if (evalskip) 234 goto out; 235 if (exitstatus == 0) 236 evaltree(n->nif.ifpart, flags); 237 else if (n->nif.elsepart) 238 evaltree(n->nif.elsepart, flags); 239 else 240 exitstatus = 0; 241 break; 242 } 243 case NWHILE: 244 case NUNTIL: 245 evalloop(n, flags & ~EV_EXIT); 246 break; 247 case NFOR: 248 evalfor(n, flags & ~EV_EXIT); 249 break; 250 case NCASE: 251 evalcase(n, flags); 252 break; 253 case NDEFUN: 254 defun(n->narg.text, n->narg.next); 255 exitstatus = 0; 256 break; 257 case NNOT: 258 evaltree(n->nnot.com, EV_TESTED); 259 exitstatus = !exitstatus; 260 break; 261 262 case NPIPE: 263 evalpipe(n); 264 do_etest = !(flags & EV_TESTED); 265 break; 266 case NCMD: 267 evalcommand(n, flags, (struct backcmd *)NULL); 268 do_etest = !(flags & EV_TESTED); 269 break; 270 default: 271 out1fmt("Node type = %d\n", n->type); 272 flushout(&output); 273 break; 274 } 275 out: 276 if (pendingsigs) 277 dotrap(); 278 if ((flags & EV_EXIT) || (eflag && exitstatus != 0 && do_etest)) 279 exitshell(exitstatus); 280 } 281 282 283 STATIC void 284 evalloop(union node *n, int flags) 285 { 286 int status; 287 288 loopnest++; 289 status = 0; 290 for (;;) { 291 evaltree(n->nbinary.ch1, EV_TESTED); 292 if (evalskip) { 293 skipping: if (evalskip == SKIPCONT && --skipcount <= 0) { 294 evalskip = 0; 295 continue; 296 } 297 if (evalskip == SKIPBREAK && --skipcount <= 0) 298 evalskip = 0; 299 break; 300 } 301 if (n->type == NWHILE) { 302 if (exitstatus != 0) 303 break; 304 } else { 305 if (exitstatus == 0) 306 break; 307 } 308 evaltree(n->nbinary.ch2, flags); 309 status = exitstatus; 310 if (evalskip) 311 goto skipping; 312 } 313 loopnest--; 314 exitstatus = status; 315 } 316 317 318 319 STATIC void 320 evalfor(union node *n, int flags) 321 { 322 struct arglist arglist; 323 union node *argp; 324 struct strlist *sp; 325 struct stackmark smark; 326 327 setstackmark(&smark); 328 arglist.lastp = &arglist.list; 329 for (argp = n->nfor.args ; argp ; argp = argp->narg.next) { 330 oexitstatus = exitstatus; 331 expandarg(argp, &arglist, EXP_FULL | EXP_TILDE); 332 if (evalskip) 333 goto out; 334 } 335 *arglist.lastp = NULL; 336 337 exitstatus = 0; 338 loopnest++; 339 for (sp = arglist.list ; sp ; sp = sp->next) { 340 setvar(n->nfor.var, sp->text, 0); 341 evaltree(n->nfor.body, flags); 342 if (evalskip) { 343 if (evalskip == SKIPCONT && --skipcount <= 0) { 344 evalskip = 0; 345 continue; 346 } 347 if (evalskip == SKIPBREAK && --skipcount <= 0) 348 evalskip = 0; 349 break; 350 } 351 } 352 loopnest--; 353 out: 354 popstackmark(&smark); 355 } 356 357 358 359 STATIC void 360 evalcase(union node *n, int flags) 361 { 362 union node *cp; 363 union node *patp; 364 struct arglist arglist; 365 struct stackmark smark; 366 367 setstackmark(&smark); 368 arglist.lastp = &arglist.list; 369 oexitstatus = exitstatus; 370 expandarg(n->ncase.expr, &arglist, EXP_TILDE); 371 for (cp = n->ncase.cases ; cp && evalskip == 0 ; cp = cp->nclist.next) { 372 for (patp = cp->nclist.pattern ; patp ; patp = patp->narg.next) { 373 if (casematch(patp, arglist.list->text)) { 374 if (evalskip == 0) { 375 evaltree(cp->nclist.body, flags); 376 } 377 goto out; 378 } 379 } 380 } 381 out: 382 popstackmark(&smark); 383 } 384 385 386 387 /* 388 * Kick off a subshell to evaluate a tree. 389 */ 390 391 STATIC void 392 evalsubshell(union node *n, int flags) 393 { 394 struct job *jp; 395 int backgnd = (n->type == NBACKGND); 396 397 expredir(n->nredir.redirect); 398 jp = makejob(n, 1); 399 if (forkshell(jp, n, backgnd) == 0) { 400 if (backgnd) 401 flags &=~ EV_TESTED; 402 redirect(n->nredir.redirect, 0); 403 evaltree(n->nredir.n, flags | EV_EXIT); /* never returns */ 404 } 405 if (! backgnd) { 406 INTOFF; 407 exitstatus = waitforjob(jp, (int *)NULL); 408 INTON; 409 } 410 } 411 412 413 414 /* 415 * Compute the names of the files in a redirection list. 416 */ 417 418 STATIC void 419 expredir(union node *n) 420 { 421 union node *redir; 422 423 for (redir = n ; redir ; redir = redir->nfile.next) { 424 struct arglist fn; 425 fn.lastp = &fn.list; 426 oexitstatus = exitstatus; 427 switch (redir->type) { 428 case NFROM: 429 case NTO: 430 case NFROMTO: 431 case NAPPEND: 432 case NCLOBBER: 433 expandarg(redir->nfile.fname, &fn, EXP_TILDE | EXP_REDIR); 434 redir->nfile.expfname = fn.list->text; 435 break; 436 case NFROMFD: 437 case NTOFD: 438 if (redir->ndup.vname) { 439 expandarg(redir->ndup.vname, &fn, EXP_FULL | EXP_TILDE); 440 fixredir(redir, fn.list->text, 1); 441 } 442 break; 443 } 444 } 445 } 446 447 448 449 /* 450 * Evaluate a pipeline. All the processes in the pipeline are children 451 * of the process creating the pipeline. (This differs from some versions 452 * of the shell, which make the last process in a pipeline the parent 453 * of all the rest.) 454 */ 455 456 STATIC void 457 evalpipe(union node *n) 458 { 459 struct job *jp; 460 struct nodelist *lp; 461 int pipelen; 462 int prevfd; 463 int pip[2]; 464 465 TRACE(("evalpipe(0x%lx) called\n", (long)n)); 466 pipelen = 0; 467 for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) 468 pipelen++; 469 INTOFF; 470 jp = makejob(n, pipelen); 471 prevfd = -1; 472 for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) { 473 prehash(lp->n); 474 pip[1] = -1; 475 if (lp->next) { 476 if (pipe(pip) < 0) { 477 if (prevfd >= 0) 478 close(prevfd); 479 error("Pipe call failed: %s", strerror(errno)); 480 } 481 } 482 if (forkshell(jp, lp->n, n->npipe.backgnd) == 0) { 483 INTON; 484 if (prevfd > 0) { 485 close(0); 486 copyfd(prevfd, 0); 487 close(prevfd); 488 } 489 if (pip[1] >= 0) { 490 if (!(prevfd >= 0 && pip[0] == 0)) 491 close(pip[0]); 492 if (pip[1] != 1) { 493 close(1); 494 copyfd(pip[1], 1); 495 close(pip[1]); 496 } 497 } 498 evaltree(lp->n, EV_EXIT); 499 } 500 if (prevfd >= 0) 501 close(prevfd); 502 prevfd = pip[0]; 503 close(pip[1]); 504 } 505 INTON; 506 if (n->npipe.backgnd == 0) { 507 INTOFF; 508 exitstatus = waitforjob(jp, (int *)NULL); 509 TRACE(("evalpipe: job done exit status %d\n", exitstatus)); 510 INTON; 511 } 512 } 513 514 515 516 /* 517 * Execute a command inside back quotes. If it's a builtin command, we 518 * want to save its output in a block obtained from malloc. Otherwise 519 * we fork off a subprocess and get the output of the command via a pipe. 520 * Should be called with interrupts off. 521 */ 522 523 void 524 evalbackcmd(union node *n, struct backcmd *result) 525 { 526 int pip[2]; 527 struct job *jp; 528 struct stackmark smark; /* unnecessary */ 529 530 setstackmark(&smark); 531 result->fd = -1; 532 result->buf = NULL; 533 result->nleft = 0; 534 result->jp = NULL; 535 if (n == NULL) { 536 exitstatus = 0; 537 goto out; 538 } 539 if (n->type == NCMD) { 540 exitstatus = oexitstatus; 541 evalcommand(n, EV_BACKCMD, result); 542 } else { 543 exitstatus = 0; 544 if (pipe(pip) < 0) 545 error("Pipe call failed: %s", strerror(errno)); 546 jp = makejob(n, 1); 547 if (forkshell(jp, n, FORK_NOJOB) == 0) { 548 FORCEINTON; 549 close(pip[0]); 550 if (pip[1] != 1) { 551 close(1); 552 copyfd(pip[1], 1); 553 close(pip[1]); 554 } 555 evaltree(n, EV_EXIT); 556 } 557 close(pip[1]); 558 result->fd = pip[0]; 559 result->jp = jp; 560 } 561 out: 562 popstackmark(&smark); 563 TRACE(("evalbackcmd done: fd=%d buf=0x%x nleft=%d jp=0x%x\n", 564 result->fd, result->buf, result->nleft, result->jp)); 565 } 566 567 568 569 /* 570 * Execute a simple command. 571 */ 572 573 STATIC void 574 evalcommand(union node *cmd, int flags, struct backcmd *backcmd) 575 { 576 struct stackmark smark; 577 union node *argp; 578 struct arglist arglist; 579 struct arglist varlist; 580 char **argv; 581 int argc; 582 char **envp; 583 int varflag; 584 struct strlist *sp; 585 int mode; 586 int pip[2]; 587 struct cmdentry cmdentry; 588 struct job *jp; 589 struct jmploc jmploc; 590 struct jmploc *volatile savehandler = NULL; 591 const char *volatile savecmdname; 592 volatile struct shparam saveparam; 593 struct localvar *volatile savelocalvars; 594 volatile int e; 595 char *lastarg; 596 int realstatus; 597 int do_clearcmdentry; 598 #if __GNUC__ 599 /* Avoid longjmp clobbering */ 600 (void) &argv; 601 (void) &argc; 602 (void) &lastarg; 603 (void) &flags; 604 (void) &do_clearcmdentry; 605 #endif 606 607 /* First expand the arguments. */ 608 TRACE(("evalcommand(0x%lx, %d) called\n", (long)cmd, flags)); 609 setstackmark(&smark); 610 arglist.lastp = &arglist.list; 611 varlist.lastp = &varlist.list; 612 varflag = 1; 613 do_clearcmdentry = 0; 614 oexitstatus = exitstatus; 615 exitstatus = 0; 616 for (argp = cmd->ncmd.args ; argp ; argp = argp->narg.next) { 617 char *p = argp->narg.text; 618 if (varflag && is_name(*p)) { 619 do { 620 p++; 621 } while (is_in_name(*p)); 622 if (*p == '=') { 623 expandarg(argp, &varlist, EXP_VARTILDE); 624 continue; 625 } 626 } 627 expandarg(argp, &arglist, EXP_FULL | EXP_TILDE); 628 varflag = 0; 629 } 630 *arglist.lastp = NULL; 631 *varlist.lastp = NULL; 632 expredir(cmd->ncmd.redirect); 633 argc = 0; 634 for (sp = arglist.list ; sp ; sp = sp->next) 635 argc++; 636 argv = stalloc(sizeof (char *) * (argc + 1)); 637 638 for (sp = arglist.list ; sp ; sp = sp->next) { 639 TRACE(("evalcommand arg: %s\n", sp->text)); 640 *argv++ = sp->text; 641 } 642 *argv = NULL; 643 lastarg = NULL; 644 if (iflag && funcnest == 0 && argc > 0) 645 lastarg = argv[-1]; 646 argv -= argc; 647 648 /* Print the command if xflag is set. */ 649 if (xflag) { 650 outc('+', &errout); 651 for (sp = varlist.list ; sp ; sp = sp->next) { 652 outc(' ', &errout); 653 out2str(sp->text); 654 } 655 for (sp = arglist.list ; sp ; sp = sp->next) { 656 outc(' ', &errout); 657 out2str(sp->text); 658 } 659 outc('\n', &errout); 660 flushout(&errout); 661 } 662 663 /* Now locate the command. */ 664 if (argc == 0) { 665 cmdentry.cmdtype = CMDBUILTIN; 666 cmdentry.u.index = BLTINCMD; 667 } else { 668 static const char PATH[] = "PATH="; 669 const char *path = pathval(); 670 671 /* 672 * Modify the command lookup path, if a PATH= assignment 673 * is present 674 */ 675 for (sp = varlist.list ; sp ; sp = sp->next) 676 if (strncmp(sp->text, PATH, sizeof(PATH) - 1) == 0) { 677 path = sp->text + sizeof(PATH) - 1; 678 /* 679 * On `PATH=... command`, we need to make 680 * sure that the command isn't using the 681 * non-updated hash table of the outer PATH 682 * setting and we need to make sure that 683 * the hash table isn't filled with items 684 * from the temporary setting. 685 * 686 * It would be better to forbit using and 687 * updating the table while this command 688 * runs, by the command finding mechanism 689 * is heavily integrated with hash handling, 690 * so we just delete the hash before and after 691 * the command runs. Partly deleting like 692 * changepatch() does doesn't seem worth the 693 * bookinging effort, since most such runs add 694 * diretories in front of the new PATH. 695 */ 696 clearcmdentry(0); 697 do_clearcmdentry = 1; 698 } 699 700 find_command(argv[0], &cmdentry, 1, path); 701 if (cmdentry.cmdtype == CMDUNKNOWN) { /* command not found */ 702 exitstatus = 127; 703 flushout(&errout); 704 return; 705 } 706 /* implement the bltin builtin here */ 707 if (cmdentry.cmdtype == CMDBUILTIN && cmdentry.u.index == BLTINCMD) { 708 for (;;) { 709 argv++; 710 if (--argc == 0) 711 break; 712 if ((cmdentry.u.index = find_builtin(*argv)) < 0) { 713 outfmt(&errout, "%s: not found\n", *argv); 714 exitstatus = 127; 715 flushout(&errout); 716 return; 717 } 718 if (cmdentry.u.index != BLTINCMD) 719 break; 720 } 721 } 722 } 723 724 /* Fork off a child process if necessary. */ 725 if (cmd->ncmd.backgnd 726 || (cmdentry.cmdtype == CMDNORMAL 727 && ((flags & EV_EXIT) == 0 || Tflag)) 728 || ((flags & EV_BACKCMD) != 0 729 && (cmdentry.cmdtype != CMDBUILTIN 730 || cmdentry.u.index == CDCMD 731 || cmdentry.u.index == DOTCMD 732 || cmdentry.u.index == EVALCMD)) 733 || (cmdentry.cmdtype == CMDBUILTIN && 734 cmdentry.u.index == COMMANDCMD)) { 735 jp = makejob(cmd, 1); 736 mode = cmd->ncmd.backgnd; 737 if (flags & EV_BACKCMD) { 738 mode = FORK_NOJOB; 739 if (pipe(pip) < 0) 740 error("Pipe call failed: %s", strerror(errno)); 741 } 742 if (forkshell(jp, cmd, mode) != 0) 743 goto parent; /* at end of routine */ 744 if (flags & EV_BACKCMD) { 745 FORCEINTON; 746 close(pip[0]); 747 if (pip[1] != 1) { 748 close(1); 749 copyfd(pip[1], 1); 750 close(pip[1]); 751 } 752 } 753 flags |= EV_EXIT; 754 } 755 756 /* This is the child process if a fork occurred. */ 757 /* Execute the command. */ 758 if (cmdentry.cmdtype == CMDFUNCTION) { 759 #ifdef DEBUG 760 trputs("Shell function: "); trargs(argv); 761 #endif 762 redirect(cmd->ncmd.redirect, REDIR_PUSH); 763 saveparam = shellparam; 764 shellparam.malloc = 0; 765 shellparam.reset = 1; 766 shellparam.nparam = argc - 1; 767 shellparam.p = argv + 1; 768 shellparam.optnext = NULL; 769 INTOFF; 770 savelocalvars = localvars; 771 localvars = NULL; 772 INTON; 773 if (setjmp(jmploc.loc)) { 774 if (exception == EXSHELLPROC) 775 freeparam((struct shparam *)&saveparam); 776 else { 777 freeparam(&shellparam); 778 shellparam = saveparam; 779 } 780 poplocalvars(); 781 localvars = savelocalvars; 782 handler = savehandler; 783 longjmp(handler->loc, 1); 784 } 785 savehandler = handler; 786 handler = &jmploc; 787 for (sp = varlist.list ; sp ; sp = sp->next) 788 mklocal(sp->text); 789 funcnest++; 790 if (flags & EV_TESTED) 791 evaltree(cmdentry.u.func, EV_TESTED); 792 else 793 evaltree(cmdentry.u.func, 0); 794 funcnest--; 795 INTOFF; 796 poplocalvars(); 797 localvars = savelocalvars; 798 freeparam(&shellparam); 799 shellparam = saveparam; 800 handler = savehandler; 801 popredir(); 802 INTON; 803 if (evalskip == SKIPFUNC) { 804 evalskip = 0; 805 skipcount = 0; 806 } 807 if (flags & EV_EXIT) 808 exitshell(exitstatus); 809 } else if (cmdentry.cmdtype == CMDBUILTIN) { 810 #ifdef DEBUG 811 trputs("builtin command: "); trargs(argv); 812 #endif 813 mode = (cmdentry.u.index == EXECCMD)? 0 : REDIR_PUSH; 814 if (flags == EV_BACKCMD) { 815 memout.nleft = 0; 816 memout.nextc = memout.buf; 817 memout.bufsize = 64; 818 mode |= REDIR_BACKQ; 819 } 820 redirect(cmd->ncmd.redirect, mode); 821 savecmdname = commandname; 822 cmdenviron = varlist.list; 823 e = -1; 824 if (setjmp(jmploc.loc)) { 825 e = exception; 826 exitstatus = (e == EXINT)? SIGINT+128 : 2; 827 goto cmddone; 828 } 829 savehandler = handler; 830 handler = &jmploc; 831 commandname = argv[0]; 832 argptr = argv + 1; 833 optptr = NULL; /* initialize nextopt */ 834 exitstatus = (*builtinfunc[cmdentry.u.index])(argc, argv); 835 flushall(); 836 cmddone: 837 cmdenviron = NULL; 838 out1 = &output; 839 out2 = &errout; 840 freestdout(); 841 if (e != EXSHELLPROC) { 842 commandname = savecmdname; 843 if (flags & EV_EXIT) { 844 exitshell(exitstatus); 845 } 846 } 847 handler = savehandler; 848 if (e != -1) { 849 if ((e != EXERROR && e != EXEXEC) 850 || cmdentry.u.index == BLTINCMD 851 || cmdentry.u.index == DOTCMD 852 || cmdentry.u.index == EVALCMD 853 #ifndef NO_HISTORY 854 || cmdentry.u.index == HISTCMD 855 #endif 856 || cmdentry.u.index == EXECCMD 857 || cmdentry.u.index == COMMANDCMD) 858 exraise(e); 859 FORCEINTON; 860 } 861 if (cmdentry.u.index != EXECCMD) 862 popredir(); 863 if (flags == EV_BACKCMD) { 864 backcmd->buf = memout.buf; 865 backcmd->nleft = memout.nextc - memout.buf; 866 memout.buf = NULL; 867 } 868 } else { 869 #ifdef DEBUG 870 trputs("normal command: "); trargs(argv); 871 #endif 872 clearredir(); 873 redirect(cmd->ncmd.redirect, 0); 874 for (sp = varlist.list ; sp ; sp = sp->next) 875 setvareq(sp->text, VEXPORT|VSTACK); 876 envp = environment(); 877 shellexec(argv, envp, pathval(), cmdentry.u.index); 878 /*NOTREACHED*/ 879 } 880 goto out; 881 882 parent: /* parent process gets here (if we forked) */ 883 if (mode == 0) { /* argument to fork */ 884 INTOFF; 885 exitstatus = waitforjob(jp, &realstatus); 886 INTON; 887 if (iflag && loopnest > 0 && WIFSIGNALED(realstatus)) { 888 evalskip = SKIPBREAK; 889 skipcount = loopnest; 890 } 891 } else if (mode == 2) { 892 backcmd->fd = pip[0]; 893 close(pip[1]); 894 backcmd->jp = jp; 895 } 896 897 out: 898 if (lastarg) 899 setvar("_", lastarg, 0); 900 if (do_clearcmdentry) 901 clearcmdentry(0); 902 popstackmark(&smark); 903 } 904 905 906 907 /* 908 * Search for a command. This is called before we fork so that the 909 * location of the command will be available in the parent as well as 910 * the child. The check for "goodname" is an overly conservative 911 * check that the name will not be subject to expansion. 912 */ 913 914 STATIC void 915 prehash(union node *n) 916 { 917 struct cmdentry entry; 918 919 if (n->type == NCMD && n->ncmd.args) 920 if (goodname(n->ncmd.args->narg.text)) 921 find_command(n->ncmd.args->narg.text, &entry, 0, 922 pathval()); 923 } 924 925 926 927 /* 928 * Builtin commands. Builtin commands whose functions are closely 929 * tied to evaluation are implemented here. 930 */ 931 932 /* 933 * No command given, or a bltin command with no arguments. Set the 934 * specified variables. 935 */ 936 937 int 938 bltincmd(int argc __unused, char **argv __unused) 939 { 940 listsetvar(cmdenviron); 941 /* 942 * Preserve exitstatus of a previous possible redirection 943 * as POSIX mandates 944 */ 945 return exitstatus; 946 } 947 948 949 /* 950 * Handle break and continue commands. Break, continue, and return are 951 * all handled by setting the evalskip flag. The evaluation routines 952 * above all check this flag, and if it is set they start skipping 953 * commands rather than executing them. The variable skipcount is 954 * the number of loops to break/continue, or the number of function 955 * levels to return. (The latter is always 1.) It should probably 956 * be an error to break out of more loops than exist, but it isn't 957 * in the standard shell so we don't make it one here. 958 */ 959 960 int 961 breakcmd(int argc, char **argv) 962 { 963 int n = argc > 1 ? number(argv[1]) : 1; 964 965 if (n > loopnest) 966 n = loopnest; 967 if (n > 0) { 968 evalskip = (**argv == 'c')? SKIPCONT : SKIPBREAK; 969 skipcount = n; 970 } 971 return 0; 972 } 973 974 /* 975 * The `command' command. 976 */ 977 int 978 commandcmd(int argc, char **argv) 979 { 980 static char stdpath[] = _PATH_STDPATH; 981 struct jmploc loc, *old; 982 struct strlist *sp; 983 const char *path; 984 int ch; 985 986 #ifdef __GNUC__ 987 /* Avoid longjmp clobbering */ 988 (void) &path; 989 (void) &argc; 990 (void) &argv; 991 #endif 992 993 for (sp = cmdenviron; sp ; sp = sp->next) 994 setvareq(sp->text, VEXPORT|VSTACK); 995 path = pathval(); 996 997 optind = optreset = 1; 998 opterr = 0; 999 while ((ch = getopt(argc, argv, "p")) != -1) { 1000 switch (ch) { 1001 case 'p': 1002 path = stdpath; 1003 break; 1004 case '?': 1005 default: 1006 error("unknown option: -%c", optopt); 1007 } 1008 } 1009 argc -= optind; 1010 argv += optind; 1011 1012 if (argc != 0) { 1013 old = handler; 1014 handler = &loc; 1015 if (setjmp(handler->loc) == 0) 1016 shellexec(argv, environment(), path, 0); 1017 handler = old; 1018 if (exception == EXEXEC) 1019 exit(exerrno); 1020 exraise(exception); 1021 } 1022 1023 /* 1024 * Do nothing successfully if no command was specified; 1025 * ksh also does this. 1026 */ 1027 exit(0); 1028 } 1029 1030 1031 /* 1032 * The return command. 1033 */ 1034 1035 int 1036 returncmd(int argc, char **argv) 1037 { 1038 int ret = argc > 1 ? number(argv[1]) : oexitstatus; 1039 1040 if (funcnest) { 1041 evalskip = SKIPFUNC; 1042 skipcount = 1; 1043 } else { 1044 /* skip the rest of the file */ 1045 evalskip = SKIPFILE; 1046 skipcount = 1; 1047 } 1048 return ret; 1049 } 1050 1051 1052 int 1053 falsecmd(int argc __unused, char **argv __unused) 1054 { 1055 return 1; 1056 } 1057 1058 1059 int 1060 truecmd(int argc __unused, char **argv __unused) 1061 { 1062 return 0; 1063 } 1064 1065 1066 int 1067 execcmd(int argc, char **argv) 1068 { 1069 if (argc > 1) { 1070 struct strlist *sp; 1071 1072 iflag = 0; /* exit on error */ 1073 mflag = 0; 1074 optschanged(); 1075 for (sp = cmdenviron; sp ; sp = sp->next) 1076 setvareq(sp->text, VEXPORT|VSTACK); 1077 shellexec(argv + 1, environment(), pathval(), 0); 1078 1079 } 1080 return 0; 1081 } 1082