The kernel maintains a TCP endpoint for each end of a TCP connection. This endpoint contains all the state needed to manage the connection. When we say “a TCP socket,” what we really mean is the combination of the application’s file descriptor (sockfd) and the underlying TCP endpoint maintained by the kernel.

The TCP endpoint’s state information includes send and receive buffers, sequence numbers, acknowledgment numbers, window sizes for flow control, and the current connection state (SYN_SENT, ESTABLISHED, FIN_WAIT, etc.).

Before any data is exchanged, TCP establishes a connection using a three-way handshake. This ensures both sides are ready to communicate and synchronizes sequence numbers:

The three steps: SYN (client initiates), SYN-ACK (server acknowledges and sends its own SYN), ACK (client acknowledges server’s SYN). After this, both sides are in the ESTABLISHED state and can exchange data.

Each TCP endpoint maintains two buffers in the kernel:

Why the send buffer holds data until ACKed: If the peer does not acknowledge a segment, TCP needs to retransmit it. Once an ACK is received for data in the send buffer, that data can be freed. This is the foundation of TCP’s reliable delivery guarantee.

Since TCP is full-duplex, each direction of data flow must be closed independently. Closing a TCP connection uses a 4-way exchange of FIN and ACK segments:

The TIME_WAIT state on the active closer lasts for 2 × MSL (Maximum Segment Lifetime, typically 60 seconds each = 2 minutes total). This ensures delayed packets from the old connection don’t confuse a new connection on the same port pair.

TCP Echo Server

/* tcp_echo_server.c */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define PORT    8080
#define BUFSIZE 1024

int main() {
    int listen_fd, conn_fd;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_len = sizeof(client_addr);
    char buf[BUFSIZE];
    ssize_t n;

    /*
     * Step 1: Create a TCP (SOCK_STREAM) socket.
     * The kernel allocates send and receive buffers
     * for this endpoint.
     */
    listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (listen_fd == -1) { perror("socket"); return 1; }

    /* Allow immediate reuse of port after server restarts */
    int opt = 1;
    setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    /* Step 2: Bind to IP and port */
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family      = AF_INET;
    server_addr.sin_port        = htons(PORT);
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);

    if (bind(listen_fd, (struct sockaddr *)&server_addr,
             sizeof(server_addr)) == -1) {
        perror("bind"); return 1;
    }

    /*
     * Step 3: Mark socket as passive (listening).
     * backlog=5: up to 5 pending connections can queue
     * waiting for accept() before the kernel starts
     * refusing new connection requests.
     */
    if (listen(listen_fd, 5) == -1) { perror("listen"); return 1; }
    printf("TCP echo server listening on port %d\n", PORT);

    for (;;) {
        /*
         * Step 4: accept() blocks until a client completes
         * the 3-way handshake. Returns a NEW socket descriptor
         * for this specific connection. listen_fd remains open
         * for future connections.
         */
        conn_fd = accept(listen_fd,
                         (struct sockaddr *)&client_addr,
                         &client_len);
        if (conn_fd == -1) { perror("accept"); continue; }

        printf("Client connected: %s:%d\n",
               inet_ntoa(client_addr.sin_addr),
               ntohs(client_addr.sin_port));

        /*
         * Step 5: Read data from the connection and echo it back.
         * TCP is a byte stream — recv() may return fewer bytes
         * than the sender sent in one call. Keep reading until
         * the client closes the connection (recv returns 0).
         */
        while ((n = recv(conn_fd, buf, BUFSIZE, 0)) > 0) {
            /* Echo all received bytes back */
            send(conn_fd, buf, n, 0);
        }

        if (n == 0)
            printf("Client disconnected\n");
        else
            perror("recv");

        close(conn_fd);  /* Close this connection's socket */
    }

    close(listen_fd);
    return 0;
}

TCP Echo Client

/* tcp_echo_client.c */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define SERVER_IP  "127.0.0.1"
#define PORT       8080
#define BUFSIZE    1024

int main() {
    int sockfd;
    struct sockaddr_in server_addr;
    char send_buf[] = "Hello from TCP client!";
    char recv_buf[BUFSIZE];
    ssize_t n;

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

    /* Step 2: Fill in server address */
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port   = htons(PORT);
    inet_pton(AF_INET, SERVER_IP, &server_addr.sin_addr);

    /*
     * Step 3: connect() triggers the 3-way handshake.
     * Blocks until ESTABLISHED or error.
     * OS assigns an ephemeral source port automatically.
     */
    if (connect(sockfd, (struct sockaddr *)&server_addr,
                sizeof(server_addr)) == -1) {
        perror("connect"); return 1;
    }
    printf("Connected to server\n");

    /* Step 4: Send data */
    n = send(sockfd, send_buf, strlen(send_buf), 0);
    printf("Sent %zd bytes: %s\n", n, send_buf);

    /*
     * Step 5: Receive echo.
     * TCP byte-stream: recv() might not return all bytes at once.
     * For a robust client, loop until expected bytes received.
     */
    n = recv(sockfd, recv_buf, BUFSIZE - 1, 0);
    if (n > 0) {
        recv_buf[n] = '\0';
        printf("Echo received: %s\n", recv_buf);
    }

    /*
     * Step 6: close() sends FIN to server, starting
     * the 4-way connection termination sequence.
     */
    close(sockfd);
    return 0;
}

TCP vs UDP — Function Usage Summary