xref: /haiku/src/system/libroot/posix/spawn.cpp (revision c42868a015daa160e093679b2637b1cf9f0b26ba)
1 /*
2  * Copyright 2017, Jérôme Duval, jerome.Duval@gmail.com
3  * Distributed under the terms of the MIT license.
4  */
5 
6 
7 #include <spawn.h>
8 
9 #include <errno.h>
10 #include <signal.h>
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <string.h>
14 #include <unistd.h>
15 
16 #include <signal_defs.h>
17 #include <syscalls.h>
18 
19 
20 enum action_type {
21 	file_action_open,
22 	file_action_close,
23 	file_action_dup2
24 };
25 
26 struct _file_action {
27 	enum action_type type;
28 	int fd;
29 	union {
30 		struct {
31 			char* path;
32 			int	oflag;
33 			mode_t mode;
34 		} open_action;
35 		struct {
36 			int srcfd;
37 		} dup2_action;
38 	} action;
39 };
40 
41 struct _posix_spawnattr {
42 	short	flags;
43 	pid_t	pgroup;
44 	sigset_t	sigdefault;
45 	sigset_t	sigmask;
46 };
47 
48 struct _posix_spawn_file_actions {
49 	int		size;
50 	int		count;
51 	_file_action *actions;
52 };
53 
54 
55 static int
56 posix_spawn_file_actions_extend(struct _posix_spawn_file_actions *actions)
57 {
58 	int newsize = actions->size + 4;
59 	void *newactions = realloc(actions->actions,
60 		newsize * sizeof(struct _file_action));
61 	if (newactions == NULL)
62 		return ENOMEM;
63 	actions->actions = (struct _file_action*)newactions;
64 	actions->size = newsize;
65 	return 0;
66 }
67 
68 
69 int
70 posix_spawn_file_actions_init(posix_spawn_file_actions_t *_file_actions)
71 {
72 	posix_spawn_file_actions_t actions = (posix_spawn_file_actions_t)malloc(
73 		sizeof(struct _posix_spawn_file_actions));
74 
75 	if (actions == NULL)
76 		return ENOMEM;
77 
78 	memset(actions, 0, sizeof(*actions));
79 	*_file_actions = actions;
80 
81 	return 0;
82 }
83 
84 
85 int
86 posix_spawn_file_actions_destroy(posix_spawn_file_actions_t *_actions)
87 {
88 	struct _posix_spawn_file_actions* actions = _actions != NULL ? *_actions : NULL;
89 
90 	if (actions == NULL)
91 		return EINVAL;
92 
93 	free(actions);
94 
95 	return 0;
96 }
97 
98 
99 int
100 posix_spawn_file_actions_addopen(posix_spawn_file_actions_t *_actions,
101 	int fildes, const char *path, int oflag, mode_t mode)
102 {
103 	struct _posix_spawn_file_actions* actions = _actions != NULL ? *_actions : NULL;
104 
105 	if (actions == NULL)
106 		return EINVAL;
107 
108 	if (fildes < 0 || fildes >= sysconf(_SC_OPEN_MAX))
109 		return EBADF;
110 
111 	char* npath = strdup(path);
112 	if (npath == NULL)
113 		return ENOMEM;
114 	if (actions->count == actions->size
115 		&& posix_spawn_file_actions_extend(actions) != 0) {
116 		free(npath);
117 		return ENOMEM;
118 	}
119 
120 	struct _file_action *action = &actions->actions[actions->count];
121 	action->type = file_action_open;
122 	action->fd = fildes;
123 	action->action.open_action.path = npath;
124 	action->action.open_action.oflag = oflag;
125 	action->action.open_action.mode = mode;
126 	actions->count++;
127 	return 0;
128 }
129 
130 
131 int
132 posix_spawn_file_actions_addclose(posix_spawn_file_actions_t *_actions,
133 	int fildes)
134 {
135 	struct _posix_spawn_file_actions* actions = _actions != NULL ? *_actions : NULL;
136 
137 	if (actions == NULL)
138 		return EINVAL;
139 
140 	if (fildes < 0 || fildes >= sysconf(_SC_OPEN_MAX))
141 		return EBADF;
142 
143 	if (actions->count == actions->size
144 		&& posix_spawn_file_actions_extend(actions) != 0) {
145 		return ENOMEM;
146 	}
147 
148 	struct _file_action *action = &actions->actions[actions->count];
149 	action->type = file_action_close;
150 	action->fd = fildes;
151 	actions->count++;
152 	return 0;
153 }
154 
155 
156 int
157 posix_spawn_file_actions_adddup2(posix_spawn_file_actions_t *_actions,
158 	int fildes, int newfildes)
159 {
160 	struct _posix_spawn_file_actions* actions = _actions != NULL ? *_actions : NULL;
161 
162 	if (actions == NULL)
163 		return EINVAL;
164 
165 	if (fildes < 0 || fildes >= sysconf(_SC_OPEN_MAX))
166 		return EBADF;
167 
168 	if (actions->count == actions->size
169 		&& posix_spawn_file_actions_extend(actions) != 0) {
170 		return ENOMEM;
171 	}
172 
173 	struct _file_action *action = &actions->actions[actions->count];
174 	action->type = file_action_dup2;
175 	action->fd = newfildes;
176 	action->action.dup2_action.srcfd = fildes;
177 	actions->count++;
178 	return 0;
179 }
180 
181 
182 int
183 posix_spawnattr_init(posix_spawnattr_t *_attr)
184 {
185 	posix_spawnattr_t attr = (posix_spawnattr_t)malloc(
186 		sizeof(struct _posix_spawnattr));
187 
188 	if (attr == NULL)
189 		return ENOMEM;
190 
191 	memset(attr, 0, sizeof(*attr));
192 	*_attr = attr;
193 
194 	return 0;
195 }
196 
197 
198 int
199 posix_spawnattr_destroy(posix_spawnattr_t *_attr)
200 {
201 	struct _posix_spawnattr* attr = _attr != NULL ? *_attr : NULL;
202 
203 	if (attr == NULL)
204 		return EINVAL;
205 
206 	free(attr);
207 
208 	return 0;
209 }
210 
211 
212 int
213 posix_spawnattr_getflags(const posix_spawnattr_t *_attr, short *flags)
214 {
215 	struct _posix_spawnattr *attr;
216 
217 	if (_attr == NULL || (attr = *_attr) == NULL || flags == NULL)
218 		return EINVAL;
219 
220 	*flags = attr->flags;
221 
222 	return 0;
223 }
224 
225 
226 int
227 posix_spawnattr_setflags(posix_spawnattr_t *_attr, short flags)
228 {
229 	struct _posix_spawnattr *attr;
230 
231 	if (_attr == NULL || (attr = *_attr) == NULL)
232 		return EINVAL;
233 
234 	if ((flags & ~(POSIX_SPAWN_RESETIDS | POSIX_SPAWN_SETPGROUP
235 			| POSIX_SPAWN_SETSIGDEF | POSIX_SPAWN_SETSIGMASK)) != 0) {
236 		return EINVAL;
237 	}
238 
239 	attr->flags = flags;
240 
241 	return 0;
242 }
243 
244 
245 int
246 posix_spawnattr_getpgroup(const posix_spawnattr_t *_attr, pid_t *pgroup)
247 {
248 	struct _posix_spawnattr *attr;
249 
250 	if (_attr == NULL || (attr = *_attr) == NULL || pgroup == NULL)
251 		return EINVAL;
252 
253 	*pgroup = attr->pgroup;
254 
255 	return 0;
256 }
257 
258 
259 int
260 posix_spawnattr_setpgroup(posix_spawnattr_t *_attr, pid_t pgroup)
261 {
262 	struct _posix_spawnattr *attr;
263 
264 	if (_attr == NULL || (attr = *_attr) == NULL)
265 		return EINVAL;
266 
267 	attr->pgroup = pgroup;
268 
269 	return 0;
270 }
271 
272 
273 int
274 posix_spawnattr_getsigdefault(const posix_spawnattr_t *_attr, sigset_t *sigdefault)
275 {
276 	struct _posix_spawnattr *attr;
277 
278 	if (_attr == NULL || (attr = *_attr) == NULL || sigdefault == NULL)
279 		return EINVAL;
280 
281 	memcpy(sigdefault, &attr->sigdefault, sizeof(sigset_t));
282 
283 	return 0;
284 }
285 
286 
287 int
288 posix_spawnattr_setsigdefault(posix_spawnattr_t *_attr,
289 	const sigset_t *sigdefault)
290 {
291 	struct _posix_spawnattr *attr;
292 
293 	if (_attr == NULL || (attr = *_attr) == NULL || sigdefault == NULL)
294 		return EINVAL;
295 
296 	memcpy(&attr->sigdefault, sigdefault, sizeof(sigset_t));
297 
298 	return 0;
299 }
300 
301 
302 int
303 posix_spawnattr_getsigmask(const posix_spawnattr_t *_attr, sigset_t *sigmask)
304 {
305 	struct _posix_spawnattr *attr;
306 
307 	if (_attr == NULL || (attr = *_attr) == NULL || sigmask == NULL)
308 		return EINVAL;
309 
310 	memcpy(sigmask, &attr->sigmask, sizeof(sigset_t));
311 
312 	return 0;
313 }
314 
315 
316 int
317 posix_spawnattr_setsigmask(posix_spawnattr_t *_attr, const sigset_t *sigmask)
318 {
319 	struct _posix_spawnattr *attr;
320 
321 	if (_attr == NULL || (attr = *_attr) == NULL || sigmask == NULL)
322 		return EINVAL;
323 
324 	memcpy(&attr->sigmask, sigmask, sizeof(sigset_t));
325 
326 	return 0;
327 }
328 
329 
330 static int
331 process_spawnattr(const posix_spawnattr_t *_attr)
332 {
333 	if (_attr == NULL)
334 		return 0;
335 
336 	struct _posix_spawnattr *attr = *_attr;
337 	if (attr == NULL)
338 		return EINVAL;
339 
340 	if ((attr->flags & POSIX_SPAWN_SETSIGMASK) != 0)
341 		sigprocmask(SIG_SETMASK, &attr->sigmask, NULL);
342 
343 	if ((attr->flags & POSIX_SPAWN_SETSIGDEF) != 0) {
344 		struct sigaction action;
345 		action.sa_handler = SIG_DFL;
346 		action.sa_flags = 0;
347 		action.sa_userdata = NULL;
348 		sigemptyset(&action.sa_mask);
349 		for (int i = 1; i <= MAX_SIGNAL_NUMBER; i++) {
350 			if (sigismember(&attr->sigdefault, i) == 1
351 				&& sigaction(i, &action, NULL) != 0) {
352 				return errno;
353 			}
354 		}
355 	}
356 
357 	if ((attr->flags & POSIX_SPAWN_RESETIDS) != 0) {
358 		if (setegid(getgid()) != 0)
359 			return errno;
360 		if (seteuid(getuid()) != 0)
361 			return errno;
362 	}
363 
364 	if ((attr->flags & POSIX_SPAWN_SETPGROUP) != 0) {
365 		if (setpgid(0, attr->pgroup) != 0)
366 			return errno;
367 	}
368 
369 	return 0;
370 }
371 
372 
373 static int
374 process_file_actions(const posix_spawn_file_actions_t *_actions, int *errfd)
375 {
376 	if (_actions == NULL)
377 		return 0;
378 
379 	struct _posix_spawn_file_actions* actions = *_actions;
380 	if (actions == NULL)
381 		return EINVAL;
382 
383 	for (int i = 0; i < actions->count; i++) {
384 		struct _file_action *action = &actions->actions[i];
385 
386 		if (action->fd == *errfd) {
387 			int newfd = dup(action->fd);
388 			if (newfd == -1)
389 				return errno;
390 			close(action->fd);
391 			fcntl(newfd, F_SETFD, FD_CLOEXEC);
392 			*errfd = newfd;
393 		}
394 
395 		if (action->type == file_action_close) {
396 			if (close(action->fd) != 0)
397 				return errno;
398 		} else if (action->type == file_action_open) {
399 			int fd = open(action->action.open_action.path,
400 				action->action.open_action.oflag,
401 				action->action.open_action.mode);
402 			if (fd == -1)
403 				return errno;
404 			if (fd != action->fd) {
405 				if (dup2(action->fd, fd) != 0)
406 					return errno;
407 				if (close(fd) != 0)
408 					return errno;
409 			}
410 		} else if (action->type == file_action_dup2) {
411 			if (dup2(action->action.dup2_action.srcfd, action->fd) != 0)
412 				return errno;
413 		}
414 	}
415 
416 	return 0;
417 }
418 
419 
420 static int
421 do_posix_spawn(pid_t *_pid, const char *path,
422 	const posix_spawn_file_actions_t *actions,
423 	const posix_spawnattr_t *attrp, char *const argv[], char *const envp[],
424 	bool envpath)
425 {
426 	int err = 0;
427 	int fds[2];
428 	pid_t pid;
429 
430 	if (pipe(fds) != 0)
431 		return errno;
432 	if (fcntl(fds[0], F_SETFD, FD_CLOEXEC) != 0
433 		|| fcntl(fds[1], F_SETFD, FD_CLOEXEC) != 0) {
434 		goto fail;
435 	}
436 	pid = vfork();
437 	if (pid == -1)
438 		goto fail;
439 
440 	if (pid != 0) {
441 		// parent
442 		if (_pid != NULL)
443 			*_pid = pid;
444 		close(fds[1]);
445 		read(fds[0], &err, sizeof(err));
446 		if (err != 0)
447 			waitpid(pid, NULL, WNOHANG);
448 		close(fds[0]);
449 		return err;
450 	}
451 
452 	// child
453 	close(fds[0]);
454 
455 	err = process_spawnattr(attrp);
456 	if (err == 0)
457 		err = process_file_actions(actions, &fds[1]);
458 	if (err != 0)
459 		goto fail_child;
460 
461 	if (envpath)
462 		execvpe(path, argv, envp != NULL ? envp : environ);
463 	else
464 		execve(path, argv, envp != NULL ? envp : environ);
465 
466 	err = errno;
467 
468 fail_child:
469 	write(fds[1], &err, sizeof(err));
470 	close(fds[1]);
471 	_exit(127);
472 
473 fail:
474 	err = errno;
475 	close(fds[0]);
476 	close(fds[1]);
477 	return err;
478 }
479 
480 
481 int
482 posix_spawn(pid_t *pid, const char *path,
483 	const posix_spawn_file_actions_t *file_actions,
484 	const posix_spawnattr_t *attrp, char *const argv[], char *const envp[])
485 {
486 	return do_posix_spawn(pid, path, file_actions, attrp, argv, envp, false);
487 }
488 
489 
490 int
491 posix_spawnp(pid_t *pid, const char *file,
492 	const posix_spawn_file_actions_t *file_actions,
493 	const posix_spawnattr_t *attrp, char *const argv[],
494 	char *const envp[])
495 {
496 	return do_posix_spawn(pid, file, file_actions, attrp, argv, envp, true);
497 }
498 
499