grpc 1.83.1 → 1.84.0

data/src/core/ext/transport/chttp2/server/chttp2_server.cc

@@ -65,8 +65,6 @@
 #include "src/core/lib/iomgr/event_engine_shims/endpoint.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/pollset_set.h"
-#include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/iomgr/tcp_server.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
 #include "src/core/lib/iomgr/vsock.h"
@@ -744,24 +742,12 @@ absl::StatusOr<int> Chttp2ServerAddPort(Server* server, const char* addr,
       resolved = grpc_resolve_vsock_address(parsed_addr_unprefixed);
       GRPC_RETURN_IF_ERROR(resolved.status());
     } else {
-      if (IsEventEngineDnsNonClientChannelEnabled()) {
-        absl::StatusOr<std::unique_ptr<EventEngine::DNSResolver>> ee_resolver =
-            args.GetObjectRef<EventEngine>()->GetDNSResolver(
-                EventEngine::DNSResolver::ResolverOptions());
-        GRPC_RETURN_IF_ERROR(ee_resolver.status());
-        results = grpc_event_engine::experimental::LookupHostnameBlocking(
-            ee_resolver->get(), parsed_addr, "https");
-      } else {
-        // TODO(yijiem): Remove this after event_engine_dns_non_client_channel
-        // is fully enabled.
-        absl::StatusOr<std::vector<grpc_resolved_address>> iomgr_results =
-            GetDNSResolver()->LookupHostnameBlocking(parsed_addr, "https");
-        GRPC_RETURN_IF_ERROR(iomgr_results.status());
-        for (const auto& addr : *iomgr_results) {
-          results->push_back(
-              grpc_event_engine::experimental::CreateResolvedAddress(addr));
-        }
-      }
+      absl::StatusOr<std::unique_ptr<EventEngine::DNSResolver>> ee_resolver =
+          args.GetObjectRef<EventEngine>()->GetDNSResolver(
+              EventEngine::DNSResolver::ResolverOptions());
+      GRPC_RETURN_IF_ERROR(ee_resolver.status());
+      results = grpc_event_engine::experimental::LookupHostnameBlocking(
+          ee_resolver->get(), parsed_addr, "https");
     }
     if (resolved.ok()) {
       for (const auto& addr : *resolved) {

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

@@ -698,13 +698,13 @@ void grpc_chttp2_transport::WriteSecurityFrameLocked(
   if (data == nullptr) {
     return;
   }
+  if (!closed_with_error.ok()) {
+    return;
+  }
   if (!settings.peer().allow_security_frame()) {
     close_transport_locked(
-        this,
-        grpc_error_set_int(
-            GRPC_ERROR_CREATE("Unexpected SECURITY frame scheduled for write"),
-            grpc_core::StatusIntProperty::kRpcStatus,
-            GRPC_STATUS_FAILED_PRECONDITION));
+        this, absl::FailedPreconditionError(
+                  "Unexpected SECURITY frame scheduled for write"));
     return;
   }
   grpc_core::SliceBuffer security_frame;
@@ -889,10 +889,9 @@ static void close_transport_locked(grpc_chttp2_transport* t,
     t->transport_framing_endpoint_extension = nullptr;
   }
   if (t->closed_with_error.ok()) {
-    if (!grpc_error_has_clear_grpc_status(error)) {
+    if (absl::IsUnknown(error)) {
       error =
-          grpc_error_set_int(error, grpc_core::StatusIntProperty::kRpcStatus,
-                             GRPC_STATUS_UNAVAILABLE);
+          grpc_core::ReplaceStatusCode(error, absl::StatusCode::kUnavailable);
     }
     if (t->write_state != GRPC_CHTTP2_WRITE_STATE_IDLE) {
       if (t->close_transport_on_writes_finished.ok()) {
@@ -1385,13 +1384,12 @@ void grpc_chttp2_add_incoming_goaway(grpc_chttp2_transport* t,
                                      uint32_t goaway_error,
                                      uint32_t last_stream_id,
                                      absl::string_view goaway_text) {
-  t->goaway_error = grpc_error_set_int(
+  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);
+                         static_cast<intptr_t>(goaway_error));
 
   GRPC_TRACE_LOG(http, INFO)
       << "transport " << t << " got goaway with last stream id "
@@ -1419,7 +1417,7 @@ void grpc_chttp2_add_incoming_goaway(grpc_chttp2_transport* t,
       grpc_chttp2_cancel_stream(s->t.get(), s, s->t->goaway_error, false);
     }
   }
-  absl::Status status = grpc_error_to_absl_status(t->goaway_error);
+  absl::Status status = t->goaway_error;
   grpc_core::Transport::StateWatcher::DisconnectInfo disconnect_info;
   disconnect_info.reason = grpc_core::Transport::StateWatcher::kGoaway;
   disconnect_info.http2_error_code = static_cast<Http2ErrorCode>(goaway_error);
@@ -1442,10 +1440,6 @@ void grpc_chttp2_add_incoming_goaway(grpc_chttp2_transport* t,
         t->keepalive_time.millis() > max_keepalive_time_millis
             ? INT_MAX
             : t->keepalive_time.millis() * KEEPALIVE_TIME_BACKOFF_MULTIPLIER;
-    if (!grpc_core::IsSubchannelConnectionScalingEnabled()) {
-      status.SetPayload(grpc_core::kKeepaliveThrottlingKey,
-                        absl::Cord(std::to_string(throttled_keepalive_time)));
-    }
     disconnect_info.keepalive_time =
         grpc_core::Duration::Milliseconds(throttled_keepalive_time);
   }
@@ -1502,11 +1496,7 @@ static void maybe_start_some_streams(grpc_chttp2_transport* t) {
           grpc_core::GrpcStreamNetworkState(),
           grpc_core::GrpcStreamNetworkState::kNotSentOnWire);
       grpc_chttp2_cancel_stream(
-          t, s,
-          grpc_error_set_int(GRPC_ERROR_CREATE("Stream IDs exhausted"),
-                             grpc_core::StatusIntProperty::kRpcStatus,
-                             GRPC_STATUS_UNAVAILABLE),
-          false);
+          t, s, absl::UnavailableError("Stream IDs exhausted"), false);
     }
   }
 }
@@ -1640,14 +1630,10 @@ static void send_initial_metadata_locked(
           s->trailing_metadata_buffer.Set(
               grpc_core::GrpcStreamNetworkState(),
               grpc_core::GrpcStreamNetworkState::kNotSentOnWire);
-          grpc_chttp2_cancel_stream(
-              t, s,
-              grpc_error_set_int(
-                  GRPC_ERROR_CREATE_REFERENCING("Too many streams",
-                                                &t->closed_with_error, 1),
-                  grpc_core::StatusIntProperty::kRpcStatus,
-                  GRPC_STATUS_RESOURCE_EXHAUSTED),
-              false);
+          absl::Status status =
+              absl::ResourceExhaustedError("Too many streams");
+          grpc_core::StatusAddChild(&status, t->closed_with_error);
+          grpc_chttp2_cancel_stream(t, s, std::move(status), false);
         } else {
           grpc_chttp2_list_add_waiting_for_concurrency(t, s);
           maybe_start_some_streams(t);
@@ -1656,14 +1642,9 @@ static void send_initial_metadata_locked(
         s->trailing_metadata_buffer.Set(
             grpc_core::GrpcStreamNetworkState(),
             grpc_core::GrpcStreamNetworkState::kNotSentOnWire);
-        grpc_chttp2_cancel_stream(
-            t, s,
-            grpc_error_set_int(
-                GRPC_ERROR_CREATE_REFERENCING("Transport closed",
-                                              &t->closed_with_error, 1),
-                grpc_core::StatusIntProperty::kRpcStatus,
-                GRPC_STATUS_UNAVAILABLE),
-            false);
+        absl::Status status = absl::UnavailableError("Transport closed");
+        grpc_core::StatusAddChild(&status, t->closed_with_error);
+        grpc_chttp2_cancel_stream(t, s, std::move(status), false);
       }
     } else {
       GRPC_CHECK_NE(s->id, 0u);
@@ -2075,11 +2056,8 @@ void grpc_chttp2_keepalive_timeout(
                 grpc_core::StatusIntProperty::kHttp2Error,
                 static_cast<intptr_t>(Http2ErrorCode::kEnhanceYourCalm)),
             /*immediate_disconnect_hint=*/true);
-        close_transport_locked(
-            t.get(),
-            grpc_error_set_int(GRPC_ERROR_CREATE("keepalive timeout"),
-                               grpc_core::StatusIntProperty::kRpcStatus,
-                               GRPC_STATUS_UNAVAILABLE));
+        close_transport_locked(t.get(),
+                               absl::UnavailableError("keepalive timeout"));
       }),
       absl::OkStatus());
 }
@@ -2097,11 +2075,7 @@ void grpc_chttp2_ping_timeout(
                 grpc_core::StatusIntProperty::kHttp2Error,
                 static_cast<intptr_t>(Http2ErrorCode::kEnhanceYourCalm)),
             /*immediate_disconnect_hint=*/true);
-        close_transport_locked(
-            t.get(),
-            grpc_error_set_int(GRPC_ERROR_CREATE("ping timeout"),
-                               grpc_core::StatusIntProperty::kRpcStatus,
-                               GRPC_STATUS_UNAVAILABLE));
+        close_transport_locked(t.get(), absl::UnavailableError("ping timeout"));
       }),
       absl::OkStatus());
 }
@@ -2119,11 +2093,8 @@ void grpc_chttp2_settings_timeout(
                 grpc_core::StatusIntProperty::kHttp2Error,
                 static_cast<intptr_t>(Http2ErrorCode::kSettingsTimeout)),
             /*immediate_disconnect_hint=*/true);
-        close_transport_locked(
-            t.get(),
-            grpc_error_set_int(GRPC_ERROR_CREATE("settings timeout"),
-                               grpc_core::StatusIntProperty::kRpcStatus,
-                               GRPC_STATUS_UNAVAILABLE));
+        close_transport_locked(t.get(),
+                               absl::UnavailableError("settings timeout"));
       }),
       absl::OkStatus());
 }
@@ -2256,10 +2227,7 @@ void grpc_chttp2_exceeded_ping_strikes(grpc_chttp2_transport* t) {
                   static_cast<intptr_t>(Http2ErrorCode::kEnhanceYourCalm)),
               /*immediate_disconnect_hint=*/true);
   // The transport will be closed after the write is done
-  close_transport_locked(
-      t, grpc_error_set_int(GRPC_ERROR_CREATE("Too many pings"),
-                            grpc_core::StatusIntProperty::kRpcStatus,
-                            GRPC_STATUS_UNAVAILABLE));
+  close_transport_locked(t, absl::UnavailableError("Too many pings"));
 }
 
 void grpc_chttp2_reset_ping_clock(grpc_chttp2_transport* t) {
@@ -2554,8 +2522,7 @@ void grpc_chttp2_cancel_stream(
     grpc_error_handle due_to_error, bool tarpit,
     grpc_core::ServerMetadataHandle send_trailing_metadata) {
   if (!t->is_client && !s->sent_trailing_metadata &&
-      grpc_error_has_clear_grpc_status(due_to_error) &&
-      !(s->read_closed && s->write_closed)) {
+      !absl::IsUnknown(due_to_error) && !(s->read_closed && s->write_closed)) {
     close_from_api(t, s, due_to_error, tarpit,
                    std::move(send_trailing_metadata));
     return;
@@ -2955,11 +2922,10 @@ static void end_all_the_calls(grpc_chttp2_transport* t,
                               grpc_error_handle error) {
   intptr_t http2_error;
   // If there is no explicit grpc or HTTP/2 error, set to UNAVAILABLE on server.
-  if (!t->is_client && !grpc_error_has_clear_grpc_status(error) &&
+  if (!t->is_client && absl::IsUnknown(error) &&
       !grpc_error_get_int(error, grpc_core::StatusIntProperty::kHttp2Error,
                           &http2_error)) {
-    error = grpc_error_set_int(error, grpc_core::StatusIntProperty::kRpcStatus,
-                               GRPC_STATUS_UNAVAILABLE);
+    error = grpc_core::ReplaceStatusCode(error, absl::StatusCode::kUnavailable);
   }
   cancel_unstarted_streams(t, error, false);
   std::vector<grpc_chttp2_stream*> to_cancel;
@@ -3042,12 +3008,11 @@ static grpc_error_handle try_http_parsing(grpc_chttp2_transport* t) {
   }
   if (parse_error.ok() &&
       (parse_error = grpc_http_parser_eof(&parser)) == absl::OkStatus()) {
-    error = grpc_error_set_int(
-        GRPC_ERROR_CREATE(
-            absl::StrCat("Trying to connect an http1.x server (HTTP status ",
-                         response.status, ")")),
-        grpc_core::StatusIntProperty::kRpcStatus,
-        grpc_http2_status_to_grpc_status(response.status));
+    error = absl::Status(
+        static_cast<absl::StatusCode>(
+            grpc_http2_status_to_grpc_status(response.status)),
+        absl::StrCat("Trying to connect an http1.x server (HTTP status ",
+                     response.status, ")"));
   }
 
   grpc_http_parser_destroy(&parser);

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

@@ -124,6 +124,7 @@ TransportFlowControl::TransportFlowControl(absl::string_view peer_name,
                                            MemoryOwner* memory_owner)
     : memory_owner_(memory_owner),
       enable_bdp_probe_(enable_bdp_probe),
+      bdp_ping_blocked_(true),
       bdp_estimator_(peer_name) {}
 
 uint32_t TransportFlowControl::DesiredAnnounceSize(bool writing_anyway) const {
@@ -348,6 +349,7 @@ std::string TransportFlowControl::Stats::ToString() const {
                       " announced_stream_total_over_incoming_window: ",
                       announced_stream_total_over_incoming_window,
                       " bdp_accumulator: ", bdp_accumulator,
+                      " bdp_ping_blocked: ", bdp_ping_blocked,
                       " bdp_estimate: ", bdp_estimate,
                       " bdp_bw_est: ", bdp_bw_est);
 }

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

@@ -24,6 +24,7 @@
 #include <stdint.h>
 
 #include <algorithm>
+#include <cstddef>
 #include <iosfwd>
 #include <optional>
 #include <string>
@@ -370,6 +371,7 @@ class TransportFlowControl final {
     int64_t bdp_accumulator;
     int64_t bdp_estimate;
     double bdp_bw_est;
+    bool bdp_ping_blocked;
 
     std::string ToString() const;
     channelz::PropertyList ChannelzProperties() const {
@@ -386,6 +388,7 @@ class TransportFlowControl final {
           .Set("announced_stream_total_over_incoming_window",
                announced_stream_total_over_incoming_window)
           .Set("bdp_accumulator", bdp_accumulator)
+          .Set("bdp_ping_blocked", bdp_ping_blocked)
           .Set("bdp_estimate", bdp_estimate)
           .Set("bdp_bw_est", bdp_bw_est);
     }
@@ -405,6 +408,7 @@ class TransportFlowControl final {
     stats.announced_stream_total_over_incoming_window =
         announced_stream_total_over_incoming_window();
     stats.bdp_accumulator = bdp_estimator_.accumulator();
+    stats.bdp_ping_blocked = bdp_ping_blocked_;
     stats.bdp_estimate = bdp_estimator_.EstimateBdp();
     stats.bdp_bw_est = bdp_estimator_.EstimateBandwidth();
     return stats;
@@ -418,6 +422,67 @@ class TransportFlowControl final {
   }
   size_t window_update_list_size() const { return window_update_list_.size(); }
 
+  //////////////////////////////////////////////////////////////////////////////
+  // BDP Ping related functions.
+
+  // The current implementation of BDP relies on the assumption that our
+  // transport will not send out a new ping till it has received an ACK for the
+  // previous ping.
+
+  // CHTTP2 reference : schedule_bdp_ping_locked
+  void ScheduleBdpPing() {
+    GRPC_DCHECK(enable_bdp_probe_);
+    bdp_estimator_.SchedulePing();
+  }
+
+  // CHTTP2 reference : start_bdp_ping_locked
+  void StartBdpPing() {
+    // TODO(tjagtap) : [PH2][P1] : Reset the keepalive ping timer
+    bdp_estimator_.StartPing();
+  }
+
+  // CHTTP2 reference : finish_bdp_ping_locked
+  Duration CompleteBdpPing() {
+    return bdp_estimator_.CompletePing() - Timestamp::Now();
+  }
+
+  // CHTTP2 reference : init_data_frame_parser
+  void OnReceiveDataFrame(const uint32_t bytes) {
+    if (enable_bdp_probe_) {
+      bdp_estimator_.AddIncomingBytes(bytes);
+      if (bdp_ping_blocked_ && (bytes > 0)) {
+        // Once we receive a data frame, we can start sending BDP pings again.
+        bdp_ping_blocked_ = false;
+        bdp_waker_.Wakeup();
+      }
+    }
+  }
+
+  // CHTTP2 reference : grpc_chttp2_transport::bdp_ping_blocked
+  bool IsBdpPingBlocked() const { return bdp_ping_blocked_; }
+
+  auto WaitForBdpActivation() {
+    GRPC_HTTP2_FLOW_CONTROL_DLOG
+        << "TransportFlowControl::WaitForBdpActivation Factory";
+    return [this]() -> Poll<absl::Status> {
+      GRPC_DCHECK(enable_bdp_probe_);
+      if (bdp_estimator_.accumulator() == 0) {
+        // Block BDP ping till we receive data in a DATA frame on the transport.
+        bdp_ping_blocked_ = true;
+      }
+      if (bdp_ping_blocked_) {
+        bdp_waker_ = GetContext<Activity>()->MakeNonOwningWaker();
+        GRPC_HTTP2_FLOW_CONTROL_DLOG
+            << "TransportFlowControl::WaitForBdpActivation Pending";
+        return Pending{};
+      }
+      GRPC_HTTP2_FLOW_CONTROL_DLOG
+          << "TransportFlowControl::WaitForBdpActivation Resolved";
+      ScheduleBdpPing();
+      return absl::OkStatus();
+    };
+  }
+
  private:
   friend class StreamFlowControl;
 
@@ -461,10 +526,12 @@ class TransportFlowControl final {
   /// incoming_window = total_over - max(bdp - total_under, 0)
   int64_t announced_stream_total_over_incoming_window_ = 0;
 
-  /// should we probe bdp?
+  //  Transport level channel argument GRPC_ARG_HTTP2_BDP_PROBE decides if we
+  //  should probe for bdp.
   const bool enable_bdp_probe_;
-
-  // bdp estimation
+  // CHTTP2 reference : grpc_chttp2_transport::bdp_ping_blocked
+  bool bdp_ping_blocked_;
+  Waker bdp_waker_;
   BdpEstimator bdp_estimator_;
 
   int64_t remote_window_ = kDefaultWindow;
@@ -490,10 +557,17 @@ class TransportFlowControl final {
 class StreamFlowControl final {
  public:
   explicit StreamFlowControl(TransportFlowControl* tfc);
+  // TODO(ritulb) : [PH2][P5] :  When CHTTP2 is removed, delete this
+  // destructor(no-op).
   ~StreamFlowControl() {
     tfc_->RemoveAnnouncedWindowDelta(announced_window_delta_);
   }
 
+  void OnStreamClosed() {
+    tfc_->RemoveAnnouncedWindowDelta(announced_window_delta_);
+    announced_window_delta_ = 0;
+  }
+
   // Track an update to the incoming flow control counters - that is how many
   // tokens we report to our peer that we're willing to accept.
   // Instantiators *must* call MakeAction before destruction of this value.
@@ -526,7 +600,7 @@ class StreamFlowControl final {
     // `min_progress_size` bytes to make progress on reading the current stream.
     // An example usage of this would be, say we receive the first 1000 bytes of
     // a 2000 byte gRPC message, we can call SetMinProgressSize(1000)
-    // TODO(tjagtap) [PH2][P2] Plumb with PH2 flow control.
+    // TODO(tjagtap) [PH2][P2][FCV3] Plumb with PH2 flow control.
     void SetMinProgressSize(int64_t min_progress_size) {
       sfc_->min_progress_size_ = min_progress_size;
     }

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

@@ -398,6 +398,8 @@ inline constexpr absl::string_view kSettingsTimeout =
     "timeout. Connection will be closed";
 inline constexpr absl::string_view kLastStreamClosed =
     "Closing last stream and cannot create any more streams.";
+inline constexpr absl::string_view kReceivedStreamAfterGoaway =
+    "Received new stream after GOAWAY was received.";
 inline constexpr absl::string_view kFirstSettingsFrameClient =
     "RFC9113: The server connection preface consists of a potentially empty "
     "SETTINGS frame that MUST be the first frame the server sends in the "

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

@@ -133,10 +133,9 @@ grpc_core::Poll<grpc_error_handle> grpc_deframe_unprocessed_incoming_frames(
                           *(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);
+      // Attach the explicit gRPC status code to fail the RPC correctly
+      error = grpc_core::ReplaceStatusCode(
+          error, absl::StatusCode::kResourceExhausted);
       s->message_size_limit_exceeded = true;
       return error;
     }

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

@@ -365,6 +365,13 @@ class GoawayManager {
            !context_->was_immediate;
   }
 
+  bool IsGracefulGoawayInProgress() const {
+    return context_->goaway_state ==
+               GoawayState::kInitialGracefulGoawayScheduled ||
+           context_->goaway_state == GoawayState::kInitialGracefulGoawaySent ||
+           context_->goaway_state == GoawayState::kFinalGracefulGoawayScheduled;
+  }
+
   // 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

@@ -1009,7 +1009,7 @@ class HPackParser::Parser {
         key_string.size() + value.wire_size + hpack_constants::kEntryOverhead;
     if (state_.mitigation_engine != nullptr) {
       auto action = state_.mitigation_engine->EvaluateIncomingMetadata(
-          key_string, value_slice.as_string_view());
+          key_string, value_slice.as_string_view(), state_.peer_address);
       if (action.has_value()) {
         if (action.value() == MitigationEngine::Action::kCloseConnection) {
           input_->SetErrorAndStopParsing(
@@ -1118,7 +1118,8 @@ void HPackParser::BeginFrame(grpc_metadata_batch* metadata_buffer,
                              uint32_t metadata_size_hard_limit,
                              Boundary boundary, Priority priority,
                              LogInfo log_info,
-                             MitigationEngine* mitigation_engine) {
+                             MitigationEngine* mitigation_engine,
+                             absl::string_view peer_address) {
   metadata_buffer_ = metadata_buffer;
   if (metadata_buffer != nullptr) {
     metadata_buffer->Set(GrpcStatusFromWire(), true);
@@ -1126,6 +1127,7 @@ void HPackParser::BeginFrame(grpc_metadata_batch* metadata_buffer,
   boundary_ = boundary;
   priority_ = priority;
   state_.mitigation_engine = mitigation_engine;
+  state_.peer_address = peer_address;
   state_.dynamic_table_updates_allowed = 2;
   state_.metadata_early_detection.SetLimits(
       /*soft_limit=*/metadata_size_soft_limit,
@@ -1162,7 +1164,7 @@ grpc_error_handle HPackParser::ParseInput(Input input, bool is_last,
   if (is_last && is_boundary()) {
     if (state_.mitigation_engine != nullptr && metadata_buffer_ != nullptr) {
       auto action = state_.mitigation_engine->EvaluateAllIncomingMetadata(
-          *metadata_buffer_);
+          *metadata_buffer_, state_.peer_address);
       if (action.has_value()) {
         if (action.value() == MitigationEngine::Action::kCloseConnection) {
           input.SetErrorAndStopParsing(HpackParseResult::MitigationEngineError(

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

@@ -101,7 +101,8 @@ class HPackParser {
                   uint32_t metadata_size_soft_limit,
                   uint32_t metadata_size_hard_limit, Boundary boundary,
                   Priority priority, LogInfo log_info,
-                  MitigationEngine* mitigation_engine);
+                  MitigationEngine* mitigation_engine,
+                  absl::string_view peer_address = "");
   // Start throwing away any received headers after parsing them.
   void StopBufferingFrame() { metadata_buffer_ = nullptr; }
   // Parse one slice worth of data
@@ -255,6 +256,7 @@ class HPackParser {
     // Current parse state
     ParseState parse_state = ParseState::kTop;
     MitigationEngine* mitigation_engine = nullptr;
+    absl::string_view peer_address;
     std::variant<const HPackTable::Memento*, Slice> key;
   };