C++中如何通过Socket完整读取HTTP响应？

核心思路：分阶段读取+解析HTTP协议结构 #

HTTP响应遵循「头部 + 空行(\r\n\r\n) + 正文」的固定结构，无需逐字节读取，分两个阶段处理即可：先获取完整头部，再根据头部信息读取正文。

1. 读取完整的HTTP头部 #

用缓冲区批量读取（比如每次读4096字节），每次读完后检查拼接后的内容中是否出现头部结束标志\r\n\r\n，找到后拆分头部和正文起始部分：

#include <string>
#include <cstring>
#include <sys/socket.h> // Linux环境，Windows替换为winsock相关头文件

void read_http_header(int sock_fd, std::string& out_header, std::string& out_body_start) {
    char buffer[4096];
    std::string temp_buf;
    bool header_done = false;

    while (!header_done) {
        ssize_t bytes_read = recv(sock_fd, buffer, sizeof(buffer) - 1, 0);
        if (bytes_read <= 0) {
            // 处理连接错误或提前关闭
            break;
        }
        buffer[bytes_read] = '\0';
        temp_buf += buffer;

        size_t sep_pos = temp_buf.find("\r\n\r\n");
        if (sep_pos != std::string::npos) {
            header_done = true;
            out_header = temp_buf.substr(0, sep_pos);
            out_body_start = temp_buf.substr(sep_pos + 4); // 跳过空行
        }
    }
}

这种批量读取的方式比逐字节读取高效得多，能大幅减少系统调用次数。

2. 根据头部信息读取完整正文 #

HTTP正文传输有两种常见方式，需分别处理：

方式一：Content-Length固定长度 #

从头部提取Content-Length字段的值，计算剩余需要读取的字节数，循环读取直到凑够总长度：

#include <algorithm>
#include <stdexcept>

size_t parse_content_length(const std::string& header) {
    size_t len_pos = header.find("Content-Length: ");
    if (len_pos == std::string::npos) {
        throw std::runtime_error("No Content-Length field");
    }
    len_pos += 16; // 跳过"Content-Length: "字符串
    size_t line_end = header.find("\r\n", len_pos);
    std::string len_str = header.substr(len_pos, line_end - len_pos);
    return std::stoull(len_str);
}

void read_http_body_by_length(int sock_fd, std::string& out_body, size_t total_len, const std::string& initial_body) {
    out_body = initial_body;
    size_t remaining = total_len - initial_body.size();
    char buffer[4096];

    while (remaining > 0) {
        size_t read_size = std::min(sizeof(buffer) - 1, remaining);
        ssize_t bytes_read = recv(sock_fd, buffer, read_size, 0);
        if (bytes_read <= 0) {
            throw std::runtime_error("Failed to read body");
        }
        buffer[bytes_read] = '\0';
        out_body += buffer;
        remaining -= bytes_read;
    }
}

方式二：Transfer-Encoding: chunked分块编码 #

如果头部存在Transfer-Encoding: chunked，需按照分块规则读取：每个块以十六进制长度开头（后跟\r\n），接着是块内容（后跟\r\n），最后以长度为0的块结束：

#include <sstream>
#include <iomanip>

void read_http_body_chunked(int sock_fd, std::string& out_body, const std::string& initial_body) {
    out_body = initial_body;
    char buffer[4096];
    std::string temp_buf = initial_body;

    while (true) {
        // 读取块长度
        size_t len_sep = temp_buf.find("\r\n");
        while (len_sep == std::string::npos) {
            ssize_t bytes_read = recv(sock_fd, buffer, sizeof(buffer)-1, 0);
            if (bytes_read <=0) throw std::runtime_error("Chunk read error");
            buffer[bytes_read] = '\0';
            temp_buf += buffer;
            len_sep = temp_buf.find("\r\n");
        }

        std::string len_str = temp_buf.substr(0, len_sep);
        temp_buf = temp_buf.substr(len_sep + 2); // 跳过\r\n

        // 十六进制转十进制
        std::stringstream ss;
        ss << std::hex << len_str;
        size_t chunk_len;
        ss >> chunk_len;

        if (chunk_len == 0) break; // 分块结束

        // 读取块内容
        while (temp_buf.size() < chunk_len + 2) { // +2是末尾的\r\n
            ssize_t bytes_read = recv(sock_fd, buffer, sizeof(buffer)-1, 0);
            if (bytes_read <=0) throw std::runtime_error("Chunk content read error");
            buffer[bytes_read] = '\0';
            temp_buf += buffer;
        }

        out_body += temp_buf.substr(0, chunk_len);
        temp_buf = temp_buf.substr(chunk_len + 2); // 跳过块内容后的\r\n
    }
}

3. 处理边界情况 #

• 若为HTTP 1.0响应，可能既无Content-Length也不是分块编码，此时持续读取直到recv返回0（连接正常关闭）。
• 每次调用recv需处理返回值：返回0表示对方关闭连接，返回-1表示出错（如超时、连接重置）。

内容的提问来源于stack exchange，提问作者Jark