1. Why SO_REUSEADDR Is Important

When you stop and restart a server, the old TCP connection can stay in a TIME_WAIT state for up to 2 minutes. During this time, if you try to bind() to the same port again, you get an error: “Address already in use”.

The SO_REUSEADDR socket option tells the kernel: “Allow me to bind to this address/port even if it is still in TIME_WAIT.” This is why almost every TCP server sets this option before calling bind().

Code: Correct Server Socket Setup

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int sockfd, optval;
    struct sockaddr_in addr;

    /* Step 1: Create the socket */
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    /* Step 2: Set SO_REUSEADDR BEFORE bind() */
    optval = 1;
    if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR,
                   &optval, sizeof(optval)) == -1) {
        perror("setsockopt SO_REUSEADDR");
        exit(EXIT_FAILURE);
    }

    /* Step 3: Bind to address */
    addr.sin_family      = AF_INET;
    addr.sin_port        = htons(8080);
    addr.sin_addr.s_addr = INADDR_ANY;

    if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
        perror("bind");
        exit(EXIT_FAILURE);
    }

    /* Step 4: Start listening */
    if (listen(sockfd, 5) == -1) {
        perror("listen");
        exit(EXIT_FAILURE);
    }

    printf("Server listening on port 8080\n");
    /* ... accept loop ... */
    return 0;
}

Key rule: Always call setsockopt(SO_REUSEADDR) before bind(). Setting it after bind has no effect on the current bind.

2. Two Sockets: Listening vs. Connected

A TCP server actually uses two different sockets:

The critical question is: what does the connected socket inherit from the listening socket?

3. What Is NOT Inherited by accept()

On Linux, the following are not inherited by the new socket returned from accept(). This is actually a good thing — it prevents unwanted behavior from leaking into client connections.

In simple terms: open file status flags (set via fcntl F_SETFL) and file descriptor flags (set via fcntl F_SETFD) are NOT inherited.

4. What IS Inherited by accept()

The new connected socket does inherit a copy of most socket options set via setsockopt(). This includes important options like:

So if you set TCP_NODELAY on the listening socket, every connected socket you get from accept() will also have TCP_NODELAY enabled. This saves you from calling setsockopt() again for each client.

5. Portability Issue and How to Handle It

The behavior described above is for Linux. On some other UNIX systems (like older BSD systems), O_NONBLOCK and O_ASYNC are inherited from the listening socket. This creates a portability trap.

Code: Making accept() Socket Non-Blocking (Portable Way)

#include <sys/socket.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>

/* Helper: set a socket to non-blocking mode */
static void set_nonblocking(int fd)
{
    int flags;

    flags = fcntl(fd, F_GETFL, 0);
    if (flags == -1) {
        perror("fcntl F_GETFL");
        exit(EXIT_FAILURE);
    }

    if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
        perror("fcntl F_SETFL O_NONBLOCK");
        exit(EXIT_FAILURE);
    }
}

int main(void)
{
    int listenfd, connfd;
    struct sockaddr_in client_addr;
    socklen_t addrlen = sizeof(client_addr);

    listenfd = socket(AF_INET, SOCK_STREAM, 0);
    /* ... bind(), listen() ... */

    connfd = accept(listenfd, (struct sockaddr *)&client_addr, &addrlen);
    if (connfd == -1) {
        perror("accept");
        exit(EXIT_FAILURE);
    }

    /*
     * Portability: explicitly set O_NONBLOCK on the connected socket.
     * On Linux, O_NONBLOCK is NOT inherited from the listening socket.
     * On some BSD systems, it IS inherited.
     * Explicit setting handles both cases correctly.
     */
    set_nonblocking(connfd);

    printf("Client connected, connfd=%d (non-blocking)\n", connfd);
    /* ... read()/write() on connfd ... */
    return 0;
}

Code: Making accept() Socket Close-on-Exec (Portable Way)

#include <sys/socket.h>
#include <fcntl.h>

/*
 * FD_CLOEXEC is also NOT inherited by the accept() socket on Linux.
 * If your server forks and execs child processes, you want connected
 * sockets to be closed automatically in the child's exec().
 * Set it explicitly after accept().
 */
int accept_cloexec(int listenfd)
{
    int connfd;
    struct sockaddr_storage client_addr;
    socklen_t addrlen = sizeof(client_addr);
    int flags;

    connfd = accept(listenfd, (struct sockaddr *)&client_addr, &addrlen);
    if (connfd == -1)
        return -1;

    /* Set close-on-exec flag on the new socket */
    flags = fcntl(connfd, F_GETFD, 0);
    if (flags == -1 || fcntl(connfd, F_SETFD, flags | FD_CLOEXEC) == -1) {
        close(connfd);
        return -1;
    }

    return connfd;
}

/*
 * Linux 2.6.28+ alternative: use accept4() which can set flags atomically.
 * This avoids a race condition between accept() and fcntl().
 */
int accept_cloexec_atomic(int listenfd)
{
    struct sockaddr_storage client_addr;
    socklen_t addrlen = sizeof(client_addr);

    /* SOCK_CLOEXEC sets FD_CLOEXEC atomically */
    return accept4(listenfd, (struct sockaddr *)&client_addr,
                   &addrlen, SOCK_CLOEXEC | SOCK_NONBLOCK);
}

Tip: On Linux, prefer accept4() with SOCK_NONBLOCK and/or SOCK_CLOEXEC flags. This sets both atomically, which avoids the tiny race window between accept() and the subsequent fcntl() call.

6. Summary: Inheritance Rules at a Glance

Interview Questions