grpc 1.42.0 → 1.51.0

data/src/core/ext/transport/chttp2/client/chttp2_connector.cc

@@ -20,32 +20,79 @@
 
 #include "src/core/ext/transport/chttp2/client/chttp2_connector.h"
 
-#include <string.h>
+#include <stdint.h>
+
+#include <string>
+#include <utility>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/str_format.h"
 
 #include <grpc/grpc.h>
+#include <grpc/grpc_posix.h>
+#include <grpc/grpc_security.h>
+#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/slice_buffer.h>
+#include <grpc/status.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/string_util.h>
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
 
+#include "src/core/ext/filters/client_channel/client_channel.h"
+#include "src/core/ext/filters/client_channel/client_channel_factory.h"
 #include "src/core/ext/filters/client_channel/connector.h"
+#include "src/core/ext/filters/client_channel/subchannel.h"
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/handshaker.h"
+#include "src/core/lib/channel/channel_args_preconditioning.h"
+#include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/iomgr/tcp_client.h"
-#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/event_engine/channel_args_endpoint_config.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/status_helper.h"
+#include "src/core/lib/gprpp/unique_type_name.h"
+#include "src/core/lib/iomgr/endpoint.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/resolved_address.h"
+#include "src/core/lib/resolver/resolver_registry.h"
+#include "src/core/lib/security/credentials/credentials.h"
+#include "src/core/lib/security/credentials/insecure/insecure_credentials.h"
+#include "src/core/lib/security/security_connector/security_connector.h"
+#include "src/core/lib/surface/api_trace.h"
+#include "src/core/lib/surface/channel.h"
+#include "src/core/lib/surface/channel_stack_type.h"
+#include "src/core/lib/transport/error_utils.h"
+#include "src/core/lib/transport/handshaker.h"
+#include "src/core/lib/transport/handshaker_registry.h"
+#include "src/core/lib/transport/tcp_connect_handshaker.h"
+#include "src/core/lib/transport/transport.h"
+#include "src/core/lib/transport/transport_fwd.h"
+
+#ifdef GPR_SUPPORT_CHANNELS_FROM_FD
+
+#include <fcntl.h>
+
+#include "src/core/lib/iomgr/ev_posix.h"
+#include "src/core/lib/iomgr/tcp_client_posix.h"
+
+#endif  // GPR_SUPPORT_CHANNELS_FROM_FD
 
 namespace grpc_core {
 
-Chttp2Connector::Chttp2Connector() {
-  GRPC_CLOSURE_INIT(&connected_, Connected, this, grpc_schedule_on_exec_ctx);
+namespace {
+void NullThenSchedClosure(const DebugLocation& location, grpc_closure** closure,
+                          grpc_error_handle error) {
+  grpc_closure* c = *closure;
+  *closure = nullptr;
+  ExecCtx::Run(location, c, error);
 }
+}  // namespace
 
 Chttp2Connector::~Chttp2Connector() {
-  if (resource_quota_ != nullptr) {
-    grpc_resource_quota_unref_internal(resource_quota_);
-  }
   if (endpoint_ != nullptr) {
     grpc_endpoint_destroy(endpoint_);
   }
@@ -53,109 +100,51 @@ Chttp2Connector::~Chttp2Connector() {
 
 void Chttp2Connector::Connect(const Args& args, Result* result,
                               grpc_closure* notify) {
-  grpc_endpoint** ep;
   {
     MutexLock lock(&mu_);
     GPR_ASSERT(notify_ == nullptr);
     args_ = args;
     result_ = result;
     notify_ = notify;
-    GPR_ASSERT(!connecting_);
-    connecting_ = true;
     GPR_ASSERT(endpoint_ == nullptr);
-    ep = &endpoint_;
-    if (resource_quota_ != nullptr) {
-      grpc_resource_quota_unref_internal(resource_quota_);
-    }
-    resource_quota_ =
-        grpc_resource_quota_from_channel_args(args.channel_args, true);
   }
-  // In some implementations, the closure can be flushed before
-  // grpc_tcp_client_connect() returns, and since the closure requires access
-  // to mu_, this can result in a deadlock (see
-  // https://github.com/grpc/grpc/issues/16427 for details).
-  // grpc_tcp_client_connect() will fill endpoint_ with proper contents, and we
-  // make sure that we still exist at that point by taking a ref.
-  Ref().release();  // Ref held by callback.
-  grpc_tcp_client_connect(
-      &connected_, ep,
-      grpc_slice_allocator_create(resource_quota_,
-                                  grpc_sockaddr_to_string(args.address, false),
-                                  args.channel_args),
-      args.interested_parties, args.channel_args, args.address, args.deadline);
+  absl::StatusOr<std::string> address = grpc_sockaddr_to_uri(args.address);
+  if (!address.ok()) {
+    grpc_error_handle error = GRPC_ERROR_CREATE(address.status().ToString());
+    NullThenSchedClosure(DEBUG_LOCATION, &notify_, error);
+    return;
+  }
+  ChannelArgs channel_args =
+      args_.channel_args
+          .Set(GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS, address.value())
+          .Set(GRPC_ARG_TCP_HANDSHAKER_BIND_ENDPOINT_TO_POLLSET, 1);
+  handshake_mgr_ = MakeRefCounted<HandshakeManager>();
+  CoreConfiguration::Get().handshaker_registry().AddHandshakers(
+      HANDSHAKER_CLIENT, channel_args, args_.interested_parties,
+      handshake_mgr_.get());
+  Ref().release();  // Ref held by OnHandshakeDone().
+  handshake_mgr_->DoHandshake(nullptr /* endpoint */, channel_args,
+                              args.deadline, nullptr /* acceptor */,
+                              OnHandshakeDone, this);
 }
 
 void Chttp2Connector::Shutdown(grpc_error_handle error) {
   MutexLock lock(&mu_);
   shutdown_ = true;
   if (handshake_mgr_ != nullptr) {
-    handshake_mgr_->Shutdown(GRPC_ERROR_REF(error));
-  }
-  // If handshaking is not yet in progress, shutdown the endpoint.
-  // Otherwise, the handshaker will do this for us.
-  if (!connecting_ && endpoint_ != nullptr) {
-    grpc_endpoint_shutdown(endpoint_, GRPC_ERROR_REF(error));
-  }
-  GRPC_ERROR_UNREF(error);
-}
-
-void Chttp2Connector::Connected(void* arg, grpc_error_handle error) {
-  Chttp2Connector* self = static_cast<Chttp2Connector*>(arg);
-  bool unref = false;
-  {
-    MutexLock lock(&self->mu_);
-    GPR_ASSERT(self->connecting_);
-    self->connecting_ = false;
-    if (error != GRPC_ERROR_NONE || self->shutdown_) {
-      if (error == GRPC_ERROR_NONE) {
-        error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("connector shutdown");
-      } else {
-        error = GRPC_ERROR_REF(error);
-      }
-      if (self->endpoint_ != nullptr) {
-        grpc_endpoint_shutdown(self->endpoint_, GRPC_ERROR_REF(error));
-      }
-      self->result_->Reset();
-      grpc_closure* notify = self->notify_;
-      self->notify_ = nullptr;
-      ExecCtx::Run(DEBUG_LOCATION, notify, error);
-      unref = true;
-    } else {
-      GPR_ASSERT(self->endpoint_ != nullptr);
-      self->StartHandshakeLocked();
-    }
+    // Handshaker will also shutdown the endpoint if it exists
+    handshake_mgr_->Shutdown(error);
   }
-  if (unref) self->Unref();
-}
-
-void Chttp2Connector::StartHandshakeLocked() {
-  handshake_mgr_ = MakeRefCounted<HandshakeManager>();
-  CoreConfiguration::Get().handshaker_registry().AddHandshakers(
-      HANDSHAKER_CLIENT, args_.channel_args, args_.interested_parties,
-      handshake_mgr_.get());
-  grpc_endpoint_add_to_pollset_set(endpoint_, args_.interested_parties);
-  handshake_mgr_->DoHandshake(endpoint_, args_.channel_args, args_.deadline,
-                              nullptr /* acceptor */, OnHandshakeDone, this);
-  endpoint_ = nullptr;  // Endpoint handed off to handshake manager.
-}
-
-namespace {
-void NullThenSchedClosure(const DebugLocation& location, grpc_closure** closure,
-                          grpc_error_handle error) {
-  grpc_closure* c = *closure;
-  *closure = nullptr;
-  ExecCtx::Run(location, c, error);
 }
-}  // namespace
 
 void Chttp2Connector::OnHandshakeDone(void* arg, grpc_error_handle error) {
   auto* args = static_cast<HandshakerArgs*>(arg);
   Chttp2Connector* self = static_cast<Chttp2Connector*>(args->user_data);
   {
     MutexLock lock(&self->mu_);
-    if (error != GRPC_ERROR_NONE || self->shutdown_) {
-      if (error == GRPC_ERROR_NONE) {
-        error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("connector shutdown");
+    if (!error.ok() || self->shutdown_) {
+      if (error.ok()) {
+        error = GRPC_ERROR_CREATE("connector shutdown");
         // We were shut down after handshaking completed successfully, so
         // destroy the endpoint here.
         if (args->endpoint != nullptr) {
@@ -163,24 +152,17 @@ void Chttp2Connector::OnHandshakeDone(void* arg, grpc_error_handle error) {
           // before destroying them, even if we know that there are no
           // pending read/write callbacks.  This should be fixed, at which
           // point this can be removed.
-          grpc_endpoint_shutdown(args->endpoint, GRPC_ERROR_REF(error));
+          grpc_endpoint_shutdown(args->endpoint, error);
           grpc_endpoint_destroy(args->endpoint);
-          grpc_channel_args_destroy(args->args);
-          grpc_slice_buffer_destroy_internal(args->read_buffer);
+          grpc_slice_buffer_destroy(args->read_buffer);
           gpr_free(args->read_buffer);
         }
-      } else {
-        error = GRPC_ERROR_REF(error);
       }
       self->result_->Reset();
       NullThenSchedClosure(DEBUG_LOCATION, &self->notify_, error);
     } else if (args->endpoint != nullptr) {
-      self->result_->transport = grpc_create_chttp2_transport(
-          args->args, args->endpoint, true,
-          grpc_resource_user_create(
-              self->resource_quota_,
-              absl::StrCat(grpc_endpoint_get_peer(args->endpoint),
-                           ":connector_transport")));
+      self->result_->transport =
+          grpc_create_chttp2_transport(args->args, args->endpoint, true);
       self->result_->socket_node =
           grpc_chttp2_transport_get_socket_node(self->result_->transport);
       self->result_->channel_args = args->args;
@@ -215,20 +197,19 @@ void Chttp2Connector::OnReceiveSettings(void* arg, grpc_error_handle error) {
     if (!self->notify_error_.has_value()) {
       grpc_endpoint_delete_from_pollset_set(self->endpoint_,
                                             self->args_.interested_parties);
-      if (error != GRPC_ERROR_NONE) {
+      if (!error.ok()) {
         // Transport got an error while waiting on SETTINGS frame.
         // TODO(yashykt): The following two lines should be moved to
         // SubchannelConnector::Result::Reset()
         grpc_transport_destroy(self->result_->transport);
-        grpc_channel_args_destroy(self->result_->channel_args);
         self->result_->Reset();
       }
-      self->MaybeNotify(GRPC_ERROR_REF(error));
+      self->MaybeNotify(error);
       grpc_timer_cancel(&self->timer_);
     } else {
       // OnTimeout() was already invoked. Call Notify() again so that notify_
       // can be invoked.
-      self->MaybeNotify(GRPC_ERROR_NONE);
+      self->MaybeNotify(absl::OkStatus());
     }
   }
   self->Unref();
@@ -246,14 +227,13 @@ void Chttp2Connector::OnTimeout(void* arg, grpc_error_handle /*error*/) {
       // TODO(yashykt): The following two lines should be moved to
       // SubchannelConnector::Result::Reset()
       grpc_transport_destroy(self->result_->transport);
-      grpc_channel_args_destroy(self->result_->channel_args);
       self->result_->Reset();
-      self->MaybeNotify(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+      self->MaybeNotify(GRPC_ERROR_CREATE(
           "connection attempt timed out before receiving SETTINGS frame"));
     } else {
       // OnReceiveSettings() was already invoked. Call Notify() again so that
       // notify_ can be invoked.
-      self->MaybeNotify(GRPC_ERROR_NONE);
+      self->MaybeNotify(absl::OkStatus());
     }
   }
   self->Unref();
@@ -261,7 +241,6 @@ void Chttp2Connector::OnTimeout(void* arg, grpc_error_handle /*error*/) {
 
 void Chttp2Connector::MaybeNotify(grpc_error_handle error) {
   if (notify_error_.has_value()) {
-    GRPC_ERROR_UNREF(error);
     NullThenSchedClosure(DEBUG_LOCATION, &notify_, notify_error_.value());
     // Clear state for a new Connect().
     // Clear out the endpoint_, since it is the responsibility of
@@ -273,4 +252,183 @@ void Chttp2Connector::MaybeNotify(grpc_error_handle error) {
   }
 }
 
+namespace {
+
+class Chttp2SecureClientChannelFactory : public ClientChannelFactory {
+ public:
+  RefCountedPtr<Subchannel> CreateSubchannel(
+      const grpc_resolved_address& address, const ChannelArgs& args) override {
+    absl::StatusOr<ChannelArgs> new_args = GetSecureNamingChannelArgs(args);
+    if (!new_args.ok()) {
+      gpr_log(GPR_ERROR,
+              "Failed to create channel args during subchannel creation: %s; "
+              "Got args: %s",
+              new_args.status().ToString().c_str(), args.ToString().c_str());
+      return nullptr;
+    }
+    RefCountedPtr<Subchannel> s = Subchannel::Create(
+        MakeOrphanable<Chttp2Connector>(), address, *new_args);
+    return s;
+  }
+
+ private:
+  static absl::StatusOr<ChannelArgs> GetSecureNamingChannelArgs(
+      ChannelArgs args) {
+    auto* channel_credentials = args.GetObject<grpc_channel_credentials>();
+    if (channel_credentials == nullptr) {
+      return absl::InternalError(
+          "channel credentials missing for secure channel");
+    }
+    // Make sure security connector does not already exist in args.
+    if (args.Contains(GRPC_ARG_SECURITY_CONNECTOR)) {
+      return absl::InternalError(
+          "security connector already present in channel args.");
+    }
+    // Find the authority to use in the security connector.
+    absl::optional<std::string> authority =
+        args.GetOwnedString(GRPC_ARG_DEFAULT_AUTHORITY);
+    if (!authority.has_value()) {
+      return absl::InternalError("authority not present in channel args");
+    }
+    // Create the security connector using the credentials and target name.
+    RefCountedPtr<grpc_channel_security_connector>
+        subchannel_security_connector =
+            channel_credentials->create_security_connector(
+                /*call_creds=*/nullptr, authority->c_str(), &args);
+    if (subchannel_security_connector == nullptr) {
+      return absl::InternalError(absl::StrFormat(
+          "Failed to create secure subchannel for secure name '%s'",
+          *authority));
+    }
+    return args.SetObject(std::move(subchannel_security_connector));
+  }
+};
+
+absl::StatusOr<RefCountedPtr<Channel>> CreateChannel(const char* target,
+                                                     const ChannelArgs& args) {
+  if (target == nullptr) {
+    gpr_log(GPR_ERROR, "cannot create channel with NULL target name");
+    return absl::InvalidArgumentError("channel target is NULL");
+  }
+  // Add channel arg containing the server URI.
+  std::string canonical_target =
+      CoreConfiguration::Get().resolver_registry().AddDefaultPrefixIfNeeded(
+          target);
+  return Channel::Create(target,
+                         args.Set(GRPC_ARG_SERVER_URI, canonical_target),
+                         GRPC_CLIENT_CHANNEL, nullptr);
+}
+
+}  // namespace
 }  // namespace grpc_core
+
+namespace {
+
+grpc_core::Chttp2SecureClientChannelFactory* g_factory;
+gpr_once g_factory_once = GPR_ONCE_INIT;
+
+void FactoryInit() {
+  g_factory = new grpc_core::Chttp2SecureClientChannelFactory();
+}
+
+}  // namespace
+
+// Create a secure client channel:
+//   Asynchronously: - resolve target
+//                   - connect to it (trying alternatives as presented)
+//                   - perform handshakes
+grpc_channel* grpc_channel_create(const char* target,
+                                  grpc_channel_credentials* creds,
+                                  const grpc_channel_args* c_args) {
+  grpc_core::ExecCtx exec_ctx;
+  GRPC_API_TRACE("grpc_secure_channel_create(target=%s, creds=%p, args=%p)", 3,
+                 (target, (void*)creds, (void*)c_args));
+  grpc_channel* channel = nullptr;
+  grpc_error_handle error;
+  if (creds != nullptr) {
+    // Add channel args containing the client channel factory and channel
+    // credentials.
+    gpr_once_init(&g_factory_once, FactoryInit);
+    grpc_core::ChannelArgs args =
+        creds->update_arguments(grpc_core::CoreConfiguration::Get()
+                                    .channel_args_preconditioning()
+                                    .PreconditionChannelArgs(c_args)
+                                    .SetObject(creds->Ref())
+                                    .SetObject(g_factory));
+    // Create channel.
+    auto r = grpc_core::CreateChannel(target, args);
+    if (r.ok()) {
+      channel = r->release()->c_ptr();
+    } else {
+      error = absl_status_to_grpc_error(r.status());
+    }
+  }
+  if (channel == nullptr) {
+    intptr_t integer;
+    grpc_status_code status = GRPC_STATUS_INTERNAL;
+    if (grpc_error_get_int(error, grpc_core::StatusIntProperty::kRpcStatus,
+                           &integer)) {
+      status = static_cast<grpc_status_code>(integer);
+    }
+    channel = grpc_lame_client_channel_create(
+        target, status, "Failed to create secure client channel");
+  }
+  return channel;
+}
+
+#ifdef GPR_SUPPORT_CHANNELS_FROM_FD
+grpc_channel* grpc_channel_create_from_fd(const char* target, int fd,
+                                          grpc_channel_credentials* creds,
+                                          const grpc_channel_args* args) {
+  grpc_core::ExecCtx exec_ctx;
+  GRPC_API_TRACE(
+      "grpc_channel_create_from_fd(target=%p, fd=%d, creds=%p, args=%p)", 4,
+      (target, fd, creds, args));
+  // For now, we only support insecure channel credentials.
+  if (creds == nullptr ||
+      creds->type() != grpc_core::InsecureCredentials::Type()) {
+    return grpc_lame_client_channel_create(
+        target, GRPC_STATUS_INTERNAL,
+        "Failed to create client channel due to invalid creds");
+  }
+  grpc_core::ChannelArgs final_args =
+      grpc_core::CoreConfiguration::Get()
+          .channel_args_preconditioning()
+          .PreconditionChannelArgs(args)
+          .SetIfUnset(GRPC_ARG_DEFAULT_AUTHORITY, "test.authority")
+          .SetObject(creds->Ref());
+
+  int flags = fcntl(fd, F_GETFL, 0);
+  GPR_ASSERT(fcntl(fd, F_SETFL, flags | O_NONBLOCK) == 0);
+  grpc_endpoint* client = grpc_tcp_create_from_fd(
+      grpc_fd_create(fd, "client", true),
+      grpc_event_engine::experimental::ChannelArgsEndpointConfig(final_args),
+      "fd-client");
+  grpc_transport* transport =
+      grpc_create_chttp2_transport(final_args, client, true);
+  GPR_ASSERT(transport);
+  auto channel = grpc_core::Channel::Create(
+      target, final_args, GRPC_CLIENT_DIRECT_CHANNEL, transport);
+  if (channel.ok()) {
+    grpc_chttp2_transport_start_reading(transport, nullptr, nullptr, nullptr);
+    grpc_core::ExecCtx::Get()->Flush();
+    return channel->release()->c_ptr();
+  } else {
+    grpc_transport_destroy(transport);
+    return grpc_lame_client_channel_create(
+        target, static_cast<grpc_status_code>(channel.status().code()),
+        "Failed to create client channel");
+  }
+}
+
+#else  // !GPR_SUPPORT_CHANNELS_FROM_FD
+
+grpc_channel* grpc_channel_create_from_fd(const char* /* target */,
+                                          int /* fd */,
+                                          grpc_channel_credentials* /* creds*/,
+                                          const grpc_channel_args* /* args */) {
+  GPR_ASSERT(0);
+  return nullptr;
+}
+
+#endif  // GPR_SUPPORT_CHANNELS_FROM_FD

data/src/core/ext/transport/chttp2/client/chttp2_connector.h

@@ -21,24 +21,27 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/types/optional.h"
+
 #include "src/core/ext/filters/client_channel/connector.h"
-#include "src/core/lib/channel/handshaker.h"
-#include "src/core/lib/channel/handshaker_registry.h"
-#include "src/core/lib/iomgr/resource_quota.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/endpoint.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/timer.h"
+#include "src/core/lib/transport/handshaker.h"
 
 namespace grpc_core {
 
 class Chttp2Connector : public SubchannelConnector {
  public:
-  Chttp2Connector();
   ~Chttp2Connector() override;
 
   void Connect(const Args& args, Result* result, grpc_closure* notify) override;
   void Shutdown(grpc_error_handle error) override;
 
  private:
-  static void Connected(void* arg, grpc_error_handle error);
-  void StartHandshakeLocked();
   static void OnHandshakeDone(void* arg, grpc_error_handle error);
   static void OnReceiveSettings(void* arg, grpc_error_handle error);
   static void OnTimeout(void* arg, grpc_error_handle error);
@@ -59,17 +62,14 @@ class Chttp2Connector : public SubchannelConnector {
   Result* result_ = nullptr;
   grpc_closure* notify_ = nullptr;
   bool shutdown_ = false;
-  bool connecting_ = false;
   // Holds the endpoint when first created before being handed off to
   // the handshake manager, and then again after handshake is done.
   grpc_endpoint* endpoint_ = nullptr;
-  grpc_closure connected_;
   grpc_closure on_receive_settings_;
   grpc_timer timer_;
   grpc_closure on_timeout_;
   absl::optional<grpc_error_handle> notify_error_;
   RefCountedPtr<HandshakeManager> handshake_mgr_;
-  grpc_resource_quota* resource_quota_ = nullptr;
 };
 
 }  // namespace grpc_core