C / C++ / 系统课时

处理 TCP 字节流边界

处理 TCP 字节流边界

TCP 只交付有序字节,不保留应用层一次 send 的边界。本课用长度前缀实现可复用的消息帧读取器,并说明粘包、拆包和半关闭时应该如何判断一条消息是否完整。

学习目标

  • 解释为什么一次 read 不能等同于一条 TCP 消息
  • 使用定长头和长度前缀可靠地重组消息
  • 正确区分完整消息、流结束与半关闭

TCP 只保证字节序列

发送端连续写入两条消息后,接收端可能一次读到两条,也可能把一条拆成多次返回。所谓“粘包”和“拆包”不是 TCP 异常,而是应用层没有直接可见的消息边界。程序必须把 read 看成“取得当前可用的一段字节”,再按自己的协议组帧。

TCP 消息帧在字节流中的拆分与重组

为消息建立可判定的边界

常见方案有三类。固定长度记录适合字段和尺寸恒定的协议;固定长度头 + 长度字段适合二进制协议和任意正文;分隔符适合文本协议,但必须定义转义、编码和最大行长,避免正文中的分隔符被误判。

长度前缀的关键不是“头有 4 字节”本身,而是接收端先完整读取头,再把长度转换成本机字节序,检查上限,最后循环读取恰好这么多正文。任何一步都不能假设单次 read 会返回请求的全部字节。

用长度前缀完整收发

下面的 Linux 示例用 socketpair 创建一条本地 SOCK_STREAM 连接,避免把注意力分散到地址配置。发送端依次写入两帧,然后只关闭写方向;接收端通过 read_exact 处理任意拆分方式,并在读完所有帧后观察 EOF。

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

#define MAX_FRAME 4096

static int write_all(int fd, const void *buf, size_t len) {
    const unsigned char *p = buf;
    size_t off = 0;
    while (off < len) {
        ssize_t n = write(fd, p + off, len - off);
        if (n < 0 && errno == EINTR) continue;
        if (n <= 0) return -1;
        off += (size_t)n;
    }
    return 0;
}

/* 返回 1 表示读满,0 表示尚未读取任何字节就遇到 EOF,-1 表示错误。 */
static int read_exact(int fd, void *buf, size_t len) {
    unsigned char *p = buf;
    size_t off = 0;
    while (off < len) {
        ssize_t n = read(fd, p + off, len - off);
        if (n < 0 && errno == EINTR) continue;
        if (n < 0) return -1;
        if (n == 0) {
            if (off == 0) return 0;
            errno = ECONNRESET;  /* 帧中途结束,协议数据不完整。 */
            return -1;
        }
        off += (size_t)n;
    }
    return 1;
}

static int send_frame(int fd, const char *text) {
    size_t len = strlen(text);
    if (len > MAX_FRAME) {
        errno = EMSGSIZE;
        return -1;
    }

    uint32_t net_len = htonl((uint32_t)len);
    if (write_all(fd, &net_len, sizeof(net_len)) < 0) return -1;
    return write_all(fd, text, len);
}

static int read_frame(int fd, char **out, size_t *out_len) {
    uint32_t net_len;
    int rc = read_exact(fd, &net_len, sizeof(net_len));
    if (rc <= 0) return rc;

    uint32_t len = ntohl(net_len);
    if (len > MAX_FRAME) {
        errno = EMSGSIZE;
        return -1;
    }

    char *buf = malloc((size_t)len + 1);
    if (!buf) return -1;

    rc = read_exact(fd, buf, len);
    if (rc != 1) {
        free(buf);
        if (rc == 0) errno = ECONNRESET;
        return -1;
    }

    buf[len] = '\0';
    *out = buf;
    *out_len = len;
    return 1;
}

int main(void) {
    int sv[2];
    if (socketpair(AF_UNIX, SOCK_STREAM, 0, sv) < 0) {
        perror("socketpair");
        return 1;
    }

    pid_t pid = fork();
    if (pid < 0) {
        perror("fork");
        return 1;
    }

    if (pid == 0) {
        close(sv[0]);
        if (send_frame(sv[1], "alpha") < 0 ||
            send_frame(sv[1], "beta-gamma") < 0 ||
            shutdown(sv[1], SHUT_WR) < 0) {
            _exit(2);
        }

        /* 保持读方向打开,直到父进程关闭它的连接端。 */
        char sink;
        while (read(sv[1], &sink, 1) < 0 && errno == EINTR) {}
        close(sv[1]);
        _exit(0);
    }

    close(sv[1]);
    for (;;) {
        char *frame = NULL;
        size_t len = 0;
        int rc = read_frame(sv[0], &frame, &len);
        if (rc == 0) {
            puts("peer half-closed write side");
            break;
        }
        if (rc < 0) {
            perror("read_frame");
            close(sv[0]);
            return 1;
        }
        printf("frame(len=%zu): %s\n", len, frame);
        free(frame);
    }

    close(sv[0]);
    waitpid(pid, NULL, 0);
    return 0;
}

编译并运行:

bash
gcc -Wall -Wextra -O2 tcp_frame.c -o tcp_frame
./tcp_frame

预期输出:

text
frame(len=5): alpha
frame(len=10): beta-gamma
peer half-closed write side

即使内核把头和正文拆成多次返回,或者把连续两帧一次交付给接收缓冲区,输出仍应保持两条独立消息。

正确解释半关闭和 EOF

shutdown(fd, SHUT_WR) 表示本端不再发送新字节,内核会在已经排队的数据之后发送 FIN。对端只有在前面的字节全部读取完后,read 才返回 0;与此同时,对端仍可继续向另一个方向发送数据,所以半关闭不等于连接立刻消失。

不要把 EOF 当作长期连接中“每条消息的结束符”。EOF 更适合表示整个字节流结束,例如一次性上传完成。对于需要在同一连接上传输多条请求和响应的协议,应持续使用长度、定长记录或分隔符确定单条消息边界。

如果长度头已经读到、正文却在达到声明长度前遇到 EOF,这不是一条较短的合法消息,而是截断帧。生产代码应记录协议错误并关闭连接;若协议允许超大正文,还应把“最大帧长、读取超时、内存策略”一并纳入边界设计。

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

目录与阅读设置

阅读设置

17

记录一个想法

处理 TCP 字节流边界

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

登录哪都通