1. Iterative Server

An iterative server handles clients one at a time. It picks up one client, finishes everything needed for that client, and only then moves on to the next one. Think of it like a single-window bank counter — one customer at a time.

When is Iterative the Right Choice?

The TLPI book gives a perfect example: a UDP echo server. The server receives a datagram and immediately echoes it back. This is almost instant — so iterative design is perfectly fine.

2. Concurrent Server

A concurrent server handles multiple clients at the same time. When a new client arrives, the server creates a separate entity (a child process or a thread) to handle that client, and goes back to listening for more clients. Think of it like a hospital with many doctors — each patient gets their own doctor.

When is Concurrent the Right Choice?

3. Thread-per-Client Variant

Instead of forking a child process, you can create a new POSIX thread for each client. This avoids the heavy cost of fork() but requires careful shared-memory management. The book mentions this as a variation — we will cover it in a later chapter.

Code Skeleton: Concurrent Server

Here is a simplified skeleton showing the structure of a concurrent TCP server:

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

/* SIGCHLD handler - reaps zombie children */
static void sigchld_handler(int sig)
{
    int saved_errno = errno;  /* waitpid may change errno */

    /* Loop to reap ALL terminated children, not just one */
    while (waitpid(-1, NULL, WNOHANG) > 0)
        continue;

    errno = saved_errno;
}

int main(void)
{
    int lfd, cfd;
    struct sigaction sa;

    /* Step 1: Install SIGCHLD handler before accepting any clients */
    sigemptyset(&sa.sa_mask);
    sa.sa_flags   = SA_RESTART;   /* restart interrupted system calls */
    sa.sa_handler = sigchld_handler;
    sigaction(SIGCHLD, &sa, NULL);

    /* Step 2: Create listening socket (bind + listen) */
    lfd = create_and_bind_socket();   /* your helper function */

    /* Step 3: Accept loop */
    for (;;) {
        cfd = accept(lfd, NULL, NULL);
        if (cfd == -1) {
            perror("accept");
            continue;
        }

        switch (fork()) {
        case -1:
            perror("fork");
            close(cfd);    /* can't fork - close and move on */
            break;

        case 0:            /* CHILD: serve this client */
            close(lfd);    /* child doesn't need listening socket */
            serve_client(cfd);
            close(cfd);
            _exit(EXIT_SUCCESS);

        default:           /* PARENT: go back to accepting */
            close(cfd);    /* parent doesn't need connected socket */
            /* child has its own copy via fork - this closes parent's copy */
            break;
        }
    }

    /* never reached */
    close(lfd);
    return 0;
}

The Echo Service (RFC 862)

The examples in Chapter 60 implement the echo service, defined in RFC 862. It is the simplest possible service: whatever the client sends, the server sends back exactly. It runs on port 7 for both UDP and TCP. Though simple, it is a perfect teaching tool because:

• UDP echo works naturally with an iterative server (one datagram at a time)
• TCP echo works well with a concurrent server (client may send many lines)
• It requires no application logic — only socket mechanics matter

Interview Questions & Answers