grpc 1.30.0 → 1.31.1

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

@@ -38,7 +38,8 @@ static optional_filter compress_filter = {
     &grpc_message_compress_filter, GRPC_ARG_ENABLE_PER_MESSAGE_COMPRESSION};
 
 static optional_filter decompress_filter = {
-    &grpc_message_decompress_filter, GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION};
+    &grpc_core::MessageDecompressFilter,
+    GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION};
 
 static bool is_building_http_like_transport(
     grpc_channel_stack_builder* builder) {

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

@@ -18,16 +18,20 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/ext/filters/http/message_compress/message_decompress_filter.h"
+
 #include <assert.h>
 #include <string.h>
 
+#include "absl/strings/str_cat.h"
+
 #include <grpc/compression.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
 
-#include "src/core/ext/filters/http/message_compress/message_decompress_filter.h"
+#include "absl/strings/str_format.h"
+#include "src/core/ext/filters/message_size/message_size_filter.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/compression/algorithm_metadata.h"
 #include "src/core/lib/compression/compression_args.h"
@@ -37,14 +41,25 @@
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 
+namespace grpc_core {
 namespace {
 
-class ChannelData {};
+class ChannelData {
+ public:
+  explicit ChannelData(const grpc_channel_element_args* args)
+      : max_recv_size_(GetMaxRecvSizeFromChannelArgs(args->channel_args)) {}
+
+  int max_recv_size() const { return max_recv_size_; }
+
+ private:
+  int max_recv_size_;
+};
 
 class CallData {
  public:
-  explicit CallData(const grpc_call_element_args& args)
-      : call_combiner_(args.call_combiner) {
+  CallData(const grpc_call_element_args& args, const ChannelData* chand)
+      : call_combiner_(args.call_combiner),
+        max_recv_message_length_(chand->max_recv_size()) {
     // Initialize state for recv_initial_metadata_ready callback
     GRPC_CLOSURE_INIT(&on_recv_initial_metadata_ready_,
                       OnRecvInitialMetadataReady, this,
@@ -59,6 +74,13 @@ class CallData {
     GRPC_CLOSURE_INIT(&on_recv_trailing_metadata_ready_,
                       OnRecvTrailingMetadataReady, this,
                       grpc_schedule_on_exec_ctx);
+    const MessageSizeParsedConfig* limits =
+        MessageSizeParsedConfig::GetFromCallContext(args.context);
+    if (limits != nullptr && limits->limits().max_recv_size >= 0 &&
+        (limits->limits().max_recv_size < max_recv_message_length_ ||
+         max_recv_message_length_ < 0)) {
+      max_recv_message_length_ = limits->limits().max_recv_size;
+    }
   }
 
   ~CallData() { grpc_slice_buffer_destroy_internal(&recv_slices_); }
@@ -82,7 +104,7 @@ class CallData {
   void MaybeResumeOnRecvTrailingMetadataReady();
   static void OnRecvTrailingMetadataReady(void* arg, grpc_error* error);
 
-  grpc_core::CallCombiner* call_combiner_;
+  CallCombiner* call_combiner_;
   // Overall error for the call
   grpc_error* error_ = GRPC_ERROR_NONE;
   // Fields for handling recv_initial_metadata_ready callback
@@ -91,17 +113,18 @@ class CallData {
   grpc_metadata_batch* recv_initial_metadata_ = nullptr;
   // Fields for handling recv_message_ready callback
   bool seen_recv_message_ready_ = false;
+  int max_recv_message_length_;
   grpc_message_compression_algorithm algorithm_ = GRPC_MESSAGE_COMPRESS_NONE;
   grpc_closure on_recv_message_ready_;
   grpc_closure* original_recv_message_ready_ = nullptr;
   grpc_closure on_recv_message_next_done_;
-  grpc_core::OrphanablePtr<grpc_core::ByteStream>* recv_message_ = nullptr;
+  OrphanablePtr<ByteStream>* recv_message_ = nullptr;
   // recv_slices_ holds the slices read from the original recv_message stream.
   // It is initialized during construction and reset when a new stream is
   // created using it.
   grpc_slice_buffer recv_slices_;
-  std::aligned_storage<sizeof(grpc_core::SliceBufferByteStream),
-                       alignof(grpc_core::SliceBufferByteStream)>::type
+  std::aligned_storage<sizeof(SliceBufferByteStream),
+                       alignof(SliceBufferByteStream)>::type
       recv_replacement_stream_;
   // Fields for handling recv_trailing_metadata_ready callback
   bool seen_recv_trailing_metadata_ready_ = false;
@@ -139,7 +162,7 @@ void CallData::OnRecvInitialMetadataReady(void* arg, grpc_error* error) {
   calld->MaybeResumeOnRecvTrailingMetadataReady();
   grpc_closure* closure = calld->original_recv_initial_metadata_ready_;
   calld->original_recv_initial_metadata_ready_ = nullptr;
-  grpc_core::Closure::Run(DEBUG_LOCATION, closure, GRPC_ERROR_REF(error));
+  Closure::Run(DEBUG_LOCATION, closure, GRPC_ERROR_REF(error));
 }
 
 void CallData::MaybeResumeOnRecvMessageReady() {
@@ -170,6 +193,19 @@ void CallData::OnRecvMessageReady(void* arg, grpc_error* error) {
               0) {
         return calld->ContinueRecvMessageReadyCallback(GRPC_ERROR_NONE);
       }
+      if (calld->max_recv_message_length_ >= 0 &&
+          (*calld->recv_message_)->length() >
+              static_cast<uint32_t>(calld->max_recv_message_length_)) {
+        std::string message_string = absl::StrFormat(
+            "Received message larger than max (%u vs. %d)",
+            (*calld->recv_message_)->length(), calld->max_recv_message_length_);
+        GPR_DEBUG_ASSERT(calld->error_ == GRPC_ERROR_NONE);
+        calld->error_ = grpc_error_set_int(
+            GRPC_ERROR_CREATE_FROM_COPIED_STRING(message_string.c_str()),
+            GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_RESOURCE_EXHAUSTED);
+        return calld->ContinueRecvMessageReadyCallback(
+            GRPC_ERROR_REF(calld->error_));
+      }
       grpc_slice_buffer_destroy_internal(&calld->recv_slices_);
       grpc_slice_buffer_init(&calld->recv_slices_);
       return calld->ContinueReadingRecvMessage();
@@ -223,14 +259,12 @@ void CallData::FinishRecvMessage() {
   grpc_slice_buffer_init(&decompressed_slices);
   if (grpc_msg_decompress(algorithm_, &recv_slices_, &decompressed_slices) ==
       0) {
-    char* msg;
-    gpr_asprintf(
-        &msg,
-        "Unexpected error decompressing data for algorithm with enum value %d",
-        algorithm_);
     GPR_DEBUG_ASSERT(error_ == GRPC_ERROR_NONE);
-    error_ = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
-    gpr_free(msg);
+    error_ = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+        absl::StrCat("Unexpected error decompressing data for algorithm with "
+                     "enum value ",
+                     algorithm_)
+            .c_str());
     grpc_slice_buffer_destroy_internal(&decompressed_slices);
   } else {
     uint32_t recv_flags =
@@ -241,9 +275,9 @@ void CallData::FinishRecvMessage() {
     // Initializing recv_replacement_stream_ with decompressed_slices removes
     // all the slices from decompressed_slices leaving it empty.
     new (&recv_replacement_stream_)
-        grpc_core::SliceBufferByteStream(&decompressed_slices, recv_flags);
-    recv_message_->reset(reinterpret_cast<grpc_core::SliceBufferByteStream*>(
-        &recv_replacement_stream_));
+        SliceBufferByteStream(&decompressed_slices, recv_flags);
+    recv_message_->reset(
+        reinterpret_cast<SliceBufferByteStream*>(&recv_replacement_stream_));
     recv_message_ = nullptr;
   }
   ContinueRecvMessageReadyCallback(GRPC_ERROR_REF(error_));
@@ -254,7 +288,7 @@ void CallData::ContinueRecvMessageReadyCallback(grpc_error* error) {
   // The surface will clean up the receiving stream if there is an error.
   grpc_closure* closure = original_recv_message_ready_;
   original_recv_message_ready_ = nullptr;
-  grpc_core::Closure::Run(DEBUG_LOCATION, closure, error);
+  Closure::Run(DEBUG_LOCATION, closure, error);
 }
 
 void CallData::MaybeResumeOnRecvTrailingMetadataReady() {
@@ -283,7 +317,7 @@ void CallData::OnRecvTrailingMetadataReady(void* arg, grpc_error* error) {
   calld->error_ = GRPC_ERROR_NONE;
   grpc_closure* closure = calld->original_recv_trailing_metadata_ready_;
   calld->original_recv_trailing_metadata_ready_ = nullptr;
-  grpc_core::Closure::Run(DEBUG_LOCATION, closure, error);
+  Closure::Run(DEBUG_LOCATION, closure, error);
 }
 
 void CallData::DecompressStartTransportStreamOpBatch(
@@ -322,37 +356,44 @@ void DecompressStartTransportStreamOpBatch(
   calld->DecompressStartTransportStreamOpBatch(elem, batch);
 }
 
-static grpc_error* DecompressInitCallElem(grpc_call_element* elem,
-                                          const grpc_call_element_args* args) {
-  new (elem->call_data) CallData(*args);
+grpc_error* DecompressInitCallElem(grpc_call_element* elem,
+                                   const grpc_call_element_args* args) {
+  ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
+  new (elem->call_data) CallData(*args, chand);
   return GRPC_ERROR_NONE;
 }
 
-static void DecompressDestroyCallElem(
-    grpc_call_element* elem, const grpc_call_final_info* /*final_info*/,
-    grpc_closure* /*ignored*/) {
+void DecompressDestroyCallElem(grpc_call_element* elem,
+                               const grpc_call_final_info* /*final_info*/,
+                               grpc_closure* /*ignored*/) {
   CallData* calld = static_cast<CallData*>(elem->call_data);
   calld->~CallData();
 }
 
-static grpc_error* DecompressInitChannelElem(
-    grpc_channel_element* /*elem*/, grpc_channel_element_args* /*args*/) {
+grpc_error* DecompressInitChannelElem(grpc_channel_element* elem,
+                                      grpc_channel_element_args* args) {
+  ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
+  new (chand) ChannelData(args);
   return GRPC_ERROR_NONE;
 }
 
-void DecompressDestroyChannelElem(grpc_channel_element* /*elem*/) {}
+void DecompressDestroyChannelElem(grpc_channel_element* elem) {
+  ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
+  chand->~ChannelData();
+}
 
 }  // namespace
 
-const grpc_channel_filter grpc_message_decompress_filter = {
+const grpc_channel_filter MessageDecompressFilter = {
     DecompressStartTransportStreamOpBatch,
     grpc_channel_next_op,
     sizeof(CallData),
     DecompressInitCallElem,
     grpc_call_stack_ignore_set_pollset_or_pollset_set,
     DecompressDestroyCallElem,
-    0,  // sizeof(ChannelData)
+    sizeof(ChannelData),
     DecompressInitChannelElem,
     DecompressDestroyChannelElem,
     grpc_channel_next_get_info,
     "message_decompress"};
+}  // namespace grpc_core

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

@@ -23,7 +23,9 @@
 
 #include "src/core/lib/channel/channel_stack.h"
 
-extern const grpc_channel_filter grpc_message_decompress_filter;
+namespace grpc_core {
+extern const grpc_channel_filter MessageDecompressFilter;
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_EXT_FILTERS_HTTP_MESSAGE_COMPRESS_MESSAGE_DECOMPRESS_FILTER_H \
         */

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

@@ -21,10 +21,11 @@
 #include <limits.h>
 #include <string.h>
 
+#include "absl/strings/str_format.h"
+
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
 
 #include "src/core/ext/filters/client_channel/service_config.h"
 #include "src/core/ext/filters/client_channel/service_config_call_data.h"
@@ -45,6 +46,25 @@ namespace {
 size_t g_message_size_parser_index;
 }  // namespace
 
+//
+// MessageSizeParsedConfig
+//
+
+const MessageSizeParsedConfig* MessageSizeParsedConfig::GetFromCallContext(
+    const grpc_call_context_element* context) {
+  if (context == nullptr) return nullptr;
+  auto* svc_cfg_call_data = static_cast<ServiceConfigCallData*>(
+      context[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].value);
+  if (svc_cfg_call_data == nullptr) return nullptr;
+  return static_cast<const MessageSizeParsedConfig*>(
+      svc_cfg_call_data->GetMethodParsedConfig(
+          MessageSizeParser::ParserIndex()));
+}
+
+//
+// MessageSizeParser
+//
+
 std::unique_ptr<ServiceConfigParser::ParsedConfig>
 MessageSizeParser::ParsePerMethodParams(const Json& json, grpc_error** error) {
   GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
@@ -97,12 +117,26 @@ void MessageSizeParser::Register() {
 }
 
 size_t MessageSizeParser::ParserIndex() { return g_message_size_parser_index; }
+
+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 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});
+}
+
 }  // namespace grpc_core
 
 namespace {
 struct channel_data {
   grpc_core::MessageSizeParsedConfig::message_size_limits limits;
-  grpc_core::RefCountedPtr<grpc_core::ServiceConfig> svc_cfg;
 };
 
 struct call_data {
@@ -118,24 +152,8 @@ struct call_data {
     // Note: Per-method config is only available on the client, so we
     // apply the max request size to the send limit and the max response
     // size to the receive limit.
-    const grpc_core::MessageSizeParsedConfig* limits = nullptr;
-    grpc_core::ServiceConfigCallData* svc_cfg_call_data = nullptr;
-    if (args.context != nullptr) {
-      svc_cfg_call_data = static_cast<grpc_core::ServiceConfigCallData*>(
-          args.context[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].value);
-    }
-    if (svc_cfg_call_data != nullptr) {
-      limits = static_cast<const grpc_core::MessageSizeParsedConfig*>(
-          svc_cfg_call_data->GetMethodParsedConfig(
-              grpc_core::MessageSizeParser::ParserIndex()));
-    } else if (chand.svc_cfg != nullptr) {
-      const auto* objs_vector =
-          chand.svc_cfg->GetMethodParsedConfigVector(args.path);
-      if (objs_vector != nullptr) {
-        limits = static_cast<const grpc_core::MessageSizeParsedConfig*>(
-            (*objs_vector)[grpc_core::MessageSizeParser::ParserIndex()].get());
-      }
-    }
+    const grpc_core::MessageSizeParsedConfig* limits =
+        grpc_core::MessageSizeParsedConfig::GetFromCallContext(args.context);
     if (limits != nullptr) {
       if (limits->limits().max_send_size >= 0 &&
           (limits->limits().max_send_size < this->limits.max_send_size ||
@@ -181,17 +199,16 @@ static void recv_message_ready(void* user_data, grpc_error* error) {
   if (*calld->recv_message != nullptr && calld->limits.max_recv_size >= 0 &&
       (*calld->recv_message)->length() >
           static_cast<size_t>(calld->limits.max_recv_size)) {
-    char* message_string;
-    gpr_asprintf(&message_string,
-                 "Received message larger than max (%u vs. %d)",
-                 (*calld->recv_message)->length(), calld->limits.max_recv_size);
     grpc_error* new_error = grpc_error_set_int(
-        GRPC_ERROR_CREATE_FROM_COPIED_STRING(message_string),
+        GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+            absl::StrFormat("Received message larger than max (%u vs. %d)",
+                            (*calld->recv_message)->length(),
+                            calld->limits.max_recv_size)
+                .c_str()),
         GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_RESOURCE_EXHAUSTED);
     error = grpc_error_add_child(GRPC_ERROR_REF(error), new_error);
     GRPC_ERROR_UNREF(calld->error);
     calld->error = GRPC_ERROR_REF(error);
-    gpr_free(message_string);
   } else {
     GRPC_ERROR_REF(error);
   }
@@ -241,17 +258,17 @@ static void message_size_start_transport_stream_op_batch(
   if (op->send_message && calld->limits.max_send_size >= 0 &&
       op->payload->send_message.send_message->length() >
           static_cast<size_t>(calld->limits.max_send_size)) {
-    char* message_string;
-    gpr_asprintf(&message_string, "Sent message larger than max (%u vs. %d)",
-                 op->payload->send_message.send_message->length(),
-                 calld->limits.max_send_size);
     grpc_transport_stream_op_batch_finish_with_failure(
         op,
-        grpc_error_set_int(GRPC_ERROR_CREATE_FROM_COPIED_STRING(message_string),
-                           GRPC_ERROR_INT_GRPC_STATUS,
-                           GRPC_STATUS_RESOURCE_EXHAUSTED),
+        grpc_error_set_int(
+            GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+                absl::StrFormat(
+                    "Sent message larger than max (%u vs. %d)",
+                    op->payload->send_message.send_message->length(),
+                    calld->limits.max_send_size)
+                    .c_str()),
+            GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_RESOURCE_EXHAUSTED),
         calld->call_combiner);
-    gpr_free(message_string);
     return;
   }
   // Inject callback for receiving a message.
@@ -288,35 +305,11 @@ static void message_size_destroy_call_elem(
   calld->~call_data();
 }
 
-static int default_size(const grpc_channel_args* args,
-                        int without_minimal_stack) {
-  if (grpc_channel_args_want_minimal_stack(args)) {
-    return -1;
-  }
-  return without_minimal_stack;
-}
-
 grpc_core::MessageSizeParsedConfig::message_size_limits get_message_size_limits(
     const grpc_channel_args* channel_args) {
   grpc_core::MessageSizeParsedConfig::message_size_limits lim;
-  lim.max_send_size =
-      default_size(channel_args, GRPC_DEFAULT_MAX_SEND_MESSAGE_LENGTH);
-  lim.max_recv_size =
-      default_size(channel_args, GRPC_DEFAULT_MAX_RECV_MESSAGE_LENGTH);
-  for (size_t i = 0; i < channel_args->num_args; ++i) {
-    if (strcmp(channel_args->args[i].key, GRPC_ARG_MAX_SEND_MESSAGE_LENGTH) ==
-        0) {
-      const grpc_integer_options options = {lim.max_send_size, -1, INT_MAX};
-      lim.max_send_size =
-          grpc_channel_arg_get_integer(&channel_args->args[i], options);
-    }
-    if (strcmp(channel_args->args[i].key,
-               GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH) == 0) {
-      const grpc_integer_options options = {lim.max_recv_size, -1, INT_MAX};
-      lim.max_recv_size =
-          grpc_channel_arg_get_integer(&channel_args->args[i], options);
-    }
-  }
+  lim.max_send_size = grpc_core::GetMaxSendSizeFromChannelArgs(channel_args);
+  lim.max_recv_size = grpc_core::GetMaxRecvSizeFromChannelArgs(channel_args);
   return lim;
 }
 
@@ -327,26 +320,6 @@ static grpc_error* message_size_init_channel_elem(
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   new (chand) channel_data();
   chand->limits = get_message_size_limits(args->channel_args);
-  // TODO(yashykt): We only need to read GRPC_ARG_SERVICE_CONFIG in the case of
-  // direct channels. (Service config is otherwise stored in the call_context by
-  // client_channel filter.) If we ever need a second filter that also needs to
-  // parse GRPC_ARG_SERVICE_CONFIG, we should refactor this code and add a
-  // separate filter that reads GRPC_ARG_SERVICE_CONFIG and saves the parsed
-  // config in the call_context.
-  const grpc_arg* channel_arg =
-      grpc_channel_args_find(args->channel_args, GRPC_ARG_SERVICE_CONFIG);
-  const char* service_config_str = grpc_channel_arg_get_string(channel_arg);
-  if (service_config_str != nullptr) {
-    grpc_error* service_config_error = GRPC_ERROR_NONE;
-    auto svc_cfg = grpc_core::ServiceConfig::Create(service_config_str,
-                                                    &service_config_error);
-    if (service_config_error == GRPC_ERROR_NONE) {
-      chand->svc_cfg = std::move(svc_cfg);
-    } else {
-      gpr_log(GPR_ERROR, "%s", grpc_error_string(service_config_error));
-    }
-    GRPC_ERROR_UNREF(service_config_error);
-  }
   return GRPC_ERROR_NONE;
 }
 
@@ -387,6 +360,9 @@ static bool maybe_add_message_size_filter(grpc_channel_stack_builder* builder,
                                           void* /*arg*/) {
   const grpc_channel_args* channel_args =
       grpc_channel_stack_builder_get_channel_arguments(builder);
+  if (grpc_channel_args_want_minimal_stack(channel_args)) {
+    return true;
+  }
   bool enable = false;
   grpc_core::MessageSizeParsedConfig::message_size_limits lim =
       get_message_size_limits(channel_args);