grpc 1.62.3 → 1.63.0

data/src/core/client_channel/subchannel_pool_interface.h

@@ -39,7 +39,7 @@ class Subchannel;
 extern TraceFlag grpc_subchannel_pool_trace;
 
 // A key that can uniquely identify a subchannel.
-class SubchannelKey {
+class SubchannelKey final {
  public:
   SubchannelKey(const grpc_resolved_address& address, const ChannelArgs& args);
 

data/src/core/client_channel/subchannel_stream_client.cc

@@ -172,11 +172,7 @@ SubchannelStreamClient::CallState::CallState(
       arena_(Arena::Create(subchannel_stream_client_->connected_subchannel_
                                ->GetInitialCallSizeEstimate(),
                            &subchannel_stream_client_->call_allocator_)),
-      payload_(context_),
-      send_initial_metadata_(arena_.get()),
-      send_trailing_metadata_(arena_.get()),
-      recv_initial_metadata_(arena_.get()),
-      recv_trailing_metadata_(arena_.get()) {}
+      payload_(context_) {}
 
 SubchannelStreamClient::CallState::~CallState() {
   if (GPR_UNLIKELY(subchannel_stream_client_->tracer_ != nullptr)) {

data/src/core/client_channel/subchannel_stream_client.h

@@ -61,7 +61,7 @@ namespace grpc_core {
 //
 // Currently, this assumes server-side streaming, but it could be extended
 // to support full bidi streaming if there is a need in the future.
-class SubchannelStreamClient
+class SubchannelStreamClient final
     : public InternallyRefCounted<SubchannelStreamClient> {
  public:
   // Interface implemented by caller.  Thread safety is provided for the
@@ -112,7 +112,7 @@ class SubchannelStreamClient
 
  private:
   // Contains a call to the backend and all the data related to the call.
-  class CallState : public Orphanable {
+  class CallState final : public Orphanable {
    public:
     CallState(RefCountedPtr<SubchannelStreamClient> client,
               grpc_pollset_set* interested_parties);

data/src/core/ext/filters/backend_metrics/backend_metric_filter.cc

@@ -117,55 +117,15 @@ absl::optional<std::string> MaybeSerializeBackendMetrics(
 }
 }  // namespace
 
-const grpc_channel_filter LegacyBackendMetricFilter::kFilter =
-    MakePromiseBasedFilter<LegacyBackendMetricFilter, FilterEndpoint::kServer>(
-        "backend_metric");
-
 const grpc_channel_filter BackendMetricFilter::kFilter =
     MakePromiseBasedFilter<BackendMetricFilter, FilterEndpoint::kServer>(
         "backend_metric");
 
-absl::StatusOr<LegacyBackendMetricFilter> LegacyBackendMetricFilter::Create(
-    const ChannelArgs&, ChannelFilter::Args) {
-  return LegacyBackendMetricFilter();
-}
-
 absl::StatusOr<BackendMetricFilter> BackendMetricFilter::Create(
     const ChannelArgs&, ChannelFilter::Args) {
   return BackendMetricFilter();
 }
 
-ArenaPromise<ServerMetadataHandle> LegacyBackendMetricFilter::MakeCallPromise(
-    CallArgs call_args, NextPromiseFactory next_promise_factory) {
-  return ArenaPromise<ServerMetadataHandle>(Map(
-      next_promise_factory(std::move(call_args)),
-      [this](ServerMetadataHandle trailing_metadata) {
-        auto* ctx = &GetContext<
-            grpc_call_context_element>()[GRPC_CONTEXT_BACKEND_METRIC_PROVIDER];
-        if (ctx == nullptr) {
-          if (GRPC_TRACE_FLAG_ENABLED(grpc_backend_metric_filter_trace)) {
-            gpr_log(GPR_INFO, "[%p] No BackendMetricProvider.", this);
-          }
-          return trailing_metadata;
-        }
-        absl::optional<std::string> serialized = MaybeSerializeBackendMetrics(
-            reinterpret_cast<BackendMetricProvider*>(ctx->value));
-        if (serialized.has_value() && !serialized->empty()) {
-          if (GRPC_TRACE_FLAG_ENABLED(grpc_backend_metric_filter_trace)) {
-            gpr_log(GPR_INFO,
-                    "[%p] Backend metrics serialized. size: %" PRIuPTR, this,
-                    serialized->size());
-          }
-          trailing_metadata->Set(
-              EndpointLoadMetricsBinMetadata(),
-              Slice::FromCopiedString(std::move(*serialized)));
-        } else if (GRPC_TRACE_FLAG_ENABLED(grpc_backend_metric_filter_trace)) {
-          gpr_log(GPR_INFO, "[%p] No backend metrics.", this);
-        }
-        return trailing_metadata;
-      }));
-}
-
 void BackendMetricFilter::Call::OnServerTrailingMetadata(ServerMetadata& md) {
   auto* ctx = &GetContext<
       grpc_call_context_element>()[GRPC_CONTEXT_BACKEND_METRIC_PROVIDER];
@@ -190,15 +150,9 @@ void BackendMetricFilter::Call::OnServerTrailingMetadata(ServerMetadata& md) {
 }
 
 void RegisterBackendMetricFilter(CoreConfiguration::Builder* builder) {
-  if (IsV3BackendMetricFilterEnabled()) {
-    builder->channel_init()
-        ->RegisterFilter<BackendMetricFilter>(GRPC_SERVER_CHANNEL)
-        .IfHasChannelArg(GRPC_ARG_SERVER_CALL_METRIC_RECORDING);
-  } else {
-    builder->channel_init()
-        ->RegisterFilter<LegacyBackendMetricFilter>(GRPC_SERVER_CHANNEL)
-        .IfHasChannelArg(GRPC_ARG_SERVER_CALL_METRIC_RECORDING);
-  }
+  builder->channel_init()
+      ->RegisterFilter<BackendMetricFilter>(GRPC_SERVER_CHANNEL)
+      .IfHasChannelArg(GRPC_ARG_SERVER_CALL_METRIC_RECORDING);
 }
 
 }  // namespace grpc_core

data/src/core/ext/filters/backend_metrics/backend_metric_filter.h

@@ -31,18 +31,6 @@
 
 namespace grpc_core {
 
-class LegacyBackendMetricFilter : public ChannelFilter {
- public:
-  static const grpc_channel_filter kFilter;
-
-  static absl::StatusOr<LegacyBackendMetricFilter> Create(
-      const ChannelArgs& args, ChannelFilter::Args);
-
-  // Construct a promise for one call.
-  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
-      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
-};
-
 class BackendMetricFilter : public ImplementChannelFilter<BackendMetricFilter> {
  public:
   static const grpc_channel_filter kFilter;

data/src/core/ext/filters/channel_idle/legacy_channel_idle_filter.cc

@@ -58,12 +58,7 @@ namespace grpc_core {
 
 namespace {
 
-// TODO(roth): This can go back to being a constant when the experiment
-// is removed.
-Duration DefaultIdleTimeout() {
-  if (IsClientIdlenessEnabled()) return Duration::Minutes(30);
-  return Duration::Infinity();
-}
+constexpr Duration kDefaultIdleTimeout = Duration::Minutes(30);
 
 // If these settings change, make sure that we are not sending a GOAWAY for
 // inproc transport, since a GOAWAY to inproc ends up destroying the transport.
@@ -86,7 +81,7 @@ namespace {
 
 Duration GetClientIdleTimeout(const ChannelArgs& args) {
   return args.GetDurationFromIntMillis(GRPC_ARG_CLIENT_IDLE_TIMEOUT_MS)
-      .value_or(DefaultIdleTimeout());
+      .value_or(kDefaultIdleTimeout);
 }
 
 }  // namespace
@@ -300,15 +295,14 @@ const grpc_channel_filter LegacyMaxAgeFilter::kFilter =
         "max_age");
 
 void RegisterLegacyChannelIdleFilters(CoreConfiguration::Builder* builder) {
-  if (IsV3ChannelIdleFiltersEnabled()) return;
   builder->channel_init()
-      ->RegisterFilter<LegacyClientIdleFilter>(GRPC_CLIENT_CHANNEL)
+      ->RegisterV2Filter<LegacyClientIdleFilter>(GRPC_CLIENT_CHANNEL)
       .ExcludeFromMinimalStack()
       .If([](const ChannelArgs& channel_args) {
         return GetClientIdleTimeout(channel_args) != Duration::Infinity();
       });
   builder->channel_init()
-      ->RegisterFilter<LegacyMaxAgeFilter>(GRPC_SERVER_CHANNEL)
+      ->RegisterV2Filter<LegacyMaxAgeFilter>(GRPC_SERVER_CHANNEL)
       .ExcludeFromMinimalStack()
       .If([](const ChannelArgs& channel_args) {
         return LegacyMaxAgeFilter::Config::FromChannelArgs(channel_args)

data/src/core/ext/filters/http/http_filters_plugin.cc

@@ -22,7 +22,6 @@
 
 #include "src/core/ext/filters/http/client/http_client_filter.h"
 #include "src/core/ext/filters/http/message_compress/compression_filter.h"
-#include "src/core/ext/filters/http/message_compress/legacy_compression_filter.h"
 #include "src/core/ext/filters/http/server/http_server_filter.h"
 #include "src/core/ext/filters/message_size/message_size_filter.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -40,40 +39,21 @@ bool IsBuildingHttpLikeTransport(const ChannelArgs& args) {
 }  // namespace
 
 void RegisterHttpFilters(CoreConfiguration::Builder* builder) {
-  if (IsV3CompressionFilterEnabled()) {
-    builder->channel_init()
-        ->RegisterFilter<ClientCompressionFilter>(GRPC_CLIENT_SUBCHANNEL)
-        .If(IsBuildingHttpLikeTransport)
-        .After<HttpClientFilter>()
-        .After<ClientMessageSizeFilter>();
-    builder->channel_init()
-        ->RegisterFilter<ClientCompressionFilter>(GRPC_CLIENT_DIRECT_CHANNEL)
-        .If(IsBuildingHttpLikeTransport)
-        .After<HttpClientFilter>()
-        .After<ClientMessageSizeFilter>();
-    builder->channel_init()
-        ->RegisterFilter<ServerCompressionFilter>(GRPC_SERVER_CHANNEL)
-        .If(IsBuildingHttpLikeTransport)
-        .After<HttpServerFilter>()
-        .After<ServerMessageSizeFilter>();
-  } else {
-    builder->channel_init()
-        ->RegisterFilter<LegacyClientCompressionFilter>(GRPC_CLIENT_SUBCHANNEL)
-        .If(IsBuildingHttpLikeTransport)
-        .After<HttpClientFilter>()
-        .After<ClientMessageSizeFilter>();
-    builder->channel_init()
-        ->RegisterFilter<LegacyClientCompressionFilter>(
-            GRPC_CLIENT_DIRECT_CHANNEL)
-        .If(IsBuildingHttpLikeTransport)
-        .After<HttpClientFilter>()
-        .After<ClientMessageSizeFilter>();
-    builder->channel_init()
-        ->RegisterFilter<LegacyServerCompressionFilter>(GRPC_SERVER_CHANNEL)
-        .If(IsBuildingHttpLikeTransport)
-        .After<HttpServerFilter>()
-        .After<ServerMessageSizeFilter>();
-  }
+  builder->channel_init()
+      ->RegisterFilter<ClientCompressionFilter>(GRPC_CLIENT_SUBCHANNEL)
+      .If(IsBuildingHttpLikeTransport)
+      .After<HttpClientFilter>()
+      .After<ClientMessageSizeFilter>();
+  builder->channel_init()
+      ->RegisterFilter<ClientCompressionFilter>(GRPC_CLIENT_DIRECT_CHANNEL)
+      .If(IsBuildingHttpLikeTransport)
+      .After<HttpClientFilter>()
+      .After<ClientMessageSizeFilter>();
+  builder->channel_init()
+      ->RegisterFilter<ServerCompressionFilter>(GRPC_SERVER_CHANNEL)
+      .If(IsBuildingHttpLikeTransport)
+      .After<HttpServerFilter>()
+      .After<ServerMessageSizeFilter>();
   builder->channel_init()
       ->RegisterFilter<HttpClientFilter>(GRPC_CLIENT_SUBCHANNEL)
       .If(IsBuildingHttpLikeTransport)

data/src/core/ext/filters/http/message_compress/compression_filter.cc

@@ -169,7 +169,7 @@ MessageHandle ChannelCompression::CompressMessage(
 }
 
 absl::StatusOr<MessageHandle> ChannelCompression::DecompressMessage(
-    MessageHandle message, DecompressArgs args) const {
+    bool is_client, MessageHandle message, DecompressArgs args) const {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_compression_trace)) {
     gpr_log(GPR_INFO, "DecompressMessage: len=%" PRIdPTR " max=%d alg=%d",
             message->payload()->Length(),
@@ -186,8 +186,9 @@ absl::StatusOr<MessageHandle> ChannelCompression::DecompressMessage(
       message->payload()->Length() >
           static_cast<size_t>(*args.max_recv_message_length)) {
     return absl::ResourceExhaustedError(absl::StrFormat(
-        "Received message larger than max (%u vs. %d)",
-        message->payload()->Length(), *args.max_recv_message_length));
+        "%s: Received message larger than max (%u vs. %d)",
+        is_client ? "CLIENT" : "SERVER", message->payload()->Length(),
+        *args.max_recv_message_length));
   }
   // Check if decompression is enabled (if not, we can just pass the message
   // up).
@@ -264,8 +265,8 @@ void ClientCompressionFilter::Call::OnServerInitialMetadata(
 absl::StatusOr<MessageHandle>
 ClientCompressionFilter::Call::OnServerToClientMessage(
     MessageHandle message, ClientCompressionFilter* filter) {
-  return filter->compression_engine_.DecompressMessage(std::move(message),
-                                                       decompress_args_);
+  return filter->compression_engine_.DecompressMessage(
+      /*is_client=*/true, std::move(message), decompress_args_);
 }
 
 void ServerCompressionFilter::Call::OnClientInitialMetadata(
@@ -276,8 +277,8 @@ void ServerCompressionFilter::Call::OnClientInitialMetadata(
 absl::StatusOr<MessageHandle>
 ServerCompressionFilter::Call::OnClientToServerMessage(
     MessageHandle message, ServerCompressionFilter* filter) {
-  return filter->compression_engine_.DecompressMessage(std::move(message),
-                                                       decompress_args_);
+  return filter->compression_engine_.DecompressMessage(
+      /*is_client=*/false, std::move(message), decompress_args_);
 }
 
 void ServerCompressionFilter::Call::OnServerInitialMetadata(

data/src/core/ext/filters/http/message_compress/compression_filter.h

@@ -87,7 +87,8 @@ class ChannelCompression {
   MessageHandle CompressMessage(MessageHandle message,
                                 grpc_compression_algorithm algorithm) const;
   // Decompress one message synchronously.
-  absl::StatusOr<MessageHandle> DecompressMessage(MessageHandle message,
+  absl::StatusOr<MessageHandle> DecompressMessage(bool is_client,
+                                                  MessageHandle message,
                                                   DecompressArgs args) const;
 
  private:

data/src/core/ext/filters/http/server/http_server_filter.cc

@@ -67,7 +67,7 @@ void FilterOutgoingMetadata(ServerMetadata* md) {
 
 ServerMetadataHandle MalformedRequest(absl::string_view explanation) {
   auto* arena = GetContext<Arena>();
-  auto hdl = arena->MakePooled<ServerMetadata>(arena);
+  auto hdl = arena->MakePooled<ServerMetadata>();
   hdl->Set(GrpcStatusMetadata(), GRPC_STATUS_UNKNOWN);
   hdl->Set(GrpcMessageMetadata(), Slice::FromStaticString(explanation));
   hdl->Set(GrpcTarPit(), Empty());

data/src/core/ext/filters/message_size/message_size_filter.cc

@@ -160,7 +160,7 @@ absl::StatusOr<ServerMessageSizeFilter> ServerMessageSizeFilter::Create(
 namespace {
 ServerMetadataHandle CheckPayload(const Message& msg,
                                   absl::optional<uint32_t> max_length,
-                                  bool is_send) {
+                                  bool is_client, bool is_send) {
   if (!max_length.has_value()) return nullptr;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_call_trace)) {
     gpr_log(GPR_INFO, "%s[message_size] %s len:%" PRIdPTR " max:%d",
@@ -168,12 +168,13 @@ ServerMetadataHandle CheckPayload(const Message& msg,
             is_send ? "send" : "recv", msg.payload()->Length(), *max_length);
   }
   if (msg.payload()->Length() <= *max_length) return nullptr;
-  auto r = GetContext<Arena>()->MakePooled<ServerMetadata>(GetContext<Arena>());
+  auto r = GetContext<Arena>()->MakePooled<ServerMetadata>();
   r->Set(GrpcStatusMetadata(), GRPC_STATUS_RESOURCE_EXHAUSTED);
-  r->Set(GrpcMessageMetadata(), Slice::FromCopiedString(absl::StrFormat(
-                                    "%s message larger than max (%u vs. %d)",
-                                    is_send ? "Sent" : "Received",
-                                    msg.payload()->Length(), *max_length)));
+  r->Set(GrpcMessageMetadata(),
+         Slice::FromCopiedString(absl::StrFormat(
+             "%s: %s message larger than max (%u vs. %d)",
+             is_client ? "CLIENT" : "SERVER", is_send ? "Sent" : "Received",
+             msg.payload()->Length(), *max_length)));
   return r;
 }
 }  // namespace
@@ -207,22 +208,26 @@ ClientMessageSizeFilter::Call::Call(ClientMessageSizeFilter* filter)
 
 ServerMetadataHandle ServerMessageSizeFilter::Call::OnClientToServerMessage(
     const Message& message, ServerMessageSizeFilter* filter) {
-  return CheckPayload(message, filter->parsed_config_.max_recv_size(), false);
+  return CheckPayload(message, filter->parsed_config_.max_recv_size(),
+                      /*is_client=*/false, false);
 }
 
 ServerMetadataHandle ServerMessageSizeFilter::Call::OnServerToClientMessage(
     const Message& message, ServerMessageSizeFilter* filter) {
-  return CheckPayload(message, filter->parsed_config_.max_send_size(), true);
+  return CheckPayload(message, filter->parsed_config_.max_send_size(),
+                      /*is_client=*/false, true);
 }
 
 ServerMetadataHandle ClientMessageSizeFilter::Call::OnClientToServerMessage(
     const Message& message) {
-  return CheckPayload(message, limits_.max_send_size(), true);
+  return CheckPayload(message, limits_.max_send_size(), /*is_client=*/true,
+                      true);
 }
 
 ServerMetadataHandle ClientMessageSizeFilter::Call::OnServerToClientMessage(
     const Message& message) {
-  return CheckPayload(message, limits_.max_recv_size(), false);
+  return CheckPayload(message, limits_.max_recv_size(), /*is_client=*/true,
+                      false);
 }
 
 namespace {

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

@@ -88,17 +88,10 @@ absl::StatusOr<RbacFilter> RbacFilter::Create(const ChannelArgs& args,
   if (auth_context == nullptr) {
     return GRPC_ERROR_CREATE("No auth context found");
   }
-  auto* transport = args.GetObject<Transport>();
-  if (transport == nullptr) {
-    // This should never happen since the transport is always set on the server
-    // side.
-    return GRPC_ERROR_CREATE("No transport configured");
-  }
-  return RbacFilter(
-      grpc_channel_stack_filter_instance_number(
-          filter_args.channel_stack(),
-          filter_args.uninitialized_channel_element()),
-      EvaluateArgs::PerChannelArgs(auth_context, transport->GetEndpoint()));
+  return RbacFilter(grpc_channel_stack_filter_instance_number(
+                        filter_args.channel_stack(),
+                        filter_args.uninitialized_channel_element()),
+                    EvaluateArgs::PerChannelArgs(auth_context, args));
 }
 
 void RbacFilterRegister(CoreConfiguration::Builder* builder) {

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

@@ -203,7 +203,7 @@ struct RbacConfig {
                           ValidationErrors* errors);
       };
 
-      int action;
+      int action = static_cast<int>(Rbac::Action::kDeny);
       std::map<std::string, Policy> policies;
       // Defaults to kNone since its json field is optional.
       Rbac::AuditCondition audit_condition = Rbac::AuditCondition::kNone;
@@ -801,7 +801,7 @@ void RbacConfig::RbacPolicy::Rules::JsonPostLoad(const Json& json,
   if (rbac_action != Rbac::Action::kAllow &&
       rbac_action != Rbac::Action::kDeny) {
     ValidationErrors::ScopedField field(errors, ".action");
-    errors->AddError("unknown action");
+    errors->AddError(absl::StrCat("unknown action ", rbac_action));
   }
   // Parse and validate audit_condition field.
   auto condition = LoadJsonObjectField<int>(json.object(), args,

data/src/core/ext/filters/server_config_selector/server_config_selector_filter.cc

@@ -31,6 +31,7 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/channel/promise_based_filter.h"
+#include "src/core/lib/event_engine/event_engine_context.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/gprpp/sync.h"

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

@@ -64,6 +64,7 @@
 #include "src/core/lib/security/security_connector/security_connector.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/channel.h"
+#include "src/core/lib/surface/channel_create.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/transport/error_utils.h"
 #include "src/core/lib/transport/handshaker.h"
@@ -307,19 +308,13 @@ class Chttp2SecureClientChannelFactory : public ClientChannelFactory {
   }
 };
 
-absl::StatusOr<RefCountedPtr<Channel>> CreateChannel(const char* target,
+absl::StatusOr<OrphanablePtr<Channel>> CreateChannel(const char* target,
                                                      const ChannelArgs& args) {
   if (target == nullptr) {
     gpr_log(GPR_ERROR, "cannot create channel with NULL target name");
     return absl::InvalidArgumentError("channel target is NULL");
   }
-  // Add channel arg containing the server URI.
-  std::string canonical_target =
-      CoreConfiguration::Get().resolver_registry().AddDefaultPrefixIfNeeded(
-          target);
-  return Channel::Create(target,
-                         args.Set(GRPC_ARG_SERVER_URI, canonical_target),
-                         GRPC_CLIENT_CHANNEL, nullptr);
+  return ChannelCreate(target, args, GRPC_CLIENT_CHANNEL, nullptr);
 }
 
 }  // namespace
@@ -410,7 +405,7 @@ grpc_channel* grpc_channel_create_from_fd(const char* target, int fd,
   grpc_core::Transport* transport =
       grpc_create_chttp2_transport(final_args, client, true);
   GPR_ASSERT(transport);
-  auto channel = grpc_core::Channel::Create(
+  auto channel = grpc_core::ChannelCreate(
       target, final_args, GRPC_CLIENT_DIRECT_CHANNEL, transport);
   if (channel.ok()) {
     grpc_chttp2_transport_start_reading(transport, nullptr, nullptr, nullptr);

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

@@ -72,6 +72,7 @@
 #include "src/core/lib/iomgr/tcp_server.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
 #include "src/core/lib/iomgr/vsock.h"
+#include "src/core/lib/resource_quota/connection_quota.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
 #include "src/core/lib/security/credentials/credentials.h"
@@ -283,6 +284,7 @@ class Chttp2ServerListener : public Server::ListenerInterface {
   grpc_closure* on_destroy_done_ ABSL_GUARDED_BY(mu_) = nullptr;
   RefCountedPtr<channelz::ListenSocketNode> channelz_listen_socket_;
   MemoryQuotaRefPtr memory_quota_;
+  ConnectionQuotaRefPtr connection_quota_;
 };
 
 //
@@ -450,11 +452,13 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
   OrphanablePtr<HandshakingState> handshaking_state_ref;
   RefCountedPtr<HandshakeManager> handshake_mgr;
   bool cleanup_connection = false;
+  bool release_connection = false;
   {
     MutexLock connection_lock(&self->connection_->mu_);
     if (!error.ok() || self->connection_->shutdown_) {
       std::string error_str = StatusToString(error);
       cleanup_connection = true;
+      release_connection = true;
       if (error.ok() && args->endpoint != nullptr) {
         // We were shut down or stopped serving after handshaking completed
         // successfully, so destroy the endpoint here.
@@ -504,6 +508,18 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
           } else {
             // Remove the connection from the connections_ map since OnClose()
             // will not be invoked when a config fetcher is set.
+            auto connection_quota =
+                self->connection_->listener_->connection_quota_->Ref()
+                    .release();
+            auto on_close_transport = [](void* arg,
+                                         grpc_error_handle /*handle*/) {
+              ConnectionQuota* connection_quota =
+                  static_cast<ConnectionQuota*>(arg);
+              connection_quota->ReleaseConnections(1);
+              connection_quota->Unref();
+            };
+            on_close = GRPC_CLOSURE_CREATE(on_close_transport, connection_quota,
+                                           grpc_schedule_on_exec_ctx_);
             cleanup_connection = true;
           }
           grpc_chttp2_transport_start_reading(transport, args->read_buffer,
@@ -526,9 +542,11 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
           grpc_slice_buffer_destroy(args->read_buffer);
           gpr_free(args->read_buffer);
           cleanup_connection = true;
+          release_connection = true;
         }
       } else {
         cleanup_connection = true;
+        release_connection = true;
       }
     }
     // Since the handshake manager is done, the connection no longer needs to
@@ -543,6 +561,9 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
   OrphanablePtr<ActiveConnection> connection;
   if (cleanup_connection) {
     MutexLock listener_lock(&self->connection_->listener_->mu_);
+    if (release_connection) {
+      self->connection_->listener_->connection_quota_->ReleaseConnections(1);
+    }
     auto it = self->connection_->listener_->connections_.find(
         self->connection_.get());
     if (it != self->connection_->listener_->connections_.end()) {
@@ -658,6 +679,7 @@ void Chttp2ServerListener::ActiveConnection::OnClose(
       self->drain_grace_timer_handle_.reset();
     }
   }
+  self->listener_->connection_quota_->ReleaseConnections(1);
   self->Unref();
 }
 
@@ -762,7 +784,14 @@ Chttp2ServerListener::Chttp2ServerListener(
     : server_(server),
       args_modifier_(args_modifier),
       args_(args),
-      memory_quota_(args.GetObject<ResourceQuota>()->memory_quota()) {
+      memory_quota_(args.GetObject<ResourceQuota>()->memory_quota()),
+      connection_quota_(MakeRefCounted<ConnectionQuota>()) {
+  auto max_allowed_incoming_connections =
+      args.GetInt(GRPC_ARG_MAX_ALLOWED_INCOMING_CONNECTIONS);
+  if (max_allowed_incoming_connections.has_value()) {
+    connection_quota_->SetMaxIncomingConnections(
+        max_allowed_incoming_connections.value());
+  }
   GRPC_CLOSURE_INIT(&tcp_server_shutdown_complete_, TcpServerShutdownComplete,
                     this, grpc_schedule_on_exec_ctx);
 }
@@ -821,6 +850,14 @@ void Chttp2ServerListener::OnAccept(void* arg, grpc_endpoint* tcp,
     grpc_endpoint_destroy(tcp);
     gpr_free(acceptor);
   };
+  if (!self->connection_quota_->AllowIncomingConnection(
+          self->memory_quota_, grpc_endpoint_get_peer(tcp))) {
+    grpc_error_handle error = GRPC_ERROR_CREATE(
+        "Rejected incoming connection because configured connection quota "
+        "limits have been exceeded.");
+    endpoint_cleanup(error);
+    return;
+  }
   if (self->server_->config_fetcher() != nullptr) {
     if (connection_manager == nullptr) {
       grpc_error_handle error = GRPC_ERROR_CREATE(