Boost.Beast处理无响应体HTTP请求时is_done返回false的问题及解决方案咨询

我来帮你拆解这个问题的根源，并给出符合HTTP规范的正确解决思路：

一、为什么parser.is_done()对HEAD请求返回false？ #

Boost.Beast的HTTP响应解析器（http::response_parser）的is_done()方法，核心逻辑是判断是否完成了响应体的解析流程，而非直接遵循HTTP规范中“是否应该存在响应体”的规则。

对于HEAD请求，虽然HTTP规范明确要求服务器返回的响应没有实际体内容，但响应头中可能仍会携带Content-Length（对应同路径GET请求的体长度）。Beast的解析器不会自动识别HEAD请求的特殊性——它默认会等待读取响应体数据，直到你明确告知不需要，因此调用read_header()后is_done()会返回false。

二、你提出的判断条件存在的问题 #

你考虑用(!parser.content_length() || parser.content_length().value() == 0) && !parser.chunked()来替代is_done()，这个方案有明显的局限性：

• HEAD请求场景不适用：HEAD响应的Content-Length通常对应GET请求的体长度，并非实际存在的响应体长度，你的条件会误判为“存在响应体”。
• 覆盖不全HTTP规范：HTTP中还有很多无需响应体的场景（比如状态码204 No Content、304 Not Modified、1xx信息性响应），这些情况即使有Content-Length也不会有体，你的条件无法覆盖。

三、正确的解决方案 #

根据HTTP规范（RFC 7230、RFC 7231）和Boost.Beast的设计，有两种可靠的处理方式：

方式1：利用Beast解析器的skip_body()方法 #

对于明确不需要响应体的场景（比如HEAD请求），在调用read_header()后，直接告诉解析器跳过响应体，这样is_done()会立即返回true：

修改你的代码，在http::read_header(stream, buffer, parser);之后添加：

// 针对HEAD请求，告诉解析器跳过响应体
if (req.method() == http::verb::head) {
    parser.skip_body(true);
}

调用skip_body(true)后，解析器会标记“响应已完成”，此时parser.is_done()将返回true，同时也不会尝试读取任何响应体数据，完全符合HEAD请求的要求。

方式2：严格遵循HTTP规范判断是否存在响应体 #

如果需要处理所有无需响应体的场景（不仅是HEAD请求），可以先根据HTTP方法和响应状态码判断，再结合头信息：

bool has_no_body = false;

// 情况1：请求方法是HEAD，无论状态码都无响应体
if (req.method() == http::verb::head) {
    has_no_body = true;
} 
// 情况2：响应状态码属于无需体的类型
else {
    auto status = res.result_int();
    if (status >= 100 && status < 200) { // 1xx信息性响应
        has_no_body = true;
    } else if (status == 204) { // 204 No Content
        has_no_body = true;
    } else if (status == 304) { // 304 Not Modified
        has_no_body = true;
    }
}

// 如果确定无响应体，标记解析完成
if (has_no_body) {
    parser.skip_body(true);
}

// 之后就可以安全使用parser.is_done()判断
if (parser.is_done()) {
    // 处理响应完成的逻辑
}

四、修改后的完整代码示例 #

这里是整合了方式1的完整代码，针对HEAD请求修复is_done()返回false的问题：

#include <boost/beast/core.hpp>
#include <boost/beast/http.hpp>
#include <boost/beast/ssl.hpp>
#include <boost/asio/connect.hpp>
#include <boost/asio/ssl/error.hpp>
#include <boost/asio/ssl/stream.hpp>
#include <iostream>

namespace beast = boost::beast;
namespace http = beast::http;
namespace net = boost::asio;
namespace ssl = net::ssl;
using tcp = net::ip::tcp;

int main() {
    try {
        const std::string host = "stackoverflow.com";
        const std::string port = "443";
        const std::string target = "/questions";
        int version = 11; // HTTP/1.1

        // IO + SSL
        net::io_context ioc;
        ssl::context ctx(boost::asio::ssl::context::tls_client);
        ctx.set_options(ssl::context::default_workarounds | boost::asio::ssl::context::no_tlsv1);

        beast::ssl_stream<beast::tcp_stream> stream(ioc, ctx);

        tcp::resolver resolver(ioc);
        auto const results = resolver.resolve(host, port);

        beast::get_lowest_layer(stream).connect(results);

        if (!SSL_set_tlsext_host_name(stream.native_handle(), host.c_str())) {
            throw boost::system::system_error(::ERR_get_error(), boost::asio::error::get_ssl_category());
        }

        // SSL Handshake
        stream.handshake(ssl::stream_base::client);

        // HEAD request
        http::request<http::empty_body> req{ http::verb::head, target, version };
        req.set(http::field::host, host);
        req.set(http::field::user_agent, "Boost::Beast");

        // send request
        http::write(stream, req);
        std::cout << "Request written" << std::endl;

        // read response
        beast::flat_buffer buffer;
        http::response_parser<http::string_body> parser;
        http::read_header(stream, buffer, parser);

        // 针对HEAD请求，告诉解析器跳过响应体
        if (req.method() == http::verb::head) {
            parser.skip_body(true);
        }

        const auto& res = parser.get();
        std::cout << "Response status: " << res.result_int() << " " << res.reason() << " parser.is_done() = " << parser.is_done() << "\n";

        for (const auto& field : res) {
            std::cout << field.name_string() << ": " << field.value() << "\n";
        }

        beast::error_code ec;
        stream.shutdown(ec);
        if (ec == net::error::eof || ec == ssl::error::stream_truncated) {
            ec = {};
        }
        if (ec) throw beast::system_error{ ec };

    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << "\n";
        return 1;
    }
    return 0;
}

总结 #

你的初始方案没有考虑HTTP规范中方法和状态码的特殊规则，容易出现误判。而使用parser.skip_body()结合HTTP方法/状态码的判断，既符合Boost.Beast的设计逻辑，也严格遵循了HTTP标准，是更可靠的解决方案。

内容来源于stack exchange