grpc 1.45.0 → 1.47.0

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

@@ -22,415 +22,134 @@
 
 #include <string.h>
 
+#include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/profiling/timers.h"
+#include "src/core/lib/promise/call_push_pull.h"
+#include "src/core/lib/promise/promise.h"
+#include "src/core/lib/promise/seq.h"
 #include "src/core/lib/slice/b64.h"
 #include "src/core/lib/slice/percent_encoding.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 
-static void hs_recv_initial_metadata_ready(void* user_data,
-                                           grpc_error_handle err);
-static void hs_recv_trailing_metadata_ready(void* user_data,
-                                            grpc_error_handle err);
-static void hs_recv_message_ready(void* user_data, grpc_error_handle err);
+namespace grpc_core {
 
-namespace {
-
-struct call_data {
-  call_data(grpc_call_element* elem, const grpc_call_element_args& args)
-      : call_combiner(args.call_combiner) {
-    GRPC_CLOSURE_INIT(&recv_initial_metadata_ready,
-                      hs_recv_initial_metadata_ready, elem,
-                      grpc_schedule_on_exec_ctx);
-    GRPC_CLOSURE_INIT(&recv_message_ready, hs_recv_message_ready, elem,
-                      grpc_schedule_on_exec_ctx);
-    GRPC_CLOSURE_INIT(&recv_trailing_metadata_ready,
-                      hs_recv_trailing_metadata_ready, elem,
-                      grpc_schedule_on_exec_ctx);
-  }
-
-  ~call_data() {
-    GRPC_ERROR_UNREF(recv_initial_metadata_ready_error);
-    if (have_read_stream) {
-      read_stream->Orphan();
-    }
-  }
-
-  grpc_core::CallCombiner* call_combiner;
-
-  // If we see the recv_message contents in the GET query string, we
-  // store it here.
-  grpc_core::ManualConstructor<grpc_core::SliceBufferByteStream> read_stream;
-  bool have_read_stream = false;
-
-  // State for intercepting recv_initial_metadata.
-  grpc_closure recv_initial_metadata_ready;
-  grpc_error_handle recv_initial_metadata_ready_error = GRPC_ERROR_NONE;
-  grpc_closure* original_recv_initial_metadata_ready;
-  grpc_metadata_batch* recv_initial_metadata = nullptr;
-  uint32_t* recv_initial_metadata_flags;
-  bool seen_recv_initial_metadata_ready = false;
-
-  // State for intercepting recv_message.
-  grpc_closure* original_recv_message_ready;
-  grpc_closure recv_message_ready;
-  grpc_core::OrphanablePtr<grpc_core::ByteStream>* recv_message;
-  bool seen_recv_message_ready = false;
-
-  // State for intercepting recv_trailing_metadata
-  grpc_closure recv_trailing_metadata_ready;
-  grpc_closure* original_recv_trailing_metadata_ready;
-  grpc_error_handle recv_trailing_metadata_ready_error;
-  bool seen_recv_trailing_metadata_ready = false;
-};
-
-struct channel_data {
-  bool surface_user_agent;
-};
-
-}  // namespace
-
-static grpc_error_handle hs_filter_outgoing_metadata(grpc_metadata_batch* b) {
-  if (grpc_core::Slice* grpc_message =
-          b->get_pointer(grpc_core::GrpcMessageMetadata())) {
-    *grpc_message = grpc_core::PercentEncodeSlice(
-        std::move(*grpc_message), grpc_core::PercentEncodingType::Compatible);
-  }
-  return GRPC_ERROR_NONE;
-}
+const grpc_channel_filter HttpServerFilter::kFilter =
+    MakePromiseBasedFilter<HttpServerFilter, FilterEndpoint::kServer,
+                           kFilterExaminesServerInitialMetadata>("http-server");
 
-static void hs_add_error(const char* error_name, grpc_error_handle* cumulative,
-                         grpc_error_handle new_err) {
-  if (new_err == GRPC_ERROR_NONE) return;
-  if (*cumulative == GRPC_ERROR_NONE) {
-    *cumulative = GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_name);
+namespace {
+void FilterOutgoingMetadata(ServerMetadata* md) {
+  if (Slice* grpc_message = md->get_pointer(GrpcMessageMetadata())) {
+    *grpc_message = PercentEncodeSlice(std::move(*grpc_message),
+                                       PercentEncodingType::Compatible);
   }
-  *cumulative = grpc_error_add_child(*cumulative, new_err);
 }
+}  // namespace
 
-static grpc_error_handle hs_filter_incoming_metadata(grpc_call_element* elem,
-                                                     grpc_metadata_batch* b) {
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  grpc_error_handle error = GRPC_ERROR_NONE;
-  static const char* error_name = "Failed processing incoming headers";
+ArenaPromise<ServerMetadataHandle> HttpServerFilter::MakeCallPromise(
+    CallArgs call_args, NextPromiseFactory next_promise_factory) {
+  const auto& md = call_args.client_initial_metadata;
 
-  auto method = b->get(grpc_core::HttpMethodMetadata());
+  auto method = md->get(HttpMethodMetadata());
   if (method.has_value()) {
     switch (*method) {
-      case grpc_core::HttpMethodMetadata::kPost:
-        *calld->recv_initial_metadata_flags &=
-            ~(GRPC_INITIAL_METADATA_CACHEABLE_REQUEST |
-              GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST);
-        break;
-      case grpc_core::HttpMethodMetadata::kPut:
-        *calld->recv_initial_metadata_flags &=
-            ~GRPC_INITIAL_METADATA_CACHEABLE_REQUEST;
-        *calld->recv_initial_metadata_flags |=
-            GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST;
-        break;
-      case grpc_core::HttpMethodMetadata::kGet:
-        *calld->recv_initial_metadata_flags |=
-            GRPC_INITIAL_METADATA_CACHEABLE_REQUEST;
-        *calld->recv_initial_metadata_flags &=
-            ~GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST;
-        break;
-      case grpc_core::HttpMethodMetadata::kInvalid:
-        hs_add_error(error_name, &error,
-                     GRPC_ERROR_CREATE_FROM_STATIC_STRING("Bad method header"));
+      case HttpMethodMetadata::kPost:
         break;
+      case HttpMethodMetadata::kPut:
+        if (allow_put_requests_) {
+          break;
+        }
+        ABSL_FALLTHROUGH_INTENDED;
+      case HttpMethodMetadata::kInvalid:
+      case HttpMethodMetadata::kGet:
+        return Immediate(
+            ServerMetadataHandle(absl::UnknownError("Bad method header")));
     }
   } else {
-    hs_add_error(error_name, &error,
-                 grpc_error_set_str(
-                     GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing header"),
-                     GRPC_ERROR_STR_KEY, ":method"));
+    return Immediate(
+        ServerMetadataHandle(absl::UnknownError("Missing :method header")));
   }
 
-  auto te = b->Take(grpc_core::TeMetadata());
-  if (te == grpc_core::TeMetadata::kTrailers) {
+  auto te = md->Take(TeMetadata());
+  if (te == TeMetadata::kTrailers) {
     // Do nothing, ok.
   } else if (!te.has_value()) {
-    hs_add_error(error_name, &error,
-                 grpc_error_set_str(
-                     GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing header"),
-                     GRPC_ERROR_STR_KEY, "te"));
+    return Immediate(
+        ServerMetadataHandle(absl::UnknownError("Missing :te header")));
   } else {
-    hs_add_error(error_name, &error,
-                 GRPC_ERROR_CREATE_FROM_STATIC_STRING("Bad te header"));
+    return Immediate(
+        ServerMetadataHandle(absl::UnknownError("Bad :te header")));
   }
 
-  auto scheme = b->Take(grpc_core::HttpSchemeMetadata());
+  auto scheme = md->Take(HttpSchemeMetadata());
   if (scheme.has_value()) {
-    if (*scheme == grpc_core::HttpSchemeMetadata::kInvalid) {
-      hs_add_error(error_name, &error,
-                   GRPC_ERROR_CREATE_FROM_STATIC_STRING("Bad :scheme header"));
+    if (*scheme == HttpSchemeMetadata::kInvalid) {
+      return Immediate(
+          ServerMetadataHandle(absl::UnknownError("Bad :scheme header")));
     }
   } else {
-    hs_add_error(error_name, &error,
-                 grpc_error_set_str(
-                     GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing header"),
-                     GRPC_ERROR_STR_KEY, ":scheme"));
+    return Immediate(
+        ServerMetadataHandle(absl::UnknownError("Missing :scheme header")));
   }
 
-  b->Remove(grpc_core::ContentTypeMetadata());
+  md->Remove(ContentTypeMetadata());
 
-  grpc_core::Slice* path_slice = b->get_pointer(grpc_core::HttpPathMetadata());
+  Slice* path_slice = md->get_pointer(HttpPathMetadata());
   if (path_slice == nullptr) {
-    hs_add_error(error_name, &error,
-                 grpc_error_set_str(
-                     GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing header"),
-                     GRPC_ERROR_STR_KEY, ":path"));
-  } else if (*calld->recv_initial_metadata_flags &
-             GRPC_INITIAL_METADATA_CACHEABLE_REQUEST) {
-    /* We have a cacheable request made with GET verb. The path contains the
-     * query parameter which is base64 encoded request payload. */
-    static const char kQuerySeparator = '?';
-    /* offset of the character '?' */
-    auto it =
-        std::find(path_slice->begin(), path_slice->end(), kQuerySeparator);
-    if (it != path_slice->end()) {
-      const auto query_start = it - path_slice->begin() + 1;
-      auto query_slice = path_slice->RefSubSlice(
-          query_start, path_slice->size() - query_start);
-
-      /* substitute path metadata with just the path (not query) */
-      auto path_without_query = path_slice->TakeSubSlice(0, query_start - 1);
-      *path_slice = std::move(path_without_query);
-
-      /* decode payload from query and add to the slice buffer to be returned */
-      const int k_url_safe = 1;
-      grpc_slice_buffer read_slice_buffer;
-      grpc_slice_buffer_init(&read_slice_buffer);
-      grpc_slice_buffer_add(
-          &read_slice_buffer,
-          grpc_base64_decode_with_len(
-              reinterpret_cast<const char*>(query_slice.begin()),
-              query_slice.size(), k_url_safe));
-      calld->read_stream.Init(&read_slice_buffer, 0);
-      grpc_slice_buffer_destroy_internal(&read_slice_buffer);
-      calld->have_read_stream = true;
-    } else {
-      gpr_log(GPR_ERROR, "GET request without QUERY");
-    }
+    return Immediate(
+        ServerMetadataHandle(absl::UnknownError("Missing :path header")));
   }
 
-  if (b->get_pointer(grpc_core::HttpAuthorityMetadata()) == nullptr) {
-    absl::optional<grpc_core::Slice> host = b->Take(grpc_core::HostMetadata());
+  if (md->get_pointer(HttpAuthorityMetadata()) == nullptr) {
+    absl::optional<Slice> host = md->Take(HostMetadata());
     if (host.has_value()) {
-      b->Set(grpc_core::HttpAuthorityMetadata(), std::move(*host));
-    }
-  }
-
-  if (b->get_pointer(grpc_core::HttpAuthorityMetadata()) == nullptr) {
-    hs_add_error(error_name, &error,
-                 grpc_error_set_str(
-                     GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing header"),
-                     GRPC_ERROR_STR_KEY, ":authority"));
-  }
-
-  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  if (!chand->surface_user_agent) {
-    b->Remove(grpc_core::UserAgentMetadata());
-  }
-
-  return error;
-}
-
-static void hs_recv_initial_metadata_ready(void* user_data,
-                                           grpc_error_handle err) {
-  grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  calld->seen_recv_initial_metadata_ready = true;
-  if (err == GRPC_ERROR_NONE) {
-    err = hs_filter_incoming_metadata(elem, calld->recv_initial_metadata);
-    calld->recv_initial_metadata_ready_error = GRPC_ERROR_REF(err);
-    if (calld->seen_recv_message_ready) {
-      // We've already seen the recv_message callback, but we previously
-      // deferred it, so we need to return it here.
-      // Replace the recv_message byte stream if needed.
-      if (calld->have_read_stream) {
-        calld->recv_message->reset(calld->read_stream.get());
-        calld->have_read_stream = false;
-      }
-      // Re-enter call combiner for original_recv_message_ready, since the
-      // surface code will release the call combiner for each callback it
-      // receives.
-      GRPC_CALL_COMBINER_START(
-          calld->call_combiner, calld->original_recv_message_ready,
-          GRPC_ERROR_REF(err),
-          "resuming recv_message_ready from recv_initial_metadata_ready");
+      md->Set(HttpAuthorityMetadata(), std::move(*host));
     }
-  } else {
-    (void)GRPC_ERROR_REF(err);
-  }
-  if (calld->seen_recv_trailing_metadata_ready) {
-    GRPC_CALL_COMBINER_START(calld->call_combiner,
-                             &calld->recv_trailing_metadata_ready,
-                             calld->recv_trailing_metadata_ready_error,
-                             "resuming hs_recv_trailing_metadata_ready from "
-                             "hs_recv_initial_metadata_ready");
-  }
-  grpc_core::Closure::Run(DEBUG_LOCATION,
-                          calld->original_recv_initial_metadata_ready, err);
-}
-
-static void hs_recv_message_ready(void* user_data, grpc_error_handle err) {
-  grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  calld->seen_recv_message_ready = true;
-  if (calld->seen_recv_initial_metadata_ready) {
-    // We've already seen the recv_initial_metadata callback, so
-    // replace the recv_message byte stream if needed and invoke the
-    // original recv_message callback immediately.
-    if (calld->have_read_stream) {
-      calld->recv_message->reset(calld->read_stream.get());
-      calld->have_read_stream = false;
-    }
-    grpc_core::Closure::Run(DEBUG_LOCATION, calld->original_recv_message_ready,
-                            GRPC_ERROR_REF(err));
-  } else {
-    // We have not yet seen the recv_initial_metadata callback, so we
-    // need to wait to see if this is a GET request.
-    // Note that we release the call combiner here, so that other
-    // callbacks can run.
-    GRPC_CALL_COMBINER_STOP(
-        calld->call_combiner,
-        "pausing recv_message_ready until recv_initial_metadata_ready");
-  }
-}
-
-static void hs_recv_trailing_metadata_ready(void* user_data,
-                                            grpc_error_handle err) {
-  grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  if (!calld->seen_recv_initial_metadata_ready) {
-    calld->recv_trailing_metadata_ready_error = GRPC_ERROR_REF(err);
-    calld->seen_recv_trailing_metadata_ready = true;
-    GRPC_CALL_COMBINER_STOP(calld->call_combiner,
-                            "deferring hs_recv_trailing_metadata_ready until "
-                            "ater hs_recv_initial_metadata_ready");
-    return;
-  }
-  err = grpc_error_add_child(
-      GRPC_ERROR_REF(err),
-      GRPC_ERROR_REF(calld->recv_initial_metadata_ready_error));
-  grpc_core::Closure::Run(DEBUG_LOCATION,
-                          calld->original_recv_trailing_metadata_ready, err);
-}
-
-static grpc_error_handle hs_mutate_op(grpc_call_element* elem,
-                                      grpc_transport_stream_op_batch* op) {
-  /* grab pointers to our data from the call element */
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-
-  if (op->send_initial_metadata) {
-    grpc_error_handle error = GRPC_ERROR_NONE;
-    static const char* error_name = "Failed sending initial metadata";
-    op->payload->send_initial_metadata.send_initial_metadata->Set(
-        grpc_core::HttpStatusMetadata(), 200);
-    op->payload->send_initial_metadata.send_initial_metadata->Set(
-        grpc_core::ContentTypeMetadata(),
-        grpc_core::ContentTypeMetadata::kApplicationGrpc);
-    hs_add_error(error_name, &error,
-                 hs_filter_outgoing_metadata(
-                     op->payload->send_initial_metadata.send_initial_metadata));
-    if (error != GRPC_ERROR_NONE) return error;
-  }
-
-  if (op->recv_initial_metadata) {
-    /* substitute our callback for the higher callback */
-    GPR_ASSERT(op->payload->recv_initial_metadata.recv_flags != nullptr);
-    calld->recv_initial_metadata =
-        op->payload->recv_initial_metadata.recv_initial_metadata;
-    calld->recv_initial_metadata_flags =
-        op->payload->recv_initial_metadata.recv_flags;
-    calld->original_recv_initial_metadata_ready =
-        op->payload->recv_initial_metadata.recv_initial_metadata_ready;
-    op->payload->recv_initial_metadata.recv_initial_metadata_ready =
-        &calld->recv_initial_metadata_ready;
   }
 
-  if (op->recv_message) {
-    calld->recv_message = op->payload->recv_message.recv_message;
-    calld->original_recv_message_ready =
-        op->payload->recv_message.recv_message_ready;
-    op->payload->recv_message.recv_message_ready = &calld->recv_message_ready;
+  if (md->get_pointer(HttpAuthorityMetadata()) == nullptr) {
+    return Immediate(
+        ServerMetadataHandle(absl::UnknownError("Missing :authority header")));
   }
 
-  if (op->recv_trailing_metadata) {
-    calld->original_recv_trailing_metadata_ready =
-        op->payload->recv_trailing_metadata.recv_trailing_metadata_ready;
-    op->payload->recv_trailing_metadata.recv_trailing_metadata_ready =
-        &calld->recv_trailing_metadata_ready;
+  if (!surface_user_agent_) {
+    md->Remove(UserAgentMetadata());
   }
 
-  if (op->send_trailing_metadata) {
-    grpc_error_handle error = hs_filter_outgoing_metadata(
-        op->payload->send_trailing_metadata.send_trailing_metadata);
-    if (error != GRPC_ERROR_NONE) return error;
-  }
+  auto* read_latch = GetContext<Arena>()->New<Latch<ServerMetadata*>>();
+  auto* write_latch =
+      absl::exchange(call_args.server_initial_metadata, read_latch);
 
-  return GRPC_ERROR_NONE;
+  return CallPushPull(Seq(next_promise_factory(std::move(call_args)),
+                          [](ServerMetadataHandle md) -> ServerMetadataHandle {
+                            FilterOutgoingMetadata(md.get());
+                            return md;
+                          }),
+                      Seq(read_latch->Wait(),
+                          [write_latch](ServerMetadata** md) {
+                            FilterOutgoingMetadata(*md);
+                            (*md)->Set(HttpStatusMetadata(), 200);
+                            (*md)->Set(ContentTypeMetadata(),
+                                       ContentTypeMetadata::kApplicationGrpc);
+                            write_latch->Set(*md);
+                            return absl::OkStatus();
+                          }),
+                      []() { return absl::OkStatus(); });
 }
 
-static void hs_start_transport_stream_op_batch(
-    grpc_call_element* elem, grpc_transport_stream_op_batch* op) {
-  GPR_TIMER_SCOPE("hs_start_transport_stream_op_batch", 0);
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  grpc_error_handle error = hs_mutate_op(elem, op);
-  if (error != GRPC_ERROR_NONE) {
-    grpc_transport_stream_op_batch_finish_with_failure(op, error,
-                                                       calld->call_combiner);
-  } else {
-    grpc_call_next_op(elem, op);
-  }
+absl::StatusOr<HttpServerFilter> HttpServerFilter::Create(ChannelArgs args,
+                                                          ChannelFilter::Args) {
+  return HttpServerFilter(
+      args.GetBool(GRPC_ARG_SURFACE_USER_AGENT).value_or(true),
+      args.GetBool(
+              GRPC_ARG_DO_NOT_USE_UNLESS_YOU_HAVE_PERMISSION_FROM_GRPC_TEAM_ALLOW_BROKEN_PUT_REQUESTS)
+          .value_or(false));
 }
 
-/* Constructor for call_data */
-static grpc_error_handle hs_init_call_elem(grpc_call_element* elem,
-                                           const grpc_call_element_args* args) {
-  new (elem->call_data) call_data(elem, *args);
-  return GRPC_ERROR_NONE;
-}
-
-/* Destructor for call_data */
-static void hs_destroy_call_elem(grpc_call_element* elem,
-                                 const grpc_call_final_info* /*final_info*/,
-                                 grpc_closure* /*ignored*/) {
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  calld->~call_data();
-}
-
-/* Constructor for channel_data */
-static grpc_error_handle hs_init_channel_elem(grpc_channel_element* elem,
-                                              grpc_channel_element_args* args) {
-  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  GPR_ASSERT(!args->is_last);
-  chand->surface_user_agent = grpc_channel_arg_get_bool(
-      grpc_channel_args_find(args->channel_args,
-                             const_cast<char*>(GRPC_ARG_SURFACE_USER_AGENT)),
-      true);
-  return GRPC_ERROR_NONE;
-}
-
-/* Destructor for channel data */
-static void hs_destroy_channel_elem(grpc_channel_element* /*elem*/) {}
-
-const grpc_channel_filter grpc_http_server_filter = {
-    hs_start_transport_stream_op_batch,
-    nullptr,
-    grpc_channel_next_op,
-    sizeof(call_data),
-    hs_init_call_elem,
-    grpc_call_stack_ignore_set_pollset_or_pollset_set,
-    hs_destroy_call_elem,
-    sizeof(channel_data),
-    hs_init_channel_elem,
-    hs_destroy_channel_elem,
-    grpc_channel_next_get_info,
-    "http-server"};
+}  // namespace grpc_core

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

@@ -22,8 +22,37 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/channel/promise_based_filter.h"
 
-/* Processes metadata on the server side for HTTP2 transports */
-extern const grpc_channel_filter grpc_http_server_filter;
+namespace grpc_core {
+
+// Processes metadata on the server side for HTTP2 transports
+class HttpServerFilter : public ChannelFilter {
+ public:
+  static const grpc_channel_filter kFilter;
+
+  static absl::StatusOr<HttpServerFilter> Create(
+      ChannelArgs args, ChannelFilter::Args filter_args);
+
+  // Construct a promise for one call.
+  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
+      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
+
+ private:
+  HttpServerFilter(bool surface_user_agent, bool allow_put_requests)
+      : surface_user_agent_(surface_user_agent),
+        allow_put_requests_(allow_put_requests) {}
+
+  bool surface_user_agent_;
+  bool allow_put_requests_;
+};
+
+}  // namespace grpc_core
+
+// A Temporary channel arg that allows servers to accept PUT requests. DO NOT
+// USE WITHOUT PERMISSION.
+#define GRPC_ARG_DO_NOT_USE_UNLESS_YOU_HAVE_PERMISSION_FROM_GRPC_TEAM_ALLOW_BROKEN_PUT_REQUESTS \
+  "grpc.http.do_not_use_unless_you_have_permission_from_grpc_team_allow_"                       \
+  "broken_put_requests"
 
 #endif /* GRPC_CORE_EXT_FILTERS_HTTP_SERVER_HTTP_SERVER_FILTER_H */

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

@@ -120,18 +120,16 @@ size_t MessageSizeParser::ParserIndex() {
       parser_name());
 }
 
-int GetMaxRecvSizeFromChannelArgs(const grpc_channel_args* args) {
-  if (grpc_channel_args_want_minimal_stack(args)) return -1;
-  return grpc_channel_args_find_integer(
-      args, GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH,
-      {GRPC_DEFAULT_MAX_RECV_MESSAGE_LENGTH, -1, INT_MAX});
+int GetMaxRecvSizeFromChannelArgs(const ChannelArgs& args) {
+  if (args.WantMinimalStack()) return -1;
+  return std::max(-1, args.GetInt(GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH)
+                          .value_or(GRPC_DEFAULT_MAX_RECV_MESSAGE_LENGTH));
 }
 
-int GetMaxSendSizeFromChannelArgs(const grpc_channel_args* args) {
-  if (grpc_channel_args_want_minimal_stack(args)) return -1;
-  return grpc_channel_args_find_integer(
-      args, GRPC_ARG_MAX_SEND_MESSAGE_LENGTH,
-      {GRPC_DEFAULT_MAX_SEND_MESSAGE_LENGTH, -1, INT_MAX});
+int GetMaxSendSizeFromChannelArgs(const ChannelArgs& args) {
+  if (args.WantMinimalStack()) return -1;
+  return std::max(-1, args.GetInt(GRPC_ARG_MAX_SEND_MESSAGE_LENGTH)
+                          .value_or(GRPC_DEFAULT_MAX_SEND_MESSAGE_LENGTH));
 }
 
 }  // namespace grpc_core
@@ -308,7 +306,7 @@ static void message_size_destroy_call_elem(
 }
 
 grpc_core::MessageSizeParsedConfig::message_size_limits get_message_size_limits(
-    const grpc_channel_args* channel_args) {
+    const grpc_core::ChannelArgs& channel_args) {
   grpc_core::MessageSizeParsedConfig::message_size_limits lim;
   lim.max_send_size = grpc_core::GetMaxSendSizeFromChannelArgs(channel_args);
   lim.max_recv_size = grpc_core::GetMaxRecvSizeFromChannelArgs(channel_args);
@@ -321,7 +319,8 @@ static grpc_error_handle message_size_init_channel_elem(
   GPR_ASSERT(!args->is_last);
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   new (chand) channel_data();
-  chand->limits = get_message_size_limits(args->channel_args);
+  chand->limits = get_message_size_limits(
+      grpc_core::ChannelArgs::FromC(args->channel_args));
   return GRPC_ERROR_NONE;
 }
 
@@ -341,6 +340,7 @@ const grpc_channel_filter grpc_message_size_filter = {
     message_size_destroy_call_elem,
     sizeof(channel_data),
     message_size_init_channel_elem,
+    grpc_channel_stack_no_post_init,
     message_size_destroy_channel_elem,
     grpc_channel_next_get_info,
     "message_size"};
@@ -348,11 +348,10 @@ const grpc_channel_filter grpc_message_size_filter = {
 // Used for GRPC_CLIENT_SUBCHANNEL
 static bool maybe_add_message_size_filter_subchannel(
     grpc_core::ChannelStackBuilder* builder) {
-  const grpc_channel_args* channel_args = builder->channel_args();
-  if (grpc_channel_args_want_minimal_stack(channel_args)) {
+  if (builder->channel_args().WantMinimalStack()) {
     return true;
   }
-  builder->PrependFilter(&grpc_message_size_filter, nullptr);
+  builder->PrependFilter(&grpc_message_size_filter);
   return true;
 }
 
@@ -360,21 +359,16 @@ static bool maybe_add_message_size_filter_subchannel(
 // only if message size limits or service config is specified.
 static bool maybe_add_message_size_filter(
     grpc_core::ChannelStackBuilder* builder) {
-  const grpc_channel_args* channel_args = builder->channel_args();
-  if (grpc_channel_args_want_minimal_stack(channel_args)) {
+  auto channel_args = builder->channel_args();
+  if (channel_args.WantMinimalStack()) {
     return true;
   }
-  bool enable = false;
   grpc_core::MessageSizeParsedConfig::message_size_limits lim =
       get_message_size_limits(channel_args);
-  if (lim.max_send_size != -1 || lim.max_recv_size != -1) {
-    enable = true;
-  }
-  const grpc_arg* a =
-      grpc_channel_args_find(channel_args, GRPC_ARG_SERVICE_CONFIG);
-  const char* svc_cfg_str = grpc_channel_arg_get_string(a);
-  if (svc_cfg_str != nullptr) enable = true;
-  if (enable) builder->PrependFilter(&grpc_message_size_filter, nullptr);
+  const bool enable =
+      lim.max_send_size != -1 || lim.max_recv_size != -1 ||
+      channel_args.GetString(GRPC_ARG_SERVICE_CONFIG).has_value();
+  if (enable) builder->PrependFilter(&grpc_message_size_filter);
   return true;
 }
 

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

@@ -65,8 +65,8 @@ class MessageSizeParser : public ServiceConfigParser::Parser {
   static absl::string_view parser_name() { return "message_size"; }
 };
 
-int GetMaxRecvSizeFromChannelArgs(const grpc_channel_args* args);
-int GetMaxSendSizeFromChannelArgs(const grpc_channel_args* args);
+int GetMaxRecvSizeFromChannelArgs(const ChannelArgs& args);
+int GetMaxSendSizeFromChannelArgs(const ChannelArgs& args);
 
 }  // namespace grpc_core
 

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

@@ -118,6 +118,7 @@ const grpc_channel_filter RbacFilter::kFilterVtable = {
     RbacFilter::CallData::Destroy,
     sizeof(RbacFilter),
     RbacFilter::Init,
+    grpc_channel_stack_no_post_init,
     RbacFilter::Destroy,
     grpc_channel_next_get_info,
     "rbac_filter",

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

@@ -54,14 +54,8 @@ grpc_arg ServerConfigSelectorProvider::MakeChannelArg() const {
       const_cast<ServerConfigSelectorProvider*>(this), &kChannelArgVtable);
 }
 
-RefCountedPtr<ServerConfigSelectorProvider>
-ServerConfigSelectorProvider::GetFromChannelArgs(
-    const grpc_channel_args& args) {
-  ServerConfigSelectorProvider* config_selector_provider =
-      grpc_channel_args_find_pointer<ServerConfigSelectorProvider>(
-          &args, kServerConfigSelectorProviderChannelArgName);
-  return config_selector_provider != nullptr ? config_selector_provider->Ref()
-                                             : nullptr;
+absl::string_view ServerConfigSelectorProvider::ChannelArgName() {
+  return kServerConfigSelectorProviderChannelArgName;
 }
 
 }  // namespace grpc_core