#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                500
#define TIMEOUT                 300
#define A_LONG_TIME             3600
#define CHILD_RUN_TIME(n)       1

/*
 *  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);
void sigalrm_handler(int);
void sigusr1_handler(int);

/*
 *  Functions
 */

int main(
int argc,
char *argv[])
{
    int i;
    int running_children_count, next_timeout, killed_something;
    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);
    signal(SIGALRM, sigalrm_handler);
    signal(SIGUSR1, sigusr1_handler);

    /*
     *  Start children.
     */

    infomsg("parent starting %d children ...", CHILDREN);
    for (i=0; i<CHILDREN; i++)
        start_child_sleep(CHILD_RUN_TIME(i));

    /*
     *  Main monitoring loop
     */

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

        /*
         *  Exit if no running children.
         */

        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)
            break;

        /*
         *  Kill any children that have reached their timeout time and not
         *  been killed already.
         */

        killed_something = FALSE;
        for (i=0; i<MAX_CHILDREN; i++)
            if (children[i].pid != 0 && children[i].start != 0 &&
                    now >= children[i].start+TIMEOUT) {
                kill(children[i].pid, SIGTERM);
                children[i].start = 0;
                killed_something = TRUE;
            }

        /*
         *  Slight optimisation: if something did reach its timeout and got
         *  killed then skip to reassessing if this program can exit.
         */

        if (killed_something)
            continue;

        /*
         *  Schedule timeout alarm of next-to-timeout child.
         */

        infomsg("parent scheduling timeout alarm ...");
        next_timeout = 0;
        for (i=0; i<MAX_CHILDREN; i++)
            if (children[i].pid != 0 && children[i].start != 0)
                if (next_timeout == 0)
                    next_timeout = children[i].start+TIMEOUT - now;
                else if (children[i].start+TIMEOUT - now < next_timeout)
                    next_timeout = children[i].start+TIMEOUT - now;
        if (next_timeout >= 1) {
            infomsg("parent scheduling alarm for %ds ...", next_timeout);
            alarm(next_timeout);
        }

        /*
         *  Sleep until next signal arrives
         *  (unless timeout is so close that we didn't schedule an alarm
         *  so sleeping might not be interrupted).
         */

        infomsg("parent sleeping until signal arrives ...");
        if (next_timeout >= 1)
            sleep(A_LONG_TIME);

        /*
         *  If SIGCHLD arrived before SIGALRM then the alarm is still
         *  pending. Cancel it.
         */

        infomsg("parent cancelling alarm ...");
        alarm(0);
    }

    /*
     *  Clean up and exit.
     */

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

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

    /*
     *  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.
     */

    sprintf(buf, "echo \"child $$ started ...\";"
                 "sleep %d;"
                 "echo \"child $$ exiting ...\"",
                 period);
    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
     */

    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;
            }
    }
}

void sigalrm_handler(
int sig)
{
   infomsg("parent received SIGALRM");
}

void sigusr1_handler(
int sig)
{
   int i;

   finfomsg(stderr, "parent received SIGUSR1");
   for (i=0; i<MAX_CHILDREN; i++)
       if (children[i].pid != 0)
           finfomsg(stderr, "slot:%04d; pid:%05d, start=%ld", 
                    i, children[i].pid, children[i].start);
}