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