grpc 1.83.0 → 1.84.0.pre1

data/src/core/ext/filters/rbac/rbac_filter.cc

@@ -44,21 +44,29 @@ namespace grpc_core {
 absl::Status RbacFilter::Call::OnClientInitialMetadata(ClientMetadata& md,
                                                        RbacFilter* filter) {
   GRPC_LATENT_SEE_SCOPE("RbacFilter::Call::OnClientInitialMetadata");
-  // Fetch and apply the rbac policy from the service config.
-  auto* service_config_call_data = GetContext<ServiceConfigCallData>();
-  auto* method_params = static_cast<RbacMethodParsedConfig*>(
-      service_config_call_data->GetMethodParsedConfig(
-          filter->service_config_parser_index_));
-  if (method_params == nullptr) {
-    return absl::PermissionDeniedError("No RBAC policy found.");
-  } else {
-    auto* authorization_engine =
-        method_params->authorization_engine(filter->index_);
-    if (authorization_engine
-            ->Evaluate(EvaluateArgs(&md, &filter->per_channel_evaluate_args_))
-            .type == AuthorizationEngine::Decision::Type::kDeny) {
-      return absl::PermissionDeniedError("Unauthorized RPC rejected");
+  if (!IsXdsServerFilterChainPerRouteEnabled()) {
+    // Fetch and apply the rbac policy from the service config.
+    auto* service_config_call_data = GetContext<ServiceConfigCallData>();
+    auto* method_params = static_cast<RbacMethodParsedConfig*>(
+        service_config_call_data->GetMethodParsedConfig(
+            filter->service_config_parser_index_));
+    if (method_params == nullptr) {
+      return absl::PermissionDeniedError("No RBAC policy found.");
+    } else {
+      auto* authorization_engine =
+          method_params->authorization_engine(filter->index_);
+      if (authorization_engine
+              ->Evaluate(EvaluateArgs(&md, &filter->per_channel_evaluate_args_))
+              .type == AuthorizationEngine::Decision::Type::kDeny) {
+        return absl::PermissionDeniedError("Unauthorized RPC rejected");
+      }
     }
+    return absl::OkStatus();
+  }
+  auto decision = filter->authorization_engine_.Evaluate(
+      EvaluateArgs(&md, &filter->per_channel_evaluate_args_));
+  if (decision.type == AuthorizationEngine::Decision::Type::kDeny) {
+    return absl::PermissionDeniedError("Unauthorized RPC rejected");
   }
   return absl::OkStatus();
 }
@@ -66,12 +74,6 @@ absl::Status RbacFilter::Call::OnClientInitialMetadata(ClientMetadata& md,
 const grpc_channel_filter RbacFilter::kFilterVtable =
     MakePromiseBasedFilter<RbacFilter, FilterEndpoint::kServer>();
 
-RbacFilter::RbacFilter(size_t index,
-                       EvaluateArgs::PerChannelArgs per_channel_evaluate_args)
-    : index_(index),
-      service_config_parser_index_(RbacServiceConfigParser::ParserIndex()),
-      per_channel_evaluate_args_(std::move(per_channel_evaluate_args)) {}
-
 absl::StatusOr<std::unique_ptr<RbacFilter>> RbacFilter::Create(
     const ChannelArgs& args, ChannelFilter::Args filter_args) {
   auto* auth_context = args.GetObject<grpc_auth_context>();
@@ -84,11 +86,31 @@ absl::StatusOr<std::unique_ptr<RbacFilter>> RbacFilter::Create(
     // side.
     return GRPC_ERROR_CREATE("No transport configured");
   }
+  if (!IsXdsServerFilterChainPerRouteEnabled()) {
+    return std::make_unique<RbacFilter>(
+        filter_args.instance_id(), Rbac(),
+        EvaluateArgs::PerChannelArgs(auth_context, args));
+  }
+  if (filter_args.config() == nullptr) {
+    return absl::InternalError("no config passed to RBAC filter");
+  }
+  if (filter_args.config()->type() != Config::Type()) {
+    return absl::InternalError(
+        absl::StrCat("wrong config type passed to RBAC filter: ",
+                     filter_args.config()->type().name()));
+  }
   return std::make_unique<RbacFilter>(
-      filter_args.instance_id(),
+      /*instance_id=*/0, DownCast<const Config&>(*filter_args.config()).rbac,
       EvaluateArgs::PerChannelArgs(auth_context, args));
 }
 
+RbacFilter::RbacFilter(size_t index, const Rbac& rbac,
+                       EvaluateArgs::PerChannelArgs per_channel_evaluate_args)
+    : index_(index),
+      service_config_parser_index_(RbacServiceConfigParser::ParserIndex()),
+      authorization_engine_(rbac),
+      per_channel_evaluate_args_(std::move(per_channel_evaluate_args)) {}
+
 void RbacFilterRegister(CoreConfiguration::Builder* builder) {
   RbacServiceConfigParser::Register(builder);
 }

data/src/core/ext/filters/rbac/rbac_filter.h

@@ -25,6 +25,8 @@
 #include "src/core/lib/channel/promise_based_filter.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/security/authorization/evaluate_args.h"
+#include "src/core/lib/security/authorization/grpc_authorization_engine.h"
+#include "src/core/lib/security/authorization/rbac_policy.h"
 #include "src/core/lib/transport/transport.h"
 #include "absl/status/statusor.h"
 
@@ -34,6 +36,20 @@ namespace grpc_core {
 // HTTP RBAC filter. Also serves as the type for channel data for the filter.
 class RbacFilter : public ImplementChannelFilter<RbacFilter> {
  public:
+  struct Config final : public FilterConfig {
+    static UniqueTypeName Type() {
+      return GRPC_UNIQUE_TYPE_NAME_HERE("rbac_filter_config");
+    }
+    UniqueTypeName type() const override { return Type(); }
+
+    bool Equals(const FilterConfig& other) const override {
+      return rbac == DownCast<const Config&>(other).rbac;
+    }
+    std::string ToString() const override { return rbac.ToString(); }
+
+    Rbac rbac;
+  };
+
   // This channel filter is intended to be used by connections on xDS enabled
   // servers configured with RBAC. The RBAC filter fetches the RBAC policy from
   // the method config of service config returned by the ServerConfigSelector,
@@ -45,7 +61,7 @@ class RbacFilter : public ImplementChannelFilter<RbacFilter> {
   static absl::StatusOr<std::unique_ptr<RbacFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 
-  RbacFilter(size_t index,
+  RbacFilter(size_t index, const Rbac& rbac,
              EvaluateArgs::PerChannelArgs per_channel_evaluate_args);
 
   class Call {
@@ -64,10 +80,12 @@ class RbacFilter : public ImplementChannelFilter<RbacFilter> {
   };
 
  private:
-  // The index of this filter instance among instances of the same filter.
+  // TODO(roth): Remove these fields as part of removing the
+  // xds_server_filter_chain_per_route experiment.
   size_t index_;
-  // Assigned index for service config data from the parser.
   const size_t service_config_parser_index_;
+
+  GrpcAuthorizationEngine authorization_engine_;
   // Per channel args used for authorization.
   EvaluateArgs::PerChannelArgs per_channel_evaluate_args_;
 };

data/src/core/ext/filters/rbac/rbac_service_config_parser.cc

@@ -564,7 +564,7 @@ void RbacConfig::RbacPolicy::Rules::Policy::Permission::JsonPostLoad(
                                       /*required=*/false);
   if (not_rule.has_value()) {
     permission = std::make_unique<Rbac::Permission>(
-        Rbac::Permission::MakeNotPermission(std::move(*not_rule->permission)));
+        Rbac::Permission::MakeNotPermission(std::move(not_rule->permission)));
     return;
   }
   if (errors->size() == original_error_size) {
@@ -719,7 +719,7 @@ void RbacConfig::RbacPolicy::Rules::Policy::Principal::JsonPostLoad(
                                      /*required=*/false);
   if (not_rule.has_value()) {
     principal = std::make_unique<Rbac::Principal>(
-        Rbac::Principal::MakeNotPrincipal(std::move(*not_rule->principal)));
+        Rbac::Principal::MakeNotPrincipal(std::move(not_rule->principal)));
     return;
   }
   if (errors->size() == original_error_size) {

data/src/core/ext/transport/chttp2/client/chttp2_connector.cc

@@ -209,7 +209,7 @@ void Chttp2Connector::OnHandshakeDone(absl::StatusOr<HandshakerArgs*> result) {
     } else {
       GRPC_HTTP2_CONNECTOR_DLOG
           << "Chttp2Connector::OnHandshakeDone creating PH2 transport";
-      // TODO(tjagtap) : [PH2][P1] : Validate this code block thoroughly once
+      // TODO(tjagtap) : [PH2][P2] : Validate this code block thoroughly once
       // the ping pong test is in place.
       std::unique_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
           event_engine_endpoint = grpc_event_engine::experimental::

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

@@ -106,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"
@@ -697,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;
@@ -816,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,
@@ -859,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*/) {
@@ -879,11 +884,14 @@ 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)) {
+    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()) {
@@ -1376,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 "
@@ -1410,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);
@@ -1433,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);
   }
@@ -1493,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);
     }
   }
 }
@@ -1507,7 +1506,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
@@ -1516,7 +1516,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,
@@ -1626,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);
@@ -1642,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);
@@ -2061,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());
 }
@@ -2083,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());
 }
@@ -2105,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());
 }
@@ -2242,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) {
@@ -2343,6 +2325,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);
   }
 }
@@ -2415,7 +2399,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);
     }
   }();
 
@@ -2509,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;
@@ -2910,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;
@@ -2997,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);
 }