Imagine a bank with only one teller. Every customer must wait for the person in front to finish completely before being served. That is exactly how an iterative server works — it handles one client at a time, fully, before moving on to the next.

Now imagine a bank with multiple tellers. Several customers are served at the same time. That is a concurrent server.

For services like TCP echo (where a client may send unlimited data and the server must keep reading and writing), serving one client can take an unlimited amount of time. During that time, all other clients are blocked waiting. This is completely unacceptable in real systems.

The rule is simple: if servicing one client may take an indefinite amount of time, use a concurrent server design.

The classic Linux approach creates a new child process using fork() for every incoming client connection. Here is the step-by-step flow:

Key insight: After fork(), both parent and child have copies of both file descriptors (lfd and cfd). Each closes the one it does not need:

• The child closes lfd (listening socket) because it does not accept new connections.
• The parent closes cfd (connected socket) because it does not talk to that client.

If the parent does NOT close cfd, that socket will never actually close (the reference count stays above zero), and eventually the parent runs out of file descriptors.

This is one of the most important things to understand. When fork() is called, the child inherits a copy of all the parent’s open file descriptors. Both point to the same underlying open file descriptions in the kernel.

When a child process finishes, it does not immediately disappear. It becomes a zombie — it has exited but its entry is still in the process table, waiting for the parent to collect its exit status using wait() or waitpid().

In a concurrent server that creates many child processes, if we never call waitpid(), the process table fills up with zombies. This can eventually exhaust system resources.

The solution is to install a SIGCHLD signal handler. The kernel sends SIGCHLD to the parent whenever a child exits. In the handler we call waitpid() in a loop (because multiple children may exit between signal deliveries):

static void grimReaper(int sig)
{
    int savedErrno;
    savedErrno = errno;   /* Save errno - waitpid() may change it */

    while (waitpid(-1, NULL, WNOHANG) > 0)
        continue;         /* Reap all dead children */

    errno = savedErrno;   /* Restore errno */
}

Important details:

• waitpid(-1, ...) means “wait for any child”.
• WNOHANG means “do not block if no child has exited yet”.
• We use a while loop because multiple children can exit before the handler runs.
• We save and restore errno because signal handlers can interrupt system calls that set errno.

A daemon is a process that runs in the background, detached from any terminal, and typically started at system boot. Network servers are usually daemons because:

• They should run indefinitely without an attached terminal.
• They should not be killed when the user logs out.
• They use syslog for logging instead of printing to a terminal.

The server calls becomeDaemon() (covered in Chapter 37) which: forks, makes the child the session leader via setsid(), changes the working directory to /, closes standard file descriptors, and redirects them to /dev/null.

A malicious attacker can connect to your server thousands of times, causing it to create thousands of child processes. This is called a remote fork bomb and it can make the system unusable.

In production servers you should track the number of currently running children:

static int childCount = 0;
#define MAX_CHILDREN 100

/* In the SIGCHLD handler: */
childCount--;   /* decrement when a child dies */

/* After fork(): */
childCount++;

/* Before calling fork(): */
if (childCount >= MAX_CHILDREN) {
    /* Either refuse the connection or temporarily stop accepting */
    close(cfd);
    continue;
}

Another approach: accept the connection but immediately close it, so the client gets a clean “connection refused” style response instead of hanging forever.

Below is the cleanest possible skeleton of a fork-based concurrent TCP server. Every line is explained in comments so you understand the role of each part:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <signal.h>
#include <errno.h>

#define PORT 9000
#define BACKLOG 10

/* SIGCHLD handler - reap zombie child processes */
static void sigchld_handler(int sig)
{
    int saved_errno = errno;
    while (waitpid(-1, NULL, WNOHANG) > 0)  /* reap all dead children */
        continue;
    errno = saved_errno;
}

/* Per-client work done by the child process */
static void handle_client(int cfd)
{
    char buf[1024];
    ssize_t n;

    /* Echo everything back to the client */
    while ((n = read(cfd, buf, sizeof(buf))) > 0)
        write(cfd, buf, n);

    /* n == 0: client disconnected; n == -1: error */
}

int main(void)
{
    int lfd, cfd;                  /* listening fd, connected fd */
    struct sockaddr_in addr;
    struct sigaction sa;

    /* 1. Install SIGCHLD handler to prevent zombies */
    sa.sa_handler = sigchld_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;      /* restart interrupted system calls */
    sigaction(SIGCHLD, &sa, NULL);

    /* 2. Create the listening socket */
    lfd = socket(AF_INET, SOCK_STREAM, 0);

    memset(&addr, 0, sizeof(addr));
    addr.sin_family      = AF_INET;
    addr.sin_port        = htons(PORT);
    addr.sin_addr.s_addr = htonl(INADDR_ANY);  /* listen on all interfaces */

    bind(lfd, (struct sockaddr *)&addr, sizeof(addr));
    listen(lfd, BACKLOG);

    printf("Server listening on port %d\n", PORT);

    /* 3. Accept loop */
    for (;;) {
        cfd = accept(lfd, NULL, NULL);   /* block until a client connects */
        if (cfd == -1) {
            if (errno == EINTR) continue; /* interrupted by signal - retry */
            perror("accept");
            break;
        }

        /* 4. Fork a child to handle this client */
        switch (fork()) {
        case -1:
            perror("fork");
            close(cfd);         /* cannot create child; skip this client */
            break;

        case 0:                 /* CHILD PROCESS */
            close(lfd);         /* child doesn't need listening socket */
            handle_client(cfd);
            close(cfd);
            _exit(EXIT_SUCCESS);  /* use _exit() not exit() in child */

        default:                /* PARENT PROCESS */
            close(cfd);         /* parent doesn't need connected socket */
            break;              /* loop back to accept() */
        }
    }

    close(lfd);
    return 0;
}

Why _exit() in the child? Because exit() flushes stdio buffers and calls atexit() handlers. In the child those are copies inherited from the parent and flushing them twice causes double output. _exit() exits immediately without any cleanup.