grpc 1.41.1 → 1.44.0.pre2

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

@@ -41,6 +41,7 @@
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/resolve_address_posix.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/tcp_posix.h"
 #include "src/core/lib/iomgr/tcp_server.h"
@@ -55,7 +56,6 @@ extern grpc_tcp_client_vtable grpc_cfstream_client_vtable;
 extern grpc_timer_vtable grpc_generic_timer_vtable;
 extern grpc_pollset_vtable grpc_posix_pollset_vtable;
 extern grpc_pollset_set_vtable grpc_posix_pollset_set_vtable;
-extern grpc_address_resolver_vtable grpc_posix_resolver_vtable;
 
 static void apple_iomgr_platform_init(void) { grpc_pollset_global_init(); }
 
@@ -178,7 +178,7 @@ void grpc_set_default_iomgr_platform() {
     grpc_set_iomgr_platform_vtable(&apple_vtable);
   }
   grpc_set_timer_impl(&grpc_generic_timer_vtable);
-  grpc_set_resolver_impl(&grpc_posix_resolver_vtable);
+  grpc_core::SetDNSResolver(grpc_core::NativeDNSResolver::GetOrCreate());
 }
 
 bool grpc_iomgr_run_in_background() {

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

@@ -28,6 +28,7 @@
 #include "src/core/lib/iomgr/iomgr.h"
 #include "src/core/lib/iomgr/pollset_windows.h"
 #include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/resolve_address_windows.h"
 #include "src/core/lib/iomgr/sockaddr_windows.h"
 #include "src/core/lib/iomgr/socket_windows.h"
 #include "src/core/lib/iomgr/tcp_client.h"
@@ -39,7 +40,6 @@ extern grpc_tcp_client_vtable grpc_windows_tcp_client_vtable;
 extern grpc_timer_vtable grpc_generic_timer_vtable;
 extern grpc_pollset_vtable grpc_windows_pollset_vtable;
 extern grpc_pollset_set_vtable grpc_windows_pollset_set_vtable;
-extern grpc_address_resolver_vtable grpc_windows_resolver_vtable;
 
 /* Windows' io manager is going to be fully designed using IO completion
    ports. All of what we're doing here is basically make sure that
@@ -96,7 +96,7 @@ void grpc_set_default_iomgr_platform() {
   grpc_set_timer_impl(&grpc_generic_timer_vtable);
   grpc_set_pollset_vtable(&grpc_windows_pollset_vtable);
   grpc_set_pollset_set_vtable(&grpc_windows_pollset_set_vtable);
-  grpc_set_resolver_impl(&grpc_windows_resolver_vtable);
+  grpc_core::SetDNSResolver(grpc_core::NativeDNSResolver::GetOrCreate());
   grpc_set_iomgr_platform_vtable(&vtable);
 }
 

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

@@ -71,8 +71,8 @@ end:
         grpc_error_set_str(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                                "Failed to load file", &error, 1),
                            GRPC_ERROR_STR_FILENAME,
-                           grpc_slice_from_copied_string(
-                               filename));  // TODO(ncteisen), always static?
+
+                           filename);
     GRPC_ERROR_UNREF(error);
     error = error_out;
   }

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

@@ -77,7 +77,11 @@ void LockfreeEvent::DestroyEvent() {
   do {
     curr = gpr_atm_no_barrier_load(&state_);
     if (curr & kShutdownBit) {
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+      internal::StatusFreeHeapPtr(curr & ~kShutdownBit);
+#else
       GRPC_ERROR_UNREF((grpc_error_handle)(curr & ~kShutdownBit));
+#endif
     } else {
       GPR_ASSERT(curr == kClosureNotReady || curr == kClosureReady);
     }
@@ -139,8 +143,13 @@ void LockfreeEvent::NotifyOn(grpc_closure* closure) {
            contains a pointer to the shutdown-error). If the fd is shutdown,
            schedule the closure with the shutdown error */
         if ((curr & kShutdownBit) > 0) {
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+          grpc_error_handle shutdown_err =
+              internal::StatusGetFromHeapPtr(curr & ~kShutdownBit);
+#else
           grpc_error_handle shutdown_err =
               reinterpret_cast<grpc_error_handle>(curr & ~kShutdownBit);
+#endif
           ExecCtx::Run(DEBUG_LOCATION, closure,
                        GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                            "FD Shutdown", &shutdown_err, 1));
@@ -160,7 +169,12 @@ void LockfreeEvent::NotifyOn(grpc_closure* closure) {
 }
 
 bool LockfreeEvent::SetShutdown(grpc_error_handle shutdown_error) {
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+  intptr_t status_ptr = internal::StatusAllocHeapPtr(shutdown_error);
+  gpr_atm new_state = status_ptr | kShutdownBit;
+#else
   gpr_atm new_state = reinterpret_cast<gpr_atm>(shutdown_error) | kShutdownBit;
+#endif
 
   while (true) {
     gpr_atm curr = gpr_atm_no_barrier_load(&state_);
@@ -184,7 +198,11 @@ bool LockfreeEvent::SetShutdown(grpc_error_handle shutdown_error) {
 
         /* If fd is already shutdown, we are done */
         if ((curr & kShutdownBit) > 0) {
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+          internal::StatusFreeHeapPtr(status_ptr);
+#else
           GRPC_ERROR_UNREF(shutdown_error);
+#endif
           return false;
         }
 

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

@@ -76,7 +76,7 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
   // control back to the application
   grpc_core::ExecCtx* curr = grpc_core::ExecCtx::Get();
   grpc_core::ExecCtx::Set(nullptr);
-  grpc_error* err = poller_vtable->poll(static_cast<size_t>(timeout));
+  grpc_error_handle err = poller_vtable->poll(static_cast<size_t>(timeout));
   grpc_core::ExecCtx::Set(curr);
   grpc_core::ExecCtx::Get()->InvalidateNow();
   if (grpc_core::ExecCtx::Get()->HasWork()) {

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

@@ -27,7 +27,7 @@
 
 typedef struct grpc_custom_poller_vtable {
   void (*init)();
-  grpc_error* (*poll)(size_t timeout_ms);
+  grpc_error_handle (*poll)(size_t timeout_ms);
   void (*kick)();
   void (*shutdown)();
 } grpc_custom_poller_vtable;

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

@@ -73,9 +73,9 @@
 #if __GLIBC_PREREQ(2, 10)
 #define GRPC_LINUX_SOCKETUTILS 1
 #endif
-#if !(__GLIBC_PREREQ(2, 17))
+#if !(__GLIBC_PREREQ(2, 18))
 /*
- * TCP_USER_TIMEOUT wasn't imported to glibc until 2.17. Use Linux system
+ * TCP_USER_TIMEOUT wasn't imported to glibc until 2.18. Use Linux system
  * header instead.
  */
 #define GRPC_LINUX_TCP_H 1

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

@@ -24,32 +24,13 @@
 
 namespace grpc_core {
 const char* kDefaultSecurePort = "https";
-}  // namespace grpc_core
-
-grpc_address_resolver_vtable* grpc_resolve_address_impl;
 
-void grpc_set_resolver_impl(grpc_address_resolver_vtable* vtable) {
-  grpc_resolve_address_impl = vtable;
+namespace {
+DNSResolver* g_dns_resolver;
 }
 
-void grpc_resolve_address(const char* addr, const char* default_port,
-                          grpc_pollset_set* interested_parties,
-                          grpc_closure* on_done,
-                          grpc_resolved_addresses** addresses) {
-  grpc_resolve_address_impl->resolve_address(
-      addr, default_port, interested_parties, on_done, addresses);
-}
+void SetDNSResolver(DNSResolver* resolver) { g_dns_resolver = resolver; }
 
-void grpc_resolved_addresses_destroy(grpc_resolved_addresses* addresses) {
-  if (addresses != nullptr) {
-    gpr_free(addresses->addrs);
-  }
-  gpr_free(addresses);
-}
+DNSResolver* GetDNSResolver() { return g_dns_resolver; }
 
-grpc_error_handle grpc_blocking_resolve_address(
-    const char* name, const char* default_port,
-    grpc_resolved_addresses** addresses) {
-  return grpc_resolve_address_impl->blocking_resolve_address(name, default_port,
-                                                             addresses);
-}
+}  // namespace grpc_core

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