grpc 1.81.1 → 1.83.1

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

@@ -269,18 +269,39 @@ http2::ValueOrHttp2Status<GrpcMessageHeader> ExtractGrpcHeader(
 void AppendGrpcHeaderToSliceBuffer(SliceBuffer& payload, uint32_t flags,
                                    uint32_t length);
 
+///////////////////////////////////////////////////////////////////////////////
+// Frame limits
+
+constexpr uint16_t kMaxNoopDataFrames = 16384u;
+constexpr uint16_t kMaxNoopContinuationFrames = 128u;
+
+struct Http2FrameCountTracker {
+  void OnLastContinuationFrame() { noop_continuation_frames = 0u; }
+
+  std::string DebugString() const {
+    return absl::StrCat(
+        "{ noop_continuation_frames : ", noop_continuation_frames,
+        ", noop_data_frames : ", noop_data_frames, "}");
+  }
+
+  uint16_t noop_continuation_frames = 0u;
+  uint16_t noop_data_frames = 0u;
+};
+
 ///////////////////////////////////////////////////////////////////////////////
 // Validations
 
 http2::Http2Status ValidateSettingsValues(
     std::vector<Http2SettingsFrame::Setting>& list);
 
-http2::Http2Status ValidateFrameHeader(uint32_t max_frame_size_setting,
-                                       bool incoming_header_in_progress,
-                                       uint32_t incoming_header_stream_id,
-                                       Http2FrameHeader& current_frame_header,
-                                       uint32_t last_stream_id, bool is_client,
-                                       bool is_first_settings_processed);
+// The checks in this function MUST be done before the frame payload is read.
+http2::Http2Status ValidateFrameHeader(
+    const uint32_t max_frame_size_setting,
+    const bool incoming_header_in_progress,
+    const uint32_t incoming_header_stream_id,
+    const Http2FrameHeader& current_frame_header, const uint32_t last_stream_id,
+    const bool is_client, const bool is_first_settings_processed,
+    Http2FrameCountTracker& tracker, const uint32_t max_security_frame_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 // RFC9113 Related Strings and Consts
@@ -344,8 +365,7 @@ inline constexpr absl::string_view kPaddingLengthLargerThanFrameLength =
 // Misc Errors
 inline constexpr absl::string_view kNoPushPromise =
     "RFC9113: PUSH_PROMISE MUST NOT be sent if the SETTINGS_ENABLE_PUSH "
-    "setting of the "
-    "peer endpoint is set to 0";
+    "setting of the peer endpoint is set to 0";
 
 inline constexpr absl::string_view kAssemblerContiguousSequenceError =
     "RFC9113 : Field blocks MUST be transmitted as a contiguous sequence "
@@ -389,6 +409,11 @@ inline constexpr absl::string_view kFirstSettingsFrameServer =
     "empty. Clients and servers MUST treat an invalid connection preface as a "
     "connection error of type PROTOCOL_ERROR.";
 
+inline constexpr absl::string_view kIdleStreamError =
+    "Stream Idle : Receiving any frame other than HEADERS or PRIORITY on a "
+    "stream in this state MUST be treated as a connection error of type "
+    "PROTOCOL_ERROR.";
+
 inline constexpr uint32_t kMaxStreamId31Bit = 0x7fffffffu;
 inline constexpr uint32_t kMaxSize31Bit = 0x7fffffffu;
 inline constexpr uint32_t kMinimumFrameSize = 16384;
@@ -400,12 +425,34 @@ inline constexpr uint32_t kHttp2InitialWindowSize = 65535u;
 }  // namespace RFC9113
 
 namespace GrpcErrors {
+
 inline constexpr absl::string_view kTooManyMetadata =
     "gRPC Error : A gRPC server can send upto 1 initial metadata followed by "
     "upto 1 trailing metadata.";
 inline constexpr absl::string_view kOutOfOrderDataFrame =
-    "gRPC Error : DATA frames must follow initial metadata and precede "
-    "trailing metadata.";
+    "gRPC Transport Error : DATA frames must follow initial metadata and "
+    "precede trailing metadata.";
+inline constexpr absl::string_view kTooManyZeroLengthContinuationFrames =
+    "gRPC Transport Error : Received too many zero length CONTINUATION frames "
+    "without end_headers flag set";
+inline constexpr absl::string_view kTooManyZeroLengthDataFrames =
+    "gRPC Transport Error : Received too many zero length DATA frames";
+inline constexpr absl::string_view kUnsolicitedSettingsAck =
+    "gRPC Transport Error : Received unsolicited SETTINGS ACK.";
+inline constexpr absl::string_view kFailedToEnqueueStream =
+    "gRPC Transport Error : Failed to enqueue stream to writable stream list";
+inline constexpr absl::string_view kStreamCreationFailed =
+    "gRPC Transport Error : Stream creation failed";
+
+inline constexpr uint32_t kDefaultMaxPendingInducedFrames = 10000u;
+
+// Security frame related limits and errors
+inline constexpr uint32_t kMaxSecurityFrameSize = 16u * 1024u;
+inline constexpr int kMinMaxSecurityFrameSize = 0;
+inline constexpr absl::string_view kSecurityFrameTooLarge =
+    "gRPC Transport Error : Security frame is larger than the maximum allowed "
+    "size : ";
+
 }  // namespace GrpcErrors
 
 }  // namespace grpc_core

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

@@ -48,6 +48,7 @@ absl::Status grpc_chttp2_data_parser_begin_frame(uint8_t flags,
   } else {
     s->received_last_frame = false;
   }
+  ++s->num_frames;
 
   return absl::OkStatus();
 }
@@ -123,6 +124,24 @@ grpc_core::Poll<grpc_error_handle> grpc_deframe_unprocessed_incoming_frames(
                   (static_cast<uint32_t>(header[3]) << 8) |
                   static_cast<uint32_t>(header[4]);
 
+  if (grpc_core::IsMessageSizeRefactoringEnabled()) {
+    if (s->max_recv_message_length.has_value() &&
+        length > *(s->max_recv_message_length)) {
+      error = GRPC_ERROR_CREATE(
+          absl::StrFormat("%s: Received message larger than max (%d vs. %u)",
+                          s->t->is_client ? "CLIENT" : "SERVER", length,
+                          *(s->max_recv_message_length)));
+      error = grpc_error_set_int(error, grpc_core::StatusIntProperty::kStreamId,
+                                 static_cast<intptr_t>(s->id));
+      // Attach the explicit gRPC status code to fail the RPC correctly.
+      error =
+          grpc_error_set_int(error, grpc_core::StatusIntProperty::kRpcStatus,
+                             GRPC_STATUS_RESOURCE_EXHAUSTED);
+      s->message_size_limit_exceeded = true;
+      return error;
+    }
+  }
+
   if (slices->length < length + GRPC_HEADER_SIZE_IN_BYTES) {
     if (min_progress_size != nullptr) {
       *min_progress_size = length + GRPC_HEADER_SIZE_IN_BYTES - slices->length;
@@ -138,6 +157,7 @@ grpc_core::Poll<grpc_error_handle> grpc_deframe_unprocessed_incoming_frames(
     grpc_slice_buffer_move_first_into_buffer(slices, GRPC_HEADER_SIZE_IN_BYTES,
                                              header);
     grpc_slice_buffer_move_first(slices, length, stream_out->c_slice_buffer());
+    s->num_frames = 0;
   }
 
   return absl::OkStatus();
@@ -148,8 +168,20 @@ grpc_error_handle grpc_chttp2_data_parser_parse(void* /*parser*/,
                                                 grpc_chttp2_stream* s,
                                                 const grpc_slice& slice,
                                                 int is_last) {
-  grpc_core::CSliceRef(slice);
-  grpc_slice_buffer_add(&s->frame_storage, slice);
+  const size_t slice_len = GRPC_SLICE_LENGTH(slice);
+  bool is_small_frame = 0 < slice_len && slice_len < GRPC_SLICE_INLINED_SIZE;
+  bool multiple_small_frames =
+      (s->num_frames >= 64) &&
+      ((s->frame_storage.length / s->num_frames) < GRPC_SLICE_INLINED_SIZE);
+  if (GPR_UNLIKELY(multiple_small_frames && is_small_frame &&
+                   grpc_core::IsHeaderDataFrameEnabled())) {
+    uint8_t* append_ptr =
+        grpc_slice_buffer_tiny_add(&s->frame_storage, slice_len);
+    memcpy(append_ptr, GRPC_SLICE_START_PTR(slice), slice_len);
+  } else {
+    grpc_core::CSliceRef(slice);
+    grpc_slice_buffer_add(&s->frame_storage, slice);
+  }
   grpc_chttp2_maybe_complete_recv_message(t, s);
 
   if (is_last) {

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

@@ -31,11 +31,15 @@
 #include "absl/strings/string_view.h"
 
 void grpc_chttp2_goaway_parser_init(grpc_chttp2_goaway_parser* p) {
-  p->debug_data = nullptr;
+  if (!grpc_core::IsPh2Perf01Enabled()) {
+    p->debug_data = nullptr;
+  }
 }
 
 void grpc_chttp2_goaway_parser_destroy(grpc_chttp2_goaway_parser* p) {
-  gpr_free(p->debug_data);
+  if (!grpc_core::IsPh2Perf01Enabled()) {
+    gpr_free(p->debug_data);
+  }
 }
 
 grpc_error_handle grpc_chttp2_goaway_parser_begin_frame(
@@ -45,10 +49,14 @@ grpc_error_handle grpc_chttp2_goaway_parser_begin_frame(
         absl::StrFormat("goaway frame too short (%d bytes)", length));
   }
 
-  gpr_free(p->debug_data);
   p->debug_length = length - 8;
-  p->debug_data = static_cast<char*>(gpr_malloc(p->debug_length));
-  p->debug_pos = 0;
+  if (grpc_core::IsPh2Perf01Enabled()) {
+    p->debug_slice_buffer.Clear();
+  } else {
+    gpr_free(p->debug_data);
+    p->debug_data = static_cast<char*>(gpr_malloc(p->debug_length));
+    p->debug_pos = 0;
+  }
   p->state = GRPC_CHTTP2_GOAWAY_LSI0;
   return absl::OkStatus();
 }
@@ -130,24 +138,48 @@ grpc_error_handle grpc_chttp2_goaway_parser_parse(void* parser,
       ++cur;
       [[fallthrough]];
     case GRPC_CHTTP2_GOAWAY_DEBUG:
-      if (end != cur) {
-        memcpy(p->debug_data + p->debug_pos, cur,
-               static_cast<size_t>(end - cur));
-      }
-      GRPC_CHECK((size_t)(end - cur) < UINT32_MAX - p->debug_pos);
-      p->debug_pos += static_cast<uint32_t>(end - cur);
-      p->state = GRPC_CHTTP2_GOAWAY_DEBUG;
-      if (is_last) {
-        t->http2_ztrace_collector.Append([p]() {
-          return grpc_core::H2GoAwayTrace<true>{
-              p->last_stream_id, p->error_code,
-              std::string(absl::string_view(p->debug_data, p->debug_length))};
-        });
-        grpc_chttp2_add_incoming_goaway(
-            t, p->error_code, p->last_stream_id,
-            absl::string_view(p->debug_data, p->debug_length));
-        gpr_free(p->debug_data);
-        p->debug_data = nullptr;
+      if (grpc_core::IsPh2Perf01Enabled()) {
+        if (end != cur) {
+          p->debug_slice_buffer.AppendIndexed(
+              grpc_core::Slice::FromCopiedBuffer(
+                  cur, static_cast<size_t>(end - cur)));
+        }
+        GRPC_CHECK(p->debug_slice_buffer.Length() <= p->debug_length);
+        p->state = GRPC_CHTTP2_GOAWAY_DEBUG;
+        if (is_last) {
+          std::string debug_str = p->debug_slice_buffer.JoinIntoString();
+
+          grpc_chttp2_add_incoming_goaway(t, p->error_code, p->last_stream_id,
+                                          absl::string_view(debug_str));
+
+          t->http2_ztrace_collector.Append(
+              [last_stream_id = p->last_stream_id, error_code = p->error_code,
+               debug_str = std::move(debug_str)]() mutable {
+                return grpc_core::H2GoAwayTrace<true>{
+                    last_stream_id, error_code, std::move(debug_str)};
+              });
+          p->debug_slice_buffer.Clear();
+        }
+      } else {
+        if (end != cur) {
+          memcpy(p->debug_data + p->debug_pos, cur,
+                 static_cast<size_t>(end - cur));
+        }
+        GRPC_CHECK((size_t)(end - cur) < UINT32_MAX - p->debug_pos);
+        p->debug_pos += static_cast<uint32_t>(end - cur);
+        p->state = GRPC_CHTTP2_GOAWAY_DEBUG;
+        if (is_last) {
+          t->http2_ztrace_collector.Append([p]() {
+            return grpc_core::H2GoAwayTrace<true>{
+                p->last_stream_id, p->error_code,
+                std::string(absl::string_view(p->debug_data, p->debug_length))};
+          });
+          grpc_chttp2_add_incoming_goaway(
+              t, p->error_code, p->last_stream_id,
+              absl::string_view(p->debug_data, p->debug_length));
+          gpr_free(p->debug_data);
+          p->debug_data = nullptr;
+        }
       }
       return absl::OkStatus();
   }

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

@@ -44,6 +44,7 @@ struct grpc_chttp2_goaway_parser {
   uint32_t last_stream_id;
   uint32_t error_code;
   char* debug_data;
+  grpc_core::SliceBuffer debug_slice_buffer;
   uint32_t debug_length;
   uint32_t debug_pos;
 };

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

@@ -115,13 +115,16 @@ grpc_error_handle grpc_chttp2_ping_parser_parse(void* parser,
             << "CLIENT[" << t << "]: received ping " << p->opaque_8bytes;
       }
       if (t->ack_pings) {
+        grpc_error_handle error =
+            grpc_chttp2_increase_num_pending_induced_frames(t);
+        if (GPR_UNLIKELY(!error.ok())) return error;
+
         if (t->ping_ack_count == t->ping_ack_capacity) {
           t->ping_ack_capacity =
               std::max(t->ping_ack_capacity * 3 / 2, size_t{3});
           t->ping_acks = static_cast<uint64_t*>(gpr_realloc(
               t->ping_acks, t->ping_ack_capacity * sizeof(*t->ping_acks)));
         }
-        t->num_pending_induced_frames++;
         t->ping_acks[t->ping_ack_count++] = p->opaque_8bytes;
         grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_PING_RESPONSE);
       }

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

@@ -74,13 +74,18 @@ grpc_slice grpc_chttp2_rst_stream_create(
   return slice;
 }
 
-void grpc_chttp2_add_rst_stream_to_next_write(
+grpc_error_handle grpc_chttp2_add_rst_stream_to_next_write(
     grpc_chttp2_transport* t, uint32_t id, uint32_t code,
     grpc_core::CallTracerInterface* call_tracer) {
-  t->num_pending_induced_frames++;
+  grpc_error_handle error = grpc_chttp2_increase_num_pending_induced_frames(t);
+  if (GPR_UNLIKELY(!error.ok())) {
+    return error;
+  }
+
   grpc_slice_buffer_add(
       &t->qbuf, grpc_chttp2_rst_stream_create(id, code, call_tracer,
                                               &t->http2_ztrace_collector));
+  return absl::OkStatus();
 }
 
 grpc_error_handle grpc_chttp2_rst_stream_parser_begin_frame(
@@ -127,17 +132,18 @@ grpc_error_handle grpc_chttp2_rst_stream_parser_parse(void* parser,
     if (reason != static_cast<uint32_t>(Http2ErrorCode::kNoError) ||
         s->trailing_metadata_buffer.empty()) {
       error = grpc_error_set_int(
-          grpc_error_set_str(
-              GRPC_ERROR_CREATE("RST_STREAM"),
-              grpc_core::StatusStrProperty::kGrpcMessage,
-              absl::StrCat("Received RST_STREAM with error code ", reason)),
+          GRPC_ERROR_CREATE(absl::StrCat(
+              "RST_STREAM (Received RST_STREAM with error code ", reason, ")")),
           grpc_core::StatusIntProperty::kHttp2Error,
           static_cast<intptr_t>(reason));
     }
     grpc_core::SharedBitGen g;
     if (!t->is_client &&
         absl::Bernoulli(g, t->ping_on_rst_stream_percent / 100.0)) {
-      ++t->num_pending_induced_frames;
+      grpc_error_handle error =
+          grpc_chttp2_increase_num_pending_induced_frames(t);
+      if (GPR_UNLIKELY(!error.ok())) return error;
+
       t->ping_callbacks.RequestPing();
       grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_KEEPALIVE_PING);
     }

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

@@ -41,7 +41,7 @@ grpc_slice grpc_chttp2_rst_stream_create(
 // Adds RST_STREAM frame to t->qbuf (buffer for the next write). Should be
 // called when we want to add RST_STREAM and we are not in
 // write_action_begin_locked.
-void grpc_chttp2_add_rst_stream_to_next_write(
+grpc_error_handle grpc_chttp2_add_rst_stream_to_next_write(
     grpc_chttp2_transport* t, uint32_t id, uint32_t code,
     grpc_core::CallTracerInterface* call_tracer);
 

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

@@ -27,6 +27,7 @@
 #include "src/core/lib/transport/transport_framing_endpoint_extension.h"
 #include "src/core/util/grpc_check.h"
 #include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
 
 absl::Status grpc_chttp2_security_frame_parser_parse(void* parser,
                                                      grpc_chttp2_transport* t,
@@ -52,7 +53,15 @@ absl::Status grpc_chttp2_security_frame_parser_parse(void* parser,
 }
 
 absl::Status grpc_chttp2_security_frame_parser_begin_frame(
-    grpc_chttp2_security_frame_parser* parser) {
+    grpc_chttp2_security_frame_parser* parser, const uint32_t length,
+    const uint32_t max_frame_size) {
+  if (GPR_UNLIKELY(length > max_frame_size &&
+                   grpc_core::IsCustomFrameCheckEnabled())) {
+    return GRPC_ERROR_CREATE(absl::StrCat(
+        "gRPC Transport Error : Security frame is larger than the maximum "
+        "allowed size : ",
+        max_frame_size, ", Received size : ", length));
+  }
   parser->payload.Clear();
   return absl::OkStatus();
 }

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

@@ -35,7 +35,8 @@ void grpc_chttp2_security_frame_create(grpc_slice_buffer* payload,
                                        grpc_slice_buffer* frame);
 
 absl::Status grpc_chttp2_security_frame_parser_begin_frame(
-    grpc_chttp2_security_frame_parser* parser);
+    grpc_chttp2_security_frame_parser* parser, uint32_t length,
+    uint32_t max_frame_size);
 
 grpc_error_handle grpc_chttp2_security_frame_parser_parse(
     void* parser, grpc_chttp2_transport* t, grpc_chttp2_stream* s,

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

@@ -136,7 +136,10 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
                 []() { return grpc_core::H2SettingsTrace<false>{true, {}}; });
             *parser->target_settings = *parser->incoming_settings;
             t->MaybeNotifyStateWatcherOfPeerMaxConcurrentStreamsLocked();
-            t->num_pending_induced_frames++;
+            grpc_error_handle error =
+                grpc_chttp2_increase_num_pending_induced_frames(t);
+            if (GPR_UNLIKELY(!error.ok())) return error;
+
             grpc_slice_buffer_add(&t->qbuf, grpc_chttp2_settings_ack_create());
             grpc_chttp2_initiate_write(t,
                                        GRPC_CHTTP2_INITIATE_WRITE_SETTINGS_ACK);

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

@@ -32,6 +32,7 @@ GoawayManager::GoawayManager(std::unique_ptr<GoawayInterface> goaway_interface)
 std::optional<Http2Frame> GoawayManager::MaybeGetGoawayFrame() {
   switch (context_->goaway_state) {
     case GoawayState::kIdle:
+    case GoawayState::kInitialGracefulGoawaySent:
     case GoawayState::kDone:
       break;
     case GoawayState::kInitialGracefulGoawayScheduled: {
@@ -85,9 +86,16 @@ void GoawayManager::Context::SentGoawayTransition() {
                         << GoawayStateToString(goaway_state);
   switch (goaway_state) {
     case GoawayState::kIdle:
-    case GoawayState::kInitialGracefulGoawayScheduled:
+    case GoawayState::kInitialGracefulGoawaySent:
     case GoawayState::kDone:
       break;
+    case GoawayState::kInitialGracefulGoawayScheduled: {
+      GRPC_HTTP2_GOAWAY_LOG
+          << "Transitioning to kInitialGracefulGoawaySent from "
+          << GoawayStateToString(goaway_state);
+      goaway_state = GoawayState::kInitialGracefulGoawaySent;
+      break;
+    }
     case GoawayState::kFinalGracefulGoawayScheduled:
     case GoawayState::kImmediateGoawayRequested: {
       GRPC_HTTP2_GOAWAY_LOG << "Transitioning to kDone from "
@@ -109,6 +117,8 @@ std::string GoawayManager::Context::GoawayStateToString(
       return "kIdle";
     case GoawayState::kInitialGracefulGoawayScheduled:
       return "kInitialGracefulGoawayScheduled";
+    case GoawayState::kInitialGracefulGoawaySent:
+      return "kInitialGracefulGoawaySent";
     case GoawayState::kFinalGracefulGoawayScheduled:
       return "kFinalGracefulGoawayScheduled";
     case GoawayState::kImmediateGoawayRequested:

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

@@ -64,6 +64,8 @@ enum class GoawayState : uint8_t {
   // Initial graceful GOAWAY is scheduled to be sent in the next transport write
   // cycle.
   kInitialGracefulGoawayScheduled,
+  // Initial graceful GOAWAY has been written on the wire.
+  kInitialGracefulGoawaySent,
   // Final graceful GOAWAY is scheduled to be sent in the next transport write
   // cycle. Sending this GOAWAY frame completes the graceful GOAWAY process and
   // transitions the state to kDone.
@@ -161,6 +163,7 @@ class GoawayManager {
     absl::Status TriggerWriteCycle();
 
     GoawayState goaway_state = GoawayState::kIdle;
+    bool was_immediate = false;
     std::unique_ptr<GoawayInterface> goaway_interface;
     // TODO(akshitpatel) : [PH2][P4] : There is scope to make this
     // IntractivityWaker.
@@ -222,6 +225,7 @@ class GoawayManager {
                             << " -> "
                                "kImmediateGoawayRequested.";
 
+      ctx->was_immediate = true;
       ctx->goaway_state = GoawayState::kImmediateGoawayRequested;
       ctx->SetGoawayArgs(
           /*error_code=*/static_cast<uint32_t>(error_code),
@@ -275,6 +279,7 @@ class GoawayManager {
                                 << " -> "
                                    "kInitialGracefulGoawayScheduled.";
           GRPC_DCHECK(error_code == Http2ErrorCode::kNoError);
+          ctx->was_immediate = false;
           ctx->goaway_state = GoawayState::kInitialGracefulGoawayScheduled;
           ctx->SetGoawayArgs(
               /*error_code=*/static_cast<uint32_t>(Http2ErrorCode::kNoError),
@@ -290,7 +295,7 @@ class GoawayManager {
                               << "Ping resolved. Current state: "
                               << ctx->GoawayStateToString(ctx->goaway_state);
                           if (ctx->goaway_state ==
-                              GoawayState::kInitialGracefulGoawayScheduled) {
+                              GoawayState::kInitialGracefulGoawaySent) {
                             GRPC_HTTP2_GOAWAY_LOG
                                 << " [Graceful GOAWAY] state change "
                                 << ctx->GoawayStateToString(ctx->goaway_state)
@@ -349,6 +354,17 @@ class GoawayManager {
     return context_->goaway_state == GoawayState::kImmediateGoawayRequested;
   }
 
+  bool IsFinalGracefulGoawayScheduledOrSent() const {
+    return (context_->goaway_state ==
+            GoawayState::kFinalGracefulGoawayScheduled) ||
+           IsFinalGracefulGoawaySent();
+  }
+
+  bool IsFinalGracefulGoawaySent() const {
+    return context_->goaway_state == GoawayState::kDone &&
+           !context_->was_immediate;
+  }
+
   // Called from the transport write cycle to notify the GOAWAY manager that a
   // GOAWAY frame may have been sent. If a GOAWAY frame is sent in current
   // write cycle, this function handles the needed state transition.

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

@@ -23,6 +23,7 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <optional>
 #include <string>
 #include <utility>
 
@@ -41,7 +42,7 @@
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 
-// TODO(tjagtap) TODO(akshitpatel): [PH2][P3] : Write micro benchmarks for
+// TODO(akshitpatel): [PH2][P4] : Write micro benchmarks for
 // assembler and disassembler code
 
 namespace grpc_core {
@@ -100,6 +101,8 @@ class HeaderAssembler {
 
     // Start header workflow
     header_in_progress_ = true;
+    GRPC_DCHECK_GT(stream_id_, 0u);
+    GRPC_DCHECK_EQ(stream_id_, frame.stream_id);
 
     // Manage payload
     frame.payload.MoveFirstNBytesIntoSliceBuffer(current_len, buffer_);
@@ -121,6 +124,8 @@ class HeaderAssembler {
   Http2Status AppendFrame(Http2ContinuationFrame& frame) {
     // Validate Assembler state
     GRPC_DCHECK(header_in_progress_);
+    GRPC_DCHECK_GT(stream_id_, 0u);
+    GRPC_DCHECK_EQ(stream_id_, frame.stream_id);
 
     // Manage payload
     const size_t current_len = frame.payload.Length();
@@ -195,18 +200,27 @@ class HeaderAssembler {
                   << 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;
+    if (buffer_.Length() > 0) {
+      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;
+    }
+
+    GRPC_DCHECK(!is_ready_);
+    GRPC_DCHECK(buffer_.Length() == 0);
+    GRPC_DCHECK(!header_in_progress_);
+    return Http2Status::Ok();
   }
 
   size_t GetBufferedHeadersLength() const { return buffer_.Length(); }
@@ -217,7 +231,6 @@ class HeaderAssembler {
   explicit HeaderAssembler(const bool is_client)
       : header_in_progress_(false),
         is_ready_(false),
-        allow_true_binary_metadata_acked_(true),
         is_client_(is_client),
         stream_id_(0) {}
 
@@ -228,12 +241,24 @@ 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);
+  // This is set only once in the lifetime of a transport.
+  // TODO(tjagtap) [PH2][P3] : This value in settings can only be set once as
+  // the allow_true_binary_metadata setting is sent only once. Re-think this
+  // once we add actual use of this value.
+  void MaybeSetAllowTrueBinaryMetadataAcked(
+      const bool allow_true_binary_metadata_acked) {
+    if (allow_true_binary_metadata_acked_.has_value()) {
+      return;
+    }
+    allow_true_binary_metadata_acked_ = allow_true_binary_metadata_acked;
+  }
+
+  void SetStreamId(uint32_t stream_id) {
     GRPC_DCHECK_NE(stream_id, 0u);
+    GRPC_DCHECK(!header_in_progress_);
+    GRPC_DCHECK_EQ(is_ready_, false);
+    GRPC_DCHECK(buffer_.Length() == 0);
     stream_id_ = stream_id;
-    allow_true_binary_metadata_acked_ = allow_true_binary_metadata_acked;
   }
 
   // HPACK parser helpers
@@ -250,14 +275,15 @@ class HeaderAssembler {
           "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);
+          " max_header_list_size_hard_limit: ", max_header_list_size_hard_limit,
+          " stream_id:", stream_id);
     }
   };
 
   static Http2Status ParseHeader(HPackParser& parser, SliceBuffer&& buffer,
                                  grpc_metadata_batch* grpc_metadata_batch,
                                  const ParseHeaderArgs args) {
+    // TODO(alishananda): Propagate mitigation engine here.
     parser.BeginFrame(
         /*grpc_metadata_batch*/ grpc_metadata_batch,
         args.max_header_list_size_soft_limit,
@@ -268,7 +294,8 @@ class HeaderAssembler {
                              args.is_initial_metadata
                                  ? HPackParser::LogInfo::Type::kHeaders
                                  : HPackParser::LogInfo::Type::kTrailers,
-                             args.is_client});
+                             args.is_client},
+        /*mitigation_engine=*/nullptr);
     // 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();
@@ -314,16 +341,21 @@ class HeaderAssembler {
     return boundary;
   }
 
+  std::optional<bool> TestOnlyAllowTrueBinaryMetadataAcked() const {
+    return allow_true_binary_metadata_acked_;
+  }
+
  private:
   void Cleanup() {
     buffer_.Clear();
     header_in_progress_ = false;
     is_ready_ = false;
+    stream_id_ = 0;
   }
 
   bool header_in_progress_;
   bool is_ready_;
-  bool allow_true_binary_metadata_acked_;
+  std::optional<bool> allow_true_binary_metadata_acked_;
   const bool is_client_;
   uint32_t stream_id_;
   SliceBuffer buffer_;