C / C++ / 系统课时

编写 TCP 服务端

编写 TCP 服务端

本课实现一个最小但完整的 Linux TCP 服务端:创建监听套接字,设置地址复用,完成 bind、listen、accept,读取客户端请求并返回响应,同时明确监听描述符与已连接描述符各自的生命周期。

学习目标

  • 使用 bind、listen、accept 建立 TCP 服务端监听链路
  • 区分监听套接字与 accept 返回的已连接套接字
  • 理解 SO_REUSEADDR、监听队列和连接关闭的实际边界

从监听到已连接套接字

服务端先用 socket 创建监听套接字,bind 把它绑定到本地 IP 与端口,listen 将其转为被动监听状态。之后每次 accept 成功都会返回一个新的文件描述符:监听描述符继续接收后续连接,而新描述符只负责当前客户端的数据收发。

TCP 服务端监听与连接生命周期

这一区分决定了关闭行为:关闭某个已连接描述符只结束那条连接;关闭监听描述符才会停止接受新连接。把两者混为一个描述符,是初学服务端最常见的生命周期错误之一。

配置地址并开始监听

SO_REUSEADDR 应在 bind 前设置,它主要帮助服务端在重启时更快重新绑定先前使用过的本地地址。它不等价于“允许两个普通进程同时监听完全相同的地址和端口”;需要多进程分担同一端口时,应另外理解 Linux 的 SO_REUSEPORT。

listen(fd, 128) 中的 128 是 backlog 提示值,用来约束等待应用 accept 的已完成连接队列规模,实际值还会受内核上限影响。backlog 不是“最大并发连接数”,已被 accept 取出的连接不再占用这条等待队列。

实现单连接服务端

下面的服务端绑定到 127.0.0.1:18080,只接受一个客户端,读取直到客户端半关闭写方向,然后返回 pong 并退出。这样代码足够短,同时能完整展示监听套接字和连接套接字的责任边界。

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

static int send_all(int fd, const char *buf, size_t len) {
    size_t sent = 0;
    while (sent < len) {
        ssize_t n = send(fd, buf + sent, len - sent, MSG_NOSIGNAL);
        if (n > 0) {
            sent += (size_t)n;
            continue;
        }
        if (n == -1 && errno == EINTR) {
            continue;
        }
        return -1;
    }
    return 0;
}

int main(void) {
    int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (listen_fd == -1) {
        perror("socket");
        return 1;
    }

    int one = 1;
    if (setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR,
                   &one, sizeof(one)) == -1) {
        perror("setsockopt");
        close(listen_fd);
        return 1;
    }

    struct sockaddr_in local = {
        .sin_family = AF_INET,
        .sin_port = htons(18080)
    };
    local.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

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

    if (listen(listen_fd, 128) == -1) {
        perror("listen");
        close(listen_fd);
        return 1;
    }

    printf("listening on 127.0.0.1:18080\n");
    fflush(stdout);

    struct sockaddr_in peer;
    socklen_t peer_len = sizeof(peer);
    int conn_fd;
    do {
        conn_fd = accept(listen_fd, (struct sockaddr *)&peer, &peer_len);
    } while (conn_fd == -1 && errno == EINTR);

    if (conn_fd == -1) {
        perror("accept");
        close(listen_fd);
        return 1;
    }

    char peer_ip[INET_ADDRSTRLEN];
    if (inet_ntop(AF_INET, &peer.sin_addr, peer_ip,
                  sizeof(peer_ip)) == NULL) {
        strcpy(peer_ip, "<IP>");
    }
    printf("accepted %s:%u\n", peer_ip, ntohs(peer.sin_port));

    char request[4096];
    size_t used = 0;
    for (;;) {
        ssize_t n = recv(conn_fd, request + used,
                         sizeof(request) - 1 - used, 0);
        if (n > 0) {
            used += (size_t)n;
            if (used == sizeof(request) - 1) {
                fprintf(stderr, "request too large\n");
                close(conn_fd);
                close(listen_fd);
                return 1;
            }
            continue;
        }
        if (n == 0) {
            break;
        }
        if (errno == EINTR) {
            continue;
        }

        perror("recv");
        close(conn_fd);
        close(listen_fd);
        return 1;
    }

    request[used] = '\0';
    printf("request: %s", request);

    const char response[] = "pong\n";
    if (send_all(conn_fd, response, sizeof(response) - 1) == -1) {
        perror("send");
        close(conn_fd);
        close(listen_fd);
        return 1;
    }

    close(conn_fd);
    printf("connection closed\n");
    close(listen_fd);
    return 0;
}

编译后让服务端后台运行,再用 python3 充当一次性客户端。客户端发送完请求后调用半关闭,服务端因此能收到 EOF 并返回响应:

bash
gcc -Wall -Wextra -O2 tcp_server.c -o tcp_server
./tcp_server >server.log 2>&1 &
SERVER_PID=$!
until grep -q '^listening on 127.0.0.1:18080$' server.log; do
    if ! kill -0 "$SERVER_PID" 2>/dev/null; then
        cat server.log
        exit 1
    fi
    sleep 0.01
done
python3 -c 'import socket; s=socket.create_connection(("127.0.0.1",18080)); s.sendall(b"ping\n"); s.shutdown(socket.SHUT_WR); print(s.recv(1024).decode(), end=""); s.close()'
wait "$SERVER_PID"
cat server.log
rm -f server.log

预期输出

text
pong
listening on 127.0.0.1:18080
accepted 127.0.0.1:<PORT>
request: ping
connection closed

<PORT> 是客户端临时端口,每次运行都可能不同。若 18080 已被其他程序占用,bind 会失败并报告 Address already in use;可先更换端口,或确认旧服务端是否仍在运行。

理解监听队列与并发边界

listen 只让内核开始为该套接字维护连接等待队列,并不会自动替应用处理请求。当前示例在一次 accept 后同步处理一个连接,所以第二个客户端即使完成握手,也可能继续在队列中等待应用再次调用 accept。

要支持多个并发客户端,可以在循环中持续 accept,再把已连接描述符交给进程、线程或 epoll 驱动的事件循环。无论采用哪种并发模型,都应尽快回到 accept,避免应用处理速度长期落后于新连接到达速度。

关闭连接时避免协议死锁

示例以 EOF 作为“请求结束”标志,因此测试客户端必须执行 shutdown(SHUT_WR)。如果客户端发送 ping 后一直等待响应却不半关闭,而服务端又一直等 EOF,双方就会互相等待。这个问题不是 TCP 故障,而是应用层消息边界没有定义清楚。

生产协议通常使用长度前缀、分隔符、固定长度或更高层协议来界定一条消息,并为读写设置超时。监听套接字负责接入,连接套接字负责会话;把这两个生命周期分开管理,是后续实现并发服务端、优雅停机和资源回收的基础。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

编写 TCP 服务端

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通