From 4f9f72001f3805d65e478413d0c732b7baf93b64 Mon Sep 17 00:00:00 2001 From: chenBright Date: Mon, 16 Nov 2026 22:05:58 +0800 Subject: [PATCH 1/2] Fix HTTP/2 window accounting and parser test socket leaks --- src/brpc/policy/http2_rpc_protocol.cpp | 8 +- test/brpc_couchbase_unittest.cpp | 3 + test/brpc_http_rpc_protocol_unittest.cpp | 157 +++++++++++++++++++++++ test/brpc_memcache_unittest.cpp | 3 + 4 files changed, 169 insertions(+), 2 deletions(-) diff --git a/src/brpc/policy/http2_rpc_protocol.cpp b/src/brpc/policy/http2_rpc_protocol.cpp index 438603bdc8..2768cb37e2 100644 --- a/src/brpc/policy/http2_rpc_protocol.cpp +++ b/src/brpc/policy/http2_rpc_protocol.cpp @@ -931,6 +931,12 @@ H2ParseResult H2StreamContext::OnData( butil::IOBuf data; it.append_and_forward(&data, frag_size); it.forward(pad_length); + // Account for the full DATA payload, including padding, before OnBody() + // can reject it. Stream cleanup must return this frame's connection credit + // even when the body exceeds max_body_size. + int64_t acc = frame_head.payload_size + + _deferred_window_update.fetch_add( + frame_head.payload_size, butil::memory_order_relaxed); for (size_t i = 0; i < data.backing_block_num(); ++i) { const butil::StringPiece blk = data.backing_block(i); if (OnBody(blk.data(), blk.size()) != 0) { @@ -942,8 +948,6 @@ H2ParseResult H2StreamContext::OnData( } } - int64_t acc = frag_size + - _deferred_window_update.fetch_add(frag_size, butil::memory_order_relaxed); int64_t quota = static_cast( _conn_ctx->local_settings().stream_window_size / (_conn_ctx->VolatilePendingStreamSize() + 1)); diff --git a/test/brpc_couchbase_unittest.cpp b/test/brpc_couchbase_unittest.cpp index 87278d6b6e..6ec6584d9f 100644 --- a/test/brpc_couchbase_unittest.cpp +++ b/test/brpc_couchbase_unittest.cpp @@ -70,6 +70,7 @@ TEST_F(CouchbaseUnitTest, RejectOversizedResponseBeforeBufferingBody) { ASSERT_EQ(0, brpc::Socket::Create(options, &id)); brpc::SocketUniquePtr socket; ASSERT_EQ(0, brpc::Socket::Address(id, &socket)); + ASSERT_EQ(0, socket->ReleaseAdditionalReference()); brpc::policy::CouchbaseResponseHeader couchbase_header = {}; couchbase_header.magic = brpc::policy::CB_MAGIC_RESPONSE; @@ -80,6 +81,8 @@ TEST_F(CouchbaseUnitTest, RejectOversizedResponseBeforeBufferingBody) { brpc::policy::ParseCouchbaseMessage( &couchbase_buf, socket.get(), false, nullptr).error()); + socket.reset(); + EXPECT_EQ(-1, brpc::Socket::Status(id)); } TEST_F(CouchbaseUnitTest, RequestBuilders) { diff --git a/test/brpc_http_rpc_protocol_unittest.cpp b/test/brpc_http_rpc_protocol_unittest.cpp index 3339505684..df195ade3b 100644 --- a/test/brpc_http_rpc_protocol_unittest.cpp +++ b/test/brpc_http_rpc_protocol_unittest.cpp @@ -38,9 +38,11 @@ #include #include #include "brpc/http_method.h" +#include "brpc/global.h" #include "brpc/grpc.h" #include "butil/iobuf.h" #include "butil/logging.h" +#include "butil/sys_byteorder.h" #include "butil/files/scoped_file.h" #include "butil/fd_guard.h" #include "butil/fd_utility.h" @@ -2285,6 +2287,161 @@ TEST_F(HttpTest, http2_deferred_response_notify_registration_failure_resets_stre EXPECT_EQ(0, bthread_id_error(dummy_id, 0)); } +TEST(Http2FlowControlTest, oversized_body_returns_connection_window) { + brpc::GlobalInitializeOrDie(); + GFLAGS_NAMESPACE::FlagSaver flag_saver; + brpc::FLAGS_max_body_size = 4; + + for (bool client_side : {false, true}) { + SCOPED_TRACE(client_side); + int fds[2]; + ASSERT_EQ(0, pipe(fds)); + butil::fd_guard read_fd(fds[0]); + brpc::SocketOptions options; + options.fd = fds[1]; + if (client_side) { + options.user = brpc::get_client_side_messenger(); + } + brpc::SocketId id; + ASSERT_EQ(0, brpc::Socket::Create(options, &id)); + brpc::SocketUniquePtr socket; + ASSERT_EQ(0, brpc::Socket::Address(id, &socket)); + ASSERT_EQ(0, socket->ReleaseAdditionalReference()); + + brpc::policy::H2Context ctx(socket.get(), nullptr); + ASSERT_EQ(0, ctx.Init()); + ASSERT_EQ(client_side, ctx.is_client_side()); + ctx._conn_state = brpc::policy::H2_CONNECTION_READY; + // Flush connection credit on each rejected body, while keeping the + // first three bytes of a split body below the stream-update threshold. + ctx._local_settings.stream_window_size = 8; + ctx._unack_local_settings.stream_window_size = 8; + + auto consume_frame = [&](brpc::policy::H2FrameType type, uint8_t flags, + int stream_id, const std::string& payload) { + char head[brpc::policy::FRAME_HEAD_SIZE]; + brpc::policy::SerializeFrameHead( + head, payload.size(), type, flags, stream_id); + butil::IOBuf buf; + buf.append(head, sizeof(head)); + buf.append(payload); + butil::IOBufBytesIterator it(buf); + brpc::ParseResult result = ctx.Consume(it, socket.get()); + EXPECT_EQ(0u, it.bytes_left()); + return result; + }; + + auto start_stream = [&](int stream_id) { + if (client_side) { + // A response arrives on a stream already opened by a request. + std::unique_ptr sctx( + new brpc::policy::H2StreamContext(false)); + sctx->Init(&ctx, stream_id); + ASSERT_EQ(0, ctx.TryToInsertStream(stream_id, sctx.get())); + sctx.release(); + } + // HPACK static entries: :status 200, or :method POST, :scheme http, + // :path /. END_HEADERS leaves the body open. + std::string headers = client_side ? "\x88" : "\x83\x86\x84"; + brpc::ParseResult result = consume_frame( + brpc::policy::H2_FRAME_HEADERS, 0x4, stream_id, headers); + ASSERT_TRUE(result.is_ok()) << result.error_str(); + ASSERT_EQ(nullptr, result.message()); + }; + + auto check_replies = [&](int stream_id, bool reset, + uint32_t expected_credit) { + int bytes = 0; + ASSERT_EQ(0, ioctl(read_fd, FIONREAD, &bytes)); + ASSERT_GT(bytes, 0); + butil::IOPortal replies; + ASSERT_EQ(bytes, + replies.append_from_file_descriptor(read_fd, bytes)); + butil::IOBufBytesIterator it(replies); + int resets = 0; + uint32_t connection_credit = 0; + uint32_t stream_credit = 0; + while (it.bytes_left() != 0) { + brpc::policy::H2FrameHead head; + ASSERT_TRUE(ctx.ConsumeFrameHead(it, &head).is_ok()); + ASSERT_EQ(4u, head.payload_size); + uint32_t value; + ASSERT_EQ(sizeof(value), + it.copy_and_forward(&value, sizeof(value))); + value = butil::NetToHost32(value); + if (head.type == brpc::policy::H2_FRAME_RST_STREAM) { + EXPECT_EQ(stream_id, head.stream_id); + EXPECT_EQ(brpc::H2_ENHANCE_YOUR_CALM, value); + ++resets; + } else { + ASSERT_EQ(brpc::policy::H2_FRAME_WINDOW_UPDATE, head.type); + if (head.stream_id == 0) { + connection_credit += value; + } else { + EXPECT_EQ(stream_id, head.stream_id); + stream_credit += value; + } + } + } + EXPECT_EQ(reset ? 1 : 0, resets); + EXPECT_EQ(expected_credit, connection_credit); + EXPECT_EQ(reset ? 0u : expected_credit, stream_credit); + }; + + int stream_id = 1; + for (bool split_body : {false, true}) { + for (bool padded : {false, true}) { + SCOPED_TRACE(stream_id); + ASSERT_NO_FATAL_FAILURE(start_stream(stream_id)); + if (split_body) { + brpc::ParseResult first = consume_frame( + brpc::policy::H2_FRAME_DATA, 0, stream_id, "hel"); + ASSERT_TRUE(first.is_ok()); + ASSERT_EQ(nullptr, first.message()); + } + std::string payload = split_body ? "lo" : "hello"; + uint8_t flags = 0x1; // END_STREAM + if (padded) { + payload.insert(0, 1, '\x02'); + payload.append(2, '\0'); + flags |= 0x8; // PADDED + } + brpc::ParseResult result = consume_frame( + brpc::policy::H2_FRAME_DATA, flags, stream_id, payload); + brpc::DestroyingPtr message( + result.message()); + ASSERT_TRUE(result.is_ok()) << result.error_str(); + EXPECT_EQ(client_side, message != nullptr); + EXPECT_EQ(nullptr, ctx.FindStream(stream_id)); + // All five body bytes must be returned, including the entire + // offending frame, plus the pad-length byte and padding. + ASSERT_NO_FATAL_FAILURE( + check_replies(stream_id, true, padded ? 8 : 5)); + EXPECT_EQ(0, ctx._deferred_window_update.load( + butil::memory_order_relaxed)); + stream_id += 2; + } + } + + // A body exactly at the limit still completes on the same connection. + // Padding consumes flow-control credit but does not count as body data. + ASSERT_NO_FATAL_FAILURE(start_stream(stream_id)); + std::string payload(1, '\x02'); + payload.append("good"); + payload.append(2, '\0'); + brpc::ParseResult result = consume_frame( + brpc::policy::H2_FRAME_DATA, 0x9, stream_id, payload); + brpc::DestroyingPtr message( + static_cast(result.message())); + ASSERT_TRUE(result.is_ok()) << result.error_str(); + ASSERT_TRUE(message != nullptr); + EXPECT_EQ("good", message->body().to_string()); + ASSERT_NO_FATAL_FAILURE(check_replies(stream_id, false, 7)); + EXPECT_EQ(brpc::policy::H2_CONNECTION_READY, ctx._conn_state); + EXPECT_FALSE(socket->Failed()); + } +} + TEST_F(HttpTest, http2_settings) { char settingsbuf[brpc::policy::FRAME_HEAD_SIZE + 36]; brpc::H2Settings h2_settings; diff --git a/test/brpc_memcache_unittest.cpp b/test/brpc_memcache_unittest.cpp index a43a1e0132..92cb0a00f6 100644 --- a/test/brpc_memcache_unittest.cpp +++ b/test/brpc_memcache_unittest.cpp @@ -50,6 +50,7 @@ TEST(MemcacheParserTest, RejectOversizedResponseBeforeBufferingBody) { ASSERT_EQ(0, brpc::Socket::Create(options, &id)); brpc::SocketUniquePtr socket; ASSERT_EQ(0, brpc::Socket::Address(id, &socket)); + ASSERT_EQ(0, socket->ReleaseAdditionalReference()); brpc::policy::MemcacheResponseHeader header = {}; header.magic = brpc::policy::MC_MAGIC_RESPONSE; @@ -60,6 +61,8 @@ TEST(MemcacheParserTest, RejectOversizedResponseBeforeBufferingBody) { brpc::policy::ParseMemcacheMessage( &buf, socket.get(), false, nullptr).error()); + socket.reset(); + EXPECT_EQ(-1, brpc::Socket::Status(id)); } TEST(MemcacheParserTest, PopStoreRejectsNegativeValueSize) { From a8dd380e8f1cc7cebb79cb5ce36ee6ee5544915f Mon Sep 17 00:00:00 2001 From: chenBright Date: Mon, 16 Nov 2026 22:07:58 +0800 Subject: [PATCH 2/2] Guard the HTTP/2 test pipe during socket creatio --- test/brpc_http_rpc_protocol_unittest.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/test/brpc_http_rpc_protocol_unittest.cpp b/test/brpc_http_rpc_protocol_unittest.cpp index df195ade3b..623b22ee6e 100644 --- a/test/brpc_http_rpc_protocol_unittest.cpp +++ b/test/brpc_http_rpc_protocol_unittest.cpp @@ -2297,13 +2297,15 @@ TEST(Http2FlowControlTest, oversized_body_returns_connection_window) { int fds[2]; ASSERT_EQ(0, pipe(fds)); butil::fd_guard read_fd(fds[0]); + butil::fd_guard write_fd(fds[1]); brpc::SocketOptions options; - options.fd = fds[1]; + options.fd = write_fd; if (client_side) { options.user = brpc::get_client_side_messenger(); } brpc::SocketId id; ASSERT_EQ(0, brpc::Socket::Create(options, &id)); + write_fd.release(); // Socket owns the fd after successful creation. brpc::SocketUniquePtr socket; ASSERT_EQ(0, brpc::Socket::Address(id, &socket)); ASSERT_EQ(0, socket->ReleaseAdditionalReference());