grpc 1.83.1 → 1.84.0

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

@@ -1,59 +0,0 @@
-//
-//
-// 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 "src/core/lib/iomgr/resolve_address.h"
-
-#include <grpc/event_engine/event_engine.h>
-#include <grpc/support/alloc.h>
-#include <grpc/support/port_platform.h>
-
-#include "src/core/util/crash.h"
-#include "src/core/util/no_destruct.h"
-#include "absl/strings/str_cat.h"
-
-namespace grpc_core {
-const char* kDefaultSecurePort = "https";
-
-namespace {
-NoDestruct<std::shared_ptr<DNSResolver>> g_dns_resolver;
-}
-
-const DNSResolver::LookupTaskHandle DNSResolver::LookupTaskHandle::kInvalid = {
-    -1, -1};
-const DNSResolver::TaskHandle DNSResolver::kNullHandle = {0, 0};
-
-void ResetDNSResolver(std::shared_ptr<DNSResolver> resolver) {
-  *g_dns_resolver = std::move(resolver);
-}
-
-std::shared_ptr<DNSResolver> GetDNSResolver() { return *g_dns_resolver; }
-
-bool operator==(const DNSResolver::LookupTaskHandle& lhs,
-                const DNSResolver::LookupTaskHandle& rhs) {
-  return lhs.keys[0] == rhs.keys[0] && lhs.keys[1] == rhs.keys[1];
-}
-
-bool operator!=(const DNSResolver::LookupTaskHandle& lhs,
-                const DNSResolver::LookupTaskHandle& rhs) {
-  return !(lhs == rhs);
-}
-
-std::string DNSResolver::HandleToString(TaskHandle handle) {
-  return absl::StrCat("{", handle.keys[0], ",", handle.keys[1], "}");
-}
-
-}  // namespace grpc_core

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

@@ -1,125 +0,0 @@
-//
-//
-// 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_SRC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_H
-#define GRPC_SRC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_H
-
-#include <grpc/event_engine/event_engine.h>
-#include <grpc/support/port_platform.h>
-#include <stddef.h>
-
-#include "src/core/lib/event_engine/handle_containers.h"
-#include "src/core/lib/iomgr/pollset_set.h"
-#include "src/core/lib/iomgr/port.h"
-#include "src/core/lib/iomgr/resolved_address.h"
-#include "src/core/util/orphanable.h"
-#include "src/core/util/time.h"
-#include "absl/container/flat_hash_set.h"
-#include "absl/status/statusor.h"
-
-namespace grpc_core {
-extern const char* kDefaultSecurePort;
-constexpr int kDefaultSecurePortInt = 443;
-constexpr Duration kDefaultDNSRequestTimeout = Duration::Minutes(2);
-
-// A singleton class used for async and blocking DNS resolution
-class DNSResolver {
- public:
-  /// Task handle for DNS Resolution requests.
-  struct LookupTaskHandle {
-    intptr_t keys[2];
-    static const LookupTaskHandle kInvalid;
-    friend bool operator==(const LookupTaskHandle& lhs,
-                           const LookupTaskHandle& rhs);
-    friend bool operator!=(const LookupTaskHandle& lhs,
-                           const LookupTaskHandle& rhs);
-  };
-  using TaskHandle = LookupTaskHandle;
-  using TaskHandleSet = absl::flat_hash_set<
-      TaskHandle,
-      grpc_event_engine::experimental::TaskHandleComparator<TaskHandle>::Hash>;
-
-  static const TaskHandle kNullHandle;
-
-  virtual ~DNSResolver() {}
-
-  static std::string HandleToString(TaskHandle handle);
-
-  // 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 starting the request. Therefore,
-  // implementations must not invoke \a on_done inline from the call site that
-  // starts the request. The DNSCallbackExecCtxScheduler utility may help
-  // address this.
-  //
-  // \a interested_parties may be deleted after a request is cancelled.
-  virtual TaskHandle LookupHostname(
-      std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
-          on_resolved,
-      absl::string_view name, absl::string_view default_port, Duration timeout,
-      grpc_pollset_set* interested_parties, absl::string_view name_server) = 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>>
-  LookupHostnameBlocking(absl::string_view name,
-                         absl::string_view default_port) = 0;
-
-  // Asynchronously resolve an SRV Record to Hostnames.
-  // On completion, \a on_done is invoked with the result.
-  //
-  // The same caveats in \a LookupHostname apply here as well.
-  //
-  // TODO(hork): return std::vector<SRVRecord> and ask the client to do the
-  // subsequent hostname lookups.
-  virtual TaskHandle LookupSRV(
-      std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
-          on_resolved,
-      absl::string_view name, Duration timeout,
-      grpc_pollset_set* interested_parties, absl::string_view name_server) = 0;
-
-  // Asynchronously resolve a TXT Record. On completion, \a on_done is invoked
-  // with the resulting string.
-  //
-  // The same caveats in \a LookupHostname apply here.
-  virtual TaskHandle LookupTXT(
-      std::function<void(absl::StatusOr<std::string>)> on_resolved,
-      absl::string_view name, Duration timeout,
-      grpc_pollset_set* interested_parties, absl::string_view name_server) = 0;
-
-  // This shares the same semantics with \a EventEngine::Cancel: successfully
-  // cancelled lookups will not have their callbacks executed, and this
-  // method returns true. If a TaskHandle is unknown, this method should return
-  // false.
-  virtual bool Cancel(TaskHandle handle) = 0;
-};
-
-// Override the active DNS resolver which should be used for all DNS
-// resolution in gRPC.
-void ResetDNSResolver(std::shared_ptr<DNSResolver> resolver);
-
-// Get the singleton DNS resolver instance which should be used for all
-// DNS resolution in gRPC.
-std::shared_ptr<DNSResolver> GetDNSResolver();
-
-}  // namespace grpc_core
-
-#endif  // GRPC_SRC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_H

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

@@ -1,58 +0,0 @@
-//
-// 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_SRC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_IMPL_H
-#define GRPC_SRC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_IMPL_H
-
-#include <grpc/support/port_platform.h>
-#include <stddef.h>
-
-#include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/port.h"
-#include "src/core/lib/iomgr/resolve_address.h"
-
-namespace grpc_core {
-
-// A fire and forget class 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_, absl::OkStatus());
-  }
-
- 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_SRC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_IMPL_H

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

@@ -1,184 +0,0 @@
-//
-//
-// 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.
-//
-//
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/iomgr/port.h"
-#ifdef GRPC_POSIX_SOCKET_RESOLVE_ADDRESS
-
-#include <grpc/event_engine/event_engine.h>
-#include <grpc/support/alloc.h>
-#include <grpc/support/string_util.h>
-#include <grpc/support/time.h>
-#include <string.h>
-#include <sys/types.h>
-
-#include <atomic>
-#include <functional>
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "src/core/lib/iomgr/block_annotate.h"
-#include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/iomgr/resolve_address_posix.h"
-#include "src/core/lib/iomgr/resolved_address.h"
-#include "src/core/lib/transport/error_utils.h"
-#include "src/core/util/host_port.h"
-#include "src/core/util/time.h"
-#include "src/core/util/useful.h"
-#include "absl/status/status.h"
-#include "absl/status/statusor.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
-namespace grpc_core {
-
-grpc_event_engine::experimental::EventEngine* NativeDNSResolver::engine() {
-  // Optimistically, if the engine is already created, return it.
-  auto engine_ptr = engine_ptr_.load(std::memory_order_relaxed);
-  if (engine_ptr != nullptr) return engine_ptr;
-  // Otherwise, create the engine under the lock.
-  // This is only if some other thread did not already create it.
-  MutexLock lock(&mu_);
-  if (engine_ != nullptr) return engine_.get();
-  engine_ = grpc_event_engine::experimental::GetDefaultEventEngine();
-  engine_ptr_.store(engine_.get(), std::memory_order_relaxed);
-  return engine_.get();
-}
-
-DNSResolver::TaskHandle NativeDNSResolver::LookupHostname(
-    std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
-        on_done,
-    absl::string_view name, absl::string_view default_port,
-    Duration /* timeout */, grpc_pollset_set* /* interested_parties */,
-    absl::string_view /* name_server */) {
-  engine()->Run([on_done = std::move(on_done), name = std::string(name),
-                 default_port = std::string(default_port)]() {
-    ExecCtx exec_ctx;
-    auto result = GetDNSResolver()->LookupHostnameBlocking(name, default_port);
-    on_done(std::move(result));
-  });
-  return kNullHandle;
-}
-
-absl::StatusOr<std::vector<grpc_resolved_address>>
-NativeDNSResolver::LookupHostnameBlocking(absl::string_view name,
-                                          absl::string_view default_port) {
-  ExecCtx exec_ctx;
-  struct addrinfo hints;
-  struct addrinfo *result = nullptr, *resp;
-  int s;
-  size_t i;
-  grpc_error_handle err;
-  std::vector<grpc_resolved_address> addresses;
-  std::string host;
-  std::string port;
-  // parse name, splitting it into host and port parts
-  SplitHostPort(name, &host, &port);
-  if (host.empty()) {
-    err =
-        GRPC_ERROR_CREATE(absl::StrCat("unparsable host:port \"", name, "\""));
-    goto done;
-  }
-  if (port.empty()) {
-    if (default_port.empty()) {
-      err = GRPC_ERROR_CREATE(absl::StrCat("no port in name \"", name, "\""));
-      goto done;
-    }
-    port = std::string(default_port);
-  }
-  // Call getaddrinfo
-  memset(&hints, 0, sizeof(hints));
-  hints.ai_family = AF_UNSPEC;      // ipv4 or ipv6
-  hints.ai_socktype = SOCK_STREAM;  // stream socket
-  hints.ai_flags = AI_PASSIVE;      // for wildcard IP address
-  GRPC_SCHEDULING_START_BLOCKING_REGION;
-  s = getaddrinfo(host.c_str(), port.c_str(), &hints, &result);
-  GRPC_SCHEDULING_END_BLOCKING_REGION;
-  if (s != 0) {
-    // Retry if well-known service name is recognized
-    const char* svc[][2] = {{"http", "80"}, {"https", "443"}};
-    for (i = 0; i < GPR_ARRAY_SIZE(svc); i++) {
-      if (port == svc[i][0]) {
-        GRPC_SCHEDULING_START_BLOCKING_REGION;
-        s = getaddrinfo(host.c_str(), svc[i][1], &hints, &result);
-        GRPC_SCHEDULING_END_BLOCKING_REGION;
-        break;
-      }
-    }
-  }
-  if (s != 0) {
-    err = absl::UnknownError(absl::StrCat(
-        "getaddrinfo(\"", name, "\"): ", gai_strerror(s), " (", s, ")"));
-    goto done;
-  }
-  // Success path: fill in addrs
-  for (resp = result; resp != nullptr; resp = resp->ai_next) {
-    grpc_resolved_address addr;
-    memcpy(&addr.addr, resp->ai_addr, resp->ai_addrlen);
-    addr.len = resp->ai_addrlen;
-    addresses.push_back(addr);
-  }
-  err = absl::OkStatus();
-done:
-  if (result) {
-    freeaddrinfo(result);
-  }
-  if (err.ok()) {
-    return addresses;
-  }
-  auto error_result = grpc_error_to_absl_status(err);
-  return error_result;
-}
-
-DNSResolver::TaskHandle NativeDNSResolver::LookupSRV(
-    std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
-        on_resolved,
-    absl::string_view /* name */, Duration /* timeout */,
-    grpc_pollset_set* /* interested_parties */,
-    absl::string_view /* name_server */) {
-  engine()->Run([on_resolved] {
-    ExecCtx exec_ctx;
-    on_resolved(absl::UnimplementedError(
-        "The Native resolver does not support looking up SRV records"));
-  });
-  return kNullHandle;
-};
-
-DNSResolver::TaskHandle NativeDNSResolver::LookupTXT(
-    std::function<void(absl::StatusOr<std::string>)> on_resolved,
-    absl::string_view /* name */, Duration /* timeout */,
-    grpc_pollset_set* /* interested_parties */,
-    absl::string_view /* name_server */) {
-  // Not supported
-  engine()->Run([on_resolved] {
-    ExecCtx exec_ctx;
-    on_resolved(absl::UnimplementedError(
-        "The Native resolver does not support looking up TXT records"));
-  });
-  return kNullHandle;
-};
-
-bool NativeDNSResolver::Cancel(TaskHandle /*handle*/) { return false; }
-
-}  // namespace grpc_core
-
-#endif

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

@@ -1,78 +0,0 @@
-//
-// 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_SRC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_POSIX_H
-#define GRPC_SRC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_POSIX_H
-
-#include <grpc/support/port_platform.h>
-
-#include <functional>
-#include <memory>
-
-#include "src/core/lib/iomgr/port.h"
-#include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/util/sync.h"
-
-namespace grpc_core {
-
-// A DNS resolver which uses the native platform's getaddrinfo API.
-class NativeDNSResolver : public DNSResolver {
- public:
-  NativeDNSResolver() = default;
-
-  TaskHandle LookupHostname(
-      std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
-          on_done,
-      absl::string_view name, absl::string_view default_port, Duration timeout,
-      grpc_pollset_set* interested_parties,
-      absl::string_view name_server) override;
-
-  absl::StatusOr<std::vector<grpc_resolved_address>> LookupHostnameBlocking(
-      absl::string_view name, absl::string_view default_port) override;
-
-  TaskHandle LookupSRV(
-      std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
-          on_resolved,
-      absl::string_view name, Duration timeout,
-      grpc_pollset_set* interested_parties,
-      absl::string_view name_server) override;
-
-  TaskHandle LookupTXT(
-      std::function<void(absl::StatusOr<std::string>)> on_resolved,
-      absl::string_view name, Duration timeout,
-      grpc_pollset_set* interested_parties,
-      absl::string_view name_server) override;
-
-  // NativeDNSResolver does not support cancellation.
-  bool Cancel(TaskHandle handle) override;
-
- private:
-  // Lazily instantiate and return a pointer to the owned EventEngine.
-  // The engine needs to be lazily instantiated to avoid a mutex reacquisition,
-  // because the NativeDNSResolver is created in grpc_init, and creating an
-  // EventEngine calls grpc_init.
-  grpc_event_engine::experimental::EventEngine* engine();
-
-  Mutex mu_;
-  std::shared_ptr<grpc_event_engine::experimental::EventEngine> engine_
-      ABSL_GUARDED_BY(mu_);
-  std::atomic<grpc_event_engine::experimental::EventEngine*> engine_ptr_{
-      nullptr};
-};
-
-}  // namespace grpc_core
-
-#endif  // GRPC_SRC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_POSIX_H

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

@@ -1,169 +0,0 @@
-//
-// 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.
-//
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/iomgr/port.h"
-#ifdef GRPC_WINSOCK_SOCKET
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log_windows.h>
-#include <grpc/support/string_util.h>
-#include <grpc/support/time.h>
-#include <inttypes.h>
-#include <string.h>
-#include <sys/types.h>
-
-#include <string>
-
-#include "src/core/lib/address_utils/sockaddr_utils.h"
-#include "src/core/lib/event_engine/default_event_engine.h"
-#include "src/core/lib/iomgr/block_annotate.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/iomgr_internal.h"
-#include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/iomgr/resolve_address_windows.h"
-#include "src/core/lib/iomgr/sockaddr.h"
-#include "src/core/lib/transport/error_utils.h"
-#include "src/core/util/crash.h"
-#include "src/core/util/host_port.h"
-#include "src/core/util/string.h"
-#include "src/core/util/thd.h"
-#include "absl/strings/str_format.h"
-
-namespace grpc_core {
-
-grpc_event_engine::experimental::EventEngine* NativeDNSResolver::engine() {
-  // Optimistically, if the engine is already created, return it.
-  auto engine_ptr = engine_ptr_.load(std::memory_order_relaxed);
-  if (engine_ptr != nullptr) return engine_ptr;
-  // Otherwise, create the engine under the lock.
-  // This is only if some other thread did not already create it.
-  MutexLock lock(&mu_);
-  if (engine_ != nullptr) return engine_.get();
-  engine_ = grpc_event_engine::experimental::GetDefaultEventEngine();
-  engine_ptr_.store(engine_.get(), std::memory_order_relaxed);
-  return engine_.get();
-}
-
-DNSResolver::TaskHandle NativeDNSResolver::LookupHostname(
-    std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
-        on_resolved,
-    absl::string_view name, absl::string_view default_port,
-    Duration /* timeout */, grpc_pollset_set* /* interested_parties */,
-    absl::string_view /* name_server */) {
-  engine()->Run([on_resolved = std::move(on_resolved), name = std::string(name),
-                 default_port = std::string(default_port)]() {
-    ExecCtx exec_ctx;
-    auto result = GetDNSResolver()->LookupHostnameBlocking(name, default_port);
-    on_resolved(std::move(result));
-  });
-  return kNullHandle;
-}
-
-absl::StatusOr<std::vector<grpc_resolved_address>>
-NativeDNSResolver::LookupHostnameBlocking(absl::string_view name,
-                                          absl::string_view default_port) {
-  ExecCtx exec_ctx;
-  struct addrinfo hints;
-  struct addrinfo *result = NULL, *resp;
-  int s;
-  grpc_error_handle error;
-  std::vector<grpc_resolved_address> addresses;
-
-  // parse name, splitting it into host and port parts
-  std::string host;
-  std::string port;
-  SplitHostPort(name, &host, &port);
-  if (host.empty()) {
-    error =
-        GRPC_ERROR_CREATE(absl::StrFormat("unparsable host:port: '%s'", name));
-    goto done;
-  }
-  if (port.empty()) {
-    if (default_port.empty()) {
-      error = GRPC_ERROR_CREATE(absl::StrFormat("no port in name '%s'", name));
-      goto done;
-    }
-    port = std::string(default_port);
-  }
-
-  // Call getaddrinfo
-  memset(&hints, 0, sizeof(hints));
-  hints.ai_family = AF_UNSPEC;      // ipv4 or ipv6
-  hints.ai_socktype = SOCK_STREAM;  // stream socket
-  hints.ai_flags = AI_PASSIVE;      // for wildcard IP address
-
-  GRPC_SCHEDULING_START_BLOCKING_REGION;
-  s = getaddrinfo(host.c_str(), port.c_str(), &hints, &result);
-  GRPC_SCHEDULING_END_BLOCKING_REGION;
-  if (s != 0) {
-    error = GRPC_WSA_ERROR(WSAGetLastError(), "getaddrinfo");
-    goto done;
-  }
-
-  // Success path: set addrs non-NULL, fill it in
-  for (resp = result; resp != NULL; resp = resp->ai_next) {
-    grpc_resolved_address addr;
-    memcpy(&addr.addr, resp->ai_addr, resp->ai_addrlen);
-    addr.len = resp->ai_addrlen;
-    addresses.push_back(addr);
-  }
-
-done:
-  if (result) {
-    freeaddrinfo(result);
-  }
-  if (error.ok()) {
-    return addresses;
-  }
-  auto error_result = grpc_error_to_absl_status(error);
-  return error_result;
-}
-
-DNSResolver::TaskHandle NativeDNSResolver::LookupSRV(
-    std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
-        on_resolved,
-    absl::string_view /* name */, Duration /* deadline */,
-    grpc_pollset_set* /* interested_parties */,
-    absl::string_view /* name_server */) {
-  engine()->Run([on_resolved] {
-    ExecCtx exec_ctx;
-    on_resolved(absl::UnimplementedError(
-        "The Native resolver does not support looking up SRV records"));
-  });
-  return kNullHandle;
-};
-
-DNSResolver::TaskHandle NativeDNSResolver::LookupTXT(
-    std::function<void(absl::StatusOr<std::string>)> on_resolved,
-    absl::string_view /* name */, Duration /* timeout */,
-    grpc_pollset_set* /* interested_parties */,
-    absl::string_view /* name_server */) {
-  // Not supported
-  engine()->Run([on_resolved] {
-    ExecCtx exec_ctx;
-    on_resolved(absl::UnimplementedError(
-        "The Native resolver does not support looking up TXT records"));
-  });
-  return kNullHandle;
-};
-
-bool NativeDNSResolver::Cancel(TaskHandle /*handle*/) { return false; }
-
-}  // namespace grpc_core
-
-#endif