grpc 1.43.1 → 1.44.0.pre2

data/src/core/lib/iomgr/resolve_address.h

@@ -23,61 +23,64 @@
 
 #include <stddef.h>
 
-#include "src/core/lib/iomgr/port.h"
-
-#ifdef GRPC_WINSOCK_SOCKET
-#include <ws2tcpip.h>
-#endif
-
-#if defined(GRPC_POSIX_SOCKET) || defined(GRPC_CFSTREAM)
-#include <sys/socket.h>
-#endif
+#include "absl/status/statusor.h"
 
+#include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/iomgr/port.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 
 #define GRPC_MAX_SOCKADDR_SIZE 128
 
-struct grpc_resolved_address {
-  char addr[GRPC_MAX_SOCKADDR_SIZE];
-  socklen_t len;
-};
-struct grpc_resolved_addresses {
-  size_t naddrs;
-  grpc_resolved_address* addrs;
-};
-
 namespace grpc_core {
 extern const char* kDefaultSecurePort;
 constexpr int kDefaultSecurePortInt = 443;
-}  // namespace grpc_core
-
-typedef struct grpc_address_resolver_vtable {
-  void (*resolve_address)(const char* addr, const char* default_port,
-                          grpc_pollset_set* interested_parties,
-                          grpc_closure* on_done,
-                          grpc_resolved_addresses** addresses);
-  grpc_error_handle (*blocking_resolve_address)(
-      const char* name, const char* default_port,
-      grpc_resolved_addresses** addresses);
-} grpc_address_resolver_vtable;
 
-void grpc_set_resolver_impl(grpc_address_resolver_vtable* vtable);
+// A singleton class used for async and blocking DNS resolution
+class DNSResolver {
+ public:
+  // Tracks a single asynchronous DNS resolution attempt. The DNS
+  // resolution should be arranged to be cancelled as soon as possible
+  // when Orphan is called.
+  class Request : public InternallyRefCounted<Request> {
+   public:
+    // Begins async DNS resolution
+    virtual void Start() = 0;
+  };
+
+  virtual ~DNSResolver() {}
+
+  // Asynchronously resolve name. Use \a default_port if a port isn't designated
+  // in \a name, otherwise use the port in \a name. On completion, \a on_done is
+  // invoked with the result.
+  //
+  // Note for implementations: calls may acquire locks in \a on_done which
+  // were previously held while calling Request::Start(). Therefore,
+  // implementations must not invoke \a on_done inline from the call to
+  // Request::Start(). The DNSCallbackExecCtxScheduler utility may help address
+  // this.
+  virtual OrphanablePtr<Request> ResolveName(
+      absl::string_view name, absl::string_view default_port,
+      grpc_pollset_set* interested_parties,
+      std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+          on_done) GRPC_MUST_USE_RESULT = 0;
+
+  // Resolve name in a blocking fashion. Use \a default_port if a port isn't
+  // designated in \a name, otherwise use the port in \a name.
+  virtual absl::StatusOr<std::vector<grpc_resolved_address>>
+  ResolveNameBlocking(absl::string_view name,
+                      absl::string_view default_port) = 0;
+};
 
-/* Asynchronously resolve addr. Use default_port if a port isn't designated
-   in addr, otherwise use the port in addr. */
-/* TODO(apolcyn): add a timeout here */
-void grpc_resolve_address(const char* addr, const char* default_port,
-                          grpc_pollset_set* interested_parties,
-                          grpc_closure* on_done,
-                          grpc_resolved_addresses** addresses);
+// Override the active DNS resolver which should be used for all DNS
+// resolution in gRPC. Note this should only be used during library
+// initialization or within tests.
+void SetDNSResolver(DNSResolver* resolver);
 
-/* Destroy resolved addresses */
-void grpc_resolved_addresses_destroy(grpc_resolved_addresses* addresses);
+// Get the singleton DNS resolver instance which should be used for all
+// DNS resolution in gRPC.
+DNSResolver* GetDNSResolver();
 
-/* Resolve addr in a blocking fashion. On success,
-   result must be freed with grpc_resolved_addresses_destroy. */
-grpc_error_handle grpc_blocking_resolve_address(
-    const char* name, const char* default_port,
-    grpc_resolved_addresses** addresses);
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_H */

data/src/core/lib/iomgr/resolve_address_custom.cc

@@ -1,20 +1,18 @@
-/*
- *
- * Copyright 2018 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.
- *
- */
+//
+// Copyright 2018 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>
 
@@ -22,6 +20,7 @@
 
 #include <string.h>
 
+#include <cstdio>
 #include <string>
 
 #include "absl/strings/str_format.h"
@@ -35,135 +34,158 @@
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/iomgr/iomgr_custom.h"
 #include "src/core/lib/iomgr/port.h"
+#include "src/core/lib/iomgr/resolve_address_impl.h"
+#include "src/core/lib/transport/error_utils.h"
 
-struct grpc_custom_resolver {
-  grpc_closure* on_done = nullptr;
-  grpc_resolved_addresses** addresses = nullptr;
-  std::string host;
-  std::string port;
-};
-
-static grpc_custom_resolver_vtable* resolve_address_vtable = nullptr;
-
-static int retry_named_port_failure(grpc_custom_resolver* r,
-                                    grpc_resolved_addresses** res) {
-  // This loop is copied from resolve_address_posix.c
-  const char* svc[][2] = {{"http", "80"}, {"https", "443"}};
-  for (size_t i = 0; i < GPR_ARRAY_SIZE(svc); i++) {
-    if (r->port == svc[i][0]) {
-      r->port = svc[i][1];
-      if (res) {
-        grpc_error_handle error = resolve_address_vtable->resolve(
-            r->host.c_str(), r->port.c_str(), res);
-        if (error != GRPC_ERROR_NONE) {
-          GRPC_ERROR_UNREF(error);
-          return 0;
-        }
-      } else {
-        resolve_address_vtable->resolve_async(r, r->host.c_str(),
-                                              r->port.c_str());
-      }
-      return 1;
-    }
+void grpc_resolved_addresses_destroy(grpc_resolved_addresses* addresses) {
+  if (addresses != nullptr) {
+    gpr_free(addresses->addrs);
   }
-  return 0;
+  gpr_free(addresses);
 }
 
-void grpc_custom_resolve_callback(grpc_custom_resolver* r,
+void grpc_custom_resolve_callback(grpc_custom_resolver* resolver,
                                   grpc_resolved_addresses* result,
                                   grpc_error_handle error) {
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
-  if (error == GRPC_ERROR_NONE) {
-    *r->addresses = result;
-  } else if (retry_named_port_failure(r, nullptr)) {
-    return;
-  }
-  if (r->on_done) {
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, r->on_done, error);
+  grpc_core::CustomDNSResolver::Request* request =
+      grpc_core::CustomDNSResolver::Request::FromC(resolver);
+  if (error != GRPC_ERROR_NONE) {
+    request->ResolveCallback(grpc_error_to_absl_status(error));
+  } else {
+    std::vector<grpc_resolved_address> addresses;
+    for (size_t i = 0; i < result->naddrs; i++) {
+      addresses.push_back(result->addrs[i]);
+    }
+    request->ResolveCallback(std::move(addresses));
+    grpc_resolved_addresses_destroy(result);
   }
-  delete r;
+  GRPC_ERROR_UNREF(error);
 }
 
-static grpc_error_handle try_split_host_port(const char* name,
-                                             const char* default_port,
-                                             std::string* host,
-                                             std::string* port) {
-  /* parse name, splitting it into host and port parts */
-  grpc_core::SplitHostPort(name, host, port);
+namespace grpc_core {
+
+namespace {
+
+absl::Status TrySplitHostPort(absl::string_view name,
+                              absl::string_view default_port, std::string* host,
+                              std::string* port) {
+  // parse name, splitting it into host and port parts
+  SplitHostPort(name, host, port);
   if (host->empty()) {
-    return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+    return absl::UnknownError(
         absl::StrFormat("unparseable host:port: '%s'", name));
   }
   if (port->empty()) {
     // TODO(murgatroid99): add tests for this case
     if (default_port == nullptr) {
-      return GRPC_ERROR_CREATE_FROM_CPP_STRING(
-          absl::StrFormat("no port in name '%s'", name));
+      return absl::UnknownError(absl::StrFormat("no port in name '%s'", name));
+    }
+    *port = std::string(default_port);
+  }
+  return absl::OkStatus();
+}
+
+absl::StatusOr<std::string> NamedPortToNumeric(absl::string_view named_port) {
+  if (named_port == "http") {
+    return "80";
+  } else if (named_port == "https") {
+    return "443";
+  } else {
+    return absl::UnknownError(absl::StrCat("unknown named port: ", named_port));
+  }
+}
+
+}  // namespace
+
+void CustomDNSResolver::Request::ResolveCallback(
+    absl::StatusOr<std::vector<grpc_resolved_address>> result) {
+  if (!result.ok()) {
+    auto numeric_port_or = NamedPortToNumeric(port_);
+    if (numeric_port_or.ok()) {
+      port_ = *numeric_port_or;
+      resolve_address_vtable_->resolve_async(c_ptr(), host_.c_str(),
+                                             port_.c_str());
+      // keep holding ref for active resolution
+      return;
     }
-    *port = default_port;
   }
-  return GRPC_ERROR_NONE;
+  // since we can't guarantee that we're not being called inline from
+  // Start(), run the callback on the ExecCtx.
+  new DNSCallbackExecCtxScheduler(std::move(on_done_), std::move(result));
+  Unref();
 }
 
-static grpc_error_handle blocking_resolve_address_impl(
-    const char* name, const char* default_port,
-    grpc_resolved_addresses** addresses) {
+namespace {
+CustomDNSResolver* g_custom_dns_resolver;
+}  // namespace
+
+// Creates the global custom resolver with the specified vtable.
+void CustomDNSResolver::Create(grpc_custom_resolver_vtable* vtable) {
+  if (g_custom_dns_resolver != nullptr) return;
+  g_custom_dns_resolver = new CustomDNSResolver(vtable);
+}
+
+// Gets the singleton instance.
+CustomDNSResolver* CustomDNSResolver::Get() { return g_custom_dns_resolver; }
+
+absl::StatusOr<std::vector<grpc_resolved_address>>
+CustomDNSResolver::ResolveNameBlocking(absl::string_view name,
+                                       absl::string_view default_port) {
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
 
-  grpc_custom_resolver resolver;
-  grpc_error_handle err =
-      try_split_host_port(name, default_port, &resolver.host, &resolver.port);
-  if (err != GRPC_ERROR_NONE) {
-    return err;
+  std::string host;
+  std::string port;
+  absl::Status parse_status =
+      TrySplitHostPort(name, default_port, &host, &port);
+  if (!parse_status.ok()) {
+    return parse_status;
   }
 
-  /* Call getaddrinfo */
+  // Call getaddrinfo
+  ExecCtx* curr = ExecCtx::Get();
+  ExecCtx::Set(nullptr);
   grpc_resolved_addresses* addrs;
-  grpc_core::ExecCtx* curr = grpc_core::ExecCtx::Get();
-  grpc_core::ExecCtx::Set(nullptr);
-  err = resolve_address_vtable->resolve(resolver.host.c_str(),
-                                        resolver.port.c_str(), &addrs);
+  grpc_error_handle err =
+      resolve_address_vtable_->resolve(host.c_str(), port.c_str(), &addrs);
   if (err != GRPC_ERROR_NONE) {
-    if (retry_named_port_failure(&resolver, &addrs)) {
+    auto numeric_port_or = NamedPortToNumeric(port);
+    if (numeric_port_or.ok()) {
+      port = *numeric_port_or;
       GRPC_ERROR_UNREF(err);
-      err = GRPC_ERROR_NONE;
+      err =
+          resolve_address_vtable_->resolve(host.c_str(), port.c_str(), &addrs);
     }
   }
-  grpc_core::ExecCtx::Set(curr);
+  ExecCtx::Set(curr);
   if (err == GRPC_ERROR_NONE) {
-    *addresses = addrs;
+    GPR_ASSERT(addrs != nullptr);
+    std::vector<grpc_resolved_address> result;
+    for (size_t i = 0; i < addrs->naddrs; i++) {
+      result.push_back(addrs->addrs[i]);
+    }
+    grpc_resolved_addresses_destroy(addrs);
+    return result;
   }
-  return err;
+  auto error_result = grpc_error_to_absl_status(err);
+  GRPC_ERROR_UNREF(err);
+  return error_result;
 }
 
-static void resolve_address_impl(const char* name, const char* default_port,
-                                 grpc_pollset_set* /*interested_parties*/,
-                                 grpc_closure* on_done,
-                                 grpc_resolved_addresses** addrs) {
+void CustomDNSResolver::Request::Start() {
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
-  std::string host;
-  std::string port;
-  grpc_error_handle err = try_split_host_port(name, default_port, &host, &port);
-  if (err != GRPC_ERROR_NONE) {
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_done, err);
+  absl::Status parse_status =
+      TrySplitHostPort(name_, default_port_, &host_, &port_);
+  if (!parse_status.ok()) {
+    new DNSCallbackExecCtxScheduler(std::move(on_done_),
+                                    std::move(parse_status));
     return;
   }
-  grpc_custom_resolver* r = new grpc_custom_resolver();
-  r->on_done = on_done;
-  r->addresses = addrs;
-  r->host = std::move(host);
-  r->port = std::move(port);
-
-  /* Call getaddrinfo */
-  resolve_address_vtable->resolve_async(r, r->host.c_str(), r->port.c_str());
+  // Call getaddrinfo
+  Ref().release();  // ref held by resolution
+  resolve_address_vtable_->resolve_async(c_ptr(), host_.c_str(), port_.c_str());
 }
 
-static grpc_address_resolver_vtable custom_resolver_vtable = {
-    resolve_address_impl, blocking_resolve_address_impl};
-
-void grpc_custom_resolver_init(grpc_custom_resolver_vtable* impl) {
-  resolve_address_vtable = impl;
-  grpc_set_resolver_impl(&custom_resolver_vtable);
-}
+}  // namespace grpc_core

data/src/core/lib/iomgr/resolve_address_custom.h

@@ -1,30 +1,43 @@
-/*
- *
- * Copyright 2018 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.
- *
- */
+//
+// Copyright 2018 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_LIB_IOMGR_RESOLVE_ADDRESS_CUSTOM_H
 #define GRPC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_CUSTOM_H
 
 #include <grpc/support/port_platform.h>
 
+#include <grpc/support/sync.h>
+
+#include "src/core/lib/gprpp/cpp_impl_of.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 
+// User-configured custom DNS resolution APIs
+
+// TODO(apolcyn): This type could be deleted as a part of converting
+// this grpc_custom_resolver API to C++.
+struct grpc_resolved_addresses {
+  size_t naddrs;
+  grpc_resolved_address* addrs;
+};
+
+// Destroy resolved addresses
+void grpc_resolved_addresses_destroy(grpc_resolved_addresses* addresses);
+
 typedef struct grpc_custom_resolver grpc_custom_resolver;
 
 typedef struct grpc_custom_resolver_vtable {
@@ -34,11 +47,80 @@ typedef struct grpc_custom_resolver_vtable {
                         const char* port);
 } grpc_custom_resolver_vtable;
 
+// TODO(apolcyn): as a part of converting this API to C++,
+// callers of \a grpc_custom_resolve_callback could instead just invoke
+// CustomDNSResolver::Request::ResolveCallback directly.
 void grpc_custom_resolve_callback(grpc_custom_resolver* resolver,
                                   grpc_resolved_addresses* result,
                                   grpc_error_handle error);
 
-/* Internal APIs */
-void grpc_custom_resolver_init(grpc_custom_resolver_vtable* impl);
+// Internal APIs
+
+namespace grpc_core {
+
+class CustomDNSResolver : public DNSResolver {
+ public:
+  class Request : public DNSResolver::Request,
+                  public CppImplOf<Request, grpc_custom_resolver> {
+   public:
+    Request(
+        absl::string_view name, absl::string_view default_port,
+        std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+            on_done,
+        const grpc_custom_resolver_vtable* resolve_address_vtable)
+        : name_(name),
+          default_port_(default_port),
+          on_done_(std::move(on_done)),
+          resolve_address_vtable_(resolve_address_vtable) {}
+
+    // Starts the resolution
+    void Start() override;
+
+    // This is a no-op for the native resolver. Note
+    // that no I/O polling is required for the resolution to finish.
+    void Orphan() override { Unref(); }
+
+    // Continues async resolution with the results passed first in to
+    // grpc_custom_resolve_callback.
+    void ResolveCallback(
+        absl::StatusOr<std::vector<grpc_resolved_address>> result);
+
+   private:
+    const std::string name_;
+    const std::string default_port_;
+    std::string host_;
+    std::string port_;
+    std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+        on_done_;
+    // user-defined DNS methods
+    const grpc_custom_resolver_vtable* resolve_address_vtable_;
+  };
+
+  // Creates the global custom resolver with the specified vtable.
+  static void Create(grpc_custom_resolver_vtable* vtable);
+
+  // Gets the singleton instance.
+  static CustomDNSResolver* Get();
+
+  explicit CustomDNSResolver(const grpc_custom_resolver_vtable* vtable)
+      : resolve_address_vtable_(vtable) {}
+
+  OrphanablePtr<DNSResolver::Request> ResolveName(
+      absl::string_view name, absl::string_view default_port,
+      grpc_pollset_set* /* interested_parties */,
+      std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+          on_done) override {
+    return MakeOrphanable<Request>(name, default_port, std::move(on_done),
+                                   resolve_address_vtable_);
+  }
+
+  absl::StatusOr<std::vector<grpc_resolved_address>> ResolveNameBlocking(
+      absl::string_view name, absl::string_view default_port) override;
+
+ private:
+  // user-defined DNS methods
+  const grpc_custom_resolver_vtable* resolve_address_vtable_;
+};
 
+}  // namespace grpc_core
 #endif /* GRPC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_CUSTOM_H */

data/src/core/lib/iomgr/resolve_address_impl.h

@@ -0,0 +1,59 @@
+//
+// Copyright 2015 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_LIB_IOMGR_RESOLVE_ADDRESS_IMPL_H
+#define GRPC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_IMPL_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include "src/core/lib/iomgr/port.h"
+#include "src/core/lib/iomgr/resolve_address.h"
+
+namespace grpc_core {
+
+// A fire and forget class used by DNSResolver::Request implementations to
+// schedule DNS  resolution callbacks on the ExecCtx, which is frequently
+// necessary to avoid lock inversion related problems.
+class DNSCallbackExecCtxScheduler {
+ public:
+  DNSCallbackExecCtxScheduler(
+      std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+          on_done,
+      absl::StatusOr<std::vector<grpc_resolved_address>> param)
+      : on_done_(std::move(on_done)), param_(std::move(param)) {
+    GRPC_CLOSURE_INIT(&closure_, RunCallback, this, grpc_schedule_on_exec_ctx);
+    ExecCtx::Run(DEBUG_LOCATION, &closure_, GRPC_ERROR_NONE);
+  }
+
+ private:
+  static void RunCallback(void* arg, grpc_error_handle /* error */) {
+    DNSCallbackExecCtxScheduler* self =
+        static_cast<DNSCallbackExecCtxScheduler*>(arg);
+    self->on_done_(std::move(self->param_));
+    delete self;
+  }
+
+  const std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+      on_done_;
+  absl::StatusOr<std::vector<grpc_resolved_address>> param_;
+  grpc_closure closure_;
+};
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_IMPL_H */