操作系统 / 系统课时
为每条连接维护协议状态机
为每条连接维护协议状态机
非阻塞服务器不能假设一次 recv 就得到一条完整消息。正确做法是把“已读到哪里、当前等待什么、已经缓存多少字节”放进连接对象,让协议解析能跨多次可读事件继续,同时把一次读取中已经完整的多条消息连续取出处理。
学习目标
- 为每条连接保存独立的协议解析状态与读取进度
- 正确处理消息跨多次
recv到达,以及一次recv包含多条消息 - 明确协议错误、连接关闭与暂时无数据的不同处理方式
把解析进度放进连接对象
TCP 只提供有序字节流,没有“消息边界”。下面用一个简单的长度前缀协议说明状态机:每条消息先发 1 字节长度,再发送对应数量的正文。真实协议可以把长度字段换成 4 字节整数、固定头部或分隔符,连接级状态的思路不变。
连接对象至少需要保存当前阶段、目标正文长度、已经收集的正文字节数和正文缓冲区。关键点是这些字段属于连接,不能做成所有客户端共享的一组全局变量,否则并发连接会互相覆盖解析进度。

用循环消费输入字节
下面的完整程序使用 socketpair 模拟一条 TCP 字节流,并把读端设为非阻塞。第一次只写入长度和正文前两个字节,解析器必须保留 2/5 的进度;第二次写入剩余字节以及下一条完整消息,解析器会先补完 hello,再继续从同一批输入里取出 world。
#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>
enum ParseState { NEED_LEN, NEED_BODY };
struct Conn {
enum ParseState state;
unsigned char len;
size_t have;
char body[256];
};
static void consume(struct Conn *c, const unsigned char *buf, size_t n) {
size_t i = 0;
// 同一批输入可能包含半条、整条或多条消息,因此持续消费到 buf 用尽。
while (i < n) {
if (c->state == NEED_LEN) {
c->len = buf[i++];
c->have = 0;
if (c->len == 0) {
fprintf(stderr, "protocol error: zero length\n");
exit(1);
}
c->state = NEED_BODY;
}
size_t need = (size_t)c->len - c->have;
size_t avail = n - i;
size_t take = need < avail ? need : avail;
memcpy(c->body + c->have, buf + i, take);
c->have += take;
i += take;
if (c->have == c->len) {
// 只有正文完整后才交给业务层,随后立即恢复到读取下一帧头部。
c->body[c->len] = '\0';
printf("message=%s\n", c->body);
c->state = NEED_LEN;
c->have = 0;
}
}
}
static void on_readable(int fd, struct Conn *c) {
unsigned char buf[64];
// 非阻塞可读回调要一直读到 EAGAIN,尤其适用于 EPOLLET。
for (;;) {
ssize_t n = recv(fd, buf, sizeof(buf), 0);
if (n > 0) {
consume(c, buf, (size_t)n);
continue;
}
if (n == 0) {
puts("peer closed");
return;
}
if (errno == EAGAIN || errno == EWOULDBLOCK) {
return;
}
perror("recv");
exit(1);
}
}
static void print_state(const struct Conn *c, const char *label) {
if (c->state == NEED_LEN) {
printf("%s: state=LEN, have=0/0\n", label);
} else {
printf("%s: state=BODY, have=%zu/%u\n", label, c->have, c->len);
}
}
int main(void) {
int sv[2];
if (socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == -1) {
perror("socketpair");
return 1;
}
int flags = fcntl(sv[0], F_GETFL, 0);
if (flags == -1 || fcntl(sv[0], F_SETFL, flags | O_NONBLOCK) == -1) {
perror("fcntl");
return 1;
}
struct Conn c = { .state = NEED_LEN };
// 人为拆成两次写入,验证一条消息可以跨两次 recv 完成。
unsigned char first[] = {5, 'h', 'e'};
unsigned char second[] = {'l', 'l', 'o', 5, 'w', 'o', 'r', 'l', 'd'};
if (write(sv[1], first, sizeof(first)) != (ssize_t)sizeof(first)) {
perror("write");
return 1;
}
on_readable(sv[0], &c);
print_state(&c, "after first read");
if (write(sv[1], second, sizeof(second)) != (ssize_t)sizeof(second)) {
perror("write");
return 1;
}
on_readable(sv[0], &c);
print_state(&c, "after second read");
close(sv[0]);
close(sv[1]);
return 0;
}预期输出:
after first read: state=BODY, have=2/5
message=hello
message=world
after second read: state=LEN, have=0/0不同系统对一次 recv 实际返回多少字节没有保证,因此验收重点是消息顺序与最终状态,而不是依赖某次系统调用恰好返回多少字节。
可读事件里要读到暂时无数据
在非阻塞模式下,可读回调通常要循环调用 recv,直到返回 EAGAIN 或 EWOULDBLOCK。这表示“当前内核接收缓冲区已经读空”,不是连接故障。若 recv 返回 0,才表示对端已经有序关闭发送方向。
如果使用边缘触发 EPOLLET,读到 EAGAIN 尤其重要:没有把当前数据读空,后续可能不会再收到新的边缘通知。协议状态机则负责在下一次数据到达时从上次进度继续。
给生产协议补上边界检查
长度字段必须在分配内存或复制正文之前验证。若协议允许最大消息为 64 KiB,就在读取长度后立即拒绝更大的值;否则恶意客户端可以声明超大正文,让服务器不断占用内存等待永远不会到齐的数据。
完整消息交给业务层后,应立即把状态恢复为等待下一帧,并继续消费当前输入缓冲区的剩余字节。这样既能处理“半包”,也能处理“粘包”,而且不会把 TCP 的任意分段误当成应用层消息边界。