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. 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 * $Id: exec.c,v 1.5 1996/09/01 10:20:02 peter Exp $ 37 */ 38 39 #ifndef lint 40 static char sccsid[] = "@(#)exec.c 8.4 (Berkeley) 6/8/95"; 41 #endif /* not lint */ 42 43 #include <sys/types.h> 44 #include <sys/stat.h> 45 #include <unistd.h> 46 #include <fcntl.h> 47 #include <errno.h> 48 #include <stdlib.h> 49 50 /* 51 * When commands are first encountered, they are entered in a hash table. 52 * This ensures that a full path search will not have to be done for them 53 * on each invocation. 54 * 55 * We should investigate converting to a linear search, even though that 56 * would make the command name "hash" a misnomer. 57 */ 58 59 #include "shell.h" 60 #include "main.h" 61 #include "nodes.h" 62 #include "parser.h" 63 #include "redir.h" 64 #include "eval.h" 65 #include "exec.h" 66 #include "builtins.h" 67 #include "var.h" 68 #include "options.h" 69 #include "input.h" 70 #include "output.h" 71 #include "syntax.h" 72 #include "memalloc.h" 73 #include "error.h" 74 #include "init.h" 75 #include "mystring.h" 76 #include "show.h" 77 #include "jobs.h" 78 79 80 #define CMDTABLESIZE 31 /* should be prime */ 81 #define ARB 1 /* actual size determined at run time */ 82 83 84 85 struct tblentry { 86 struct tblentry *next; /* next entry in hash chain */ 87 union param param; /* definition of builtin function */ 88 short cmdtype; /* index identifying command */ 89 char rehash; /* if set, cd done since entry created */ 90 char cmdname[ARB]; /* name of command */ 91 }; 92 93 94 STATIC struct tblentry *cmdtable[CMDTABLESIZE]; 95 STATIC int builtinloc = -1; /* index in path of %builtin, or -1 */ 96 97 98 STATIC void tryexec __P((char *, char **, char **)); 99 STATIC void execinterp __P((char **, char **)); 100 STATIC void printentry __P((struct tblentry *, int)); 101 STATIC void clearcmdentry __P((int)); 102 STATIC struct tblentry *cmdlookup __P((char *, int)); 103 STATIC void delete_cmd_entry __P((void)); 104 105 106 107 /* 108 * Exec a program. Never returns. If you change this routine, you may 109 * have to change the find_command routine as well. 110 */ 111 112 void 113 shellexec(argv, envp, path, index) 114 char **argv, **envp; 115 char *path; 116 int index; 117 { 118 char *cmdname; 119 int e; 120 121 if (strchr(argv[0], '/') != NULL) { 122 tryexec(argv[0], argv, envp); 123 e = errno; 124 } else { 125 e = ENOENT; 126 while ((cmdname = padvance(&path, argv[0])) != NULL) { 127 if (--index < 0 && pathopt == NULL) { 128 tryexec(cmdname, argv, envp); 129 if (errno != ENOENT && errno != ENOTDIR) 130 e = errno; 131 } 132 stunalloc(cmdname); 133 } 134 } 135 error("%s: %s", argv[0], errmsg(e, E_EXEC)); 136 } 137 138 139 STATIC void 140 tryexec(cmd, argv, envp) 141 char *cmd; 142 char **argv; 143 char **envp; 144 { 145 int e; 146 #ifndef BSD 147 char *p; 148 #endif 149 150 #ifdef SYSV 151 do { 152 execve(cmd, argv, envp); 153 } while (errno == EINTR); 154 #else 155 execve(cmd, argv, envp); 156 #endif 157 e = errno; 158 if (e == ENOEXEC) { 159 initshellproc(); 160 setinputfile(cmd, 0); 161 commandname = arg0 = savestr(argv[0]); 162 #ifndef BSD 163 pgetc(); pungetc(); /* fill up input buffer */ 164 p = parsenextc; 165 if (parsenleft > 2 && p[0] == '#' && p[1] == '!') { 166 argv[0] = cmd; 167 execinterp(argv, envp); 168 } 169 #endif 170 setparam(argv + 1); 171 exraise(EXSHELLPROC); 172 /*NOTREACHED*/ 173 } 174 errno = e; 175 } 176 177 178 #ifndef BSD 179 /* 180 * Execute an interpreter introduced by "#!", for systems where this 181 * feature has not been built into the kernel. If the interpreter is 182 * the shell, return (effectively ignoring the "#!"). If the execution 183 * of the interpreter fails, exit. 184 * 185 * This code peeks inside the input buffer in order to avoid actually 186 * reading any input. It would benefit from a rewrite. 187 */ 188 189 #define NEWARGS 5 190 191 STATIC void 192 execinterp(argv, envp) 193 char **argv, **envp; 194 { 195 int n; 196 char *inp; 197 char *outp; 198 char c; 199 char *p; 200 char **ap; 201 char *newargs[NEWARGS]; 202 int i; 203 char **ap2; 204 char **new; 205 206 n = parsenleft - 2; 207 inp = parsenextc + 2; 208 ap = newargs; 209 for (;;) { 210 while (--n >= 0 && (*inp == ' ' || *inp == '\t')) 211 inp++; 212 if (n < 0) 213 goto bad; 214 if ((c = *inp++) == '\n') 215 break; 216 if (ap == &newargs[NEWARGS]) 217 bad: error("Bad #! line"); 218 STARTSTACKSTR(outp); 219 do { 220 STPUTC(c, outp); 221 } while (--n >= 0 && (c = *inp++) != ' ' && c != '\t' && c != '\n'); 222 STPUTC('\0', outp); 223 n++, inp--; 224 *ap++ = grabstackstr(outp); 225 } 226 if (ap == newargs + 1) { /* if no args, maybe no exec is needed */ 227 p = newargs[0]; 228 for (;;) { 229 if (equal(p, "sh") || equal(p, "ash")) { 230 return; 231 } 232 while (*p != '/') { 233 if (*p == '\0') 234 goto break2; 235 p++; 236 } 237 p++; 238 } 239 break2:; 240 } 241 i = (char *)ap - (char *)newargs; /* size in bytes */ 242 if (i == 0) 243 error("Bad #! line"); 244 for (ap2 = argv ; *ap2++ != NULL ; ); 245 new = ckmalloc(i + ((char *)ap2 - (char *)argv)); 246 ap = newargs, ap2 = new; 247 while ((i -= sizeof (char **)) >= 0) 248 *ap2++ = *ap++; 249 ap = argv; 250 while (*ap2++ = *ap++); 251 shellexec(new, envp, pathval(), 0); 252 } 253 #endif 254 255 256 257 /* 258 * Do a path search. The variable path (passed by reference) should be 259 * set to the start of the path before the first call; padvance will update 260 * this value as it proceeds. Successive calls to padvance will return 261 * the possible path expansions in sequence. If an option (indicated by 262 * a percent sign) appears in the path entry then the global variable 263 * pathopt will be set to point to it; otherwise pathopt will be set to 264 * NULL. 265 */ 266 267 char *pathopt; 268 269 char * 270 padvance(path, name) 271 char **path; 272 char *name; 273 { 274 register char *p, *q; 275 char *start; 276 int len; 277 278 if (*path == NULL) 279 return NULL; 280 start = *path; 281 for (p = start ; *p && *p != ':' && *p != '%' ; p++); 282 len = p - start + strlen(name) + 2; /* "2" is for '/' and '\0' */ 283 while (stackblocksize() < len) 284 growstackblock(); 285 q = stackblock(); 286 if (p != start) { 287 memcpy(q, start, p - start); 288 q += p - start; 289 *q++ = '/'; 290 } 291 strcpy(q, name); 292 pathopt = NULL; 293 if (*p == '%') { 294 pathopt = ++p; 295 while (*p && *p != ':') p++; 296 } 297 if (*p == ':') 298 *path = p + 1; 299 else 300 *path = NULL; 301 return stalloc(len); 302 } 303 304 305 306 /*** Command hashing code ***/ 307 308 309 int 310 hashcmd(argc, argv) 311 int argc; 312 char **argv; 313 { 314 struct tblentry **pp; 315 struct tblentry *cmdp; 316 int c; 317 int verbose; 318 struct cmdentry entry; 319 char *name; 320 321 verbose = 0; 322 while ((c = nextopt("rv")) != '\0') { 323 if (c == 'r') { 324 clearcmdentry(0); 325 } else if (c == 'v') { 326 verbose++; 327 } 328 } 329 if (*argptr == NULL) { 330 for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) { 331 for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) { 332 printentry(cmdp, verbose); 333 } 334 } 335 return 0; 336 } 337 while ((name = *argptr) != NULL) { 338 if ((cmdp = cmdlookup(name, 0)) != NULL 339 && (cmdp->cmdtype == CMDNORMAL 340 || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0))) 341 delete_cmd_entry(); 342 find_command(name, &entry, 1, pathval()); 343 if (verbose) { 344 if (entry.cmdtype != CMDUNKNOWN) { /* if no error msg */ 345 cmdp = cmdlookup(name, 0); 346 printentry(cmdp, verbose); 347 } 348 flushall(); 349 } 350 argptr++; 351 } 352 return 0; 353 } 354 355 356 STATIC void 357 printentry(cmdp, verbose) 358 struct tblentry *cmdp; 359 int verbose; 360 { 361 int index; 362 char *path; 363 char *name; 364 365 if (cmdp->cmdtype == CMDNORMAL) { 366 index = cmdp->param.index; 367 path = pathval(); 368 do { 369 name = padvance(&path, cmdp->cmdname); 370 stunalloc(name); 371 } while (--index >= 0); 372 out1str(name); 373 } else if (cmdp->cmdtype == CMDBUILTIN) { 374 out1fmt("builtin %s", cmdp->cmdname); 375 } else if (cmdp->cmdtype == CMDFUNCTION) { 376 out1fmt("function %s", cmdp->cmdname); 377 if (verbose) { 378 INTOFF; 379 name = commandtext(cmdp->param.func); 380 out1c(' '); 381 out1str(name); 382 ckfree(name); 383 INTON; 384 } 385 #ifdef DEBUG 386 } else { 387 error("internal error: cmdtype %d", cmdp->cmdtype); 388 #endif 389 } 390 if (cmdp->rehash) 391 out1c('*'); 392 out1c('\n'); 393 } 394 395 396 397 /* 398 * Resolve a command name. If you change this routine, you may have to 399 * change the shellexec routine as well. 400 */ 401 402 void 403 find_command(name, entry, printerr, path) 404 char *name; 405 struct cmdentry *entry; 406 int printerr; 407 char *path; 408 { 409 struct tblentry *cmdp; 410 int index; 411 int prev; 412 char *fullname; 413 struct stat statb; 414 int e; 415 int i; 416 417 /* If name contains a slash, don't use the hash table */ 418 if (strchr(name, '/') != NULL) { 419 entry->cmdtype = CMDNORMAL; 420 entry->u.index = 0; 421 return; 422 } 423 424 /* If name is in the table, and not invalidated by cd, we're done */ 425 if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->rehash == 0) 426 goto success; 427 428 /* If %builtin not in path, check for builtin next */ 429 if (builtinloc < 0 && (i = find_builtin(name)) >= 0) { 430 INTOFF; 431 cmdp = cmdlookup(name, 1); 432 cmdp->cmdtype = CMDBUILTIN; 433 cmdp->param.index = i; 434 INTON; 435 goto success; 436 } 437 438 /* We have to search path. */ 439 prev = -1; /* where to start */ 440 if (cmdp) { /* doing a rehash */ 441 if (cmdp->cmdtype == CMDBUILTIN) 442 prev = builtinloc; 443 else 444 prev = cmdp->param.index; 445 } 446 447 e = ENOENT; 448 index = -1; 449 loop: 450 while ((fullname = padvance(&path, name)) != NULL) { 451 stunalloc(fullname); 452 index++; 453 if (pathopt) { 454 if (prefix("builtin", pathopt)) { 455 if ((i = find_builtin(name)) < 0) 456 goto loop; 457 INTOFF; 458 cmdp = cmdlookup(name, 1); 459 cmdp->cmdtype = CMDBUILTIN; 460 cmdp->param.index = i; 461 INTON; 462 goto success; 463 } else if (prefix("func", pathopt)) { 464 /* handled below */ 465 } else { 466 goto loop; /* ignore unimplemented options */ 467 } 468 } 469 /* if rehash, don't redo absolute path names */ 470 if (fullname[0] == '/' && index <= prev) { 471 if (index < prev) 472 goto loop; 473 TRACE(("searchexec \"%s\": no change\n", name)); 474 goto success; 475 } 476 while (stat(fullname, &statb) < 0) { 477 #ifdef SYSV 478 if (errno == EINTR) 479 continue; 480 #endif 481 if (errno != ENOENT && errno != ENOTDIR) 482 e = errno; 483 goto loop; 484 } 485 e = EACCES; /* if we fail, this will be the error */ 486 if (!S_ISREG(statb.st_mode)) 487 goto loop; 488 if (pathopt) { /* this is a %func directory */ 489 stalloc(strlen(fullname) + 1); 490 readcmdfile(fullname); 491 if ((cmdp = cmdlookup(name, 0)) == NULL || cmdp->cmdtype != CMDFUNCTION) 492 error("%s not defined in %s", name, fullname); 493 stunalloc(fullname); 494 goto success; 495 } 496 #ifdef notdef 497 if (statb.st_uid == geteuid()) { 498 if ((statb.st_mode & 0100) == 0) 499 goto loop; 500 } else if (statb.st_gid == getegid()) { 501 if ((statb.st_mode & 010) == 0) 502 goto loop; 503 } else { 504 if ((statb.st_mode & 01) == 0) 505 goto loop; 506 } 507 #endif 508 TRACE(("searchexec \"%s\" returns \"%s\"\n", name, fullname)); 509 INTOFF; 510 cmdp = cmdlookup(name, 1); 511 cmdp->cmdtype = CMDNORMAL; 512 cmdp->param.index = index; 513 INTON; 514 goto success; 515 } 516 517 /* We failed. If there was an entry for this command, delete it */ 518 if (cmdp) 519 delete_cmd_entry(); 520 if (printerr) 521 outfmt(out2, "%s: %s\n", name, errmsg(e, E_EXEC)); 522 entry->cmdtype = CMDUNKNOWN; 523 return; 524 525 success: 526 cmdp->rehash = 0; 527 entry->cmdtype = cmdp->cmdtype; 528 entry->u = cmdp->param; 529 } 530 531 532 533 /* 534 * Search the table of builtin commands. 535 */ 536 537 int 538 find_builtin(name) 539 char *name; 540 { 541 register const struct builtincmd *bp; 542 543 for (bp = builtincmd ; bp->name ; bp++) { 544 if (*bp->name == *name && equal(bp->name, name)) 545 return bp->code; 546 } 547 return -1; 548 } 549 550 551 552 /* 553 * Called when a cd is done. Marks all commands so the next time they 554 * are executed they will be rehashed. 555 */ 556 557 void 558 hashcd() { 559 struct tblentry **pp; 560 struct tblentry *cmdp; 561 562 for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) { 563 for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) { 564 if (cmdp->cmdtype == CMDNORMAL 565 || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0)) 566 cmdp->rehash = 1; 567 } 568 } 569 } 570 571 572 573 /* 574 * Called before PATH is changed. The argument is the new value of PATH; 575 * pathval() still returns the old value at this point. Called with 576 * interrupts off. 577 */ 578 579 void 580 changepath(newval) 581 char *newval; 582 { 583 char *old, *new; 584 int index; 585 int firstchange; 586 int bltin; 587 588 old = pathval(); 589 new = newval; 590 firstchange = 9999; /* assume no change */ 591 index = 0; 592 bltin = -1; 593 for (;;) { 594 if (*old != *new) { 595 firstchange = index; 596 if ((*old == '\0' && *new == ':') 597 || (*old == ':' && *new == '\0')) 598 firstchange++; 599 old = new; /* ignore subsequent differences */ 600 } 601 if (*new == '\0') 602 break; 603 if (*new == '%' && bltin < 0 && prefix("builtin", new + 1)) 604 bltin = index; 605 if (*new == ':') { 606 index++; 607 } 608 new++, old++; 609 } 610 if (builtinloc < 0 && bltin >= 0) 611 builtinloc = bltin; /* zap builtins */ 612 if (builtinloc >= 0 && bltin < 0) 613 firstchange = 0; 614 clearcmdentry(firstchange); 615 builtinloc = bltin; 616 } 617 618 619 /* 620 * Clear out command entries. The argument specifies the first entry in 621 * PATH which has changed. 622 */ 623 624 STATIC void 625 clearcmdentry(firstchange) 626 int firstchange; 627 { 628 struct tblentry **tblp; 629 struct tblentry **pp; 630 struct tblentry *cmdp; 631 632 INTOFF; 633 for (tblp = cmdtable ; tblp < &cmdtable[CMDTABLESIZE] ; tblp++) { 634 pp = tblp; 635 while ((cmdp = *pp) != NULL) { 636 if ((cmdp->cmdtype == CMDNORMAL && 637 cmdp->param.index >= firstchange) 638 || (cmdp->cmdtype == CMDBUILTIN && 639 builtinloc >= firstchange)) { 640 *pp = cmdp->next; 641 ckfree(cmdp); 642 } else { 643 pp = &cmdp->next; 644 } 645 } 646 } 647 INTON; 648 } 649 650 651 /* 652 * Delete all functions. 653 */ 654 655 #ifdef mkinit 656 MKINIT void deletefuncs(); 657 658 SHELLPROC { 659 deletefuncs(); 660 } 661 #endif 662 663 void 664 deletefuncs() { 665 struct tblentry **tblp; 666 struct tblentry **pp; 667 struct tblentry *cmdp; 668 669 INTOFF; 670 for (tblp = cmdtable ; tblp < &cmdtable[CMDTABLESIZE] ; tblp++) { 671 pp = tblp; 672 while ((cmdp = *pp) != NULL) { 673 if (cmdp->cmdtype == CMDFUNCTION) { 674 *pp = cmdp->next; 675 freefunc(cmdp->param.func); 676 ckfree(cmdp); 677 } else { 678 pp = &cmdp->next; 679 } 680 } 681 } 682 INTON; 683 } 684 685 686 687 /* 688 * Locate a command in the command hash table. If "add" is nonzero, 689 * add the command to the table if it is not already present. The 690 * variable "lastcmdentry" is set to point to the address of the link 691 * pointing to the entry, so that delete_cmd_entry can delete the 692 * entry. 693 */ 694 695 struct tblentry **lastcmdentry; 696 697 698 STATIC struct tblentry * 699 cmdlookup(name, add) 700 char *name; 701 int add; 702 { 703 int hashval; 704 register char *p; 705 struct tblentry *cmdp; 706 struct tblentry **pp; 707 708 p = name; 709 hashval = *p << 4; 710 while (*p) 711 hashval += *p++; 712 hashval &= 0x7FFF; 713 pp = &cmdtable[hashval % CMDTABLESIZE]; 714 for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) { 715 if (equal(cmdp->cmdname, name)) 716 break; 717 pp = &cmdp->next; 718 } 719 if (add && cmdp == NULL) { 720 INTOFF; 721 cmdp = *pp = ckmalloc(sizeof (struct tblentry) - ARB 722 + strlen(name) + 1); 723 cmdp->next = NULL; 724 cmdp->cmdtype = CMDUNKNOWN; 725 cmdp->rehash = 0; 726 strcpy(cmdp->cmdname, name); 727 INTON; 728 } 729 lastcmdentry = pp; 730 return cmdp; 731 } 732 733 /* 734 * Delete the command entry returned on the last lookup. 735 */ 736 737 STATIC void 738 delete_cmd_entry() { 739 struct tblentry *cmdp; 740 741 INTOFF; 742 cmdp = *lastcmdentry; 743 *lastcmdentry = cmdp->next; 744 ckfree(cmdp); 745 INTON; 746 } 747 748 749 750 #ifdef notdef 751 void 752 getcmdentry(name, entry) 753 char *name; 754 struct cmdentry *entry; 755 { 756 struct tblentry *cmdp = cmdlookup(name, 0); 757 758 if (cmdp) { 759 entry->u = cmdp->param; 760 entry->cmdtype = cmdp->cmdtype; 761 } else { 762 entry->cmdtype = CMDUNKNOWN; 763 entry->u.index = 0; 764 } 765 } 766 #endif 767 768 769 /* 770 * Add a new command entry, replacing any existing command entry for 771 * the same name. 772 */ 773 774 void 775 addcmdentry(name, entry) 776 char *name; 777 struct cmdentry *entry; 778 { 779 struct tblentry *cmdp; 780 781 INTOFF; 782 cmdp = cmdlookup(name, 1); 783 if (cmdp->cmdtype == CMDFUNCTION) { 784 freefunc(cmdp->param.func); 785 } 786 cmdp->cmdtype = entry->cmdtype; 787 cmdp->param = entry->u; 788 INTON; 789 } 790 791 792 /* 793 * Define a shell function. 794 */ 795 796 void 797 defun(name, func) 798 char *name; 799 union node *func; 800 { 801 struct cmdentry entry; 802 803 INTOFF; 804 entry.cmdtype = CMDFUNCTION; 805 entry.u.func = copyfunc(func); 806 addcmdentry(name, &entry); 807 INTON; 808 } 809 810 811 /* 812 * Delete a function if it exists. 813 */ 814 815 int 816 unsetfunc(name) 817 char *name; 818 { 819 struct tblentry *cmdp; 820 821 if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->cmdtype == CMDFUNCTION) { 822 freefunc(cmdp->param.func); 823 delete_cmd_entry(); 824 return (0); 825 } 826 return (1); 827 } 828