grpc 1.82.2 → 1.83.0.pre1

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

@@ -106,7 +106,6 @@
 #include "src/core/telemetry/stats_data.h"
 #include "src/core/telemetry/tcp_tracer.h"
 #include "src/core/transport/auth_context.h"
-#include "src/core/transport/message_size_service_config.h"
 #include "src/core/util/bitset.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/debug_location.h"
@@ -546,6 +545,10 @@ static void read_channel_args(grpc_chttp2_transport* t,
 
   t->settings.mutable_local().SetAllowSecurityFrame(
       channel_args.GetBool(GRPC_ARG_SECURITY_FRAME_ALLOWED).value_or(false));
+  t->max_security_frame_size = static_cast<uint32_t>(grpc_core::Clamp(
+      channel_args.GetInt(GRPC_ARG_MAX_SECURITY_FRAME_SIZE)
+          .value_or(kMaxSecurityFrameSize),
+      kMinMaxSecurityFrameSize, static_cast<int>(kMaxSecurityFrameSize)));
 
   t->ping_on_rst_stream_percent = grpc_core::Clamp(
       channel_args.GetInt(GRPC_ARG_HTTP2_PING_ON_RST_STREAM_PERCENT)
@@ -760,7 +763,8 @@ grpc_chttp2_transport::grpc_chttp2_transport(
         grpc_core::GlobalStatsPluginRegistry::StatsPluginGroup>();
     if (epte != nullptr && stats_plugin_group != nullptr) {
       epte->EnableTcpTelemetry(stats_plugin_group->GetCollectionScope(),
-                               /*is_control_endpoint=*/false);
+                               /*is_control_endpoint=*/false,
+                               /*trace_full_buffer=*/false);
       epte->SetTcpTracer(std::make_shared<grpc_core::DefaultTcpTracer>(
           std::move(stats_plugin_group)));
     }
@@ -812,7 +816,6 @@ grpc_chttp2_transport::grpc_chttp2_transport(
           Ref(), &init_keepalive_ping_locked),
       absl::OkStatus());
 
-  // TODO(tjagtap) : [PH2][P0] : Do this for PH2.
   if (flow_control.bdp_probe()) {
     bdp_ping_blocked = true;
     grpc_chttp2_act_on_flowctl_action(flow_control.PeriodicUpdate(), this,
@@ -856,9 +859,6 @@ grpc_chttp2_transport::grpc_chttp2_transport(
       epte->SetSocketNode(channelz_socket);
     }
   }
-
-  max_recv_message_length =
-      grpc_core::GetMaxRecvSizeFromChannelArgs(channel_args);
 }
 
 static void destroy_transport_locked(void* tp, grpc_error_handle /*error*/) {
@@ -879,10 +879,6 @@ static void close_transport_locked(grpc_chttp2_transport* t,
                                    grpc_error_handle error) {
   end_all_the_calls(t, error);
   cancel_pings(t, error);
-  if (t->transport_framing_endpoint_extension != nullptr) {
-    t->transport_framing_endpoint_extension->SetSendFrameCallback(nullptr);
-    t->transport_framing_endpoint_extension = nullptr;
-  }
   if (t->closed_with_error.ok()) {
     if (!grpc_error_has_clear_grpc_status(error)) {
       error =
@@ -1381,14 +1377,11 @@ void grpc_chttp2_add_incoming_goaway(grpc_chttp2_transport* t,
                                      uint32_t last_stream_id,
                                      absl::string_view goaway_text) {
   t->goaway_error = grpc_error_set_int(
-      grpc_error_set_int(
-          grpc_core::StatusCreate(
-              absl::StatusCode::kUnavailable,
-              absl::StrFormat("GOAWAY received; Error code: %u; Debug Text: %s",
-                              goaway_error, goaway_text),
-              DEBUG_LOCATION, {}),
-          grpc_core::StatusIntProperty::kHttp2Error,
-          static_cast<intptr_t>(goaway_error)),
+      grpc_error_set_int(absl::UnavailableError(absl::StrFormat(
+                             "GOAWAY received; Error code: %u; Debug Text: %s",
+                             goaway_error, goaway_text)),
+                         grpc_core::StatusIntProperty::kHttp2Error,
+                         static_cast<intptr_t>(goaway_error)),
       grpc_core::StatusIntProperty::kRpcStatus, GRPC_STATUS_UNAVAILABLE);
 
   GRPC_TRACE_LOG(http, INFO)
@@ -1514,8 +1507,7 @@ static grpc_closure* add_closure_barrier(grpc_closure* closure) {
   return closure;
 }
 
-static void null_then_sched_closure_with_error(grpc_closure** closure,
-                                               grpc_error_handle error) {
+static void null_then_sched_closure(grpc_closure** closure) {
   grpc_closure* c = *closure;
   *closure = nullptr;
   // null_then_schedule_closure might be run during a start_batch which might
@@ -1524,11 +1516,7 @@ static void null_then_sched_closure_with_error(grpc_closure** closure,
   // completion, have the application see it, and make a new operation on the
   // call which recycles the batch BEFORE the call to start_batch completes,
   // forcing a race.
-  grpc_core::ExecCtx::Run(DEBUG_LOCATION, c, error);
-}
-
-static void null_then_sched_closure(grpc_closure** closure) {
-  null_then_sched_closure_with_error(closure, absl::OkStatus());
+  grpc_core::ExecCtx::Run(DEBUG_LOCATION, c, absl::OkStatus());
 }
 
 void grpc_chttp2_complete_closure_step(grpc_chttp2_transport* t,
@@ -2355,8 +2343,6 @@ void grpc_chttp2_maybe_complete_recv_initial_metadata(grpc_chttp2_transport* t,
       t->registered_method_matcher_cb(t->accept_stream_cb_user_data,
                                       s->recv_initial_metadata);
     }
-    s->max_recv_message_length =
-        GetMaxRecvSizeFromCallContext(s->arena, t->max_recv_message_length);
     null_then_sched_closure(&s->recv_initial_metadata_ready);
   }
 }
@@ -2429,36 +2415,7 @@ void grpc_chttp2_maybe_complete_recv_message(grpc_chttp2_transport* t,
         *s->call_failed_before_recv_message =
             (s->published_metadata[1] != GRPC_METADATA_PUBLISHED_AT_CLOSE);
       }
-      if (s->seen_error && s->message_size_limit_exceeded) {
-        null_then_sched_closure_with_error(&s->recv_message_ready, error);
-      } else {
-        null_then_sched_closure(&s->recv_message_ready);
-      }
-    } else if (s->seen_error && s->message_size_limit_exceeded) {
-      null_then_sched_closure_with_error(&s->recv_message_ready, error);
-    }
-
-    if (grpc_core::IsMessageSizeRefactoringEnabled() && s->seen_error &&
-        s->message_size_limit_exceeded) {
-      s->message_size_limit_exceeded = false;
-      // Explicitly cancel the stream to fail the RPC immediately.
-      // We delay the cancellation until the recv_message_ready closure is
-      // executed to prevent re-entrancy issues. When the HTTP/2 frame deframer
-      // in `grpc_deframe_unprocessed_incoming_frames`
-      // returns a size violation error, invoking `grpc_chttp2_cancel_stream`
-      // immediately triggers `grpc_chttp2_mark_stream_closed`. This in turn
-      // synchronously re-enters `grpc_chttp2_maybe_complete_recv_message` while
-      // the original deframing loop is still active on the call stack.
-      //
-      // Because the re-entrant invocation observes that the incoming frame
-      // storage has been cleared but `s->recv_message_ready` is still non-null,
-      // it preemptively schedules the closure as a standard/non-error stream
-      // termination (i.e., via `null_then_sched_closure(...,
-      // absl::OkStatus())`). By the time control returns to the initial (outer)
-      // deframing loop to execute `null_then_sched_closure_with_error`, the
-      // closure pointer is already null, causing the original error context to
-      // be discarded.
-      grpc_chttp2_cancel_stream(t, s, error, true, nullptr);
+      null_then_sched_closure(&s->recv_message_ready);
     }
   }();
 

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

@@ -119,12 +119,12 @@ std::string FlowControlAction::ImmediateUpdateReasons() const {
   return result;
 }
 
-TransportFlowControl::TransportFlowControl(absl::string_view name,
+TransportFlowControl::TransportFlowControl(absl::string_view peer_name,
                                            bool enable_bdp_probe,
                                            MemoryOwner* memory_owner)
     : memory_owner_(memory_owner),
       enable_bdp_probe_(enable_bdp_probe),
-      bdp_estimator_(name) {}
+      bdp_estimator_(peer_name) {}
 
 uint32_t TransportFlowControl::DesiredAnnounceSize(bool writing_anyway) const {
   const uint32_t target_announced_window =

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

@@ -201,7 +201,8 @@ std::ostream& operator<<(std::ostream& out, const FlowControlAction& action);
 // This class manages the flow control at a connection level.
 class TransportFlowControl final {
  public:
-  explicit TransportFlowControl(absl::string_view name, bool enable_bdp_probe,
+  explicit TransportFlowControl(absl::string_view peer_name,
+                                bool enable_bdp_probe,
                                 MemoryOwner* memory_owner);
   ~TransportFlowControl() {}
 
@@ -318,7 +319,7 @@ class TransportFlowControl final {
   // Call periodically (at a low-ish rate, 100ms - 10s makes sense)
   // to perform more complex flow control calculations and return an action
   // to let the transport change its parameters.
-  // TODO(tjagtap) [PH2][P2] Plumb with PH2 flow control.
+  // TODO(tjagtap) [PH2][P2][FCV3] Plumb with PH2 flow control.
   FlowControlAction PeriodicUpdate();
 
   int64_t test_only_target_window() const { return target_window(); }

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

@@ -831,7 +831,8 @@ Http2Status ValidateFrameHeader(const uint32_t max_frame_size_setting,
                                 const uint32_t last_stream_id,
                                 const bool is_client,
                                 const bool is_first_settings_processed,
-                                Http2FrameCountTracker& tracker) {
+                                Http2FrameCountTracker& tracker,
+                                const uint32_t max_security_frame_size) {
   const bool is_data_frame =
       current_frame_header.type == static_cast<uint8_t>(FrameType::kData);
   const bool is_continuation_frame =
@@ -861,6 +862,16 @@ Http2Status ValidateFrameHeader(const uint32_t max_frame_size_setting,
                      ", Max Size = ", max_frame_size_setting));
   }
 
+  if (GPR_UNLIKELY(current_frame_header.type ==
+                       static_cast<uint8_t>(FrameType::kCustomSecurity) &&
+                   current_frame_header.length > max_security_frame_size)) {
+    return Http2Status::Http2ConnectionError(
+        Http2ErrorCode::kFrameSizeError,
+        absl::StrCat(GrpcErrors::kSecurityFrameTooLarge,
+                     max_security_frame_size,
+                     ", Received size : ", current_frame_header.length));
+  }
+
   // RFC 9113 (Section 6.10) requires that if a HEADERS frame does not have
   // END_HEADERS set, it must be followed by a contiguous sequence of
   // CONTINUATION frames for the same stream, ending with END_HEADERS. No other
@@ -928,3 +939,49 @@ Http2Status ValidateFrameHeader(const uint32_t max_frame_size_setting,
   return Http2Status::Ok();
 }
 }  // namespace grpc_core
+
+/*
+A note on Security Frames
+
+Security Frame is a custom frame defined by gRPC.
+
+SECURITY Frame
+
+   The SECURITY frame (type=200) is used to transmit out-of-band security and
+   transport-level privacy information between peers.
+
+   Both peers MUST agree to allow SECURITY frames.
+
+    +------------------------+
+    |     Payload Length     |
+    |          (24)          |
+    +--------+--------+------+
+    |  Type  | Flags  |
+    |  (200) |  (8)   |
+    +-+------+--------+---------------+
+    |R|       Stream Identifier       |
+    | |             (31)              |
+    +=+===============================+
+    |      Security Payload (*)     ...
+    +---------------------------------+
+
+   The SECURITY frame payload contains opaque data intended for the registered
+   transport framing endpoint extension.
+
+   The SECURITY frame does not define flags.
+
+Payload Size Limits and Chunking
+
+   The current implementation of the SECURITY frame has a HARD limit of 16,384
+   bytes (16 KB) for its payload.
+
+   This strict 16 KB limit is enforced because 16,384 bytes is the minimum
+   valid value for SETTINGS_MAX_FRAME_SIZE (the smallest maximum frame size an
+   HTTP/2 peer is allowed to advertise). Currently, the SECURITY frame does not
+   support chunking. Therefore, if a peer attempts to send a SECURITY payload
+   larger than the receiver's advertised SETTINGS_MAX_FRAME_SIZE, the endpoint
+   MUST treat this as a CONNECTION ERROR of type FRAME_SIZE_ERROR. By enforcing
+a hard 16 KB upper bound, we guarantee that the frame will safely fit within any
+compliant peer's single-frame receive buffer without requiring payload chunking.
+
+*/

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

@@ -294,13 +294,14 @@ struct Http2FrameCountTracker {
 http2::Http2Status ValidateSettingsValues(
     std::vector<Http2SettingsFrame::Setting>& list);
 
+// 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);
+    Http2FrameCountTracker& tracker, const uint32_t max_security_frame_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 // RFC9113 Related Strings and Consts
@@ -424,6 +425,7 @@ 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.";
@@ -441,6 +443,16 @@ 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,7 +48,6 @@ absl::Status grpc_chttp2_data_parser_begin_frame(uint8_t flags,
   } else {
     s->received_last_frame = false;
   }
-  ++s->num_frames;
 
   return absl::OkStatus();
 }
@@ -124,24 +123,6 @@ 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;
@@ -157,7 +138,6 @@ 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();
@@ -168,20 +148,8 @@ grpc_error_handle grpc_chttp2_data_parser_parse(void* /*parser*/,
                                                 grpc_chttp2_stream* s,
                                                 const grpc_slice& slice,
                                                 int is_last) {
-  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_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,15 +31,11 @@
 #include "absl/strings/string_view.h"
 
 void grpc_chttp2_goaway_parser_init(grpc_chttp2_goaway_parser* p) {
-  if (!grpc_core::IsPh2Perf01Enabled()) {
-    p->debug_data = nullptr;
-  }
+  p->debug_data = nullptr;
 }
 
 void grpc_chttp2_goaway_parser_destroy(grpc_chttp2_goaway_parser* p) {
-  if (!grpc_core::IsPh2Perf01Enabled()) {
-    gpr_free(p->debug_data);
-  }
+  gpr_free(p->debug_data);
 }
 
 grpc_error_handle grpc_chttp2_goaway_parser_begin_frame(
@@ -49,14 +45,10 @@ 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;
-  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->debug_data = static_cast<char*>(gpr_malloc(p->debug_length));
+  p->debug_pos = 0;
   p->state = GRPC_CHTTP2_GOAWAY_LSI0;
   return absl::OkStatus();
 }
@@ -138,48 +130,24 @@ grpc_error_handle grpc_chttp2_goaway_parser_parse(void* parser,
       ++cur;
       [[fallthrough]];
     case GRPC_CHTTP2_GOAWAY_DEBUG:
-      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;
-        }
+      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,7 +44,6 @@ 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_rst_stream.cc

@@ -132,10 +132,8 @@ 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));
     }

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/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/hpack_parser.cc

@@ -996,6 +996,15 @@ class HPackParser::Parser {
       }
     }
     auto value_slice = value.value.Take();
+    if (IsOptimization05Enabled() && !state_.is_binary_header &&
+        state_.field_error.ok()) {
+      auto r =
+          ValidateNonBinaryHeaderValueIsLegal(value_slice.as_string_view());
+      if (r != ValidateMetadataResult::kOk) {
+        input_->SetErrorAndContinueParsing(
+            HpackParseResult::InvalidMetadataError(r, key_string));
+      }
+    }
     const auto transport_size =
         key_string.size() + value.wire_size + hpack_constants::kEntryOverhead;
     if (state_.mitigation_engine != nullptr) {