exec.c revision 1.36 1 1.36 dsl /* $NetBSD: exec.c,v 1.36 2003/02/04 08:51:30 dsl 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.36 dsl __RCSID("$NetBSD: exec.c,v 1.36 2003/02/04 08:51:30 dsl 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.33 christos #include <sys/wait.h>
51 1.16 christos #include <unistd.h>
52 1.16 christos #include <fcntl.h>
53 1.16 christos #include <errno.h>
54 1.33 christos #include <stdio.h>
55 1.16 christos #include <stdlib.h>
56 1.16 christos
57 1.1 cgd /*
58 1.1 cgd * When commands are first encountered, they are entered in a hash table.
59 1.1 cgd * This ensures that a full path search will not have to be done for them
60 1.1 cgd * on each invocation.
61 1.1 cgd *
62 1.1 cgd * We should investigate converting to a linear search, even though that
63 1.1 cgd * would make the command name "hash" a misnomer.
64 1.1 cgd */
65 1.1 cgd
66 1.1 cgd #include "shell.h"
67 1.1 cgd #include "main.h"
68 1.1 cgd #include "nodes.h"
69 1.1 cgd #include "parser.h"
70 1.1 cgd #include "redir.h"
71 1.1 cgd #include "eval.h"
72 1.1 cgd #include "exec.h"
73 1.1 cgd #include "builtins.h"
74 1.1 cgd #include "var.h"
75 1.1 cgd #include "options.h"
76 1.1 cgd #include "input.h"
77 1.1 cgd #include "output.h"
78 1.1 cgd #include "syntax.h"
79 1.1 cgd #include "memalloc.h"
80 1.1 cgd #include "error.h"
81 1.1 cgd #include "init.h"
82 1.1 cgd #include "mystring.h"
83 1.16 christos #include "show.h"
84 1.8 jtc #include "jobs.h"
85 1.22 christos #include "alias.h"
86 1.1 cgd
87 1.1 cgd
88 1.1 cgd #define CMDTABLESIZE 31 /* should be prime */
89 1.1 cgd #define ARB 1 /* actual size determined at run time */
90 1.1 cgd
91 1.1 cgd
92 1.1 cgd
93 1.1 cgd struct tblentry {
94 1.1 cgd struct tblentry *next; /* next entry in hash chain */
95 1.1 cgd union param param; /* definition of builtin function */
96 1.1 cgd short cmdtype; /* index identifying command */
97 1.1 cgd char rehash; /* if set, cd done since entry created */
98 1.1 cgd char cmdname[ARB]; /* name of command */
99 1.1 cgd };
100 1.1 cgd
101 1.1 cgd
102 1.1 cgd STATIC struct tblentry *cmdtable[CMDTABLESIZE];
103 1.1 cgd STATIC int builtinloc = -1; /* index in path of %builtin, or -1 */
104 1.19 christos int exerrno = 0; /* Last exec error */
105 1.1 cgd
106 1.1 cgd
107 1.34 christos STATIC void tryexec(char *, char **, char **, int);
108 1.34 christos STATIC void execinterp(char **, char **);
109 1.34 christos STATIC void printentry(struct tblentry *, int);
110 1.34 christos STATIC void clearcmdentry(int);
111 1.34 christos STATIC struct tblentry *cmdlookup(const char *, int);
112 1.34 christos STATIC void delete_cmd_entry(void);
113 1.1 cgd
114 1.1 cgd
115 1.32 christos extern char *const parsekwd[];
116 1.1 cgd
117 1.1 cgd /*
118 1.1 cgd * Exec a program. Never returns. If you change this routine, you may
119 1.1 cgd * have to change the find_command routine as well.
120 1.1 cgd */
121 1.1 cgd
122 1.1 cgd void
123 1.34 christos shellexec(char **argv, char **envp, const char *path, int idx, int vforked)
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.33 christos tryexec(argv[0], argv, envp, vforked);
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.27 christos if (--idx < 0 && pathopt == NULL) {
135 1.33 christos tryexec(cmdname, argv, envp, vforked);
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.34 christos TRACE(("shellexec failed for %s, errno %d, vforked %d, suppressint %d\n",
156 1.34 christos argv[0], e, vforked, suppressint ));
157 1.19 christos exerror(EXEXEC, "%s: %s", argv[0], errmsg(e, E_EXEC));
158 1.26 mycroft /* NOTREACHED */
159 1.1 cgd }
160 1.1 cgd
161 1.1 cgd
162 1.1 cgd STATIC void
163 1.34 christos tryexec(char *cmd, char **argv, char **envp, int vforked)
164 1.34 christos {
165 1.1 cgd int e;
166 1.16 christos #ifndef BSD
167 1.1 cgd char *p;
168 1.16 christos #endif
169 1.1 cgd
170 1.1 cgd #ifdef SYSV
171 1.1 cgd do {
172 1.1 cgd execve(cmd, argv, envp);
173 1.1 cgd } while (errno == EINTR);
174 1.1 cgd #else
175 1.1 cgd execve(cmd, argv, envp);
176 1.1 cgd #endif
177 1.1 cgd e = errno;
178 1.1 cgd if (e == ENOEXEC) {
179 1.33 christos if (vforked) {
180 1.33 christos /* We are currently vfork(2)ed, so raise an
181 1.33 christos * exception, and evalcommand will try again
182 1.33 christos * with a normal fork(2).
183 1.33 christos */
184 1.33 christos exraise(EXSHELLPROC);
185 1.33 christos }
186 1.1 cgd initshellproc();
187 1.1 cgd setinputfile(cmd, 0);
188 1.1 cgd commandname = arg0 = savestr(argv[0]);
189 1.1 cgd #ifndef BSD
190 1.1 cgd pgetc(); pungetc(); /* fill up input buffer */
191 1.1 cgd p = parsenextc;
192 1.1 cgd if (parsenleft > 2 && p[0] == '#' && p[1] == '!') {
193 1.1 cgd argv[0] = cmd;
194 1.1 cgd execinterp(argv, envp);
195 1.1 cgd }
196 1.1 cgd #endif
197 1.1 cgd setparam(argv + 1);
198 1.1 cgd exraise(EXSHELLPROC);
199 1.1 cgd }
200 1.1 cgd errno = e;
201 1.1 cgd }
202 1.1 cgd
203 1.1 cgd
204 1.1 cgd #ifndef BSD
205 1.1 cgd /*
206 1.1 cgd * Execute an interpreter introduced by "#!", for systems where this
207 1.1 cgd * feature has not been built into the kernel. If the interpreter is
208 1.1 cgd * the shell, return (effectively ignoring the "#!"). If the execution
209 1.1 cgd * of the interpreter fails, exit.
210 1.1 cgd *
211 1.1 cgd * This code peeks inside the input buffer in order to avoid actually
212 1.1 cgd * reading any input. It would benefit from a rewrite.
213 1.1 cgd */
214 1.1 cgd
215 1.1 cgd #define NEWARGS 5
216 1.1 cgd
217 1.1 cgd STATIC void
218 1.34 christos execinterp(char **argv, char **envp)
219 1.34 christos {
220 1.1 cgd int n;
221 1.1 cgd char *inp;
222 1.1 cgd char *outp;
223 1.1 cgd char c;
224 1.1 cgd char *p;
225 1.1 cgd char **ap;
226 1.1 cgd char *newargs[NEWARGS];
227 1.1 cgd int i;
228 1.1 cgd char **ap2;
229 1.1 cgd char **new;
230 1.1 cgd
231 1.1 cgd n = parsenleft - 2;
232 1.1 cgd inp = parsenextc + 2;
233 1.1 cgd ap = newargs;
234 1.1 cgd for (;;) {
235 1.1 cgd while (--n >= 0 && (*inp == ' ' || *inp == '\t'))
236 1.1 cgd inp++;
237 1.1 cgd if (n < 0)
238 1.1 cgd goto bad;
239 1.1 cgd if ((c = *inp++) == '\n')
240 1.1 cgd break;
241 1.1 cgd if (ap == &newargs[NEWARGS])
242 1.1 cgd bad: error("Bad #! line");
243 1.1 cgd STARTSTACKSTR(outp);
244 1.1 cgd do {
245 1.1 cgd STPUTC(c, outp);
246 1.1 cgd } while (--n >= 0 && (c = *inp++) != ' ' && c != '\t' && c != '\n');
247 1.1 cgd STPUTC('\0', outp);
248 1.1 cgd n++, inp--;
249 1.1 cgd *ap++ = grabstackstr(outp);
250 1.1 cgd }
251 1.1 cgd if (ap == newargs + 1) { /* if no args, maybe no exec is needed */
252 1.1 cgd p = newargs[0];
253 1.1 cgd for (;;) {
254 1.1 cgd if (equal(p, "sh") || equal(p, "ash")) {
255 1.1 cgd return;
256 1.1 cgd }
257 1.1 cgd while (*p != '/') {
258 1.1 cgd if (*p == '\0')
259 1.1 cgd goto break2;
260 1.1 cgd p++;
261 1.1 cgd }
262 1.1 cgd p++;
263 1.1 cgd }
264 1.1 cgd break2:;
265 1.1 cgd }
266 1.1 cgd i = (char *)ap - (char *)newargs; /* size in bytes */
267 1.1 cgd if (i == 0)
268 1.1 cgd error("Bad #! line");
269 1.1 cgd for (ap2 = argv ; *ap2++ != NULL ; );
270 1.1 cgd new = ckmalloc(i + ((char *)ap2 - (char *)argv));
271 1.1 cgd ap = newargs, ap2 = new;
272 1.1 cgd while ((i -= sizeof (char **)) >= 0)
273 1.1 cgd *ap2++ = *ap++;
274 1.1 cgd ap = argv;
275 1.1 cgd while (*ap2++ = *ap++);
276 1.1 cgd shellexec(new, envp, pathval(), 0);
277 1.26 mycroft /* NOTREACHED */
278 1.1 cgd }
279 1.1 cgd #endif
280 1.1 cgd
281 1.1 cgd
282 1.1 cgd
283 1.1 cgd /*
284 1.1 cgd * Do a path search. The variable path (passed by reference) should be
285 1.1 cgd * set to the start of the path before the first call; padvance will update
286 1.1 cgd * this value as it proceeds. Successive calls to padvance will return
287 1.1 cgd * the possible path expansions in sequence. If an option (indicated by
288 1.1 cgd * a percent sign) appears in the path entry then the global variable
289 1.1 cgd * pathopt will be set to point to it; otherwise pathopt will be set to
290 1.1 cgd * NULL.
291 1.1 cgd */
292 1.1 cgd
293 1.27 christos const char *pathopt;
294 1.1 cgd
295 1.1 cgd char *
296 1.34 christos padvance(const char **path, const char *name)
297 1.34 christos {
298 1.27 christos const char *p;
299 1.27 christos char *q;
300 1.27 christos const char *start;
301 1.1 cgd int len;
302 1.1 cgd
303 1.1 cgd if (*path == NULL)
304 1.1 cgd return NULL;
305 1.1 cgd start = *path;
306 1.1 cgd for (p = start ; *p && *p != ':' && *p != '%' ; p++);
307 1.1 cgd len = p - start + strlen(name) + 2; /* "2" is for '/' and '\0' */
308 1.1 cgd while (stackblocksize() < len)
309 1.1 cgd growstackblock();
310 1.1 cgd q = stackblock();
311 1.1 cgd if (p != start) {
312 1.11 mycroft memcpy(q, start, p - start);
313 1.1 cgd q += p - start;
314 1.1 cgd *q++ = '/';
315 1.1 cgd }
316 1.1 cgd strcpy(q, name);
317 1.1 cgd pathopt = NULL;
318 1.1 cgd if (*p == '%') {
319 1.1 cgd pathopt = ++p;
320 1.1 cgd while (*p && *p != ':') p++;
321 1.1 cgd }
322 1.1 cgd if (*p == ':')
323 1.1 cgd *path = p + 1;
324 1.1 cgd else
325 1.1 cgd *path = NULL;
326 1.1 cgd return stalloc(len);
327 1.1 cgd }
328 1.1 cgd
329 1.1 cgd
330 1.1 cgd
331 1.1 cgd /*** Command hashing code ***/
332 1.1 cgd
333 1.1 cgd
334 1.12 cgd int
335 1.34 christos hashcmd(int argc, char **argv)
336 1.12 cgd {
337 1.1 cgd struct tblentry **pp;
338 1.1 cgd struct tblentry *cmdp;
339 1.1 cgd int c;
340 1.1 cgd int verbose;
341 1.1 cgd struct cmdentry entry;
342 1.1 cgd char *name;
343 1.1 cgd
344 1.1 cgd verbose = 0;
345 1.1 cgd while ((c = nextopt("rv")) != '\0') {
346 1.1 cgd if (c == 'r') {
347 1.1 cgd clearcmdentry(0);
348 1.1 cgd } else if (c == 'v') {
349 1.1 cgd verbose++;
350 1.1 cgd }
351 1.1 cgd }
352 1.8 jtc if (*argptr == NULL) {
353 1.8 jtc for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) {
354 1.8 jtc for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
355 1.36 dsl if (verbose || cmdp->cmdtype == CMDNORMAL)
356 1.36 dsl printentry(cmdp, verbose);
357 1.8 jtc }
358 1.8 jtc }
359 1.8 jtc return 0;
360 1.8 jtc }
361 1.1 cgd while ((name = *argptr) != NULL) {
362 1.1 cgd if ((cmdp = cmdlookup(name, 0)) != NULL
363 1.1 cgd && (cmdp->cmdtype == CMDNORMAL
364 1.16 christos || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0)))
365 1.1 cgd delete_cmd_entry();
366 1.24 christos find_command(name, &entry, DO_ERR, pathval());
367 1.1 cgd if (verbose) {
368 1.1 cgd if (entry.cmdtype != CMDUNKNOWN) { /* if no error msg */
369 1.1 cgd cmdp = cmdlookup(name, 0);
370 1.8 jtc printentry(cmdp, verbose);
371 1.1 cgd }
372 1.1 cgd flushall();
373 1.1 cgd }
374 1.1 cgd argptr++;
375 1.1 cgd }
376 1.1 cgd return 0;
377 1.1 cgd }
378 1.1 cgd
379 1.1 cgd
380 1.1 cgd STATIC void
381 1.34 christos printentry(struct tblentry *cmdp, int verbose)
382 1.34 christos {
383 1.27 christos int idx;
384 1.27 christos const char *path;
385 1.1 cgd char *name;
386 1.1 cgd
387 1.34 christos switch (cmdp->cmdtype) {
388 1.34 christos case CMDNORMAL:
389 1.27 christos idx = cmdp->param.index;
390 1.1 cgd path = pathval();
391 1.1 cgd do {
392 1.1 cgd name = padvance(&path, cmdp->cmdname);
393 1.1 cgd stunalloc(name);
394 1.27 christos } while (--idx >= 0);
395 1.1 cgd out1str(name);
396 1.34 christos break;
397 1.34 christos case CMDSPLBLTIN:
398 1.34 christos out1fmt("special builtin %s", cmdp->cmdname);
399 1.34 christos break;
400 1.34 christos case CMDBUILTIN:
401 1.1 cgd out1fmt("builtin %s", cmdp->cmdname);
402 1.34 christos break;
403 1.34 christos case CMDFUNCTION:
404 1.1 cgd out1fmt("function %s", cmdp->cmdname);
405 1.8 jtc if (verbose) {
406 1.34 christos struct procstat ps;
407 1.8 jtc INTOFF;
408 1.34 christos commandtext(&ps, cmdp->param.func);
409 1.36 dsl INTON;
410 1.36 dsl out1str("() { ");
411 1.34 christos out1str(ps.cmd);
412 1.36 dsl out1str("; }");
413 1.8 jtc }
414 1.34 christos break;
415 1.34 christos default:
416 1.34 christos error("internal error: %s cmdtype %d", cmdp->cmdname, cmdp->cmdtype);
417 1.1 cgd }
418 1.1 cgd if (cmdp->rehash)
419 1.1 cgd out1c('*');
420 1.1 cgd out1c('\n');
421 1.1 cgd }
422 1.1 cgd
423 1.1 cgd
424 1.1 cgd
425 1.1 cgd /*
426 1.1 cgd * Resolve a command name. If you change this routine, you may have to
427 1.1 cgd * change the shellexec routine as well.
428 1.1 cgd */
429 1.1 cgd
430 1.1 cgd void
431 1.34 christos find_command(char *name, struct cmdentry *entry, int act, const char *path)
432 1.12 cgd {
433 1.35 dsl struct tblentry *cmdp, loc_cmd;
434 1.27 christos int idx;
435 1.1 cgd int prev;
436 1.1 cgd char *fullname;
437 1.1 cgd struct stat statb;
438 1.1 cgd int e;
439 1.34 christos int (*bltin)(int,char **);
440 1.1 cgd
441 1.35 dsl /* If name contains a slash, don't use PATH or hash table */
442 1.1 cgd if (strchr(name, '/') != NULL) {
443 1.24 christos if (act & DO_ABS) {
444 1.24 christos while (stat(name, &statb) < 0) {
445 1.34 christos #ifdef SYSV
446 1.24 christos if (errno == EINTR)
447 1.24 christos continue;
448 1.34 christos #endif
449 1.24 christos if (errno != ENOENT && errno != ENOTDIR)
450 1.24 christos e = errno;
451 1.24 christos entry->cmdtype = CMDUNKNOWN;
452 1.24 christos entry->u.index = -1;
453 1.24 christos return;
454 1.24 christos }
455 1.24 christos entry->cmdtype = CMDNORMAL;
456 1.24 christos entry->u.index = -1;
457 1.24 christos return;
458 1.24 christos }
459 1.1 cgd entry->cmdtype = CMDNORMAL;
460 1.1 cgd entry->u.index = 0;
461 1.1 cgd return;
462 1.1 cgd }
463 1.1 cgd
464 1.35 dsl if (path != pathval())
465 1.35 dsl act |= DO_ALTPATH;
466 1.35 dsl
467 1.35 dsl if (act & DO_ALTPATH && strstr(path, "%builtin") != NULL)
468 1.35 dsl act |= DO_ALTBLTIN;
469 1.35 dsl
470 1.35 dsl /* If name is in the table, check answer will be ok */
471 1.35 dsl if ((cmdp = cmdlookup(name, 0)) != NULL) {
472 1.35 dsl do {
473 1.35 dsl switch (cmdp->cmdtype) {
474 1.35 dsl case CMDNORMAL:
475 1.35 dsl if (act & DO_ALTPATH) {
476 1.35 dsl cmdp = NULL;
477 1.35 dsl continue;
478 1.35 dsl }
479 1.35 dsl break;
480 1.35 dsl case CMDFUNCTION:
481 1.35 dsl if (act & DO_NOFUNC) {
482 1.35 dsl cmdp = NULL;
483 1.35 dsl continue;
484 1.35 dsl }
485 1.35 dsl break;
486 1.35 dsl case CMDBUILTIN:
487 1.35 dsl if ((act & DO_ALTBLTIN) || builtinloc >= 0) {
488 1.35 dsl cmdp = NULL;
489 1.35 dsl continue;
490 1.35 dsl }
491 1.35 dsl break;
492 1.35 dsl }
493 1.35 dsl /* if not invalidated by cd, we're done */
494 1.35 dsl if (cmdp->rehash == 0)
495 1.35 dsl goto success;
496 1.35 dsl } while (0);
497 1.35 dsl }
498 1.1 cgd
499 1.1 cgd /* If %builtin not in path, check for builtin next */
500 1.35 dsl if ((act & DO_ALTPATH ? !(act & DO_ALTBLTIN) : builtinloc < 0) &&
501 1.35 dsl (bltin = find_builtin(name)) != 0)
502 1.35 dsl goto builtin_success;
503 1.1 cgd
504 1.1 cgd /* We have to search path. */
505 1.1 cgd prev = -1; /* where to start */
506 1.1 cgd if (cmdp) { /* doing a rehash */
507 1.1 cgd if (cmdp->cmdtype == CMDBUILTIN)
508 1.1 cgd prev = builtinloc;
509 1.1 cgd else
510 1.1 cgd prev = cmdp->param.index;
511 1.1 cgd }
512 1.1 cgd
513 1.1 cgd e = ENOENT;
514 1.27 christos idx = -1;
515 1.1 cgd loop:
516 1.1 cgd while ((fullname = padvance(&path, name)) != NULL) {
517 1.1 cgd stunalloc(fullname);
518 1.27 christos idx++;
519 1.1 cgd if (pathopt) {
520 1.1 cgd if (prefix("builtin", pathopt)) {
521 1.34 christos if ((bltin = find_builtin(name)) == 0)
522 1.1 cgd goto loop;
523 1.35 dsl goto builtin_success;
524 1.1 cgd } else if (prefix("func", pathopt)) {
525 1.1 cgd /* handled below */
526 1.1 cgd } else {
527 1.35 dsl /* ignore unimplemented options */
528 1.35 dsl goto loop;
529 1.1 cgd }
530 1.1 cgd }
531 1.1 cgd /* if rehash, don't redo absolute path names */
532 1.27 christos if (fullname[0] == '/' && idx <= prev) {
533 1.27 christos if (idx < prev)
534 1.1 cgd goto loop;
535 1.1 cgd TRACE(("searchexec \"%s\": no change\n", name));
536 1.1 cgd goto success;
537 1.1 cgd }
538 1.1 cgd while (stat(fullname, &statb) < 0) {
539 1.1 cgd #ifdef SYSV
540 1.1 cgd if (errno == EINTR)
541 1.1 cgd continue;
542 1.1 cgd #endif
543 1.1 cgd if (errno != ENOENT && errno != ENOTDIR)
544 1.1 cgd e = errno;
545 1.1 cgd goto loop;
546 1.1 cgd }
547 1.1 cgd e = EACCES; /* if we fail, this will be the error */
548 1.14 mycroft if (!S_ISREG(statb.st_mode))
549 1.1 cgd goto loop;
550 1.1 cgd if (pathopt) { /* this is a %func directory */
551 1.35 dsl if (act & DO_NOFUNC)
552 1.35 dsl goto loop;
553 1.1 cgd stalloc(strlen(fullname) + 1);
554 1.1 cgd readcmdfile(fullname);
555 1.35 dsl if ((cmdp = cmdlookup(name, 0)) == NULL ||
556 1.35 dsl cmdp->cmdtype != CMDFUNCTION)
557 1.1 cgd error("%s not defined in %s", name, fullname);
558 1.1 cgd stunalloc(fullname);
559 1.1 cgd goto success;
560 1.1 cgd }
561 1.8 jtc #ifdef notdef
562 1.35 dsl /* XXX this code stops root executing stuff, and is buggy
563 1.35 dsl if you need a group from the group list. */
564 1.8 jtc if (statb.st_uid == geteuid()) {
565 1.1 cgd if ((statb.st_mode & 0100) == 0)
566 1.1 cgd goto loop;
567 1.1 cgd } else if (statb.st_gid == getegid()) {
568 1.1 cgd if ((statb.st_mode & 010) == 0)
569 1.1 cgd goto loop;
570 1.1 cgd } else {
571 1.8 jtc if ((statb.st_mode & 01) == 0)
572 1.1 cgd goto loop;
573 1.1 cgd }
574 1.4 cgd #endif
575 1.1 cgd TRACE(("searchexec \"%s\" returns \"%s\"\n", name, fullname));
576 1.1 cgd INTOFF;
577 1.35 dsl if (act & DO_ALTPATH) {
578 1.35 dsl stalloc(strlen(fullname) + 1);
579 1.35 dsl cmdp = &loc_cmd;
580 1.35 dsl } else
581 1.35 dsl cmdp = cmdlookup(name, 1);
582 1.1 cgd cmdp->cmdtype = CMDNORMAL;
583 1.27 christos cmdp->param.index = idx;
584 1.1 cgd INTON;
585 1.1 cgd goto success;
586 1.1 cgd }
587 1.1 cgd
588 1.1 cgd /* We failed. If there was an entry for this command, delete it */
589 1.1 cgd if (cmdp)
590 1.1 cgd delete_cmd_entry();
591 1.24 christos if (act & DO_ERR)
592 1.20 abrown outfmt(out2, "%s: %s\n", name, errmsg(e, E_EXEC));
593 1.1 cgd entry->cmdtype = CMDUNKNOWN;
594 1.1 cgd return;
595 1.1 cgd
596 1.35 dsl builtin_success:
597 1.35 dsl INTOFF;
598 1.35 dsl if (act & DO_ALTPATH)
599 1.35 dsl cmdp = &loc_cmd;
600 1.35 dsl else
601 1.35 dsl cmdp = cmdlookup(name, 1);
602 1.36 dsl if (cmdp->cmdtype == CMDFUNCTION)
603 1.36 dsl /* DO_NOFUNC must have been set */
604 1.36 dsl cmdp = &loc_cmd;
605 1.35 dsl cmdp->cmdtype = CMDBUILTIN;
606 1.35 dsl cmdp->param.bltin = bltin;
607 1.35 dsl INTON;
608 1.1 cgd success:
609 1.1 cgd cmdp->rehash = 0;
610 1.1 cgd entry->cmdtype = cmdp->cmdtype;
611 1.1 cgd entry->u = cmdp->param;
612 1.1 cgd }
613 1.1 cgd
614 1.1 cgd
615 1.1 cgd
616 1.1 cgd /*
617 1.1 cgd * Search the table of builtin commands.
618 1.1 cgd */
619 1.1 cgd
620 1.1 cgd int
621 1.34 christos (*find_builtin(name))(int, char **)
622 1.1 cgd char *name;
623 1.12 cgd {
624 1.21 tls const struct builtincmd *bp;
625 1.1 cgd
626 1.1 cgd for (bp = builtincmd ; bp->name ; bp++) {
627 1.1 cgd if (*bp->name == *name && equal(bp->name, name))
628 1.34 christos return bp->builtin;
629 1.34 christos }
630 1.34 christos return 0;
631 1.34 christos }
632 1.34 christos
633 1.34 christos int
634 1.34 christos (*find_splbltin(name))(int, char **)
635 1.34 christos char *name;
636 1.34 christos {
637 1.34 christos const struct builtincmd *bp;
638 1.34 christos
639 1.34 christos for (bp = splbltincmd ; bp->name ; bp++) {
640 1.34 christos if (*bp->name == *name && equal(bp->name, name))
641 1.34 christos return bp->builtin;
642 1.34 christos }
643 1.34 christos return 0;
644 1.34 christos }
645 1.34 christos
646 1.34 christos /*
647 1.34 christos * At shell startup put special builtins into hash table.
648 1.34 christos * ensures they are executed first (see posix).
649 1.34 christos * We stop functions being added with the same name
650 1.34 christos * (as they are impossible to call)
651 1.34 christos */
652 1.34 christos
653 1.34 christos void
654 1.34 christos hash_special_builtins(void)
655 1.34 christos {
656 1.34 christos const struct builtincmd *bp;
657 1.34 christos struct tblentry *cmdp;
658 1.34 christos
659 1.34 christos for (bp = splbltincmd ; bp->name ; bp++) {
660 1.34 christos cmdp = cmdlookup(bp->name, 1);
661 1.34 christos cmdp->cmdtype = CMDSPLBLTIN;
662 1.34 christos cmdp->param.bltin = bp->builtin;
663 1.1 cgd }
664 1.1 cgd }
665 1.1 cgd
666 1.1 cgd
667 1.1 cgd
668 1.1 cgd /*
669 1.1 cgd * Called when a cd is done. Marks all commands so the next time they
670 1.1 cgd * are executed they will be rehashed.
671 1.1 cgd */
672 1.1 cgd
673 1.1 cgd void
674 1.34 christos hashcd(void)
675 1.34 christos {
676 1.1 cgd struct tblentry **pp;
677 1.1 cgd struct tblentry *cmdp;
678 1.1 cgd
679 1.1 cgd for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) {
680 1.1 cgd for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
681 1.1 cgd if (cmdp->cmdtype == CMDNORMAL
682 1.16 christos || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0))
683 1.1 cgd cmdp->rehash = 1;
684 1.1 cgd }
685 1.1 cgd }
686 1.1 cgd }
687 1.1 cgd
688 1.1 cgd
689 1.1 cgd
690 1.1 cgd /*
691 1.35 dsl * Fix command hash table when PATH changed.
692 1.1 cgd * Called before PATH is changed. The argument is the new value of PATH;
693 1.35 dsl * pathval() still returns the old value at this point.
694 1.35 dsl * Called with interrupts off.
695 1.1 cgd */
696 1.1 cgd
697 1.1 cgd void
698 1.34 christos changepath(const char *newval)
699 1.13 mycroft {
700 1.18 christos const char *old, *new;
701 1.27 christos int idx;
702 1.1 cgd int firstchange;
703 1.1 cgd int bltin;
704 1.1 cgd
705 1.1 cgd old = pathval();
706 1.1 cgd new = newval;
707 1.1 cgd firstchange = 9999; /* assume no change */
708 1.27 christos idx = 0;
709 1.1 cgd bltin = -1;
710 1.1 cgd for (;;) {
711 1.1 cgd if (*old != *new) {
712 1.27 christos firstchange = idx;
713 1.16 christos if ((*old == '\0' && *new == ':')
714 1.16 christos || (*old == ':' && *new == '\0'))
715 1.1 cgd firstchange++;
716 1.1 cgd old = new; /* ignore subsequent differences */
717 1.1 cgd }
718 1.1 cgd if (*new == '\0')
719 1.1 cgd break;
720 1.1 cgd if (*new == '%' && bltin < 0 && prefix("builtin", new + 1))
721 1.27 christos bltin = idx;
722 1.1 cgd if (*new == ':') {
723 1.27 christos idx++;
724 1.1 cgd }
725 1.1 cgd new++, old++;
726 1.1 cgd }
727 1.1 cgd if (builtinloc < 0 && bltin >= 0)
728 1.1 cgd builtinloc = bltin; /* zap builtins */
729 1.1 cgd if (builtinloc >= 0 && bltin < 0)
730 1.1 cgd firstchange = 0;
731 1.1 cgd clearcmdentry(firstchange);
732 1.1 cgd builtinloc = bltin;
733 1.1 cgd }
734 1.1 cgd
735 1.1 cgd
736 1.1 cgd /*
737 1.1 cgd * Clear out command entries. The argument specifies the first entry in
738 1.1 cgd * PATH which has changed.
739 1.1 cgd */
740 1.1 cgd
741 1.1 cgd STATIC void
742 1.34 christos clearcmdentry(int firstchange)
743 1.12 cgd {
744 1.1 cgd struct tblentry **tblp;
745 1.1 cgd struct tblentry **pp;
746 1.1 cgd struct tblentry *cmdp;
747 1.1 cgd
748 1.1 cgd INTOFF;
749 1.1 cgd for (tblp = cmdtable ; tblp < &cmdtable[CMDTABLESIZE] ; tblp++) {
750 1.1 cgd pp = tblp;
751 1.1 cgd while ((cmdp = *pp) != NULL) {
752 1.16 christos if ((cmdp->cmdtype == CMDNORMAL &&
753 1.16 christos cmdp->param.index >= firstchange)
754 1.16 christos || (cmdp->cmdtype == CMDBUILTIN &&
755 1.16 christos builtinloc >= firstchange)) {
756 1.1 cgd *pp = cmdp->next;
757 1.1 cgd ckfree(cmdp);
758 1.1 cgd } else {
759 1.1 cgd pp = &cmdp->next;
760 1.1 cgd }
761 1.1 cgd }
762 1.1 cgd }
763 1.1 cgd INTON;
764 1.1 cgd }
765 1.1 cgd
766 1.1 cgd
767 1.1 cgd /*
768 1.1 cgd * Delete all functions.
769 1.1 cgd */
770 1.1 cgd
771 1.1 cgd #ifdef mkinit
772 1.34 christos MKINIT void deletefuncs(void);
773 1.34 christos MKINIT void hash_special_builtins(void);
774 1.34 christos
775 1.34 christos INIT {
776 1.34 christos hash_special_builtins();
777 1.34 christos }
778 1.1 cgd
779 1.1 cgd SHELLPROC {
780 1.1 cgd deletefuncs();
781 1.1 cgd }
782 1.1 cgd #endif
783 1.1 cgd
784 1.1 cgd void
785 1.34 christos deletefuncs(void)
786 1.34 christos {
787 1.1 cgd struct tblentry **tblp;
788 1.1 cgd struct tblentry **pp;
789 1.1 cgd struct tblentry *cmdp;
790 1.1 cgd
791 1.1 cgd INTOFF;
792 1.1 cgd for (tblp = cmdtable ; tblp < &cmdtable[CMDTABLESIZE] ; tblp++) {
793 1.1 cgd pp = tblp;
794 1.1 cgd while ((cmdp = *pp) != NULL) {
795 1.1 cgd if (cmdp->cmdtype == CMDFUNCTION) {
796 1.1 cgd *pp = cmdp->next;
797 1.1 cgd freefunc(cmdp->param.func);
798 1.1 cgd ckfree(cmdp);
799 1.1 cgd } else {
800 1.1 cgd pp = &cmdp->next;
801 1.1 cgd }
802 1.1 cgd }
803 1.1 cgd }
804 1.1 cgd INTON;
805 1.1 cgd }
806 1.1 cgd
807 1.1 cgd
808 1.1 cgd
809 1.1 cgd /*
810 1.1 cgd * Locate a command in the command hash table. If "add" is nonzero,
811 1.1 cgd * add the command to the table if it is not already present. The
812 1.1 cgd * variable "lastcmdentry" is set to point to the address of the link
813 1.1 cgd * pointing to the entry, so that delete_cmd_entry can delete the
814 1.1 cgd * entry.
815 1.1 cgd */
816 1.1 cgd
817 1.1 cgd struct tblentry **lastcmdentry;
818 1.1 cgd
819 1.1 cgd
820 1.1 cgd STATIC struct tblentry *
821 1.34 christos cmdlookup(const char *name, int add)
822 1.12 cgd {
823 1.1 cgd int hashval;
824 1.34 christos const char *p;
825 1.1 cgd struct tblentry *cmdp;
826 1.1 cgd struct tblentry **pp;
827 1.1 cgd
828 1.1 cgd p = name;
829 1.1 cgd hashval = *p << 4;
830 1.1 cgd while (*p)
831 1.1 cgd hashval += *p++;
832 1.1 cgd hashval &= 0x7FFF;
833 1.1 cgd pp = &cmdtable[hashval % CMDTABLESIZE];
834 1.1 cgd for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
835 1.1 cgd if (equal(cmdp->cmdname, name))
836 1.1 cgd break;
837 1.1 cgd pp = &cmdp->next;
838 1.1 cgd }
839 1.1 cgd if (add && cmdp == NULL) {
840 1.1 cgd INTOFF;
841 1.1 cgd cmdp = *pp = ckmalloc(sizeof (struct tblentry) - ARB
842 1.1 cgd + strlen(name) + 1);
843 1.1 cgd cmdp->next = NULL;
844 1.1 cgd cmdp->cmdtype = CMDUNKNOWN;
845 1.1 cgd cmdp->rehash = 0;
846 1.1 cgd strcpy(cmdp->cmdname, name);
847 1.1 cgd INTON;
848 1.1 cgd }
849 1.1 cgd lastcmdentry = pp;
850 1.1 cgd return cmdp;
851 1.1 cgd }
852 1.1 cgd
853 1.1 cgd /*
854 1.1 cgd * Delete the command entry returned on the last lookup.
855 1.1 cgd */
856 1.1 cgd
857 1.1 cgd STATIC void
858 1.34 christos delete_cmd_entry(void)
859 1.34 christos {
860 1.1 cgd struct tblentry *cmdp;
861 1.1 cgd
862 1.1 cgd INTOFF;
863 1.1 cgd cmdp = *lastcmdentry;
864 1.1 cgd *lastcmdentry = cmdp->next;
865 1.1 cgd ckfree(cmdp);
866 1.1 cgd INTON;
867 1.1 cgd }
868 1.1 cgd
869 1.1 cgd
870 1.1 cgd
871 1.1 cgd #ifdef notdef
872 1.1 cgd void
873 1.34 christos getcmdentry(char *name, struct cmdentry *entry)
874 1.34 christos {
875 1.1 cgd struct tblentry *cmdp = cmdlookup(name, 0);
876 1.1 cgd
877 1.1 cgd if (cmdp) {
878 1.1 cgd entry->u = cmdp->param;
879 1.1 cgd entry->cmdtype = cmdp->cmdtype;
880 1.1 cgd } else {
881 1.1 cgd entry->cmdtype = CMDUNKNOWN;
882 1.1 cgd entry->u.index = 0;
883 1.1 cgd }
884 1.1 cgd }
885 1.1 cgd #endif
886 1.1 cgd
887 1.1 cgd
888 1.1 cgd /*
889 1.1 cgd * Add a new command entry, replacing any existing command entry for
890 1.34 christos * the same name - except special builtins.
891 1.1 cgd */
892 1.1 cgd
893 1.35 dsl STATIC void
894 1.34 christos addcmdentry(char *name, struct cmdentry *entry)
895 1.34 christos {
896 1.1 cgd struct tblentry *cmdp;
897 1.1 cgd
898 1.1 cgd INTOFF;
899 1.1 cgd cmdp = cmdlookup(name, 1);
900 1.34 christos if (cmdp->cmdtype != CMDSPLBLTIN) {
901 1.34 christos if (cmdp->cmdtype == CMDFUNCTION) {
902 1.34 christos freefunc(cmdp->param.func);
903 1.34 christos }
904 1.34 christos cmdp->cmdtype = entry->cmdtype;
905 1.34 christos cmdp->param = entry->u;
906 1.1 cgd }
907 1.1 cgd INTON;
908 1.1 cgd }
909 1.1 cgd
910 1.1 cgd
911 1.1 cgd /*
912 1.1 cgd * Define a shell function.
913 1.1 cgd */
914 1.1 cgd
915 1.1 cgd void
916 1.34 christos defun(char *name, union node *func)
917 1.34 christos {
918 1.1 cgd struct cmdentry entry;
919 1.1 cgd
920 1.1 cgd INTOFF;
921 1.1 cgd entry.cmdtype = CMDFUNCTION;
922 1.1 cgd entry.u.func = copyfunc(func);
923 1.1 cgd addcmdentry(name, &entry);
924 1.1 cgd INTON;
925 1.1 cgd }
926 1.1 cgd
927 1.1 cgd
928 1.1 cgd /*
929 1.1 cgd * Delete a function if it exists.
930 1.1 cgd */
931 1.1 cgd
932 1.8 jtc int
933 1.34 christos unsetfunc(char *name)
934 1.34 christos {
935 1.1 cgd struct tblentry *cmdp;
936 1.1 cgd
937 1.35 dsl if ((cmdp = cmdlookup(name, 0)) != NULL &&
938 1.35 dsl cmdp->cmdtype == CMDFUNCTION) {
939 1.1 cgd freefunc(cmdp->param.func);
940 1.1 cgd delete_cmd_entry();
941 1.8 jtc return (0);
942 1.1 cgd }
943 1.8 jtc return (1);
944 1.22 christos }
945 1.22 christos
946 1.22 christos /*
947 1.22 christos * Locate and print what a word is...
948 1.35 dsl * also used for 'command -[v|V]'
949 1.22 christos */
950 1.22 christos
951 1.22 christos int
952 1.34 christos typecmd(int argc, char **argv)
953 1.22 christos {
954 1.22 christos struct cmdentry entry;
955 1.22 christos struct tblentry *cmdp;
956 1.30 matt char * const *pp;
957 1.22 christos struct alias *ap;
958 1.27 christos int err = 0;
959 1.35 dsl char *arg;
960 1.35 dsl int c;
961 1.35 dsl int V_flag = 0;
962 1.35 dsl int v_flag = 0;
963 1.35 dsl int p_flag = 0;
964 1.22 christos
965 1.35 dsl while ((c = nextopt("vVp")) != 0) {
966 1.35 dsl switch (c) {
967 1.35 dsl case 'v': v_flag = 1; break;
968 1.35 dsl case 'V': V_flag = 1; break;
969 1.35 dsl case 'p': p_flag = 1; break;
970 1.35 dsl }
971 1.35 dsl }
972 1.35 dsl
973 1.35 dsl if (p_flag && (v_flag || V_flag))
974 1.35 dsl error("cannot specify -p with -v or -V");
975 1.35 dsl
976 1.35 dsl while ((arg = *argptr++)) {
977 1.35 dsl if (!v_flag)
978 1.35 dsl out1str(arg);
979 1.22 christos /* First look at the keywords */
980 1.30 matt for (pp = parsekwd; *pp; pp++)
981 1.35 dsl if (**pp == *arg && equal(*pp, arg))
982 1.22 christos break;
983 1.22 christos
984 1.22 christos if (*pp) {
985 1.35 dsl if (v_flag)
986 1.35 dsl err = 1;
987 1.35 dsl else
988 1.35 dsl out1str(" is a shell keyword\n");
989 1.22 christos continue;
990 1.22 christos }
991 1.22 christos
992 1.22 christos /* Then look at the aliases */
993 1.35 dsl if ((ap = lookupalias(arg, 1)) != NULL) {
994 1.35 dsl if (!v_flag)
995 1.35 dsl out1fmt(" is an alias for \n");
996 1.35 dsl out1fmt("%s\n", ap->val);
997 1.22 christos continue;
998 1.22 christos }
999 1.22 christos
1000 1.22 christos /* Then check if it is a tracked alias */
1001 1.35 dsl if ((cmdp = cmdlookup(arg, 0)) != NULL) {
1002 1.22 christos entry.cmdtype = cmdp->cmdtype;
1003 1.22 christos entry.u = cmdp->param;
1004 1.35 dsl } else {
1005 1.22 christos /* Finally use brute force */
1006 1.35 dsl find_command(arg, &entry, DO_ABS, pathval());
1007 1.22 christos }
1008 1.22 christos
1009 1.22 christos switch (entry.cmdtype) {
1010 1.22 christos case CMDNORMAL: {
1011 1.35 dsl if (strchr(arg, '/') == NULL) {
1012 1.31 christos const char *path = pathval();
1013 1.31 christos char *name;
1014 1.31 christos int j = entry.u.index;
1015 1.31 christos do {
1016 1.35 dsl name = padvance(&path, arg);
1017 1.24 christos stunalloc(name);
1018 1.24 christos } while (--j >= 0);
1019 1.35 dsl if (!v_flag)
1020 1.35 dsl out1fmt(" is%s ",
1021 1.35 dsl cmdp ? " a tracked alias for" : "");
1022 1.35 dsl out1fmt("%s\n", name);
1023 1.31 christos } else {
1024 1.35 dsl if (access(arg, X_OK) == 0) {
1025 1.35 dsl if (!v_flag)
1026 1.35 dsl out1fmt(" is ");
1027 1.35 dsl out1fmt("%s\n", arg);
1028 1.35 dsl } else {
1029 1.35 dsl if (!v_flag)
1030 1.35 dsl out1fmt(": %s\n",
1031 1.35 dsl strerror(errno));
1032 1.35 dsl else
1033 1.35 dsl err = 126;
1034 1.35 dsl }
1035 1.24 christos }
1036 1.31 christos break;
1037 1.22 christos }
1038 1.22 christos case CMDFUNCTION:
1039 1.35 dsl if (!v_flag)
1040 1.35 dsl out1str(" is a shell function\n");
1041 1.35 dsl else
1042 1.35 dsl out1fmt("%s\n", arg);
1043 1.22 christos break;
1044 1.22 christos
1045 1.22 christos case CMDBUILTIN:
1046 1.35 dsl if (!v_flag)
1047 1.35 dsl out1str(" is a shell builtin\n");
1048 1.35 dsl else
1049 1.35 dsl out1fmt("%s\n", arg);
1050 1.34 christos break;
1051 1.34 christos
1052 1.34 christos case CMDSPLBLTIN:
1053 1.35 dsl if (!v_flag)
1054 1.35 dsl out1str(" is a special shell builtin\n");
1055 1.35 dsl else
1056 1.35 dsl out1fmt("%s\n", arg);
1057 1.22 christos break;
1058 1.22 christos
1059 1.22 christos default:
1060 1.35 dsl if (!v_flag)
1061 1.35 dsl out1str(": not found\n");
1062 1.35 dsl err = 127;
1063 1.22 christos break;
1064 1.22 christos }
1065 1.22 christos }
1066 1.27 christos return err;
1067 1.1 cgd }
1068