Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/rdist/child.c	Lines:	0	173	0.0 %
Date:	2017-11-07	Branches:	0	84	0.0 %


/*	$OpenBSD: child.c,v 1.26 2016/03/30 20:12:18 millert Exp $	*/

/*
 * Copyright (c) 1983 Regents of the University of California.
 * 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.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
 */

/*
 * Functions for rdist related to children
 */

#include <sys/types.h>
#include <sys/select.h>
#include <sys/wait.h>

#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "client.h"

typedef enum _PROCSTATE {
    PSrunning,
    PSdead
} PROCSTATE;

/*
 * Structure for child rdist processes mainted by the parent
 */
struct _child {
	char	       *c_name;			/* Name of child */
	int		c_readfd;		/* Read file descriptor */
	pid_t		c_pid;			/* Process ID */
	PROCSTATE       c_state;		/* Running? */
	struct _child  *c_next;			/* Next entry */
};
typedef struct _child CHILD;

static CHILD	       *childlist = NULL;	/* List of children */
int     		activechildren = 0;	/* Number of active children */
static int 		needscan = FALSE;	/* Need to scan children */

static void removechild(CHILD *);
static CHILD *copychild(CHILD *);
static void addchild(CHILD *);
static void readchild(CHILD *);
static pid_t waitproc(int *, int);
static void reap(int);
static void childscan(void);

/*
 * Remove a child that has died (exited)
 * from the list of active children
 */
static void
removechild(CHILD *child)
{
	CHILD *pc, *prevpc;

	debugmsg(DM_CALL, "removechild(%s, %d, %d) start",
		 child->c_name, child->c_pid, child->c_readfd);

	/*
	 * Find the child in the list
	 */
	for (pc = childlist, prevpc = NULL; pc != NULL;
	     prevpc = pc, pc = pc->c_next)
		if (pc == child)
			break;

	if (pc == NULL)
		error("RemoveChild called with bad child %s %d %d",
		      child->c_name, child->c_pid, child->c_readfd);
	else {
		/*
		 * Remove the child
		 */
		sigset_t set, oset;

		sigemptyset(&set);
		sigaddset(&set, SIGCHLD);
		sigprocmask(SIG_BLOCK, &set, &oset);

		if (prevpc != NULL)
			prevpc->c_next = pc->c_next;
		else
			childlist = pc->c_next;

		sigprocmask(SIG_SETMASK, &oset, NULL);

		(void) free(child->c_name);
		--activechildren;
		(void) close(child->c_readfd);
		(void) free(pc);
	}

	debugmsg(DM_CALL, "removechild() end");
}

/*
 * Create a totally new copy of a child.
 */
static CHILD *
copychild(CHILD *child)
{
	CHILD *newc;

	newc = xmalloc(sizeof *newc);

	newc->c_name = xstrdup(child->c_name);
	newc->c_readfd = child->c_readfd;
	newc->c_pid = child->c_pid;
	newc->c_state = child->c_state;
	newc->c_next = NULL;

	return(newc);
}

/*
 * Add a child to the list of children.
 */
static void
addchild(CHILD *child)
{
	CHILD *pc;

	debugmsg(DM_CALL, "addchild() start\n");

	pc = copychild(child);
	pc->c_next = childlist;
	childlist = pc;

	++activechildren;

	debugmsg(DM_MISC,
		 "addchild() created '%s' pid %d fd %d (active=%d)\n",
		 child->c_name, child->c_pid, child->c_readfd, activechildren);
}

/*
 * Read input from a child process.
 */
static void
readchild(CHILD *child)
{
	char rbuf[BUFSIZ];
	ssize_t amt;

	debugmsg(DM_CALL, "[readchild(%s, %d, %d) start]",
		 child->c_name, child->c_pid, child->c_readfd);

	/*
	 * Check that this is a valid child.
	 */
	if (child->c_name == NULL || child->c_readfd <= 0) {
		debugmsg(DM_MISC, "[readchild(%s, %d, %d) bad child]",
			 child->c_name, child->c_pid, child->c_readfd);
		return;
	}

	/*
	 * Read from child and display the result.
	 */
	while ((amt = read(child->c_readfd, rbuf, sizeof(rbuf))) > 0) {
		/* XXX remove these debug calls */
		debugmsg(DM_MISC, "[readchild(%s, %d, %d) got %zd bytes]",
			 child->c_name, child->c_pid, child->c_readfd, amt);

		(void) xwrite(fileno(stdout), rbuf, amt);

		debugmsg(DM_MISC, "[readchild(%s, %d, %d) write done]",
			 child->c_name, child->c_pid, child->c_readfd);
	}

	debugmsg(DM_MISC, "readchild(%s, %d, %d) done: amt = %zd errno = %d\n",
		 child->c_name, child->c_pid, child->c_readfd, amt, errno);

	/*
	 * See if we've reached EOF
	 */
	if (amt == 0)
		debugmsg(DM_MISC, "readchild(%s, %d, %d) at EOF\n",
			 child->c_name, child->c_pid, child->c_readfd);
}

/*
 * Wait for processes to exit.  If "block" is true, then we block
 * until a process exits.  Otherwise, we return right away.  If
 * a process does exit, then the pointer "statval" is set to the
 * exit status of the exiting process, if statval is not NULL.
 */
static pid_t
waitproc(int *statval, int block)
{
	int status;
	pid_t pid;
	int exitval;

	debugmsg(DM_CALL, "waitproc() %s, active children = %d...\n",
		 (block) ? "blocking" : "nonblocking", activechildren);

	pid = waitpid(-1, &status, (block) ? 0 : WNOHANG);

	exitval = WEXITSTATUS(status);

	if (pid > 0 && exitval != 0) {
		nerrs++;
		debugmsg(DM_MISC,
			 "Child process %d exited with status %d.\n",
			 pid, exitval);
	}

	if (statval)
		*statval = exitval;

	debugmsg(DM_CALL, "waitproc() done (activechildren = %d)\n",
		 activechildren);

	return(pid);
}

/*
 * Check to see if any children have exited, and if so, read any unread
 * input and then remove the child from the list of children.
 */
static void
reap(int dummy)
{
	CHILD *pc;
	int save_errno = errno;
	int status = 0;
	pid_t pid;

	debugmsg(DM_CALL, "reap() called\n");

	/*
	 * Reap every child that has exited.  Break out of the
	 * loop as soon as we run out of children that have
	 * exited so far.
	 */
	for ( ; ; ) {
		/*
		 * Do a non-blocking check for exiting processes
		 */
		pid = waitproc(&status, FALSE);
		debugmsg(DM_MISC,
			 "reap() pid = %d status = %d activechildren=%d\n",
			 pid, status, activechildren);

		/*
		 * See if a child really exited
		 */
		if (pid == 0)
			break;
		if (pid < 0) {
			if (errno != ECHILD)
				error("Wait failed: %s", SYSERR);
			break;
		}

		/*
		 * Find the process (pid) and mark it as dead.
		 */
		for (pc = childlist; pc; pc = pc->c_next)
			if (pc->c_pid == pid) {
				needscan = TRUE;
				pc->c_state = PSdead;
			}

	}

	/*
	 * Reset signals
	 */
	(void) signal(SIGCHLD, reap);

	debugmsg(DM_CALL, "reap() done\n");
	errno = save_errno;
}

/*
 * Scan the children list to find the child that just exited,
 * read any unread input, then remove it from the list of active children.
 */
static void
childscan(void)
{
	CHILD *pc, *nextpc;

	debugmsg(DM_CALL, "childscan() start");

	for (pc = childlist; pc; pc = nextpc) {
		nextpc = pc->c_next;
		if (pc->c_state == PSdead) {
			readchild(pc);
			removechild(pc);
		}
	}

	needscan = FALSE;
	debugmsg(DM_CALL, "childscan() end");
}

/*
 *
 * Wait for children to send output for us to read.
 *
 */
void
waitup(void)
{
	int count;
	CHILD *pc;
	fd_set *rchildfdsp = NULL;
	int rchildfdsn = 0;

	debugmsg(DM_CALL, "waitup() start\n");

	if (needscan)
		childscan();

	if (activechildren <= 0)
		return;

	/*
	 * Set up which children we want to select() on.
	 */
	for (pc = childlist; pc; pc = pc->c_next)
		if (pc->c_readfd > rchildfdsn)
			rchildfdsn = pc->c_readfd;
	rchildfdsp = xcalloc(howmany(rchildfdsn+1, NFDBITS), sizeof(fd_mask));

	for (pc = childlist; pc; pc = pc->c_next)
		if (pc->c_readfd > 0) {
			debugmsg(DM_MISC, "waitup() select on %d (%s)\n",
				 pc->c_readfd, pc->c_name);
			FD_SET(pc->c_readfd, rchildfdsp);
		}

	/*
	 * Actually call select()
	 */
	/* XXX remove debugmsg() calls */
	debugmsg(DM_MISC, "waitup() Call select(), activechildren=%d\n",
		 activechildren);

	count = select(rchildfdsn+1, rchildfdsp, NULL, NULL, NULL);

	debugmsg(DM_MISC, "waitup() select returned %d activechildren = %d\n",
		 count, activechildren);

	/*
	 * select() will return count < 0 and errno == EINTR when
	 * there are no active children left.
	 */
	if (count < 0) {
		if (errno != EINTR)
			error("Select failed reading children input: %s",
			      SYSERR);
		free(rchildfdsp);
		return;
	}

	/*
	 * This should never happen.
	 */
	if (count == 0) {
		error("Select returned an unexpected count of 0.");
		free(rchildfdsp);
		return;
	}

	/*
	 * Go through the list of children and read from each child
	 * which select() detected as ready for reading.
	 */
	for (pc = childlist; pc && count > 0; pc = pc->c_next) {
		/*
		 * Make sure child still exists
		 */
		if (pc->c_name && kill(pc->c_pid, 0) < 0 &&
		    errno == ESRCH) {
			debugmsg(DM_MISC,
				 "waitup() proc %d (%s) died unexpectedly!",
				 pc->c_pid, pc->c_name);
			pc->c_state = PSdead;
			needscan = TRUE;
		}

		if (pc->c_name == NULL ||
		    !FD_ISSET(pc->c_readfd, rchildfdsp))
			continue;

		readchild(pc);
		--count;
	}
	free(rchildfdsp);

	debugmsg(DM_CALL, "waitup() end\n");
}

/*
 * Enable non-blocking I/O.
 */
static int
setnonblocking(int fd)
{
	int	flags;

	if ((flags = fcntl(fd, F_GETFL)) < 0)
		return (-1);
	if (flags & O_NONBLOCK)
		return (0);
	return (fcntl(fd, F_SETFL, flags | O_NONBLOCK));
}

/*
 * Spawn (create) a new child process for "cmd".
 */
int
spawn(struct cmd *cmd, struct cmd *cmdlist)
{
	pid_t pid;
	int fildes[2];
	char *childname = cmd->c_name;

	if (pipe(fildes) < 0) {
		error("Cannot create pipe for %s: %s", childname, SYSERR);
		return(-1);
	}

	pid = fork();
	if (pid == (pid_t)-1) {
		error("Cannot spawn child for %s: fork failed: %s",
		      childname, SYSERR);
		return(-1);
	} else if (pid > 0) {
		/*
		 * Parent
		 */
		static CHILD newchild;

		/* Receive notification when the child exits */
		(void) signal(SIGCHLD, reap);

		/* Settup the new child */
		newchild.c_next = NULL;
		newchild.c_name = childname;
		newchild.c_readfd = fildes[PIPE_READ];
		newchild.c_pid = pid;
		newchild.c_state = PSrunning;

		/* We're not going to write to the child */
		(void) close(fildes[PIPE_WRITE]);

		/* Set non-blocking I/O */
		if (setnonblocking(newchild.c_readfd) < 0) {
			error("Set nonblocking I/O failed: %s", SYSERR);
			return(-1);
		}

		/* Add new child to child list */
		addchild(&newchild);

		/* Mark all other entries for this host as assigned */
		markassigned(cmd, cmdlist);

		debugmsg(DM_CALL,
			 "spawn() Forked child %d for host %s active = %d\n",
			 pid, childname, activechildren);
		return(pid);
	} else {
		/*
		 * Child
		 */

		/* We're not going to read from our parent */
		(void) close(fildes[PIPE_READ]);

		/* Make stdout and stderr go to PIPE_WRITE (our parent) */
		if (dup2(fildes[PIPE_WRITE], (int)fileno(stdout)) < 0) {
			error("Cannot duplicate stdout file descriptor: %s",
			      SYSERR);
			return(-1);
		}
		if (dup2(fildes[PIPE_WRITE], (int)fileno(stderr)) < 0) {
			error("Cannot duplicate stderr file descriptor: %s",
			      SYSERR);
			return(-1);
		}

		return(0);
	}
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: child.c,v 1.26 2016/03/30 20:12:18 millert Exp $ */
2
3			/*
4			* Copyright (c) 1983 Regents of the University of California.
5			* All rights reserved.
6			*
7			* Redistribution and use in source and binary forms, with or without
8			* modification, are permitted provided that the following conditions
9			* are met:
10			* 1. Redistributions of source code must retain the above copyright
11			* notice, this list of conditions and the following disclaimer.
12			* 2. Redistributions in binary form must reproduce the above copyright
13			* notice, this list of conditions and the following disclaimer in the
14			* documentation and/or other materials provided with the distribution.
15			* 3. Neither the name of the University nor the names of its contributors
16			* may be used to endorse or promote products derived from this software
17			* without specific prior written permission.
18			*
19			* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22			* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29			* SUCH DAMAGE.
30			*/
31
32			/*
33			* Functions for rdist related to children
34			*/
35
36			#include <sys/types.h>
37			#include <sys/select.h>
38			#include <sys/wait.h>
39
40			#include <errno.h>
41			#include <fcntl.h>
42			#include <stdlib.h>
43			#include <string.h>
44			#include <unistd.h>
45
46			#include "client.h"
47
48			typedef enum _PROCSTATE {
49			PSrunning,
50			PSdead
51			} PROCSTATE;
52
53			/*
54			* Structure for child rdist processes mainted by the parent
55			*/
56			struct _child {
57			char c_name; / Name of child */
58			int c_readfd; /* Read file descriptor */
59			pid_t c_pid; /* Process ID */
60			PROCSTATE c_state; /* Running? */
61			struct _child c_next; / Next entry */
62			};
63			typedef struct _child CHILD;
64
65			static CHILD childlist = NULL; / List of children */
66			int activechildren = 0; /* Number of active children */
67			static int needscan = FALSE; /* Need to scan children */
68
69			static void removechild(CHILD *);
70			static CHILD copychild(CHILD );
71			static void addchild(CHILD *);
72			static void readchild(CHILD *);
73			static pid_t waitproc(int *, int);
74			static void reap(int);
75			static void childscan(void);
76
77			/*
78			* Remove a child that has died (exited)
79			* from the list of active children
80			*/
81			static void
82			removechild(CHILD *child)
83			{
84			CHILD pc, prevpc;
85
86			debugmsg(DM_CALL, "removechild(%s, %d, %d) start",
87			child->c_name, child->c_pid, child->c_readfd);
88
89			/*
90			* Find the child in the list
91			*/
92			for (pc = childlist, prevpc = NULL; pc != NULL;
93			prevpc = pc, pc = pc->c_next)
94			if (pc == child)
95			break;
96
97			if (pc == NULL)
98			error("RemoveChild called with bad child %s %d %d",
99			child->c_name, child->c_pid, child->c_readfd);
100			else {
101			/*
102			* Remove the child
103			*/
104			sigset_t set, oset;
105
106			sigemptyset(&set);
107			sigaddset(&set, SIGCHLD);
108			sigprocmask(SIG_BLOCK, &set, &oset);
109
110			if (prevpc != NULL)
111			prevpc->c_next = pc->c_next;
112			else
113			childlist = pc->c_next;
114
115			sigprocmask(SIG_SETMASK, &oset, NULL);
116
117			(void) free(child->c_name);
118			--activechildren;
119			(void) close(child->c_readfd);
120			(void) free(pc);
121			}
122
123			debugmsg(DM_CALL, "removechild() end");
124			}
125
126			/*
127			* Create a totally new copy of a child.
128			*/
129			static CHILD *
130			copychild(CHILD *child)
131			{
132			CHILD *newc;
133
134			newc = xmalloc(sizeof *newc);
135
136			newc->c_name = xstrdup(child->c_name);
137			newc->c_readfd = child->c_readfd;
138			newc->c_pid = child->c_pid;
139			newc->c_state = child->c_state;
140			newc->c_next = NULL;
141
142			return(newc);
143			}
144
145			/*
146			* Add a child to the list of children.
147			*/
148			static void
149			addchild(CHILD *child)
150			{
151			CHILD *pc;
152
153			debugmsg(DM_CALL, "addchild() start\n");
154
155			pc = copychild(child);
156			pc->c_next = childlist;
157			childlist = pc;
158
159			++activechildren;
160
161			debugmsg(DM_MISC,
162			"addchild() created '%s' pid %d fd %d (active=%d)\n",
163			child->c_name, child->c_pid, child->c_readfd, activechildren);
164			}
165
166			/*
167			* Read input from a child process.
168			*/
169			static void
170			readchild(CHILD *child)
171			{
172			char rbuf[BUFSIZ];
173			ssize_t amt;
174
175			debugmsg(DM_CALL, "[readchild(%s, %d, %d) start]",
176			child->c_name, child->c_pid, child->c_readfd);
177
178			/*
179			* Check that this is a valid child.
180			*/
181			if (child->c_name == NULL \|\| child->c_readfd <= 0) {
182			debugmsg(DM_MISC, "[readchild(%s, %d, %d) bad child]",
183			child->c_name, child->c_pid, child->c_readfd);
184			return;
185			}
186
187			/*
188			* Read from child and display the result.
189			*/
190			while ((amt = read(child->c_readfd, rbuf, sizeof(rbuf))) > 0) {
191			/* XXX remove these debug calls */
192			debugmsg(DM_MISC, "[readchild(%s, %d, %d) got %zd bytes]",
193			child->c_name, child->c_pid, child->c_readfd, amt);
194
195			(void) xwrite(fileno(stdout), rbuf, amt);
196
197			debugmsg(DM_MISC, "[readchild(%s, %d, %d) write done]",
198			child->c_name, child->c_pid, child->c_readfd);
199			}
200
201			debugmsg(DM_MISC, "readchild(%s, %d, %d) done: amt = %zd errno = %d\n",
202			child->c_name, child->c_pid, child->c_readfd, amt, errno);
203
204			/*
205			* See if we've reached EOF
206			*/
207			if (amt == 0)
208			debugmsg(DM_MISC, "readchild(%s, %d, %d) at EOF\n",
209			child->c_name, child->c_pid, child->c_readfd);
210			}
211
212			/*
213			* Wait for processes to exit. If "block" is true, then we block
214			* until a process exits. Otherwise, we return right away. If
215			* a process does exit, then the pointer "statval" is set to the
216			* exit status of the exiting process, if statval is not NULL.
217			*/
218			static pid_t
219			waitproc(int *statval, int block)
220			{
221			int status;
222			pid_t pid;
223			int exitval;
224
225			debugmsg(DM_CALL, "waitproc() %s, active children = %d...\n",
226			(block) ? "blocking" : "nonblocking", activechildren);
227
228			pid = waitpid(-1, &status, (block) ? 0 : WNOHANG);
229
230			exitval = WEXITSTATUS(status);
231
232			if (pid > 0 && exitval != 0) {
233			nerrs++;
234			debugmsg(DM_MISC,
235			"Child process %d exited with status %d.\n",
236			pid, exitval);
237			}
238
239			if (statval)
240			*statval = exitval;
241
242			debugmsg(DM_CALL, "waitproc() done (activechildren = %d)\n",
243			activechildren);
244
245			return(pid);
246			}
247
248			/*
249			* Check to see if any children have exited, and if so, read any unread
250			* input and then remove the child from the list of children.
251			*/
252			static void
253			reap(int dummy)
254			{
255			CHILD *pc;
256			int save_errno = errno;
257			int status = 0;
258			pid_t pid;
259
260			debugmsg(DM_CALL, "reap() called\n");
261
262			/*
263			* Reap every child that has exited. Break out of the
264			* loop as soon as we run out of children that have
265			* exited so far.
266			*/
267			for ( ; ; ) {
268			/*
269			* Do a non-blocking check for exiting processes
270			*/
271			pid = waitproc(&status, FALSE);
272			debugmsg(DM_MISC,
273			"reap() pid = %d status = %d activechildren=%d\n",
274			pid, status, activechildren);
275
276			/*
277			* See if a child really exited
278			*/
279			if (pid == 0)
280			break;
281			if (pid < 0) {
282			if (errno != ECHILD)
283			error("Wait failed: %s", SYSERR);
284			break;
285			}
286
287			/*
288			* Find the process (pid) and mark it as dead.
289			*/
290			for (pc = childlist; pc; pc = pc->c_next)
291			if (pc->c_pid == pid) {
292			needscan = TRUE;
293			pc->c_state = PSdead;
294			}
295
296			}
297
298			/*
299			* Reset signals
300			*/
301			(void) signal(SIGCHLD, reap);
302
303			debugmsg(DM_CALL, "reap() done\n");
304			errno = save_errno;
305			}
306
307			/*
308			* Scan the children list to find the child that just exited,
309			* read any unread input, then remove it from the list of active children.
310			*/
311			static void
312			childscan(void)
313			{
314			CHILD pc, nextpc;
315
316			debugmsg(DM_CALL, "childscan() start");
317
318			for (pc = childlist; pc; pc = nextpc) {
319			nextpc = pc->c_next;
320			if (pc->c_state == PSdead) {
321			readchild(pc);
322			removechild(pc);
323			}
324			}
325
326			needscan = FALSE;
327			debugmsg(DM_CALL, "childscan() end");
328			}
329
330			/*
331			*
332			* Wait for children to send output for us to read.
333			*
334			*/
335			void
336			waitup(void)
337			{
338			int count;
339			CHILD *pc;
340			fd_set *rchildfdsp = NULL;
341			int rchildfdsn = 0;
342
343			debugmsg(DM_CALL, "waitup() start\n");
344
345			if (needscan)
346			childscan();
347
348			if (activechildren <= 0)
349			return;
350
351			/*
352			* Set up which children we want to select() on.
353			*/
354			for (pc = childlist; pc; pc = pc->c_next)
355			if (pc->c_readfd > rchildfdsn)
356			rchildfdsn = pc->c_readfd;
357			rchildfdsp = xcalloc(howmany(rchildfdsn+1, NFDBITS), sizeof(fd_mask));
358
359			for (pc = childlist; pc; pc = pc->c_next)
360			if (pc->c_readfd > 0) {
361			debugmsg(DM_MISC, "waitup() select on %d (%s)\n",
362			pc->c_readfd, pc->c_name);
363			FD_SET(pc->c_readfd, rchildfdsp);
364			}
365
366			/*
367			* Actually call select()
368			*/
369			/* XXX remove debugmsg() calls */
370			debugmsg(DM_MISC, "waitup() Call select(), activechildren=%d\n",
371			activechildren);
372
373			count = select(rchildfdsn+1, rchildfdsp, NULL, NULL, NULL);
374
375			debugmsg(DM_MISC, "waitup() select returned %d activechildren = %d\n",
376			count, activechildren);
377
378			/*
379			* select() will return count < 0 and errno == EINTR when
380			* there are no active children left.
381			*/
382			if (count < 0) {
383			if (errno != EINTR)
384			error("Select failed reading children input: %s",
385			SYSERR);
386			free(rchildfdsp);
387			return;
388			}
389
390			/*
391			* This should never happen.
392			*/
393			if (count == 0) {
394			error("Select returned an unexpected count of 0.");
395			free(rchildfdsp);
396			return;
397			}
398
399			/*
400			* Go through the list of children and read from each child
401			* which select() detected as ready for reading.
402			*/
403			for (pc = childlist; pc && count > 0; pc = pc->c_next) {
404			/*
405			* Make sure child still exists
406			*/
407			if (pc->c_name && kill(pc->c_pid, 0) < 0 &&
408			errno == ESRCH) {
409			debugmsg(DM_MISC,
410			"waitup() proc %d (%s) died unexpectedly!",
411			pc->c_pid, pc->c_name);
412			pc->c_state = PSdead;
413			needscan = TRUE;
414			}
415
416			if (pc->c_name == NULL \|\|
417			!FD_ISSET(pc->c_readfd, rchildfdsp))
418			continue;
419
420			readchild(pc);
421			--count;
422			}
423			free(rchildfdsp);
424
425			debugmsg(DM_CALL, "waitup() end\n");
426			}
427
428			/*
429			* Enable non-blocking I/O.
430			*/
431			static int
432			setnonblocking(int fd)
433			{
434			int flags;
435
436			if ((flags = fcntl(fd, F_GETFL)) < 0)
437			return (-1);
438			if (flags & O_NONBLOCK)
439			return (0);
440			return (fcntl(fd, F_SETFL, flags \| O_NONBLOCK));
441			}
442
443			/*
444			* Spawn (create) a new child process for "cmd".
445			*/
446			int
447			spawn(struct cmd cmd, struct cmd cmdlist)
448			{
449			pid_t pid;
450			int fildes[2];
451			char *childname = cmd->c_name;
452
453			if (pipe(fildes) < 0) {
454			error("Cannot create pipe for %s: %s", childname, SYSERR);
455			return(-1);
456			}
457
458			pid = fork();
459			if (pid == (pid_t)-1) {
460			error("Cannot spawn child for %s: fork failed: %s",
461			childname, SYSERR);
462			return(-1);
463			} else if (pid > 0) {
464			/*
465			* Parent
466			*/
467			static CHILD newchild;
468
469			/* Receive notification when the child exits */
470			(void) signal(SIGCHLD, reap);
471
472			/* Settup the new child */
473			newchild.c_next = NULL;
474			newchild.c_name = childname;
475			newchild.c_readfd = fildes[PIPE_READ];
476			newchild.c_pid = pid;
477			newchild.c_state = PSrunning;
478
479			/* We're not going to write to the child */
480			(void) close(fildes[PIPE_WRITE]);
481
482			/* Set non-blocking I/O */
483			if (setnonblocking(newchild.c_readfd) < 0) {
484			error("Set nonblocking I/O failed: %s", SYSERR);
485			return(-1);
486			}
487
488			/* Add new child to child list */
489			addchild(&newchild);
490
491			/* Mark all other entries for this host as assigned */
492			markassigned(cmd, cmdlist);
493
494			debugmsg(DM_CALL,
495			"spawn() Forked child %d for host %s active = %d\n",
496			pid, childname, activechildren);
497			return(pid);
498			} else {
499			/*
500			* Child
501			*/
502
503			/* We're not going to read from our parent */
504			(void) close(fildes[PIPE_READ]);
505
506			/* Make stdout and stderr go to PIPE_WRITE (our parent) */
507			if (dup2(fildes[PIPE_WRITE], (int)fileno(stdout)) < 0) {
508			error("Cannot duplicate stdout file descriptor: %s",
509			SYSERR);
510			return(-1);
511			}
512			if (dup2(fildes[PIPE_WRITE], (int)fileno(stderr)) < 0) {
513			error("Cannot duplicate stderr file descriptor: %s",
514			SYSERR);
515			return(-1);
516			}
517
518			return(0);
519			}
520			}