#include <errno.h>              /* for errno() */
#include <linux/limits.h>       /* for ARG_MAX */
#include <signal.h>             /* for signal(), SIG* */
#include <stdio.h>              /* for sprintf(), stderr, ... */
#include <stdlib.h>             /* for exit() */
#include <string.h>             /* for strerror() */
#include <sys/types.h>          /* for wait() */
#include <sys/wait.h>           /* for wait() */
#include <time.h>               /* for time() */
#include <unistd.h>             /* for sleep(), fork() and execlp() */
#include "funcs.h"              /* for infomsg(), errormsg() */

/*
 *  Macros
 */

#define MAX_CHILDREN            1000
#define CHILDREN                5
#define INTER_CHILD_INTERVAL    10
#define CHILD_RUN_TIME(n)       (((n+getpid())*7)%19) /* stupid pseudo RNG */

/*
 *  Type and struct definitions
 */

struct child {
    pid_t  pid;
    time_t start;
};

/*
 *  Global variables
 */

struct child children[MAX_CHILDREN];

/*
 *  Forward declarations
 */

pid_t start_child_sleep(int);
void sigchld_handler(int);

/*
 *  Functions
 */

int main(
int argc,
char *argv[])
{
    int i, j;
    int running_children_count;
    time_t now;

    /*
     *  Initialise.
     */

    infomsg("parent initialising children status table ...");
    for (i=0; i<MAX_CHILDREN; i++)
        children[i].pid = 0;

    infomsg("parent setting up signal handlers ...");
    signal(SIGCHLD, sigchld_handler);

    /*
     *  Main monitoring loop
     */

    infomsg("parent entering monitoring loop ...");
    j = 0;
    while (TRUE) {
        now = time(NULL);

        /*
         *  Exit if no running child processes *and*
         *  we've already started desired number
         */

        if (j < CHILDREN)
            infomsg("parent sees some children not started yet");
        else {
            infomsg("parent checking for running children ...");
            running_children_count = 0;
            for (i=0; i<MAX_CHILDREN; i++)
                if (children[i].pid != 0)
                    running_children_count++;
            infomsg("parent sees %d children still running", running_children_count);
            if (running_children_count == 0 && j == CHILDREN)
                break;
        }

        /*
         *  Every INTER_CHILD_INTERVAL seconds start another child process.
         */

        if (j<CHILDREN) {
            infomsg("parent starting one child ...");
            start_child_sleep(CHILD_RUN_TIME(j));
            j++;
            infomsg("parent sleeping %ds ...", INTER_CHILD_INTERVAL);
            sleep(INTER_CHILD_INTERVAL);
        }
    }

    /*
     *  Clean up and exit.
     */

    infomsg("parent cleaning up and exiting ...");
    signal(SIGCHLD, SIG_DFL);
    return(0);
}

pid_t start_child_sleep(
int period)
{
    pid_t pid;
    int i;
    char buf[ARG_MAX];

    /*
     *  Find an empty slot to store info about the process we're
     *  about launch.
     */

    for (i=0; i<MAX_CHILDREN; i++)
        if (children[i].pid == 0)
            break;
    if (i == MAX_CHILDREN)
        errormsg("start_child_sleep: unable to find a free slot");

    /*
     *  Launch a child process and note its pid and start time
     *  in the empty slot.
     */

    if ((pid=fork()) < 0)
        errormsg("fork() failed: %s", strerror(errno));
    else if (pid > 0) {
        children[i].pid = pid;
        children[i].start = time(NULL);
        return(pid);
    }

    /*
     *  Only the child gets here
     */

    sprintf(buf, "echo \"child $$ started ...\";"
                 "sleep %d;"
                 "echo \"child $$ exiting ...\"",
                 period);
    infomsg("child running for %ds ...", period);
    execlp("/bin/sh", "sh", "-c", buf, (char *) NULL);
    errormsg("exec() failed: %s", strerror(errno));
}

void sigchld_handler(
int sig)
{
    int wstatus;
    pid_t pid;
    int i;

    while ((pid=waitpid(-1, &wstatus, WNOHANG)) > 0) {
        infomsg("parent received SIGCHLD; reaping and clearing child data ...");
        for (i=0; i<MAX_CHILDREN; i++)
            if (children[i].pid == pid) {
                children[i].pid = 0;
                children[i].start = 0;
                break;
            }
    }
}