exec.c@ 885

Last change on this file since 885 was 885, checked in by bird, 18 years ago
PC_SLASHES
Property svn:eol-style set to `native`
File size: 25.9 KB

Line
1	/* $NetBSD: exec.c,v 1.37 2003/08/07 09:05:31 agc Exp $ */
2
3	/*-
4	* Copyright (c) 1991, 1993
5	* The Regents of the University of California. All rights reserved.
6	*
7	* This code is derived from software contributed to Berkeley by
8	* Kenneth Almquist.
9	*
10	* Redistribution and use in source and binary forms, with or without
11	* modification, are permitted provided that the following conditions
12	* are met:
13	* 1. Redistributions of source code must retain the above copyright
14	* notice, this list of conditions and the following disclaimer.
15	* 2. Redistributions in binary form must reproduce the above copyright
16	* notice, this list of conditions and the following disclaimer in the
17	* documentation and/or other materials provided with the distribution.
18	* 3. Neither the name of the University nor the names of its contributors
19	* may be used to endorse or promote products derived from this software
20	* without specific prior written permission.
21	*
22	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32	* SUCH DAMAGE.
33	*/
34
35	#ifdef HAVE_SYS_CDEFS_H
36	#include <sys/cdefs.h>
37	#endif
38	#ifndef lint
39	#if 0
40	static char sccsid[] = "@(#)exec.c 8.4 (Berkeley) 6/8/95";
41	#else
42	__RCSID("$NetBSD: exec.c,v 1.37 2003/08/07 09:05:31 agc Exp $");
43	#endif
44	#endif /* not lint */
45
46	#include <sys/types.h>
47	#include <sys/stat.h>
48	#include <sys/wait.h>
49	#include <unistd.h>
50	#include <fcntl.h>
51	#include <errno.h>
52	#include <stdio.h>
53	#include <stdlib.h>
54
55	/*
56	* When commands are first encountered, they are entered in a hash table.
57	* This ensures that a full path search will not have to be done for them
58	* on each invocation.
59	*
60	* We should investigate converting to a linear search, even though that
61	* would make the command name "hash" a misnomer.
62	*/
63
64	#include "shell.h"
65	#include "main.h"
66	#include "nodes.h"
67	#include "parser.h"
68	#include "redir.h"
69	#include "eval.h"
70	#include "exec.h"
71	#include "builtins.h"
72	#include "var.h"
73	#include "options.h"
74	#include "input.h"
75	#include "output.h"
76	#include "syntax.h"
77	#include "memalloc.h"
78	#include "error.h"
79	#include "init.h"
80	#include "mystring.h"
81	#include "show.h"
82	#include "jobs.h"
83	#include "alias.h"
84	#ifdef __INNOTEK_LIBC__
85	#include <InnoTekLIBC/backend.h>
86	#endif
87
88
89	#define CMDTABLESIZE 31 /* should be prime */
90	#define ARB 1 /* actual size determined at run time */
91
92
93
94	struct tblentry {
95	struct tblentry next; / next entry in hash chain */
96	union param param; /* definition of builtin function */
97	short cmdtype; /* index identifying command */
98	char rehash; /* if set, cd done since entry created */
99	char cmdname[ARB]; /* name of command */
100	};
101
102
103	STATIC struct tblentry *cmdtable[CMDTABLESIZE];
104	STATIC int builtinloc = -1; /* index in path of %builtin, or -1 */
105	int exerrno = 0; /* Last exec error */
106
107
108	STATIC void tryexec(char , char , char *, int, int);
109	STATIC void execinterp(char , char );
110	STATIC void printentry(struct tblentry *, int);
111	STATIC void clearcmdentry(int);
112	STATIC struct tblentry cmdlookup(const char , int);
113	STATIC void delete_cmd_entry(void);
114	#ifdef PC_EXE_EXTS
115	STATIC int stat_pc_exec_exts(char fullname, struct stat st, int has_ext);
116	#endif
117
118
119	extern char *const parsekwd[];
120
121	/*
122	* Exec a program. Never returns. If you change this routine, you may
123	* have to change the find_command routine as well.
124	*/
125
126	void
127	shellexec(char argv, char envp, const char *path, int idx, int vforked)
128	{
129	char *cmdname;
130	int e;
131	#ifdef PC_EXE_EXTS
132	int has_ext = strlen(argv[0]) - 4;
133	has_ext = has_ext > 0
134	&& argv[0][has_ext] == '.'
135	/* use strstr and upper/lower permuated extensions to avoid multiple strcasecmp calls. */
136	&& strstr("exe;" "Exe;" "EXe;" "EXE;" "ExE;" "eXe;" "eXE;" "exE;"
137	"cmd;" "Cmd;" "CMd;" "CMD;" "CmD;" "cMd;" "cMD;" "cmD;"
138	"com;" "Com;" "COm;" "COM;" "CoM;" "cOm;" "cOM;" "coM;"
139	"bat;" "Bat;" "BAt;" "BAT;" "BaT;" "bAt;" "bAT;" "baT;"
140	"btm;" "Btm;" "BTm;" "BTM;" "BtM;" "bTm;" "bTM;" "btM;",
141	argv[0] + has_ext + 1)
142	!= NULL;
143	#else
144	const int has_ext = 1;
145	#endif
146	TRACE(("shellexec: argv[0]=%s idx=%d\n", argv[0], idx));
147	if (strchr(argv[0], '/') != NULL) {
148	cmdname = stalloc(strlen(argv[0]) + 5);
149	strcpy(cmdname, argv[0]);
150	tryexec(cmdname, argv, envp, vforked, has_ext);
151	TRACE(("shellexec: cmdname=%s\n", cmdname));
152	stunalloc(cmdname);
153	e = errno;
154	} else {
155	e = ENOENT;
156	while ((cmdname = padvance(&path, argv[0])) != NULL) {
157	if (--idx < 0 && pathopt == NULL) {
158	tryexec(cmdname, argv, envp, vforked, has_ext);
159	if (errno != ENOENT && errno != ENOTDIR)
160	e = errno;
161	}
162	stunalloc(cmdname);
163	}
164	}
165
166	/* Map to POSIX errors */
167	switch (e) {
168	case EACCES:
169	exerrno = 126;
170	break;
171	case ENOENT:
172	exerrno = 127;
173	break;
174	default:
175	exerrno = 2;
176	break;
177	}
178	TRACE(("shellexec failed for '%s', errno %d, vforked %d, suppressint %d\n",
179	argv[0], e, vforked, suppressint ));
180	exerror(EXEXEC, "%s: %s", argv[0], errmsg(e, E_EXEC));
181	/* NOTREACHED */
182	}
183
184
185	STATIC void
186	tryexec(char cmd, char argv, char *envp, int vforked, int has_ext)
187	{
188	int e;
189	#ifdef EXEC_HASH_BANG_SCRIPT
190	char *p;
191	#endif
192	#ifdef PC_EXE_EXTS
193	/* exploit the effect of stat_pc_exec_exts which adds the
194	* correct extentions to the file.
195	*/
196	struct stat st;
197	if (!has_ext)
198	stat_pc_exec_exts(cmd, &st, 0);
199	#endif
200	#if defined __INNOTEK_LIBC__ && defined EXEC_HASH_BANG_SCRIPT
201	__libc_Back_gfProcessHandleHashBangScripts = 0;
202	#endif
203
204	#ifdef SYSV
205	do {
206	execve(cmd, argv, envp);
207	} while (errno == EINTR);
208	#else
209	execve(cmd, argv, envp);
210	#endif
211	e = errno;
212	if (e == ENOEXEC) {
213	if (vforked) {
214	/* We are currently vfork(2)ed, so raise an
215	* exception, and evalcommand will try again
216	* with a normal fork(2).
217	*/
218	exraise(EXSHELLPROC);
219	}
220	initshellproc();
221	setinputfile(cmd, 0);
222	commandname = arg0 = savestr(argv[0]);
223	#ifdef EXEC_HASH_BANG_SCRIPT
224	pgetc(); pungetc(); /* fill up input buffer */
225	p = parsenextc;
226	if (parsenleft > 2 && p[0] == '#' && p[1] == '!') {
227	argv[0] = cmd;
228	execinterp(argv, envp);
229	}
230	#endif
231	setparam(argv + 1);
232	exraise(EXSHELLPROC);
233	}
234	errno = e;
235	}
236
237
238	#ifdef EXEC_HASH_BANG_SCRIPT
239	/*
240	* Execute an interpreter introduced by "#!", for systems where this
241	* feature has not been built into the kernel. If the interpreter is
242	* the shell, return (effectively ignoring the "#!"). If the execution
243	* of the interpreter fails, exit.
244	*
245	* This code peeks inside the input buffer in order to avoid actually
246	* reading any input. It would benefit from a rewrite.
247	*/
248
249	#define NEWARGS 5
250
251	STATIC void
252	execinterp(char argv, char envp)
253	{
254	int n;
255	char *inp;
256	char *outp;
257	char c;
258	char *p;
259	char **ap;
260	char *newargs[NEWARGS];
261	int i;
262	char **ap2;
263	char **new;
264
265	n = parsenleft - 2;
266	inp = parsenextc + 2;
267	ap = newargs;
268	for (;;) {
269	while (--n >= 0 && (inp == ' ' \|\| inp == '\t'))
270	inp++;
271	if (n < 0)
272	goto bad;
273	if ((c = *inp++) == '\n')
274	break;
275	if (ap == &newargs[NEWARGS])
276	bad: error("Bad #! line");
277	STARTSTACKSTR(outp);
278	do {
279	STPUTC(c, outp);
280	} while (--n >= 0 && (c = *inp++) != ' ' && c != '\t' && c != '\n');
281	STPUTC('\0', outp);
282	n++, inp--;
283	*ap++ = grabstackstr(outp);
284	}
285	if (ap == newargs + 1) { /* if no args, maybe no exec is needed */
286	p = newargs[0];
287	for (;;) {
288	if (equal(p, "sh") \|\| equal(p, "ash")) {
289	TRACE(("hash bang self\n"));
290	return;
291	}
292	while (*p != '/') {
293	if (*p == '\0')
294	goto break2;
295	p++;
296	}
297	p++;
298	}
299	break2:;
300	}
301	i = (char )ap - (char )newargs; /* size in bytes */
302	if (i == 0)
303	error("Bad #! line");
304	for (ap2 = argv ; *ap2++ != NULL ; );
305	new = ckmalloc(i + ((char )ap2 - (char )argv));
306	ap = newargs, ap2 = new;
307	while ((i -= sizeof (char **)) >= 0)
308	ap2++ = ap++;
309	ap = argv;
310	while (ap2++ = ap++);
311	TRACE(("hash bang '%s'\n", new[0]));
312	shellexec(new, envp, pathval(), 0, 0);
313	/* NOTREACHED */
314	}
315	#endif
316
317
318
319	/*
320	* Do a path search. The variable path (passed by reference) should be
321	* set to the start of the path before the first call; padvance will update
322	* this value as it proceeds. Successive calls to padvance will return
323	* the possible path expansions in sequence. If an option (indicated by
324	* a percent sign) appears in the path entry then the global variable
325	* pathopt will be set to point to it; otherwise pathopt will be set to
326	* NULL.
327	*/
328
329	const char *pathopt;
330
331	char *
332	padvance(const char *path, const char name)
333	{
334	const char *p;
335	char *q;
336	#ifdef PC_SLASHES
337	char *s;
338	#endif
339	const char *start;
340	int len;
341
342	if (*path == NULL)
343	return NULL;
344	start = *path;
345	#ifdef PC_PATH_SEP
346	for (p = start ; p && p != ';' && *p != '%' ; p++);
347	#else
348	for (p = start ; p && p != ':' && *p != '%' ; p++);
349	#endif
350	len = p - start + strlen(name) + 2; /* "2" is for '/' and '\0' */
351	#ifdef PC_EXE_EXTS
352	len += 4; /* "4" is for .exe/.com/.cmd/.bat/.btm */
353	#endif
354	while (stackblocksize() < len)
355	growstackblock();
356	#ifdef PC_SLASHES
357	s =
358	#endif
359	q = stackblock();
360	if (p != start) {
361	memcpy(q, start, p - start);
362	q += p - start;
363	*q++ = '/';
364	}
365	strcpy(q, name);
366	#ifdef PC_SLASHES
367	while ((s = strchr(s, '\\')) != NULL)
368	*s++ = '/';
369	#endif
370	pathopt = NULL;
371	if (*p == '%') {
372	pathopt = ++p;
373	#ifdef PC_PATH_SEP
374	while (p && p != ';') p++;
375	#else
376	while (p && p != ':') p++;
377	#endif
378	}
379	#ifdef PC_PATH_SEP
380	if (*p == ';')
381	#else
382	if (*p == ':')
383	#endif
384	*path = p + 1;
385	else
386	*path = NULL;
387	return stalloc(len);
388	}
389
390
391	#ifdef PC_EXE_EXTS
392	STATIC int stat_pc_exec_exts(char fullname, struct stat st, int has_ext)
393	{
394	/* skip the SYSV crap */
395	if (stat(fullname, st) >= 0)
396	return 0;
397	if (!has_ext && errno == ENOENT)
398	{
399	char *psz = strchr(fullname, '\0');
400	memcpy(psz, ".exe", 5);
401	if (stat(fullname, st) >= 0)
402	return 0;
403	if (errno != ENOENT && errno != ENOTDIR)
404	return -1;
405
406	memcpy(psz, ".cmd", 5);
407	if (stat(fullname, st) >= 0)
408	return 0;
409	if (errno != ENOENT && errno != ENOTDIR)
410	return -1;
411
412	memcpy(psz, ".bat", 5);
413	if (stat(fullname, st) >= 0)
414	return 0;
415	if (errno != ENOENT && errno != ENOTDIR)
416	return -1;
417
418	memcpy(psz, ".com", 5);
419	if (stat(fullname, st) >= 0)
420	return 0;
421	if (errno != ENOENT && errno != ENOTDIR)
422	return -1;
423
424	memcpy(psz, ".btm", 5);
425	if (stat(fullname, st) >= 0)
426	return 0;
427	*psz = '\0';
428	}
429	return -1;
430	}
431	#endif /* PC_EXE_EXTS */
432
433
434
435	/* Command hashing code */
436
437
438	int
439	hashcmd(int argc, char **argv)
440	{
441	struct tblentry **pp;
442	struct tblentry *cmdp;
443	int c;
444	int verbose;
445	struct cmdentry entry;
446	char *name;
447
448	verbose = 0;
449	while ((c = nextopt("rv")) != '\0') {
450	if (c == 'r') {
451	clearcmdentry(0);
452	} else if (c == 'v') {
453	verbose++;
454	}
455	}
456	if (*argptr == NULL) {
457	for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) {
458	for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
459	if (verbose \|\| cmdp->cmdtype == CMDNORMAL)
460	printentry(cmdp, verbose);
461	}
462	}
463	return 0;
464	}
465	while ((name = *argptr) != NULL) {
466	if ((cmdp = cmdlookup(name, 0)) != NULL
467	&& (cmdp->cmdtype == CMDNORMAL
468	\|\| (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0)))
469	delete_cmd_entry();
470	find_command(name, &entry, DO_ERR, pathval());
471	if (verbose) {
472	if (entry.cmdtype != CMDUNKNOWN) { /* if no error msg */
473	cmdp = cmdlookup(name, 0);
474	printentry(cmdp, verbose);
475	}
476	output_flushall();
477	}
478	argptr++;
479	}
480	return 0;
481	}
482
483
484	STATIC void
485	printentry(struct tblentry *cmdp, int verbose)
486	{
487	int idx;
488	const char *path;
489	char *name;
490
491	switch (cmdp->cmdtype) {
492	case CMDNORMAL:
493	idx = cmdp->param.index;
494	path = pathval();
495	do {
496	name = padvance(&path, cmdp->cmdname);
497	stunalloc(name);
498	} while (--idx >= 0);
499	out1str(name);
500	break;
501	case CMDSPLBLTIN:
502	out1fmt("special builtin %s", cmdp->cmdname);
503	break;
504	case CMDBUILTIN:
505	out1fmt("builtin %s", cmdp->cmdname);
506	break;
507	case CMDFUNCTION:
508	out1fmt("function %s", cmdp->cmdname);
509	if (verbose) {
510	struct procstat ps;
511	INTOFF;
512	commandtext(&ps, cmdp->param.func);
513	INTON;
514	out1str("() { ");
515	out1str(ps.cmd);
516	out1str("; }");
517	}
518	break;
519	default:
520	error("internal error: %s cmdtype %d", cmdp->cmdname, cmdp->cmdtype);
521	}
522	if (cmdp->rehash)
523	out1c('*');
524	out1c('\n');
525	}
526
527
528
529	/*
530	* Resolve a command name. If you change this routine, you may have to
531	* change the shellexec routine as well.
532	*/
533
534	void
535	find_command(char name, struct cmdentry entry, int act, const char *path)
536	{
537	struct tblentry *cmdp, loc_cmd;
538	int idx;
539	int prev;
540	char *fullname;
541	struct stat statb;
542	int e;
543	int (bltin)(int,char *);
544
545	#ifdef PC_EXE_EXTS
546	int has_ext = strlen(name) - 4;
547	has_ext = has_ext > 0
548	&& name[has_ext] == '.'
549	/* use strstr and upper/lower permuated extensions to avoid multiple strcasecmp calls. */
550	&& strstr("exe;" "Exe;" "EXe;" "EXE;" "ExE;" "eXe;" "eXE;" "exE;"
551	"cmd;" "Cmd;" "CMd;" "CMD;" "CmD;" "cMd;" "cMD;" "cmD;"
552	"com;" "Com;" "COm;" "COM;" "CoM;" "cOm;" "cOM;" "coM;"
553	"bat;" "Bat;" "BAt;" "BAT;" "BaT;" "bAt;" "bAT;" "baT;"
554	"btm;" "Btm;" "BTm;" "BTM;" "BtM;" "bTm;" "bTM;" "btM;",
555	name + has_ext + 1)
556	!= NULL;
557	#endif
558
559	/* If name contains a slash, don't use PATH or hash table */
560	if (strchr(name, '/') != NULL) {
561	if (act & DO_ABS) {
562	while (stat(name, &statb) < 0) {
563	#ifdef SYSV
564	if (errno == EINTR)
565	continue;
566	#endif
567	if (errno != ENOENT && errno != ENOTDIR)
568	e = errno;
569	entry->cmdtype = CMDUNKNOWN;
570	entry->u.index = -1;
571	return;
572	}
573	entry->cmdtype = CMDNORMAL;
574	entry->u.index = -1;
575	return;
576	}
577	entry->cmdtype = CMDNORMAL;
578	entry->u.index = 0;
579	return;
580	}
581
582	if (path != pathval())
583	act \|= DO_ALTPATH;
584
585	if (act & DO_ALTPATH && strstr(path, "%builtin") != NULL)
586	act \|= DO_ALTBLTIN;
587
588	/* If name is in the table, check answer will be ok */
589	if ((cmdp = cmdlookup(name, 0)) != NULL) {
590	do {
591	switch (cmdp->cmdtype) {
592	case CMDNORMAL:
593	if (act & DO_ALTPATH) {
594	cmdp = NULL;
595	continue;
596	}
597	break;
598	case CMDFUNCTION:
599	if (act & DO_NOFUNC) {
600	cmdp = NULL;
601	continue;
602	}
603	break;
604	case CMDBUILTIN:
605	if ((act & DO_ALTBLTIN) \|\| builtinloc >= 0) {
606	cmdp = NULL;
607	continue;
608	}
609	break;
610	}
611	/* if not invalidated by cd, we're done */
612	if (cmdp->rehash == 0)
613	goto success;
614	} while (0);
615	}
616
617	/* If %builtin not in path, check for builtin next */
618	if ((act & DO_ALTPATH ? !(act & DO_ALTBLTIN) : builtinloc < 0) &&
619	(bltin = find_builtin(name)) != 0)
620	goto builtin_success;
621
622	/* We have to search path. */
623	prev = -1; /* where to start */
624	if (cmdp) { /* doing a rehash */
625	if (cmdp->cmdtype == CMDBUILTIN)
626	prev = builtinloc;
627	else
628	prev = cmdp->param.index;
629	}
630
631	e = ENOENT;
632	idx = -1;
633	loop:
634	while ((fullname = padvance(&path, name)) != NULL) {
635	stunalloc(fullname);
636	idx++;
637	if (pathopt) {
638	if (prefix("builtin", pathopt)) {
639	if ((bltin = find_builtin(name)) == 0)
640	goto loop;
641	goto builtin_success;
642	} else if (prefix("func", pathopt)) {
643	/* handled below */
644	} else {
645	/* ignore unimplemented options */
646	goto loop;
647	}
648	}
649	/* if rehash, don't redo absolute path names */
650	if (fullname[0] == '/' && idx <= prev) {
651	if (idx < prev)
652	goto loop;
653	TRACE(("searchexec \"%s\": no change\n", name));
654	goto success;
655	}
656	#ifdef PC_EXE_EXTS
657	while (stat_pc_exec_exts(fullname, &statb, has_ext) < 0) {
658	#else
659	while (stat(fullname, &statb) < 0) {
660	#endif
661	#ifdef SYSV
662	if (errno == EINTR)
663	continue;
664	#endif
665	if (errno != ENOENT && errno != ENOTDIR)
666	e = errno;
667
668	goto loop;
669	}
670	e = EACCES; /* if we fail, this will be the error */
671	if (!S_ISREG(statb.st_mode))
672	goto loop;
673	if (pathopt) { /* this is a %func directory */
674	if (act & DO_NOFUNC)
675	goto loop;
676	stalloc(strlen(fullname) + 1);
677	readcmdfile(fullname);
678	if ((cmdp = cmdlookup(name, 0)) == NULL \|\|
679	cmdp->cmdtype != CMDFUNCTION)
680	error("%s not defined in %s", name, fullname);
681	stunalloc(fullname);
682	goto success;
683	}
684	#ifdef notdef
685	/* XXX this code stops root executing stuff, and is buggy
686	if you need a group from the group list. */
687	if (statb.st_uid == geteuid()) {
688	if ((statb.st_mode & 0100) == 0)
689	goto loop;
690	} else if (statb.st_gid == getegid()) {
691	if ((statb.st_mode & 010) == 0)
692	goto loop;
693	} else {
694	if ((statb.st_mode & 01) == 0)
695	goto loop;
696	}
697	#endif
698	TRACE(("searchexec \"%s\" returns \"%s\"\n", name, fullname));
699	INTOFF;
700	if (act & DO_ALTPATH) {
701	stalloc(strlen(fullname) + 1);
702	cmdp = &loc_cmd;
703	} else
704	cmdp = cmdlookup(name, 1);
705	cmdp->cmdtype = CMDNORMAL;
706	cmdp->param.index = idx;
707	INTON;
708	goto success;
709	}
710
711	/* We failed. If there was an entry for this command, delete it */
712	if (cmdp)
713	delete_cmd_entry();
714	if (act & DO_ERR)
715	outfmt(out2, "%s: %s\n", name, errmsg(e, E_EXEC));
716	entry->cmdtype = CMDUNKNOWN;
717	return;
718
719	builtin_success:
720	INTOFF;
721	if (act & DO_ALTPATH)
722	cmdp = &loc_cmd;
723	else
724	cmdp = cmdlookup(name, 1);
725	if (cmdp->cmdtype == CMDFUNCTION)
726	/* DO_NOFUNC must have been set */
727	cmdp = &loc_cmd;
728	cmdp->cmdtype = CMDBUILTIN;
729	cmdp->param.bltin = bltin;
730	INTON;
731	success:
732	cmdp->rehash = 0;
733	entry->cmdtype = cmdp->cmdtype;
734	entry->u = cmdp->param;
735	}
736
737
738
739	/*
740	* Search the table of builtin commands.
741	*/
742
743	int
744	(find_builtin(name))(int, char *)
745	char *name;
746	{
747	const struct builtincmd *bp;
748
749	for (bp = builtincmd ; bp->name ; bp++) {
750	if (bp->name == name && equal(bp->name, name))
751	return bp->builtin;
752	}
753	return 0;
754	}
755
756	int
757	(find_splbltin(name))(int, char *)
758	char *name;
759	{
760	const struct builtincmd *bp;
761
762	for (bp = splbltincmd ; bp->name ; bp++) {
763	if (bp->name == name && equal(bp->name, name))
764	return bp->builtin;
765	}
766	return 0;
767	}
768
769	/*
770	* At shell startup put special builtins into hash table.
771	* ensures they are executed first (see posix).
772	* We stop functions being added with the same name
773	* (as they are impossible to call)
774	*/
775
776	void
777	hash_special_builtins(void)
778	{
779	const struct builtincmd *bp;
780	struct tblentry *cmdp;
781
782	for (bp = splbltincmd ; bp->name ; bp++) {
783	cmdp = cmdlookup(bp->name, 1);
784	cmdp->cmdtype = CMDSPLBLTIN;
785	cmdp->param.bltin = bp->builtin;
786	}
787	}
788
789
790
791	/*
792	* Called when a cd is done. Marks all commands so the next time they
793	* are executed they will be rehashed.
794	*/
795
796	void
797	hashcd(void)
798	{
799	struct tblentry **pp;
800	struct tblentry *cmdp;
801
802	for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) {
803	for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
804	if (cmdp->cmdtype == CMDNORMAL
805	\|\| (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0))
806	cmdp->rehash = 1;
807	}
808	}
809	}
810
811
812
813	/*
814	* Fix command hash table when PATH changed.
815	* Called before PATH is changed. The argument is the new value of PATH;
816	* pathval() still returns the old value at this point.
817	* Called with interrupts off.
818	*/
819
820	void
821	changepath(const char *newval)
822	{
823	const char old, new;
824	int idx;
825	int firstchange;
826	int bltin;
827
828	old = pathval();
829	new = newval;
830	firstchange = 9999; /* assume no change */
831	idx = 0;
832	bltin = -1;
833	for (;;) {
834	if (old != new) {
835	firstchange = idx;
836	#ifdef PC_PATH_SEP
837	if ((old == '\0' && new == ';')
838	\|\| (old == ';' && new == '\0'))
839	#else
840	if ((old == '\0' && new == ':')
841	\|\| (old == ':' && new == '\0'))
842	#endif
843	firstchange++;
844	old = new; /* ignore subsequent differences */
845	}
846	if (*new == '\0')
847	break;
848	if (*new == '%' && bltin < 0 && prefix("builtin", new + 1))
849	bltin = idx;
850	#ifdef PC_PATH_SEP
851	if (*new == ';') {
852	#else
853	if (*new == ':') {
854	#endif
855	idx++;
856	}
857	new++, old++;
858	}
859	if (builtinloc < 0 && bltin >= 0)
860	builtinloc = bltin; /* zap builtins */
861	if (builtinloc >= 0 && bltin < 0)
862	firstchange = 0;
863	clearcmdentry(firstchange);
864	builtinloc = bltin;
865	}
866
867
868	/*
869	* Clear out command entries. The argument specifies the first entry in
870	* PATH which has changed.
871	*/
872
873	STATIC void
874	clearcmdentry(int firstchange)
875	{
876	struct tblentry **tblp;
877	struct tblentry **pp;
878	struct tblentry *cmdp;
879
880	INTOFF;
881	for (tblp = cmdtable ; tblp < &cmdtable[CMDTABLESIZE] ; tblp++) {
882	pp = tblp;
883	while ((cmdp = *pp) != NULL) {
884	if ((cmdp->cmdtype == CMDNORMAL &&
885	cmdp->param.index >= firstchange)
886	\|\| (cmdp->cmdtype == CMDBUILTIN &&
887	builtinloc >= firstchange)) {
888	*pp = cmdp->next;
889	ckfree(cmdp);
890	} else {
891	pp = &cmdp->next;
892	}
893	}
894	}
895	INTON;
896	}
897
898
899	/*
900	* Delete all functions.
901	*/
902
903	#ifdef mkinit
904	MKINIT void deletefuncs(void);
905	MKINIT void hash_special_builtins(void);
906
907	INIT {
908	hash_special_builtins();
909	}
910
911	SHELLPROC {
912	deletefuncs();
913	}
914	#endif
915
916	void
917	deletefuncs(void)
918	{
919	struct tblentry **tblp;
920	struct tblentry **pp;
921	struct tblentry *cmdp;
922
923	INTOFF;
924	for (tblp = cmdtable ; tblp < &cmdtable[CMDTABLESIZE] ; tblp++) {
925	pp = tblp;
926	while ((cmdp = *pp) != NULL) {
927	if (cmdp->cmdtype == CMDFUNCTION) {
928	*pp = cmdp->next;
929	freefunc(cmdp->param.func);
930	ckfree(cmdp);
931	} else {
932	pp = &cmdp->next;
933	}
934	}
935	}
936	INTON;
937	}
938
939
940
941	/*
942	* Locate a command in the command hash table. If "add" is nonzero,
943	* add the command to the table if it is not already present. The
944	* variable "lastcmdentry" is set to point to the address of the link
945	* pointing to the entry, so that delete_cmd_entry can delete the
946	* entry.
947	*/
948
949	struct tblentry **lastcmdentry;
950
951
952	STATIC struct tblentry *
953	cmdlookup(const char *name, int add)
954	{
955	int hashval;
956	const char *p;
957	struct tblentry *cmdp;
958	struct tblentry **pp;
959
960	p = name;
961	hashval = *p << 4;
962	while (*p)
963	hashval += *p++;
964	hashval &= 0x7FFF;
965	pp = &cmdtable[hashval % CMDTABLESIZE];
966	for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
967	if (equal(cmdp->cmdname, name))
968	break;
969	pp = &cmdp->next;
970	}
971	if (add && cmdp == NULL) {
972	INTOFF;
973	cmdp = *pp = ckmalloc(sizeof (struct tblentry) - ARB
974	+ strlen(name) + 1);
975	cmdp->next = NULL;
976	cmdp->cmdtype = CMDUNKNOWN;
977	cmdp->rehash = 0;
978	strcpy(cmdp->cmdname, name);
979	INTON;
980	}
981	lastcmdentry = pp;
982	return cmdp;
983	}
984
985	/*
986	* Delete the command entry returned on the last lookup.
987	*/
988
989	STATIC void
990	delete_cmd_entry(void)
991	{
992	struct tblentry *cmdp;
993
994	INTOFF;
995	cmdp = *lastcmdentry;
996	*lastcmdentry = cmdp->next;
997	ckfree(cmdp);
998	INTON;
999	}
1000
1001
1002
1003	#ifdef notdef
1004	void
1005	getcmdentry(char name, struct cmdentry entry)
1006	{
1007	struct tblentry *cmdp = cmdlookup(name, 0);
1008
1009	if (cmdp) {
1010	entry->u = cmdp->param;
1011	entry->cmdtype = cmdp->cmdtype;
1012	} else {
1013	entry->cmdtype = CMDUNKNOWN;
1014	entry->u.index = 0;
1015	}
1016	}
1017	#endif
1018
1019
1020	/*
1021	* Add a new command entry, replacing any existing command entry for
1022	* the same name - except special builtins.
1023	*/
1024
1025	STATIC void
1026	addcmdentry(char name, struct cmdentry entry)
1027	{
1028	struct tblentry *cmdp;
1029
1030	INTOFF;
1031	cmdp = cmdlookup(name, 1);
1032	if (cmdp->cmdtype != CMDSPLBLTIN) {
1033	if (cmdp->cmdtype == CMDFUNCTION) {
1034	freefunc(cmdp->param.func);
1035	}
1036	cmdp->cmdtype = entry->cmdtype;
1037	cmdp->param = entry->u;
1038	}
1039	INTON;
1040	}
1041
1042
1043	/*
1044	* Define a shell function.
1045	*/
1046
1047	void
1048	defun(char name, union node func)
1049	{
1050	struct cmdentry entry;
1051
1052	INTOFF;
1053	entry.cmdtype = CMDFUNCTION;
1054	entry.u.func = copyfunc(func);
1055	addcmdentry(name, &entry);
1056	INTON;
1057	}
1058
1059
1060	/*
1061	* Delete a function if it exists.
1062	*/
1063
1064	int
1065	unsetfunc(char *name)
1066	{
1067	struct tblentry *cmdp;
1068
1069	if ((cmdp = cmdlookup(name, 0)) != NULL &&
1070	cmdp->cmdtype == CMDFUNCTION) {
1071	freefunc(cmdp->param.func);
1072	delete_cmd_entry();
1073	return (0);
1074	}
1075	return (1);
1076	}
1077
1078	/*
1079	* Locate and print what a word is...
1080	* also used for 'command -[v\|V]'
1081	*/
1082
1083	int
1084	typecmd(int argc, char **argv)
1085	{
1086	struct cmdentry entry;
1087	struct tblentry *cmdp;
1088	char * const *pp;
1089	struct alias *ap;
1090	int err = 0;
1091	char *arg;
1092	int c;
1093	int V_flag = 0;
1094	int v_flag = 0;
1095	int p_flag = 0;
1096
1097	while ((c = nextopt("vVp")) != 0) {
1098	switch (c) {
1099	case 'v': v_flag = 1; break;
1100	case 'V': V_flag = 1; break;
1101	case 'p': p_flag = 1; break;
1102	}
1103	}
1104
1105	if (p_flag && (v_flag \|\| V_flag))
1106	error("cannot specify -p with -v or -V");
1107
1108	while ((arg = *argptr++)) {
1109	if (!v_flag)
1110	out1str(arg);
1111	/* First look at the keywords */
1112	for (pp = parsekwd; *pp; pp++)
1113	if (*pp == arg && equal(*pp, arg))
1114	break;
1115
1116	if (*pp) {
1117	if (v_flag)
1118	err = 1;
1119	else
1120	out1str(" is a shell keyword\n");
1121	continue;
1122	}
1123
1124	/* Then look at the aliases */
1125	if ((ap = lookupalias(arg, 1)) != NULL) {
1126	if (!v_flag)
1127	out1fmt(" is an alias for \n");
1128	out1fmt("%s\n", ap->val);
1129	continue;
1130	}
1131
1132	/* Then check if it is a tracked alias */
1133	if ((cmdp = cmdlookup(arg, 0)) != NULL) {
1134	entry.cmdtype = cmdp->cmdtype;
1135	entry.u = cmdp->param;
1136	} else {
1137	/* Finally use brute force */
1138	find_command(arg, &entry, DO_ABS, pathval());
1139	}
1140
1141	switch (entry.cmdtype) {
1142	case CMDNORMAL: {
1143	if (strchr(arg, '/') == NULL) {
1144	const char *path = pathval();
1145	char *name;
1146	int j = entry.u.index;
1147	do {
1148	name = padvance(&path, arg);
1149	stunalloc(name);
1150	} while (--j >= 0);
1151	if (!v_flag)
1152	out1fmt(" is%s ",
1153	cmdp ? " a tracked alias for" : "");
1154	out1fmt("%s\n", name);
1155	} else {
1156	if (access(arg, X_OK) == 0) {
1157	if (!v_flag)
1158	out1fmt(" is ");
1159	out1fmt("%s\n", arg);
1160	} else {
1161	if (!v_flag)
1162	out1fmt(": %s\n",
1163	strerror(errno));
1164	else
1165	err = 126;
1166	}
1167	}
1168	break;
1169	}
1170	case CMDFUNCTION:
1171	if (!v_flag)
1172	out1str(" is a shell function\n");
1173	else
1174	out1fmt("%s\n", arg);
1175	break;
1176
1177	case CMDBUILTIN:
1178	if (!v_flag)
1179	out1str(" is a shell builtin\n");
1180	else
1181	out1fmt("%s\n", arg);
1182	break;
1183
1184	case CMDSPLBLTIN:
1185	if (!v_flag)
1186	out1str(" is a special shell builtin\n");
1187	else
1188	out1fmt("%s\n", arg);
1189	break;
1190
1191	default:
1192	if (!v_flag)
1193	out1str(": not found\n");
1194	err = 127;
1195	break;
1196	}
1197	}
1198	return err;
1199	}

Note: See TracBrowser for help on using the repository browser.

source: kBuild/trunk/src/ash/exec.c@ 885

Download in other formats: