Home | History | Annotate | Line # | Download | only in sh
exec.c revision 1.26
      1  1.26   mycroft /*	$NetBSD: exec.c,v 1.26 1998/07/28 11:41:54 mycroft Exp $	*/
      2  1.15       cgd 
      3   1.1       cgd /*-
      4   1.8       jtc  * Copyright (c) 1991, 1993
      5   1.8       jtc  *	The Regents of the University of California.  All rights reserved.
      6   1.1       cgd  *
      7   1.1       cgd  * This code is derived from software contributed to Berkeley by
      8   1.1       cgd  * Kenneth Almquist.
      9   1.1       cgd  *
     10   1.1       cgd  * Redistribution and use in source and binary forms, with or without
     11   1.1       cgd  * modification, are permitted provided that the following conditions
     12   1.1       cgd  * are met:
     13   1.1       cgd  * 1. Redistributions of source code must retain the above copyright
     14   1.1       cgd  *    notice, this list of conditions and the following disclaimer.
     15   1.1       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     16   1.1       cgd  *    notice, this list of conditions and the following disclaimer in the
     17   1.1       cgd  *    documentation and/or other materials provided with the distribution.
     18   1.1       cgd  * 3. All advertising materials mentioning features or use of this software
     19   1.1       cgd  *    must display the following acknowledgement:
     20   1.1       cgd  *	This product includes software developed by the University of
     21   1.1       cgd  *	California, Berkeley and its contributors.
     22   1.1       cgd  * 4. Neither the name of the University nor the names of its contributors
     23   1.1       cgd  *    may be used to endorse or promote products derived from this software
     24   1.1       cgd  *    without specific prior written permission.
     25   1.1       cgd  *
     26   1.1       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     27   1.1       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     28   1.1       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     29   1.1       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     30   1.1       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     31   1.1       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     32   1.1       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     33   1.1       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     34   1.1       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     35   1.1       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     36   1.1       cgd  * SUCH DAMAGE.
     37   1.1       cgd  */
     38   1.1       cgd 
     39  1.23  christos #include <sys/cdefs.h>
     40   1.1       cgd #ifndef lint
     41  1.15       cgd #if 0
     42  1.17  christos static char sccsid[] = "@(#)exec.c	8.4 (Berkeley) 6/8/95";
     43  1.15       cgd #else
     44  1.26   mycroft __RCSID("$NetBSD: exec.c,v 1.26 1998/07/28 11:41:54 mycroft Exp $");
     45  1.15       cgd #endif
     46   1.1       cgd #endif /* not lint */
     47   1.1       cgd 
     48  1.16  christos #include <sys/types.h>
     49  1.16  christos #include <sys/stat.h>
     50  1.16  christos #include <unistd.h>
     51  1.16  christos #include <fcntl.h>
     52  1.16  christos #include <errno.h>
     53  1.16  christos #include <stdlib.h>
     54  1.16  christos 
     55   1.1       cgd /*
     56   1.1       cgd  * When commands are first encountered, they are entered in a hash table.
     57   1.1       cgd  * This ensures that a full path search will not have to be done for them
     58   1.1       cgd  * on each invocation.
     59   1.1       cgd  *
     60   1.1       cgd  * We should investigate converting to a linear search, even though that
     61   1.1       cgd  * would make the command name "hash" a misnomer.
     62   1.1       cgd  */
     63   1.1       cgd 
     64   1.1       cgd #include "shell.h"
     65   1.1       cgd #include "main.h"
     66   1.1       cgd #include "nodes.h"
     67   1.1       cgd #include "parser.h"
     68   1.1       cgd #include "redir.h"
     69   1.1       cgd #include "eval.h"
     70   1.1       cgd #include "exec.h"
     71   1.1       cgd #include "builtins.h"
     72   1.1       cgd #include "var.h"
     73   1.1       cgd #include "options.h"
     74   1.1       cgd #include "input.h"
     75   1.1       cgd #include "output.h"
     76   1.1       cgd #include "syntax.h"
     77   1.1       cgd #include "memalloc.h"
     78   1.1       cgd #include "error.h"
     79   1.1       cgd #include "init.h"
     80   1.1       cgd #include "mystring.h"
     81  1.16  christos #include "show.h"
     82   1.8       jtc #include "jobs.h"
     83  1.22  christos #include "alias.h"
     84   1.1       cgd 
     85   1.1       cgd 
     86   1.1       cgd #define CMDTABLESIZE 31		/* should be prime */
     87   1.1       cgd #define ARB 1			/* actual size determined at run time */
     88   1.1       cgd 
     89   1.1       cgd 
     90   1.1       cgd 
     91   1.1       cgd struct tblentry {
     92   1.1       cgd 	struct tblentry *next;	/* next entry in hash chain */
     93   1.1       cgd 	union param param;	/* definition of builtin function */
     94   1.1       cgd 	short cmdtype;		/* index identifying command */
     95   1.1       cgd 	char rehash;		/* if set, cd done since entry created */
     96   1.1       cgd 	char cmdname[ARB];	/* name of command */
     97   1.1       cgd };
     98   1.1       cgd 
     99   1.1       cgd 
    100   1.1       cgd STATIC struct tblentry *cmdtable[CMDTABLESIZE];
    101   1.1       cgd STATIC int builtinloc = -1;		/* index in path of %builtin, or -1 */
    102  1.19  christos int exerrno = 0;			/* Last exec error */
    103   1.1       cgd 
    104   1.1       cgd 
    105  1.16  christos STATIC void tryexec __P((char *, char **, char **));
    106  1.16  christos STATIC void execinterp __P((char **, char **));
    107  1.16  christos STATIC void printentry __P((struct tblentry *, int));
    108  1.16  christos STATIC void clearcmdentry __P((int));
    109  1.16  christos STATIC struct tblentry *cmdlookup __P((char *, int));
    110  1.16  christos STATIC void delete_cmd_entry __P((void));
    111   1.1       cgd 
    112   1.1       cgd 
    113   1.1       cgd 
    114   1.1       cgd /*
    115   1.1       cgd  * Exec a program.  Never returns.  If you change this routine, you may
    116   1.1       cgd  * have to change the find_command routine as well.
    117   1.1       cgd  */
    118   1.1       cgd 
    119   1.1       cgd void
    120   1.1       cgd shellexec(argv, envp, path, index)
    121   1.1       cgd 	char **argv, **envp;
    122   1.1       cgd 	char *path;
    123  1.12       cgd 	int index;
    124  1.12       cgd {
    125   1.1       cgd 	char *cmdname;
    126   1.1       cgd 	int e;
    127   1.1       cgd 
    128   1.1       cgd 	if (strchr(argv[0], '/') != NULL) {
    129   1.1       cgd 		tryexec(argv[0], argv, envp);
    130   1.1       cgd 		e = errno;
    131   1.1       cgd 	} else {
    132   1.1       cgd 		e = ENOENT;
    133   1.1       cgd 		while ((cmdname = padvance(&path, argv[0])) != NULL) {
    134   1.1       cgd 			if (--index < 0 && pathopt == NULL) {
    135   1.1       cgd 				tryexec(cmdname, argv, envp);
    136   1.1       cgd 				if (errno != ENOENT && errno != ENOTDIR)
    137   1.1       cgd 					e = errno;
    138   1.1       cgd 			}
    139   1.1       cgd 			stunalloc(cmdname);
    140   1.1       cgd 		}
    141   1.1       cgd 	}
    142  1.19  christos 
    143  1.19  christos 	/* Map to POSIX errors */
    144  1.19  christos 	switch (e) {
    145  1.19  christos 	case EACCES:
    146  1.19  christos 		exerrno = 126;
    147  1.19  christos 		break;
    148  1.19  christos 	case ENOENT:
    149  1.19  christos 		exerrno = 127;
    150  1.19  christos 		break;
    151  1.19  christos 	default:
    152  1.19  christos 		exerrno = 2;
    153  1.19  christos 		break;
    154  1.19  christos 	}
    155  1.19  christos 	exerror(EXEXEC, "%s: %s", argv[0], errmsg(e, E_EXEC));
    156  1.26   mycroft 	/* NOTREACHED */
    157   1.1       cgd }
    158   1.1       cgd 
    159   1.1       cgd 
    160   1.1       cgd STATIC void
    161   1.1       cgd tryexec(cmd, argv, envp)
    162   1.1       cgd 	char *cmd;
    163   1.1       cgd 	char **argv;
    164   1.1       cgd 	char **envp;
    165   1.1       cgd 	{
    166   1.1       cgd 	int e;
    167  1.16  christos #ifndef BSD
    168   1.1       cgd 	char *p;
    169  1.16  christos #endif
    170   1.1       cgd 
    171   1.1       cgd #ifdef SYSV
    172   1.1       cgd 	do {
    173   1.1       cgd 		execve(cmd, argv, envp);
    174   1.1       cgd 	} while (errno == EINTR);
    175   1.1       cgd #else
    176   1.1       cgd 	execve(cmd, argv, envp);
    177   1.1       cgd #endif
    178   1.1       cgd 	e = errno;
    179   1.1       cgd 	if (e == ENOEXEC) {
    180   1.1       cgd 		initshellproc();
    181   1.1       cgd 		setinputfile(cmd, 0);
    182   1.1       cgd 		commandname = arg0 = savestr(argv[0]);
    183   1.1       cgd #ifndef BSD
    184   1.1       cgd 		pgetc(); pungetc();		/* fill up input buffer */
    185   1.1       cgd 		p = parsenextc;
    186   1.1       cgd 		if (parsenleft > 2 && p[0] == '#' && p[1] == '!') {
    187   1.1       cgd 			argv[0] = cmd;
    188   1.1       cgd 			execinterp(argv, envp);
    189   1.1       cgd 		}
    190   1.1       cgd #endif
    191   1.1       cgd 		setparam(argv + 1);
    192   1.1       cgd 		exraise(EXSHELLPROC);
    193   1.1       cgd 	}
    194   1.1       cgd 	errno = e;
    195   1.1       cgd }
    196   1.1       cgd 
    197   1.1       cgd 
    198   1.1       cgd #ifndef BSD
    199   1.1       cgd /*
    200   1.1       cgd  * Execute an interpreter introduced by "#!", for systems where this
    201   1.1       cgd  * feature has not been built into the kernel.  If the interpreter is
    202   1.1       cgd  * the shell, return (effectively ignoring the "#!").  If the execution
    203   1.1       cgd  * of the interpreter fails, exit.
    204   1.1       cgd  *
    205   1.1       cgd  * This code peeks inside the input buffer in order to avoid actually
    206   1.1       cgd  * reading any input.  It would benefit from a rewrite.
    207   1.1       cgd  */
    208   1.1       cgd 
    209   1.1       cgd #define NEWARGS 5
    210   1.1       cgd 
    211   1.1       cgd STATIC void
    212   1.1       cgd execinterp(argv, envp)
    213   1.1       cgd 	char **argv, **envp;
    214   1.1       cgd 	{
    215   1.1       cgd 	int n;
    216   1.1       cgd 	char *inp;
    217   1.1       cgd 	char *outp;
    218   1.1       cgd 	char c;
    219   1.1       cgd 	char *p;
    220   1.1       cgd 	char **ap;
    221   1.1       cgd 	char *newargs[NEWARGS];
    222   1.1       cgd 	int i;
    223   1.1       cgd 	char **ap2;
    224   1.1       cgd 	char **new;
    225   1.1       cgd 
    226   1.1       cgd 	n = parsenleft - 2;
    227   1.1       cgd 	inp = parsenextc + 2;
    228   1.1       cgd 	ap = newargs;
    229   1.1       cgd 	for (;;) {
    230   1.1       cgd 		while (--n >= 0 && (*inp == ' ' || *inp == '\t'))
    231   1.1       cgd 			inp++;
    232   1.1       cgd 		if (n < 0)
    233   1.1       cgd 			goto bad;
    234   1.1       cgd 		if ((c = *inp++) == '\n')
    235   1.1       cgd 			break;
    236   1.1       cgd 		if (ap == &newargs[NEWARGS])
    237   1.1       cgd bad:		  error("Bad #! line");
    238   1.1       cgd 		STARTSTACKSTR(outp);
    239   1.1       cgd 		do {
    240   1.1       cgd 			STPUTC(c, outp);
    241   1.1       cgd 		} while (--n >= 0 && (c = *inp++) != ' ' && c != '\t' && c != '\n');
    242   1.1       cgd 		STPUTC('\0', outp);
    243   1.1       cgd 		n++, inp--;
    244   1.1       cgd 		*ap++ = grabstackstr(outp);
    245   1.1       cgd 	}
    246   1.1       cgd 	if (ap == newargs + 1) {	/* if no args, maybe no exec is needed */
    247   1.1       cgd 		p = newargs[0];
    248   1.1       cgd 		for (;;) {
    249   1.1       cgd 			if (equal(p, "sh") || equal(p, "ash")) {
    250   1.1       cgd 				return;
    251   1.1       cgd 			}
    252   1.1       cgd 			while (*p != '/') {
    253   1.1       cgd 				if (*p == '\0')
    254   1.1       cgd 					goto break2;
    255   1.1       cgd 				p++;
    256   1.1       cgd 			}
    257   1.1       cgd 			p++;
    258   1.1       cgd 		}
    259   1.1       cgd break2:;
    260   1.1       cgd 	}
    261   1.1       cgd 	i = (char *)ap - (char *)newargs;		/* size in bytes */
    262   1.1       cgd 	if (i == 0)
    263   1.1       cgd 		error("Bad #! line");
    264   1.1       cgd 	for (ap2 = argv ; *ap2++ != NULL ; );
    265   1.1       cgd 	new = ckmalloc(i + ((char *)ap2 - (char *)argv));
    266   1.1       cgd 	ap = newargs, ap2 = new;
    267   1.1       cgd 	while ((i -= sizeof (char **)) >= 0)
    268   1.1       cgd 		*ap2++ = *ap++;
    269   1.1       cgd 	ap = argv;
    270   1.1       cgd 	while (*ap2++ = *ap++);
    271   1.1       cgd 	shellexec(new, envp, pathval(), 0);
    272  1.26   mycroft 	/* NOTREACHED */
    273   1.1       cgd }
    274   1.1       cgd #endif
    275   1.1       cgd 
    276   1.1       cgd 
    277   1.1       cgd 
    278   1.1       cgd /*
    279   1.1       cgd  * Do a path search.  The variable path (passed by reference) should be
    280   1.1       cgd  * set to the start of the path before the first call; padvance will update
    281   1.1       cgd  * this value as it proceeds.  Successive calls to padvance will return
    282   1.1       cgd  * the possible path expansions in sequence.  If an option (indicated by
    283   1.1       cgd  * a percent sign) appears in the path entry then the global variable
    284   1.1       cgd  * pathopt will be set to point to it; otherwise pathopt will be set to
    285   1.1       cgd  * NULL.
    286   1.1       cgd  */
    287   1.1       cgd 
    288   1.1       cgd char *pathopt;
    289   1.1       cgd 
    290   1.1       cgd char *
    291   1.1       cgd padvance(path, name)
    292   1.1       cgd 	char **path;
    293   1.1       cgd 	char *name;
    294   1.1       cgd 	{
    295  1.21       tls 	char *p, *q;
    296   1.1       cgd 	char *start;
    297   1.1       cgd 	int len;
    298   1.1       cgd 
    299   1.1       cgd 	if (*path == NULL)
    300   1.1       cgd 		return NULL;
    301   1.1       cgd 	start = *path;
    302   1.1       cgd 	for (p = start ; *p && *p != ':' && *p != '%' ; p++);
    303   1.1       cgd 	len = p - start + strlen(name) + 2;	/* "2" is for '/' and '\0' */
    304   1.1       cgd 	while (stackblocksize() < len)
    305   1.1       cgd 		growstackblock();
    306   1.1       cgd 	q = stackblock();
    307   1.1       cgd 	if (p != start) {
    308  1.11   mycroft 		memcpy(q, start, p - start);
    309   1.1       cgd 		q += p - start;
    310   1.1       cgd 		*q++ = '/';
    311   1.1       cgd 	}
    312   1.1       cgd 	strcpy(q, name);
    313   1.1       cgd 	pathopt = NULL;
    314   1.1       cgd 	if (*p == '%') {
    315   1.1       cgd 		pathopt = ++p;
    316   1.1       cgd 		while (*p && *p != ':')  p++;
    317   1.1       cgd 	}
    318   1.1       cgd 	if (*p == ':')
    319   1.1       cgd 		*path = p + 1;
    320   1.1       cgd 	else
    321   1.1       cgd 		*path = NULL;
    322   1.1       cgd 	return stalloc(len);
    323   1.1       cgd }
    324   1.1       cgd 
    325   1.1       cgd 
    326   1.1       cgd 
    327   1.1       cgd /*** Command hashing code ***/
    328   1.1       cgd 
    329   1.1       cgd 
    330  1.12       cgd int
    331  1.12       cgd hashcmd(argc, argv)
    332  1.12       cgd 	int argc;
    333  1.19  christos 	char **argv;
    334  1.12       cgd {
    335   1.1       cgd 	struct tblentry **pp;
    336   1.1       cgd 	struct tblentry *cmdp;
    337   1.1       cgd 	int c;
    338   1.1       cgd 	int verbose;
    339   1.1       cgd 	struct cmdentry entry;
    340   1.1       cgd 	char *name;
    341   1.1       cgd 
    342   1.1       cgd 	verbose = 0;
    343   1.1       cgd 	while ((c = nextopt("rv")) != '\0') {
    344   1.1       cgd 		if (c == 'r') {
    345   1.1       cgd 			clearcmdentry(0);
    346   1.1       cgd 		} else if (c == 'v') {
    347   1.1       cgd 			verbose++;
    348   1.1       cgd 		}
    349   1.1       cgd 	}
    350   1.8       jtc 	if (*argptr == NULL) {
    351   1.8       jtc 		for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) {
    352   1.8       jtc 			for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
    353   1.8       jtc 				printentry(cmdp, verbose);
    354   1.8       jtc 			}
    355   1.8       jtc 		}
    356   1.8       jtc 		return 0;
    357   1.8       jtc 	}
    358   1.1       cgd 	while ((name = *argptr) != NULL) {
    359   1.1       cgd 		if ((cmdp = cmdlookup(name, 0)) != NULL
    360   1.1       cgd 		 && (cmdp->cmdtype == CMDNORMAL
    361  1.16  christos 		     || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0)))
    362   1.1       cgd 			delete_cmd_entry();
    363  1.24  christos 		find_command(name, &entry, DO_ERR, pathval());
    364   1.1       cgd 		if (verbose) {
    365   1.1       cgd 			if (entry.cmdtype != CMDUNKNOWN) {	/* if no error msg */
    366   1.1       cgd 				cmdp = cmdlookup(name, 0);
    367   1.8       jtc 				printentry(cmdp, verbose);
    368   1.1       cgd 			}
    369   1.1       cgd 			flushall();
    370   1.1       cgd 		}
    371   1.1       cgd 		argptr++;
    372   1.1       cgd 	}
    373   1.1       cgd 	return 0;
    374   1.1       cgd }
    375   1.1       cgd 
    376   1.1       cgd 
    377   1.1       cgd STATIC void
    378   1.8       jtc printentry(cmdp, verbose)
    379   1.1       cgd 	struct tblentry *cmdp;
    380   1.8       jtc 	int verbose;
    381   1.1       cgd 	{
    382   1.1       cgd 	int index;
    383   1.1       cgd 	char *path;
    384   1.1       cgd 	char *name;
    385   1.1       cgd 
    386   1.1       cgd 	if (cmdp->cmdtype == CMDNORMAL) {
    387   1.1       cgd 		index = cmdp->param.index;
    388   1.1       cgd 		path = pathval();
    389   1.1       cgd 		do {
    390   1.1       cgd 			name = padvance(&path, cmdp->cmdname);
    391   1.1       cgd 			stunalloc(name);
    392   1.1       cgd 		} while (--index >= 0);
    393   1.1       cgd 		out1str(name);
    394   1.1       cgd 	} else if (cmdp->cmdtype == CMDBUILTIN) {
    395   1.1       cgd 		out1fmt("builtin %s", cmdp->cmdname);
    396   1.1       cgd 	} else if (cmdp->cmdtype == CMDFUNCTION) {
    397   1.1       cgd 		out1fmt("function %s", cmdp->cmdname);
    398   1.8       jtc 		if (verbose) {
    399   1.8       jtc 			INTOFF;
    400   1.8       jtc 			name = commandtext(cmdp->param.func);
    401   1.8       jtc 			out1c(' ');
    402   1.8       jtc 			out1str(name);
    403   1.8       jtc 			ckfree(name);
    404   1.8       jtc 			INTON;
    405   1.8       jtc 		}
    406   1.1       cgd #ifdef DEBUG
    407   1.1       cgd 	} else {
    408   1.1       cgd 		error("internal error: cmdtype %d", cmdp->cmdtype);
    409   1.1       cgd #endif
    410   1.1       cgd 	}
    411   1.1       cgd 	if (cmdp->rehash)
    412   1.1       cgd 		out1c('*');
    413   1.1       cgd 	out1c('\n');
    414   1.1       cgd }
    415   1.1       cgd 
    416   1.1       cgd 
    417   1.1       cgd 
    418   1.1       cgd /*
    419   1.1       cgd  * Resolve a command name.  If you change this routine, you may have to
    420   1.1       cgd  * change the shellexec routine as well.
    421   1.1       cgd  */
    422   1.1       cgd 
    423   1.1       cgd void
    424  1.24  christos find_command(name, entry, act, path)
    425   1.1       cgd 	char *name;
    426   1.1       cgd 	struct cmdentry *entry;
    427  1.24  christos 	int act;
    428  1.17  christos 	char *path;
    429  1.12       cgd {
    430   1.1       cgd 	struct tblentry *cmdp;
    431   1.1       cgd 	int index;
    432   1.1       cgd 	int prev;
    433   1.1       cgd 	char *fullname;
    434   1.1       cgd 	struct stat statb;
    435   1.1       cgd 	int e;
    436   1.1       cgd 	int i;
    437   1.1       cgd 
    438   1.1       cgd 	/* If name contains a slash, don't use the hash table */
    439   1.1       cgd 	if (strchr(name, '/') != NULL) {
    440  1.24  christos 		if (act & DO_ABS) {
    441  1.24  christos 			while (stat(name, &statb) < 0) {
    442  1.24  christos 	#ifdef SYSV
    443  1.24  christos 				if (errno == EINTR)
    444  1.24  christos 					continue;
    445  1.24  christos 	#endif
    446  1.24  christos 				if (errno != ENOENT && errno != ENOTDIR)
    447  1.24  christos 					e = errno;
    448  1.24  christos 				entry->cmdtype = CMDUNKNOWN;
    449  1.24  christos 				entry->u.index = -1;
    450  1.24  christos 				return;
    451  1.24  christos 			}
    452  1.24  christos 			entry->cmdtype = CMDNORMAL;
    453  1.24  christos 			entry->u.index = -1;
    454  1.24  christos 			return;
    455  1.24  christos 		}
    456   1.1       cgd 		entry->cmdtype = CMDNORMAL;
    457   1.1       cgd 		entry->u.index = 0;
    458   1.1       cgd 		return;
    459   1.1       cgd 	}
    460   1.1       cgd 
    461   1.1       cgd 	/* If name is in the table, and not invalidated by cd, we're done */
    462   1.1       cgd 	if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->rehash == 0)
    463   1.1       cgd 		goto success;
    464   1.1       cgd 
    465   1.1       cgd 	/* If %builtin not in path, check for builtin next */
    466   1.1       cgd 	if (builtinloc < 0 && (i = find_builtin(name)) >= 0) {
    467   1.1       cgd 		INTOFF;
    468   1.1       cgd 		cmdp = cmdlookup(name, 1);
    469   1.1       cgd 		cmdp->cmdtype = CMDBUILTIN;
    470   1.1       cgd 		cmdp->param.index = i;
    471   1.1       cgd 		INTON;
    472   1.1       cgd 		goto success;
    473   1.1       cgd 	}
    474   1.1       cgd 
    475   1.1       cgd 	/* We have to search path. */
    476   1.1       cgd 	prev = -1;		/* where to start */
    477   1.1       cgd 	if (cmdp) {		/* doing a rehash */
    478   1.1       cgd 		if (cmdp->cmdtype == CMDBUILTIN)
    479   1.1       cgd 			prev = builtinloc;
    480   1.1       cgd 		else
    481   1.1       cgd 			prev = cmdp->param.index;
    482   1.1       cgd 	}
    483   1.1       cgd 
    484   1.1       cgd 	e = ENOENT;
    485   1.1       cgd 	index = -1;
    486   1.1       cgd loop:
    487   1.1       cgd 	while ((fullname = padvance(&path, name)) != NULL) {
    488   1.1       cgd 		stunalloc(fullname);
    489   1.1       cgd 		index++;
    490   1.1       cgd 		if (pathopt) {
    491   1.1       cgd 			if (prefix("builtin", pathopt)) {
    492   1.1       cgd 				if ((i = find_builtin(name)) < 0)
    493   1.1       cgd 					goto loop;
    494   1.1       cgd 				INTOFF;
    495   1.1       cgd 				cmdp = cmdlookup(name, 1);
    496   1.1       cgd 				cmdp->cmdtype = CMDBUILTIN;
    497   1.1       cgd 				cmdp->param.index = i;
    498   1.1       cgd 				INTON;
    499   1.1       cgd 				goto success;
    500   1.1       cgd 			} else if (prefix("func", pathopt)) {
    501   1.1       cgd 				/* handled below */
    502   1.1       cgd 			} else {
    503   1.1       cgd 				goto loop;	/* ignore unimplemented options */
    504   1.1       cgd 			}
    505   1.1       cgd 		}
    506   1.1       cgd 		/* if rehash, don't redo absolute path names */
    507   1.1       cgd 		if (fullname[0] == '/' && index <= prev) {
    508   1.1       cgd 			if (index < prev)
    509   1.1       cgd 				goto loop;
    510   1.1       cgd 			TRACE(("searchexec \"%s\": no change\n", name));
    511   1.1       cgd 			goto success;
    512   1.1       cgd 		}
    513   1.1       cgd 		while (stat(fullname, &statb) < 0) {
    514   1.1       cgd #ifdef SYSV
    515   1.1       cgd 			if (errno == EINTR)
    516   1.1       cgd 				continue;
    517   1.1       cgd #endif
    518   1.1       cgd 			if (errno != ENOENT && errno != ENOTDIR)
    519   1.1       cgd 				e = errno;
    520   1.1       cgd 			goto loop;
    521   1.1       cgd 		}
    522   1.1       cgd 		e = EACCES;	/* if we fail, this will be the error */
    523  1.14   mycroft 		if (!S_ISREG(statb.st_mode))
    524   1.1       cgd 			goto loop;
    525   1.1       cgd 		if (pathopt) {		/* this is a %func directory */
    526   1.1       cgd 			stalloc(strlen(fullname) + 1);
    527   1.1       cgd 			readcmdfile(fullname);
    528   1.1       cgd 			if ((cmdp = cmdlookup(name, 0)) == NULL || cmdp->cmdtype != CMDFUNCTION)
    529   1.1       cgd 				error("%s not defined in %s", name, fullname);
    530   1.1       cgd 			stunalloc(fullname);
    531   1.1       cgd 			goto success;
    532   1.1       cgd 		}
    533   1.8       jtc #ifdef notdef
    534   1.8       jtc 		if (statb.st_uid == geteuid()) {
    535   1.1       cgd 			if ((statb.st_mode & 0100) == 0)
    536   1.1       cgd 				goto loop;
    537   1.1       cgd 		} else if (statb.st_gid == getegid()) {
    538   1.1       cgd 			if ((statb.st_mode & 010) == 0)
    539   1.1       cgd 				goto loop;
    540   1.1       cgd 		} else {
    541   1.8       jtc 			if ((statb.st_mode & 01) == 0)
    542   1.1       cgd 				goto loop;
    543   1.1       cgd 		}
    544   1.4       cgd #endif
    545   1.1       cgd 		TRACE(("searchexec \"%s\" returns \"%s\"\n", name, fullname));
    546   1.1       cgd 		INTOFF;
    547   1.1       cgd 		cmdp = cmdlookup(name, 1);
    548   1.1       cgd 		cmdp->cmdtype = CMDNORMAL;
    549   1.1       cgd 		cmdp->param.index = index;
    550   1.1       cgd 		INTON;
    551   1.1       cgd 		goto success;
    552   1.1       cgd 	}
    553   1.1       cgd 
    554   1.1       cgd 	/* We failed.  If there was an entry for this command, delete it */
    555   1.1       cgd 	if (cmdp)
    556   1.1       cgd 		delete_cmd_entry();
    557  1.24  christos 	if (act & DO_ERR)
    558  1.20    abrown 		outfmt(out2, "%s: %s\n", name, errmsg(e, E_EXEC));
    559   1.1       cgd 	entry->cmdtype = CMDUNKNOWN;
    560   1.1       cgd 	return;
    561   1.1       cgd 
    562   1.1       cgd success:
    563   1.1       cgd 	cmdp->rehash = 0;
    564   1.1       cgd 	entry->cmdtype = cmdp->cmdtype;
    565   1.1       cgd 	entry->u = cmdp->param;
    566   1.1       cgd }
    567   1.1       cgd 
    568   1.1       cgd 
    569   1.1       cgd 
    570   1.1       cgd /*
    571   1.1       cgd  * Search the table of builtin commands.
    572   1.1       cgd  */
    573   1.1       cgd 
    574   1.1       cgd int
    575   1.1       cgd find_builtin(name)
    576   1.1       cgd 	char *name;
    577  1.12       cgd {
    578  1.21       tls 	const struct builtincmd *bp;
    579   1.1       cgd 
    580   1.1       cgd 	for (bp = builtincmd ; bp->name ; bp++) {
    581   1.1       cgd 		if (*bp->name == *name && equal(bp->name, name))
    582   1.1       cgd 			return bp->code;
    583   1.1       cgd 	}
    584   1.1       cgd 	return -1;
    585   1.1       cgd }
    586   1.1       cgd 
    587   1.1       cgd 
    588   1.1       cgd 
    589   1.1       cgd /*
    590   1.1       cgd  * Called when a cd is done.  Marks all commands so the next time they
    591   1.1       cgd  * are executed they will be rehashed.
    592   1.1       cgd  */
    593   1.1       cgd 
    594   1.1       cgd void
    595   1.1       cgd hashcd() {
    596   1.1       cgd 	struct tblentry **pp;
    597   1.1       cgd 	struct tblentry *cmdp;
    598   1.1       cgd 
    599   1.1       cgd 	for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) {
    600   1.1       cgd 		for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
    601   1.1       cgd 			if (cmdp->cmdtype == CMDNORMAL
    602  1.16  christos 			 || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0))
    603   1.1       cgd 				cmdp->rehash = 1;
    604   1.1       cgd 		}
    605   1.1       cgd 	}
    606   1.1       cgd }
    607   1.1       cgd 
    608   1.1       cgd 
    609   1.1       cgd 
    610   1.1       cgd /*
    611   1.1       cgd  * Called before PATH is changed.  The argument is the new value of PATH;
    612   1.1       cgd  * pathval() still returns the old value at this point.  Called with
    613   1.1       cgd  * interrupts off.
    614   1.1       cgd  */
    615   1.1       cgd 
    616   1.1       cgd void
    617   1.1       cgd changepath(newval)
    618  1.18  christos 	const char *newval;
    619  1.13   mycroft {
    620  1.18  christos 	const char *old, *new;
    621   1.1       cgd 	int index;
    622   1.1       cgd 	int firstchange;
    623   1.1       cgd 	int bltin;
    624   1.1       cgd 
    625   1.1       cgd 	old = pathval();
    626   1.1       cgd 	new = newval;
    627   1.1       cgd 	firstchange = 9999;	/* assume no change */
    628  1.13   mycroft 	index = 0;
    629   1.1       cgd 	bltin = -1;
    630   1.1       cgd 	for (;;) {
    631   1.1       cgd 		if (*old != *new) {
    632   1.1       cgd 			firstchange = index;
    633  1.16  christos 			if ((*old == '\0' && *new == ':')
    634  1.16  christos 			 || (*old == ':' && *new == '\0'))
    635   1.1       cgd 				firstchange++;
    636   1.1       cgd 			old = new;	/* ignore subsequent differences */
    637   1.1       cgd 		}
    638   1.1       cgd 		if (*new == '\0')
    639   1.1       cgd 			break;
    640   1.1       cgd 		if (*new == '%' && bltin < 0 && prefix("builtin", new + 1))
    641   1.1       cgd 			bltin = index;
    642   1.1       cgd 		if (*new == ':') {
    643   1.1       cgd 			index++;
    644   1.1       cgd 		}
    645   1.1       cgd 		new++, old++;
    646   1.1       cgd 	}
    647   1.1       cgd 	if (builtinloc < 0 && bltin >= 0)
    648   1.1       cgd 		builtinloc = bltin;		/* zap builtins */
    649   1.1       cgd 	if (builtinloc >= 0 && bltin < 0)
    650   1.1       cgd 		firstchange = 0;
    651   1.1       cgd 	clearcmdentry(firstchange);
    652   1.1       cgd 	builtinloc = bltin;
    653   1.1       cgd }
    654   1.1       cgd 
    655   1.1       cgd 
    656   1.1       cgd /*
    657   1.1       cgd  * Clear out command entries.  The argument specifies the first entry in
    658   1.1       cgd  * PATH which has changed.
    659   1.1       cgd  */
    660   1.1       cgd 
    661   1.1       cgd STATIC void
    662  1.12       cgd clearcmdentry(firstchange)
    663  1.12       cgd 	int firstchange;
    664  1.12       cgd {
    665   1.1       cgd 	struct tblentry **tblp;
    666   1.1       cgd 	struct tblentry **pp;
    667   1.1       cgd 	struct tblentry *cmdp;
    668   1.1       cgd 
    669   1.1       cgd 	INTOFF;
    670   1.1       cgd 	for (tblp = cmdtable ; tblp < &cmdtable[CMDTABLESIZE] ; tblp++) {
    671   1.1       cgd 		pp = tblp;
    672   1.1       cgd 		while ((cmdp = *pp) != NULL) {
    673  1.16  christos 			if ((cmdp->cmdtype == CMDNORMAL &&
    674  1.16  christos 			     cmdp->param.index >= firstchange)
    675  1.16  christos 			 || (cmdp->cmdtype == CMDBUILTIN &&
    676  1.16  christos 			     builtinloc >= firstchange)) {
    677   1.1       cgd 				*pp = cmdp->next;
    678   1.1       cgd 				ckfree(cmdp);
    679   1.1       cgd 			} else {
    680   1.1       cgd 				pp = &cmdp->next;
    681   1.1       cgd 			}
    682   1.1       cgd 		}
    683   1.1       cgd 	}
    684   1.1       cgd 	INTON;
    685   1.1       cgd }
    686   1.1       cgd 
    687   1.1       cgd 
    688   1.1       cgd /*
    689   1.1       cgd  * Delete all functions.
    690   1.1       cgd  */
    691   1.1       cgd 
    692   1.1       cgd #ifdef mkinit
    693  1.23  christos MKINIT void deletefuncs __P((void));
    694   1.1       cgd 
    695   1.1       cgd SHELLPROC {
    696   1.1       cgd 	deletefuncs();
    697   1.1       cgd }
    698   1.1       cgd #endif
    699   1.1       cgd 
    700   1.1       cgd void
    701   1.1       cgd deletefuncs() {
    702   1.1       cgd 	struct tblentry **tblp;
    703   1.1       cgd 	struct tblentry **pp;
    704   1.1       cgd 	struct tblentry *cmdp;
    705   1.1       cgd 
    706   1.1       cgd 	INTOFF;
    707   1.1       cgd 	for (tblp = cmdtable ; tblp < &cmdtable[CMDTABLESIZE] ; tblp++) {
    708   1.1       cgd 		pp = tblp;
    709   1.1       cgd 		while ((cmdp = *pp) != NULL) {
    710   1.1       cgd 			if (cmdp->cmdtype == CMDFUNCTION) {
    711   1.1       cgd 				*pp = cmdp->next;
    712   1.1       cgd 				freefunc(cmdp->param.func);
    713   1.1       cgd 				ckfree(cmdp);
    714   1.1       cgd 			} else {
    715   1.1       cgd 				pp = &cmdp->next;
    716   1.1       cgd 			}
    717   1.1       cgd 		}
    718   1.1       cgd 	}
    719   1.1       cgd 	INTON;
    720   1.1       cgd }
    721   1.1       cgd 
    722   1.1       cgd 
    723   1.1       cgd 
    724   1.1       cgd /*
    725   1.1       cgd  * Locate a command in the command hash table.  If "add" is nonzero,
    726   1.1       cgd  * add the command to the table if it is not already present.  The
    727   1.1       cgd  * variable "lastcmdentry" is set to point to the address of the link
    728   1.1       cgd  * pointing to the entry, so that delete_cmd_entry can delete the
    729   1.1       cgd  * entry.
    730   1.1       cgd  */
    731   1.1       cgd 
    732   1.1       cgd struct tblentry **lastcmdentry;
    733   1.1       cgd 
    734   1.1       cgd 
    735   1.1       cgd STATIC struct tblentry *
    736   1.1       cgd cmdlookup(name, add)
    737   1.1       cgd 	char *name;
    738  1.12       cgd 	int add;
    739  1.12       cgd {
    740   1.1       cgd 	int hashval;
    741  1.21       tls 	char *p;
    742   1.1       cgd 	struct tblentry *cmdp;
    743   1.1       cgd 	struct tblentry **pp;
    744   1.1       cgd 
    745   1.1       cgd 	p = name;
    746   1.1       cgd 	hashval = *p << 4;
    747   1.1       cgd 	while (*p)
    748   1.1       cgd 		hashval += *p++;
    749   1.1       cgd 	hashval &= 0x7FFF;
    750   1.1       cgd 	pp = &cmdtable[hashval % CMDTABLESIZE];
    751   1.1       cgd 	for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
    752   1.1       cgd 		if (equal(cmdp->cmdname, name))
    753   1.1       cgd 			break;
    754   1.1       cgd 		pp = &cmdp->next;
    755   1.1       cgd 	}
    756   1.1       cgd 	if (add && cmdp == NULL) {
    757   1.1       cgd 		INTOFF;
    758   1.1       cgd 		cmdp = *pp = ckmalloc(sizeof (struct tblentry) - ARB
    759   1.1       cgd 					+ strlen(name) + 1);
    760   1.1       cgd 		cmdp->next = NULL;
    761   1.1       cgd 		cmdp->cmdtype = CMDUNKNOWN;
    762   1.1       cgd 		cmdp->rehash = 0;
    763   1.1       cgd 		strcpy(cmdp->cmdname, name);
    764   1.1       cgd 		INTON;
    765   1.1       cgd 	}
    766   1.1       cgd 	lastcmdentry = pp;
    767   1.1       cgd 	return cmdp;
    768   1.1       cgd }
    769   1.1       cgd 
    770   1.1       cgd /*
    771   1.1       cgd  * Delete the command entry returned on the last lookup.
    772   1.1       cgd  */
    773   1.1       cgd 
    774   1.1       cgd STATIC void
    775   1.1       cgd delete_cmd_entry() {
    776   1.1       cgd 	struct tblentry *cmdp;
    777   1.1       cgd 
    778   1.1       cgd 	INTOFF;
    779   1.1       cgd 	cmdp = *lastcmdentry;
    780   1.1       cgd 	*lastcmdentry = cmdp->next;
    781   1.1       cgd 	ckfree(cmdp);
    782   1.1       cgd 	INTON;
    783   1.1       cgd }
    784   1.1       cgd 
    785   1.1       cgd 
    786   1.1       cgd 
    787   1.1       cgd #ifdef notdef
    788   1.1       cgd void
    789   1.1       cgd getcmdentry(name, entry)
    790   1.1       cgd 	char *name;
    791  1.19  christos 	struct cmdentry *entry;
    792   1.1       cgd 	{
    793   1.1       cgd 	struct tblentry *cmdp = cmdlookup(name, 0);
    794   1.1       cgd 
    795   1.1       cgd 	if (cmdp) {
    796   1.1       cgd 		entry->u = cmdp->param;
    797   1.1       cgd 		entry->cmdtype = cmdp->cmdtype;
    798   1.1       cgd 	} else {
    799   1.1       cgd 		entry->cmdtype = CMDUNKNOWN;
    800   1.1       cgd 		entry->u.index = 0;
    801   1.1       cgd 	}
    802   1.1       cgd }
    803   1.1       cgd #endif
    804   1.1       cgd 
    805   1.1       cgd 
    806   1.1       cgd /*
    807   1.1       cgd  * Add a new command entry, replacing any existing command entry for
    808   1.1       cgd  * the same name.
    809   1.1       cgd  */
    810   1.1       cgd 
    811   1.1       cgd void
    812   1.1       cgd addcmdentry(name, entry)
    813   1.1       cgd 	char *name;
    814   1.1       cgd 	struct cmdentry *entry;
    815   1.1       cgd 	{
    816   1.1       cgd 	struct tblentry *cmdp;
    817   1.1       cgd 
    818   1.1       cgd 	INTOFF;
    819   1.1       cgd 	cmdp = cmdlookup(name, 1);
    820   1.1       cgd 	if (cmdp->cmdtype == CMDFUNCTION) {
    821   1.1       cgd 		freefunc(cmdp->param.func);
    822   1.1       cgd 	}
    823   1.1       cgd 	cmdp->cmdtype = entry->cmdtype;
    824   1.1       cgd 	cmdp->param = entry->u;
    825   1.1       cgd 	INTON;
    826   1.1       cgd }
    827   1.1       cgd 
    828   1.1       cgd 
    829   1.1       cgd /*
    830   1.1       cgd  * Define a shell function.
    831   1.1       cgd  */
    832   1.1       cgd 
    833   1.1       cgd void
    834   1.1       cgd defun(name, func)
    835   1.1       cgd 	char *name;
    836   1.1       cgd 	union node *func;
    837   1.1       cgd 	{
    838   1.1       cgd 	struct cmdentry entry;
    839   1.1       cgd 
    840   1.1       cgd 	INTOFF;
    841   1.1       cgd 	entry.cmdtype = CMDFUNCTION;
    842   1.1       cgd 	entry.u.func = copyfunc(func);
    843   1.1       cgd 	addcmdentry(name, &entry);
    844   1.1       cgd 	INTON;
    845   1.1       cgd }
    846   1.1       cgd 
    847   1.1       cgd 
    848   1.1       cgd /*
    849   1.1       cgd  * Delete a function if it exists.
    850   1.1       cgd  */
    851   1.1       cgd 
    852   1.8       jtc int
    853   1.1       cgd unsetfunc(name)
    854   1.1       cgd 	char *name;
    855   1.1       cgd 	{
    856   1.1       cgd 	struct tblentry *cmdp;
    857   1.1       cgd 
    858   1.1       cgd 	if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->cmdtype == CMDFUNCTION) {
    859   1.1       cgd 		freefunc(cmdp->param.func);
    860   1.1       cgd 		delete_cmd_entry();
    861   1.8       jtc 		return (0);
    862   1.1       cgd 	}
    863   1.8       jtc 	return (1);
    864  1.22  christos }
    865  1.22  christos 
    866  1.22  christos /*
    867  1.22  christos  * Locate and print what a word is...
    868  1.22  christos  */
    869  1.22  christos 
    870  1.22  christos int
    871  1.22  christos typecmd(argc, argv)
    872  1.22  christos 	int argc;
    873  1.22  christos 	char **argv;
    874  1.22  christos {
    875  1.22  christos 	struct cmdentry entry;
    876  1.22  christos 	struct tblentry *cmdp;
    877  1.22  christos 	char **pp;
    878  1.22  christos 	struct alias *ap;
    879  1.22  christos 	int i;
    880  1.22  christos 	int error = 0;
    881  1.22  christos 	extern char *const parsekwd[];
    882  1.22  christos 
    883  1.22  christos 	for (i = 1; i < argc; i++) {
    884  1.22  christos 		out1str(argv[i]);
    885  1.22  christos 		/* First look at the keywords */
    886  1.22  christos 		for (pp = (char **)parsekwd; *pp; pp++)
    887  1.22  christos 			if (**pp == *argv[i] && equal(*pp, argv[i]))
    888  1.22  christos 				break;
    889  1.22  christos 
    890  1.22  christos 		if (*pp) {
    891  1.22  christos 			out1str(" is a shell keyword\n");
    892  1.22  christos 			continue;
    893  1.22  christos 		}
    894  1.22  christos 
    895  1.22  christos 		/* Then look at the aliases */
    896  1.22  christos 		if ((ap = lookupalias(argv[i], 1)) != NULL) {
    897  1.22  christos 			out1fmt(" is an alias for %s\n", ap->val);
    898  1.22  christos 			continue;
    899  1.22  christos 		}
    900  1.22  christos 
    901  1.22  christos 		/* Then check if it is a tracked alias */
    902  1.22  christos 		if ((cmdp = cmdlookup(argv[i], 0)) != NULL) {
    903  1.22  christos 			entry.cmdtype = cmdp->cmdtype;
    904  1.22  christos 			entry.u = cmdp->param;
    905  1.22  christos 		}
    906  1.22  christos 		else {
    907  1.22  christos 			/* Finally use brute force */
    908  1.24  christos 			find_command(argv[i], &entry, DO_ABS, pathval());
    909  1.22  christos 		}
    910  1.22  christos 
    911  1.22  christos 		switch (entry.cmdtype) {
    912  1.22  christos 		case CMDNORMAL: {
    913  1.22  christos 			int j = entry.u.index;
    914  1.22  christos 			char *path = pathval(), *name;
    915  1.24  christos 			if (j == -1)
    916  1.24  christos 				name = argv[i];
    917  1.24  christos 			else {
    918  1.24  christos 				do {
    919  1.24  christos 					name = padvance(&path, argv[i]);
    920  1.24  christos 					stunalloc(name);
    921  1.24  christos 				} while (--j >= 0);
    922  1.24  christos 			}
    923  1.22  christos 			out1fmt(" is%s %s\n",
    924  1.22  christos 			    cmdp ? " a tracked alias for" : "", name);
    925  1.22  christos 			break;
    926  1.22  christos 		}
    927  1.22  christos 		case CMDFUNCTION:
    928  1.22  christos 			out1str(" is a shell function\n");
    929  1.22  christos 			break;
    930  1.22  christos 
    931  1.22  christos 		case CMDBUILTIN:
    932  1.22  christos 			out1str(" is a shell builtin\n");
    933  1.22  christos 			break;
    934  1.22  christos 
    935  1.22  christos 		default:
    936  1.22  christos 			out1str(" not found\n");
    937  1.22  christos 			error |= 127;
    938  1.22  christos 			break;
    939  1.22  christos 		}
    940  1.22  christos 	}
    941  1.22  christos 	return error;
    942   1.1       cgd }
    943