Recall from Part 1 that the final step of TCP termination is the active closer sending an ACK for the passive closer’s FIN. What if that ACK gets lost?

Why 2MSL? One MSL covers the time for the final ACK to reach the server. A second MSL covers the time for the retransmitted FIN to come back, if the ACK was lost. Total: 2 × MSL.

TCP retransmission means that duplicate copies of segments can exist in the network at any time. These duplicates can arrive late — even after the connection has closed.

What is MSL exactly? The Maximum Segment Lifetime (MSL) is the estimated maximum time a TCP/IP segment can survive in the network before being discarded. IP packets have an 8-bit TTL (Time-To-Live) field that decrements at each router hop. When TTL reaches 0, the packet is dropped. MSL is the time estimate for a packet to exceed 255 hops. In practice, BSD and Linux use 30 seconds for MSL. RFC 1122 suggests 2 minutes.

The most common complaint about TIME_WAIT among developers: you restart your server and get bind(): Address already in use (EADDRINUSE).

This happens because the previous server process initiated a connection close, entered TIME_WAIT for that port, and the 60-second timer has not expired yet. The new server cannot bind the same port.

/* Demonstrating the EADDRINUSE problem */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <errno.h>

#define PORT 9090

int create_server_socket(int use_reuse_addr) {
    int sock_fd;
    struct sockaddr_in addr;

    sock_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (sock_fd < 0) {
        perror("socket");
        return -1;
    }

    if (use_reuse_addr) {
        /*
         * SO_REUSEADDR: allows binding even if port is in TIME_WAIT.
         * This is safe because TIME_WAIT still protects against stale
         * duplicates — the OS ensures the sequence numbers won't collide.
         * This is the CORRECT FIX for EADDRINUSE on server restart.
         */
        int opt = 1;
        if (setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR,
                       &opt, sizeof(opt)) < 0) {
            perror("setsockopt SO_REUSEADDR");
            close(sock_fd);
            return -1;
        }
        printf("SO_REUSEADDR enabled.\n");
    }

    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(PORT);
    addr.sin_addr.s_addr = INADDR_ANY;

    if (bind(sock_fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        if (errno == EADDRINUSE) {
            printf("bind() FAILED: EADDRINUSE — port %d in TIME_WAIT!\n",
                   PORT);
            printf("Solution: set SO_REUSEADDR before bind()\n");
        } else {
            perror("bind");
        }
        close(sock_fd);
        return -1;
    }

    printf("bind() SUCCESS on port %d\n", PORT);
    return sock_fd;
}

int main() {
    int fd;

    printf("=== Without SO_REUSEADDR ===\n");
    fd = create_server_socket(0); /* May fail with EADDRINUSE */
    if (fd > 0) close(fd);

    printf("\n=== With SO_REUSEADDR ===\n");
    fd = create_server_socket(1); /* Should succeed */
    if (fd > 0) {
        listen(fd, 5);
        printf("Server is listening. Press Ctrl+C to stop.\n");
        /* Normally you would call accept() here */
        close(fd);
    }

    return 0;
}

Best practice: Always set SO_REUSEADDR on TCP server sockets before calling bind(). This is safe — it does not disable TIME_WAIT’s protections. It only allows rebinding a port that is in TIME_WAIT, and the kernel ensures that old sequence numbers from the TIME_WAIT connection cannot be confused with the new connection.

int sock_fd = socket(AF_INET, SOCK_STREAM, 0);
int opt = 1;
/* ALWAYS do this before bind() */
setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
bind(sock_fd, ...);
listen(sock_fd, SOMAXCONN);

You can see TIME_WAIT connections using netstat or ss:

# Show all TCP connections including TIME_WAIT
netstat -tn | grep TIME_WAIT

# Using ss (newer tool, faster than netstat)
ss -tan state time-wait

# Count how many TIME_WAIT connections exist
netstat -tn | grep TIME_WAIT | wc -l

# Example output you might see:
# tcp  0  0  127.0.0.1:9090  127.0.0.1:54321  TIME_WAIT

On a busy web server, hundreds or thousands of TIME_WAIT connections are normal and expected. Each represents a recently closed HTTP connection where this server was the active closer.

Developers frustrated with EADDRINUSE sometimes try to eliminate TIME_WAIT using socket options or kernel tuning (like tcp_tw_recycle on old Linux kernels). This is dangerous: