grpc 1.38.0 → 1.40.0

data/src/core/lib/surface/completion_queue.cc

@@ -197,8 +197,7 @@ const cq_poller_vtable g_poller_vtable_by_poller_type[] = {
 struct cq_vtable {
   grpc_cq_completion_type cq_completion_type;
   size_t data_size;
-  void (*init)(void* data,
-               grpc_experimental_completion_queue_functor* shutdown_callback);
+  void (*init)(void* data, grpc_completion_queue_functor* shutdown_callback);
   void (*shutdown)(grpc_completion_queue* cq);
   void (*destroy)(void* data);
   bool (*begin_op)(grpc_completion_queue* cq, void* tag);
@@ -310,8 +309,7 @@ struct cq_pluck_data {
 };
 
 struct cq_callback_data {
-  explicit cq_callback_data(
-      grpc_experimental_completion_queue_functor* shutdown_callback)
+  explicit cq_callback_data(grpc_completion_queue_functor* shutdown_callback)
       : shutdown_callback(shutdown_callback) {}
 
   ~cq_callback_data() {
@@ -332,7 +330,7 @@ struct cq_callback_data {
   bool shutdown_called = false;
 
   /** A callback that gets invoked when the CQ completes shutdown */
-  grpc_experimental_completion_queue_functor* shutdown_callback;
+  grpc_completion_queue_functor* shutdown_callback;
 };
 
 }  // namespace
@@ -397,12 +395,12 @@ static grpc_event cq_pluck(grpc_completion_queue* cq, void* tag,
                            gpr_timespec deadline, void* reserved);
 
 // Note that cq_init_next and cq_init_pluck do not use the shutdown_callback
-static void cq_init_next(
-    void* data, grpc_experimental_completion_queue_functor* shutdown_callback);
-static void cq_init_pluck(
-    void* data, grpc_experimental_completion_queue_functor* shutdown_callback);
-static void cq_init_callback(
-    void* data, grpc_experimental_completion_queue_functor* shutdown_callback);
+static void cq_init_next(void* data,
+                         grpc_completion_queue_functor* shutdown_callback);
+static void cq_init_pluck(void* data,
+                          grpc_completion_queue_functor* shutdown_callback);
+static void cq_init_callback(void* data,
+                             grpc_completion_queue_functor* shutdown_callback);
 static void cq_destroy_next(void* data);
 static void cq_destroy_pluck(void* data);
 static void cq_destroy_callback(void* data);
@@ -513,7 +511,7 @@ grpc_cq_completion* CqEventQueue::Pop() {
 
 grpc_completion_queue* grpc_completion_queue_create_internal(
     grpc_cq_completion_type completion_type, grpc_cq_polling_type polling_type,
-    grpc_experimental_completion_queue_functor* shutdown_callback) {
+    grpc_completion_queue_functor* shutdown_callback) {
   GPR_TIMER_SCOPE("grpc_completion_queue_create_internal", 0);
 
   grpc_completion_queue* cq;
@@ -548,9 +546,8 @@ grpc_completion_queue* grpc_completion_queue_create_internal(
   return cq;
 }
 
-static void cq_init_next(
-    void* data,
-    grpc_experimental_completion_queue_functor* /*shutdown_callback*/) {
+static void cq_init_next(void* data,
+                         grpc_completion_queue_functor* /*shutdown_callback*/) {
   new (data) cq_next_data();
 }
 
@@ -560,8 +557,7 @@ static void cq_destroy_next(void* data) {
 }
 
 static void cq_init_pluck(
-    void* data,
-    grpc_experimental_completion_queue_functor* /*shutdown_callback*/) {
+    void* data, grpc_completion_queue_functor* /*shutdown_callback*/) {
   new (data) cq_pluck_data();
 }
 
@@ -570,8 +566,8 @@ static void cq_destroy_pluck(void* data) {
   cqd->~cq_pluck_data();
 }
 
-static void cq_init_callback(
-    void* data, grpc_experimental_completion_queue_functor* shutdown_callback) {
+static void cq_init_callback(void* data,
+                             grpc_completion_queue_functor* shutdown_callback) {
   new (data) cq_callback_data(shutdown_callback);
 }
 
@@ -836,7 +832,7 @@ static void cq_end_op_for_pluck(
 }
 
 static void functor_callback(void* arg, grpc_error_handle error) {
-  auto* functor = static_cast<grpc_experimental_completion_queue_functor*>(arg);
+  auto* functor = static_cast<grpc_completion_queue_functor*>(arg);
   functor->functor_run(functor, error == GRPC_ERROR_NONE);
 }
 
@@ -880,7 +876,7 @@ static void cq_end_op_for_callback(
   // 2. The callback is marked inlineable and there is an ACEC available
   // 3. We are already running in a background poller thread (which always has
   //    an ACEC available at the base of the stack).
-  auto* functor = static_cast<grpc_experimental_completion_queue_functor*>(tag);
+  auto* functor = static_cast<grpc_completion_queue_functor*>(tag);
   if (((internal || functor->inlineable) &&
        grpc_core::ApplicationCallbackExecCtx::Available()) ||
       grpc_iomgr_is_any_background_poller_thread()) {
@@ -1065,7 +1061,11 @@ static grpc_event cq_next(grpc_completion_queue* cq, gpr_timespec deadline,
       gpr_log(GPR_ERROR, "Completion queue next failed: %s",
               grpc_error_std_string(err).c_str());
       GRPC_ERROR_UNREF(err);
-      ret.type = GRPC_QUEUE_TIMEOUT;
+      if (err == GRPC_ERROR_CANCELLED) {
+        ret.type = GRPC_QUEUE_SHUTDOWN;
+      } else {
+        ret.type = GRPC_QUEUE_TIMEOUT;
+      }
       ret.success = 0;
       dump_pending_tags(cq);
       break;

data/src/core/lib/surface/completion_queue.h

@@ -93,6 +93,6 @@ int grpc_get_cq_poll_num(grpc_completion_queue* cq);
 
 grpc_completion_queue* grpc_completion_queue_create_internal(
     grpc_cq_completion_type completion_type, grpc_cq_polling_type polling_type,
-    grpc_experimental_completion_queue_functor* shutdown_callback);
+    grpc_completion_queue_functor* shutdown_callback);
 
 #endif /* GRPC_CORE_LIB_SURFACE_COMPLETION_QUEUE_H */

data/src/core/lib/surface/completion_queue_factory.cc

@@ -72,8 +72,7 @@ grpc_completion_queue* grpc_completion_queue_create_for_pluck(void* reserved) {
 }
 
 grpc_completion_queue* grpc_completion_queue_create_for_callback(
-    grpc_experimental_completion_queue_functor* shutdown_callback,
-    void* reserved) {
+    grpc_completion_queue_functor* shutdown_callback, void* reserved) {
   GPR_ASSERT(!reserved);
   grpc_completion_queue_attributes attr = {
       2, GRPC_CQ_CALLBACK, GRPC_CQ_DEFAULT_POLLING, shutdown_callback};

data/src/core/lib/surface/init.cc

@@ -126,7 +126,6 @@ void grpc_register_plugin(void (*init)(void), void (*destroy)(void)) {
 }
 
 void grpc_init(void) {
-  int i;
   gpr_once_init(&g_basic_init, do_basic_init);
 
   grpc_core::MutexLock lock(g_init_mu);
@@ -150,7 +149,7 @@ void grpc_init(void) {
     gpr_timers_global_init();
     grpc_core::HandshakerRegistry::Init();
     grpc_security_init();
-    for (i = 0; i < g_number_of_plugins; i++) {
+    for (int i = 0; i < g_number_of_plugins; i++) {
       if (g_all_of_the_plugins[i].init != nullptr) {
         g_all_of_the_plugins[i].init();
       }
@@ -175,7 +174,6 @@ void grpc_shutdown_internal_locked(void) {
     grpc_iomgr_shutdown_background_closure();
     {
       grpc_timer_manager_set_threading(false);  // shutdown timer_manager thread
-      grpc_core::Executor::ShutdownAll();
       for (i = g_number_of_plugins; i >= 0; i--) {
         if (g_all_of_the_plugins[i].destroy != nullptr) {
           g_all_of_the_plugins[i].destroy();

data/src/core/lib/surface/init.h

@@ -15,10 +15,19 @@
  * limitations under the License.
  *
  */
-
 #ifndef GRPC_CORE_LIB_SURFACE_INIT_H
 #define GRPC_CORE_LIB_SURFACE_INIT_H
 
+#include <grpc/support/port_platform.h>
+
+#include <memory>
+
+namespace grpc_event_engine {
+namespace experimental {
+class EventEngine;
+}
+}  // namespace grpc_event_engine
+
 void grpc_register_security_filters(void);
 void grpc_security_pre_init(void);
 void grpc_security_init(void);

data/src/core/lib/surface/server.cc

@@ -809,7 +809,9 @@ void Server::ShutdownAndNotify(grpc_completion_queue* cq, void* tag) {
   {
     // Wait for startup to be finished.  Locks mu_global.
     MutexLock lock(&mu_global_);
-    WaitUntil(&starting_cv_, &mu_global_, [this] { return !starting_; });
+    while (starting_) {
+      starting_cv_.Wait(&mu_global_);
+    }
     // Stay locked, and gather up some stuff to do.
     GPR_ASSERT(grpc_cq_begin_op(cq, tag));
     if (shutdown_published_) {

data/src/core/lib/surface/server.h

@@ -416,9 +416,9 @@ class Server : public InternallyRefCounted<Server> {
   Mutex mu_global_;  // mutex for server and channel state
   Mutex mu_call_;    // mutex for call-specific state
 
-  // startup synchronization: flag is protected by mu_global_, signals whether
-  // we are doing the listener start routine or not.
-  bool starting_ = false;
+  // startup synchronization: flag, signals whether we are doing the listener
+  // start routine or not.
+  bool starting_ ABSL_GUARDED_BY(mu_global_) = false;
   CondVar starting_cv_;
 
   std::vector<std::unique_ptr<RegisteredMethod>> registered_methods_;

data/src/core/lib/surface/version.cc

@@ -23,8 +23,6 @@
 
 #include <grpc/grpc.h>
 
-const char* grpc_version_string(void) { return "16.0.0"; }
+const char* grpc_version_string(void) { return "18.0.0"; }
 
-const char* grpc_g_stands_for(void) {
-  return "guadalupe_river_park_conservancy";
-}
+const char* grpc_g_stands_for(void) { return "guileless"; }

data/src/core/lib/transport/error_utils.cc

@@ -74,7 +74,7 @@ void grpc_error_get_status(grpc_error_handle error, grpc_millis deadline,
   // until we find the first one that has a status code.
   grpc_error_handle found_error =
       recursively_find_error_with_field(error, GRPC_ERROR_INT_GRPC_STATUS);
-  if (found_error == nullptr) {
+  if (found_error == GRPC_ERROR_NONE) {
     /// If no grpc-status exists, retry through the tree to find a http2 error
     /// code
     found_error =
@@ -83,7 +83,7 @@ void grpc_error_get_status(grpc_error_handle error, grpc_millis deadline,
 
   // If we found an error with a status code above, use that; otherwise,
   // fall back to using the parent error.
-  if (found_error == nullptr) found_error = error;
+  if (found_error == GRPC_ERROR_NONE) found_error = error;
 
   grpc_status_code status = GRPC_STATUS_UNKNOWN;
   intptr_t integer;

data/src/core/lib/transport/metadata_batch.cc

@@ -401,9 +401,20 @@ void grpc_metadata_batch_copy(grpc_metadata_batch* src,
   size_t i = 0;
   for (grpc_linked_mdelem* elem = src->list.head; elem != nullptr;
        elem = elem->next) {
+    // If the mdelem is not external, take a ref.
+    // Otherwise, create a new copy, holding its own refs to the
+    // underlying slices.
+    grpc_mdelem md;
+    if (GRPC_MDELEM_STORAGE(elem->md) != GRPC_MDELEM_STORAGE_EXTERNAL) {
+      md = GRPC_MDELEM_REF(elem->md);
+    } else {
+      md = grpc_mdelem_from_slices(
+          grpc_slice_ref_internal(GRPC_MDKEY(elem->md)),
+          grpc_slice_ref_internal(GRPC_MDVALUE(elem->md)));
+    }
     // Error unused in non-debug builds.
-    grpc_error_handle GRPC_UNUSED error = grpc_metadata_batch_add_tail(
-        dst, &storage[i++], GRPC_MDELEM_REF(elem->md));
+    grpc_error_handle GRPC_UNUSED error =
+        grpc_metadata_batch_add_tail(dst, &storage[i++], md);
     // The only way that grpc_metadata_batch_add_tail() can fail is if
     // there's a duplicate entry for a callout.  However, that can't be
     // the case here, because we would not have been allowed to create

data/src/core/lib/transport/metadata_batch.h

@@ -196,6 +196,13 @@ void grpc_metadata_batch_assert_ok(grpc_metadata_batch* batch);
 
 /// Copies \a src to \a dst.  \a storage must point to an array of
 /// \a grpc_linked_mdelem structs of at least the same size as \a src.
+///
+/// For each mdelem in \a src, if the mdelem is of storage types
+/// GRPC_MDELEM_STORAGE_INTERNED or GRPC_MDELEM_STORAGE_ALLOCATED,
+/// refs the original mdelem for the copy.  Otherwise, makes a new
+/// mdelem that will hold its own refs to the key and value slices.
+///
+/// Currently used only in the retry code.
 void grpc_metadata_batch_copy(grpc_metadata_batch* src,
                               grpc_metadata_batch* dst,
                               grpc_linked_mdelem* storage);

data/src/core/lib/transport/transport.h

@@ -295,6 +295,8 @@ struct grpc_transport_stream_op_batch_payload {
     // containing a received message.
     // Will be NULL if trailing metadata is received instead of a message.
     grpc_core::OrphanablePtr<grpc_core::ByteStream>* recv_message = nullptr;
+    // Was this recv_message failed for reasons other than a clean end-of-stream
+    bool* call_failed_before_recv_message = nullptr;
     /** Should be enqueued when one message is ready to be processed. */
     grpc_closure* recv_message_ready = nullptr;
   } recv_message;

data/src/core/lib/transport/transport_op_string.cc

@@ -135,7 +135,7 @@ std::string grpc_transport_op_string(grpc_transport_op* op) {
         " DISCONNECT:", grpc_error_std_string(op->disconnect_with_error)));
   }
 
-  if (op->goaway_error) {
+  if (op->goaway_error != GRPC_ERROR_NONE) {
     out.push_back(absl::StrCat(" SEND_GOAWAY:%s",
                                grpc_error_std_string(op->goaway_error)));
   }

data/src/core/plugin_registry/grpc_plugin_registry.cc

@@ -63,6 +63,8 @@ void grpc_workaround_cronet_compression_filter_shutdown(void);
 namespace grpc_core {
 void FaultInjectionFilterInit(void);
 void FaultInjectionFilterShutdown(void);
+void GrpcLbPolicyRingHashInit(void);
+void GrpcLbPolicyRingHashShutdown(void);
 }  // namespace grpc_core
 
 #ifndef GRPC_NO_XDS
@@ -115,6 +117,8 @@ void grpc_register_built_in_plugins(void) {
                        grpc_lb_policy_pick_first_shutdown);
   grpc_register_plugin(grpc_lb_policy_round_robin_init,
                        grpc_lb_policy_round_robin_shutdown);
+  grpc_register_plugin(grpc_core::GrpcLbPolicyRingHashInit,
+                       grpc_core::GrpcLbPolicyRingHashShutdown);
   grpc_register_plugin(grpc_resolver_dns_ares_init,
                        grpc_resolver_dns_ares_shutdown);
   grpc_register_plugin(grpc_resolver_dns_native_init,

data/src/core/tsi/alts/crypt/gsec.h

@@ -29,12 +29,14 @@
 
 #include <grpc/grpc.h>
 
+#ifndef _STRUCT_IOVEC
 #ifndef GRPC_EVENT_ENGINE_POSIX
 struct iovec {
   void* iov_base;
   size_t iov_len;
 };
 #endif  // GRPC_EVENT_ENGINE_POSIX
+#endif  // _STRUCT_IOVEC
 
 /**
  * A gsec interface for AEAD encryption schemes. The API is thread-compatible.

data/src/ruby/ext/grpc/extconf.rb

@@ -56,6 +56,8 @@ if RUBY_PLATFORM =~ /darwin/
 end
 
 ENV['CPPFLAGS'] = '-DGPR_BACKWARDS_COMPATIBILITY_MODE'
+ENV['CPPFLAGS'] += ' -DGRPC_XDS_USER_AGENT_NAME_SUFFIX="\"RUBY\"" '
+ENV['CPPFLAGS'] += ' -DGRPC_XDS_USER_AGENT_VERSION_SUFFIX="\"1.40.0\"" '
 
 output_dir = File.expand_path(RbConfig::CONFIG['topdir'])
 grpc_lib_dir = File.join(output_dir, 'libs', grpc_config)

data/src/ruby/ext/grpc/rb_grpc_imports.generated.c

@@ -107,6 +107,7 @@ grpc_channelz_get_server_sockets_type grpc_channelz_get_server_sockets_import;
 grpc_channelz_get_channel_type grpc_channelz_get_channel_import;
 grpc_channelz_get_subchannel_type grpc_channelz_get_subchannel_import;
 grpc_channelz_get_socket_type grpc_channelz_get_socket_import;
+grpc_authorization_policy_provider_arg_vtable_type grpc_authorization_policy_provider_arg_vtable_import;
 grpc_insecure_channel_create_from_fd_type grpc_insecure_channel_create_from_fd_import;
 grpc_server_add_insecure_channel_from_fd_type grpc_server_add_insecure_channel_from_fd_import;
 grpc_auth_property_iterator_next_type grpc_auth_property_iterator_next_import;
@@ -182,6 +183,8 @@ grpc_tls_server_authorization_check_config_create_type grpc_tls_server_authoriza
 grpc_tls_server_authorization_check_config_release_type grpc_tls_server_authorization_check_config_release_import;
 grpc_xds_credentials_create_type grpc_xds_credentials_create_import;
 grpc_xds_server_credentials_create_type grpc_xds_server_credentials_create_import;
+grpc_authorization_policy_provider_static_data_create_type grpc_authorization_policy_provider_static_data_create_import;
+grpc_authorization_policy_provider_release_type grpc_authorization_policy_provider_release_import;
 grpc_raw_byte_buffer_create_type grpc_raw_byte_buffer_create_import;
 grpc_raw_compressed_byte_buffer_create_type grpc_raw_compressed_byte_buffer_create_import;
 grpc_byte_buffer_copy_type grpc_byte_buffer_copy_import;
@@ -392,6 +395,7 @@ void grpc_rb_load_imports(HMODULE library) {
   grpc_channelz_get_channel_import = (grpc_channelz_get_channel_type) GetProcAddress(library, "grpc_channelz_get_channel");
   grpc_channelz_get_subchannel_import = (grpc_channelz_get_subchannel_type) GetProcAddress(library, "grpc_channelz_get_subchannel");
   grpc_channelz_get_socket_import = (grpc_channelz_get_socket_type) GetProcAddress(library, "grpc_channelz_get_socket");
+  grpc_authorization_policy_provider_arg_vtable_import = (grpc_authorization_policy_provider_arg_vtable_type) GetProcAddress(library, "grpc_authorization_policy_provider_arg_vtable");
   grpc_insecure_channel_create_from_fd_import = (grpc_insecure_channel_create_from_fd_type) GetProcAddress(library, "grpc_insecure_channel_create_from_fd");
   grpc_server_add_insecure_channel_from_fd_import = (grpc_server_add_insecure_channel_from_fd_type) GetProcAddress(library, "grpc_server_add_insecure_channel_from_fd");
   grpc_auth_property_iterator_next_import = (grpc_auth_property_iterator_next_type) GetProcAddress(library, "grpc_auth_property_iterator_next");
@@ -467,6 +471,8 @@ void grpc_rb_load_imports(HMODULE library) {
   grpc_tls_server_authorization_check_config_release_import = (grpc_tls_server_authorization_check_config_release_type) GetProcAddress(library, "grpc_tls_server_authorization_check_config_release");
   grpc_xds_credentials_create_import = (grpc_xds_credentials_create_type) GetProcAddress(library, "grpc_xds_credentials_create");
   grpc_xds_server_credentials_create_import = (grpc_xds_server_credentials_create_type) GetProcAddress(library, "grpc_xds_server_credentials_create");
+  grpc_authorization_policy_provider_static_data_create_import = (grpc_authorization_policy_provider_static_data_create_type) GetProcAddress(library, "grpc_authorization_policy_provider_static_data_create");
+  grpc_authorization_policy_provider_release_import = (grpc_authorization_policy_provider_release_type) GetProcAddress(library, "grpc_authorization_policy_provider_release");
   grpc_raw_byte_buffer_create_import = (grpc_raw_byte_buffer_create_type) GetProcAddress(library, "grpc_raw_byte_buffer_create");
   grpc_raw_compressed_byte_buffer_create_import = (grpc_raw_compressed_byte_buffer_create_type) GetProcAddress(library, "grpc_raw_compressed_byte_buffer_create");
   grpc_byte_buffer_copy_import = (grpc_byte_buffer_copy_type) GetProcAddress(library, "grpc_byte_buffer_copy");

data/src/ruby/ext/grpc/rb_grpc_imports.generated.h

@@ -110,7 +110,7 @@ extern grpc_completion_queue_create_for_next_type grpc_completion_queue_create_f
 typedef grpc_completion_queue*(*grpc_completion_queue_create_for_pluck_type)(void* reserved);
 extern grpc_completion_queue_create_for_pluck_type grpc_completion_queue_create_for_pluck_import;
 #define grpc_completion_queue_create_for_pluck grpc_completion_queue_create_for_pluck_import
-typedef grpc_completion_queue*(*grpc_completion_queue_create_for_callback_type)(grpc_experimental_completion_queue_functor* shutdown_callback, void* reserved);
+typedef grpc_completion_queue*(*grpc_completion_queue_create_for_callback_type)(grpc_completion_queue_functor* shutdown_callback, void* reserved);
 extern grpc_completion_queue_create_for_callback_type grpc_completion_queue_create_for_callback_import;
 #define grpc_completion_queue_create_for_callback grpc_completion_queue_create_for_callback_import
 typedef grpc_completion_queue*(*grpc_completion_queue_create_type)(const grpc_completion_queue_factory* factory, const grpc_completion_queue_attributes* attributes, void* reserved);
@@ -296,6 +296,9 @@ extern grpc_channelz_get_subchannel_type grpc_channelz_get_subchannel_import;
 typedef char*(*grpc_channelz_get_socket_type)(intptr_t socket_id);
 extern grpc_channelz_get_socket_type grpc_channelz_get_socket_import;
 #define grpc_channelz_get_socket grpc_channelz_get_socket_import
+typedef const grpc_arg_pointer_vtable*(*grpc_authorization_policy_provider_arg_vtable_type)(void);
+extern grpc_authorization_policy_provider_arg_vtable_type grpc_authorization_policy_provider_arg_vtable_import;
+#define grpc_authorization_policy_provider_arg_vtable grpc_authorization_policy_provider_arg_vtable_import
 typedef grpc_channel*(*grpc_insecure_channel_create_from_fd_type)(const char* target, int fd, const grpc_channel_args* args);
 extern grpc_insecure_channel_create_from_fd_type grpc_insecure_channel_create_from_fd_import;
 #define grpc_insecure_channel_create_from_fd grpc_insecure_channel_create_from_fd_import
@@ -521,6 +524,12 @@ extern grpc_xds_credentials_create_type grpc_xds_credentials_create_import;
 typedef grpc_server_credentials*(*grpc_xds_server_credentials_create_type)(grpc_server_credentials* fallback_credentials);
 extern grpc_xds_server_credentials_create_type grpc_xds_server_credentials_create_import;
 #define grpc_xds_server_credentials_create grpc_xds_server_credentials_create_import
+typedef grpc_authorization_policy_provider*(*grpc_authorization_policy_provider_static_data_create_type)(const char* authz_policy, grpc_status_code* code, const char** error_details);
+extern grpc_authorization_policy_provider_static_data_create_type grpc_authorization_policy_provider_static_data_create_import;
+#define grpc_authorization_policy_provider_static_data_create grpc_authorization_policy_provider_static_data_create_import
+typedef void(*grpc_authorization_policy_provider_release_type)(grpc_authorization_policy_provider* provider);
+extern grpc_authorization_policy_provider_release_type grpc_authorization_policy_provider_release_import;
+#define grpc_authorization_policy_provider_release grpc_authorization_policy_provider_release_import
 typedef grpc_byte_buffer*(*grpc_raw_byte_buffer_create_type)(grpc_slice* slices, size_t nslices);
 extern grpc_raw_byte_buffer_create_type grpc_raw_byte_buffer_create_import;
 #define grpc_raw_byte_buffer_create grpc_raw_byte_buffer_create_import

data/src/ruby/lib/grpc/version.rb

@@ -14,5 +14,5 @@
 
 # GRPC contains the General RPC module.
 module GRPC
-  VERSION = '1.38.0'
+  VERSION = '1.40.0'
 end

data/third_party/boringssl-with-bazel/err_data.c

@@ -193,47 +193,47 @@ const uint32_t kOpenSSLReasonValues[] = {
     0x283480b9,
     0x283500f7,
     0x28358c79,
-    0x2c3231de,
+    0x2c323227,
     0x2c329313,
-    0x2c3331ec,
-    0x2c33b1fe,
-    0x2c343212,
-    0x2c34b224,
-    0x2c35323f,
-    0x2c35b251,
-    0x2c363281,
+    0x2c333235,
+    0x2c33b247,
+    0x2c34325b,
+    0x2c34b26d,
+    0x2c353288,
+    0x2c35b29a,
+    0x2c3632ca,
     0x2c36833a,
-    0x2c37328e,
-    0x2c37b2ba,
-    0x2c3832df,
-    0x2c38b2f6,
-    0x2c393314,
-    0x2c39b324,
-    0x2c3a3336,
-    0x2c3ab34a,
-    0x2c3b335b,
-    0x2c3bb37a,
+    0x2c3732d7,
+    0x2c37b303,
+    0x2c383328,
+    0x2c38b33f,
+    0x2c39335d,
+    0x2c39b36d,
+    0x2c3a337f,
+    0x2c3ab393,
+    0x2c3b33a4,
+    0x2c3bb3c3,
     0x2c3c1325,
     0x2c3c933b,
-    0x2c3d338e,
+    0x2c3d33d7,
     0x2c3d9354,
-    0x2c3e33ab,
-    0x2c3eb3b9,
-    0x2c3f33d1,
-    0x2c3fb3e9,
-    0x2c403413,
+    0x2c3e33f4,
+    0x2c3eb402,
+    0x2c3f341a,
+    0x2c3fb432,
+    0x2c40345c,
     0x2c409226,
-    0x2c413424,
-    0x2c41b437,
+    0x2c41346d,
+    0x2c41b480,
     0x2c4211ec,
-    0x2c42b448,
+    0x2c42b491,
     0x2c43072f,
-    0x2c43b36c,
-    0x2c4432cd,
-    0x2c44b3f6,
-    0x2c453264,
-    0x2c45b2a0,
-    0x2c463304,
+    0x2c43b3b5,
+    0x2c443316,
+    0x2c44b43f,
+    0x2c4532ad,
+    0x2c45b2e9,
+    0x2c46334d,
     0x30320000,
     0x30328015,
     0x3033001f,
@@ -428,196 +428,199 @@ const uint32_t kOpenSSLReasonValues[] = {
     0x404e2022,
     0x404ea02f,
     0x404f20ac,
-    0x404fa0f2,
-    0x40502149,
-    0x4050a15d,
-    0x40512190,
-    0x405221a0,
-    0x4052a1c4,
-    0x405321dc,
-    0x4053a1ef,
-    0x40542204,
-    0x4054a227,
-    0x40552252,
-    0x4055a28f,
-    0x405622b4,
-    0x4056a2cd,
-    0x405722e5,
-    0x4057a2f8,
-    0x4058230d,
-    0x4058a334,
-    0x40592363,
-    0x4059a390,
-    0x405a23a4,
-    0x405aa3b4,
-    0x405b23cc,
-    0x405ba3dd,
-    0x405c23f0,
-    0x405ca42f,
-    0x405d243c,
-    0x405da461,
-    0x405e249f,
+    0x404fa122,
+    0x40502179,
+    0x4050a18d,
+    0x405121c0,
+    0x405221d0,
+    0x4052a1f4,
+    0x4053220c,
+    0x4053a21f,
+    0x40542234,
+    0x4054a257,
+    0x40552282,
+    0x4055a2bf,
+    0x405622e4,
+    0x4056a2fd,
+    0x40572315,
+    0x4057a328,
+    0x4058233d,
+    0x4058a364,
+    0x40592393,
+    0x4059a3c0,
+    0x405a23d4,
+    0x405aa3e4,
+    0x405b23fc,
+    0x405ba40d,
+    0x405c2420,
+    0x405ca45f,
+    0x405d246c,
+    0x405da491,
+    0x405e24cf,
     0x405e8ac0,
-    0x405f24c0,
-    0x405fa4cd,
-    0x406024db,
-    0x4060a4fd,
-    0x4061255e,
-    0x4061a596,
-    0x406225ad,
-    0x4062a5be,
-    0x4063260b,
-    0x4063a620,
-    0x40642637,
-    0x4064a663,
-    0x4065267e,
-    0x4065a695,
-    0x406626ad,
-    0x4066a6d7,
-    0x40672702,
-    0x4067a747,
-    0x4068278f,
-    0x4068a7b0,
-    0x406927e2,
-    0x4069a810,
-    0x406a2831,
-    0x406aa851,
-    0x406b29d9,
-    0x406ba9fc,
-    0x406c2a12,
-    0x406cad03,
-    0x406d2d32,
-    0x406dad5a,
-    0x406e2d88,
-    0x406eadd5,
-    0x406f2e2e,
-    0x406fae66,
-    0x40702e79,
-    0x4070ae96,
+    0x405f24f0,
+    0x405fa4fd,
+    0x4060250b,
+    0x4060a52d,
+    0x4061258e,
+    0x4061a5c6,
+    0x406225dd,
+    0x4062a5ee,
+    0x4063263b,
+    0x4063a650,
+    0x40642667,
+    0x4064a693,
+    0x406526ae,
+    0x4065a6c5,
+    0x406626dd,
+    0x4066a707,
+    0x40672732,
+    0x4067a777,
+    0x406827bf,
+    0x4068a7e0,
+    0x40692812,
+    0x4069a840,
+    0x406a2861,
+    0x406aa881,
+    0x406b2a09,
+    0x406baa2c,
+    0x406c2a42,
+    0x406cad4c,
+    0x406d2d7b,
+    0x406dada3,
+    0x406e2dd1,
+    0x406eae1e,
+    0x406f2e77,
+    0x406faeaf,
+    0x40702ec2,
+    0x4070aedf,
     0x4071080f,
-    0x4071aea8,
-    0x40722ebb,
-    0x4072aef1,
-    0x40732f09,
+    0x4071aef1,
+    0x40722f04,
+    0x4072af3a,
+    0x40732f52,
     0x40739525,
-    0x40742f1d,
-    0x4074af37,
-    0x40752f48,
-    0x4075af5c,
-    0x40762f6a,
+    0x40742f66,
+    0x4074af80,
+    0x40752f91,
+    0x4075afa5,
+    0x40762fb3,
     0x407692e9,
-    0x40772f8f,
-    0x4077afcf,
-    0x40782fea,
-    0x4078b023,
-    0x4079303a,
-    0x4079b050,
-    0x407a307c,
-    0x407ab08f,
-    0x407b30a4,
-    0x407bb0b6,
-    0x407c30e7,
-    0x407cb0f0,
-    0x407d27cb,
-    0x407da102,
-    0x407e2fff,
-    0x407ea344,
+    0x40772fd8,
+    0x4077b018,
+    0x40783033,
+    0x4078b06c,
+    0x40793083,
+    0x4079b099,
+    0x407a30c5,
+    0x407ab0d8,
+    0x407b30ed,
+    0x407bb0ff,
+    0x407c3130,
+    0x407cb139,
+    0x407d27fb,
+    0x407da132,
+    0x407e3048,
+    0x407ea374,
     0x407f1db0,
     0x407f9f76,
     0x408020bc,
     0x40809dd8,
-    0x408121b2,
+    0x408121e2,
     0x4081a060,
-    0x40822d73,
+    0x40822dbc,
     0x40829b2b,
-    0x4083231f,
-    0x4083a648,
+    0x4083234f,
+    0x4083a678,
     0x40841dec,
-    0x4084a37c,
-    0x40852401,
-    0x4085a525,
-    0x40862481,
-    0x4086a11c,
-    0x40872db9,
-    0x4087a573,
+    0x4084a3ac,
+    0x40852431,
+    0x4085a555,
+    0x408624b1,
+    0x4086a14c,
+    0x40872e02,
+    0x4087a5a3,
     0x40881b69,
-    0x4088a75a,
+    0x4088a78a,
     0x40891bb8,
     0x40899b45,
-    0x408a2a4a,
+    0x408a2a7a,
     0x408a993d,
-    0x408b30cb,
-    0x408bae43,
-    0x408c2411,
+    0x408b3114,
+    0x408bae8c,
+    0x408c2441,
     0x408c9975,
     0x408d1ec7,
     0x408d9e1e,
     0x408e1ff7,
-    0x408ea26f,
-    0x408f276e,
-    0x408fa541,
-    0x40902723,
-    0x4090a453,
-    0x40912a32,
+    0x408ea29f,
+    0x408f279e,
+    0x408fa571,
+    0x40902753,
+    0x4090a483,
+    0x40912a62,
     0x4091999b,
     0x40921c05,
-    0x4092adf4,
-    0x40932ed4,
-    0x4093a12d,
+    0x4092ae3d,
+    0x40932f1d,
+    0x4093a15d,
     0x40941e00,
-    0x4094aa63,
-    0x409525cf,
-    0x4095b05c,
-    0x40962da0,
+    0x4094aa93,
+    0x409525ff,
+    0x4095b0a5,
+    0x40962de9,
     0x4096a0d5,
-    0x40972178,
+    0x409721a8,
     0x4097a046,
     0x40981c65,
-    0x4098a5e3,
-    0x40992e10,
-    0x4099a29c,
-    0x409a2235,
+    0x4098a613,
+    0x40992e59,
+    0x4099a2cc,
+    0x409a2265,
     0x409a9959,
     0x409b1e4d,
     0x409b9e78,
-    0x409c2fb1,
+    0x409c2ffa,
     0x409c9ea0,
     0x409d2091,
     0x409da076,
     0x409e1cf6,
-    0x41f42904,
-    0x41f92996,
-    0x41fe2889,
-    0x41feab3f,
-    0x41ff2c54,
-    0x4203291d,
-    0x4208293f,
-    0x4208a97b,
-    0x4209286d,
-    0x4209a9b5,
-    0x420a28c4,
-    0x420aa8a4,
-    0x420b28e4,
-    0x420ba95d,
-    0x420c2c70,
-    0x420caa73,
-    0x420d2b26,
-    0x420dab5d,
-    0x42122b77,
-    0x42172c37,
-    0x4217abb9,
-    0x421c2bdb,
-    0x421f2b96,
-    0x42212ce8,
-    0x42262c1a,
-    0x422b2cc6,
-    0x422bab01,
-    0x422c2ca8,
-    0x422caab4,
-    0x422d2a8d,
-    0x422dac87,
-    0x422e2ae0,
-    0x42302bf6,
+    0x409ea10a,
+    0x409f20f2,
+    0x41f42934,
+    0x41f929c6,
+    0x41fe28b9,
+    0x41feab6f,
+    0x41ff2c9d,
+    0x4203294d,
+    0x4208296f,
+    0x4208a9ab,
+    0x4209289d,
+    0x4209a9e5,
+    0x420a28f4,
+    0x420aa8d4,
+    0x420b2914,
+    0x420ba98d,
+    0x420c2cb9,
+    0x420caaa3,
+    0x420d2b56,
+    0x420dab8d,
+    0x42122bc0,
+    0x42172c80,
+    0x4217ac02,
+    0x421c2c24,
+    0x421f2bdf,
+    0x42212d31,
+    0x42262c63,
+    0x422b2d0f,
+    0x422bab31,
+    0x422c2cf1,
+    0x422caae4,
+    0x422d2abd,
+    0x422dacd0,
+    0x422e2b10,
+    0x42302c3f,
+    0x4230aba7,
     0x4432073a,
     0x44328749,
     0x44330755,
@@ -672,69 +675,69 @@ const uint32_t kOpenSSLReasonValues[] = {
     0x4c411582,
     0x4c419405,
     0x4c42156e,
-    0x5032345a,
-    0x5032b469,
-    0x50333474,
-    0x5033b484,
-    0x5034349d,
-    0x5034b4b7,
-    0x503534c5,
-    0x5035b4db,
-    0x503634ed,
-    0x5036b503,
-    0x5037351c,
-    0x5037b52f,
-    0x50383547,
-    0x5038b558,
-    0x5039356d,
-    0x5039b581,
-    0x503a35a1,
-    0x503ab5b7,
-    0x503b35cf,
-    0x503bb5e1,
-    0x503c35fd,
-    0x503cb614,
-    0x503d362d,
-    0x503db643,
-    0x503e3650,
-    0x503eb666,
-    0x503f3678,
+    0x503234a3,
+    0x5032b4b2,
+    0x503334bd,
+    0x5033b4cd,
+    0x503434e6,
+    0x5034b500,
+    0x5035350e,
+    0x5035b524,
+    0x50363536,
+    0x5036b54c,
+    0x50373565,
+    0x5037b578,
+    0x50383590,
+    0x5038b5a1,
+    0x503935b6,
+    0x5039b5ca,
+    0x503a35ea,
+    0x503ab600,
+    0x503b3618,
+    0x503bb62a,
+    0x503c3646,
+    0x503cb65d,
+    0x503d3676,
+    0x503db68c,
+    0x503e3699,
+    0x503eb6af,
+    0x503f36c1,
     0x503f8388,
-    0x5040368b,
-    0x5040b69b,
-    0x504136b5,
-    0x5041b6c4,
-    0x504236de,
-    0x5042b6fb,
-    0x5043370b,
-    0x5043b71b,
-    0x5044372a,
+    0x504036d4,
+    0x5040b6e4,
+    0x504136fe,
+    0x5041b70d,
+    0x50423727,
+    0x5042b744,
+    0x50433754,
+    0x5043b764,
+    0x50443773,
     0x5044843e,
-    0x5045373e,
-    0x5045b75c,
-    0x5046376f,
-    0x5046b785,
-    0x50473797,
-    0x5047b7ac,
-    0x504837d2,
-    0x5048b7e0,
-    0x504937f3,
-    0x5049b808,
-    0x504a381e,
-    0x504ab82e,
-    0x504b384e,
-    0x504bb861,
-    0x504c3884,
-    0x504cb8b2,
-    0x504d38c4,
-    0x504db8e1,
-    0x504e38fc,
-    0x504eb918,
-    0x504f392a,
-    0x504fb941,
-    0x50503950,
+    0x50453787,
+    0x5045b7a5,
+    0x504637b8,
+    0x5046b7ce,
+    0x504737e0,
+    0x5047b7f5,
+    0x5048381b,
+    0x5048b829,
+    0x5049383c,
+    0x5049b851,
+    0x504a3867,
+    0x504ab877,
+    0x504b3897,
+    0x504bb8aa,
+    0x504c38cd,
+    0x504cb8fb,
+    0x504d390d,
+    0x504db92a,
+    0x504e3945,
+    0x504eb961,
+    0x504f3973,
+    0x504fb98a,
+    0x50503999,
     0x505086fe,
-    0x50513963,
+    0x505139ac,
     0x58320f72,
     0x68320f34,
     0x68328c8c,
@@ -778,19 +781,19 @@ const uint32_t kOpenSSLReasonValues[] = {
     0x7c321202,
     0x80321418,
     0x80328090,
-    0x803331ad,
+    0x803331f6,
     0x803380b9,
-    0x803431bc,
-    0x8034b124,
-    0x80353142,
-    0x8035b1d0,
-    0x80363184,
-    0x8036b133,
-    0x80373176,
-    0x8037b111,
-    0x80383197,
-    0x8038b153,
-    0x80393168,
+    0x80343205,
+    0x8034b16d,
+    0x8035318b,
+    0x8035b219,
+    0x803631cd,
+    0x8036b17c,
+    0x803731bf,
+    0x8037b15a,
+    0x803831e0,
+    0x8038b19c,
+    0x803931b1,
 };
 
 const size_t kOpenSSLReasonValuesLen = sizeof(kOpenSSLReasonValues) / sizeof(kOpenSSLReasonValues[0]);
@@ -1208,6 +1211,8 @@ const char kOpenSSLReasonStringData[] =
     "INVALID_COMMAND\0"
     "INVALID_COMPRESSION_LIST\0"
     "INVALID_DELEGATED_CREDENTIAL\0"
+    "INVALID_ECH_CONFIG_LIST\0"
+    "INVALID_ECH_PUBLIC_NAME\0"
     "INVALID_MESSAGE\0"
     "INVALID_OUTER_RECORD_TYPE\0"
     "INVALID_SCT_LIST\0"
@@ -1312,6 +1317,7 @@ const char kOpenSSLReasonStringData[] =
     "TLSV1_ALERT_DECODE_ERROR\0"
     "TLSV1_ALERT_DECRYPTION_FAILED\0"
     "TLSV1_ALERT_DECRYPT_ERROR\0"
+    "TLSV1_ALERT_ECH_REQUIRED\0"
     "TLSV1_ALERT_EXPORT_RESTRICTION\0"
     "TLSV1_ALERT_INAPPROPRIATE_FALLBACK\0"
     "TLSV1_ALERT_INSUFFICIENT_SECURITY\0"