Linux recv() 一次读到半包或多个请求怎么拆

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 进程内存不足,增加内存并调整数据库后解决,而不是拆包逻辑问题。 排查时应先分别确认帧边界、载荷有效性和请求响应关联,再判断问题究竟发生在协议、业务还是系统资源层。

© 版权声明
THE END
喜欢就支持一下吧
点赞0 分享
评论 抢沙发

请登录后发表评论

    暂无评论内容