TCP 服务端比 UDP 多两个调用:listen 和 accept。这两个调用经常被理解成"开始监听"和"建立连接",但连接并不是 accept 建立的——三次握手在 listen 之后由内核自动完成,accept 只是从队列里取一个已经建好的连接。

五个调用各自改了什么

int socket(int domain, int type, int protocol);                      /* 创建套接字 */
int bind(int sockfd, const struct sockaddr *addr, socklen_t len);    /* 绑定本地地址 */
int listen(int sockfd, int backlog);                                 /* 转入监听 */
int accept(int sockfd, struct sockaddr *addr, socklen_t *len);       /* 取出一个连接 */
int connect(int sockfd, const struct sockaddr *addr, socklen_t len); /* 发起连接 */

TCP 的 socket 参数是 AF_INET、SOCK_STREAM、0。它返回的 fd 和 UDP 一样是文件描述符,但此时还只是个"套接字壳子",既没有地址也没有连接。

bind 的填法和 UDP 完全一致:清零结构体、sin_family = AF_INET、sin_port = htons(port)、sin_addr.s_addr = htonl(INADDR_ANY)、第三个参数 sizeof(local)。INADDR_ANY 是全零,htonl 转不转结果都一样,写 htonl 只是让"这个值要进网络"的意图更明确。服务端必须 bind 一个固定端口,否则内核每次启动分配的端口都不同,客户端没法找;客户端不必 bind,connect 时会由内核选源地址和临时端口——显式 bind 固定端口反而会让同一台机器上第二个客户端起不来。

listen 做了两件事:把套接字从"可 bind 的普通套接字"变成监听套接字,并让内核开始对这个地址端口上的 SYN 做应答。它不建立连接,只决定"这个门口排队排多长";成功返回 0,失败返回 -1。

accept 从已完成连接的队列里取出一个,返回一个新的 fd。队列为空时它就阻塞,直到有连接完成握手;这也是顺序服务端"卡住"的直接原因。失败时返回 -1,典型原因是进程被信号打断(EINTR)或监听 fd 已经关掉。监听 fd 只负责收连接,新 fd 才是这条连接的读写句柄;一个服务端可以有很多个新 fd,但监听 fd 始终只有一个。addr 是输出参数,返回对端地址;不关心就传 NULL。addrlen 又是 value-result:传入缓冲区大小,传出实际长度。

connect 的参数形式与 bind 一样,区别只在语义:bind 给的是自己的地址,connect 给的是对方的地址。它阻塞到握手完成或失败,成功返回 0,失败返回 -1,常见错误码是 ECONNREFUSED(端口没人监听)和 ETIMEDOUT(SYN 没有回应)。

setsockopt 的第三个参数是选项名,不是位掩码

课件的服务端写了这样一行:

setsockopt(_listensock, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt));

这行设不上 SO_REUSEADDR。setsockopt 的第三个参数是单个 optname,不是可以按位或的标志集合。Linux 上 SO_REUSEADDR 的值是 2,SO_REUSEPORT 是 15,2 | 15 还是 15,于是最终生效的只有 SO_REUSEPORT。

后果很具体:SO_REUSEADDR 的作用是允许在端口处于 TIME_WAIT 时重新 bind,这正是重启服务端最需要的行为;只设上 SO_REUSEPORT 时,旧连接还留在 TIME_WAIT,重启仍可能拿到 EADDRINUSE(errno 98)。正确写法是两次调用:

int opt = 1;
setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
setsockopt(listenfd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));   /* 需要时再加 */

SO_REUSEPORT 是另一件事:允许多个套接字绑同一个端口,由内核在它们之间分流,通常用于多进程负载均衡。不需要多进程共享端口时,别顺手加上。

三次握手对应到哪几个调用

时刻客户端状态服务端状态
socket() 之后CLOSEDCLOSED
bind() + listen()—LISTEN
connect() 发出 SYNSYN_SENT收到 SYN,回 SYN+ACK,进入 SYN_RECV
客户端收到 SYN+ACK,回 ACKESTABLISHED,connect 返回收到 ACK,进入 ESTABLISHED,连接被放进已完成队列
accept()—从已完成队列取出,返回新 fd

这张表里最容易被忽略的是最后两行的时间差。connect 返回成功时,服务端可能一行 accept 都还没执行,连接照样已经建立并排在队列里。客户端的 send 可以把数据发出去,这些数据躺在这条连接的接收缓冲区里,等 accept 取出 fd 之后才读得到。

accept 之前还有一个队列:只收到 SYN、还没完成握手的连接,在 SYN 队列里;三次握手完成、等着被 accept 的连接,在已完成队列(accept queue)里。

课件对 listen 的说明是"最多允许有 backlog 个客户端处于连接等待状态,如果接收到更多的连接请求就忽略,一般设为 5"。这里要拆成两句:

  • backlog 不是"最大连接数"。它只限制已握手完成、还没被 accept 取走的队列长度。已经 accept 的连接不占这个名额,所以一个 backlog 为 5 的服务端可以同时维持几百条连接——只要 accept 循环跟得上。Linux 的 listen(2) 手册写明,自 2.2 起 backlog 指定的是已完成队列长度;未完成队列的上限由 /proc/sys/net/ipv4/tcp_max_syn_backlog 控制。
  • "更多就忽略"也不准确。队列满时,内核对新连接的处理取决于 tcp_abort_on_overflow 等设置:默认既不接受也不明确拒绝,客户端通常看到重传后超时,而不是立刻收到一个"拒绝"。

backlog 写 5 在今天偏小,常见服务端用 128 或 512;它的上限受 somaxconn 约束。

一个能跑的回显服务端和客户端

/* tcp_echo_server.c: gcc tcp_echo_server.c -o tcp_echo_server */
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
 
#define BUF_SIZE 1024
 
static void service(int fd)
{
    char buf[BUF_SIZE];
 
    for (;;) {
        ssize_t n = read(fd, buf, sizeof(buf) - 1);
        if (n > 0) {
            buf[n] = '\0';
            printf("client say# %s\n", buf);
            if (write(fd, buf, (size_t)n) < 0) {
                perror("write");
                break;
            }
        } else if (n == 0) {
            printf("client quit\n");
            break;
        } else {
            if (errno == EINTR)
                continue;
            perror("read");
            break;
        }
    }
}
 
int main(int argc, char *argv[])
{
    if (argc != 2) {
        fprintf(stderr, "usage: %s port\n", argv[0]);
        return 1;
    }
    uint16_t port = (uint16_t)strtoul(argv[1], NULL, 10);
 
    signal(SIGPIPE, SIG_IGN);
 
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if (listenfd < 0) {
        perror("socket");
        return 1;
    }
 
    int opt = 1;
    if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
        perror("setsockopt");
        close(listenfd);
        return 1;
    }
 
    struct sockaddr_in local;
    memset(&local, 0, sizeof(local));
    local.sin_family = AF_INET;
    local.sin_port = htons(port);
    local.sin_addr.s_addr = htonl(INADDR_ANY);
 
    if (bind(listenfd, (struct sockaddr *)&local, sizeof(local)) < 0) {
        perror("bind");
        close(listenfd);
        return 1;
    }
 
    if (listen(listenfd, 128) < 0) {
        perror("listen");
        close(listenfd);
        return 1;
    }
    printf("tcp echo server on port %u\n", (unsigned)port);
 
    for (;;) {
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        int fd = accept(listenfd, (struct sockaddr *)&peer, &len);
        if (fd < 0) {
            if (errno == EINTR)
                continue;
            perror("accept");
            break;
        }
 
        char ip[INET_ADDRSTRLEN];
        inet_ntop(AF_INET, &peer.sin_addr, ip, sizeof(ip));
        printf("accept %s:%u, fd=%d\n",
               ip, (unsigned)ntohs(peer.sin_port), fd);
 
        service(fd);
        close(fd);
    }
 
    close(listenfd);
    return 0;
}

读返回值的三种情况必须分开处理:n > 0 是数据,n == 0 是对端发了 FIN(TCP 里的"文件结尾"),n < 0 才是错误。EINTR 要重试,其余错误直接放弃这条连接。

客户端:

/* tcp_echo_client.c: gcc tcp_echo_client.c -o tcp_echo_client */
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
 
int main(int argc, char *argv[])
{
    if (argc != 3) {
        fprintf(stderr, "usage: %s server_ip server_port\n", argv[0]);
        return 1;
    }
 
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    if (fd < 0) {
        perror("socket");
        return 1;
    }
 
    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons((uint16_t)strtoul(argv[2], NULL, 10));
    if (inet_pton(AF_INET, argv[1], &server.sin_addr) != 1) {
        fprintf(stderr, "bad ip: %s\n", argv[1]);
        close(fd);
        return 1;
    }
 
    if (connect(fd, (struct sockaddr *)&server, sizeof(server)) < 0) {
        perror("connect");
        close(fd);
        return 1;
    }
 
    char line[1024];
    while (fgets(line, sizeof(line), stdin) != NULL) {
        size_t n = strlen(line);
        if (n > 0 && line[n - 1] == '\n')
            line[--n] = '\0';
        if (n == 0)
            continue;
 
        if (write(fd, line, n) < 0) {
            perror("write");
            break;
        }
 
        char buf[1024];
        ssize_t m = read(fd, buf, sizeof(buf) - 1);
        if (m > 0) {
            buf[m] = '\0';
            printf("echo# %s\n", buf);
        } else if (m == 0) {
            printf("server closed\n");
            break;
        } else {
            perror("read");
            break;
        }
    }
 
    close(fd);
    return 0;
}

客户端 connect 成功后就用同一个 fd 读写,不会再产生新 fd;新 fd 只出现在服务端的 accept 返回值里。

read/write 和 send/recv 在 Linux 上都能用于套接字:read 等价于不带 flags 的 recv,write 等价于不带 flags 的 send。区别在于后两个能带选项——MSG_DONTWAIT 让这一次调用非阻塞,MSG_PEEK 只看数据不从缓冲区取走,MSG_NOSIGNAL 让这一次写入不产生 SIGPIPE。课件两种写法都用了,功能一样;判断 EOF 时也都要看返回值 0。

写方向还有一个容易漏的点:write 和 send 的返回值是实际写入的字节数,可能小于请求长度。内核发送缓冲区快满时,它只收下一部分就返回;非阻塞模式下更常见。小报文通常一次写完,大报文和慢速对端必须循环补齐剩下的部分,不能把"返回了正数"当成"全部发出去了"。

监听 fd 和连接 fd 是两个独立对象,在 ss -tnp 里会同时出现:一行是 LISTEN,本地地址是监听端口;另一行是 ESTABLISHED,本地地址和远端地址构成一个四元组。连接结束只 close 新 fd,监听 fd 要活到进程退出;提前关掉监听 fd,后续客户端 connect 会收到 RST,而不是排队等待。

为什么第二个客户端连上了却不回话

先起服务端,再开两个客户端,第二个客户端敲字后没有任何回显。这不是 listen 的 backlog 太小,也不是第二个连接没建立——它的握手同样完成了,正躺在 accept queue 里。

原因是服务端只有一条执行线:accept 返回后进入 service(fd) 的 for (;;),一直读到第一个客户端关闭;只要那个人不说话也不退出,accept 就永远轮不到第二次调用。第二个客户端的数据已经在内核缓冲区里,但没人去读。

这个现象说明三件事:握手与 accept 是两个阶段;backlog 兜住的是"已完成但没人取"的连接;一个连接一个执行单元,才能同时服务多个客户端。后面的多进程、多线程、线程池都是在补最后一条。

多进程与多线程:一个连接一个执行单元

最直接的并行化是每个连接一个进程。子进程继承父进程的全部 fd,所以必须先把监听 fd 关掉,否则子进程也会拿着它,影响后续资源回收。

/* 需要 <sys/wait.h>、<unistd.h>,与前面的 service() 一起使用 */
static void process_connection(int listenfd, int fd)
{
    pid_t id = fork();
    if (id < 0) {
        perror("fork");
        close(fd);
        return;
    }
    if (id == 0) {
        close(listenfd);
        if (fork() > 0)
            _exit(0);          /* 中间这一层立刻退出,孙子进程被 init 领养 */
        service(fd);
        close(fd);
        _exit(0);
    }
    close(fd);
    waitpid(id, NULL, 0);
}

两次 fork 是为了省掉父进程的 wait。子进程再 fork 出一个孙子进程后自己退出,服务连接的是孙子;孙子成了孤儿,由系统接管,父进程 waitpid 只等那个立刻退出的子进程,不会一直挂着。父进程同时关掉 fd,因为这条连接已经交给孙子,多留一份引用只会让端口晚一点释放。

代价也明显:每个连接一个进程,进程创建的开销和内存占用都不小,几百个连接就撑不住了。

线程版:一个连接一个线程

线程版把 service 挪进线程入口。参数要 heap 分配,因为 pthread_create 的 void * 只能传一个指针,栈上的局部变量在循环下一轮就被覆盖了。

/* 需要 <pthread.h>、<stdlib.h> */
struct thread_data {
    int fd;
    struct sockaddr_in peer;
};
 
static void *thread_routine(void *arg)
{
    struct thread_data *td = (struct thread_data *)arg;
 
    pthread_detach(pthread_self());
    service(td->fd);
    close(td->fd);
    free(td);
    return NULL;
}
 
static void process_connection_thread(int fd, const struct sockaddr_in *peer)
{
    pthread_t tid;
    struct thread_data *td = malloc(sizeof(*td));
    if (td == NULL) {
        close(fd);
        return;
    }
    td->fd = fd;
    td->peer = *peer;
 
    int ret = pthread_create(&tid, NULL, thread_routine, td);
    if (ret != 0) {
        fprintf(stderr, "pthread_create: %d\n", ret);
        close(fd);
        free(td);
    }
}

pthread_detach(pthread_self()) 让线程结束后自动回收资源,主线程不需要 join。main 的 accept 循环里把 service(fd); close(fd); 换成 process_connection_thread(fd, &peer); 即可。注意这里不再由主线程 close(fd)——fd 已经属于新线程,主线程关掉会让它读到无效 fd。

线程比进程轻,但"一连接一线程"仍然把线程数绑在连接数上。连接上万时,栈空间和调度开销都成了问题。

线程池与远程命令执行

线程池版本把连接包成一个 std::function<void()> 任务丢进队列:

using func_t = std::function<void()>;
func_t func = std::bind(&TcpServer::Service, this, sockfd, addr);
ThreadPool<func_t>::GetInstance()->Push(func);

课件在这行旁边注了"这里不能 auto"。原因是 ThreadPool 的模板参数被写死成 func_t,std::bind 返回的是一个未指定类型的函数对象,用 auto 推出来的类型和 func_t 不是同一个;显式声明成 func_t,bind 的结果才会被转换成 std::function。另外 std::bind 会复制参数,addr 和 sockfd 都被复制进任务对象,任务执行时局部变量早已失效也没关系。

同一个多线程框架加一个命令执行业务,就是课件里的远程命令:

  • 业务类持有连接 fd,用 popen(command, "r") 起一个子 shell 读命令输出,读完 pclose 回收子进程;
  • 只允许白名单里的命令(ls、pwd、whoami 之类),否则等于把 shell 送给网络上的任何人;
  • 有的命令没有输出(touch),SendCommand 里补一个 "done",否则客户端收到 0 字节,会以为服务端没响应。

它同时也埋了后面要处理的问题:服务端只调一次 recv 就把收到的内容当完整命令,客户端两次 send 可能被合并成一次读,一条长命令也可能被拆成两次读。TCP 是字节流,没有报文边界,这就是粘包。命令结果一次 send 发回去、客户端一次 recv 收,同样可能只收到前半段。

对端先关,SIGPIPE 会把进程带走

回显服务端写回数据用的是 write。如果客户端在发送之后立刻关掉,服务端某个时刻的 write 会遇到一个已经收到 RST 的连接,内核给进程发 SIGPIPE。这个信号的默认动作是终止进程——单进程服务端会整个退出,而报错信息一行都没有;多进程版本里只是当前子进程死掉,主进程还活着,所以这个 bug 在多进程版本里更不容易被发现。

处理方式有两种,选一种即可:

signal(SIGPIPE, SIG_IGN);                                  /* 进程级:忽略,write 返回 -1/EPIPE */
write(fd, buf, n);                                          /* 此时按普通错误处理 */
 
ssize_t m = send(fd, buf, n, MSG_NOSIGNAL);                 /* 单次调用级:只对这一次 send 生效 */

服务端在 main 开头忽略 SIGPIPE,把 write 的 -1 当作"这条连接没了",close 之后继续 accept,是最省事的做法。

关闭本身也有成本。close(fd) 会让这一侧发出 FIN,进入四次挥手;主动关闭的一方最后要停在 TIME_WAIT,等 2MSL(Linux 上约 60 秒)才真正释放这个四元组。这段时间内重新 bind 同一个端口,就会碰上 EADDRINUSE——这也正是前面必须单独设 SO_REUSEADDR 的原因。

两个容易混淆的错误状态:read 返回 0 是对端正常关闭,read 返回 -1 且 errno == ECONNRESET 是对端发了 RST(比如进程被杀、或往已关闭的连接继续写)。前者可以安静地关掉,后者通常意味着对端已经不告而别。