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