Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	lib/libc/gen/posix_spawn.c	Lines:	0	145	0.0 %
Date:	2017-11-07	Branches:	0	89	0.0 %


/*	$OpenBSD: posix_spawn.c,v 1.9 2016/03/13 18:34:20 guenther Exp $	*/
/*-
 * Copyright (c) 2008 Ed Schouten <ed@FreeBSD.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/queue.h>

#include <errno.h>
#include <fcntl.h>
#include <sched.h>
#include <spawn.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

struct __posix_spawnattr {
	short			sa_flags;
	pid_t			sa_pgroup;
	struct sched_param	sa_schedparam;
	int			sa_schedpolicy;
	sigset_t		sa_sigdefault;
	sigset_t		sa_sigmask;
};

struct __posix_spawn_file_actions {
	SIMPLEQ_HEAD(, __posix_spawn_file_actions_entry) fa_list;
};

typedef struct __posix_spawn_file_actions_entry {
	SIMPLEQ_ENTRY(__posix_spawn_file_actions_entry) fae_list;
	enum { FAE_OPEN, FAE_DUP2, FAE_CLOSE } fae_action;

	int fae_fildes;
	union {
		struct {
			char *path;
#define fae_path	fae_data.open.path
			int oflag;
#define fae_oflag	fae_data.open.oflag
			mode_t mode;
#define fae_mode	fae_data.open.mode
		} open;
		struct {
			int newfildes;
#define fae_newfildes	fae_data.dup2.newfildes
		} dup2;
	} fae_data;
} posix_spawn_file_actions_entry_t;

/*
 * Spawn routines
 */

static int
process_spawnattr(const posix_spawnattr_t sa)
{
	struct sigaction sigact;
	int i;

	memset(&sigact, 0, sizeof(sigact));
	sigact.sa_handler = SIG_DFL;

	/*
	 * POSIX doesn't really describe in which order everything
	 * should be set. We'll just set them in the order in which they
	 * are mentioned.
	 */

	/* Set process group */
	if (sa->sa_flags & POSIX_SPAWN_SETPGROUP) {
		if (setpgid(0, sa->sa_pgroup) != 0)
			return (errno);
	}

#if 0 /* NOT IMPLEMENTED */
	/* Set scheduler policy */
	if (sa->sa_flags & POSIX_SPAWN_SETSCHEDULER) {
		if (sched_setscheduler(0, sa->sa_schedpolicy,
		    &sa->sa_schedparam) != 0)
			return (errno);
	} else if (sa->sa_flags & POSIX_SPAWN_SETSCHEDPARAM) {
		if (sched_setparam(0, &sa->sa_schedparam) != 0)
			return (errno);
	}
#endif

	/* Reset user ID's */
	if (sa->sa_flags & POSIX_SPAWN_RESETIDS) {
		if (setegid(getgid()) != 0)
			return (errno);
		if (seteuid(getuid()) != 0)
			return (errno);
	}

	/* Set signal masks/defaults */
	if (sa->sa_flags & POSIX_SPAWN_SETSIGMASK) {
		WRAP(sigprocmask)(SIG_SETMASK, &sa->sa_sigmask, NULL);
	}

	if (sa->sa_flags & POSIX_SPAWN_SETSIGDEF) {
		for (i = 1; i < _NSIG; i++) {
			/* silently ignore attempts to alter SIGTHR */
			if (sigismember(&sa->sa_sigdefault, i) && i != SIGTHR)
				if (sigaction(i, &sigact, NULL) != 0)
					return (errno);
		}
	}

	return (0);
}

static int
process_file_actions_entry(posix_spawn_file_actions_entry_t *fae)
{
	int fd;

	switch (fae->fae_action) {
	case FAE_OPEN:
		/* Perform an open(), make it use the right fd */
		fd = open(fae->fae_path, fae->fae_oflag, fae->fae_mode);
		if (fd < 0)
			return (errno);
		if (fd != fae->fae_fildes) {
			if (dup2(fd, fae->fae_fildes) == -1)
				return (errno);
			if (close(fd) != 0) {
				if (errno == EBADF)
					return (EBADF);
			}
		}
		break;
	case FAE_DUP2:
		/*
		 * Perform a dup2(), making sure the FD_CLOEXEC flag is clear
		 */
		fd = fae->fae_fildes;
		if (fd == fae->fae_newfildes) {
			int flags = fcntl(fd, F_GETFD);

			if (flags == -1 ||
			    ((flags & FD_CLOEXEC) &&
			    fcntl(fd, F_SETFD, flags & ~FD_CLOEXEC) == -1))
				return (errno);
		} else if (dup2(fd, fae->fae_newfildes) == -1)
			return (errno);
		break;
	case FAE_CLOSE:
		/* Perform a close(), do not fail if already closed */
		(void)close(fae->fae_fildes);
		break;
	}
	return (0);
}

static int
process_file_actions(const posix_spawn_file_actions_t fa)
{
	posix_spawn_file_actions_entry_t *fae;
	int error;

	/* Replay all file descriptor modifications */
	SIMPLEQ_FOREACH(fae, &fa->fa_list, fae_list) {
		error = process_file_actions_entry(fae);
		if (error)
			return (error);
	}
	return (0);
}

static int
do_posix_spawn(pid_t *pid, const char *path,
    const posix_spawn_file_actions_t *fa,
    const posix_spawnattr_t *sa,
    char *const argv[], char *const envp[], int use_env_path)
{
	pid_t p;

	p = fork();
	switch (p) {
	case -1:
		return (errno);
	case 0: {
		int error;
		if (sa != NULL) {
			error = process_spawnattr(*sa);
			if (error)
				_exit(127);
		}
		if (fa != NULL) {
			error = process_file_actions(*fa);
			if (error)
				_exit(127);
		}
		if (use_env_path)
			execvpe(path, argv, envp != NULL ? envp : environ);
		else
			execve(path, argv, envp != NULL ? envp : environ);
		_exit(127);
	}
	default:
		if (pid != NULL)
			*pid = p;
		return (0);
	}
}

int
posix_spawn(pid_t *pid, const char *path,
    const posix_spawn_file_actions_t *fa,
    const posix_spawnattr_t *sa,
    char *const argv[], char *const envp[])
{
	return do_posix_spawn(pid, path, fa, sa, argv, envp, 0);
}

int
posix_spawnp(pid_t *pid, const char *path,
    const posix_spawn_file_actions_t *fa,
    const posix_spawnattr_t *sa,
    char *const argv[], char *const envp[])
{
	return do_posix_spawn(pid, path, fa, sa, argv, envp, 1);
}

/*
 * File descriptor actions
 */

int
posix_spawn_file_actions_init(posix_spawn_file_actions_t *ret)
{
	posix_spawn_file_actions_t fa;

	fa = malloc(sizeof(struct __posix_spawn_file_actions));
	if (fa == NULL)
		return (errno);

	SIMPLEQ_INIT(&fa->fa_list);
	*ret = fa;
	return (0);
}

int
posix_spawn_file_actions_destroy(posix_spawn_file_actions_t *fa)
{
	posix_spawn_file_actions_entry_t *fae;

	while ((fae = SIMPLEQ_FIRST(&(*fa)->fa_list)) != NULL) {
		/* Remove file action entry from the queue */
		SIMPLEQ_REMOVE_HEAD(&(*fa)->fa_list, fae_list);

		/* Deallocate file action entry */
		if (fae->fae_action == FAE_OPEN)
			free(fae->fae_path);
		free(fae);
	}

	free(*fa);
	return (0);
}

int
posix_spawn_file_actions_addopen(posix_spawn_file_actions_t *__restrict fa,
    int fildes, const char *__restrict path, int oflag, mode_t mode)
{
	posix_spawn_file_actions_entry_t *fae;
	int error;

	if (fildes < 0)
		return (EBADF);

	/* Allocate object */
	fae = malloc(sizeof(posix_spawn_file_actions_entry_t));
	if (fae == NULL)
		return (errno);

	/* Set values and store in queue */
	fae->fae_action = FAE_OPEN;
	fae->fae_path = strdup(path);
	if (fae->fae_path == NULL) {
		error = errno;
		free(fae);
		return (error);
	}
	fae->fae_fildes = fildes;
	fae->fae_oflag = oflag;
	fae->fae_mode = mode;

	SIMPLEQ_INSERT_TAIL(&(*fa)->fa_list, fae, fae_list);
	return (0);
}

int
posix_spawn_file_actions_adddup2(posix_spawn_file_actions_t *fa,
    int fildes, int newfildes)
{
	posix_spawn_file_actions_entry_t *fae;

	if (fildes < 0 || newfildes < 0)
		return (EBADF);

	/* Allocate object */
	fae = malloc(sizeof(posix_spawn_file_actions_entry_t));
	if (fae == NULL)
		return (errno);

	/* Set values and store in queue */
	fae->fae_action = FAE_DUP2;
	fae->fae_fildes = fildes;
	fae->fae_newfildes = newfildes;

	SIMPLEQ_INSERT_TAIL(&(*fa)->fa_list, fae, fae_list);
	return (0);
}

int
posix_spawn_file_actions_addclose(posix_spawn_file_actions_t *fa,
    int fildes)
{
	posix_spawn_file_actions_entry_t *fae;

	if (fildes < 0)
		return (EBADF);

	/* Allocate object */
	fae = malloc(sizeof(posix_spawn_file_actions_entry_t));
	if (fae == NULL)
		return (errno);

	/* Set values and store in queue */
	fae->fae_action = FAE_CLOSE;
	fae->fae_fildes = fildes;

	SIMPLEQ_INSERT_TAIL(&(*fa)->fa_list, fae, fae_list);
	return (0);
}

/*
 * Spawn attributes
 */

int
posix_spawnattr_init(posix_spawnattr_t *ret)
{
	posix_spawnattr_t sa;

	sa = calloc(1, sizeof(struct __posix_spawnattr));
	if (sa == NULL)
		return (errno);

	/* Set defaults as specified by POSIX, cleared above */
	*ret = sa;
	return (0);
}

int
posix_spawnattr_destroy(posix_spawnattr_t *sa)
{
	free(*sa);
	return (0);
}

int
posix_spawnattr_getflags(const posix_spawnattr_t *__restrict sa,
    short *__restrict flags)
{
	*flags = (*sa)->sa_flags;
	return (0);
}

int
posix_spawnattr_getpgroup(const posix_spawnattr_t *__restrict sa,
    pid_t *__restrict pgroup)
{
	*pgroup = (*sa)->sa_pgroup;
	return (0);
}

int
posix_spawnattr_getschedparam(const posix_spawnattr_t *__restrict sa,
    struct sched_param *__restrict schedparam)
{
	*schedparam = (*sa)->sa_schedparam;
	return (0);
}

int
posix_spawnattr_getschedpolicy(const posix_spawnattr_t *__restrict sa,
    int *__restrict schedpolicy)
{
	*schedpolicy = (*sa)->sa_schedpolicy;
	return (0);
}

int
posix_spawnattr_getsigdefault(const posix_spawnattr_t *__restrict sa,
    sigset_t *__restrict sigdefault)
{
	*sigdefault = (*sa)->sa_sigdefault;
	return (0);
}

int
posix_spawnattr_getsigmask(const posix_spawnattr_t *__restrict sa,
    sigset_t *__restrict sigmask)
{
	*sigmask = (*sa)->sa_sigmask;
	return (0);
}

int
posix_spawnattr_setflags(posix_spawnattr_t *sa, short flags)
{
	(*sa)->sa_flags = flags;
	return (0);
}

int
posix_spawnattr_setpgroup(posix_spawnattr_t *sa, pid_t pgroup)
{
	(*sa)->sa_pgroup = pgroup;
	return (0);
}

int
posix_spawnattr_setschedparam(posix_spawnattr_t *__restrict sa,
    const struct sched_param *__restrict schedparam)
{
	(*sa)->sa_schedparam = *schedparam;
	return (0);
}

int
posix_spawnattr_setschedpolicy(posix_spawnattr_t *sa, int schedpolicy)
{
	(*sa)->sa_schedpolicy = schedpolicy;
	return (0);
}

int
posix_spawnattr_setsigdefault(posix_spawnattr_t *__restrict sa,
    const sigset_t *__restrict sigdefault)
{
	(*sa)->sa_sigdefault = *sigdefault;
	return (0);
}

int
posix_spawnattr_setsigmask(posix_spawnattr_t *__restrict sa,
    const sigset_t *__restrict sigmask)
{
	(*sa)->sa_sigmask = *sigmask;
	return (0);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: posix_spawn.c,v 1.9 2016/03/13 18:34:20 guenther Exp $ */
2			/*-
3			* Copyright (c) 2008 Ed Schouten <ed@FreeBSD.org>
4			* All rights reserved.
5			*
6			* Redistribution and use in source and binary forms, with or without
7			* modification, are permitted provided that the following conditions
8			* are met:
9			* 1. Redistributions of source code must retain the above copyright
10			* notice, this list of conditions and the following disclaimer.
11			* 2. Redistributions in binary form must reproduce the above copyright
12			* notice, this list of conditions and the following disclaimer in the
13			* documentation and/or other materials provided with the distribution.
14			*
15			* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18			* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25			* SUCH DAMAGE.
26			*/
27
28			#include <sys/queue.h>
29
30			#include <errno.h>
31			#include <fcntl.h>
32			#include <sched.h>
33			#include <spawn.h>
34			#include <signal.h>
35			#include <stdlib.h>
36			#include <string.h>
37			#include <unistd.h>
38
39			struct __posix_spawnattr {
40			short sa_flags;
41			pid_t sa_pgroup;
42			struct sched_param sa_schedparam;
43			int sa_schedpolicy;
44			sigset_t sa_sigdefault;
45			sigset_t sa_sigmask;
46			};
47
48			struct __posix_spawn_file_actions {
49			SIMPLEQ_HEAD(, __posix_spawn_file_actions_entry) fa_list;
50			};
51
52			typedef struct __posix_spawn_file_actions_entry {
53			SIMPLEQ_ENTRY(__posix_spawn_file_actions_entry) fae_list;
54			enum { FAE_OPEN, FAE_DUP2, FAE_CLOSE } fae_action;
55
56			int fae_fildes;
57			union {
58			struct {
59			char *path;
60			#define fae_path fae_data.open.path
61			int oflag;
62			#define fae_oflag fae_data.open.oflag
63			mode_t mode;
64			#define fae_mode fae_data.open.mode
65			} open;
66			struct {
67			int newfildes;
68			#define fae_newfildes fae_data.dup2.newfildes
69			} dup2;
70			} fae_data;
71			} posix_spawn_file_actions_entry_t;
72
73			/*
74			* Spawn routines
75			*/
76
77			static int
78			process_spawnattr(const posix_spawnattr_t sa)
79			{
80			struct sigaction sigact;
81			int i;
82
83			memset(&sigact, 0, sizeof(sigact));
84			sigact.sa_handler = SIG_DFL;
85
86			/*
87			* POSIX doesn't really describe in which order everything
88			* should be set. We'll just set them in the order in which they
89			* are mentioned.
90			*/
91
92			/* Set process group */
93			if (sa->sa_flags & POSIX_SPAWN_SETPGROUP) {
94			if (setpgid(0, sa->sa_pgroup) != 0)
95			return (errno);
96			}
97
98			#if 0 /* NOT IMPLEMENTED */
99			/* Set scheduler policy */
100			if (sa->sa_flags & POSIX_SPAWN_SETSCHEDULER) {
101			if (sched_setscheduler(0, sa->sa_schedpolicy,
102			&sa->sa_schedparam) != 0)
103			return (errno);
104			} else if (sa->sa_flags & POSIX_SPAWN_SETSCHEDPARAM) {
105			if (sched_setparam(0, &sa->sa_schedparam) != 0)
106			return (errno);
107			}
108			#endif
109
110			/* Reset user ID's */
111			if (sa->sa_flags & POSIX_SPAWN_RESETIDS) {
112			if (setegid(getgid()) != 0)
113			return (errno);
114			if (seteuid(getuid()) != 0)
115			return (errno);
116			}
117
118			/* Set signal masks/defaults */
119			if (sa->sa_flags & POSIX_SPAWN_SETSIGMASK) {
120			WRAP(sigprocmask)(SIG_SETMASK, &sa->sa_sigmask, NULL);
121			}
122
123			if (sa->sa_flags & POSIX_SPAWN_SETSIGDEF) {
124			for (i = 1; i < _NSIG; i++) {
125			/* silently ignore attempts to alter SIGTHR */
126			if (sigismember(&sa->sa_sigdefault, i) && i != SIGTHR)
127			if (sigaction(i, &sigact, NULL) != 0)
128			return (errno);
129			}
130			}
131
132			return (0);
133			}
134
135			static int
136			process_file_actions_entry(posix_spawn_file_actions_entry_t *fae)
137			{
138			int fd;
139
140			switch (fae->fae_action) {
141			case FAE_OPEN:
142			/* Perform an open(), make it use the right fd */
143			fd = open(fae->fae_path, fae->fae_oflag, fae->fae_mode);
144			if (fd < 0)
145			return (errno);
146			if (fd != fae->fae_fildes) {
147			if (dup2(fd, fae->fae_fildes) == -1)
148			return (errno);
149			if (close(fd) != 0) {
150			if (errno == EBADF)
151			return (EBADF);
152			}
153			}
154			break;
155			case FAE_DUP2:
156			/*
157			* Perform a dup2(), making sure the FD_CLOEXEC flag is clear
158			*/
159			fd = fae->fae_fildes;
160			if (fd == fae->fae_newfildes) {
161			int flags = fcntl(fd, F_GETFD);
162
163			if (flags == -1 \|\|
164			((flags & FD_CLOEXEC) &&
165			fcntl(fd, F_SETFD, flags & ~FD_CLOEXEC) == -1))
166			return (errno);
167			} else if (dup2(fd, fae->fae_newfildes) == -1)
168			return (errno);
169			break;
170			case FAE_CLOSE:
171			/* Perform a close(), do not fail if already closed */
172			(void)close(fae->fae_fildes);
173			break;
174			}
175			return (0);
176			}
177
178			static int
179			process_file_actions(const posix_spawn_file_actions_t fa)
180			{
181			posix_spawn_file_actions_entry_t *fae;
182			int error;
183
184			/* Replay all file descriptor modifications */
185			SIMPLEQ_FOREACH(fae, &fa->fa_list, fae_list) {
186			error = process_file_actions_entry(fae);
187			if (error)
188			return (error);
189			}
190			return (0);
191			}
192
193			static int
194			do_posix_spawn(pid_t pid, const char path,
195			const posix_spawn_file_actions_t *fa,
196			const posix_spawnattr_t *sa,
197			char const argv[], char const envp[], int use_env_path)
198			{
199			pid_t p;
200
201			p = fork();
202			switch (p) {
203			case -1:
204			return (errno);
205			case 0: {
206			int error;
207			if (sa != NULL) {
208			error = process_spawnattr(*sa);
209			if (error)
210			_exit(127);
211			}
212			if (fa != NULL) {
213			error = process_file_actions(*fa);
214			if (error)
215			_exit(127);
216			}
217			if (use_env_path)
218			execvpe(path, argv, envp != NULL ? envp : environ);
219			else
220			execve(path, argv, envp != NULL ? envp : environ);
221			_exit(127);
222			}
223			default:
224			if (pid != NULL)
225			*pid = p;
226			return (0);
227			}
228			}
229
230			int
231			posix_spawn(pid_t pid, const char path,
232			const posix_spawn_file_actions_t *fa,
233			const posix_spawnattr_t *sa,
234			char const argv[], char const envp[])
235			{
236			return do_posix_spawn(pid, path, fa, sa, argv, envp, 0);
237			}
238
239			int
240			posix_spawnp(pid_t pid, const char path,
241			const posix_spawn_file_actions_t *fa,
242			const posix_spawnattr_t *sa,
243			char const argv[], char const envp[])
244			{
245			return do_posix_spawn(pid, path, fa, sa, argv, envp, 1);
246			}
247
248			/*
249			* File descriptor actions
250			*/
251
252			int
253			posix_spawn_file_actions_init(posix_spawn_file_actions_t *ret)
254			{
255			posix_spawn_file_actions_t fa;
256
257			fa = malloc(sizeof(struct __posix_spawn_file_actions));
258			if (fa == NULL)
259			return (errno);
260
261			SIMPLEQ_INIT(&fa->fa_list);
262			*ret = fa;
263			return (0);
264			}
265
266			int
267			posix_spawn_file_actions_destroy(posix_spawn_file_actions_t *fa)
268			{
269			posix_spawn_file_actions_entry_t *fae;
270
271			while ((fae = SIMPLEQ_FIRST(&(*fa)->fa_list)) != NULL) {
272			/* Remove file action entry from the queue */
273			SIMPLEQ_REMOVE_HEAD(&(*fa)->fa_list, fae_list);
274
275			/* Deallocate file action entry */
276			if (fae->fae_action == FAE_OPEN)
277			free(fae->fae_path);
278			free(fae);
279			}
280
281			free(*fa);
282			return (0);
283			}
284
285			int
286			posix_spawn_file_actions_addopen(posix_spawn_file_actions_t *__restrict fa,
287			int fildes, const char *__restrict path, int oflag, mode_t mode)
288			{
289			posix_spawn_file_actions_entry_t *fae;
290			int error;
291
292			if (fildes < 0)
293			return (EBADF);
294
295			/* Allocate object */
296			fae = malloc(sizeof(posix_spawn_file_actions_entry_t));
297			if (fae == NULL)
298			return (errno);
299
300			/* Set values and store in queue */
301			fae->fae_action = FAE_OPEN;
302			fae->fae_path = strdup(path);
303			if (fae->fae_path == NULL) {
304			error = errno;
305			free(fae);
306			return (error);
307			}
308			fae->fae_fildes = fildes;
309			fae->fae_oflag = oflag;
310			fae->fae_mode = mode;
311
312			SIMPLEQ_INSERT_TAIL(&(*fa)->fa_list, fae, fae_list);
313			return (0);
314			}
315
316			int
317			posix_spawn_file_actions_adddup2(posix_spawn_file_actions_t *fa,
318			int fildes, int newfildes)
319			{
320			posix_spawn_file_actions_entry_t *fae;
321
322			if (fildes < 0 \|\| newfildes < 0)
323			return (EBADF);
324
325			/* Allocate object */
326			fae = malloc(sizeof(posix_spawn_file_actions_entry_t));
327			if (fae == NULL)
328			return (errno);
329
330			/* Set values and store in queue */
331			fae->fae_action = FAE_DUP2;
332			fae->fae_fildes = fildes;
333			fae->fae_newfildes = newfildes;
334
335			SIMPLEQ_INSERT_TAIL(&(*fa)->fa_list, fae, fae_list);
336			return (0);
337			}
338
339			int
340			posix_spawn_file_actions_addclose(posix_spawn_file_actions_t *fa,
341			int fildes)
342			{
343			posix_spawn_file_actions_entry_t *fae;
344
345			if (fildes < 0)
346			return (EBADF);
347
348			/* Allocate object */
349			fae = malloc(sizeof(posix_spawn_file_actions_entry_t));
350			if (fae == NULL)
351			return (errno);
352
353			/* Set values and store in queue */
354			fae->fae_action = FAE_CLOSE;
355			fae->fae_fildes = fildes;
356
357			SIMPLEQ_INSERT_TAIL(&(*fa)->fa_list, fae, fae_list);
358			return (0);
359			}
360
361			/*
362			* Spawn attributes
363			*/
364
365			int
366			posix_spawnattr_init(posix_spawnattr_t *ret)
367			{
368			posix_spawnattr_t sa;
369
370			sa = calloc(1, sizeof(struct __posix_spawnattr));
371			if (sa == NULL)
372			return (errno);
373
374			/* Set defaults as specified by POSIX, cleared above */
375			*ret = sa;
376			return (0);
377			}
378
379			int
380			posix_spawnattr_destroy(posix_spawnattr_t *sa)
381			{
382			free(*sa);
383			return (0);
384			}
385
386			int
387			posix_spawnattr_getflags(const posix_spawnattr_t *__restrict sa,
388			short *__restrict flags)
389			{
390			flags = (sa)->sa_flags;
391			return (0);
392			}
393
394			int
395			posix_spawnattr_getpgroup(const posix_spawnattr_t *__restrict sa,
396			pid_t *__restrict pgroup)
397			{
398			pgroup = (sa)->sa_pgroup;
399			return (0);
400			}
401
402			int
403			posix_spawnattr_getschedparam(const posix_spawnattr_t *__restrict sa,
404			struct sched_param *__restrict schedparam)
405			{
406			schedparam = (sa)->sa_schedparam;
407			return (0);
408			}
409
410			int
411			posix_spawnattr_getschedpolicy(const posix_spawnattr_t *__restrict sa,
412			int *__restrict schedpolicy)
413			{
414			schedpolicy = (sa)->sa_schedpolicy;
415			return (0);
416			}
417
418			int
419			posix_spawnattr_getsigdefault(const posix_spawnattr_t *__restrict sa,
420			sigset_t *__restrict sigdefault)
421			{
422			sigdefault = (sa)->sa_sigdefault;
423			return (0);
424			}
425
426			int
427			posix_spawnattr_getsigmask(const posix_spawnattr_t *__restrict sa,
428			sigset_t *__restrict sigmask)
429			{
430			sigmask = (sa)->sa_sigmask;
431			return (0);
432			}
433
434			int
435			posix_spawnattr_setflags(posix_spawnattr_t *sa, short flags)
436			{
437			(*sa)->sa_flags = flags;
438			return (0);
439			}
440
441			int
442			posix_spawnattr_setpgroup(posix_spawnattr_t *sa, pid_t pgroup)
443			{
444			(*sa)->sa_pgroup = pgroup;
445			return (0);
446			}
447
448			int
449			posix_spawnattr_setschedparam(posix_spawnattr_t *__restrict sa,
450			const struct sched_param *__restrict schedparam)
451			{
452			(sa)->sa_schedparam = schedparam;
453			return (0);
454			}
455
456			int
457			posix_spawnattr_setschedpolicy(posix_spawnattr_t *sa, int schedpolicy)
458			{
459			(*sa)->sa_schedpolicy = schedpolicy;
460			return (0);
461			}
462
463			int
464			posix_spawnattr_setsigdefault(posix_spawnattr_t *__restrict sa,
465			const sigset_t *__restrict sigdefault)
466			{
467			(sa)->sa_sigdefault = sigdefault;
468			return (0);
469			}
470
471			int
472			posix_spawnattr_setsigmask(posix_spawnattr_t *__restrict sa,
473			const sigset_t *__restrict sigmask)
474			{
475			(sa)->sa_sigmask = sigmask;
476			return (0);
477			}