grpc 1.45.0 → 1.46.2

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

@@ -60,20 +60,6 @@ grpc_error_handle grpc_call_create(grpc_call_create_args* args,
 
 void grpc_call_set_completion_queue(grpc_call* call, grpc_completion_queue* cq);
 
-#ifndef NDEBUG
-void grpc_call_internal_ref(grpc_call* call, const char* reason);
-void grpc_call_internal_unref(grpc_call* call, const char* reason);
-#define GRPC_CALL_INTERNAL_REF(call, reason) \
-  grpc_call_internal_ref(call, reason)
-#define GRPC_CALL_INTERNAL_UNREF(call, reason) \
-  grpc_call_internal_unref(call, reason)
-#else
-void grpc_call_internal_ref(grpc_call* call);
-void grpc_call_internal_unref(grpc_call* call);
-#define GRPC_CALL_INTERNAL_REF(call, reason) grpc_call_internal_ref(call)
-#define GRPC_CALL_INTERNAL_UNREF(call, reason) grpc_call_internal_unref(call)
-#endif
-
 grpc_core::Arena* grpc_call_get_arena(grpc_call* call);
 
 grpc_call_stack* grpc_call_get_call_stack(grpc_call* call);

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

@@ -31,6 +31,7 @@
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_stack_builder_impl.h"
 #include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/channel/channelz_registry.h"
@@ -241,8 +242,8 @@ grpc_channel* grpc_channel_create_internal(
   // grpc_shutdown() when the channel is actually destroyed, thus
   // ensuring that shutdown is deferred until that point.
   grpc_init();
-  grpc_core::ChannelStackBuilder builder(
-      grpc_channel_stack_type_string(channel_stack_type));
+  grpc_core::ChannelStackBuilderImpl builder(
+      grpc_channel_stack_type_string(channel_stack_type), channel_stack_type);
   const grpc_core::UniquePtr<char> default_authority =
       get_default_authority(input_args);
   grpc_channel_args* args =
@@ -258,7 +259,7 @@ grpc_channel* grpc_channel_create_internal(
       optional_transport);
   grpc_channel_args_destroy(args);
   if (!grpc_core::CoreConfiguration::Get().channel_init().CreateStack(
-          &builder, channel_stack_type)) {
+          &builder)) {
     grpc_shutdown();  // Since we won't call destroy_channel().
     return nullptr;
   }

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

@@ -45,9 +45,8 @@ ChannelInit ChannelInit::Builder::Build() {
   return result;
 }
 
-bool ChannelInit::CreateStack(ChannelStackBuilder* builder,
-                              grpc_channel_stack_type type) const {
-  for (const auto& stage : slots_[type]) {
+bool ChannelInit::CreateStack(ChannelStackBuilder* builder) const {
+  for (const auto& stage : slots_[builder->channel_stack_type()]) {
     if (!stage(builder)) return false;
   }
   return true;

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

@@ -24,7 +24,7 @@
 #include <functional>
 #include <vector>
 
-#include "src/core/lib/surface/channel_stack_type.h"
+#include "src/core/lib/channel/channel_stack_builder.h"
 
 #define GRPC_CHANNEL_INIT_BUILTIN_PRIORITY 10000
 
@@ -35,8 +35,6 @@
 
 namespace grpc_core {
 
-class ChannelStackBuilder;
-
 class ChannelInit {
  public:
   /// One stage of mutation: call functions against \a builder to influence the
@@ -72,10 +70,8 @@ class ChannelInit {
   };
 
   /// Construct a channel stack of some sort: see channel_stack.h for details
-  /// \a type is the type of channel stack to create
   /// \a builder is the channel stack builder to build into.
-  bool CreateStack(ChannelStackBuilder* builder,
-                   grpc_channel_stack_type type) const;
+  bool CreateStack(ChannelStackBuilder* builder) const;
 
  private:
   std::vector<Stage> slots_[GRPC_NUM_CHANNEL_STACK_TYPES];

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

@@ -86,7 +86,7 @@ static bool maybe_prepend_client_auth_filter(
   if (args) {
     for (size_t i = 0; i < args->num_args; i++) {
       if (0 == strcmp(GRPC_ARG_SECURITY_CONNECTOR, args->args[i].key)) {
-        builder->PrependFilter(&grpc_client_auth_filter, nullptr);
+        builder->PrependFilter(&grpc_core::ClientAuthFilter::kFilter, nullptr);
         break;
       }
     }

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

@@ -479,7 +479,6 @@ class ChannelBroadcaster {
                   GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server shutdown"),
                   GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_OK)
             : GRPC_ERROR_NONE;
-    op->set_accept_stream = true;
     sc->slice = grpc_slice_from_copied_string("Server shutdown");
     op->disconnect_with_error = send_disconnect;
     elem =
@@ -685,7 +684,7 @@ Server::RegisteredMethod* Server::RegisterMethod(
       return nullptr;
     }
   }
-  if ((flags & ~GRPC_INITIAL_METADATA_USED_MASK) != 0) {
+  if (flags != 0) {
     gpr_log(GPR_ERROR, "grpc_server_register_method invalid flags 0x%08x",
             flags);
     return nullptr;
@@ -1062,7 +1061,7 @@ void Server::ChannelData::InitTransport(RefCountedPtr<Server> server,
 }
 
 Server::ChannelRegisteredMethod* Server::ChannelData::GetRegisteredMethod(
-    const grpc_slice& host, const grpc_slice& path, bool is_idempotent) {
+    const grpc_slice& host, const grpc_slice& path) {
   if (registered_methods_ == nullptr) return nullptr;
   /* TODO(ctiller): unify these two searches */
   /* check for an exact match with host */
@@ -1075,10 +1074,6 @@ Server::ChannelRegisteredMethod* Server::ChannelData::GetRegisteredMethod(
     if (!rm->has_host) continue;
     if (rm->host != host) continue;
     if (rm->method != path) continue;
-    if ((rm->flags & GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST) &&
-        !is_idempotent) {
-      continue;
-    }
     return rm;
   }
   /* check for a wildcard method definition (no host set) */
@@ -1089,10 +1084,6 @@ Server::ChannelRegisteredMethod* Server::ChannelData::GetRegisteredMethod(
     if (rm->server_registered_method == nullptr) break;
     if (rm->has_host) continue;
     if (rm->method != path) continue;
-    if ((rm->flags & GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST) &&
-        !is_idempotent) {
-      continue;
-    }
     return rm;
   }
   return nullptr;
@@ -1299,9 +1290,7 @@ void Server::CallData::StartNewRpc(grpc_call_element* elem) {
       GRPC_SRM_PAYLOAD_NONE;
   if (path_.has_value() && host_.has_value()) {
     ChannelRegisteredMethod* rm =
-        chand->GetRegisteredMethod(host_->c_slice(), path_->c_slice(),
-                                   (recv_initial_metadata_flags_ &
-                                    GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST));
+        chand->GetRegisteredMethod(host_->c_slice(), path_->c_slice());
     if (rm != nullptr) {
       matcher_ = rm->server_registered_method->matcher.get();
       payload_handling = rm->server_registered_method->payload_handling;

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

@@ -200,8 +200,7 @@ class Server : public InternallyRefCounted<Server>,
     size_t cq_idx() const { return cq_idx_; }
 
     ChannelRegisteredMethod* GetRegisteredMethod(const grpc_slice& host,
-                                                 const grpc_slice& path,
-                                                 bool is_idempotent);
+                                                 const grpc_slice& path);
 
     // Filter vtable functions.
     static grpc_error_handle InitChannelElement(

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

@@ -23,6 +23,6 @@
 
 #include <grpc/grpc.h>
 
-const char* grpc_version_string(void) { return "23.0.0"; }
+const char* grpc_version_string(void) { return "24.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "gravity"; }
+const char* grpc_g_stands_for(void) { return "golazo"; }

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

@@ -51,6 +51,7 @@ SliceBufferByteStream::~SliceBufferByteStream() {}
 void SliceBufferByteStream::Orphan() {
   grpc_slice_buffer_destroy_internal(&backing_buffer_);
   GRPC_ERROR_UNREF(shutdown_error_);
+  shutdown_error_ = GRPC_ERROR_NONE;
   // Note: We do not actually delete the object here, since
   // SliceBufferByteStream is usually allocated as part of a larger
   // object and has an OrphanablePtr of itself passed down through the
@@ -107,6 +108,7 @@ ByteStreamCache::CachingByteStream::~CachingByteStream() {}
 
 void ByteStreamCache::CachingByteStream::Orphan() {
   GRPC_ERROR_UNREF(shutdown_error_);
+  shutdown_error_ = GRPC_ERROR_NONE;
   // Note: We do not actually delete the object here, since
   // CachingByteStream is usually allocated as part of a larger
   // object and has an OrphanablePtr of itself passed down through the

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

@@ -45,6 +45,8 @@
 #include "src/core/lib/transport/parsed_metadata.h"
 #include "src/core/lib/transport/timeout_encoding.h"
 
+struct grpc_call_final_info;
+
 namespace grpc_core {
 
 // grpc-timeout metadata trait.
@@ -224,7 +226,6 @@ struct HttpMethodMetadata {
   static constexpr bool kRepeatable = false;
   enum ValueType {
     kPost,
-    kPut,
     kGet,
     kInvalid,
   };
@@ -235,8 +236,6 @@ struct HttpMethodMetadata {
     auto value_string = value.as_string_view();
     if (value_string == "POST") {
       out = kPost;
-    } else if (value_string == "PUT") {
-      out = kPut;
     } else if (value_string == "GET") {
       out = kGet;
     } else {
@@ -251,8 +250,6 @@ struct HttpMethodMetadata {
     switch (x) {
       case kPost:
         return StaticSlice::FromStaticString("POST");
-      case kPut:
-        return StaticSlice::FromStaticString("PUT");
       case kGet:
         return StaticSlice::FromStaticString("GET");
       default:
@@ -263,8 +260,6 @@ struct HttpMethodMetadata {
     switch (content_type) {
       case kPost:
         return "POST";
-      case kPut:
-        return "PUT";
       case kGet:
         return "GET";
       default:
@@ -533,6 +528,14 @@ struct GrpcStreamNetworkState {
   }
 };
 
+// Annotation added by a server transport to note the peer making a request.
+struct PeerString {
+  static absl::string_view DebugKey() { return "PeerString"; }
+  static constexpr bool kRepeatable = false;
+  using ValueType = absl::string_view;
+  static std::string DisplayValue(ValueType x) { return std::string(x); }
+};
+
 // Annotation added by various systems to describe the reason for a failure.
 struct GrpcStatusContext {
   static absl::string_view DebugKey() { return "GrpcStatusContext"; }
@@ -1381,7 +1384,8 @@ using grpc_metadata_batch_base = grpc_core::MetadataMap<
     grpc_core::GrpcTagsBinMetadata, grpc_core::GrpcLbClientStatsMetadata,
     grpc_core::LbCostBinMetadata, grpc_core::LbTokenMetadata,
     // Non-encodable things
-    grpc_core::GrpcStreamNetworkState, grpc_core::GrpcStatusContext>;
+    grpc_core::GrpcStreamNetworkState, grpc_core::PeerString,
+    grpc_core::GrpcStatusContext>;
 
 struct grpc_metadata_batch : public grpc_metadata_batch_base {
   using grpc_metadata_batch_base::grpc_metadata_batch_base;

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

@@ -31,6 +31,7 @@
 #include "src/core/lib/iomgr/pollset.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/promise/arena_promise.h"
+#include "src/core/lib/promise/latch.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/transport/byte_stream.h"
@@ -43,6 +44,8 @@
 #define GRPC_PROTOCOL_VERSION_MIN_MAJOR 2
 #define GRPC_PROTOCOL_VERSION_MIN_MINOR 1
 
+#define GRPC_ARG_TRANSPORT "grpc.internal.transport"
+
 namespace grpc_core {
 // TODO(ctiller): eliminate once MetadataHandle is constructable directly.
 namespace promise_filter_detail {
@@ -97,23 +100,35 @@ class MetadataHandle {
   T* handle_ = nullptr;
 };
 
-// Trailing metadata type
+// Server metadata type
 // TODO(ctiller): This should be a bespoke instance of MetadataMap<>
-using TrailingMetadata = MetadataHandle<grpc_metadata_batch>;
+using ServerMetadata = grpc_metadata_batch;
+using ServerMetadataHandle = MetadataHandle<ServerMetadata>;
 
 // Ok/not-ok check for trailing metadata, so that it can be used as result types
 // for TrySeq.
-inline bool IsStatusOk(const TrailingMetadata& m) {
+inline bool IsStatusOk(const ServerMetadataHandle& m) {
   return m->get(GrpcStatusMetadata()).value_or(GRPC_STATUS_UNKNOWN) ==
          GRPC_STATUS_OK;
 }
 
 // Client initial metadata type
 // TODO(ctiller): This should be a bespoke instance of MetadataMap<>
-using ClientInitialMetadata = MetadataHandle<grpc_metadata_batch>;
+using ClientMetadata = grpc_metadata_batch;
+using ClientMetadataHandle = MetadataHandle<ClientMetadata>;
+
+// Server initial metadata type
+// TODO(ctiller): This should be a bespoke instance of MetadataMap<>
+using ServerMetadataHandle = MetadataHandle<grpc_metadata_batch>;
+
+struct CallArgs {
+  ClientMetadataHandle client_initial_metadata;
+  Latch<ServerMetadata*>* server_initial_metadata;
+};
 
 using NextPromiseFactory =
-    std::function<ArenaPromise<TrailingMetadata>(ClientInitialMetadata)>;
+    std::function<ArenaPromise<ServerMetadataHandle>(CallArgs)>;
+
 }  // namespace grpc_core
 
 /* forward declarations */

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

@@ -45,9 +45,8 @@ typedef struct grpc_transport_vtable {
        - allocation of memory for call data (sizeof_stream may be ignored)
      There is an on-going migration to move all filters to providing this, and
      then to drop perform_stream_op. */
-  grpc_core::ArenaPromise<grpc_core::TrailingMetadata> (*make_call_promise)(
-      grpc_transport* self, grpc_core::ClientInitialMetadata initial_metadata,
-      grpc_core::NextPromiseFactory next_promise_factory);
+  grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle> (*make_call_promise)(
+      grpc_transport* self, grpc_core::ClientMetadataHandle initial_metadata);
 
   /* implementation of grpc_transport_set_pollset */
   void (*set_pollset)(grpc_transport* self, grpc_stream* stream,
@@ -77,6 +76,8 @@ typedef struct grpc_transport_vtable {
 
 /* an instance of a grpc transport */
 struct grpc_transport {
+  struct RawPointerChannelArgTag {};
+  static absl::string_view ChannelArgName() { return GRPC_ARG_TRANSPORT; }
   /* pointer to a vtable defining operations on this transport */
   const grpc_transport_vtable* vtable;
 };

data/src/core/plugin_registry/grpc_plugin_registry.cc

@@ -80,12 +80,11 @@ extern void BuildClientChannelConfiguration(
 extern void SecurityRegisterHandshakerFactories(
     CoreConfiguration::Builder* builder);
 extern void RegisterClientAuthorityFilter(CoreConfiguration::Builder* builder);
-extern void RegisterClientIdleFilter(CoreConfiguration::Builder* builder);
+extern void RegisterChannelIdleFilters(CoreConfiguration::Builder* builder);
 extern void RegisterDeadlineFilter(CoreConfiguration::Builder* builder);
 extern void RegisterGrpcLbLoadReportingFilter(
     CoreConfiguration::Builder* builder);
 extern void RegisterHttpFilters(CoreConfiguration::Builder* builder);
-extern void RegisterMaxAgeFilter(CoreConfiguration::Builder* builder);
 extern void RegisterMessageSizeFilter(CoreConfiguration::Builder* builder);
 extern void RegisterSecurityFilters(CoreConfiguration::Builder* builder);
 extern void RegisterServiceConfigChannelArgFilter(
@@ -105,10 +104,9 @@ void BuildCoreConfiguration(CoreConfiguration::Builder* builder) {
   BuildClientChannelConfiguration(builder);
   SecurityRegisterHandshakerFactories(builder);
   RegisterClientAuthorityFilter(builder);
-  RegisterClientIdleFilter(builder);
+  RegisterChannelIdleFilters(builder);
   RegisterGrpcLbLoadReportingFilter(builder);
   RegisterHttpFilters(builder);
-  RegisterMaxAgeFilter(builder);
   RegisterDeadlineFilter(builder);
   RegisterMessageSizeFilter(builder);
   RegisterServiceConfigChannelArgFilter(builder);

data/src/core/tsi/alts/handshaker/alts_tsi_handshaker.cc

@@ -447,7 +447,7 @@ static tsi_result alts_tsi_handshaker_continue_handshaker_next(
       GPR_ASSERT(handshaker->client == nullptr);
       handshaker->client = client;
       if (handshaker->shutdown) {
-        gpr_log(GPR_ERROR, "TSI handshake shutdown");
+        gpr_log(GPR_INFO, "TSI handshake shutdown");
         return TSI_HANDSHAKE_SHUTDOWN;
       }
     }
@@ -532,7 +532,7 @@ static tsi_result handshaker_next(
   {
     grpc_core::MutexLock lock(&handshaker->mu);
     if (handshaker->shutdown) {
-      gpr_log(GPR_ERROR, "TSI handshake shutdown");
+      gpr_log(GPR_INFO, "TSI handshake shutdown");
       return TSI_HANDSHAKE_SHUTDOWN;
     }
   }

data/src/core/tsi/ssl_transport_security.cc

@@ -1441,8 +1441,7 @@ static tsi_result ssl_handshaker_result_create(
 static tsi_result ssl_handshaker_get_bytes_to_send_to_peer(
     tsi_ssl_handshaker* impl, unsigned char* bytes, size_t* bytes_size) {
   int bytes_read_from_ssl = 0;
-  if (bytes == nullptr || bytes_size == nullptr || *bytes_size == 0 ||
-      *bytes_size > INT_MAX) {
+  if (bytes == nullptr || bytes_size == nullptr || *bytes_size > INT_MAX) {
     return TSI_INVALID_ARGUMENT;
   }
   GPR_ASSERT(*bytes_size <= INT_MAX);
@@ -1469,22 +1468,7 @@ static tsi_result ssl_handshaker_get_result(tsi_ssl_handshaker* impl) {
   return impl->result;
 }
 
-static tsi_result ssl_handshaker_process_bytes_from_peer(
-    tsi_ssl_handshaker* impl, const unsigned char* bytes, size_t* bytes_size) {
-  int bytes_written_into_ssl_size = 0;
-  if (bytes == nullptr || bytes_size == nullptr || *bytes_size > INT_MAX) {
-    return TSI_INVALID_ARGUMENT;
-  }
-  GPR_ASSERT(*bytes_size <= INT_MAX);
-  bytes_written_into_ssl_size =
-      BIO_write(impl->network_io, bytes, static_cast<int>(*bytes_size));
-  if (bytes_written_into_ssl_size < 0) {
-    gpr_log(GPR_ERROR, "Could not write to memory BIO.");
-    impl->result = TSI_INTERNAL_ERROR;
-    return impl->result;
-  }
-  *bytes_size = static_cast<size_t>(bytes_written_into_ssl_size);
-
+static tsi_result ssl_handshaker_do_handshake(tsi_ssl_handshaker* impl) {
   if (ssl_handshaker_get_result(impl) != TSI_HANDSHAKE_IN_PROGRESS) {
     impl->result = TSI_OK;
     return impl->result;
@@ -1503,6 +1487,8 @@ static tsi_result ssl_handshaker_process_bytes_from_peer(
         }
       case SSL_ERROR_NONE:
         return TSI_OK;
+      case SSL_ERROR_WANT_WRITE:
+        return TSI_DRAIN_BUFFER;
       default: {
         char err_str[256];
         ERR_error_string_n(ERR_get_error(), err_str, sizeof(err_str));
@@ -1515,6 +1501,24 @@ static tsi_result ssl_handshaker_process_bytes_from_peer(
   }
 }
 
+static tsi_result ssl_handshaker_process_bytes_from_peer(
+    tsi_ssl_handshaker* impl, const unsigned char* bytes, size_t* bytes_size) {
+  int bytes_written_into_ssl_size = 0;
+  if (bytes == nullptr || bytes_size == nullptr || *bytes_size > INT_MAX) {
+    return TSI_INVALID_ARGUMENT;
+  }
+  GPR_ASSERT(*bytes_size <= INT_MAX);
+  bytes_written_into_ssl_size =
+      BIO_write(impl->network_io, bytes, static_cast<int>(*bytes_size));
+  if (bytes_written_into_ssl_size < 0) {
+    gpr_log(GPR_ERROR, "Could not write to memory BIO.");
+    impl->result = TSI_INTERNAL_ERROR;
+    return impl->result;
+  }
+  *bytes_size = static_cast<size_t>(bytes_written_into_ssl_size);
+  return ssl_handshaker_do_handshake(impl);
+}
+
 static void ssl_handshaker_destroy(tsi_handshaker* self) {
   tsi_ssl_handshaker* impl = reinterpret_cast<tsi_ssl_handshaker*>(self);
   SSL_free(impl->ssl);
@@ -1554,6 +1558,30 @@ static tsi_result ssl_bytes_remaining(tsi_ssl_handshaker* impl,
   return TSI_OK;
 }
 
+// Write handshake data received from SSL to an unbound output buffer.
+// By doing that, we drain SSL bio buffer used to hold handshake data.
+// This API needs to be repeatedly called until all handshake data are
+// received from SSL.
+static tsi_result ssl_handshaker_write_output_buffer(tsi_handshaker* self,
+                                                     size_t* bytes_written) {
+  tsi_ssl_handshaker* impl = reinterpret_cast<tsi_ssl_handshaker*>(self);
+  tsi_result status = TSI_OK;
+  int offset = *bytes_written;
+  do {
+    size_t to_send_size = impl->outgoing_bytes_buffer_size - offset;
+    status = ssl_handshaker_get_bytes_to_send_to_peer(
+        impl, impl->outgoing_bytes_buffer + offset, &to_send_size);
+    offset += to_send_size;
+    if (status == TSI_INCOMPLETE_DATA) {
+      impl->outgoing_bytes_buffer_size *= 2;
+      impl->outgoing_bytes_buffer = static_cast<unsigned char*>(gpr_realloc(
+          impl->outgoing_bytes_buffer, impl->outgoing_bytes_buffer_size));
+    }
+  } while (status == TSI_INCOMPLETE_DATA);
+  *bytes_written = offset;
+  return status;
+}
+
 static tsi_result ssl_handshaker_next(
     tsi_handshaker* self, const unsigned char* received_bytes,
     size_t received_bytes_size, const unsigned char** bytes_to_send,
@@ -1569,27 +1597,22 @@ static tsi_result ssl_handshaker_next(
   tsi_ssl_handshaker* impl = reinterpret_cast<tsi_ssl_handshaker*>(self);
   tsi_result status = TSI_OK;
   size_t bytes_consumed = received_bytes_size;
+  size_t bytes_written = 0;
   if (received_bytes_size > 0) {
     status = ssl_handshaker_process_bytes_from_peer(impl, received_bytes,
                                                     &bytes_consumed);
-    if (status != TSI_OK) return status;
+    while (status == TSI_DRAIN_BUFFER) {
+      status = ssl_handshaker_write_output_buffer(self, &bytes_written);
+      if (status != TSI_OK) return status;
+      status = ssl_handshaker_do_handshake(impl);
+    }
   }
+  if (status != TSI_OK) return status;
   /* Get bytes to send to the peer, if available.  */
-  size_t offset = 0;
-  do {
-    size_t to_send_size = impl->outgoing_bytes_buffer_size - offset;
-    status = ssl_handshaker_get_bytes_to_send_to_peer(
-        impl, impl->outgoing_bytes_buffer + offset, &to_send_size);
-    offset += to_send_size;
-    if (status == TSI_INCOMPLETE_DATA) {
-      impl->outgoing_bytes_buffer_size *= 2;
-      impl->outgoing_bytes_buffer = static_cast<unsigned char*>(gpr_realloc(
-          impl->outgoing_bytes_buffer, impl->outgoing_bytes_buffer_size));
-    }
-  } while (status == TSI_INCOMPLETE_DATA);
+  status = ssl_handshaker_write_output_buffer(self, &bytes_written);
   if (status != TSI_OK) return status;
   *bytes_to_send = impl->outgoing_bytes_buffer;
-  *bytes_to_send_size = offset;
+  *bytes_to_send_size = bytes_written;
   /* If handshake completes, create tsi_handshaker_result.  */
   if (ssl_handshaker_get_result(impl) == TSI_HANDSHAKE_IN_PROGRESS) {
     *handshaker_result = nullptr;
@@ -1646,6 +1669,8 @@ static void tsi_ssl_handshaker_resume_session(
 
 static tsi_result create_tsi_ssl_handshaker(SSL_CTX* ctx, int is_client,
                                             const char* server_name_indication,
+                                            size_t network_bio_buf_size,
+                                            size_t ssl_bio_buf_size,
                                             tsi_ssl_handshaker_factory* factory,
                                             tsi_handshaker** handshaker) {
   SSL* ssl = SSL_new(ctx);
@@ -1662,7 +1687,8 @@ static tsi_result create_tsi_ssl_handshaker(SSL_CTX* ctx, int is_client,
   }
   SSL_set_info_callback(ssl, ssl_info_callback);
 
-  if (!BIO_new_bio_pair(&network_io, 0, &ssl_io, 0)) {
+  if (!BIO_new_bio_pair(&network_io, network_bio_buf_size, &ssl_io,
+                        ssl_bio_buf_size)) {
     gpr_log(GPR_ERROR, "BIO_new_bio_pair failed.");
     SSL_free(ssl);
     return TSI_OUT_OF_RESOURCES;
@@ -1747,10 +1773,11 @@ static int select_protocol_list(const unsigned char** out,
 
 tsi_result tsi_ssl_client_handshaker_factory_create_handshaker(
     tsi_ssl_client_handshaker_factory* factory,
-    const char* server_name_indication, tsi_handshaker** handshaker) {
-  return create_tsi_ssl_handshaker(factory->ssl_context, 1,
-                                   server_name_indication, &factory->base,
-                                   handshaker);
+    const char* server_name_indication, size_t network_bio_buf_size,
+    size_t ssl_bio_buf_size, tsi_handshaker** handshaker) {
+  return create_tsi_ssl_handshaker(
+      factory->ssl_context, 1, server_name_indication, network_bio_buf_size,
+      ssl_bio_buf_size, &factory->base, handshaker);
 }
 
 void tsi_ssl_client_handshaker_factory_unref(
@@ -1784,11 +1811,13 @@ static int client_handshaker_factory_npn_callback(
 /* --- tsi_ssl_server_handshaker_factory methods implementation. --- */
 
 tsi_result tsi_ssl_server_handshaker_factory_create_handshaker(
-    tsi_ssl_server_handshaker_factory* factory, tsi_handshaker** handshaker) {
+    tsi_ssl_server_handshaker_factory* factory, size_t network_bio_buf_size,
+    size_t ssl_bio_buf_size, tsi_handshaker** handshaker) {
   if (factory->ssl_context_count == 0) return TSI_INVALID_ARGUMENT;
   /* Create the handshaker with the first context. We will switch if needed
      because of SNI in ssl_server_handshaker_factory_servername_callback.  */
   return create_tsi_ssl_handshaker(factory->ssl_contexts[0], 0, nullptr,
+                                   network_bio_buf_size, ssl_bio_buf_size,
                                    &factory->base, handshaker);
 }
 
@@ -1939,8 +1968,16 @@ static void ssl_keylogging_callback(const SSL* ssl, const char* info) {
   factory->key_logger->LogSessionKeys(ssl_context, info);
 }
 
+// This callback is invoked when the CRL has been verified and will soft-fail
+// errors in verification depending on certain error types.
 static int verify_cb(int ok, X509_STORE_CTX* ctx) {
   int cert_error = X509_STORE_CTX_get_error(ctx);
+  if (cert_error == X509_V_ERR_UNABLE_TO_GET_CRL) {
+    gpr_log(
+        GPR_INFO,
+        "Certificate verification failed to get CRL files. Ignoring error.");
+    return 1;
+  }
   if (cert_error != 0) {
     gpr_log(GPR_ERROR, "Certificate verify failed with code %d", cert_error);
   }

data/src/core/tsi/ssl_transport_security.h

@@ -209,13 +209,16 @@ tsi_result tsi_create_ssl_client_handshaker_factory_with_options(
   - server_name_indication indicates the name of the server the client is
     trying to connect to which will be relayed to the server using the SNI
     extension.
+  - network_bio_buf_size and ssl_bio_buf_size represent BIO pair buffers used in
+    SSL. The buffer size being 0 translates to 17KB in boringSSL.
   - handshaker is the address of the handshaker pointer to be created.
 
   - This method returns TSI_OK on success or TSI_INVALID_PARAMETER in the case
     where a parameter is invalid.  */
 tsi_result tsi_ssl_client_handshaker_factory_create_handshaker(
     tsi_ssl_client_handshaker_factory* factory,
-    const char* server_name_indication, tsi_handshaker** handshaker);
+    const char* server_name_indication, size_t network_bio_buf_size,
+    size_t ssl_bio_buf_size, tsi_handshaker** handshaker);
 
 /* Decrements reference count of the handshaker factory. Handshaker factory will
  * be destroyed once no references exist. */
@@ -347,12 +350,15 @@ tsi_result tsi_create_ssl_server_handshaker_factory_with_options(
 
 /* Creates a server handshaker.
   - factory is the factory from which the handshaker will be created.
+  - network_bio_buf_size and ssl_bio_buf_size represent BIO pair buffers used in
+    SSL. The buffer size being 0 translates to 17KB in boringSSL.
   - handshaker is the address of the handshaker pointer to be created.
 
   - This method returns TSI_OK on success or TSI_INVALID_PARAMETER in the case
     where a parameter is invalid.  */
 tsi_result tsi_ssl_server_handshaker_factory_create_handshaker(
-    tsi_ssl_server_handshaker_factory* factory, tsi_handshaker** handshaker);
+    tsi_ssl_server_handshaker_factory* factory, size_t network_bio_buf_size,
+    size_t ssl_bio_buf_size, tsi_handshaker** handshaker);
 
 /* Decrements reference count of the handshaker factory. Handshaker factory will
  * be destroyed once no references exist. */

data/src/core/tsi/transport_security_interface.h

@@ -45,6 +45,8 @@ typedef enum {
   TSI_ASYNC = 13,
   TSI_HANDSHAKE_SHUTDOWN = 14,
   TSI_CLOSE_NOTIFY = 15,  // Indicates that the connection should be closed.
+  TSI_DRAIN_BUFFER = 16,  // Indicates that the buffer used to store handshake
+                          // data should be drained.
 } tsi_result;
 
 typedef enum {

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

@@ -60,7 +60,7 @@ 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.45.0\"" '
+ENV['CPPFLAGS'] += ' -DGRPC_XDS_USER_AGENT_VERSION_SUFFIX="\"1.46.2\"" '
 
 output_dir = File.expand_path(RbConfig::CONFIG['topdir'])
 grpc_lib_dir = File.join(output_dir, 'libs', grpc_config)

data/src/ruby/lib/grpc/generic/active_call.rb

@@ -164,7 +164,13 @@ module GRPC
     end
 
     def receive_and_check_status
-      batch_result = @call.run_batch(RECV_STATUS_ON_CLIENT => nil)
+      ops = { RECV_STATUS_ON_CLIENT => nil }
+      ops[RECV_INITIAL_METADATA] = nil unless @metadata_received
+      batch_result = @call.run_batch(ops)
+      unless @metadata_received
+        @call.metadata = batch_result.metadata
+        @metadata_received = true
+      end
       set_input_stream_done
       attach_status_results_and_complete_call(batch_result)
     end