C / C++ / 系统课时

设计简单的消息边界协议

设计简单的消息边界协议

TCP 只保证按顺序传递字节,不会保留应用层“第几条消息”的边界。本篇用 4 字节长度头定义一个最小分帧协议,并实现循环收发,让接收端能够从任意拆分或合并的字节流中恢复完整消息。

学习目标

  • 解释为什么一次 send 不一定对应一次 recv
  • 设计“长度头 + 消息体”的应用层帧格式
  • 用循环读取正确处理短读、EOF 和异常长度

TCP 为什么需要应用层分帧

SOCK_STREAM 提供的是连续字节流。发送方连续发送 hello 和 world,接收方可能一次读到两者,也可能先读到 he、再读到剩余字节。TCP 不承诺应用层调用边界,因此不能把“一次 recv 返回”直接当成“一条消息”。

如果协议没有边界规则,接收端就无法可靠判断一条消息何时结束。常见方案有固定长度、分隔符和长度头。对二进制数据或内容本身可能包含任意字节的场景,长度头通常最直接。

长度头协议在 TCP 字节流中的组装过程

定义一个最小长度头协议

这里约定每帧前 4 字节是无符号 32 位整数,表示消息体字节数,并使用网络字节序传输。接收端先完整读取头部,再根据长度读取消息体。

协议可以抽象为:

[4 字节 payload_length][payload_length 字节 payload]

必须同时给消息长度设置上限。否则恶意或损坏的数据可以声明一个极大的长度,诱导程序分配过多内存。下面示例把单帧限制为 1 MiB。

实现循环读取与组帧

下面的完整程序用 socketpair 创建本地流式套接字,方便稳定演示 TCP 同类的字节流行为;send_frame 和 recv_frame 接收的都是已连接流式 socket 文件描述符,换成 TCP accept 或 connect 得到的 fd 后逻辑不变。

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 <unistd.h>

#define MAX_FRAME_SIZE (1024U * 1024U)

static int write_all(int fd, const void *buf, size_t len) {
    const unsigned char *p = buf;
    // 流式 socket 允许短写,因此循环直到全部字节送出。
    while (len > 0) {
        ssize_t n = send(fd, p, len, 0);
        if (n < 0) {
            if (errno == EINTR) continue;
            return -1;
        }
        if (n == 0) return -1;
        p += (size_t)n;
        len -= (size_t)n;
    }
    return 0;
}

static int read_all(int fd, void *buf, size_t len) {
    unsigned char *p = buf;
    // recv 返回 0 表示对端已关闭,不能把未完成的帧当成成功消息。
    while (len > 0) {
        ssize_t n = recv(fd, p, len, 0);
        if (n == 0) return 0;
        if (n < 0) {
            if (errno == EINTR) continue;
            return -1;
        }
        p += (size_t)n;
        len -= (size_t)n;
    }
    return 1;
}

static int send_frame(int fd, const void *data, uint32_t len) {
    if (len > MAX_FRAME_SIZE) return -1;

    // 长度头统一使用网络字节序,避免不同主机字节序产生歧义。
    uint32_t net_len = htonl(len);
    if (write_all(fd, &net_len, sizeof(net_len)) < 0) return -1;
    return write_all(fd, data, len);
}

static int recv_frame(int fd, unsigned char **data, uint32_t *len) {
    uint32_t net_len;
    int rc = read_all(fd, &net_len, sizeof(net_len));
    if (rc <= 0) return rc;

    uint32_t body_len = ntohl(net_len);
    // 必须先限制声明长度,再根据它分配内存。
    if (body_len > MAX_FRAME_SIZE) return -1;

    unsigned char *buf = malloc((size_t)body_len + 1);
    if (buf == NULL) return -1;

    rc = read_all(fd, buf, body_len);
    if (rc <= 0) {
        free(buf);
        return -1;
    }

    buf[body_len] = '\0';
    *data = buf;
    *len = body_len;
    return 1;
}

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

    const char *first = "hello";
    const char *second = "world";
    if (send_frame(sv[0], first, (uint32_t)strlen(first)) < 0 ||
        send_frame(sv[0], second, (uint32_t)strlen(second)) < 0) {
        fprintf(stderr, "send_frame failed\n");
        return 1;
    }

    for (int i = 0; i < 2; ++i) {
        unsigned char *msg = NULL;
        uint32_t len = 0;
        if (recv_frame(sv[1], &msg, &len) != 1) {
            fprintf(stderr, "recv_frame failed\n");
            return 1;
        }
        printf("frame %d: len=%u, data=%s\n", i + 1, len, msg);
        free(msg);
    }

    close(sv[0]);
    close(sv[1]);
    return 0;
}

预期输出

text
frame 1: len=5, data=hello
frame 2: len=5, data=world

read_all 的关键不是“多读几次”,而是一直读到目标字节数满足为止。recv 返回正数但小于请求长度属于正常短读;返回 0 表示对端已关闭连接;返回负数时应根据 errno 区分可重试与真正错误。

处理边界与协议错误

长度头只能解决“消息在哪里结束”,不能自动解决内容合法性。生产代码通常还应检查协议版本、消息类型、最大长度和业务字段,并规定半包时连接如何处理。

如果连接在消息体尚未收完整时出现 EOF,这一帧应视为截断消息,不能把已收到的部分交给业务层。发送端同样不能假设一次 send 会写完全部字节,所以长度头和消息体都要使用“写满”为目标的循环。

长度前缀协议的核心不是 4 字节这个具体格式,而是让双方共享同一套边界规则:先准确知道要读多少,再把 TCP 的任意字节分片重新组装成完整应用消息。

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

目录与阅读设置

阅读设置

17

记录一个想法

设计简单的消息边界协议

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

登录哪都通