1/* Guts of POSIX spawn interface. Generic POSIX.1 version.
2 Copyright (C) 2000-2016 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <http://www.gnu.org/licenses/>. */
18
19#include <errno.h>
20#include <fcntl.h>
21#include <paths.h>
22#include <spawn.h>
23#include <stdbool.h>
24#include <stdlib.h>
25#include <string.h>
26#include <unistd.h>
27#include <signal.h>
28#include <sys/resource.h>
29#include "spawn_int.h"
30#include <not-cancel.h>
31#include <local-setxid.h>
32#include <shlib-compat.h>
33
34
35/* The Unix standard contains a long explanation of the way to signal
36 an error after the fork() was successful. Since no new wait status
37 was wanted there is no way to signal an error using one of the
38 available methods. The committee chose to signal an error by a
39 normal program exit with the exit code 127. */
40#define SPAWN_ERROR 127
41
42
43/* The file is accessible but it is not an executable file. Invoke
44 the shell to interpret it as a script. */
45static void
46internal_function
47script_execute (const char *file, char *const argv[], char *const envp[])
48{
49 /* Count the arguments. */
50 int argc = 0;
51 while (argv[argc++])
52 ;
53
54 /* Construct an argument list for the shell. */
55 {
56 char *new_argv[argc + 1];
57 new_argv[0] = (char *) _PATH_BSHELL;
58 new_argv[1] = (char *) file;
59 while (argc > 1)
60 {
61 new_argv[argc] = argv[argc - 1];
62 --argc;
63 }
64
65 /* Execute the shell. */
66 __execve (new_argv[0], new_argv, envp);
67 }
68}
69
70static inline void
71maybe_script_execute (const char *file, char *const argv[], char *const envp[],
72 int xflags)
73{
74 if (SHLIB_COMPAT (libc, GLIBC_2_2, GLIBC_2_15)
75 && (xflags & SPAWN_XFLAGS_TRY_SHELL)
76 && errno == ENOEXEC)
77 script_execute (file, argv, envp);
78}
79
80/* Spawn a new process executing PATH with the attributes describes in *ATTRP.
81 Before running the process perform the actions described in FILE-ACTIONS. */
82int
83__spawni (pid_t *pid, const char *file,
84 const posix_spawn_file_actions_t *file_actions,
85 const posix_spawnattr_t *attrp, char *const argv[],
86 char *const envp[], int xflags)
87{
88 pid_t new_pid;
89 char *path, *p, *name;
90 size_t len;
91 size_t pathlen;
92
93 /* Do this once. */
94 short int flags = attrp == NULL ? 0 : attrp->__flags;
95
96 /* Generate the new process. */
97 if ((flags & POSIX_SPAWN_USEVFORK) != 0
98 /* If no major work is done, allow using vfork. Note that we
99 might perform the path searching. But this would be done by
100 a call to execvp(), too, and such a call must be OK according
101 to POSIX. */
102 || ((flags & (POSIX_SPAWN_SETSIGMASK | POSIX_SPAWN_SETSIGDEF
103 | POSIX_SPAWN_SETSCHEDPARAM | POSIX_SPAWN_SETSCHEDULER
104 | POSIX_SPAWN_SETPGROUP | POSIX_SPAWN_RESETIDS)) == 0
105 && file_actions == NULL))
106 new_pid = __vfork ();
107 else
108 new_pid = __fork ();
109
110 if (new_pid != 0)
111 {
112 if (new_pid < 0)
113 return errno;
114
115 /* The call was successful. Store the PID if necessary. */
116 if (pid != NULL)
117 *pid = new_pid;
118
119 return 0;
120 }
121
122 /* Set signal mask. */
123 if ((flags & POSIX_SPAWN_SETSIGMASK) != 0
124 && __sigprocmask (SIG_SETMASK, &attrp->__ss, NULL) != 0)
125 _exit (SPAWN_ERROR);
126
127 /* Set signal default action. */
128 if ((flags & POSIX_SPAWN_SETSIGDEF) != 0)
129 {
130 /* We have to iterate over all signals. This could possibly be
131 done better but it requires system specific solutions since
132 the sigset_t data type can be very different on different
133 architectures. */
134 int sig;
135 struct sigaction sa;
136
137 memset (&sa, '\0', sizeof (sa));
138 sa.sa_handler = SIG_DFL;
139
140 for (sig = 1; sig <= _NSIG; ++sig)
141 if (__sigismember (&attrp->__sd, sig) != 0
142 && __sigaction (sig, &sa, NULL) != 0)
143 _exit (SPAWN_ERROR);
144
145 }
146
147#ifdef _POSIX_PRIORITY_SCHEDULING
148 /* Set the scheduling algorithm and parameters. */
149 if ((flags & (POSIX_SPAWN_SETSCHEDPARAM | POSIX_SPAWN_SETSCHEDULER))
150 == POSIX_SPAWN_SETSCHEDPARAM)
151 {
152 if (__sched_setparam (0, &attrp->__sp) == -1)
153 _exit (SPAWN_ERROR);
154 }
155 else if ((flags & POSIX_SPAWN_SETSCHEDULER) != 0)
156 {
157 if (__sched_setscheduler (0, attrp->__policy, &attrp->__sp) == -1)
158 _exit (SPAWN_ERROR);
159 }
160#endif
161
162 /* Set the process group ID. */
163 if ((flags & POSIX_SPAWN_SETPGROUP) != 0
164 && __setpgid (0, attrp->__pgrp) != 0)
165 _exit (SPAWN_ERROR);
166
167 /* Set the effective user and group IDs. */
168 if ((flags & POSIX_SPAWN_RESETIDS) != 0
169 && (local_seteuid (__getuid ()) != 0
170 || local_setegid (__getgid ()) != 0))
171 _exit (SPAWN_ERROR);
172
173 /* Execute the file actions. */
174 if (file_actions != NULL)
175 {
176 int cnt;
177 struct rlimit64 fdlimit;
178 bool have_fdlimit = false;
179
180 for (cnt = 0; cnt < file_actions->__used; ++cnt)
181 {
182 struct __spawn_action *action = &file_actions->__actions[cnt];
183
184 switch (action->tag)
185 {
186 case spawn_do_close:
187 if (close_not_cancel (action->action.close_action.fd) != 0)
188 {
189 if (! have_fdlimit)
190 {
191 __getrlimit64 (RLIMIT_NOFILE, &fdlimit);
192 have_fdlimit = true;
193 }
194
195 /* Only signal errors for file descriptors out of range. */
196 if (action->action.close_action.fd < 0
197 || action->action.close_action.fd >= fdlimit.rlim_cur)
198 /* Signal the error. */
199 _exit (SPAWN_ERROR);
200 }
201 break;
202
203 case spawn_do_open:
204 {
205 int new_fd = open_not_cancel (action->action.open_action.path,
206 action->action.open_action.oflag
207 | O_LARGEFILE,
208 action->action.open_action.mode);
209
210 if (new_fd == -1)
211 /* The `open' call failed. */
212 _exit (SPAWN_ERROR);
213
214 /* Make sure the desired file descriptor is used. */
215 if (new_fd != action->action.open_action.fd)
216 {
217 if (__dup2 (new_fd, action->action.open_action.fd)
218 != action->action.open_action.fd)
219 /* The `dup2' call failed. */
220 _exit (SPAWN_ERROR);
221
222 if (close_not_cancel (new_fd) != 0)
223 /* The `close' call failed. */
224 _exit (SPAWN_ERROR);
225 }
226 }
227 break;
228
229 case spawn_do_dup2:
230 if (__dup2 (action->action.dup2_action.fd,
231 action->action.dup2_action.newfd)
232 != action->action.dup2_action.newfd)
233 /* The `dup2' call failed. */
234 _exit (SPAWN_ERROR);
235 break;
236 }
237 }
238 }
239
240 if ((xflags & SPAWN_XFLAGS_USE_PATH) == 0 || strchr (file, '/') != NULL)
241 {
242 /* The FILE parameter is actually a path. */
243 __execve (file, argv, envp);
244
245 maybe_script_execute (file, argv, envp, xflags);
246
247 /* Oh, oh. `execve' returns. This is bad. */
248 _exit (SPAWN_ERROR);
249 }
250
251 /* We have to search for FILE on the path. */
252 path = getenv ("PATH");
253 if (path == NULL)
254 {
255 /* There is no `PATH' in the environment.
256 The default search path is the current directory
257 followed by the path `confstr' returns for `_CS_PATH'. */
258 len = confstr (_CS_PATH, (char *) NULL, 0);
259 path = (char *) __alloca (1 + len);
260 path[0] = ':';
261 (void) confstr (_CS_PATH, path + 1, len);
262 }
263
264 len = strlen (file) + 1;
265 pathlen = strlen (path);
266 name = __alloca (pathlen + len + 1);
267 /* Copy the file name at the top. */
268 name = (char *) memcpy (name + pathlen + 1, file, len);
269 /* And add the slash. */
270 *--name = '/';
271
272 p = path;
273 do
274 {
275 char *startp;
276
277 path = p;
278 p = __strchrnul (path, ':');
279
280 if (p == path)
281 /* Two adjacent colons, or a colon at the beginning or the end
282 of `PATH' means to search the current directory. */
283 startp = name + 1;
284 else
285 startp = (char *) memcpy (name - (p - path), path, p - path);
286
287 /* Try to execute this name. If it works, execv will not return. */
288 __execve (startp, argv, envp);
289
290 maybe_script_execute (startp, argv, envp, xflags);
291
292 switch (errno)
293 {
294 case EACCES:
295 case ENOENT:
296 case ESTALE:
297 case ENOTDIR:
298 /* Those errors indicate the file is missing or not executable
299 by us, in which case we want to just try the next path
300 directory. */
301 break;
302
303 default:
304 /* Some other error means we found an executable file, but
305 something went wrong executing it; return the error to our
306 caller. */
307 _exit (SPAWN_ERROR);
308 }
309 }
310 while (*p++ != '\0');
311
312 /* Return with an error. */
313 _exit (SPAWN_ERROR);
314}
315