grpc 1.40.0 → 1.46.3

data/src/core/ext/filters/server_config_selector/server_config_selector.cc

@@ -0,0 +1,61 @@
+//
+// Copyright 2021 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/filters/server_config_selector/server_config_selector.h"
+
+#include "src/core/lib/channel/channel_args.h"
+
+namespace grpc_core {
+namespace {
+
+void* ServerConfigSelectorProviderArgCopy(void* p) {
+  ServerConfigSelectorProvider* arg =
+      static_cast<ServerConfigSelectorProvider*>(p);
+  return arg->Ref().release();
+}
+
+void ServerConfigSelectorProviderArgDestroy(void* p) {
+  ServerConfigSelectorProvider* arg =
+      static_cast<ServerConfigSelectorProvider*>(p);
+  arg->Unref();
+}
+
+int ServerConfigSelectorProviderArgCmp(void* p, void* q) {
+  return QsortCompare(p, q);
+}
+
+const grpc_arg_pointer_vtable kChannelArgVtable = {
+    ServerConfigSelectorProviderArgCopy, ServerConfigSelectorProviderArgDestroy,
+    ServerConfigSelectorProviderArgCmp};
+
+const char* kServerConfigSelectorProviderChannelArgName =
+    "grpc.internal.server_config_selector_provider";
+
+}  // namespace
+
+grpc_arg ServerConfigSelectorProvider::MakeChannelArg() const {
+  return grpc_channel_arg_pointer_create(
+      const_cast<char*>(kServerConfigSelectorProviderChannelArgName),
+      const_cast<ServerConfigSelectorProvider*>(this), &kChannelArgVtable);
+}
+
+absl::string_view ServerConfigSelectorProvider::ChannelArgName() {
+  return kServerConfigSelectorProviderChannelArgName;
+}
+
+}  // namespace grpc_core

data/src/core/ext/filters/server_config_selector/server_config_selector.h

@@ -0,0 +1,71 @@
+//
+// Copyright 2021 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef GRPC_CORE_EXT_FILTERS_SERVER_CONFIG_SELECTOR_SERVER_CONFIG_SELECTOR_H
+#define GRPC_CORE_EXT_FILTERS_SERVER_CONFIG_SELECTOR_SERVER_CONFIG_SELECTOR_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/status/statusor.h"
+
+#include "src/core/lib/gprpp/dual_ref_counted.h"
+#include "src/core/lib/service_config/service_config.h"
+#include "src/core/lib/transport/metadata_batch.h"
+
+namespace grpc_core {
+
+// ServerConfigSelector allows for choosing the service config to apply to a
+// server-side call based on the received initial metadata.
+class ServerConfigSelector : public RefCounted<ServerConfigSelector> {
+ public:
+  // Configuration to apply to an incoming call
+  struct CallConfig {
+    grpc_error_handle error = GRPC_ERROR_NONE;
+    const ServiceConfigParser::ParsedConfigVector* method_configs = nullptr;
+    RefCountedPtr<ServiceConfig> service_config;
+  };
+
+  ~ServerConfigSelector() override = default;
+  // Returns the CallConfig to apply to a call based on the incoming \a metadata
+  virtual CallConfig GetCallConfig(grpc_metadata_batch* metadata) = 0;
+};
+
+// ServerConfigSelectorProvider allows for subscribers to watch for updates on
+// ServerConfigSelector. It is propagated via channel args.
+class ServerConfigSelectorProvider
+    : public DualRefCounted<ServerConfigSelectorProvider> {
+ public:
+  class ServerConfigSelectorWatcher {
+   public:
+    virtual ~ServerConfigSelectorWatcher() = default;
+    virtual void OnServerConfigSelectorUpdate(
+        absl::StatusOr<RefCountedPtr<ServerConfigSelector>> update) = 0;
+  };
+
+  ~ServerConfigSelectorProvider() override = default;
+  // Only a single watcher is allowed at present
+  virtual absl::StatusOr<RefCountedPtr<ServerConfigSelector>> Watch(
+      std::unique_ptr<ServerConfigSelectorWatcher> watcher) = 0;
+  virtual void CancelWatch() = 0;
+
+  static absl::string_view ChannelArgName();
+
+  grpc_arg MakeChannelArg() const;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_EXT_FILTERS_SERVER_CONFIG_SELECTOR_SERVER_CONFIG_SELECTOR_H

data/src/core/ext/filters/server_config_selector/server_config_selector_filter.cc

@@ -0,0 +1,143 @@
+// Copyright 2021 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/filters/server_config_selector/server_config_selector_filter.h"
+
+#include "src/core/ext/filters/server_config_selector/server_config_selector.h"
+#include "src/core/lib/channel/promise_based_filter.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/promise/promise.h"
+#include "src/core/lib/resource_quota/arena.h"
+#include "src/core/lib/service_config/service_config_call_data.h"
+#include "src/core/lib/transport/error_utils.h"
+
+namespace grpc_core {
+
+namespace {
+
+class ServerConfigSelectorFilter final : public ChannelFilter {
+ public:
+  ~ServerConfigSelectorFilter() override;
+
+  ServerConfigSelectorFilter(const ServerConfigSelectorFilter&) = delete;
+  ServerConfigSelectorFilter& operator=(const ServerConfigSelectorFilter&) =
+      delete;
+  ServerConfigSelectorFilter(ServerConfigSelectorFilter&&) = default;
+  ServerConfigSelectorFilter& operator=(ServerConfigSelectorFilter&&) = default;
+
+  static absl::StatusOr<ServerConfigSelectorFilter> Create(ChannelArgs args,
+                                                           ChannelFilter::Args);
+
+  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
+      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
+
+  absl::StatusOr<RefCountedPtr<ServerConfigSelector>> config_selector() {
+    MutexLock lock(&state_->mu);
+    return state_->config_selector.value();
+  }
+
+ private:
+  struct State {
+    Mutex mu;
+    absl::optional<absl::StatusOr<RefCountedPtr<ServerConfigSelector>>>
+        config_selector ABSL_GUARDED_BY(mu);
+  };
+  class ServerConfigSelectorWatcher
+      : public ServerConfigSelectorProvider::ServerConfigSelectorWatcher {
+   public:
+    explicit ServerConfigSelectorWatcher(std::shared_ptr<State> state)
+        : state_(state) {}
+    void OnServerConfigSelectorUpdate(
+        absl::StatusOr<RefCountedPtr<ServerConfigSelector>> update) override {
+      MutexLock lock(&state_->mu);
+      state_->config_selector = std::move(update);
+    }
+
+   private:
+    std::shared_ptr<State> state_;
+  };
+
+  explicit ServerConfigSelectorFilter(
+      RefCountedPtr<ServerConfigSelectorProvider>
+          server_config_selector_provider);
+
+  RefCountedPtr<ServerConfigSelectorProvider> server_config_selector_provider_;
+  std::shared_ptr<State> state_;
+};
+
+absl::StatusOr<ServerConfigSelectorFilter> ServerConfigSelectorFilter::Create(
+    ChannelArgs args, ChannelFilter::Args) {
+  ServerConfigSelectorProvider* server_config_selector_provider =
+      args.GetObject<ServerConfigSelectorProvider>();
+  if (server_config_selector_provider == nullptr) {
+    return absl::UnknownError("No ServerConfigSelectorProvider object found");
+  }
+  return ServerConfigSelectorFilter(server_config_selector_provider->Ref());
+}
+
+ServerConfigSelectorFilter::ServerConfigSelectorFilter(
+    RefCountedPtr<ServerConfigSelectorProvider> server_config_selector_provider)
+    : server_config_selector_provider_(
+          std::move(server_config_selector_provider)),
+      state_(std::make_shared<State>()) {
+  GPR_ASSERT(server_config_selector_provider_ != nullptr);
+  auto server_config_selector_watcher =
+      absl::make_unique<ServerConfigSelectorWatcher>(state_);
+  auto config_selector = server_config_selector_provider_->Watch(
+      std::move(server_config_selector_watcher));
+  MutexLock lock(&state_->mu);
+  // It's possible for the watcher to have already updated config_selector_
+  if (!state_->config_selector.has_value()) {
+    state_->config_selector = std::move(config_selector);
+  }
+}
+
+ServerConfigSelectorFilter::~ServerConfigSelectorFilter() {
+  if (server_config_selector_provider_ != nullptr) {
+    server_config_selector_provider_->CancelWatch();
+  }
+}
+
+ArenaPromise<ServerMetadataHandle> ServerConfigSelectorFilter::MakeCallPromise(
+    CallArgs call_args, NextPromiseFactory next_promise_factory) {
+  auto sel = config_selector();
+  if (!sel.ok()) return Immediate(ServerMetadataHandle(sel.status()));
+  auto call_config =
+      sel.value()->GetCallConfig(call_args.client_initial_metadata.get());
+  if (call_config.error != GRPC_ERROR_NONE) {
+    auto r = Immediate(ServerMetadataHandle(
+        absl::UnavailableError(grpc_error_std_string(call_config.error))));
+    GRPC_ERROR_UNREF(call_config.error);
+    return std::move(r);
+  }
+  auto& ctx = GetContext<
+      grpc_call_context_element>()[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA];
+  ctx.value = GetContext<Arena>()->New<ServiceConfigCallData>(
+      std::move(call_config.service_config), call_config.method_configs,
+      ServiceConfigCallData::CallAttributes{});
+  ctx.destroy = [](void* p) {
+    static_cast<ServiceConfigCallData*>(p)->~ServiceConfigCallData();
+  };
+  return next_promise_factory(std::move(call_args));
+}
+
+}  // namespace
+
+const grpc_channel_filter kServerConfigSelectorFilter =
+    MakePromiseBasedFilter<ServerConfigSelectorFilter, FilterEndpoint::kServer>(
+        "server_config_selector_filter");
+
+}  // namespace grpc_core

data/src/core/ext/filters/{workarounds/workaround_cronet_compression_filter.h → server_config_selector/server_config_selector_filter.h}

@@ -1,5 +1,6 @@
 //
-// Copyright 2017 gRPC authors.
+//
+// Copyright 2021 gRPC authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -13,15 +14,19 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
+//
 
-#ifndef GRPC_CORE_EXT_FILTERS_WORKAROUNDS_WORKAROUND_CRONET_COMPRESSION_FILTER_H
-#define GRPC_CORE_EXT_FILTERS_WORKAROUNDS_WORKAROUND_CRONET_COMPRESSION_FILTER_H
+#ifndef GRPC_CORE_EXT_FILTERS_SERVER_CONFIG_SELECTOR_SERVER_CONFIG_SELECTOR_FILTER_H
+#define GRPC_CORE_EXT_FILTERS_SERVER_CONFIG_SELECTOR_SERVER_CONFIG_SELECTOR_FILTER_H
 
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_stack.h"
 
-extern const grpc_channel_filter grpc_workaround_cronet_compression_filter;
+namespace grpc_core {
+
+extern const grpc_channel_filter kServerConfigSelectorFilter;
+
+}  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_WORKAROUNDS_WORKAROUND_CRONET_COMPRESSION_FILTER_H \
-        */
+#endif  // GRPC_CORE_EXT_FILTERS_SERVER_CONFIG_SELECTOR_SERVER_CONFIG_SELECTOR_FILTER_H

data/src/core/ext/transport/chttp2/alpn/alpn.cc

@@ -18,9 +18,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/support/log.h>
 #include "src/core/ext/transport/chttp2/alpn/alpn.h"
 
+#include <grpc/support/log.h>
+
 #include "src/core/lib/gpr/useful.h"
 
 /* in order of preference */

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

@@ -20,23 +20,43 @@
 
 #include "src/core/ext/transport/chttp2/client/chttp2_connector.h"
 
-#include <grpc/grpc.h>
-
 #include <string.h>
 
+#include <grpc/grpc.h>
+#include <grpc/grpc_posix.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 
+#include "src/core/ext/filters/client_channel/client_channel.h"
 #include "src/core/ext/filters/client_channel/connector.h"
-#include "src/core/ext/filters/client_channel/http_connect_handshaker.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/handshaker_registry.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/tcp_client.h"
+#include "src/core/lib/resolver/resolver_registry.h"
+#include "src/core/lib/resource_quota/api.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/slice/slice_internal.h"
+#include "src/core/lib/surface/api_trace.h"
+#include "src/core/lib/surface/channel.h"
+#include "src/core/lib/transport/transport.h"
+#include "src/core/lib/uri/uri_parser.h"
+
+#ifdef GPR_SUPPORT_CHANNELS_FROM_FD
+
+#include <fcntl.h>
+
+#include "src/core/lib/iomgr/tcp_client_posix.h"
+#include "src/core/lib/iomgr/tcp_posix.h"
+
+#endif  // GPR_SUPPORT_CHANNELS_FROM_FD
 
 namespace grpc_core {
 
@@ -45,13 +65,13 @@ Chttp2Connector::Chttp2Connector() {
 }
 
 Chttp2Connector::~Chttp2Connector() {
-  if (endpoint_ != nullptr) grpc_endpoint_destroy(endpoint_);
+  if (endpoint_ != nullptr) {
+    grpc_endpoint_destroy(endpoint_);
+  }
 }
 
 void Chttp2Connector::Connect(const Args& args, Result* result,
                               grpc_closure* notify) {
-  grpc_resolved_address addr;
-  Subchannel::GetAddressFromSubchannelAddressArg(args.channel_args, &addr);
   grpc_endpoint** ep;
   {
     MutexLock lock(&mu_);
@@ -72,7 +92,7 @@ void Chttp2Connector::Connect(const Args& args, Result* result,
   // 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, args.interested_parties,
-                          args.channel_args, &addr, args.deadline);
+                          args.channel_args, args.address, args.deadline);
 }
 
 void Chttp2Connector::Shutdown(grpc_error_handle error) {
@@ -120,9 +140,9 @@ void Chttp2Connector::Connected(void* arg, grpc_error_handle error) {
 
 void Chttp2Connector::StartHandshakeLocked() {
   handshake_mgr_ = MakeRefCounted<HandshakeManager>();
-  HandshakerRegistry::AddHandshakers(HANDSHAKER_CLIENT, args_.channel_args,
-                                     args_.interested_parties,
-                                     handshake_mgr_.get());
+  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);
@@ -259,4 +279,217 @@ void Chttp2Connector::MaybeNotify(grpc_error_handle error) {
   }
 }
 
+namespace {
+
+class Chttp2SecureClientChannelFactory : public ClientChannelFactory {
+ public:
+  RefCountedPtr<Subchannel> CreateSubchannel(
+      const grpc_resolved_address& address,
+      const grpc_channel_args* args) override {
+    grpc_channel_args* new_args = GetSecureNamingChannelArgs(args);
+    if (new_args == nullptr) {
+      gpr_log(GPR_ERROR,
+              "Failed to create channel args during subchannel creation.");
+      return nullptr;
+    }
+    RefCountedPtr<Subchannel> s = Subchannel::Create(
+        MakeOrphanable<Chttp2Connector>(), address, new_args);
+    grpc_channel_args_destroy(new_args);
+    return s;
+  }
+
+ private:
+  static grpc_channel_args* GetSecureNamingChannelArgs(
+      const grpc_channel_args* args) {
+    grpc_channel_credentials* channel_credentials =
+        grpc_channel_credentials_find_in_args(args);
+    if (channel_credentials == nullptr) {
+      gpr_log(GPR_ERROR,
+              "Can't create subchannel: channel credentials missing for secure "
+              "channel.");
+      return nullptr;
+    }
+    // Make sure security connector does not already exist in args.
+    if (grpc_security_connector_find_in_args(args) != nullptr) {
+      gpr_log(GPR_ERROR,
+              "Can't create subchannel: security connector already present in "
+              "channel args.");
+      return nullptr;
+    }
+    // Find the authority to use in the security connector.
+    const char* authority =
+        grpc_channel_args_find_string(args, GRPC_ARG_DEFAULT_AUTHORITY);
+    GPR_ASSERT(authority != nullptr);
+    // Create the security connector using the credentials and target name.
+    grpc_channel_args* new_args_from_connector = nullptr;
+    RefCountedPtr<grpc_channel_security_connector>
+        subchannel_security_connector =
+            channel_credentials->create_security_connector(
+                /*call_creds=*/nullptr, authority, args,
+                &new_args_from_connector);
+    if (subchannel_security_connector == nullptr) {
+      gpr_log(GPR_ERROR,
+              "Failed to create secure subchannel for secure name '%s'",
+              authority);
+      return nullptr;
+    }
+    grpc_arg new_security_connector_arg =
+        grpc_security_connector_to_arg(subchannel_security_connector.get());
+    grpc_channel_args* new_args = grpc_channel_args_copy_and_add(
+        new_args_from_connector != nullptr ? new_args_from_connector : args,
+        &new_security_connector_arg, 1);
+    subchannel_security_connector.reset(DEBUG_LOCATION, "lb_channel_create");
+    grpc_channel_args_destroy(new_args_from_connector);
+    return new_args;
+  }
+};
+
+grpc_channel* CreateChannel(const char* target, const grpc_channel_args* args,
+                            grpc_error_handle* error) {
+  if (target == nullptr) {
+    gpr_log(GPR_ERROR, "cannot create channel with NULL target name");
+    if (error != nullptr) {
+      *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("channel target is NULL");
+    }
+    return nullptr;
+  }
+  // Add channel arg containing the server URI.
+  std::string canonical_target =
+      CoreConfiguration::Get().resolver_registry().AddDefaultPrefixIfNeeded(
+          target);
+  grpc_arg arg = grpc_channel_arg_string_create(
+      const_cast<char*>(GRPC_ARG_SERVER_URI),
+      const_cast<char*>(canonical_target.c_str()));
+  const char* to_remove[] = {GRPC_ARG_SERVER_URI};
+  grpc_channel_args* new_args =
+      grpc_channel_args_copy_and_add_and_remove(args, to_remove, 1, &arg, 1);
+  grpc_channel* channel = grpc_channel_create_internal(
+      target, new_args, GRPC_CLIENT_CHANNEL, nullptr, error);
+  grpc_channel_args_destroy(new_args);
+  return channel;
+}
+
+}  // 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* args) {
+  grpc_core::ExecCtx exec_ctx;
+  GRPC_API_TRACE("grpc_secure_channel_create(target=%s, creds=%p, args=%p)", 3,
+                 (target, (void*)creds, (void*)args));
+  args = grpc_core::CoreConfiguration::Get()
+             .channel_args_preconditioning()
+             .PreconditionChannelArgs(args);
+  grpc_channel* channel = nullptr;
+  grpc_error_handle error = GRPC_ERROR_NONE;
+  if (creds != nullptr) {
+    // Add channel args containing the client channel factory and channel
+    // credentials.
+    gpr_once_init(&g_factory_once, FactoryInit);
+    grpc_arg channel_factory_arg =
+        grpc_core::ClientChannelFactory::CreateChannelArg(g_factory);
+    grpc_arg args_to_add[] = {channel_factory_arg,
+                              grpc_channel_credentials_to_arg(creds)};
+    const char* arg_to_remove = channel_factory_arg.key;
+    grpc_channel_args* new_args = grpc_channel_args_copy_and_add_and_remove(
+        args, &arg_to_remove, 1, args_to_add, GPR_ARRAY_SIZE(args_to_add));
+    new_args = creds->update_arguments(new_args);
+    // Create channel.
+    channel = grpc_core::CreateChannel(target, new_args, &error);
+    // Clean up.
+    grpc_channel_args_destroy(new_args);
+  }
+  grpc_channel_args_destroy(args);
+  if (channel == nullptr) {
+    intptr_t integer;
+    grpc_status_code status = GRPC_STATUS_INTERNAL;
+    if (grpc_error_get_int(error, GRPC_ERROR_INT_GRPC_STATUS, &integer)) {
+      status = static_cast<grpc_status_code>(integer);
+    }
+    GRPC_ERROR_UNREF(error);
+    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::InsecureServerCredentials::Type()) {
+    return grpc_lame_client_channel_create(
+        target, GRPC_STATUS_INTERNAL,
+        "Failed to create client channel due to invalid creds");
+  }
+  grpc_arg default_authority_arg = grpc_channel_arg_string_create(
+      const_cast<char*>(GRPC_ARG_DEFAULT_AUTHORITY),
+      const_cast<char*>("test.authority"));
+  args = grpc_channel_args_copy_and_add(args, &default_authority_arg, 1);
+  const grpc_channel_args* final_args = grpc_core::CoreConfiguration::Get()
+                                            .channel_args_preconditioning()
+                                            .PreconditionChannelArgs(args);
+  grpc_channel_args_destroy(args);
+
+  int flags = fcntl(fd, F_GETFL, 0);
+  GPR_ASSERT(fcntl(fd, F_SETFL, flags | O_NONBLOCK) == 0);
+  grpc_endpoint* client = grpc_tcp_client_create_from_fd(
+      grpc_fd_create(fd, "client", true), final_args, "fd-client");
+  grpc_transport* transport =
+      grpc_create_chttp2_transport(final_args, client, true);
+  GPR_ASSERT(transport);
+  grpc_error_handle error = GRPC_ERROR_NONE;
+  grpc_channel* channel = grpc_channel_create_internal(
+      target, final_args, GRPC_CLIENT_DIRECT_CHANNEL, transport, &error);
+  grpc_channel_args_destroy(final_args);
+  if (channel != nullptr) {
+    grpc_chttp2_transport_start_reading(transport, nullptr, nullptr, nullptr);
+    grpc_core::ExecCtx::Get()->Flush();
+  } else {
+    intptr_t integer;
+    grpc_status_code status = GRPC_STATUS_INTERNAL;
+    if (grpc_error_get_int(error, GRPC_ERROR_INT_GRPC_STATUS, &integer)) {
+      status = static_cast<grpc_status_code>(integer);
+    }
+    GRPC_ERROR_UNREF(error);
+    grpc_transport_destroy(transport);
+    channel = grpc_lame_client_channel_create(
+        target, status, "Failed to create client channel");
+  }
+
+  return 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