grpc 1.76.0 → 1.78.0.pre1

data/src/core/ext/transport/chttp2/transport/header_assembler.h

@@ -23,17 +23,23 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <string>
+#include <utility>
 
-#include "absl/log/log.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/ext/transport/chttp2/transport/frame.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parser.h"
 #include "src/core/ext/transport/chttp2/transport/http2_status.h"
+#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/shared_bit_gen.h"
+#include "src/core/util/status_helper.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
 
 // TODO(tjagtap) TODO(akshitpatel): [PH2][P3] : Write micro benchmarks for
 // assembler and disassembler code
@@ -42,7 +48,7 @@ namespace grpc_core {
 namespace http2 {
 
 // If the Client Transport code is using HeaderAssembler in the wrong way,
-// we fail with a DCHECK.
+// we fail with a GRPC_DCHECK.
 // If the peer sent some bad data, we fail with the appropriate Http2Status.
 
 #define ASSEMBLER_LOG DVLOG(3)
@@ -85,17 +91,20 @@ constexpr uint8_t kMaxHeaderFrames = 2;
 class HeaderAssembler {
  public:
   // Call this for each incoming HTTP2 Header frame.
-  // The payload of the Http2HeaderFrame will be cleared in this function.
-  Http2Status AppendHeaderFrame(Http2HeaderFrame&& frame) {
+  // If AppendHeaderFrame returns an OK status, the payload will be consumed.
+  // Else, the payload will be left in the frame.
+  Http2Status AppendHeaderFrame(Http2HeaderFrame& frame) {
     // Validate input frame
     GRPC_DCHECK_GT(frame.stream_id, 0u)
         << "RFC9113 : HEADERS frames MUST be associated with a stream.";
 
+    // Validate assembler state
+    GRPC_DCHECK(!header_in_progress_);
+
     // Manage size constraints
     const size_t current_len = frame.payload.Length();
     if constexpr (sizeof(size_t) == 4) {
       if (GPR_UNLIKELY(buffer_.Length() >= UINT32_MAX - current_len)) {
-        Cleanup();
         LOG(ERROR)
             << "Stream Error: SliceBuffer overflow for 32 bit platforms.";
         return Http2Status::Http2StreamError(
@@ -109,11 +118,12 @@ class HeaderAssembler {
 
     // Manage payload
     frame.payload.MoveFirstNBytesIntoSliceBuffer(current_len, buffer_);
-    ASSEMBLER_LOG << "AppendHeaderFrame " << current_len << " Bytes.";
+    ASSEMBLER_LOG << "HeaderAssembler::AppendHeaderFrame " << current_len
+                  << " Bytes.";
 
     // Manage if last frame
     if (frame.end_headers) {
-      ASSEMBLER_LOG << "AppendHeaderFrame end_headers";
+      ASSEMBLER_LOG << "HeaderAssembler::AppendHeaderFrame end_headers";
       is_ready_ = true;
     }
 
@@ -121,16 +131,21 @@ class HeaderAssembler {
   }
 
   // Call this for each incoming HTTP2 Continuation frame.
-  // The payload of the Http2ContinuationFrame will be cleared in this function.
-  Http2Status AppendContinuationFrame(Http2ContinuationFrame&& frame) {
+  // If AppendContinuationFrame returns an OK status, the payload will be
+  // consumed. Else, the payload will be left in the frame.
+  Http2Status AppendContinuationFrame(Http2ContinuationFrame& frame) {
+    // Validate Assembler state
+    GRPC_DCHECK(header_in_progress_);
+
     // Manage payload
     const size_t current_len = frame.payload.Length();
     frame.payload.MoveFirstNBytesIntoSliceBuffer(current_len, buffer_);
-    ASSEMBLER_LOG << "AppendContinuationFrame " << current_len << " Bytes.";
+    ASSEMBLER_LOG << "HeaderAssembler::AppendContinuationFrame " << current_len
+                  << " Bytes.";
 
     // Manage if last frame
     if (frame.end_headers) {
-      ASSEMBLER_LOG << "AppendHeaderFrame end_headers";
+      ASSEMBLER_LOG << "HeaderAssembler::AppendContinuationFrame end_headers";
       is_ready_ = true;
     }
 
@@ -142,10 +157,13 @@ class HeaderAssembler {
       HPackParser& parser, bool is_initial_metadata, bool is_client,
       const uint32_t max_header_list_size_soft_limit,
       const uint32_t max_header_list_size_hard_limit) {
-    ASSEMBLER_LOG << "ReadMetadata " << buffer_.Length() << " Bytes.";
+    ASSEMBLER_LOG << "HeaderAssembler::ReadMetadata " << buffer_.Length()
+                  << " Bytes.";
 
     // Validate
     GRPC_DCHECK_EQ(is_ready_, true);
+    GRPC_DCHECK_GT(stream_id_, 0u)
+        << "Stream id must be set before reading metadata.";
 
     // Generate the gRPC Metadata from buffer_
     // RFC9113 :  A receiver MUST terminate the connection with a connection
@@ -162,48 +180,60 @@ class HeaderAssembler {
     // experiment of its own. For now we just honour allow_true_binary_metadata_
     // while writing frames for the peer on the write path. We do not enforce it
     // on the read path.
-    parser.BeginFrame(
-        /*grpc_metadata_batch*/ metadata.get(), max_header_list_size_soft_limit,
-        max_header_list_size_hard_limit,
-        is_initial_metadata ? HPackParser::Boundary::EndOfHeaders
-                            : HPackParser::Boundary::EndOfStream,
-        HPackParser::Priority::None,
-        HPackParser::LogInfo{stream_id_,
-                             is_initial_metadata
-                                 ? HPackParser::LogInfo::Type::kHeaders
-                                 : HPackParser::LogInfo::Type::kTrailers,
-                             is_client});
-    for (size_t i = 0; i < buffer_.Count(); i++) {
-      absl::Status result = parser.Parse(
-          buffer_.c_slice_at(i), i == buffer_.Count() - 1, SharedBitGen(),
-          /*call_tracer=*/nullptr);
-      if (GPR_UNLIKELY(!result.ok())) {
-        Cleanup();
-        LOG(ERROR) << "Connection Error: " << kAssemblerHpackError;
-        return Http2Status::Http2ConnectionError(
-            Http2ErrorCode::kCompressionError,
-            std::string(kAssemblerHpackError));
-      }
-    }
-    parser.FinishFrame();
-
+    Http2Status status = ParseHeader(
+        parser, std::move(buffer_), metadata.get(),
+        ParseHeaderArgs{
+            /*is_initial_metadata=*/is_initial_metadata,
+            /*is_end_headers=*/is_ready_,
+            /*is_client=*/is_client,
+            /*max_header_list_size_soft_limit=*/max_header_list_size_soft_limit,
+            /*max_header_list_size_hard_limit=*/max_header_list_size_hard_limit,
+            /*stream_id=*/stream_id_,
+        });
     Cleanup();
-
+    if (!status.IsOk()) {
+      return std::move(status);
+    }
     return ValueOrHttp2Status<Arena::PoolPtr<grpc_metadata_batch>>(
         std::move(metadata));
   }
 
+  Http2Status ParseAndDiscardHeaders(
+      HPackParser& parser, const bool is_initial_metadata, const bool is_client,
+      const uint32_t max_header_list_size_soft_limit,
+      const uint32_t max_header_list_size_hard_limit) {
+    ASSEMBLER_LOG << "HeaderAssembler::ParseAndDiscardHeaders "
+                  << buffer_.Length() << " Bytes"
+                  << " is_initial_metadata: " << is_initial_metadata
+                  << " is_client: " << is_client
+                  << " max_header_list_size_soft_limit: "
+                  << max_header_list_size_soft_limit
+                  << "max_header_list_size_hard_limit: "
+                  << max_header_list_size_hard_limit;
+    Http2Status status = ParseHeader(
+        parser, std::move(buffer_), /*grpc_metadata_batch=*/nullptr,
+        ParseHeaderArgs{
+            /*is_initial_metadata=*/is_initial_metadata,
+            /*is_end_headers=*/is_ready_,
+            /*is_client=*/is_client,
+            /*max_header_list_size_soft_limit=*/max_header_list_size_soft_limit,
+            /*max_header_list_size_hard_limit=*/max_header_list_size_hard_limit,
+            /*stream_id=*/stream_id_,
+        });
+    Cleanup();
+    return status;
+  }
+
   size_t GetBufferedHeadersLength() const { return buffer_.Length(); }
 
   // This value MUST be checked before calling ReadMetadata()
   bool IsReady() const { return is_ready_; }
 
-  explicit HeaderAssembler(const uint32_t stream_id,
-                           const bool allow_true_binary_metadata_acked)
+  explicit HeaderAssembler()
       : header_in_progress_(false),
         is_ready_(false),
-        allow_true_binary_metadata_acked_(allow_true_binary_metadata_acked),
-        stream_id_(stream_id) {}
+        allow_true_binary_metadata_acked_(true),
+        stream_id_(0) {}
 
   ~HeaderAssembler() = default;
 
@@ -212,6 +242,92 @@ class HeaderAssembler {
   HeaderAssembler(const HeaderAssembler&) = delete;
   HeaderAssembler& operator=(const HeaderAssembler&) = delete;
 
+  void InitializeStream(const uint32_t stream_id,
+                        const bool allow_true_binary_metadata_acked) {
+    GRPC_DCHECK_EQ(stream_id_, 0u);
+    GRPC_DCHECK_NE(stream_id, 0u);
+    stream_id_ = stream_id;
+    allow_true_binary_metadata_acked_ = allow_true_binary_metadata_acked;
+  }
+
+  // HPACK parser helpers
+  struct ParseHeaderArgs {
+    bool is_initial_metadata;
+    bool is_end_headers;
+    bool is_client;
+    uint32_t max_header_list_size_soft_limit;
+    uint32_t max_header_list_size_hard_limit;
+    uint32_t stream_id;
+
+    std::string DebugString() const {
+      return absl::StrCat(
+          "is_initial_metadata: ", is_initial_metadata,
+          " is_end_headers: ", is_end_headers, " is_client: ", is_client,
+          " max_header_list_size_soft_limit: ", max_header_list_size_soft_limit,
+          " max_header_list_size_hard_limit: ",
+          max_header_list_size_hard_limit);
+    }
+  };
+
+  static Http2Status ParseHeader(HPackParser& parser, SliceBuffer&& buffer,
+                                 grpc_metadata_batch* grpc_metadata_batch,
+                                 const ParseHeaderArgs args) {
+    parser.BeginFrame(
+        /*grpc_metadata_batch*/ grpc_metadata_batch,
+        args.max_header_list_size_soft_limit,
+        args.max_header_list_size_hard_limit,
+        GetBoundary(args.is_initial_metadata, args.is_end_headers),
+        HPackParser::Priority::None,
+        HPackParser::LogInfo{args.stream_id,
+                             args.is_initial_metadata
+                                 ? HPackParser::LogInfo::Type::kHeaders
+                                 : HPackParser::LogInfo::Type::kTrailers,
+                             args.is_client});
+    // TODO(tjagtap) [PH2][P5] Bug fix : Check if the received metadata honours
+    // allow_true_binary_metadata or not. Will need changes to HPack code.
+    absl::Status stream_error = absl::OkStatus();
+    for (size_t i = 0; i < buffer.Count(); i++) {
+      absl::Status result = parser.Parse(
+          buffer.c_slice_at(i), i == buffer.Count() - 1, SharedBitGen(),
+          /*call_tracer=*/nullptr);
+      if (GPR_UNLIKELY(!result.ok())) {
+        parser.StopBufferingFrame();
+        intptr_t unused;
+        if (grpc_error_get_int(result, StatusIntProperty::kStreamId, &unused)) {
+          // We need to keep parsing the other slices in slice buffer. Because
+          // HPACK state needs to be maintained for the other streams. Store the
+          // error and continue.
+          if (stream_error.ok()) {
+            stream_error = result;
+          }
+        } else {
+          LOG(ERROR) << "HPack Error: " << result;
+          return ToHttpOkOrConnError(result);
+        }
+      }
+    }
+    if (GPR_UNLIKELY(!stream_error.ok())) {
+      return Http2Status::AbslStreamError(stream_error.code(),
+                                          std::string(stream_error.message()));
+    }
+    parser.FinishFrame();
+    return Http2Status::Ok();
+  }
+
+  static HPackParser::Boundary GetBoundary(const bool is_initial_metadata,
+                                           const bool is_end_headers) {
+    HPackParser::Boundary boundary = HPackParser::Boundary::None;
+    if (is_end_headers) {
+      if (is_initial_metadata) {
+        boundary = HPackParser::Boundary::EndOfHeaders;
+      } else {
+        boundary = HPackParser::Boundary::EndOfStream;
+      }
+    }
+
+    return boundary;
+  }
+
  private:
   void Cleanup() {
     buffer_.Clear();
@@ -221,8 +337,8 @@ class HeaderAssembler {
 
   bool header_in_progress_;
   bool is_ready_;
-  GRPC_UNUSED const bool allow_true_binary_metadata_acked_;
-  const uint32_t stream_id_;
+  bool allow_true_binary_metadata_acked_;
+  uint32_t stream_id_;
   SliceBuffer buffer_;
 };
 
@@ -244,6 +360,9 @@ class HeaderDisassembler {
 
   Http2Frame GetNextFrame(const uint32_t max_frame_length,
                           bool& out_end_headers) {
+    GRPC_DCHECK_GT(stream_id_, 0u) << "Stream id must be set before getting "
+                                      "next Header/Continuation frame.";
+
     if (buffer_.Length() == 0 || is_done_) {
       GRPC_DCHECK(false) << "Calling code must check size using HasMoreData() "
                             "before GetNextFrame()";
@@ -273,14 +392,12 @@ class HeaderDisassembler {
 
   // A separate HeaderDisassembler object MUST be made for Initial Metadata and
   // Trailing Metadata
-  explicit HeaderDisassembler(const uint32_t stream_id,
-                              const bool is_trailing_metadata,
-                              const bool allow_true_binary_metadata_peer)
-      : stream_id_(stream_id),
+  explicit HeaderDisassembler(const bool is_trailing_metadata)
+      : stream_id_(0),
         end_stream_(is_trailing_metadata),
         did_send_header_frame_(false),
         is_done_(false),
-        allow_true_binary_metadata_peer_(allow_true_binary_metadata_peer) {}
+        allow_true_binary_metadata_peer_(false) {}
 
   ~HeaderDisassembler() = default;
 
@@ -290,13 +407,20 @@ class HeaderDisassembler {
   HeaderDisassembler& operator=(const HeaderDisassembler&) = delete;
 
   size_t TestOnlyGetMainBufferLength() const { return buffer_.Length(); }
+  void Initialize(const uint32_t stream_id,
+                  const bool allow_true_binary_metadata_peer) {
+    GRPC_DCHECK_EQ(stream_id_, 0u);
+    GRPC_DCHECK_NE(stream_id, 0u);
+    stream_id_ = stream_id;
+    allow_true_binary_metadata_peer_ = allow_true_binary_metadata_peer;
+  }
 
  private:
-  const uint32_t stream_id_;
+  uint32_t stream_id_;
   const bool end_stream_;
   bool did_send_header_frame_;
   bool is_done_;  // Protect against the same disassembler from being used twice
-  const bool allow_true_binary_metadata_peer_;
+  bool allow_true_binary_metadata_peer_;
   SliceBuffer buffer_;
 };
 

data/src/core/ext/transport/chttp2/transport/hpack_encoder.cc

@@ -25,7 +25,6 @@
 #include <algorithm>
 #include <cstdint>
 
-#include "absl/log/log.h"
 #include "src/core/ext/transport/chttp2/transport/bin_encoder.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder_table.h"
@@ -36,6 +35,7 @@
 #include "src/core/lib/transport/timeout_encoding.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/grpc_check.h"
+#include "absl/log/log.h"
 
 namespace grpc_core {
 

data/src/core/ext/transport/chttp2/transport/hpack_encoder.h

@@ -27,10 +27,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/log/log.h"
-#include "absl/strings/match.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/call/metadata_compression_traits.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
@@ -42,6 +38,10 @@
 #include "src/core/lib/transport/transport.h"
 #include "src/core/telemetry/call_tracer.h"
 #include "src/core/util/time.h"
+#include "absl/log/log.h"
+#include "absl/strings/match.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 

data/src/core/ext/transport/chttp2/transport/hpack_parse_result.cc

@@ -17,12 +17,12 @@
 #include <grpc/support/port_platform.h>
 #include <stddef.h>
 
-#include "absl/strings/str_format.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/status_helper.h"
+#include "absl/strings/str_format.h"
 
 namespace grpc_core {
 

data/src/core/ext/transport/chttp2/transport/hpack_parse_result.h

@@ -23,15 +23,15 @@
 #include <string>
 #include <utility>
 
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/lib/surface/validate_metadata.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 

data/src/core/ext/transport/chttp2/transport/hpack_parser.cc

@@ -30,13 +30,6 @@
 #include <utility>
 #include <variant>
 
-#include "absl/base/attributes.h"
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#include "absl/strings/match.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
-#include "absl/types/span.h"
 #include "src/core/call/metadata_info.h"
 #include "src/core/call/parsed_metadata.h"
 #include "src/core/ext/transport/chttp2/transport/decode_huff.h"
@@ -52,6 +45,13 @@
 #include "src/core/telemetry/stats_data.h"
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/match.h"
+#include "absl/base/attributes.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/match.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
 
 // IWYU pragma: no_include <type_traits>
 

data/src/core/ext/transport/chttp2/transport/hpack_parser.h

@@ -30,10 +30,6 @@
 #include <variant>
 #include <vector>
 
-#include "absl/random/bit_gen_ref.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
-#include "absl/types/span.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parse_result.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parser_table.h"
@@ -43,6 +39,10 @@
 #include "src/core/lib/slice/slice_refcount.h"
 #include "src/core/telemetry/call_tracer.h"
 #include "src/core/util/random_early_detection.h"
+#include "absl/random/bit_gen_ref.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
 
 // IWYU pragma: no_include <type_traits>
 

data/src/core/ext/transport/chttp2/transport/hpack_parser_table.cc

@@ -26,10 +26,6 @@
 #include <cstring>
 #include <utility>
 
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parse_result.h"
 #include "src/core/ext/transport/chttp2/transport/http2_stats_collector.h"
@@ -37,6 +33,10 @@
 #include "src/core/lib/slice/slice.h"
 #include "src/core/telemetry/stats.h"
 #include "src/core/util/grpc_check.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 

data/src/core/ext/transport/chttp2/transport/hpack_parser_table.h

@@ -28,7 +28,6 @@
 #include <string>
 #include <vector>
 
-#include "absl/functional/function_ref.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/call/parsed_metadata.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
@@ -36,6 +35,7 @@
 #include "src/core/ext/transport/chttp2/transport/http2_stats_collector.h"
 #include "src/core/util/no_destruct.h"
 #include "src/core/util/unique_ptr_with_bitset.h"
+#include "absl/functional/function_ref.h"
 
 namespace grpc_core {