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