2 * Copyright (c) 1991, 1993
3 * The Regents of the University of California. All rights reserved.
5 * This code is derived from software contributed to Berkeley by
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
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. Neither the name of the University nor the names of its contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 static char sccsid
[] = "@(#)exec.c 8.4 (Berkeley) 6/8/95";
38 #include <sys/cdefs.h>
39 __FBSDID("$FreeBSD: head/bin/sh/exec.c 365037 2020-09-01 13:19:15Z jilles $");
41 #include <sys/types.h>
51 * When commands are first encountered, they are entered in a hash table.
52 * This ensures that a full path search will not have to be done for them
55 * We should investigate converting to a linear search, even though that
56 * would make the command name "hash" a misnomer.
80 #define CMDTABLESIZE 31 /* should be prime */
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 signed char cmdtype
; /* index identifying command */
89 char cmdname
[]; /* name of command */
93 static struct tblentry
*cmdtable
[CMDTABLESIZE
];
94 static int cmdtable_cd
= 0; /* cmdtable contains cd-dependent entries */
97 static void tryexec(char *, char **, char **);
98 static void printentry(struct tblentry
*, int);
99 static struct tblentry
*cmdlookup(const char *, int);
100 static void delete_cmd_entry(void);
101 static void addcmdentry(const char *, struct cmdentry
*);
106 * Exec a program. Never returns. If you change this routine, you may
107 * have to change the find_command routine as well.
109 * The argv array may be changed and element argv[-1] should be writable.
113 shellexec(char **argv
, char **envp
, const char *path
, int idx
)
119 if (strchr(argv
[0], '/') != NULL
) {
120 tryexec(argv
[0], argv
, envp
);
124 while ((cmdname
= padvance(&path
, &opt
, argv
[0])) != NULL
) {
125 if (--idx
< 0 && opt
== NULL
) {
126 tryexec(cmdname
, argv
, envp
);
127 if (errno
!= ENOENT
&& errno
!= ENOTDIR
)
136 /* Map to POSIX errors */
137 if (e
== ENOENT
|| e
== ENOTDIR
)
138 errorwithstatus(127, "%s: not found", argv
[0]);
140 errorwithstatus(126, "%s: %s", argv
[0], strerror(e
));
145 isbinary(const char *data
, size_t len
)
150 nul
= memchr(data
, '\0', len
);
154 * POSIX says we shall allow execution if the initial part intended
155 * to be parsed by the shell consists of characters and does not
156 * contain the NUL character. This allows concatenating a shell
157 * script (ending with exec or exit) and a binary payload.
159 * In order to reject common binary files such as PNG images, check
160 * that there is a lowercase letter or expansion before the last
161 * newline before the NUL character, in addition to the check for
162 * the newline character suggested by POSIX.
165 for (p
= data
; *p
!= '\0'; p
++) {
166 if ((*p
>= 'a' && *p
<= 'z') || *p
== '$' || *p
== '`')
168 if (hasletter
&& *p
== '\n')
176 tryexec(char *cmd
, char **argv
, char **envp
)
182 execve(cmd
, argv
, envp
);
186 in
= open(cmd
, O_RDONLY
| O_NONBLOCK
);
188 n
= pread(in
, buf
, sizeof buf
, 0);
190 if (n
> 0 && isbinary(buf
, n
)) {
196 *--argv
= __DECONST(char *, _PATH_BSHELL
);
197 execve(_PATH_BSHELL
, argv
, envp
);
203 * Do a path search. The variable path (passed by reference) should be
204 * set to the start of the path before the first call; padvance will update
205 * this value as it proceeds. Successive calls to padvance will return
206 * the possible path expansions in sequence. If popt is not NULL, options
207 * are processed: if an option (indicated by a percent sign) appears in
208 * the path entry then *popt will be set to point to it; else *popt will be
209 * set to NULL. If popt is NULL, percent signs are not special.
213 padvance(const char **path
, const char **popt
, const char *name
)
215 const char *p
, *start
;
223 for (p
= start
; *p
&& *p
!= ':' && *p
!= '%'; p
++)
226 for (p
= start
; *p
&& *p
!= ':'; p
++)
228 namelen
= strlen(name
);
229 len
= p
- start
+ namelen
+ 2; /* "2" is for '/' and '\0' */
231 CHECKSTRSPACE(len
, q
);
233 memcpy(q
, start
, p
- start
);
237 memcpy(q
, name
, namelen
+ 1);
241 while (*p
&& *p
!= ':') p
++;
254 /*** Command hashing code ***/
258 hashcmd(int argc __unused
, char **argv __unused
)
260 struct tblentry
**pp
;
261 struct tblentry
*cmdp
;
264 struct cmdentry entry
;
270 while ((c
= nextopt("rv")) != '\0') {
273 } else if (c
== 'v') {
277 if (*argptr
== NULL
) {
278 for (pp
= cmdtable
; pp
< &cmdtable
[CMDTABLESIZE
] ; pp
++) {
279 for (cmdp
= *pp
; cmdp
; cmdp
= cmdp
->next
) {
280 if (cmdp
->cmdtype
== CMDNORMAL
)
281 printentry(cmdp
, verbose
);
286 while ((name
= *argptr
) != NULL
) {
287 if ((cmdp
= cmdlookup(name
, 0)) != NULL
288 && cmdp
->cmdtype
== CMDNORMAL
)
290 find_command(name
, &entry
, DO_ERR
, pathval());
291 if (entry
.cmdtype
== CMDUNKNOWN
)
294 cmdp
= cmdlookup(name
, 0);
296 printentry(cmdp
, verbose
);
298 outfmt(out2
, "%s: not found\n", name
);
310 printentry(struct tblentry
*cmdp
, int verbose
)
313 const char *path
, *opt
;
316 if (cmdp
->cmdtype
== CMDNORMAL
) {
317 idx
= cmdp
->param
.index
;
320 name
= padvance(&path
, &opt
, cmdp
->cmdname
);
322 } while (--idx
>= 0);
324 } else if (cmdp
->cmdtype
== CMDBUILTIN
) {
325 out1fmt("builtin %s", cmdp
->cmdname
);
326 } else if (cmdp
->cmdtype
== CMDFUNCTION
) {
327 out1fmt("function %s", cmdp
->cmdname
);
330 name
= commandtext(getfuncnode(cmdp
->param
.func
));
338 error("internal error: cmdtype %d", cmdp
->cmdtype
);
347 * Resolve a command name. If you change this routine, you may have to
348 * change the shellexec routine as well.
352 find_command(const char *name
, struct cmdentry
*entry
, int act
,
355 struct tblentry
*cmdp
, loc_cmd
;
365 /* If name contains a slash, don't use the hash table */
366 if (strchr(name
, '/') != NULL
) {
367 entry
->cmdtype
= CMDNORMAL
;
375 /* If name is in the table, we're done */
376 if ((cmdp
= cmdlookup(name
, 0)) != NULL
) {
377 if (cmdp
->cmdtype
== CMDFUNCTION
&& act
& DO_NOFUNC
)
383 /* Check for builtin next */
384 if ((i
= find_builtin(name
, &spec
)) >= 0) {
386 cmdp
= cmdlookup(name
, 1);
387 if (cmdp
->cmdtype
== CMDFUNCTION
)
389 cmdp
->cmdtype
= CMDBUILTIN
;
390 cmdp
->param
.index
= i
;
391 cmdp
->special
= spec
;
396 /* We have to search path. */
400 for (;(fullname
= padvance(&path
, &opt
, name
)) != NULL
;
401 stunalloc(fullname
)) {
404 if (strncmp(opt
, "func", 4) == 0) {
407 continue; /* ignore unimplemented options */
410 if (fullname
[0] != '/')
412 if (stat(fullname
, &statb
) < 0) {
413 if (errno
!= ENOENT
&& errno
!= ENOTDIR
)
417 e
= EACCES
; /* if we fail, this will be the error */
418 if (!S_ISREG(statb
.st_mode
))
420 if (opt
) { /* this is a %func directory */
421 readcmdfile(fullname
);
422 if ((cmdp
= cmdlookup(name
, 0)) == NULL
|| cmdp
->cmdtype
!= CMDFUNCTION
)
423 error("%s not defined in %s", name
, fullname
);
428 if (statb
.st_uid
== geteuid()) {
429 if ((statb
.st_mode
& 0100) == 0)
431 } else if (statb
.st_gid
== getegid()) {
432 if ((statb
.st_mode
& 010) == 0)
435 if ((statb
.st_mode
& 01) == 0)
439 TRACE(("searchexec \"%s\" returns \"%s\"\n", name
, fullname
));
442 cmdp
= cmdlookup(name
, 1);
443 if (cmdp
->cmdtype
== CMDFUNCTION
)
445 cmdp
->cmdtype
= CMDNORMAL
;
446 cmdp
->param
.index
= idx
;
453 if (e
== ENOENT
|| e
== ENOTDIR
)
454 outfmt(out2
, "%s: not found\n", name
);
456 outfmt(out2
, "%s: %s\n", name
, strerror(e
));
458 entry
->cmdtype
= CMDUNKNOWN
;
466 entry
->cmdtype
= cmdp
->cmdtype
;
467 entry
->u
= cmdp
->param
;
468 entry
->special
= cmdp
->special
;
474 * Search the table of builtin commands.
478 find_builtin(const char *name
, int *special
)
480 const unsigned char *bp
;
484 for (bp
= builtincmd
; *bp
; bp
+= 2 + bp
[0]) {
485 if (bp
[0] == len
&& memcmp(bp
+ 2, name
, len
) == 0) {
486 *special
= (bp
[1] & BUILTIN_SPECIAL
) != 0;
487 return bp
[1] & ~BUILTIN_SPECIAL
;
496 * Called when a cd is done. If any entry in cmdtable depends on the current
497 * directory, simply clear cmdtable completely.
510 * Called before PATH is changed. The argument is the new value of PATH;
511 * pathval() still returns the old value at this point. Called with
516 changepath(const char *newval __unused
)
523 * Clear out cached utility locations.
529 struct tblentry
**tblp
;
530 struct tblentry
**pp
;
531 struct tblentry
*cmdp
;
534 for (tblp
= cmdtable
; tblp
< &cmdtable
[CMDTABLESIZE
] ; tblp
++) {
536 while ((cmdp
= *pp
) != NULL
) {
537 if (cmdp
->cmdtype
== CMDNORMAL
) {
551 * Locate a command in the command hash table. If "add" is nonzero,
552 * add the command to the table if it is not already present. The
553 * variable "lastcmdentry" is set to point to the address of the link
554 * pointing to the entry, so that delete_cmd_entry can delete the
558 static struct tblentry
**lastcmdentry
;
561 static struct tblentry
*
562 cmdlookup(const char *name
, int add
)
564 unsigned int hashval
;
566 struct tblentry
*cmdp
;
567 struct tblentry
**pp
;
571 hashval
= (unsigned char)*p
<< 4;
574 pp
= &cmdtable
[hashval
% CMDTABLESIZE
];
575 for (cmdp
= *pp
; cmdp
; cmdp
= cmdp
->next
) {
576 if (equal(cmdp
->cmdname
, name
))
580 if (add
&& cmdp
== NULL
) {
583 cmdp
= *pp
= ckmalloc(sizeof (struct tblentry
) + len
+ 1);
585 cmdp
->cmdtype
= CMDUNKNOWN
;
586 memcpy(cmdp
->cmdname
, name
, len
+ 1);
594 * Delete the command entry returned on the last lookup.
598 delete_cmd_entry(void)
600 struct tblentry
*cmdp
;
603 cmdp
= *lastcmdentry
;
604 *lastcmdentry
= cmdp
->next
;
612 * Add a new command entry, replacing any existing command entry for
617 addcmdentry(const char *name
, struct cmdentry
*entry
)
619 struct tblentry
*cmdp
;
622 cmdp
= cmdlookup(name
, 1);
623 if (cmdp
->cmdtype
== CMDFUNCTION
) {
624 unreffunc(cmdp
->param
.func
);
626 cmdp
->cmdtype
= entry
->cmdtype
;
627 cmdp
->param
= entry
->u
;
628 cmdp
->special
= entry
->special
;
634 * Define a shell function.
638 defun(const char *name
, union node
*func
)
640 struct cmdentry entry
;
643 entry
.cmdtype
= CMDFUNCTION
;
644 entry
.u
.func
= copyfunc(func
);
646 addcmdentry(name
, &entry
);
652 * Delete a function if it exists.
653 * Called with interrupts off.
657 unsetfunc(const char *name
)
659 struct tblentry
*cmdp
;
661 if ((cmdp
= cmdlookup(name
, 0)) != NULL
&& cmdp
->cmdtype
== CMDFUNCTION
) {
662 unreffunc(cmdp
->param
.func
);
671 * Check if a function by a certain name exists.
674 isfunc(const char *name
)
676 struct tblentry
*cmdp
;
677 cmdp
= cmdlookup(name
, 0);
678 return (cmdp
!= NULL
&& cmdp
->cmdtype
== CMDFUNCTION
);
683 print_absolute_path(const char *name
)
687 if (*name
!= '/' && (pwd
= lookupvar("PWD")) != NULL
&& *pwd
!= '\0') {
689 if (strcmp(pwd
, "/") != 0)
693 outcslow('\n', out1
);
698 * Shared code for the following builtin commands:
699 * type, command -v, command -V
703 typecmd_impl(int argc
, char **argv
, int cmd
, const char *path
)
705 struct cmdentry entry
;
706 struct tblentry
*cmdp
;
707 const char *const *pp
;
712 if (path
!= pathval())
715 for (i
= 1; i
< argc
; i
++) {
716 /* First look at the keywords */
717 for (pp
= parsekwd
; *pp
; pp
++)
718 if (**pp
== *argv
[i
] && equal(*pp
, argv
[i
]))
722 if (cmd
== TYPECMD_SMALLV
)
723 out1fmt("%s\n", argv
[i
]);
725 out1fmt("%s is a shell keyword\n", argv
[i
]);
729 /* Then look at the aliases */
730 if ((ap
= lookupalias(argv
[i
], 1)) != NULL
) {
731 if (cmd
== TYPECMD_SMALLV
) {
732 out1fmt("alias %s=", argv
[i
]);
734 outcslow('\n', out1
);
736 out1fmt("%s is an alias for %s\n", argv
[i
],
741 /* Then check if it is a tracked alias */
742 if ((cmdp
= cmdlookup(argv
[i
], 0)) != NULL
) {
743 entry
.cmdtype
= cmdp
->cmdtype
;
744 entry
.u
= cmdp
->param
;
745 entry
.special
= cmdp
->special
;
748 /* Finally use brute force */
749 find_command(argv
[i
], &entry
, 0, path
);
752 switch (entry
.cmdtype
) {
754 if (strchr(argv
[i
], '/') == NULL
) {
755 const char *path2
= path
;
758 int j
= entry
.u
.index
;
760 name
= padvance(&path2
, &opt2
, argv
[i
]);
763 if (cmd
!= TYPECMD_SMALLV
)
764 out1fmt("%s is%s ", argv
[i
],
765 (cmdp
&& cmd
== TYPECMD_TYPE
) ?
766 " a tracked alias for" : "");
767 print_absolute_path(name
);
769 if (eaccess(argv
[i
], X_OK
) == 0) {
770 if (cmd
!= TYPECMD_SMALLV
)
771 out1fmt("%s is ", argv
[i
]);
772 print_absolute_path(argv
[i
]);
774 if (cmd
!= TYPECMD_SMALLV
)
775 outfmt(out2
, "%s: %s\n",
776 argv
[i
], strerror(errno
));
783 if (cmd
== TYPECMD_SMALLV
)
784 out1fmt("%s\n", argv
[i
]);
786 out1fmt("%s is a shell function\n", argv
[i
]);
790 if (cmd
== TYPECMD_SMALLV
)
791 out1fmt("%s\n", argv
[i
]);
792 else if (entry
.special
)
793 out1fmt("%s is a special shell builtin\n",
796 out1fmt("%s is a shell builtin\n", argv
[i
]);
800 if (cmd
!= TYPECMD_SMALLV
)
801 outfmt(out2
, "%s: not found\n", argv
[i
]);
807 if (path
!= pathval())
814 * Locate and print what a word is...
818 typecmd(int argc
, char **argv
)
820 if (argc
> 2 && strcmp(argv
[1], "--") == 0)
822 return typecmd_impl(argc
, argv
, TYPECMD_TYPE
, bltinlookup("PATH", 1));