grpc 1.48.0 → 1.50.0

data/src/core/tsi/ssl_transport_security.cc

@@ -45,6 +45,7 @@
 #include <openssl/x509v3.h>
 
 #include "absl/strings/match.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/grpc_security.h>
@@ -1036,17 +1037,16 @@ void tsi_ssl_root_certs_store_destroy(tsi_ssl_root_certs_store* self) {
 
 tsi_ssl_session_cache* tsi_ssl_session_cache_create_lru(size_t capacity) {
   /* Pointer will be dereferenced by unref call. */
-  return reinterpret_cast<tsi_ssl_session_cache*>(
-      tsi::SslSessionLRUCache::Create(capacity).release());
+  return tsi::SslSessionLRUCache::Create(capacity).release()->c_ptr();
 }
 
 void tsi_ssl_session_cache_ref(tsi_ssl_session_cache* cache) {
   /* Pointer will be dereferenced by unref call. */
-  reinterpret_cast<tsi::SslSessionLRUCache*>(cache)->Ref().release();
+  tsi::SslSessionLRUCache::FromC(cache)->Ref().release();
 }
 
 void tsi_ssl_session_cache_unref(tsi_ssl_session_cache* cache) {
-  reinterpret_cast<tsi::SslSessionLRUCache*>(cache)->Unref();
+  tsi::SslSessionLRUCache::FromC(cache)->Unref();
 }
 
 /* --- tsi_frame_protector methods implementation. ---*/
@@ -1416,9 +1416,11 @@ static const tsi_handshaker_result_vtable handshaker_result_vtable = {
 
 static tsi_result ssl_handshaker_result_create(
     tsi_ssl_handshaker* handshaker, unsigned char* unused_bytes,
-    size_t unused_bytes_size, tsi_handshaker_result** handshaker_result) {
+    size_t unused_bytes_size, tsi_handshaker_result** handshaker_result,
+    std::string* error) {
   if (handshaker == nullptr || handshaker_result == nullptr ||
       (unused_bytes_size > 0 && unused_bytes == nullptr)) {
+    if (error != nullptr) *error = "invalid argument";
     return TSI_INVALID_ARGUMENT;
   }
   tsi_ssl_handshaker_result* result =
@@ -1439,9 +1441,11 @@ static tsi_result ssl_handshaker_result_create(
 /* --- tsi_handshaker methods implementation. ---*/
 
 static tsi_result ssl_handshaker_get_bytes_to_send_to_peer(
-    tsi_ssl_handshaker* impl, unsigned char* bytes, size_t* bytes_size) {
+    tsi_ssl_handshaker* impl, unsigned char* bytes, size_t* bytes_size,
+    std::string* error) {
   int bytes_read_from_ssl = 0;
   if (bytes == nullptr || bytes_size == nullptr || *bytes_size > INT_MAX) {
+    if (error != nullptr) *error = "invalid argument";
     return TSI_INVALID_ARGUMENT;
   }
   GPR_ASSERT(*bytes_size <= INT_MAX);
@@ -1450,6 +1454,7 @@ static tsi_result ssl_handshaker_get_bytes_to_send_to_peer(
   if (bytes_read_from_ssl < 0) {
     *bytes_size = 0;
     if (!BIO_should_retry(impl->network_io)) {
+      if (error != nullptr) *error = "error reading from BIO";
       impl->result = TSI_INTERNAL_ERROR;
       return impl->result;
     } else {
@@ -1468,7 +1473,8 @@ static tsi_result ssl_handshaker_get_result(tsi_ssl_handshaker* impl) {
   return impl->result;
 }
 
-static tsi_result ssl_handshaker_do_handshake(tsi_ssl_handshaker* impl) {
+static tsi_result ssl_handshaker_do_handshake(tsi_ssl_handshaker* impl,
+                                              std::string* error) {
   if (ssl_handshaker_get_result(impl) != TSI_HANDSHAKE_IN_PROGRESS) {
     impl->result = TSI_OK;
     return impl->result;
@@ -1494,6 +1500,9 @@ static tsi_result ssl_handshaker_do_handshake(tsi_ssl_handshaker* impl) {
         ERR_error_string_n(ERR_get_error(), err_str, sizeof(err_str));
         gpr_log(GPR_ERROR, "Handshake failed with fatal error %s: %s.",
                 ssl_error_string(ssl_result), err_str);
+        if (error != nullptr) {
+          *error = absl::StrCat(ssl_error_string(ssl_result), ": ", err_str);
+        }
         impl->result = TSI_PROTOCOL_FAILURE;
         return impl->result;
       }
@@ -1502,9 +1511,11 @@ static tsi_result ssl_handshaker_do_handshake(tsi_ssl_handshaker* impl) {
 }
 
 static tsi_result ssl_handshaker_process_bytes_from_peer(
-    tsi_ssl_handshaker* impl, const unsigned char* bytes, size_t* bytes_size) {
+    tsi_ssl_handshaker* impl, const unsigned char* bytes, size_t* bytes_size,
+    std::string* error) {
   int bytes_written_into_ssl_size = 0;
   if (bytes == nullptr || bytes_size == nullptr || *bytes_size > INT_MAX) {
+    if (error != nullptr) *error = "invalid argument";
     return TSI_INVALID_ARGUMENT;
   }
   GPR_ASSERT(*bytes_size <= INT_MAX);
@@ -1512,11 +1523,12 @@ static tsi_result ssl_handshaker_process_bytes_from_peer(
       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.");
+    if (error != nullptr) *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);
+  return ssl_handshaker_do_handshake(impl, error);
 }
 
 static void ssl_handshaker_destroy(tsi_handshaker* self) {
@@ -1532,9 +1544,11 @@ static void ssl_handshaker_destroy(tsi_handshaker* self) {
 // |bytes_remaining|.
 static tsi_result ssl_bytes_remaining(tsi_ssl_handshaker* impl,
                                       unsigned char** bytes_remaining,
-                                      size_t* bytes_remaining_size) {
+                                      size_t* bytes_remaining_size,
+                                      std::string* error) {
   if (impl == nullptr || bytes_remaining == nullptr ||
       bytes_remaining_size == nullptr) {
+    if (error != nullptr) *error = "invalid argument";
     return TSI_INVALID_ARGUMENT;
   }
   // Atempt to read all of the bytes in SSL's read BIO. These bytes should
@@ -1552,6 +1566,9 @@ static tsi_result ssl_bytes_remaining(tsi_ssl_handshaker* impl,
             "Failed to read the expected number of bytes from SSL object.");
     gpr_free(*bytes_remaining);
     *bytes_remaining = nullptr;
+    if (error != nullptr) {
+      *error = "Failed to read the expected number of bytes from SSL object.";
+    }
     return TSI_INTERNAL_ERROR;
   }
   *bytes_remaining_size = static_cast<size_t>(bytes_read);
@@ -1563,14 +1580,15 @@ static tsi_result ssl_bytes_remaining(tsi_ssl_handshaker* impl,
 // 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) {
+                                                     size_t* bytes_written,
+                                                     std::string* error) {
   tsi_ssl_handshaker* impl = reinterpret_cast<tsi_ssl_handshaker*>(self);
   tsi_result status = TSI_OK;
   size_t 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);
+        impl, impl->outgoing_bytes_buffer + offset, &to_send_size, error);
     offset += to_send_size;
     if (status == TSI_INCOMPLETE_DATA) {
       impl->outgoing_bytes_buffer_size *= 2;
@@ -1582,15 +1600,19 @@ static tsi_result ssl_handshaker_write_output_buffer(tsi_handshaker* self,
   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,
-    size_t* bytes_to_send_size, tsi_handshaker_result** handshaker_result,
-    tsi_handshaker_on_next_done_cb /*cb*/, void* /*user_data*/) {
+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,
+                                      size_t* bytes_to_send_size,
+                                      tsi_handshaker_result** handshaker_result,
+                                      tsi_handshaker_on_next_done_cb /*cb*/,
+                                      void* /*user_data*/, std::string* error) {
   /* Input sanity check.  */
   if ((received_bytes_size > 0 && received_bytes == nullptr) ||
       bytes_to_send == nullptr || bytes_to_send_size == nullptr ||
       handshaker_result == nullptr) {
+    if (error != nullptr) *error = "invalid argument";
     return TSI_INVALID_ARGUMENT;
   }
   /* If there are received bytes, process them first.  */
@@ -1600,16 +1622,16 @@ static tsi_result ssl_handshaker_next(
   size_t bytes_written = 0;
   if (received_bytes_size > 0) {
     status = ssl_handshaker_process_bytes_from_peer(impl, received_bytes,
-                                                    &bytes_consumed);
+                                                    &bytes_consumed, error);
     while (status == TSI_DRAIN_BUFFER) {
-      status = ssl_handshaker_write_output_buffer(self, &bytes_written);
+      status = ssl_handshaker_write_output_buffer(self, &bytes_written, error);
       if (status != TSI_OK) return status;
-      status = ssl_handshaker_do_handshake(impl);
+      status = ssl_handshaker_do_handshake(impl, error);
     }
   }
   if (status != TSI_OK) return status;
   /* Get bytes to send to the peer, if available.  */
-  status = ssl_handshaker_write_output_buffer(self, &bytes_written);
+  status = ssl_handshaker_write_output_buffer(self, &bytes_written, error);
   if (status != TSI_OK) return status;
   *bytes_to_send = impl->outgoing_bytes_buffer;
   *bytes_to_send_size = bytes_written;
@@ -1623,15 +1645,17 @@ static tsi_result ssl_handshaker_next(
     // peer that must be processed.
     unsigned char* unused_bytes = nullptr;
     size_t unused_bytes_size = 0;
-    status = ssl_bytes_remaining(impl, &unused_bytes, &unused_bytes_size);
+    status =
+        ssl_bytes_remaining(impl, &unused_bytes, &unused_bytes_size, error);
     if (status != TSI_OK) return status;
     if (unused_bytes_size > received_bytes_size) {
       gpr_log(GPR_ERROR, "More unused bytes than received bytes.");
       gpr_free(unused_bytes);
+      if (error != nullptr) *error = "More unused bytes than received bytes.";
       return TSI_INTERNAL_ERROR;
     }
     status = ssl_handshaker_result_create(impl, unused_bytes, unused_bytes_size,
-                                          handshaker_result);
+                                          handshaker_result, error);
     if (status == TSI_OK) {
       /* Indicates that the handshake has completed and that a handshaker_result
        * has been created. */

data/src/core/tsi/transport_security.cc

@@ -216,14 +216,26 @@ tsi_result tsi_handshaker_next(
     tsi_handshaker* self, const unsigned char* received_bytes,
     size_t received_bytes_size, const unsigned char** bytes_to_send,
     size_t* bytes_to_send_size, tsi_handshaker_result** handshaker_result,
-    tsi_handshaker_on_next_done_cb cb, void* user_data) {
-  if (self == nullptr || self->vtable == nullptr) return TSI_INVALID_ARGUMENT;
-  if (self->handshaker_result_created) return TSI_FAILED_PRECONDITION;
-  if (self->handshake_shutdown) return TSI_HANDSHAKE_SHUTDOWN;
-  if (self->vtable->next == nullptr) return TSI_UNIMPLEMENTED;
+    tsi_handshaker_on_next_done_cb cb, void* user_data, std::string* error) {
+  if (self == nullptr || self->vtable == nullptr) {
+    if (error != nullptr) *error = "invalid argument";
+    return TSI_INVALID_ARGUMENT;
+  }
+  if (self->handshaker_result_created) {
+    if (error != nullptr) *error = "handshaker already returned a result";
+    return TSI_FAILED_PRECONDITION;
+  }
+  if (self->handshake_shutdown) {
+    if (error != nullptr) *error = "handshaker shutdown";
+    return TSI_HANDSHAKE_SHUTDOWN;
+  }
+  if (self->vtable->next == nullptr) {
+    if (error != nullptr) *error = "TSI handshaker does not implement next()";
+    return TSI_UNIMPLEMENTED;
+  }
   return self->vtable->next(self, received_bytes, received_bytes_size,
                             bytes_to_send, bytes_to_send_size,
-                            handshaker_result, cb, user_data);
+                            handshaker_result, cb, user_data, error);
 }
 
 void tsi_handshaker_shutdown(tsi_handshaker* self) {

data/src/core/tsi/transport_security.h

@@ -78,7 +78,8 @@ struct tsi_handshaker_vtable {
                      const unsigned char** bytes_to_send,
                      size_t* bytes_to_send_size,
                      tsi_handshaker_result** handshaker_result,
-                     tsi_handshaker_on_next_done_cb cb, void* user_data);
+                     tsi_handshaker_on_next_done_cb cb, void* user_data,
+                     std::string* error);
   void (*shutdown)(tsi_handshaker* self);
 };
 struct tsi_handshaker {

data/src/core/tsi/transport_security_interface.h

@@ -24,6 +24,8 @@
 #include <stdint.h>
 #include <stdlib.h>
 
+#include <string>
+
 #include "src/core/lib/debug/trace.h"
 
 /* --- tsi result ---  */
@@ -472,6 +474,13 @@ typedef void (*tsi_handshaker_on_next_done_cb)(
    - cb is the callback function defined above. It can be NULL for synchronous
      TSI handshaker implementation.
    - user_data is the argument to callback function passed from the caller.
+   - error, if non-null, will be populated with a human-readable error
+     message whenever the result value is something other than TSI_OK,
+     TSI_ASYNC, or TSI_INCOMPLETE_DATA.  The object pointed to by this
+     argument is owned by the caller and must continue to exist until after the
+     handshake is finished.  Some TSI implementations cache this value,
+     so callers must pass the same value to all calls to tsi_handshaker_next()
+     for a given handshake.
    This method returns TSI_ASYNC if the TSI handshaker implementation is
    asynchronous, and in this case, the callback is guaranteed to run in another
    thread owned by TSI. It returns TSI_OK if the handshake completes or if
@@ -482,11 +491,14 @@ typedef void (*tsi_handshaker_on_next_done_cb)(
    The caller is responsible for destroying the handshaker_result. However,
    the caller should not free bytes_to_send, as the buffer is owned by the
    tsi_handshaker object.  */
-tsi_result tsi_handshaker_next(
-    tsi_handshaker* self, const unsigned char* received_bytes,
-    size_t received_bytes_size, const unsigned char** bytes_to_send,
-    size_t* bytes_to_send_size, tsi_handshaker_result** handshaker_result,
-    tsi_handshaker_on_next_done_cb cb, void* user_data);
+tsi_result tsi_handshaker_next(tsi_handshaker* self,
+                               const unsigned char* received_bytes,
+                               size_t received_bytes_size,
+                               const unsigned char** bytes_to_send,
+                               size_t* bytes_to_send_size,
+                               tsi_handshaker_result** handshaker_result,
+                               tsi_handshaker_on_next_done_cb cb,
+                               void* user_data, std::string* error = nullptr);
 
 /* This method shuts down a TSI handshake that is in progress.
  *

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

@@ -16,6 +16,7 @@ require 'etc'
 require 'mkmf'
 
 windows = RUBY_PLATFORM =~ /mingw|mswin/
+windows_ucrt = RUBY_PLATFORM =~ /(mingw|mswin).*ucrt/
 bsd = RUBY_PLATFORM =~ /bsd/
 darwin = RUBY_PLATFORM =~ /darwin/
 linux = RUBY_PLATFORM =~ /linux/
@@ -109,6 +110,7 @@ unless windows
   exit 1 unless $? == 0
 end
 
+$CFLAGS << ' -DGRPC_RUBY_WINDOWS_UCRT' if windows_ucrt
 $CFLAGS << ' -I' + File.join(grpc_root, 'include')
 
 ext_export_file = File.join(grpc_root, 'src', 'ruby', 'ext', 'grpc', 'ext-export')

data/src/ruby/ext/grpc/rb_loader.c

@@ -23,9 +23,13 @@
 
 int grpc_rb_load_core() {
 #if GPR_ARCH_64
-  TCHAR fname[] = _T("grpc_c.64.ruby");
+#if GRPC_RUBY_WINDOWS_UCRT
+  TCHAR fname[] = _T("grpc_c.64-ucrt.ruby");
 #else
-  TCHAR fname[] = _T("grpc_c.32.ruby");
+  TCHAR fname[] = _T("grpc_c.64-msvcrt.ruby");
+#endif
+#else
+  TCHAR fname[] = _T("grpc_c.32-msvcrt.ruby");
 #endif
   HMODULE module = GetModuleHandle(_T("grpc_c.so"));
   TCHAR path[2048 + 32] = _T("");

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

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

data/src/ruby/pb/src/proto/grpc/testing/messages_pb.rb

@@ -104,6 +104,9 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
     end
     add_message "grpc.testing.ClientConfigureResponse" do
     end
+    add_message "grpc.testing.MemorySize" do
+      optional :rss, :int64, 1
+    end
     add_enum "grpc.testing.PayloadType" do
       value :COMPRESSABLE, 0
     end
@@ -139,6 +142,7 @@ module Grpc
     ClientConfigureRequest::Metadata = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.ClientConfigureRequest.Metadata").msgclass
     ClientConfigureRequest::RpcType = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.ClientConfigureRequest.RpcType").enummodule
     ClientConfigureResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.ClientConfigureResponse").msgclass
+    MemorySize = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.MemorySize").msgclass
     PayloadType = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.PayloadType").enummodule
     GrpclbRouteType = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.GrpclbRouteType").enummodule
   end

data/src/ruby/spec/channel_spec.rb

@@ -154,14 +154,19 @@ describe GRPC::Core::Channel do
     end
 
     it 'raises an error if called on a closed channel' do
+      STDERR.puts "#{Time.now}: begin: raises an error if called on a closed channel"
       ch = GRPC::Core::Channel.new(fake_host, nil, :this_channel_is_insecure)
+      STDERR.puts "#{Time.now}: created channel"
       ch.close
+      STDERR.puts "#{Time.now}: closed channel"
 
       deadline = Time.now + 5
       blk = proc do
         ch.create_call(nil, nil, 'phony_method', nil, deadline)
+        STDERR.puts "#{Time.now}: created call"
       end
       expect(&blk).to raise_error(RuntimeError)
+      STDERR.puts "#{Time.now}: finished: raises an error if called on a closed channel"
     end
 
     it 'raises if grpc was initialized in another process' do

data/src/ruby/spec/generic/server_interceptors_spec.rb

@@ -17,7 +17,7 @@ describe 'Server Interceptors' do
   let(:interceptor) { TestServerInterceptor.new }
   let(:request) { EchoMsg.new }
   let(:trailing_metadata) { {} }
-  let(:service) { EchoService.new(trailing_metadata) }
+  let(:service) { EchoService.new(**trailing_metadata) }
   let(:interceptors) { [] }
 
   before(:each) do

data/src/ruby/spec/user_agent_spec.rb

@@ -49,7 +49,7 @@ describe 'user agent' do
   it 'client sends expected user agent' do
     stub = UserAgentEchoServiceStub.new("localhost:#{@port}",
                                         :this_channel_is_insecure,
-                                        {})
+                                        channel_args: {})
     response = stub.an_rpc(EchoMsg.new)
     expected_user_agent_prefix = "grpc-ruby/#{GRPC::VERSION}"
     expect(response.msg.start_with?(expected_user_agent_prefix)).to be true