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