grpc 1.81.1 → 1.83.1

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

@@ -97,6 +97,7 @@
 #include "src/core/lib/transport/status_conversion.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/lib/transport/transport_framing_endpoint_extension.h"
+#include "src/core/mitigation_engine/mitigation_engine.h"
 #include "src/core/telemetry/call_tracer.h"
 #include "src/core/telemetry/context_list_entry.h"
 #include "src/core/telemetry/default_tcp_tracer.h"
@@ -105,6 +106,7 @@
 #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"
@@ -155,6 +157,8 @@ static bool g_default_client_keepalive_permit_without_calls = false;
 static bool g_default_server_keepalive_permit_without_calls = false;
 
 #define MAX_CLIENT_STREAM_ID 0x7fffffffu
+uint32_t g_pending_induced_frames_hard_limit =
+    2u * DEFAULT_MAX_PENDING_INDUCED_FRAMES;
 
 // forward declarations of various callbacks that we'll build closures around
 static void write_action_begin_locked(
@@ -500,6 +504,7 @@ static void read_channel_args(grpc_chttp2_transport* t,
           .GetDurationFromIntMillis(GRPC_ARG_HTTP_TARPIT_MAX_DURATION_MS)
           .value_or(grpc_core::Duration::Seconds(1))
           .millis();
+  GRPC_CHECK(t->min_tarpit_duration_ms <= t->max_tarpit_duration_ms);
   t->max_header_list_size_soft_limit =
       grpc_core::GetSoftLimitFromChannelArgs(channel_args);
 
@@ -541,6 +546,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)
@@ -696,6 +705,7 @@ void grpc_chttp2_transport::WriteSecurityFrameLocked(
             GRPC_ERROR_CREATE("Unexpected SECURITY frame scheduled for write"),
             grpc_core::StatusIntProperty::kRpcStatus,
             GRPC_STATUS_FAILED_PRECONDITION));
+    return;
   }
   grpc_core::SliceBuffer security_frame;
   grpc_chttp2_security_frame_create(data->c_slice_buffer(), data->Length(),
@@ -736,7 +746,12 @@ grpc_chttp2_transport::grpc_chttp2_transport(
           channel_args.GetBool(GRPC_ARG_HTTP2_BDP_PROBE).value_or(true),
           &memory_owner),
       deframe_state(is_client ? GRPC_DTS_FH_0 : GRPC_DTS_CLIENT_PREFIX_0),
-      is_client(is_client) {
+      is_client(is_client),
+      mitigation_engine([&]() {
+        auto* provider =
+            channel_args.GetObject<grpc_core::MitigationEngineProvider>();
+        return provider == nullptr ? nullptr : provider->GetEngine();
+      }()) {
   context_list = new grpc_core::ContextList();
 
   if (channel_args.GetBool(GRPC_ARG_TCP_TRACING_ENABLED).value_or(false) &&
@@ -749,7 +764,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)));
     }
@@ -801,6 +817,7 @@ 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,
@@ -844,6 +861,9 @@ 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*/) {
@@ -864,6 +884,10 @@ 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 =
@@ -884,7 +908,12 @@ static void close_transport_locked(grpc_chttp2_transport* t,
     connectivity_state_set(t, GRPC_CHANNEL_SHUTDOWN, absl::Status(),
                            "close_transport");
     // TODO(roth, ctiller): Provide better disconnect info here.
-    t->NotifyStateWatcherOnDisconnectLocked(t->closed_with_error, {});
+    grpc_core::Transport::StateWatcher::DisconnectInfo disconnect_info;
+    if (t->sent_goaway_state == GRPC_CHTTP2_FINAL_GOAWAY_SENT) {
+      disconnect_info.reason = grpc_core::Transport::StateWatcher::kGoaway;
+    }
+    t->NotifyStateWatcherOnDisconnectLocked(t->closed_with_error,
+                                            disconnect_info);
     if (t->keepalive_ping_timeout_handle != TaskHandle::kInvalid) {
       t->event_engine->Cancel(std::exchange(t->keepalive_ping_timeout_handle,
                                             TaskHandle::kInvalid));
@@ -1357,14 +1386,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)
@@ -1490,7 +1516,8 @@ static grpc_closure* add_closure_barrier(grpc_closure* closure) {
   return closure;
 }
 
-static void null_then_sched_closure(grpc_closure** closure) {
+static void null_then_sched_closure_with_error(grpc_closure** closure,
+                                               grpc_error_handle error) {
   grpc_closure* c = *closure;
   *closure = nullptr;
   // null_then_schedule_closure might be run during a start_batch which might
@@ -1499,7 +1526,11 @@ static void null_then_sched_closure(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, absl::OkStatus());
+  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());
 }
 
 void grpc_chttp2_complete_closure_step(grpc_chttp2_transport* t,
@@ -2012,6 +2043,25 @@ void grpc_chttp2_ack_ping(grpc_chttp2_transport* t, uint64_t id) {
   }
 }
 
+grpc_error_handle grpc_chttp2_increase_num_pending_induced_frames(
+    grpc_chttp2_transport* t) {
+  t->num_pending_induced_frames++;
+  if (grpc_core::IsMemoryOptimization01Enabled()) {
+    if (GPR_UNLIKELY(t->num_pending_induced_frames >=
+                     g_pending_induced_frames_hard_limit)) {
+      LOG(ERROR) << "Too many pending induced frames. Closing transport.";
+      return GRPC_ERROR_CREATE("Too many pending induced frames");
+    }
+  }
+
+  return absl::OkStatus();
+}
+
+void grpc_chttp2_close_transport_locked(grpc_chttp2_transport* t,
+                                        grpc_error_handle error) {
+  close_transport_locked(t, error);
+}
+
 void grpc_chttp2_keepalive_timeout(
     grpc_core::RefCountedPtr<grpc_chttp2_transport> t) {
   t->combiner->Run(
@@ -2307,6 +2357,8 @@ 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);
   }
 }
@@ -2379,7 +2431,36 @@ 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);
       }
-      null_then_sched_closure(&s->recv_message_ready);
+      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);
     }
   }();
 
@@ -2508,8 +2589,12 @@ void grpc_chttp2_cancel_stream(
             if (t->is_client && !sent_initial_metadata) {
               return;
             }
-            grpc_chttp2_add_rst_stream_to_next_write(
+            grpc_error_handle error = grpc_chttp2_add_rst_stream_to_next_write(
                 t, id, static_cast<uint32_t>(http_error), nullptr);
+            if (GPR_UNLIKELY(!error.ok())) {
+              grpc_chttp2_close_transport_locked(t, error);
+              return;
+            }
             grpc_chttp2_initiate_write(t,
                                        GRPC_CHTTP2_INITIATE_WRITE_RST_STREAM);
           });
@@ -2855,9 +2940,12 @@ static void close_from_api(
           grpc_slice_buffer_add(&t->qbuf, message_slice.TakeCSlice());
         }
         grpc_chttp2_reset_ping_clock(t);
-        grpc_chttp2_add_rst_stream_to_next_write(
+        grpc_error_handle error = grpc_chttp2_add_rst_stream_to_next_write(
             t, id, static_cast<intptr_t>(Http2ErrorCode::kNoError), nullptr);
-
+        if (GPR_UNLIKELY(!error.ok())) {
+          grpc_chttp2_close_transport_locked(t, error);
+          return;
+        }
         grpc_chttp2_initiate_write(t,
                                    GRPC_CHTTP2_INITIATE_WRITE_CLOSE_FROM_API);
       });
@@ -2979,6 +3067,7 @@ static void read_action_parse_loop_locked(
     grpc_core::RefCountedPtr<grpc_chttp2_transport> t,
     grpc_error_handle error) {
   GRPC_LATENT_SEE_ALWAYS_ON_SCOPE("read_action_parse_loop_locked");
+  bool should_reset_buffer = true;
   if (t->closed_with_error.ok()) {
     grpc_error_handle errors[3] = {error, absl::OkStatus(), absl::OkStatus()};
     size_t requests_started = 0;
@@ -3004,6 +3093,19 @@ static void read_action_parse_loop_locked(
       } else {
         errors[1] = std::move(std::get<absl::Status>(r));
       }
+
+      if (grpc_core::IsMemoryOptimization02Enabled()) {
+        if (errors[1].ok() && (i + 1 < t->read_buffer.count) &&
+            t->num_pending_induced_frames >=
+                DEFAULT_MAX_PENDING_INDUCED_FRAMES) {
+          for (size_t j = 0; j <= i; j++) {
+            grpc_core::CSliceUnref(
+                grpc_slice_buffer_take_first(&t->read_buffer));
+          }
+          should_reset_buffer = false;
+          break;
+        }
+      }
     }
     if (errors[1] != absl::OkStatus()) {
       errors[2] = try_http_parsing(t.get());
@@ -3045,7 +3147,9 @@ static void read_action_parse_loop_locked(
       maybe_reset_keepalive_ping_timer_locked(t.get());
     }
   }
-  grpc_slice_buffer_reset_and_unref(&t->read_buffer);
+  if (should_reset_buffer) {
+    grpc_slice_buffer_reset_and_unref(&t->read_buffer);
+  }
 
   if (keep_reading) {
     if (t->num_pending_induced_frames >= DEFAULT_MAX_PENDING_INDUCED_FRAMES) {
@@ -3084,6 +3188,16 @@ static void read_action_locked(
 
 static void continue_read_action_locked(
     grpc_core::RefCountedPtr<grpc_chttp2_transport> t) {
+  if (grpc_core::IsMemoryOptimization02Enabled()) {
+    if (t->read_buffer.count > 0) {
+      auto* tp = t.get();
+      tp->combiner->Run(
+          grpc_core::InitTransportClosure<read_action_parse_loop_locked>(
+              std::move(t), &tp->read_action_locked),
+          absl::OkStatus());
+      return;
+    }
+  }
   const bool urgent = !t->goaway_error.ok();
   auto* tp = t.get();
   grpc_endpoint_read(tp->ep.get(), &tp->read_buffer,

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

@@ -28,6 +28,7 @@
 
 #include "src/core/channelz/channelz.h"
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
+#include "src/core/ext/transport/chttp2/transport/http2_status.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/buffer_list.h"

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 =
@@ -315,7 +315,7 @@ FlowControlAction TransportFlowControl::PeriodicUpdate() {
                         Http2Settings::max_max_frame_size()),
                   &action, &FlowControlAction::set_send_max_frame_size_update);
 
-    if (IsTcpFrameSizeTuningEnabled()) {
+    if (IsTcpFrameSizeTuningEnabled() && ph2_enable_rx_crypto_) {
       // Advertise PREFERRED_RECEIVE_CRYPTO_FRAME_SIZE to peer. By advertising
       // PREFERRED_RECEIVE_CRYPTO_FRAME_SIZE to the peer, we are informing the
       // peer that we have tcp frame size tuning enabled and we inform it of our

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

@@ -201,11 +201,16 @@ 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() {}
 
   bool bdp_probe() const { return enable_bdp_probe_; }
+  bool ph2_enable_rx_crypto() const { return ph2_enable_rx_crypto_; }
+  void set_ph2_enable_rx_crypto(const bool enable) {
+    ph2_enable_rx_crypto_ = enable;
+  }
 
   // Returns a non-zero announce if we should send a transport update to our
   // peer, else returns zero; writing_anyway indicates if a write would happen
@@ -314,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(); }
@@ -471,6 +476,13 @@ class TransportFlowControl final {
   uint32_t acked_init_window_ = kDefaultWindow;
   uint32_t sent_init_window_ = kDefaultWindow;
   absl::flat_hash_set<uint32_t> window_update_list_;
+
+  // Preferred_rx_crypto_frame_sizes are advertised to the peer
+  // For CHTTP2, this is always true.
+  // For PH2, this is set by the transport based on the channel arg
+  // GRPC_ARG_EXPERIMENTAL_HTTP2_PREFERRED_CRYPTO_FRAME_SIZE.
+  // TODO(tjagtap) [PH2][CHTTP2] Edit comment when CHTTP2 is getting deleted.
+  bool ph2_enable_rx_crypto_ = true;
 };
 
 // Implementation of flow control that abides to HTTP/2 spec and attempts

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

@@ -45,16 +45,14 @@ constexpr int64_t kZero = 0;
 // This function does the settings related tasks equivalent to
 // grpc_chttp2_act_on_flowctl_action in chttp2_transport.cc
 inline void ActOnFlowControlActionSettings(
-    const chttp2::FlowControlAction& action, Http2Settings& local_settings,
-    const bool enable_preferred_rx_crypto_frame_advertisement) {
+    const chttp2::FlowControlAction& action, Http2Settings& local_settings) {
   if (action.send_initial_window_update() != kNoActionNeeded) {
     local_settings.SetInitialWindowSize(action.initial_window_size());
   }
   if (action.send_max_frame_size_update() != kNoActionNeeded) {
     local_settings.SetMaxFrameSize(action.max_frame_size());
   }
-  if (enable_preferred_rx_crypto_frame_advertisement &&
-      action.preferred_rx_crypto_frame_size_update() != kNoActionNeeded) {
+  if (action.preferred_rx_crypto_frame_size_update() != kNoActionNeeded) {
     local_settings.SetPreferredReceiveCryptoMessageSize(
         action.preferred_rx_crypto_frame_size());
   }

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

@@ -33,7 +33,7 @@
 #include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 
-// TODO(tjagtap) TODO(akshitpatel): [PH2][P3] : Write micro benchmarks for
+// TODO(tjagtap) TODO(akshitpatel): [PH2][P4] : Write micro benchmarks for
 // framing code
 
 using grpc_core::http2::Http2ErrorCode;
@@ -650,7 +650,6 @@ ValueOrHttp2Status<Http2Frame> ParseWindowUpdateFrame(
 
 ValueOrHttp2Status<Http2Frame> ParseSecurityFrame(
     const Http2FrameHeader& /*hdr*/, SliceBuffer& payload) {
-  // TODO(tjagtap) : [PH2][P3] : Add validations
   return ValueOrHttp2Status<Http2Frame>(Http2SecurityFrame{std::move(payload)});
 }
 
@@ -828,10 +827,18 @@ void AppendGrpcHeaderToSliceBuffer(SliceBuffer& payload, const uint32_t flags,
 Http2Status ValidateFrameHeader(const uint32_t max_frame_size_setting,
                                 const bool incoming_header_in_progress,
                                 const uint32_t incoming_header_stream_id,
-                                Http2FrameHeader& current_frame_header,
+                                const Http2FrameHeader& current_frame_header,
                                 const uint32_t last_stream_id,
                                 const bool is_client,
-                                const bool is_first_settings_processed) {
+                                const bool is_first_settings_processed,
+                                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 =
+      current_frame_header.type ==
+      static_cast<uint8_t>(FrameType::kContinuation);
+
   if (GPR_UNLIKELY(!is_first_settings_processed)) {
     // This check works only because we pause the read loop after reading the
     // first SETTINGS frame.
@@ -854,11 +861,30 @@ Http2Status ValidateFrameHeader(const uint32_t max_frame_size_setting,
                      ", Current Size = ", current_frame_header.length,
                      ", Max Size = ", max_frame_size_setting));
   }
-  if (GPR_UNLIKELY(
-          incoming_header_in_progress &&
-          (current_frame_header.type !=
-               static_cast<uint8_t>(FrameType::kContinuation) ||
-           current_frame_header.stream_id != incoming_header_stream_id))) {
+
+  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
+  // frame types or frames for other streams may be interleaved during this
+  // sequence.
+  const bool did_frame_violate_header_block_sequence =
+      (incoming_header_in_progress &&
+       (!is_continuation_frame ||
+        current_frame_header.stream_id != incoming_header_stream_id));
+  const bool did_receive_unexpected_continuation_frame =
+      (!incoming_header_in_progress && is_continuation_frame);
+  if (GPR_UNLIKELY(did_frame_violate_header_block_sequence ||
+                   did_receive_unexpected_continuation_frame)) {
     return Http2Status::Http2ConnectionError(
         Http2ErrorCode::kProtocolError,
         std::string(RFC9113::kAssemblerContiguousSequenceError));
@@ -868,13 +894,94 @@ Http2Status ValidateFrameHeader(const uint32_t max_frame_size_setting,
   // as in gRPC only clients can initiate a stream. last_stream_id is the stream
   // id of the last stream created by the transport. If no streams were created
   // by the transport, last_stream_id is 0.
-  // TODO(akshitpatel) : [PH2][P3] : Revisit this for server.
-  if (is_client && current_frame_header.stream_id > last_stream_id) {
-    return Http2Status::Http2ConnectionError(
-        Http2ErrorCode::kProtocolError, std::string(RFC9113::kUnknownStreamId));
+  if (GPR_UNLIKELY(current_frame_header.stream_id > last_stream_id)) {
+    const bool is_metadata_frame =
+        current_frame_header.type == static_cast<uint8_t>(FrameType::kHeader) ||
+        is_continuation_frame;
+    if (GPR_UNLIKELY(is_client)) {
+      return Http2Status::Http2ConnectionError(
+          Http2ErrorCode::kProtocolError,
+          std::string(RFC9113::kUnknownStreamId));
+    } else if (GPR_UNLIKELY(!is_metadata_frame)) {
+      // For servers, if the stream id is not known, it means the Headers have
+      // not been received for this stream yet. This means that the stream is
+      // still in idle state. A stream in idle state cannot receive any frames
+      // other than HEADERS or PRIORITY.
+      return Http2Status::Http2ConnectionError(
+          Http2ErrorCode::kProtocolError,
+          std::string(RFC9113::kIdleStreamError));
+    }
+  }
+
+  if (GPR_UNLIKELY(is_continuation_frame && current_frame_header.length == 0u &&
+                   (current_frame_header.flags & kFlagEndHeaders) == 0u)) {
+    tracker.noop_continuation_frames++;
+    if (GPR_UNLIKELY(tracker.noop_continuation_frames >=
+                     kMaxNoopContinuationFrames)) {
+      return Http2Status::Http2ConnectionError(
+          Http2ErrorCode::kInternalError,
+          std::string(GrpcErrors::kTooManyZeroLengthContinuationFrames));
+    }
   }
+
+  if (GPR_UNLIKELY(is_data_frame && current_frame_header.length == 0u &&
+                   (current_frame_header.flags & kFlagEndStream) == 0u)) {
+    tracker.noop_data_frames++;
+    if (GPR_UNLIKELY(tracker.noop_data_frames >= kMaxNoopDataFrames)) {
+      return Http2Status::Http2ConnectionError(
+          Http2ErrorCode::kInternalError,
+          std::string(GrpcErrors::kTooManyZeroLengthDataFrames));
+    }
+  }
+
   // TODO(tjagtap) : [PH2][P2]:Consider validating MAX_CONCURRENT_STREAMS here
   // for server.
   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.
+
+*/