C / C++ / 系统课时
设计简单的消息边界协议
设计简单的消息边界协议
TCP 只保证按顺序传递字节,不会保留应用层“第几条消息”的边界。本篇用 4 字节长度头定义一个最小分帧协议,并实现循环收发,让接收端能够从任意拆分或合并的字节流中恢复完整消息。
学习目标
- 解释为什么一次
send不一定对应一次recv - 设计“长度头 + 消息体”的应用层帧格式
- 用循环读取正确处理短读、EOF 和异常长度
TCP 为什么需要应用层分帧
SOCK_STREAM 提供的是连续字节流。发送方连续发送 hello 和 world,接收方可能一次读到两者,也可能先读到 he、再读到剩余字节。TCP 不承诺应用层调用边界,因此不能把“一次 recv 返回”直接当成“一条消息”。
如果协议没有边界规则,接收端就无法可靠判断一条消息何时结束。常见方案有固定长度、分隔符和长度头。对二进制数据或内容本身可能包含任意字节的场景,长度头通常最直接。

定义一个最小长度头协议
这里约定每帧前 4 字节是无符号 32 位整数,表示消息体字节数,并使用网络字节序传输。接收端先完整读取头部,再根据长度读取消息体。
协议可以抽象为:
[4 字节 payload_length][payload_length 字节 payload]
必须同时给消息长度设置上限。否则恶意或损坏的数据可以声明一个极大的长度,诱导程序分配过多内存。下面示例把单帧限制为 1 MiB。
实现循环读取与组帧
下面的完整程序用 socketpair 创建本地流式套接字,方便稳定演示 TCP 同类的字节流行为;send_frame 和 recv_frame 接收的都是已连接流式 socket 文件描述符,换成 TCP accept 或 connect 得到的 fd 后逻辑不变。
#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;
}预期输出
frame 1: len=5, data=hello
frame 2: len=5, data=worldread_all 的关键不是“多读几次”,而是一直读到目标字节数满足为止。recv 返回正数但小于请求长度属于正常短读;返回 0 表示对端已关闭连接;返回负数时应根据 errno 区分可重试与真正错误。
处理边界与协议错误
长度头只能解决“消息在哪里结束”,不能自动解决内容合法性。生产代码通常还应检查协议版本、消息类型、最大长度和业务字段,并规定半包时连接如何处理。
如果连接在消息体尚未收完整时出现 EOF,这一帧应视为截断消息,不能把已收到的部分交给业务层。发送端同样不能假设一次 send 会写完全部字节,所以长度头和消息体都要使用“写满”为目标的循环。
长度前缀协议的核心不是 4 字节这个具体格式,而是让双方共享同一套边界规则:先准确知道要读多少,再把 TCP 的任意字节分片重新组装成完整应用消息。