sh: Make various functions static.
[dragonfly.git] / bin / sh / exec.c
1 /*-
2  * Copyright (c) 1991, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * This code is derived from software contributed to Berkeley by
6  * Kenneth Almquist.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  *      This product includes software developed by the University of
19  *      California, Berkeley and its contributors.
20  * 4. Neither the name of the University nor the names of its contributors
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.
35  *
36  * @(#)exec.c   8.4 (Berkeley) 6/8/95
37  * $FreeBSD: src/bin/sh/exec.c,v 1.53 2012/01/01 22:17:12 jilles Exp $
38  */
39
40 #include <sys/types.h>
41 #include <sys/stat.h>
42 #include <unistd.h>
43 #include <fcntl.h>
44 #include <errno.h>
45 #include <paths.h>
46 #include <stdlib.h>
47
48 /*
49  * When commands are first encountered, they are entered in a hash table.
50  * This ensures that a full path search will not have to be done for them
51  * on each invocation.
52  *
53  * We should investigate converting to a linear search, even though that
54  * would make the command name "hash" a misnomer.
55  */
56
57 #include "shell.h"
58 #include "main.h"
59 #include "nodes.h"
60 #include "parser.h"
61 #include "redir.h"
62 #include "eval.h"
63 #include "exec.h"
64 #include "builtins.h"
65 #include "var.h"
66 #include "options.h"
67 #include "input.h"
68 #include "output.h"
69 #include "syntax.h"
70 #include "memalloc.h"
71 #include "error.h"
72 #include "init.h"
73 #include "mystring.h"
74 #include "show.h"
75 #include "jobs.h"
76 #include "alias.h"
77
78
79 #define CMDTABLESIZE 31         /* should be prime */
80 #define ARB 1                   /* actual size determined at run time */
81
82
83
84 struct tblentry {
85         struct tblentry *next;  /* next entry in hash chain */
86         union param param;      /* definition of builtin function */
87         int special;            /* flag for special builtin commands */
88         short cmdtype;          /* index identifying command */
89         char rehash;            /* if set, cd done since entry created */
90         char cmdname[ARB];      /* name of command */
91 };
92
93
94 static struct tblentry *cmdtable[CMDTABLESIZE];
95 int exerrno = 0;                        /* Last exec error */
96
97
98 static void tryexec(char *, char **, char **);
99 static void printentry(struct tblentry *, int);
100 static struct tblentry *cmdlookup(const char *, int);
101 static void delete_cmd_entry(void);
102 static void addcmdentry(const char *, struct cmdentry *);
103
104 /*
105  * Exec a program.  Never returns.  If you change this routine, you may
106  * have to change the find_command routine as well.
107  *
108  * The argv array may be changed and element argv[-1] should be writable.
109  */
110
111 void
112 shellexec(char **argv, char **envp, const char *path, int idx)
113 {
114         char *cmdname;
115         int e;
116
117         if (strchr(argv[0], '/') != NULL) {
118                 tryexec(argv[0], argv, envp);
119                 e = errno;
120         } else {
121                 e = ENOENT;
122                 while ((cmdname = padvance(&path, argv[0])) != NULL) {
123                         if (--idx < 0 && pathopt == NULL) {
124                                 tryexec(cmdname, argv, envp);
125                                 if (errno != ENOENT && errno != ENOTDIR)
126                                         e = errno;
127                                 if (e == ENOEXEC)
128                                         break;
129                         }
130                         stunalloc(cmdname);
131                 }
132         }
133
134         /* Map to POSIX errors */
135         if (e == ENOENT || e == ENOTDIR) {
136                 exerrno = 127;
137                 exerror(EXEXEC, "%s: not found", argv[0]);
138         } else {
139                 exerrno = 126;
140                 exerror(EXEXEC, "%s: %s", argv[0], strerror(e));
141         }
142 }
143
144
145 static void
146 tryexec(char *cmd, char **argv, char **envp)
147 {
148         int e, in;
149         ssize_t n;
150         char buf[256];
151
152         execve(cmd, argv, envp);
153         e = errno;
154         if (e == ENOEXEC) {
155                 INTOFF;
156                 in = open(cmd, O_RDONLY | O_NONBLOCK);
157                 if (in != -1) {
158                         n = pread(in, buf, sizeof buf, 0);
159                         close(in);
160                         if (n > 0 && memchr(buf, '\0', n) != NULL) {
161                                 errno = ENOEXEC;
162                                 return;
163                         }
164                 }
165                 *argv = cmd;
166                 *--argv = __DECONST(char *, _PATH_BSHELL);
167                 execve(_PATH_BSHELL, argv, envp);
168         }
169         errno = e;
170 }
171
172 /*
173  * Do a path search.  The variable path (passed by reference) should be
174  * set to the start of the path before the first call; padvance will update
175  * this value as it proceeds.  Successive calls to padvance will return
176  * the possible path expansions in sequence.  If an option (indicated by
177  * a percent sign) appears in the path entry then the global variable
178  * pathopt will be set to point to it; otherwise pathopt will be set to
179  * NULL.
180  */
181
182 const char *pathopt;
183
184 char *
185 padvance(const char **path, const char *name)
186 {
187         const char *p, *start;
188         char *q;
189         int len;
190
191         if (*path == NULL)
192                 return NULL;
193         start = *path;
194         for (p = start; *p && *p != ':' && *p != '%'; p++)
195                 ; /* nothing */
196         len = p - start + strlen(name) + 2;     /* "2" is for '/' and '\0' */
197         STARTSTACKSTR(q);
198         CHECKSTRSPACE(len, q);
199         if (p != start) {
200                 memcpy(q, start, p - start);
201                 q += p - start;
202                 *q++ = '/';
203         }
204         strcpy(q, name);
205         pathopt = NULL;
206         if (*p == '%') {
207                 pathopt = ++p;
208                 while (*p && *p != ':')  p++;
209         }
210         if (*p == ':')
211                 *path = p + 1;
212         else
213                 *path = NULL;
214         return stalloc(len);
215 }
216
217
218
219 /*** Command hashing code ***/
220
221
222 int
223 hashcmd(int argc __unused, char **argv __unused)
224 {
225         struct tblentry **pp;
226         struct tblentry *cmdp;
227         int c;
228         int verbose;
229         struct cmdentry entry;
230         char *name;
231
232         verbose = 0;
233         while ((c = nextopt("rv")) != '\0') {
234                 if (c == 'r') {
235                         clearcmdentry();
236                 } else if (c == 'v') {
237                         verbose++;
238                 }
239         }
240         if (*argptr == NULL) {
241                 for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) {
242                         for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
243                                 if (cmdp->cmdtype == CMDNORMAL)
244                                         printentry(cmdp, verbose);
245                         }
246                 }
247                 return 0;
248         }
249         while ((name = *argptr) != NULL) {
250                 if ((cmdp = cmdlookup(name, 0)) != NULL
251                  && cmdp->cmdtype == CMDNORMAL)
252                         delete_cmd_entry();
253                 find_command(name, &entry, DO_ERR, pathval());
254                 if (verbose) {
255                         if (entry.cmdtype != CMDUNKNOWN) {      /* if no error msg */
256                                 cmdp = cmdlookup(name, 0);
257                                 if (cmdp != NULL)
258                                         printentry(cmdp, verbose);
259                                 else
260                                         outfmt(out2, "%s: not found\n", name);
261                         }
262                         flushall();
263                 }
264                 argptr++;
265         }
266         return 0;
267 }
268
269
270 static void
271 printentry(struct tblentry *cmdp, int verbose)
272 {
273         int idx;
274         const char *path;
275         char *name;
276
277         if (cmdp->cmdtype == CMDNORMAL) {
278                 idx = cmdp->param.index;
279                 path = pathval();
280                 do {
281                         name = padvance(&path, cmdp->cmdname);
282                         stunalloc(name);
283                 } while (--idx >= 0);
284                 out1str(name);
285         } else if (cmdp->cmdtype == CMDBUILTIN) {
286                 out1fmt("builtin %s", cmdp->cmdname);
287         } else if (cmdp->cmdtype == CMDFUNCTION) {
288                 out1fmt("function %s", cmdp->cmdname);
289                 if (verbose) {
290                         INTOFF;
291                         name = commandtext(getfuncnode(cmdp->param.func));
292                         out1c(' ');
293                         out1str(name);
294                         ckfree(name);
295                         INTON;
296                 }
297 #ifdef DEBUG
298         } else {
299                 error("internal error: cmdtype %d", cmdp->cmdtype);
300 #endif
301         }
302         if (cmdp->rehash)
303                 out1c('*');
304         out1c('\n');
305 }
306
307
308
309 /*
310  * Resolve a command name.  If you change this routine, you may have to
311  * change the shellexec routine as well.
312  */
313
314 void
315 find_command(const char *name, struct cmdentry *entry, int act,
316     const char *path)
317 {
318         struct tblentry *cmdp, loc_cmd;
319         int idx;
320         int prev;
321         char *fullname;
322         struct stat statb;
323         int e;
324         int i;
325         int spec;
326
327         /* If name contains a slash, don't use the hash table */
328         if (strchr(name, '/') != NULL) {
329                 entry->cmdtype = CMDNORMAL;
330                 entry->u.index = 0;
331                 return;
332         }
333
334         /* If name is in the table, and not invalidated by cd, we're done */
335         if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->rehash == 0) {
336                 if (cmdp->cmdtype == CMDFUNCTION && act & DO_NOFUNC)
337                         cmdp = NULL;
338                 else
339                         goto success;
340         }
341
342         /* Check for builtin next */
343         if ((i = find_builtin(name, &spec)) >= 0) {
344                 INTOFF;
345                 cmdp = cmdlookup(name, 1);
346                 if (cmdp->cmdtype == CMDFUNCTION)
347                         cmdp = &loc_cmd;
348                 cmdp->cmdtype = CMDBUILTIN;
349                 cmdp->param.index = i;
350                 cmdp->special = spec;
351                 INTON;
352                 goto success;
353         }
354
355         /* We have to search path. */
356         prev = -1;              /* where to start */
357         if (cmdp) {             /* doing a rehash */
358                 if (cmdp->cmdtype == CMDBUILTIN)
359                         prev = -1;
360                 else
361                         prev = cmdp->param.index;
362         }
363
364         e = ENOENT;
365         idx = -1;
366 loop:
367         while ((fullname = padvance(&path, name)) != NULL) {
368                 stunalloc(fullname);
369                 idx++;
370                 if (pathopt) {
371                         if (prefix("func", pathopt)) {
372                                 /* handled below */
373                         } else {
374                                 goto loop;      /* ignore unimplemented options */
375                         }
376                 }
377                 /* if rehash, don't redo absolute path names */
378                 if (fullname[0] == '/' && idx <= prev) {
379                         if (idx < prev)
380                                 goto loop;
381                         TRACE(("searchexec \"%s\": no change\n", name));
382                         goto success;
383                 }
384                 if (stat(fullname, &statb) < 0) {
385                         if (errno != ENOENT && errno != ENOTDIR)
386                                 e = errno;
387                         goto loop;
388                 }
389                 e = EACCES;     /* if we fail, this will be the error */
390                 if (!S_ISREG(statb.st_mode))
391                         goto loop;
392                 if (pathopt) {          /* this is a %func directory */
393                         stalloc(strlen(fullname) + 1);
394                         readcmdfile(fullname);
395                         if ((cmdp = cmdlookup(name, 0)) == NULL || cmdp->cmdtype != CMDFUNCTION)
396                                 error("%s not defined in %s", name, fullname);
397                         stunalloc(fullname);
398                         goto success;
399                 }
400 #ifdef notdef
401                 if (statb.st_uid == geteuid()) {
402                         if ((statb.st_mode & 0100) == 0)
403                                 goto loop;
404                 } else if (statb.st_gid == getegid()) {
405                         if ((statb.st_mode & 010) == 0)
406                                 goto loop;
407                 } else {
408                         if ((statb.st_mode & 01) == 0)
409                                 goto loop;
410                 }
411 #endif
412                 TRACE(("searchexec \"%s\" returns \"%s\"\n", name, fullname));
413                 INTOFF;
414                 cmdp = cmdlookup(name, 1);
415                 if (cmdp->cmdtype == CMDFUNCTION)
416                         cmdp = &loc_cmd;
417                 cmdp->cmdtype = CMDNORMAL;
418                 cmdp->param.index = idx;
419                 INTON;
420                 goto success;
421         }
422
423         /* We failed.  If there was an entry for this command, delete it */
424         if (cmdp && cmdp->cmdtype != CMDFUNCTION)
425                 delete_cmd_entry();
426         if (act & DO_ERR) {
427                 if (e == ENOENT || e == ENOTDIR)
428                         outfmt(out2, "%s: not found\n", name);
429                 else
430                         outfmt(out2, "%s: %s\n", name, strerror(e));
431         }
432         entry->cmdtype = CMDUNKNOWN;
433         entry->u.index = 0;
434         return;
435
436 success:
437         if (cmdp) {
438                 cmdp->rehash = 0;
439                 entry->cmdtype = cmdp->cmdtype;
440                 entry->u = cmdp->param;
441                 entry->special = cmdp->special;
442         } else
443                 entry->cmdtype = CMDUNKNOWN;
444 }
445
446
447
448 /*
449  * Search the table of builtin commands.
450  */
451
452 int
453 find_builtin(const char *name, int *special)
454 {
455         const struct builtincmd *bp;
456
457         for (bp = builtincmd ; bp->name ; bp++) {
458                 if (*bp->name == *name && equal(bp->name, name)) {
459                         *special = bp->special;
460                         return bp->code;
461                 }
462         }
463         return -1;
464 }
465
466
467
468 /*
469  * Called when a cd is done.  Marks all commands so the next time they
470  * are executed they will be rehashed.
471  */
472
473 void
474 hashcd(void)
475 {
476         struct tblentry **pp;
477         struct tblentry *cmdp;
478
479         for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) {
480                 for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
481                         if (cmdp->cmdtype == CMDNORMAL)
482                                 cmdp->rehash = 1;
483                 }
484         }
485 }
486
487
488
489 /*
490  * Called before PATH is changed.  The argument is the new value of PATH;
491  * pathval() still returns the old value at this point.  Called with
492  * interrupts off.
493  */
494
495 void
496 changepath(const char *newval __unused)
497 {
498         clearcmdentry();
499 }
500
501
502 /*
503  * Clear out command entries.  The argument specifies the first entry in
504  * PATH which has changed.
505  */
506
507 void
508 clearcmdentry(void)
509 {
510         struct tblentry **tblp;
511         struct tblentry **pp;
512         struct tblentry *cmdp;
513
514         INTOFF;
515         for (tblp = cmdtable ; tblp < &cmdtable[CMDTABLESIZE] ; tblp++) {
516                 pp = tblp;
517                 while ((cmdp = *pp) != NULL) {
518                         if (cmdp->cmdtype == CMDNORMAL) {
519                                 *pp = cmdp->next;
520                                 ckfree(cmdp);
521                         } else {
522                                 pp = &cmdp->next;
523                         }
524                 }
525         }
526         INTON;
527 }
528
529
530 /*
531  * Locate a command in the command hash table.  If "add" is nonzero,
532  * add the command to the table if it is not already present.  The
533  * variable "lastcmdentry" is set to point to the address of the link
534  * pointing to the entry, so that delete_cmd_entry can delete the
535  * entry.
536  */
537
538 static struct tblentry **lastcmdentry;
539
540
541 static struct tblentry *
542 cmdlookup(const char *name, int add)
543 {
544         int hashval;
545         const char *p;
546         struct tblentry *cmdp;
547         struct tblentry **pp;
548
549         p = name;
550         hashval = *p << 4;
551         while (*p)
552                 hashval += *p++;
553         hashval &= 0x7FFF;
554         pp = &cmdtable[hashval % CMDTABLESIZE];
555         for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
556                 if (equal(cmdp->cmdname, name))
557                         break;
558                 pp = &cmdp->next;
559         }
560         if (add && cmdp == NULL) {
561                 INTOFF;
562                 cmdp = *pp = ckmalloc(sizeof (struct tblentry) - ARB
563                                         + strlen(name) + 1);
564                 cmdp->next = NULL;
565                 cmdp->cmdtype = CMDUNKNOWN;
566                 cmdp->rehash = 0;
567                 strcpy(cmdp->cmdname, name);
568                 INTON;
569         }
570         lastcmdentry = pp;
571         return cmdp;
572 }
573
574 /*
575  * Delete the command entry returned on the last lookup.
576  */
577
578 static void
579 delete_cmd_entry(void)
580 {
581         struct tblentry *cmdp;
582
583         INTOFF;
584         cmdp = *lastcmdentry;
585         *lastcmdentry = cmdp->next;
586         ckfree(cmdp);
587         INTON;
588 }
589
590
591
592 /*
593  * Add a new command entry, replacing any existing command entry for
594  * the same name.
595  */
596
597 static void
598 addcmdentry(const char *name, struct cmdentry *entry)
599 {
600         struct tblentry *cmdp;
601
602         INTOFF;
603         cmdp = cmdlookup(name, 1);
604         if (cmdp->cmdtype == CMDFUNCTION) {
605                 unreffunc(cmdp->param.func);
606         }
607         cmdp->cmdtype = entry->cmdtype;
608         cmdp->param = entry->u;
609         INTON;
610 }
611
612
613 /*
614  * Define a shell function.
615  */
616
617 void
618 defun(const char *name, union node *func)
619 {
620         struct cmdentry entry;
621
622         INTOFF;
623         entry.cmdtype = CMDFUNCTION;
624         entry.u.func = copyfunc(func);
625         addcmdentry(name, &entry);
626         INTON;
627 }
628
629
630 /*
631  * Delete a function if it exists.
632  */
633
634 int
635 unsetfunc(const char *name)
636 {
637         struct tblentry *cmdp;
638
639         if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->cmdtype == CMDFUNCTION) {
640                 unreffunc(cmdp->param.func);
641                 delete_cmd_entry();
642         }
643         return (0);
644 }
645
646 /*
647  * Shared code for the following builtin commands:
648  *    type, command -v, command -V
649  */
650
651 int
652 typecmd_impl(int argc, char **argv, int cmd, const char *path)
653 {
654         struct cmdentry entry;
655         struct tblentry *cmdp;
656         const char * const *pp;
657         struct alias *ap;
658         int i;
659         int err = 0;
660
661         if (path != pathval())
662                 clearcmdentry();
663
664         for (i = 1; i < argc; i++) {
665                 /* First look at the keywords */
666                 for (pp = parsekwd; *pp; pp++)
667                         if (**pp == *argv[i] && equal(*pp, argv[i]))
668                                 break;
669
670                 if (*pp) {
671                         if (cmd == TYPECMD_SMALLV)
672                                 out1fmt("%s\n", argv[i]);
673                         else
674                                 out1fmt("%s is a shell keyword\n", argv[i]);
675                         continue;
676                 }
677
678                 /* Then look at the aliases */
679                 if ((ap = lookupalias(argv[i], 1)) != NULL) {
680                         if (cmd == TYPECMD_SMALLV)
681                                 out1fmt("alias %s='%s'\n", argv[i], ap->val);
682                         else
683                                 out1fmt("%s is an alias for %s\n", argv[i],
684                                     ap->val);
685                         continue;
686                 }
687
688                 /* Then check if it is a tracked alias */
689                 if ((cmdp = cmdlookup(argv[i], 0)) != NULL) {
690                         entry.cmdtype = cmdp->cmdtype;
691                         entry.u = cmdp->param;
692                         entry.special = cmdp->special;
693                 }
694                 else {
695                         /* Finally use brute force */
696                         find_command(argv[i], &entry, 0, path);
697                 }
698
699                 switch (entry.cmdtype) {
700                 case CMDNORMAL: {
701                         if (strchr(argv[i], '/') == NULL) {
702                                 const char *path2 = path;
703                                 char *name;
704                                 int j = entry.u.index;
705                                 do {
706                                         name = padvance(&path2, argv[i]);
707                                         stunalloc(name);
708                                 } while (--j >= 0);
709                                 if (cmd == TYPECMD_SMALLV)
710                                         out1fmt("%s\n", name);
711                                 else
712                                         out1fmt("%s is%s %s\n", argv[i],
713                                             (cmdp && cmd == TYPECMD_TYPE) ?
714                                                 " a tracked alias for" : "",
715                                             name);
716                         } else {
717                                 if (access(argv[i], X_OK) == 0) {
718                                         if (cmd == TYPECMD_SMALLV)
719                                                 out1fmt("%s\n", argv[i]);
720                                         else
721                                                 out1fmt("%s is %s\n", argv[i],
722                                                     argv[i]);
723                                 } else {
724                                         if (cmd != TYPECMD_SMALLV)
725                                                 outfmt(out2, "%s: %s\n",
726                                                     argv[i], strerror(errno));
727                                         err |= 127;
728                                 }
729                         }
730                         break;
731                 }
732                 case CMDFUNCTION:
733                         if (cmd == TYPECMD_SMALLV)
734                                 out1fmt("%s\n", argv[i]);
735                         else
736                                 out1fmt("%s is a shell function\n", argv[i]);
737                         break;
738
739                 case CMDBUILTIN:
740                         if (cmd == TYPECMD_SMALLV)
741                                 out1fmt("%s\n", argv[i]);
742                         else if (entry.special)
743                                 out1fmt("%s is a special shell builtin\n",
744                                     argv[i]);
745                         else
746                                 out1fmt("%s is a shell builtin\n", argv[i]);
747                         break;
748
749                 default:
750                         if (cmd != TYPECMD_SMALLV)
751                                 outfmt(out2, "%s: not found\n", argv[i]);
752                         err |= 127;
753                         break;
754                 }
755         }
756
757         if (path != pathval())
758                 clearcmdentry();
759
760         return err;
761 }
762
763 /*
764  * Locate and print what a word is...
765  */
766
767 int
768 typecmd(int argc, char **argv)
769 {
770         return typecmd_impl(argc, argv, TYPECMD_TYPE, bltinlookup("PATH", 1));
771 }