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