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