grpc 1.42.0 → 1.46.3

data/include/grpc/grpc_security_constants.h

@@ -28,6 +28,7 @@ extern "C" {
 #define GRPC_TLS_TRANSPORT_SECURITY_TYPE "tls"
 
 #define GRPC_X509_CN_PROPERTY_NAME "x509_common_name"
+#define GRPC_X509_SUBJECT_PROPERTY_NAME "x509_subject"
 #define GRPC_X509_SAN_PROPERTY_NAME "x509_subject_alternative_name"
 #define GRPC_X509_PEM_CERT_PROPERTY_NAME "x509_pem_cert"
 // Please note that internally, we just faithfully pass whatever value we got by
@@ -135,20 +136,6 @@ typedef enum {
   GRPC_SECURITY_MAX = GRPC_PRIVACY_AND_INTEGRITY,
 } grpc_security_level;
 
-typedef enum {
-  /** Default option: performs server certificate verification and hostname
-     verification. */
-  GRPC_TLS_SERVER_VERIFICATION,
-  /** Performs server certificate verification, but skips hostname verification
-     Client is responsible for verifying server's identity via
-     server authorization check callback. */
-  GRPC_TLS_SKIP_HOSTNAME_VERIFICATION,
-  /** Skips both server certificate and hostname verification.
-     Client is responsible for verifying server's identity and
-     server's certificate via server authorization check callback. */
-  GRPC_TLS_SKIP_ALL_SERVER_VERIFICATION
-} grpc_tls_server_verification_option;
-
 /**
  * Type of local connections for which local channel/server credentials will be
  * applied. It supports UDS and local TCP connections.

data/include/grpc/impl/codegen/compression_types.h

@@ -60,8 +60,6 @@ typedef enum {
   GRPC_COMPRESS_NONE = 0,
   GRPC_COMPRESS_DEFLATE,
   GRPC_COMPRESS_GZIP,
-  /* EXPERIMENTAL: Stream compression is currently experimental. */
-  GRPC_COMPRESS_STREAM_GZIP,
   /* TODO(ctiller): snappy */
   GRPC_COMPRESS_ALGORITHMS_COUNT
 } grpc_compression_algorithm;

data/include/grpc/impl/codegen/grpc_types.h

@@ -219,7 +219,7 @@ typedef struct {
   "grpc.http2.min_ping_interval_without_data_ms"
 /** Channel arg to override the http2 :scheme header */
 #define GRPC_ARG_HTTP2_SCHEME "grpc.http2_scheme"
-/** How many pings can we send before needing to send a
+/** How many pings can the client send before needing to send a
    data/header frame? (0 indicates that an infinite number of
    pings can be sent without sending a data frame or header frame) */
 #define GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA \
@@ -241,8 +241,8 @@ typedef struct {
     not receive the ping ack, it will close the transport. Int valued,
     milliseconds. */
 #define GRPC_ARG_KEEPALIVE_TIMEOUT_MS "grpc.keepalive_timeout_ms"
-/** Is it permissible to send keepalive pings without any outstanding streams.
-    Int valued, 0(false)/1(true). */
+/** Is it permissible to send keepalive pings from the client without any
+   outstanding streams. Int valued, 0(false)/1(true). */
 #define GRPC_ARG_KEEPALIVE_PERMIT_WITHOUT_CALLS \
   "grpc.keepalive_permit_without_calls"
 /** Default authority to pass if none specified on call construction. A string.
@@ -384,11 +384,10 @@ typedef struct {
     "latency". */
 #define GRPC_ARG_OPTIMIZATION_TARGET "grpc.optimization_target"
 /** Enables retry functionality.  Defaults to true.  When enabled,
-    configurable retries are enabled when they are configured via the
-    service config.  For details, see:
+    transparent retries will be performed as appropriate, and configurable
+    retries are enabled when they are configured via the service config.
+    For details, see:
       https://github.com/grpc/proposal/blob/master/A6-client-retries.md
-    NOTE: Transparent retries are not yet implemented.  When they are
-          implemented, they will also be enabled by this arg.
     NOTE: Hedging functionality is not yet implemented, so those
           fields in the service config will currently be ignored.  See
           also the GRPC_ARG_EXPERIMENTAL_ENABLE_HEDGING arg below.
@@ -422,10 +421,14 @@ typedef struct {
 /** If set, inhibits health checking (which may be enabled via the
  *  service config.) */
 #define GRPC_ARG_INHIBIT_HEALTH_CHECKING "grpc.inhibit_health_checking"
-/** If set, the channel's resolver is allowed to query for SRV records.
- * For example, this is useful as a way to enable the "grpclb"
- * load balancing policy. Note that this only works with the "ares"
- * DNS resolver, and isn't supported by the "native" DNS resolver. */
+/** If enabled, the channel's DNS resolver queries for SRV records.
+ *  This is useful only when using the "grpclb" load balancing policy,
+ *  as described in the following documents:
+ *   https://github.com/grpc/proposal/blob/master/A5-grpclb-in-dns.md
+ *   https://github.com/grpc/proposal/blob/master/A24-lb-policy-config.md
+ *   https://github.com/grpc/proposal/blob/master/A26-grpclb-selection.md
+ *  Note that this works only with the "ares" DNS resolver; it isn't supported
+ *  by the "native" DNS resolver. */
 #define GRPC_ARG_DNS_ENABLE_SRV_QUERIES "grpc.dns_enable_srv_queries"
 /** If set, determines an upper bound on the number of milliseconds that the
  * c-ares based DNS resolver will wait on queries before cancelling them.
@@ -445,6 +448,12 @@ typedef struct {
     gRPC authorization check. */
 #define GRPC_ARG_AUTHORIZATION_POLICY_PROVIDER \
   "grpc.authorization_policy_provider"
+/** EXPERIMENTAL. Updates to a server's configuration from a config fetcher (for
+ * example, listener updates from xDS) cause all older connections to be
+ * gracefully shut down (i.e., "drained") with a grace period configured by this
+ * channel arg. Int valued, milliseconds. Defaults to 10 minutes.*/
+#define GRPC_ARG_SERVER_CONFIG_CHANGE_DRAIN_GRACE_TIME_MS \
+  "grpc.experimental.server_config_change_drain_grace_time_ms"
 /** \} */
 
 /** Result of a grpc call. If the caller satisfies the prerequisites of a
@@ -509,12 +518,8 @@ typedef enum grpc_call_error {
 
 /** Initial metadata flags */
 /** These flags are to be passed to the `grpc_op::flags` field */
-/** Signal that the call is idempotent */
-#define GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST (0x00000010u)
 /** Signal that the call should not return UNAVAILABLE before it has started */
 #define GRPC_INITIAL_METADATA_WAIT_FOR_READY (0x00000020u)
-/** Signal that the call is cacheable. GRPC is free to use GET verb */
-#define GRPC_INITIAL_METADATA_CACHEABLE_REQUEST (0x00000040u)
 /** Signal that GRPC_INITIAL_METADATA_WAIT_FOR_READY was explicitly set
     by the calling application. */
 #define GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET (0x00000080u)
@@ -522,12 +527,10 @@ typedef enum grpc_call_error {
 #define GRPC_INITIAL_METADATA_CORKED (0x00000100u)
 
 /** Mask of all valid flags */
-#define GRPC_INITIAL_METADATA_USED_MASK                  \
-  (GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST |            \
-   GRPC_INITIAL_METADATA_WAIT_FOR_READY |                \
-   GRPC_INITIAL_METADATA_CACHEABLE_REQUEST |             \
-   GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET | \
-   GRPC_INITIAL_METADATA_CORKED | GRPC_WRITE_THROUGH)
+#define GRPC_INITIAL_METADATA_USED_MASK                                  \
+  (GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET |                 \
+   GRPC_INITIAL_METADATA_WAIT_FOR_READY | GRPC_INITIAL_METADATA_CORKED | \
+   GRPC_WRITE_THROUGH)
 
 /** A single metadata element */
 typedef struct grpc_metadata {

data/include/grpc/impl/codegen/port_platform.h

@@ -51,7 +51,9 @@
 /*
  * Defines GRPC_ERROR_IS_ABSEIL_STATUS to use absl::Status for grpc_error_handle
  */
+#ifndef GRPC_ERROR_IS_ABSEIL_STATUS
 // #define GRPC_ERROR_IS_ABSEIL_STATUS 1
+#endif
 
 /* Get windows.h included everywhere (we need it) */
 #if defined(_WIN64) || defined(WIN64) || defined(_WIN32) || defined(WIN32)
@@ -126,11 +128,13 @@
 #elif defined(ANDROID) || defined(__ANDROID__)
 #define GPR_PLATFORM_STRING "android"
 #define GPR_ANDROID 1
-#ifdef __ANDROID_API__
-#if (__ANDROID_API__) >= 29
-#define GPR_SUPPORT_BINDER_TRANSPORT 1
+#ifndef __ANDROID_API__
+#error "__ANDROID_API__ must be defined for Android builds."
 #endif
+#if __ANDROID_API__ < 21
+#error "Requires Android API v21 and above"
 #endif
+#define GPR_SUPPORT_BINDER_TRANSPORT 1
 // TODO(apolcyn): re-evaluate support for c-ares
 // on android after upgrading our c-ares dependency.
 // See https://github.com/grpc/grpc/issues/18038.

data/include/grpc/impl/codegen/slice.h

@@ -58,7 +58,10 @@ struct grpc_slice_refcount;
    Multiple grpc_slice values may share a ref count.
 
    If the slice does not have a refcount, it represents an inlined small piece
-   of data that is copied by value. */
+   of data that is copied by value.
+
+   As a special case, a slice can be given refcount == uintptr_t(1), meaning
+   that the slice represents external data that is not refcounted. */
 struct grpc_slice {
   struct grpc_slice_refcount* refcount;
   union grpc_slice_data {

data/include/grpc/slice.h

@@ -69,12 +69,6 @@ GPRAPI grpc_slice grpc_slice_malloc_large(size_t length);
 
 #define GRPC_SLICE_MALLOC(len) grpc_slice_malloc(len)
 
-/** Intern a slice:
-
-   The return value for two invocations of this function with  the same sequence
-   of bytes is a slice which points to the same memory. */
-GPRAPI grpc_slice grpc_slice_intern(grpc_slice slice);
-
 /** Create a slice by copying a string.
    Does not preserve null terminators.
    Equivalent to:
@@ -129,9 +123,6 @@ GPRAPI grpc_slice grpc_slice_split_head(grpc_slice* s, size_t split);
 
 GPRAPI grpc_slice grpc_empty_slice(void);
 
-GPRAPI uint32_t grpc_slice_default_hash_impl(grpc_slice s);
-GPRAPI int grpc_slice_default_eq_impl(grpc_slice a, grpc_slice b);
-
 GPRAPI int grpc_slice_eq(grpc_slice a, grpc_slice b);
 
 /** Returns <0 if a < b, ==0 if a == b, >0 if a > b
@@ -151,8 +142,6 @@ GPRAPI int grpc_slice_chr(grpc_slice s, char c);
    if it's not found */
 GPRAPI int grpc_slice_slice(grpc_slice haystack, grpc_slice needle);
 
-GPRAPI uint32_t grpc_slice_hash(grpc_slice s);
-
 /** Do two slices point at the same memory, with the same length
    If a or b is inlined, actually compares data */
 GPRAPI int grpc_slice_is_equivalent(grpc_slice a, grpc_slice b);

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

@@ -0,0 +1,309 @@
+// Copyright 2022 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// TODO(ctiller): Add a unit test suite for these filters once it's practical to
+// mock transport operations.
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/filters/channel_idle/channel_idle_filter.h"
+
+#include <limits.h>
+#include <stdlib.h>
+
+#include <atomic>
+#include <limits>
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_stack_builder.h"
+#include "src/core/lib/channel/promise_based_filter.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/gprpp/capture.h"
+#include "src/core/lib/iomgr/timer.h"
+#include "src/core/lib/promise/exec_ctx_wakeup_scheduler.h"
+#include "src/core/lib/promise/loop.h"
+#include "src/core/lib/promise/sleep.h"
+#include "src/core/lib/promise/try_seq.h"
+#include "src/core/lib/transport/http2_errors.h"
+
+namespace grpc_core {
+
+namespace {
+// TODO(ctiller): The idle filter was disabled in client channel by default
+// due to b/143502997. Now the bug is fixed enable the filter by default.
+const auto kDefaultIdleTimeout = Duration::Infinity();
+
+// 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.
+const auto kDefaultMaxConnectionAge = Duration::Infinity();
+const auto kDefaultMaxConnectionAgeGrace = Duration::Infinity();
+const auto kDefaultMaxConnectionIdle = Duration::Infinity();
+const auto kMaxConnectionAgeJitter = 0.1;
+
+TraceFlag grpc_trace_client_idle_filter(false, "client_idle_filter");
+}  // namespace
+
+#define GRPC_IDLE_FILTER_LOG(format, ...)                               \
+  do {                                                                  \
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_client_idle_filter)) {       \
+      gpr_log(GPR_INFO, "(client idle filter) " format, ##__VA_ARGS__); \
+    }                                                                   \
+  } while (0)
+
+namespace {
+
+Duration GetClientIdleTimeout(const ChannelArgs& args) {
+  return args.GetDurationFromIntMillis(GRPC_ARG_CLIENT_IDLE_TIMEOUT_MS)
+      .value_or(kDefaultIdleTimeout);
+}
+
+}  // namespace
+
+struct MaxAgeFilter::Config {
+  Duration max_connection_age;
+  Duration max_connection_idle;
+  Duration max_connection_age_grace;
+
+  bool enable() const {
+    return max_connection_age != Duration::Infinity() ||
+           max_connection_idle != Duration::Infinity();
+  }
+
+  /* A random jitter of +/-10% will be added to MAX_CONNECTION_AGE to spread out
+     connection storms. Note that the MAX_CONNECTION_AGE option without jitter
+     would not create connection storms by itself, but if there happened to be a
+     connection storm it could cause it to repeat at a fixed period. */
+  static Config FromChannelArgs(ChannelArgs args) {
+    const Duration args_max_age =
+        args.GetDurationFromIntMillis(GRPC_ARG_MAX_CONNECTION_AGE_MS)
+            .value_or(kDefaultMaxConnectionAge);
+    const Duration args_max_idle =
+        args.GetDurationFromIntMillis(GRPC_ARG_MAX_CONNECTION_IDLE_MS)
+            .value_or(kDefaultMaxConnectionIdle);
+    const Duration args_max_age_grace =
+        args.GetDurationFromIntMillis(GRPC_ARG_MAX_CONNECTION_AGE_GRACE_MS)
+            .value_or(kDefaultMaxConnectionAgeGrace);
+    /* generate a random number between 1 - kMaxConnectionAgeJitter and
+       1 + kMaxConnectionAgeJitter */
+    const double multiplier =
+        rand() * kMaxConnectionAgeJitter * 2.0 / RAND_MAX + 1.0 -
+        kMaxConnectionAgeJitter;
+    /* GRPC_MILLIS_INF_FUTURE - 0.5 converts the value to float, so that result
+       will not be cast to int implicitly before the comparison. */
+    return Config{args_max_age * multiplier, args_max_idle, args_max_age_grace};
+  }
+};
+
+absl::StatusOr<ClientIdleFilter> ClientIdleFilter::Create(
+    ChannelArgs args, ChannelFilter::Args filter_args) {
+  ClientIdleFilter filter(filter_args.channel_stack(),
+                          GetClientIdleTimeout(args));
+  return absl::StatusOr<ClientIdleFilter>(std::move(filter));
+}
+
+absl::StatusOr<MaxAgeFilter> MaxAgeFilter::Create(
+    ChannelArgs args, ChannelFilter::Args filter_args) {
+  MaxAgeFilter filter(filter_args.channel_stack(),
+                      Config::FromChannelArgs(args));
+  return absl::StatusOr<MaxAgeFilter>(std::move(filter));
+}
+
+void MaxAgeFilter::Shutdown() {
+  max_age_activity_.Reset();
+  ChannelIdleFilter::Shutdown();
+}
+
+void MaxAgeFilter::Start() {
+  // Trigger idle timer immediately
+  IncreaseCallCount();
+  DecreaseCallCount();
+
+  struct StartupClosure {
+    RefCountedPtr<grpc_channel_stack> channel_stack;
+    MaxAgeFilter* filter;
+    grpc_closure closure;
+  };
+  auto run_startup = [](void* p, grpc_error_handle) {
+    auto* startup = static_cast<StartupClosure*>(p);
+    grpc_transport_op* op = grpc_make_transport_op(nullptr);
+    op->start_connectivity_watch.reset(
+        new ConnectivityWatcher(startup->filter));
+    op->start_connectivity_watch_state = GRPC_CHANNEL_IDLE;
+    grpc_channel_next_op(
+        grpc_channel_stack_element(startup->channel_stack.get(), 0), op);
+    delete startup;
+  };
+  auto* startup =
+      new StartupClosure{this->channel_stack()->Ref(), this, grpc_closure{}};
+  GRPC_CLOSURE_INIT(&startup->closure, run_startup, startup, nullptr);
+  ExecCtx::Run(DEBUG_LOCATION, &startup->closure, GRPC_ERROR_NONE);
+
+  auto channel_stack = this->channel_stack()->Ref();
+
+  // Start the max age timer
+  if (max_connection_age_ != Duration::Infinity()) {
+    max_age_activity_.Set(MakeActivity(
+        TrySeq(
+            // First sleep until the max connection age
+            Sleep(ExecCtx::Get()->Now() + max_connection_age_),
+            // Then send a goaway.
+            [this] {
+              GRPC_CHANNEL_STACK_REF(this->channel_stack(),
+                                     "max_age send_goaway");
+              // Jump out of the activity to send the goaway.
+              auto fn = [](void* arg, grpc_error_handle) {
+                auto* channel_stack = static_cast<grpc_channel_stack*>(arg);
+                grpc_transport_op* op = grpc_make_transport_op(nullptr);
+                op->goaway_error = grpc_error_set_int(
+                    GRPC_ERROR_CREATE_FROM_STATIC_STRING("max_age"),
+                    GRPC_ERROR_INT_HTTP2_ERROR, GRPC_HTTP2_NO_ERROR);
+                grpc_channel_element* elem =
+                    grpc_channel_stack_element(channel_stack, 0);
+                elem->filter->start_transport_op(elem, op);
+                GRPC_CHANNEL_STACK_UNREF(channel_stack, "max_age send_goaway");
+              };
+              ExecCtx::Run(
+                  DEBUG_LOCATION,
+                  GRPC_CLOSURE_CREATE(fn, this->channel_stack(), nullptr),
+                  GRPC_ERROR_NONE);
+              return Immediate(absl::OkStatus());
+            },
+            // Sleep for the grace period
+            [this] {
+              return Sleep(ExecCtx::Get()->Now() + max_connection_age_grace_);
+            }),
+        ExecCtxWakeupScheduler(), [channel_stack, this](absl::Status status) {
+          // OnDone -- close the connection if the promise completed
+          // successfully.
+          // (if it did not, it was cancelled)
+          if (status.ok()) CloseChannel();
+        }));
+  }
+}
+
+// Construct a promise for one call.
+ArenaPromise<ServerMetadataHandle> ChannelIdleFilter::MakeCallPromise(
+    CallArgs call_args, NextPromiseFactory next_promise_factory) {
+  using Decrementer = std::unique_ptr<ChannelIdleFilter, CallCountDecreaser>;
+  IncreaseCallCount();
+  return ArenaPromise<ServerMetadataHandle>(
+      Capture([](Decrementer*, ArenaPromise<ServerMetadataHandle>* next)
+                  -> Poll<ServerMetadataHandle> { return (*next)(); },
+              Decrementer(this), next_promise_factory(std::move(call_args))));
+}
+
+bool ChannelIdleFilter::StartTransportOp(grpc_transport_op* op) {
+  // Catch the disconnect_with_error transport op.
+  if (op->disconnect_with_error != GRPC_ERROR_NONE) Shutdown();
+  // Pass the op to the next filter.
+  return false;
+}
+
+void ChannelIdleFilter::Shutdown() {
+  // IncreaseCallCount() introduces a phony call and prevent the timer from
+  // being reset by other threads.
+  IncreaseCallCount();
+  activity_.Reset();
+}
+
+void ChannelIdleFilter::IncreaseCallCount() {
+  idle_filter_state_->IncreaseCallCount();
+}
+
+void ChannelIdleFilter::DecreaseCallCount() {
+  if (idle_filter_state_->DecreaseCallCount()) {
+    // If there are no more calls in progress, start the idle timer.
+    StartIdleTimer();
+  }
+}
+
+void ChannelIdleFilter::StartIdleTimer() {
+  GRPC_IDLE_FILTER_LOG("timer has started");
+  auto idle_filter_state = idle_filter_state_;
+  // Hold a ref to the channel stack for the timer callback.
+  auto channel_stack = channel_stack_->Ref();
+  auto timeout = client_idle_timeout_;
+  auto promise = Loop([timeout, idle_filter_state]() {
+    return TrySeq(Sleep(ExecCtx::Get()->Now() + timeout),
+                  [idle_filter_state]() -> Poll<LoopCtl<absl::Status>> {
+                    if (idle_filter_state->CheckTimer()) {
+                      return Continue{};
+                    } else {
+                      return absl::OkStatus();
+                    }
+                  });
+  });
+  activity_.Set(MakeActivity(std::move(promise), ExecCtxWakeupScheduler{},
+                             [channel_stack, this](absl::Status status) {
+                               if (status.ok()) CloseChannel();
+                             }));
+}
+
+void ChannelIdleFilter::CloseChannel() {
+  auto* op = grpc_make_transport_op(nullptr);
+  op->disconnect_with_error = grpc_error_set_int(
+      GRPC_ERROR_CREATE_FROM_STATIC_STRING("enter idle"),
+      GRPC_ERROR_INT_CHANNEL_CONNECTIVITY_STATE, GRPC_CHANNEL_IDLE);
+  // Pass the transport op down to the channel stack.
+  auto* elem = grpc_channel_stack_element(channel_stack_, 0);
+  elem->filter->start_transport_op(elem, op);
+}
+
+namespace {
+
+const grpc_channel_filter grpc_client_idle_filter =
+    MakePromiseBasedFilter<ClientIdleFilter, FilterEndpoint::kClient>(
+        "client_idle");
+const grpc_channel_filter grpc_max_age_filter =
+    MakePromiseBasedFilter<MaxAgeFilter, FilterEndpoint::kServer>("max_age");
+
+}  // namespace
+
+void RegisterChannelIdleFilters(CoreConfiguration::Builder* builder) {
+  builder->channel_init()->RegisterStage(
+      GRPC_CLIENT_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
+      [](ChannelStackBuilder* builder) {
+        const grpc_channel_args* channel_args = builder->channel_args();
+        if (!grpc_channel_args_want_minimal_stack(channel_args) &&
+            GetClientIdleTimeout(ChannelArgs::FromC(channel_args)) !=
+                Duration::Infinity()) {
+          builder->PrependFilter(&grpc_client_idle_filter, nullptr);
+        }
+        return true;
+      });
+  builder->channel_init()->RegisterStage(
+      GRPC_SERVER_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
+      [](ChannelStackBuilder* builder) {
+        const grpc_channel_args* channel_args = builder->channel_args();
+        if (!grpc_channel_args_want_minimal_stack(channel_args) &&
+            MaxAgeFilter::Config::FromChannelArgs(
+                ChannelArgs::FromC(channel_args))
+                .enable()) {
+          builder->PrependFilter(
+              &grpc_max_age_filter,
+              [](grpc_channel_stack*, grpc_channel_element* elem) {
+                static_cast<MaxAgeFilter*>(elem->channel_data)->Start();
+              });
+        }
+        return true;
+      });
+}
+
+MaxAgeFilter::MaxAgeFilter(grpc_channel_stack* channel_stack,
+                           const Config& max_age_config)
+    : ChannelIdleFilter(channel_stack, max_age_config.max_connection_idle),
+      max_connection_age_(max_age_config.max_connection_age),
+      max_connection_age_grace_(max_age_config.max_connection_age_grace) {}
+
+}  // namespace grpc_core

data/src/core/ext/filters/channel_idle/channel_idle_filter.h

@@ -0,0 +1,122 @@
+// Copyright 2022 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_CORE_EXT_FILTERS_CHANNEL_IDLE_CHANNEL_IDLE_FILTER_H
+#define GRPC_CORE_EXT_FILTERS_CHANNEL_IDLE_CHANNEL_IDLE_FILTER_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/filters/channel_idle/idle_filter_state.h"
+#include "src/core/lib/channel/promise_based_filter.h"
+#include "src/core/lib/gprpp/single_set_ptr.h"
+
+namespace grpc_core {
+
+class ChannelIdleFilter : public ChannelFilter {
+ public:
+  ~ChannelIdleFilter() override = default;
+
+  ChannelIdleFilter(const ChannelIdleFilter&) = delete;
+  ChannelIdleFilter& operator=(const ChannelIdleFilter&) = delete;
+  ChannelIdleFilter(ChannelIdleFilter&&) = default;
+  ChannelIdleFilter& operator=(ChannelIdleFilter&&) = default;
+
+  // Construct a promise for one call.
+  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
+      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
+
+  bool StartTransportOp(grpc_transport_op* op) override;
+
+ protected:
+  using SingleSetActivityPtr =
+      SingleSetPtr<Activity, typename ActivityPtr::deleter_type>;
+
+  ChannelIdleFilter(grpc_channel_stack* channel_stack,
+                    Duration client_idle_timeout)
+      : channel_stack_(channel_stack),
+        client_idle_timeout_(client_idle_timeout) {}
+
+  grpc_channel_stack* channel_stack() { return channel_stack_; };
+
+  virtual void Shutdown();
+  void CloseChannel();
+
+  void IncreaseCallCount();
+  void DecreaseCallCount();
+
+ private:
+  void StartIdleTimer();
+
+  struct CallCountDecreaser {
+    void operator()(ChannelIdleFilter* filter) const {
+      filter->DecreaseCallCount();
+    }
+  };
+
+  // The channel stack to which we take refs for pending callbacks.
+  grpc_channel_stack* channel_stack_;
+  Duration client_idle_timeout_;
+  std::shared_ptr<IdleFilterState> idle_filter_state_{
+      std::make_shared<IdleFilterState>(false)};
+
+  SingleSetActivityPtr activity_;
+};
+
+class ClientIdleFilter final : public ChannelIdleFilter {
+ public:
+  static absl::StatusOr<ClientIdleFilter> Create(
+      ChannelArgs args, ChannelFilter::Args filter_args);
+
+ private:
+  using ChannelIdleFilter::ChannelIdleFilter;
+};
+
+class MaxAgeFilter final : public ChannelIdleFilter {
+ public:
+  struct Config;
+
+  static absl::StatusOr<MaxAgeFilter> Create(ChannelArgs args,
+                                             ChannelFilter::Args filter_args);
+
+  void Start();
+
+ private:
+  class ConnectivityWatcher : public AsyncConnectivityStateWatcherInterface {
+   public:
+    explicit ConnectivityWatcher(MaxAgeFilter* filter)
+        : channel_stack_(filter->channel_stack()->Ref()), filter_(filter) {}
+    ~ConnectivityWatcher() override = default;
+
+    void OnConnectivityStateChange(grpc_connectivity_state new_state,
+                                   const absl::Status&) override {
+      if (new_state == GRPC_CHANNEL_SHUTDOWN) filter_->Shutdown();
+    }
+
+   private:
+    RefCountedPtr<grpc_channel_stack> channel_stack_;
+    MaxAgeFilter* filter_;
+  };
+
+  MaxAgeFilter(grpc_channel_stack* channel_stack, const Config& max_age_config);
+
+  void Shutdown() override;
+
+  SingleSetActivityPtr max_age_activity_;
+  Duration max_connection_age_;
+  Duration max_connection_age_grace_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_EXT_FILTERS_CHANNEL_IDLE_CHANNEL_IDLE_FILTER_H

data/src/core/ext/filters/{client_idle → channel_idle}/idle_filter_state.cc

@@ -14,7 +14,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/filters/client_idle/idle_filter_state.h"
+#include "src/core/ext/filters/channel_idle/idle_filter_state.h"
 
 #include <assert.h>
 

data/src/core/ext/filters/{client_idle → channel_idle}/idle_filter_state.h

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_IDLE_IDLE_FILTER_STATE_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_IDLE_IDLE_FILTER_STATE_H
+#ifndef GRPC_CORE_EXT_FILTERS_CHANNEL_IDLE_IDLE_FILTER_STATE_H
+#define GRPC_CORE_EXT_FILTERS_CHANNEL_IDLE_IDLE_FILTER_STATE_H
 
 #include <grpc/support/port_platform.h>
 
@@ -29,8 +29,8 @@ class IdleFilterState {
   explicit IdleFilterState(bool start_timer);
   ~IdleFilterState() = default;
 
-  IdleFilterState(const IdleFilterState&);
-  IdleFilterState& operator=(const IdleFilterState&);
+  IdleFilterState(const IdleFilterState&) = delete;
+  IdleFilterState& operator=(const IdleFilterState&) = delete;
 
   // Increment the number of calls in progress.
   void IncreaseCallCount();
@@ -63,4 +63,4 @@ class IdleFilterState {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_IDLE_IDLE_FILTER_STATE_H
+#endif  // GRPC_CORE_EXT_FILTERS_CHANNEL_IDLE_IDLE_FILTER_STATE_H