grpc 1.81.1 → 1.83.0

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

@@ -116,7 +116,7 @@ Http2ErrorCode Http2Settings::Apply(uint16_t key, uint32_t value) {
       max_frame_size_ = value;
       break;
     case kMaxHeaderListSizeWireId:
-      max_header_list_size_ = std::min(value, 16777216u);
+      max_header_list_size_ = std::min(value, kDefaultMaxHeaderListSize);
       break;
     case kGrpcAllowTrueBinaryMetadataWireId:
       if (value > 1) return Http2ErrorCode::kProtocolError;

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

@@ -20,6 +20,7 @@
 #include <grpc/support/port_platform.h>
 #include <stdint.h>
 
+#include <algorithm>
 #include <cstdint>
 #include <optional>
 
@@ -48,6 +49,25 @@ class Http2Settings {
     kGrpcAllowSecurityFrameWireId = 65029,
   };
 
+  constexpr static uint8_t kNumSettings = 9u;
+
+  // RFC9113 defines the default value for some of these settings.
+  // https://datatracker.ietf.org/doc/html/rfc9113#name-defined-settings
+  // RFC defined defaults for RFC defined settings :
+  constexpr static uint32_t kDefaultHeaderTableSize = 4096u;
+  constexpr static uint32_t kDefaultMaxConcurrentStreams = 4294967295u;
+  constexpr static uint32_t kDefaultInitialWindowSize = 65535u;
+  constexpr static uint32_t kDefaultMaxFrameSize = 16384u;
+  constexpr static bool kDefaultEnablePush = true;
+
+  // gRPC defined defaults for RFC defined settings :
+  constexpr static uint32_t kDefaultMaxHeaderListSize = 16777216u;
+
+  // gRPC defined defaults.
+  constexpr static uint32_t kDefaultPreferredReceiveCryptoMessageSize = 0u;
+  constexpr static bool kDefaultAllowTrueBinaryMetadata = false;
+  constexpr static bool kDefaultAllowSecurityFrame = false;
+
   void Diff(bool is_first_send, const Http2Settings& old_setting,
             absl::FunctionRef<void(uint16_t key, uint32_t value)> cb) const;
   GRPC_MUST_USE_RESULT http2::Http2ErrorCode Apply(uint16_t key,
@@ -79,7 +99,7 @@ class Http2Settings {
   }
   void SetEnablePush(bool x) { enable_push_ = x; }
   void SetMaxHeaderListSize(uint32_t x) {
-    max_header_list_size_ = std::min(x, 16777216u);
+    max_header_list_size_ = std::min(x, kDefaultMaxHeaderListSize);
   }
   void SetAllowTrueBinaryMetadata(bool x) { allow_true_binary_metadata_ = x; }
   void SetMaxFrameSize(uint32_t x) {
@@ -124,6 +144,23 @@ class Http2Settings {
     return 2147483647u;
   }
 
+  static bool IsKnownSettingId(const uint16_t id) {
+    switch (id) {
+      case kHeaderTableSizeWireId:
+      case kEnablePushWireId:
+      case kMaxConcurrentStreamsWireId:
+      case kInitialWindowSizeWireId:
+      case kMaxFrameSizeWireId:
+      case kMaxHeaderListSizeWireId:
+      case kGrpcAllowTrueBinaryMetadataWireId:
+      case kGrpcPreferredReceiveCryptoFrameSizeWireId:
+      case kGrpcAllowSecurityFrameWireId:
+        return true;
+      default:
+        return false;
+    }
+  }
+
   static std::string WireIdToName(uint16_t wire_id);
 
   bool operator==(const Http2Settings& rhs) const {
@@ -159,45 +196,42 @@ class Http2Settings {
   // RFC9113 states the default value for SETTINGS_HEADER_TABLE_SIZE
   // Currently this is set only once in the lifetime of a transport.
   // We plan to change that in the future.
-  uint32_t header_table_size_ = 4096u;
+  uint32_t header_table_size_ = kDefaultHeaderTableSize;
 
-  // TODO(tjagtap) [PH2][P4] : Get the history of why this default was decided
-  // and write it here.
   // CLIENT : Set only once in the lifetime of a client transport. This is set
   // to 0 for client.
   // SERVER : This setting can change for the server. This is usually changed to
   // handle memory pressure.
-  uint32_t initial_max_concurrent_streams_ = 4294967295u;
-  uint32_t max_concurrent_streams_ = 4294967295u;
+  uint32_t initial_max_concurrent_streams_ = kDefaultMaxConcurrentStreams;
+  uint32_t max_concurrent_streams_ = kDefaultMaxConcurrentStreams;
 
   // RFC9113 states the default for SETTINGS_INITIAL_WINDOW_SIZE
   // Both client and servers can change this setting. This is usually changed to
   // handle memory pressure.
-  uint32_t initial_window_size_ = 65535u;
+  uint32_t initial_window_size_ = kDefaultInitialWindowSize;
 
   // RFC9113 states the default for SETTINGS_MAX_FRAME_SIZE
   // Both client and servers can change this setting. This is usually changed to
   // handle memory pressure.
-  uint32_t max_frame_size_ = 16384u;
+  uint32_t max_frame_size_ = kDefaultMaxFrameSize;
 
-  // TODO(tjagtap) [PH2][P4] : Get the history of why this default was decided
-  // and write it here.
   // This is an advisory but we currently enforce it.
   // Set only once in the lifetime of a transport currently.
   // When a peer that updates this more than once, that may indicate either an
   // underlying issue or a malicious peer.
-  uint32_t max_header_list_size_ = 16777216u;
+  uint32_t max_header_list_size_ = kDefaultMaxHeaderListSize;
 
   // gRPC defined setting
   // Both client and servers can change this setting. This is usually changed to
   // handle memory pressure.
-  uint32_t preferred_receive_crypto_message_size_ = 0u;
+  uint32_t preferred_receive_crypto_message_size_ =
+      kDefaultPreferredReceiveCryptoMessageSize;
 
   // RFC9113 defined default is true. However, for gRPC we always then set it to
   // false via the SetEnablePush function
   // Currently this is set only once in the lifetime of a transport.
   // We have no plans to support this in the future.
-  bool enable_push_ = true;
+  bool enable_push_ = kDefaultEnablePush;
 
   // gRPC defined setting
   // Currently this is set only once in the lifetime of a transport.
@@ -206,7 +240,7 @@ class Http2Settings {
   // flag. Both peers can send each other the default non-binary METADATA
   // irrespective of this flag. This flag says if we are willing to accept
   // Binary-Metadata from the peer or not.
-  bool allow_true_binary_metadata_ = false;
+  bool allow_true_binary_metadata_ = kDefaultAllowTrueBinaryMetadata;
 
   // gRPC defined setting
   // Unlike most other SETTINGS, this setting is negotiated between the client
@@ -214,7 +248,7 @@ class Http2Settings {
   // apply the custom SECURITY frame.
   // Currently this is set only once in the lifetime of a transport.
   // Disconnect if it is received more than once from the peer.
-  bool allow_security_frame_ = false;
+  bool allow_security_frame_ = kDefaultAllowSecurityFrame;
 };
 
 }  // namespace grpc_core

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

@@ -32,8 +32,6 @@
 
 namespace grpc_core {
 
-// TODO(tjagtap) [PH2][P1][Settings] : Add new DCHECKs to PH2-Only functions in
-// this class.
 class Http2SettingsManager {
  public:
   // Only local and peer settings can be edited by the transport.

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

@@ -23,6 +23,7 @@
 #include <grpc/support/port_platform.h>
 
 #include <algorithm>
+#include <cstddef>
 #include <cstdint>
 #include <optional>
 #include <string>
@@ -49,6 +50,7 @@
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/time.h"
+#include "absl/container/flat_hash_map.h"
 #include "absl/functional/any_invocable.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
@@ -64,6 +66,11 @@ namespace grpc_core {
 #define GRPC_SETTINGS_TIMEOUT_DLOG \
   DLOG_IF(INFO, GRPC_TRACE_FLAG_ENABLED(http2_ph2_transport))
 
+struct ApplySettingsResult {
+  bool did_change_peer_max_concurrent_streams = false;
+  bool should_spawn_security_frame_loop = false;
+};
+
 // This class can only be used only from a promise based HTTP2 transports
 // general_party_ .
 // This class is designed with the assumption that only 1 SETTINGS frame will be
@@ -72,9 +79,13 @@ namespace grpc_core {
 class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
  public:
   explicit SettingsPromiseManager(
+      const bool is_client,
       absl::AnyInvocable<void(absl::StatusOr<uint32_t>)> on_receive_settings)
-      : on_receive_first_settings_(std::move(on_receive_settings)),
-        state_(SettingsState::kWaitingForFirstPeerSettings) {}
+      : is_client_(is_client),
+        on_receive_first_settings_(std::move(on_receive_settings)),
+        state_(SettingsState::kWaitingForFirstPeerSettings) {
+    pending_peer_settings_.reserve(Http2Settings::kNumSettings + 1);
+  }
 
   ~SettingsPromiseManager() override {
     GRPC_DCHECK(on_receive_first_settings_ == nullptr);
@@ -113,12 +124,19 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
   // Called when transport receives a SETTINGS ACK frame from peer.
   // This SETTINGS ACK was sent by peer to confirm receipt of SETTINGS frame
   // sent by us. Stop the settings timeout promise.
-  GRPC_MUST_USE_RESULT bool OnSettingsAckReceived() {
+  http2::Http2Status OnSettingsAckReceived() {
     bool is_valid = settings_.AckLastSend();
     if (is_valid) {
       RecordReceivedAck();
+    } else {
+      LOG(ERROR) << "Settings ack received without sending settings.";
+      // CHTTP2 and PH2 return connection error for an unsolicited SETTINGS ACK.
+      // RFC 9113 does not explicitly specify unsolicited ACK handling.
+      return http2::Http2Status::Http2ConnectionError(
+          http2::Http2ErrorCode::kInternalError,
+          std::string(GrpcErrors::kUnsolicitedSettingsAck));
     }
-    return is_valid;
+    return http2::Http2Status::Ok();
   }
 
   // Called when our transport enqueues a SETTINGS frame to send to the peer.
@@ -193,15 +211,24 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
   // Buffers SETTINGS frames received from peer.
   // Buffered to apply settings at start of next write cycle, only after
   // SETTINGS ACK is written to the endpoint.
-  void BufferPeerSettings(std::vector<Http2SettingsFrame::Setting>&& settings) {
+  http2::Http2Status BufferPeerSettings(
+      std::vector<Http2SettingsFrame::Setting>&& settings) {
+    http2::Http2Status status = ValidateSettingsValues(settings);
+    if (!status.IsOk()) {
+      return status;
+    }
     if (state_ == SettingsState::kWaitingForFirstPeerSettings) {
       state_ = SettingsState::kFirstPeerSettingsReceived;
     }
     ++num_acks_to_send_;
-    pending_peer_settings_.reserve(pending_peer_settings_.size() +
-                                   settings.size());
-    pending_peer_settings_.insert(pending_peer_settings_.end(),
-                                  settings.begin(), settings.end());
+    for (const auto& setting : settings) {
+      // RFC9113: An endpoint that receives a SETTINGS frame with any unknown or
+      // unsupported identifier MUST ignore that setting.
+      if (Http2Settings::IsKnownSettingId(setting.id)) {
+        pending_peer_settings_[setting.id] = setting.value;
+      }
+    }
+    return http2::Http2Status::Ok();
   }
 
   // Applies settings buffered by BufferPeerSettings().
@@ -210,14 +237,33 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
   // the peer that that needs some special handling too.
   http2::Http2ErrorCode MaybeReportAndApplyBufferedPeerSettings(
       grpc_event_engine::experimental::EventEngine* event_engine,
-      bool& should_spawn_security_frame_loop) {
-    http2::Http2ErrorCode status = settings_.ApplyIncomingSettings(
-        std::exchange(pending_peer_settings_, {}));
+      ApplySettingsResult& apply_settings_result) {
+    const uint32_t old_setting = settings_.peer().max_concurrent_streams();
+    std::vector<Http2SettingsFrame::Setting> settings_to_apply;
+    settings_to_apply.reserve(pending_peer_settings_.size());
+    for (const auto& [id, value] : pending_peer_settings_) {
+      settings_to_apply.emplace_back(id, value);
+    }
+    pending_peer_settings_.clear();
+    http2::Http2ErrorCode status =
+        settings_.ApplyIncomingSettings(settings_to_apply);
+    if (status == http2::Http2ErrorCode::kNoError && is_client_) {
+      // Since PH2-Servers do not initiate streams, we ignore this setting for
+      // Servers.
+      const uint32_t applied_max_concurrent_streams =
+          settings_.peer().max_concurrent_streams();
+      apply_settings_result.did_change_peer_max_concurrent_streams =
+          (applied_max_concurrent_streams != old_setting);
+      // TODO(tjagtap) : [PH2][P0] : Plumb this with the StateWatcher code.
+    }
+
     if (state_ == SettingsState::kFirstPeerSettingsReceived) {
       MaybeReportInitialSettings(event_engine);
       state_ = SettingsState::kReady;
-      should_spawn_security_frame_loop = IsSecurityFrameExpected();
+      apply_settings_result.should_spawn_security_frame_loop =
+          IsSecurityFrameExpected();
     }
+    GRPC_DCHECK(pending_peer_settings_.empty());
     return status;
   }
 
@@ -269,11 +315,11 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
     return settings_.ChannelzProperties().SetColumn(
         "Counters",
         channelz::PropertyList().Set("initial_window_size_increase_count",
-                                     initial_window_size_increase_count_));
+                                     num_peer_initial_window_size_increases_));
   }
 
   void IncrementInitialWindowSizeIncreaseCount() {
-    ++initial_window_size_increase_count_;
+    ++num_peer_initial_window_size_increases_;
   }
 
   bool IsSecurityFrameExpected() const {
@@ -281,20 +327,19 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
         << "Security frame must not be received before SETTINGS frame";
     // TODO(tjagtap) : [PH2][P3] : Evaluate when to accept the frame and when to
     // reject it. Compare it with the requirement and with CHTTP2.
-    return (settings_.local().allow_security_frame()) &&
-           settings_.peer().allow_security_frame();
+    const bool is_expected = (settings_.local().allow_security_frame()) &&
+                             settings_.peer().allow_security_frame();
+    GRPC_SETTINGS_TIMEOUT_DLOG
+        << "SettingsPromiseManager::IsSecurityFrameExpected: " << is_expected;
+    return is_expected;
   };
 
  private:
-  Http2SettingsManager settings_;
-
   //////////////////////////////////////////////////////////////////////////////
   // Plumbing Settings with Chttp2Connector class
 
   void MaybeReportInitialSettings(
       grpc_event_engine::experimental::EventEngine* event_engine) {
-    // TODO(tjagtap) [PH2][P2] Relook at this while writing server. I think this
-    // will be different for client and server.
     if (on_receive_first_settings_ != nullptr) {
       GRPC_DCHECK(state_ == SettingsState::kFirstPeerSettingsReceived);
       GRPC_DCHECK(event_engine != nullptr);
@@ -315,8 +360,6 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
 
   void MaybeReportInitialSettingsAbort(
       grpc_event_engine::experimental::EventEngine* event_engine) {
-    // TODO(tjagtap) [PH2][P2] Relook at this while writing server. I think this
-    // will be different for client and server.
     if (on_receive_first_settings_ != nullptr) {
       GRPC_DCHECK(event_engine != nullptr);
       GRPC_DCHECK(state_ != SettingsState::kReady);
@@ -417,9 +460,10 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
 
   //////////////////////////////////////////////////////////////////////////////
   // Data Members for SETTINGS being received from the peer.
+  const bool is_client_;
 
   absl::AnyInvocable<void(absl::StatusOr<uint32_t>)> on_receive_first_settings_;
-  std::vector<Http2SettingsFrame::Setting> pending_peer_settings_;
+  absl::flat_hash_map<uint16_t, uint32_t> pending_peer_settings_;
   // Number of incoming SETTINGS frames that we have received but not ACKed yet.
   uint32_t num_acks_to_send_ = 0;
 
@@ -430,8 +474,12 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
   };
   SettingsState state_;
 
-  // Counters
-  size_t initial_window_size_increase_count_ = 0;
+  // Number of times the peer has increased the initial window size. Currently,
+  // PH2 handles this by iterating over all the active streams to potentially
+  // make them writable. This is tracked via channelz in case it causes any
+  // performance issues in the future.
+  size_t num_peer_initial_window_size_increases_ = 0;
+  Http2SettingsManager settings_;
 };
 
 }  // namespace grpc_core

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

@@ -72,6 +72,9 @@ namespace http2 {
 //           Milestone 4. Either do the TODOs or delete them.
 // [PH2][EXT] This is a TODO related to a project unrelated to PH2 but happening
 //            in parallel.
+// [PH2][CHTTP2] This TODO is a part of CHTTP2 deletion.
+// [PH2][Px][FCV3] This TODO is related to Flow Control plumbing with the
+// Application and the Call V3 stack.
 
 constexpr Duration kDefaultPingTimeout = Duration::Minutes(1);
 constexpr Duration kDefaultKeepaliveTimeout = Duration::Seconds(20);
@@ -132,8 +135,6 @@ std::string TransportChannelArgs::DebugString() const {
       " keepalive_timeout: ", keepalive_timeout,
       " ping_timeout: ", ping_timeout, " settings_timeout: ", settings_timeout,
       " keepalive_permit_without_calls: ", keepalive_permit_without_calls,
-      " enable_preferred_rx_crypto_frame_advertisement: ",
-      enable_preferred_rx_crypto_frame_advertisement,
       " max_header_list_size_soft_limit: ", max_header_list_size_soft_limit,
       " max_usable_hpack_table_size: ", max_usable_hpack_table_size,
       " initial_sequence_number: ", initial_sequence_number,
@@ -173,11 +174,6 @@ void ReadChannelArgs(const ChannelArgs& channel_args,
       channel_args.GetBool(GRPC_ARG_KEEPALIVE_PERMIT_WITHOUT_CALLS)
           .value_or(kDefaultKeepalivePermitWithoutCalls);
 
-  args.enable_preferred_rx_crypto_frame_advertisement =
-      channel_args
-          .GetBool(GRPC_ARG_EXPERIMENTAL_HTTP2_PREFERRED_CRYPTO_FRAME_SIZE)
-          .value_or(kDefaultEnablePreferredRxCryptoFrameAdvertisement);
-
   args.max_usable_hpack_table_size =
       channel_args.GetInt(GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_ENCODER).value_or(-1);
 
@@ -235,9 +231,12 @@ void ReadSettingsFromChannelArgs(const ChannelArgs& channel_args,
         channel_args.GetInt(GRPC_ARG_HTTP2_MAX_FRAME_SIZE).value_or(-1));
   }
 
-  if (channel_args
+  const bool enable_preferred_crypto =
+      channel_args
           .GetBool(GRPC_ARG_EXPERIMENTAL_HTTP2_PREFERRED_CRYPTO_FRAME_SIZE)
-          .value_or(false)) {
+          .value_or(kDefaultEnablePreferredRxCryptoFrameAdvertisement);
+  flow_control.set_ph2_enable_rx_crypto(enable_preferred_crypto);
+  if (enable_preferred_crypto) {
     local_settings.SetPreferredReceiveCryptoMessageSize(INT_MAX);
   }
 
@@ -250,11 +249,6 @@ void ReadSettingsFromChannelArgs(const ChannelArgs& channel_args,
   local_settings.SetAllowSecurityFrame(
       channel_args.GetBool(GRPC_ARG_SECURITY_FRAME_ALLOWED).value_or(false));
 
-  // TODO(tjagtap) : [PH2][P4] : If max_header_list_size is set only once
-  // in the life of a transport, consider making this a data member of
-  // class IncomingMetadataTracker instead of accessing via acked settings again
-  // and again. Else delete this comment.
-
   GRPC_HTTP2_COMMON_DLOG
       << "Http2Settings: {"
       << "header_table_size: " << local_settings.header_table_size()
@@ -271,6 +265,20 @@ void ReadSettingsFromChannelArgs(const ChannelArgs& channel_args,
       << "}";
 }
 
+uint32_t MaxNewStreamsPerRead(const ChannelArgs& channel_args) {
+  return Clamp(
+      channel_args.GetInt("grpc.http2.max_requests_per_read").value_or(32), 1,
+      10000);
+}
+
+uint32_t GetMaxSecurityFrameSize(const ChannelArgs& channel_args) {
+  return static_cast<uint32_t>(
+      Clamp(channel_args.GetInt(GRPC_ARG_MAX_SECURITY_FRAME_SIZE)
+                .value_or(GrpcErrors::kMaxSecurityFrameSize),
+            GrpcErrors::kMinMaxSecurityFrameSize,
+            static_cast<int>(GrpcErrors::kMaxSecurityFrameSize)));
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // ChannelZ helpers
 
@@ -311,7 +319,7 @@ void ProcessOutgoingDataFrameFlowControl(
 }
 
 ValueOrHttp2Status<chttp2::FlowControlAction>
-ProcessIncomingDataFrameFlowControl(Http2FrameHeader& frame_header,
+ProcessIncomingDataFrameFlowControl(const Http2FrameHeader& frame_header,
                                     chttp2::TransportFlowControl& flow_control,
                                     Stream* stream) {
   GRPC_DCHECK_EQ(frame_header.type, 0u);
@@ -401,6 +409,22 @@ bool ProcessIncomingWindowUpdateFrameFlowControl(
 
 void MaybeAddTransportWindowUpdateFrame(
     chttp2::TransportFlowControl& flow_control, FrameSender& frame_sender) {
+  // Known Limitation:
+  // 1. writing_anyway is set to true always. This might cause the write cycle
+  // to just write 1 window update frame in one entire iteration of the
+  // Multiplexer Loop, making it wasteful. In most of the scenarios this is fine
+  // as TriggerWriteCycle is only invoked from code points that want to write
+  // frames on the wire.
+  // 2. This is because we write control frames before we write HEADER and DATA
+  // frames. So we don't know if we are going to write or not when we call
+  // this function.
+  // 3. Setting writing_anyway to false always might be a problem, because we
+  // would rather send a WINDOW_UPDATE frame with a small increment, than not
+  // send it at all.
+  // 4. In the future if we want to fix this, we need to call
+  // MaybeAddTransportWindowUpdateFrame once while writing control frames, and
+  // once after all the DATA and HEADER frames are written for the current write
+  // cycle.
   uint32_t window_size =
       flow_control.DesiredAnnounceSize(/*writing_anyway=*/true);
   if (window_size > 0) {

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

@@ -45,8 +45,8 @@ namespace http2 {
 // and it is functions. The code will be written iteratively.
 // Do not use or edit any of these functions unless you are
 // familiar with the PH2 project (Moving chttp2 to promises.)
-// TODO(tjagtap) : [PH2][P3] : Update the experimental status of the code before
-// http2 rollout begins.
+// TODO(tjagtap) : [PH2][P3] : Update the experimental status of the code when
+// CHTTP2 is deleted.
 
 #define GRPC_HTTP2_CLIENT_DLOG \
   DLOG_IF(INFO, GRPC_TRACE_FLAG_ENABLED(http2_ph2_transport))
@@ -67,6 +67,14 @@ struct CloseStreamArgs {
   bool close_writes;
 };
 
+inline bool ShouldEnablePh2Client() {
+  return IsPh2ClientEnabled() || IsPh2ClientServerEnabled();
+}
+
+inline bool ShouldEnablePh2Server() {
+  return IsPh2ServerEnabled() || IsPh2ClientServerEnabled();
+}
+
 // TODO(akshitpatel) [PH2][P3] : Write a way to measure the total size of a
 // transport object. Reference :
 // https://github.com/grpc/grpc/pull/41294/files#diff-c685cc4847f228327938326e2a45083a2d0845bacff0ac004bd802027a670c4e
@@ -74,48 +82,7 @@ struct CloseStreamArgs {
 ///////////////////////////////////////////////////////////////////////////////
 // Read and Write helpers
 
-class Http2ReadContext {
- public:
-  Http2ReadContext() = default;
-  Http2ReadContext(const Http2ReadContext&) = delete;
-  Http2ReadContext& operator=(const Http2ReadContext&) = delete;
-  Http2ReadContext(Http2ReadContext&&) = delete;
-  Http2ReadContext& operator=(Http2ReadContext&&) = delete;
-
-  // Signals that the read loop should pause. If it's already paused, this is a
-  // no-op.
-  void SetPauseReadLoop() {
-    // TODO(tjagtap) [PH2][P2][Settings] Plumb with when we receive urgent
-    // settings. Example - initial window size 0 is urgent because it indicates
-    // extreme memory pressure on the server.
-    should_pause_read_loop_ = true;
-  }
-
-  // If SetPauseReadLoop() was called, this returns Pending and
-  // registers a waker that will be woken by WakeReadLoop().
-  // If SetPauseReadLoop() was not called, this returns OkStatus.
-  // This should be polled by the read loop to yield control when requested.
-  Poll<absl::Status> MaybePauseReadLoop() {
-    if (should_pause_read_loop_) {
-      read_loop_waker_ = GetContext<Activity>()->MakeNonOwningWaker();
-      return Pending{};
-    }
-    return absl::OkStatus();
-  }
-
-  // If SetPauseReadLoop() was called, resumes it by
-  // waking up the ReadLoop. If not paused, this is a no-op.
-  void ResumeReadLoopIfPaused() {
-    if (should_pause_read_loop_) {
-      should_pause_read_loop_ = false;
-      read_loop_waker_.Wakeup();
-    }
-  }
-
- private:
-  bool should_pause_read_loop_ = false;
-  Waker read_loop_waker_;
-};
+constexpr uint32_t kMaxFramesReadPerReadCycle = 16u * 1024u;  // 16K frames
 
 Http2Status ValidateIncomingConnectionPreface(
     const absl::StatusOr<Slice>& status);
@@ -126,7 +93,7 @@ inline Http2Status ValidateMetadataFrameState(
     const uint32_t max_header_list_size) {
   if (stream.IsStreamHalfClosedRemote()) {
     return incoming_headers.ParseAndDiscardHeaders(
-        std::move(frame.payload), frame.end_headers, &stream,
+        std::move(frame.payload), frame.end_headers,
         Http2Status::Http2StreamError(
             Http2ErrorCode::kStreamClosed,
             std::string(RFC9113::kHalfClosedRemoteState)),
@@ -138,7 +105,7 @@ inline Http2Status ValidateMetadataFrameState(
             stream.IsInitialMetadataReceived(),
             stream.IsTrailingMetadataReceived())) {
       return incoming_headers.ParseAndDiscardHeaders(
-          std::move(frame.payload), frame.end_headers, &stream,
+          std::move(frame.payload), frame.end_headers,
           Http2Status::Http2StreamError(
               Http2ErrorCode::kInternalError,
               std::string(GrpcErrors::kTooManyMetadata)),
@@ -163,7 +130,6 @@ struct TransportChannelArgs {
   Duration ping_timeout;
   Duration settings_timeout;
   bool keepalive_permit_without_calls;
-  bool enable_preferred_rx_crypto_frame_advertisement;
   // This is used to test peer behaviour when we never send a ping ack.
   bool test_only_ack_pings;
   uint32_t max_header_list_size_soft_limit;
@@ -183,6 +149,10 @@ void ReadSettingsFromChannelArgs(const ChannelArgs& channel_args,
                                  chttp2::TransportFlowControl& flow_control,
                                  bool is_client);
 
+uint32_t MaxNewStreamsPerRead(const ChannelArgs& channel_args);
+
+uint32_t GetMaxSecurityFrameSize(const ChannelArgs& channel_args);
+
 ///////////////////////////////////////////////////////////////////////////////
 // ChannelZ helpers
 
@@ -199,7 +169,7 @@ void ProcessOutgoingDataFrameFlowControl(
     uint32_t flow_control_tokens_consumed);
 
 ValueOrHttp2Status<chttp2::FlowControlAction>
-ProcessIncomingDataFrameFlowControl(Http2FrameHeader& frame,
+ProcessIncomingDataFrameFlowControl(const Http2FrameHeader& frame,
                                     chttp2::TransportFlowControl& flow_control,
                                     Stream* stream);
 

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

@@ -72,6 +72,7 @@
 #include "src/core/lib/transport/connectivity_state.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/stats.h"
@@ -94,6 +95,9 @@
 //   bits being used for flags defined above)
 #define CLOSURE_BARRIER_FIRST_REF_BIT (1 << 16)
 
+constexpr uint32_t kMaxSecurityFrameSize = 16u * 1024u;
+constexpr int kMinMaxSecurityFrameSize = 0;
+
 // streams are kept in various linked lists depending on what things need to
 // happen to them... this enum labels each list
 typedef enum {
@@ -230,6 +234,9 @@ typedef enum {
   GRPC_CHTTP2_KEEPALIVE_STATE_DISABLED,
 } grpc_chttp2_keepalive_state;
 
+constexpr uint16_t kMaxNoopDataFrames = 16384u;
+constexpr uint16_t kMaxNoopContinuationFrames = 128u;
+
 struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
                                      public grpc_core::KeepsGrpcInitialized {
   grpc_chttp2_transport(const grpc_core::ChannelArgs& channel_args,
@@ -458,6 +465,7 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   /// parser for goaway frames
   grpc_chttp2_goaway_parser goaway_parser;
   // parser for secure frames
+  uint32_t max_security_frame_size;
   grpc_chttp2_security_frame_parser security_frame_parser;
 
   grpc_core::chttp2::TransportFlowControl flow_control;
@@ -472,6 +480,8 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   uint8_t incoming_frame_flags = 0;
   uint8_t header_eof = 0;
   bool is_first_frame = true;
+  uint16_t noop_continuation_frames = 0u;
+  uint16_t noop_data_frames = 0u;
   uint32_t expect_continuation_stream_id = 0;
   uint32_t incoming_frame_size = 0;
 
@@ -618,6 +628,9 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   grpc_core::Timestamp last_ztrace_time = grpc_core::Timestamp::InfPast();
 
   GPR_NO_UNIQUE_ADDRESS grpc_core::latent_see::Flow write_flow;
+
+  // Current mitigation engine, retrieved once per connection.
+  grpc_core::RefCountedPtr<grpc_core::MitigationEngine> mitigation_engine;
 };
 
 typedef enum {
@@ -878,6 +891,11 @@ void grpc_chttp2_stream_unref(grpc_chttp2_stream* s);
 #endif
 
 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);
+
+void grpc_chttp2_close_transport_locked(grpc_chttp2_transport* t,
+                                        grpc_error_handle error);
 
 /// Sends GOAWAY with error code ENHANCE_YOUR_CALM and additional debug data
 /// resembling "too_many_pings" followed by immediately closing the connection.