#include <arpa/inet.h>          /* for inet_ntoa() */
#include <errno.h>              /* for errno() */
#include <netinet/in.h>
#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 <sys/socket.h>
#include "funcs.h"              /* for infomsg(), errormsg() */

/*
 *  Macros
 */

#define MAX_CHILDREN            1000
#define MYPORT                  2345
#define MAXPENDING              10
#define CHILD_RUN_TIME          20
#define USE_SA_RESTART          FALSE
#define BLOCK_SIGCHLD           FALSE

/*
 *  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_server(int);
void handler(int);

/*
 *  Functions
 */

int main(
int argc,
char *argv[])
{
    int i;
    int listening_sfd, toclient_sfd;
    struct sockaddr_in listening_spars;
    struct sockaddr_in toclient_spars;
    int actual_toclient_spars_size;
    int sockoptval;
    sigset_t sigset, old_sigset, suspend_sigset;
    struct sigaction act, old_chld_act, old_alrm_act, old_usr1_act;

    /*
     *  Initialise.
     */

    infomsg("parent setting up listening socket ...");
    /* create addressless IPv4 TCP socket */
    if ((listening_sfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
        errormsg("socket() failed");
    /* ensure bind() doesn't find old stale socket */
    sockoptval = 1;
    setsockopt(listening_sfd, SOL_SOCKET, SO_REUSEADDR,
               &sockoptval, sizeof(sockoptval));
    /* define other socket parameters */
    memset(&listening_spars, 0, sizeof(struct sockaddr_in));
    listening_spars.sin_family = AF_INET;         /* IPv4 */
    listening_spars.sin_port = htons(MYPORT);     /* port */
    listening_spars.sin_addr.s_addr = INADDR_ANY; /* listen on all NICs */
    /* apply socket parameters */
    if (bind(listening_sfd, (struct sockaddr *) &listening_spars,
             sizeof(struct sockaddr)) == -1)
        errormsg("bind() failed");
    /* mark socket for listening */
    if (listen(listening_sfd, MAXPENDING) == -1)
        errormsg("listen() failed");

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

    infomsg("parent setting up signal handlers ...");
#if BLOCK_SIGCHLD
    sigemptyset(&sigset);
    sigaddset(&sigset, SIGCHLD);
    /* cause delivery of SIGCHLD, etc to be delayed until we call sigsuspend() */
    sigprocmask(SIG_BLOCK, &sigset, &old_sigset);
    /* later we need list of signals blocked before that sigprocmask() call,
       but *excluding* SIGCHLD, etc. */
    memcpy(&suspend_sigset, &old_sigset, sizeof(sigset_t));
    sigdelset(&suspend_sigset, SIGCHLD);
#endif
    /* establish signals handlers */
    memset(&act, 0, sizeof(struct sigaction));
    act.sa_mask = sigset;
#if USE_SA_RESTART
    act.sa_flags = SA_RESTART;
#else
    act.sa_flags = 0;
#endif
    act.sa_handler = handler;
    sigaction(SIGCHLD, &act, &old_chld_act);

    /*
     *  Main monitoring loop
     */

    infomsg("parent entering monitoring loop ...");
    while (TRUE) {
        /* wait for incoming connection, move it to a new socket */
        infomsg("parent awaiting incoming connection ...");
        actual_toclient_spars_size = sizeof(struct sockaddr_in);
        if ((toclient_sfd = accept(listening_sfd, 
                                   (struct sockaddr *) &toclient_spars,
                                   &actual_toclient_spars_size)) == -1) {
            infomsg("accept() failed");
            continue;
        }

        /*
         *  Start child server to talk to client.
         */

        infomsg("parent starting one child ...");
        start_child_server(toclient_sfd);
        /* child server uses toclient_sfd, not parent server */
        close(toclient_sfd);
    }

    /*
     *  Clean up and exit.
     */

    infomsg("parent cleaning up and exiting ...");
    sigaction(SIGCHLD, &old_chld_act, NULL);
#if BLOCK_SIGCHLD
    sigprocmask(SIG_SETMASK, &old_sigset, NULL);
#endif
    return(0);
}

pid_t start_child_server(
int toclient_sfd)
{
    pid_t pid;
    int i;
    const char *msg = "this is a message from the server to the client\n";

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

    infomsg("child is pid %d", (int) getpid());
    infomsg("child sending message to client ...");
    if (send(toclient_sfd, msg, strlen(msg), 0) == -1)
        errormsg("send");
    infomsg("child sleeping a bit ...");
    sleep(CHILD_RUN_TIME);
    infomsg("child exiting ...");
    close(toclient_sfd);
    exit(EXIT_SUCCESS);
}

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

    switch (sig) {
        case SIGCHLD: 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;
                              }
                      }
                      break;
        default:      errormsg("parent received unexpected signal %d", sig);
                      break;
    }
}