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