grpc 1.75.0 → 1.78.1

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/check.h"
-#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
-    DCHECK_GT(frame.stream_id, 0u)
+    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
-    DCHECK_EQ(is_ready_, true);
+    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
@@ -154,44 +172,68 @@ class HeaderAssembler {
     // connection error (Section 5.4.1) of type COMPRESSION_ERROR.
     Arena::PoolPtr<grpc_metadata_batch> metadata =
         Arena::MakePooledForOverwrite<grpc_metadata_batch>();
-    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();
-
+    // TODO(tjagtap) : [PH2][P5] : Currently the transport does not enforce
+    // setting allow_true_binary_metadata_ sent to the peer.
+    // Ideally Hpack code must validate and enforce this setting but it is not
+    // doing so now. Given that this is complex code and also common between
+    // CHTTP2 and PH2, we must do this as a standalone project with an
+    // 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.
+    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)
-      : header_in_progress_(false), is_ready_(false), stream_id_(stream_id) {}
+  explicit HeaderAssembler()
+      : header_in_progress_(false),
+        is_ready_(false),
+        allow_true_binary_metadata_acked_(true),
+        stream_id_(0) {}
 
   ~HeaderAssembler() = default;
 
@@ -200,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();
@@ -209,7 +337,8 @@ class HeaderAssembler {
 
   bool header_in_progress_;
   bool is_ready_;
-  const uint32_t stream_id_;
+  bool allow_true_binary_metadata_acked_;
+  uint32_t stream_id_;
   SliceBuffer buffer_;
 };
 
@@ -223,16 +352,20 @@ class HeaderDisassembler {
   bool PrepareForSending(Arena::PoolPtr<grpc_metadata_batch>&& metadata,
                          HPackCompressor& encoder) {
     // Validate disassembler state
-    DCHECK(!is_done_);
+    GRPC_DCHECK(!is_done_);
     // Prepare metadata for sending
-    return encoder.EncodeRawHeaders(*metadata.get(), buffer_);
+    return encoder.EncodeRawHeaders(*metadata.get(), buffer_,
+                                    allow_true_binary_metadata_peer_);
   }
 
   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_) {
-      DCHECK(false) << "Calling code must check size using HasMoreData() "
-                       "before GetNextFrame()";
+      GRPC_DCHECK(false) << "Calling code must check size using HasMoreData() "
+                            "before GetNextFrame()";
     }
     out_end_headers = buffer_.Length() <= max_frame_length;
     SliceBuffer temp;
@@ -259,12 +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)
-      : 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) {}
+        is_done_(false),
+        allow_true_binary_metadata_peer_(false) {}
 
   ~HeaderDisassembler() = default;
 
@@ -274,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
-
+  bool allow_true_binary_metadata_peer_;
   SliceBuffer buffer_;
 };
 

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

@@ -25,8 +25,6 @@
 #include <algorithm>
 #include <cstdint>
 
-#include "absl/log/check.h"
-#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 +34,8 @@
 #include "src/core/lib/surface/validate_metadata.h"
 #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 {
 
@@ -61,7 +61,7 @@ static void FillHeader(uint8_t* p, uint8_t type, uint32_t id, size_t len,
   // max_frame_size is derived from GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE,
   // which has a max allowable value of 16777215 (see chttp_transport.cc).
   // Thus, the following assert can be a debug assert.
-  DCHECK_LE(len, 16777216u);
+  GRPC_DCHECK_LE(len, 16777216u);
   *p++ = static_cast<uint8_t>(len >> 16);
   *p++ = static_cast<uint8_t>(len >> 8);
   *p++ = static_cast<uint8_t>(len);

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 {
 
@@ -369,8 +369,10 @@ class HPackCompressor {
   }
 
   template <typename HeaderSet>
-  bool EncodeRawHeaders(const HeaderSet& headers, SliceBuffer& output) {
-    hpack_encoder_detail::Encoder encoder(this, true, output);
+  bool EncodeRawHeaders(const HeaderSet& headers, SliceBuffer& output,
+                        bool allow_true_binary_metadata) {
+    hpack_encoder_detail::Encoder encoder(this, allow_true_binary_metadata,
+                                          output);
     headers.Encode(&encoder);
     return !encoder.saw_encoding_errors();
   }

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

@@ -18,15 +18,15 @@
 
 #include <algorithm>
 
-#include "absl/log/check.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
 uint32_t HPackEncoderTable::AllocateIndex(size_t element_size) {
-  DCHECK_GE(element_size, 32u);
+  GRPC_DCHECK_GE(element_size, 32u);
 
   uint32_t new_index = tail_remote_index_ + table_elems_ + 1;
-  DCHECK(element_size <= MaxEntrySize());
+  GRPC_DCHECK_LE(element_size, MaxEntrySize());
 
   if (element_size > max_table_size_) {
     while (table_size_ > 0) {
@@ -41,7 +41,7 @@ uint32_t HPackEncoderTable::AllocateIndex(size_t element_size) {
   while (table_size_ + element_size > max_table_size_) {
     EvictOne();
   }
-  CHECK(table_elems_ < elem_size_.size());
+  GRPC_CHECK(table_elems_ < elem_size_.size());
   elem_size_[new_index % elem_size_.size()] =
       static_cast<uint16_t>(element_size);
   table_size_ += element_size;
@@ -70,17 +70,17 @@ bool HPackEncoderTable::SetMaxSize(uint32_t max_table_size) {
 
 void HPackEncoderTable::EvictOne() {
   tail_remote_index_++;
-  CHECK_GT(tail_remote_index_, 0u);
-  CHECK_GT(table_elems_, 0u);
+  GRPC_CHECK_GT(tail_remote_index_, 0u);
+  GRPC_CHECK_GT(table_elems_, 0u);
   auto removing_size = elem_size_[tail_remote_index_ % elem_size_.size()];
-  CHECK(table_size_ >= removing_size);
+  GRPC_CHECK(table_size_ >= removing_size);
   table_size_ -= removing_size;
   table_elems_--;
 }
 
 void HPackEncoderTable::Rebuild(uint32_t capacity) {
   decltype(elem_size_) new_elem_size(capacity);
-  CHECK_LE(table_elems_, capacity);
+  GRPC_CHECK_LE(table_elems_, capacity);
   for (uint32_t i = 0; i < table_elems_; i++) {
     uint32_t ofs = tail_remote_index_ + i + 1;
     new_elem_size[ofs % capacity] = elem_size_[ofs % elem_size_.size()];

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/log/check.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 {
 
@@ -52,7 +52,7 @@ class MetadataSizeLimitExceededEncoder {
 };
 
 absl::Status MakeStreamError(absl::Status error) {
-  DCHECK(!error.ok());
+  GRPC_DCHECK(!error.ok());
   return grpc_error_set_int(std::move(error), StatusIntProperty::kStreamId, 0);
 }
 }  // namespace

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

@@ -23,15 +23,15 @@
 #include <string>
 #include <utility>
 
-#include "absl/log/check.h"
-#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 {
 
@@ -191,7 +191,7 @@ class HpackParseResult {
 
   static HpackParseResult InvalidMetadataError(ValidateMetadataResult result,
                                                absl::string_view key) {
-    DCHECK(result != ValidateMetadataResult::kOk);
+    GRPC_DCHECK(result != ValidateMetadataResult::kOk);
     HpackParseResult p{HpackParseStatus::kInvalidMetadata};
     p.state_->key = std::string(key);
     p.state_->validate_metadata_result = result;