Linux 下 recv() 一次读到半包或多个请求,通常不是 recv() 用错了,而是把 TCP 字节流误当成了消息流。正确的处理顺序是:先把收到的字节追加到持久缓冲区,再由协议层寻找完整帧、校验长度并提取正文,等正文和结束符全部到齐后,业务层才解析 JSON;一次读到多条请求时循环提取,余量继续留在缓冲区。
因此,不能在每次 recv() 返回后立即调用 JSON 解析器。recv() 返回多少字节受接收时机、已到达的数据量以及本次缓冲区大小影响,接收缓冲区即使远未填满,也可能出现半包。对于变长 JSON 请求,优先考虑长度前缀拆包;固定长度记录可以考虑定长协议,带转义规则的文本协议才适合分隔符方案。
recv() 读到的不是一条请求
TCP 提供的是有序字节流,不保留应用层消息边界。一次 send() 发送的数据可能在后续多次 recv() 调用中分段返回,多次 send() 的数据也可能被一次 recv() 合并读取。这些都是 TCP 字节流的正常表现,不是网络本身损坏。
行业里常说的 TCP 半包、TCP 粘包,实际描述的是应用层消息边界:
- 一条逻辑请求被拆成多次读取,是半包。
- 多条逻辑请求被一次读到,是粘包。
- 一次读到“一条完整请求加下一条请求的一部分”,则是最容易被忽略的混合情况。
排查时不要只记录 recv() 的返回值大小。更有用的信息是:本次收到的原始字节、协议头是否完整、声明的正文长度、当前持久缓冲区里还剩多少字节,以及发送端是否已经把整帧写完。如果发送端只写出了帧头和部分正文,接收端一直等待是正确行为,不是接收端漏掉了数据。
JSON 解析失败也要先分层判断。JSON 被截断,通常说明应用层帧还没有收齐;一次收到多个 JSON 对象,说明不能把整个接收缓冲区当成一条消息;帧已经完整但 JSON 本身语法错误,才属于载荷错误。JSON 只解决字段怎样表示,不负责判断一次业务消息在哪里结束。
即使某个 JSON 解析器能够解析缓冲区里的第一个对象,也不能据此证明拆包正确,还要确认解析器实际消费了多少字节,以及帧头声明的长度是否已经全部满足。
分隔符、定长和长度前缀怎么选
协议边界必须由应用层定义。常见路线及其取舍如下。
| 方案 | 典型帧格式 | 适合场景 | 主要代价 |
|---|---|---|---|
| 分隔符法 | 正文 + 分隔符 |
命令行、单行文本、已有转义规则的协议 | 正文包含分隔符时需要转义,还要逐字节扫描边界 |
| 定长法 | 每条消息固定为 (N) 字节 | 固定长度记录、状态字、固定槽位 | 需要填充,长度变化时浪费空间,并且存在最大消息长度 |
| 长度前缀法 | 长度 + 变长正文 |
JSON、文件片段、任意二进制载荷 | 必须固定字节序、长度语义和最大帧长,并分阶段读取帧头与正文 |
| 固定复合头 | 固定头字段加变长正文 | 有消息类型、版本、序列号或校验要求的协议 | 字段更多,编码、校验和状态处理成本最高 |
对于便于抓包和排查的 JSON 文本协议,可以使用“十进制长度、CRLF、JSON 正文、CRLF”的封包规则。热点原文采用的就是这种形式,请求和响应使用相同规则。
26\r\n{"x":10,"y":20,"oper":"+"}\r\n
这里的长度 26 只统计 JSON 正文的实际字节数,不包含长度字段后的 CRLF,也不包含正文后的 CRLF。CRLF 是回车和换行两个实际字节,不是字符 \、r、n。正文长度应当按照最终发送的字节计算,不能只按字符数量计算。
二进制协议则可以使用固定四字节大端长度加变长正文。无论采用哪种形式,都要在双方协议中写清楚长度字段代表正文长度还是整帧长度,并规定字节序、最大长度和非法长度的处理方式。
具体方案取决于业务消息的特征。固定槽位适合定长法;正文已有可靠转义机制时,分隔符法足够直观;变长 JSON 通常更适合长度前缀。长度前缀虽然多占一些头部,也比扫描正文寻找分隔符更容易控制边界。
长度前缀拆包器怎样逐条取出请求
长度前缀拆包至少要区分“等待帧头”和“等待正文”两个阶段。完整帧提取以后还要继续循环,因为同一次 recv() 可能带回多条帧,也可能在最后一条帧后面留下半条数据。
recv() → append(buffer) → 帧头是否完整?
├─ 否:继续读取
└─ 是:校验长度
├─ 非法:拒绝或关闭连接
└─ 合法:正文是否完整?
├─ 否:继续读取
└─ 是:提取帧、解析 JSON、保留余量并循环
下面是一个 Linux C++17 骨架。接收循环假设 socket 使用阻塞模式;1 MiB 和 32 字节只是示例上限,部署时需要按业务调整。代码只负责帧边界,HandleJsonFrame() 才是业务层接入 JSON 解析器的地方。
#include <sys/socket.h>
#include <cerrno>
#include <cstddef>
#include <cstring>
#include <functional>
#include <iostream>
#include <stdexcept>
#include <string>
#include <string_view>
namespace {
// 示例值,应按业务设置。
constexpr std::size_t kMaxFrameBytes = 1u << 20;
constexpr std::size_t kMaxHeaderBytes = 32;
} // namespace
enum class DecodeState {
kNeedMore,
kFrame,
kProtocolError
};
struct DecodeResult {
DecodeState state = DecodeState::kNeedMore;
std::string body;
std::string error;
};
std::string EncodeFrame(std::string_view body) {
if (body.size() > kMaxFrameBytes) {
throw std::invalid_argument("frame body too large");
}
std::string frame;
frame.reserve(body.size() + kMaxHeaderBytes);
frame += std::to_string(body.size());
frame += "\r\n";
frame.append(body.data(), body.size());
frame += "\r\n";
return frame;
}
DecodeResult DecodeOne(std::string& pending) {
DecodeResult result;
auto fail = [&result](const char* message) {
result.state = DecodeState::kProtocolError;
result.error = message;
return result;
};
const std::size_t header_end = pending.find("\r\n");
// 帧头尚未收全。
if (header_end == std::string::npos) {
if (pending.size() > kMaxHeaderBytes) {
return fail("header too long");
}
return result;
}
if (header_end == 0 || header_end > kMaxHeaderBytes) {
return fail("invalid header length");
}
std::size_t body_length = 0;
for (std::size_t i = 0; i < header_end; ++i) {
const unsigned char c = static_cast<unsigned char>(pending[i]);
if (c < '0' || c > '9') {
return fail("non-digit in length field");
}
const std::size_t digit = c - '0';
// 先检查再乘,避免溢出,同时拒绝超长帧。
if (body_length > (kMaxFrameBytes - digit) / 10) {
return fail("declared body length exceeds limit");
}
body_length = body_length * 10 + digit;
}
const std::size_t body_start = header_end + 2;
const std::size_t trailer_start = body_start + body_length;
// 正文尚未收全。
if (pending.size() < trailer_start) {
return result;
}
// 正文已齐,但结束符还没有收到。
if (pending.size() == trailer_start) {
return result;
}
if (pending[trailer_start] != '\r') {
return fail("missing CRLF trailer");
}
// 只收到 CR,还在等待 LF。
if (pending.size() < trailer_start + 2) {
return result;
}
if (pending[trailer_start + 1] != '\n') {
return fail("missing CRLF trailer");
}
result.state = DecodeState::kFrame;
result.body = pending.substr(body_start, body_length);
// 提取当前帧,余量继续留给下一帧。
pending.erase(0, trailer_start + 2);
return result;
}
void HandleJsonFrame(std::string_view body) {
// 在这里调用项目使用的 JSON 解析器。
// JSON 解析失败属于载荷错误,不是帧边界错误。
}
bool ReceiveLoop(
int fd,
const std::function<void(std::string_view)>& on_frame) {
std::string pending;
char read_buffer[16384];
for (;;) {
const ssize_t n =
::recv(fd, read_buffer, sizeof(read_buffer), 0);
if (n > 0) {
pending.append(read_buffer, static_cast<std::size_t>(n));
} else if (n == 0) {
// 对端关闭时,pending 非空表示最后一帧没有收完整。
if (!pending.empty()) {
std::cerr << "connection closed with an incomplete frame: "
<< pending.size() << " bytes pending\n";
return false;
}
return true;
} else {
if (errno == EINTR) {
continue;
}
const int saved_errno = errno;
std::cerr << "recv failed: "
<< std::strerror(saved_errno) << '\n';
return false;
}
// 一次 recv 可能带回多条完整帧,也可能只带回半条。
for (;;) {
const DecodeResult decoded = DecodeOne(pending);
if (decoded.state == DecodeState::kNeedMore) {
break;
}
if (decoded.state == DecodeState::kProtocolError) {
std::cerr << "protocol error: "
<< decoded.error << '\n';
// 长度非法或结束符错误后,无法可靠确定下一帧边界。
// 应关闭连接,而不是随意丢弃一个字节后继续猜。
return false;
}
on_frame(decoded.body);
}
}
}
这里有三个关键边界。kNeedMore 不是错误,数据必须留在 pending 中等待下一次读取;长度非法、长度超限或结束符错误属于协议错误,在没有额外重同步规则时应拒绝连接;如果帧已经完整但 JSON 无法解析,那是载荷错误,可以按业务返回错误并继续处理下一帧。
EncodeFrame() 成功只表示本地构造出了完整字节,不代表对端已经收到。发送端仍要检查每次 send() 的返回值,未写完的部分需要继续发送;否则对端可能只收到帧头和部分正文,永远等不到剩余内容。协议编码、Socket 收发和业务处理应当分别验证。
拆包测试不要只测“一次收到完整 JSON”。至少应覆盖下面的边界,表中是预期断言,不是未经运行的输出:
| 输入情况 | 预期结果 |
|---|---|
| 一次输入一帧完整数据 | 返回一帧,pending 清空 |
| 将同一帧按每一个字节位置逐段输入 | 最后一字节到齐前均为 kNeedMore,到齐后返回一帧 |
| 一次输入两帧完整数据 | 连续返回两帧,顺序不变 |
| 一次输入完整帧加下一帧的前半段 | 先返回第一帧,剩余半帧留在 pending |
| 只收到部分长度头 | 返回 kNeedMore |
| 长度头完整但正文不完整 | 返回 kNeedMore |
| 长度字段包含非数字字符 | 返回 kProtocolError |
| 声明长度超过上限 | 返回 kProtocolError |
| 正文完整但结束符尚未收到 | 连接仍开放时返回 kNeedMore;随后 EOF 则报告残帧 |
| 结束符字节不正确 | 返回 kProtocolError |
| 帧完整但正文不是合法 JSON | 拆包成功,随后由 JSON 层报告载荷错误 |
参考资料 中的网络计算器案例使用 Ubuntu、Linux 5.15.0-181-generic、GCC 11.4.0、JsonCpp 1.9.5-3 和 C++17,并检查了单帧、多帧、半包及非法报文等场景。这只是原文案例的验证记录,不能据此认为上述骨架已经在相同环境运行过。
长度前缀只解决消息边界。固定长度记录可以用定长法,带转义规则的文本可以用分隔符法,变长 JSON 通常优先使用长度前缀。并发请求与响应的关联、慢连接造成的缓冲区膨胀、资源上限和消息完整性仍要另行处理。 如果服务端并发处理请求,响应顺序可能与请求顺序不同,还需要串行队列、请求 ID 或序列号。对端长时间等不到正文时,也要检查发送端是否真正写完整。
如果现象是 recv-Q 堆积或服务挂起,也不能一律归因于半包、粘包。参考资料中的 Tomcat 案例最终是 Java 进程内存不足,增加内存并调整数据库后解决,而不是拆包逻辑问题。 排查时应先分别确认帧边界、载荷有效性和请求响应关联,再判断问题究竟发生在协议、业务还是系统资源层。












暂无评论内容