ca1166e7d370e0acae5a95e8a9bafe07e49b4260
[dragonfly.git] / lib / libc / gen / exec.c
1 /*-
2  * Copyright (c) 1991, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *      This product includes software developed by the University of
16  *      California, Berkeley and its contributors.
17  * 4. Neither the name of the University nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  * $FreeBSD: src/lib/libc/gen/exec.c,v 1.15 2000/01/27 23:06:14 jasone Exp $
34  * $DragonFly: src/lib/libc/gen/exec.c,v 1.7 2005/11/13 00:07:42 swildner Exp $
35  *
36  * @(#)exec.c   8.1 (Berkeley) 6/4/93
37  * $FreeBSD: src/lib/libc/gen/exec.c,v 1.15 2000/01/27 23:06:14 jasone Exp $
38  */
39
40 #include "namespace.h"
41 #include <sys/param.h>
42 #include <sys/types.h>
43 #include <sys/stat.h>
44 #include <errno.h>
45 #include <unistd.h>
46 #include <stdlib.h>
47 #include <string.h>
48 #include <stdio.h>
49 #include <paths.h>
50 #include "un-namespace.h"
51
52 #include <stdarg.h>
53
54 extern char **environ;
55
56 int
57 execl(const char *name, const char *arg, ...)
58 {
59         va_list ap;
60         const char **argv;
61         int n;
62
63         va_start(ap, arg);
64         n = 1;
65         while (va_arg(ap, char *) != NULL)
66                 n++;
67         va_end(ap);
68         argv = alloca((n + 1) * sizeof(*argv));
69         if (argv == NULL) {
70                 errno = ENOMEM;
71                 return (-1);
72         }
73         va_start(ap, arg);
74         n = 1;
75         argv[0] = arg;
76         while ((argv[n] = va_arg(ap, const char *)) != NULL)
77                 n++;
78         va_end(ap);
79         return (_execve(name, __DECONST(char **, argv),
80                         __DECONST(char **, environ)));
81 }
82
83 int
84 execle(const char *name, const char *arg, ...)
85 {
86         va_list ap;
87         const char **argv, **envp;
88         int n;
89
90         va_start(ap, arg);
91         n = 1;
92         while (va_arg(ap, char *) != NULL)
93                 n++;
94         va_end(ap);
95         argv = alloca((n + 1) * sizeof(*argv));
96         if (argv == NULL) {
97                 errno = ENOMEM;
98                 return (-1);
99         }
100         va_start(ap, arg);
101         n = 1;
102         argv[0] = arg;
103         while ((argv[n] = va_arg(ap, const char *)) != NULL)
104                 n++;
105         envp = va_arg(ap, const char **);
106         va_end(ap);
107         return (_execve(name, __DECONST(char **, argv),
108                         __DECONST(char **, envp)));
109 }
110
111 int
112 execlp(const char *name, const char *arg, ...)
113 {
114         va_list ap;
115         const char **argv;
116         int n;
117
118         va_start(ap, arg);
119         n = 1;
120         while (va_arg(ap, char *) != NULL)
121                 n++;
122         va_end(ap);
123         argv = alloca((n + 1) * sizeof(*argv));
124         if (argv == NULL) {
125                 errno = ENOMEM;
126                 return (-1);
127         }
128         va_start(ap, arg);
129         n = 1;
130         argv[0] = arg;
131         while ((argv[n] = va_arg(ap, const char *)) != NULL)
132                 n++;
133         va_end(ap);
134         return (execvp(name, __DECONST(char **, argv)));
135 }
136
137 int
138 execv(const char *name, char * const *argv)
139 {
140         _execve(name, argv, environ);
141         return (-1);
142 }
143
144 int
145 execvp(const char *name, char * const *argv)
146 {
147         const char **memp;
148         int cnt;
149         size_t lp, ln;
150         int eacces, save_errno;
151         const char *bp, *p, *path;
152         char *cur, buf[MAXPATHLEN];
153         struct stat sb;
154
155         eacces = 0;
156
157         /* If it's an absolute or relative path name, it's easy. */
158         if (index(name, '/')) {
159                 bp = name;
160                 cur = NULL;
161                 path = NULL;
162                 goto retry;
163         }
164         bp = buf;
165
166         /* If it's an empty path name, fail in the usual POSIX way. */
167         if (*name == '\0') {
168                 errno = ENOENT;
169                 return (-1);
170         }
171
172         /* Get the path we're searching. */
173         if (!(path = getenv("PATH")))
174                 path = _PATH_DEFPATH;
175         cur = alloca(strlen(path) + 1);
176         if (cur == NULL) {
177                 errno = ENOMEM;
178                 return (-1);
179         }
180         strcpy(cur, path);
181         path = cur;
182         while ( (p = strsep(&cur, ":")) ) {
183                 /*
184                  * It's a SHELL path -- double, leading and trailing colons
185                  * mean the current directory.
186                  */
187                 if (!*p) {
188                         p = ".";
189                         lp = 1;
190                 } else
191                         lp = strlen(p);
192                 ln = strlen(name);
193
194                 /*
195                  * If the path is too long complain.  This is a possible
196                  * security issue; given a way to make the path too long
197                  * the user may execute the wrong program.
198                  */
199                 if (lp + ln + 2 > sizeof(buf)) {
200                         _write(STDERR_FILENO, "execvp: ", 8);
201                         _write(STDERR_FILENO, p, lp);
202                         _write(STDERR_FILENO, ": path too long\n", 16);
203                         continue;
204                 }
205                 bcopy(p, buf, lp);
206                 buf[lp] = '/';
207                 bcopy(name, buf + lp + 1, ln);
208                 buf[lp + ln + 1] = '\0';
209
210 retry:          _execve(bp, argv, environ);
211                 switch(errno) {
212                 case E2BIG:
213                         goto done;
214                 case ELOOP:
215                 case ENAMETOOLONG:
216                 case ENOENT:
217                         break;
218                 case ENOEXEC:
219                         for (cnt = 0; argv[cnt]; ++cnt)
220                                 ;
221                         memp = alloca((cnt + 2) * sizeof(char *));
222                         if (memp == NULL) {
223                                 /* errno = ENOMEM; XXX override ENOEXEC? */
224                                 goto done;
225                         }
226                         memp[0] = "sh";
227                         memp[1] = bp;
228                         bcopy(argv + 1, memp + 2, cnt * sizeof(char *));
229                         _execve(_PATH_BSHELL, __DECONST(char **, memp), environ);
230                         goto done;
231                 case ENOMEM:
232                         goto done;
233                 case ENOTDIR:
234                         break;
235                 case ETXTBSY:
236                         /*
237                          * We used to retry here, but sh(1) doesn't.
238                          */
239                         goto done;
240                 default:
241                         /*
242                          * EACCES may be for an inaccessible directory or
243                          * a non-executable file.  Call stat() to decide
244                          * which.  This also handles ambiguities for EFAULT
245                          * and EIO, and undocumented errors like ESTALE.
246                          * We hope that the race for a stat() is unimportant.
247                          */
248                         save_errno = errno;
249                         if (stat(bp, &sb) != 0)
250                                 break;
251                         if (save_errno == EACCES) {
252                                 eacces = 1;
253                                 continue;
254                         }
255                         errno = save_errno;
256                         goto done;
257                 }
258         }
259         if (eacces)
260                 errno = EACCES;
261         else
262                 errno = ENOENT;
263 done:
264         return (-1);
265 }