grpc 1.54.2 → 1.61.0

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.cc

@@ -19,12 +19,11 @@
 #include <grpc/support/port_platform.h>
 
 #include <algorithm>
-#include <initializer_list>
 #include <vector>
 
 #include "absl/strings/string_view.h"
 
-#include <grpc/grpc.h>
+#include <grpc/impl/channel_arg_names.h>
 
 #include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/iomgr/sockaddr.h"
@@ -73,8 +72,8 @@
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/iomgr/timer.h"
 
-using grpc_core::ServerAddress;
-using grpc_core::ServerAddressList;
+using grpc_core::EndpointAddresses;
+using grpc_core::EndpointAddressesList;
 
 grpc_core::TraceFlag grpc_trace_cares_address_sorting(false,
                                                       "cares_address_sorting");
@@ -366,9 +365,7 @@ static void on_readable(void* arg, grpc_error_handle error) {
   GRPC_CARES_TRACE_LOG("request:%p readable on %s", fdn->ev_driver->request,
                        fdn->grpc_polled_fd->GetName());
   if (error.ok() && !ev_driver->shutting_down) {
-    do {
-      ares_process_fd(ev_driver->channel, as, ARES_SOCKET_BAD);
-    } while (fdn->grpc_polled_fd->IsFdStillReadableLocked());
+    ares_process_fd(ev_driver->channel, as, ARES_SOCKET_BAD);
   } else {
     // If error is not absl::OkStatus() or the resolution was cancelled, it
     // means the fd has been shutdown or timed out. The pending lookups made on
@@ -438,12 +435,21 @@ static void grpc_ares_notify_on_event_locked(grpc_ares_ev_driver* ev_driver)
         if (ARES_GETSOCK_READABLE(socks_bitmask, i) &&
             !fdn->readable_registered) {
           grpc_ares_ev_driver_ref(ev_driver);
-          GRPC_CARES_TRACE_LOG("request:%p notify read on: %s",
-                               ev_driver->request,
-                               fdn->grpc_polled_fd->GetName());
           GRPC_CLOSURE_INIT(&fdn->read_closure, on_readable, fdn,
                             grpc_schedule_on_exec_ctx);
-          fdn->grpc_polled_fd->RegisterForOnReadableLocked(&fdn->read_closure);
+          if (fdn->grpc_polled_fd->IsFdStillReadableLocked()) {
+            GRPC_CARES_TRACE_LOG("request:%p schedule direct read on: %s",
+                                 ev_driver->request,
+                                 fdn->grpc_polled_fd->GetName());
+            grpc_core::ExecCtx::Run(DEBUG_LOCATION, &fdn->read_closure,
+                                    absl::OkStatus());
+          } else {
+            GRPC_CARES_TRACE_LOG("request:%p notify read on: %s",
+                                 ev_driver->request,
+                                 fdn->grpc_polled_fd->GetName());
+            fdn->grpc_polled_fd->RegisterForOnReadableLocked(
+                &fdn->read_closure);
+          }
           fdn->readable_registered = true;
         }
         // Register write_closure if the socket is writable and write_closure
@@ -510,11 +516,13 @@ void grpc_ares_ev_driver_start_locked(grpc_ares_ev_driver* ev_driver)
                   &ev_driver->on_ares_backup_poll_alarm_locked);
 }
 
-static void noop_inject_channel_config(ares_channel /*channel*/) {}
+static void noop_inject_channel_config(ares_channel* /*channel*/) {}
 
-void (*grpc_ares_test_only_inject_config)(ares_channel channel) =
+void (*grpc_ares_test_only_inject_config)(ares_channel* channel) =
     noop_inject_channel_config;
 
+bool g_grpc_ares_test_only_force_tcp = false;
+
 grpc_error_handle grpc_ares_ev_driver_create_locked(
     grpc_ares_ev_driver** ev_driver, grpc_pollset_set* pollset_set,
     int query_timeout_ms, grpc_ares_request* request)
@@ -523,8 +531,11 @@ grpc_error_handle grpc_ares_ev_driver_create_locked(
   ares_options opts;
   memset(&opts, 0, sizeof(opts));
   opts.flags |= ARES_FLAG_STAYOPEN;
+  if (g_grpc_ares_test_only_force_tcp) {
+    opts.flags |= ARES_FLAG_USEVC;
+  }
   int status = ares_init_options(&(*ev_driver)->channel, &opts, ARES_OPT_FLAGS);
-  grpc_ares_test_only_inject_config((*ev_driver)->channel);
+  grpc_ares_test_only_inject_config(&(*ev_driver)->channel);
   GRPC_CARES_TRACE_LOG("request:%p grpc_ares_ev_driver_create_locked", request);
   if (status != ARES_SUCCESS) {
     grpc_error_handle err = GRPC_ERROR_CREATE(absl::StrCat(
@@ -545,7 +556,7 @@ grpc_error_handle grpc_ares_ev_driver_create_locked(
 }
 
 static void log_address_sorting_list(const grpc_ares_request* r,
-                                     const ServerAddressList& addresses,
+                                     const EndpointAddressesList& addresses,
                                      const char* input_output_str) {
   for (size_t i = 0; i < addresses.size(); i++) {
     auto addr_str = grpc_sockaddr_to_string(&addresses[i].address(), true);
@@ -559,7 +570,7 @@ static void log_address_sorting_list(const grpc_ares_request* r,
 }
 
 void grpc_cares_wrapper_address_sorting_sort(const grpc_ares_request* r,
-                                             ServerAddressList* addresses) {
+                                             EndpointAddressesList* addresses) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_cares_address_sorting)) {
     log_address_sorting_list(r, *addresses, "input");
   }
@@ -572,10 +583,11 @@ void grpc_cares_wrapper_address_sorting_sort(const grpc_ares_request* r,
     sortables[i].dest_addr.len = (*addresses)[i].address().len;
   }
   address_sorting_rfc_6724_sort(sortables, addresses->size());
-  ServerAddressList sorted;
+  EndpointAddressesList sorted;
   sorted.reserve(addresses->size());
   for (size_t i = 0; i < addresses->size(); ++i) {
-    sorted.emplace_back(*static_cast<ServerAddress*>(sortables[i].user_data));
+    sorted.emplace_back(
+        *static_cast<EndpointAddresses*>(sortables[i].user_data));
   }
   gpr_free(sortables);
   *addresses = std::move(sorted);
@@ -608,7 +620,8 @@ void grpc_ares_complete_request_locked(grpc_ares_request* r)
     // with no addresses along side it
   }
   if (r->balancer_addresses_out != nullptr) {
-    ServerAddressList* balancer_addresses = r->balancer_addresses_out->get();
+    EndpointAddressesList* balancer_addresses =
+        r->balancer_addresses_out->get();
     if (balancer_addresses != nullptr) {
       grpc_cares_wrapper_address_sorting_sort(r, balancer_addresses);
     }
@@ -655,46 +668,44 @@ static void on_hostbyname_done_locked(void* arg, int status, int /*timeouts*/,
     GRPC_CARES_TRACE_LOG(
         "request:%p on_hostbyname_done_locked qtype=%s host=%s ARES_SUCCESS", r,
         hr->qtype, hr->host);
-    std::unique_ptr<ServerAddressList>* address_list_ptr =
+    std::unique_ptr<EndpointAddressesList>* address_list_ptr =
         hr->is_balancer ? r->balancer_addresses_out : r->addresses_out;
     if (*address_list_ptr == nullptr) {
-      *address_list_ptr = std::make_unique<ServerAddressList>();
+      *address_list_ptr = std::make_unique<EndpointAddressesList>();
     }
-    ServerAddressList& addresses = **address_list_ptr;
+    EndpointAddressesList& addresses = **address_list_ptr;
     for (size_t i = 0; hostent->h_addr_list[i] != nullptr; ++i) {
       grpc_core::ChannelArgs args;
       if (hr->is_balancer) {
         args = args.Set(GRPC_ARG_DEFAULT_AUTHORITY, hr->host);
       }
+      grpc_resolved_address address;
+      memset(&address, 0, sizeof(address));
       switch (hostent->h_addrtype) {
         case AF_INET6: {
-          size_t addr_len = sizeof(struct sockaddr_in6);
-          struct sockaddr_in6 addr;
-          memset(&addr, 0, addr_len);
-          memcpy(&addr.sin6_addr, hostent->h_addr_list[i],
+          address.len = sizeof(struct sockaddr_in6);
+          auto* addr = reinterpret_cast<struct sockaddr_in6*>(&address.addr);
+          memcpy(&addr->sin6_addr, hostent->h_addr_list[i],
                  sizeof(struct in6_addr));
-          addr.sin6_family = static_cast<unsigned char>(hostent->h_addrtype);
-          addr.sin6_port = hr->port;
-          addresses.emplace_back(&addr, addr_len, args);
+          addr->sin6_family = static_cast<unsigned char>(hostent->h_addrtype);
+          addr->sin6_port = hr->port;
           char output[INET6_ADDRSTRLEN];
-          ares_inet_ntop(AF_INET6, &addr.sin6_addr, output, INET6_ADDRSTRLEN);
+          ares_inet_ntop(AF_INET6, &addr->sin6_addr, output, INET6_ADDRSTRLEN);
           GRPC_CARES_TRACE_LOG(
               "request:%p c-ares resolver gets a AF_INET6 result: \n"
               "  addr: %s\n  port: %d\n  sin6_scope_id: %d\n",
-              r, output, ntohs(hr->port), addr.sin6_scope_id);
+              r, output, ntohs(hr->port), addr->sin6_scope_id);
           break;
         }
         case AF_INET: {
-          size_t addr_len = sizeof(struct sockaddr_in);
-          struct sockaddr_in addr;
-          memset(&addr, 0, addr_len);
-          memcpy(&addr.sin_addr, hostent->h_addr_list[i],
+          address.len = sizeof(struct sockaddr_in);
+          auto* addr = reinterpret_cast<struct sockaddr_in*>(&address.addr);
+          memcpy(&addr->sin_addr, hostent->h_addr_list[i],
                  sizeof(struct in_addr));
-          addr.sin_family = static_cast<unsigned char>(hostent->h_addrtype);
-          addr.sin_port = hr->port;
-          addresses.emplace_back(&addr, addr_len, args);
+          addr->sin_family = static_cast<unsigned char>(hostent->h_addrtype);
+          addr->sin_port = hr->port;
           char output[INET_ADDRSTRLEN];
-          ares_inet_ntop(AF_INET, &addr.sin_addr, output, INET_ADDRSTRLEN);
+          ares_inet_ntop(AF_INET, &addr->sin_addr, output, INET_ADDRSTRLEN);
           GRPC_CARES_TRACE_LOG(
               "request:%p c-ares resolver gets a AF_INET result: \n"
               "  addr: %s\n  port: %d\n",
@@ -702,6 +713,7 @@ static void on_hostbyname_done_locked(void* arg, int status, int /*timeouts*/,
           break;
         }
       }
+      addresses.emplace_back(address, args);
     }
   } else {
     std::string error_msg = absl::StrFormat(
@@ -893,7 +905,7 @@ grpc_error_handle grpc_dns_lookup_ares_continued(
 
 static bool inner_resolve_as_ip_literal_locked(
     const char* name, const char* default_port,
-    std::unique_ptr<grpc_core::ServerAddressList>* addrs, std::string* host,
+    std::unique_ptr<grpc_core::EndpointAddressesList>* addrs, std::string* host,
     std::string* port, std::string* hostport) {
   if (!grpc_core::SplitHostPort(name, host, port)) {
     gpr_log(GPR_ERROR,
@@ -919,8 +931,8 @@ static bool inner_resolve_as_ip_literal_locked(
       grpc_parse_ipv6_hostport(hostport->c_str(), &addr,
                                false /* log errors */)) {
     GPR_ASSERT(*addrs == nullptr);
-    *addrs = std::make_unique<ServerAddressList>();
-    (*addrs)->emplace_back(addr.addr, addr.len, grpc_core::ChannelArgs());
+    *addrs = std::make_unique<EndpointAddressesList>();
+    (*addrs)->emplace_back(addr, grpc_core::ChannelArgs());
     return true;
   }
   return false;
@@ -928,7 +940,7 @@ static bool inner_resolve_as_ip_literal_locked(
 
 static bool resolve_as_ip_literal_locked(
     const char* name, const char* default_port,
-    std::unique_ptr<grpc_core::ServerAddressList>* addrs) {
+    std::unique_ptr<grpc_core::EndpointAddressesList>* addrs) {
   std::string host;
   std::string port;
   std::string hostport;
@@ -955,7 +967,7 @@ static bool target_matches_localhost(const char* name) {
 #ifdef GRPC_ARES_RESOLVE_LOCALHOST_MANUALLY
 static bool inner_maybe_resolve_localhost_manually_locked(
     const grpc_ares_request* r, const char* name, const char* default_port,
-    std::unique_ptr<grpc_core::ServerAddressList>* addrs, std::string* host,
+    std::unique_ptr<grpc_core::EndpointAddressesList>* addrs, std::string* host,
     std::string* port) {
   grpc_core::SplitHostPort(name, host, port);
   if (host->empty()) {
@@ -977,25 +989,28 @@ static bool inner_maybe_resolve_localhost_manually_locked(
   }
   if (gpr_stricmp(host->c_str(), "localhost") == 0) {
     GPR_ASSERT(*addrs == nullptr);
-    *addrs = std::make_unique<grpc_core::ServerAddressList>();
+    *addrs = std::make_unique<grpc_core::EndpointAddressesList>();
     uint16_t numeric_port = grpc_strhtons(port->c_str());
+    grpc_resolved_address address;
     // Append the ipv6 loopback address.
-    struct sockaddr_in6 ipv6_loopback_addr;
-    memset(&ipv6_loopback_addr, 0, sizeof(ipv6_loopback_addr));
-    ((char*)&ipv6_loopback_addr.sin6_addr)[15] = 1;
-    ipv6_loopback_addr.sin6_family = AF_INET6;
-    ipv6_loopback_addr.sin6_port = numeric_port;
-    (*addrs)->emplace_back(&ipv6_loopback_addr, sizeof(ipv6_loopback_addr),
-                           grpc_core::ChannelArgs() /* args */);
+    memset(&address, 0, sizeof(address));
+    auto* ipv6_loopback_addr =
+        reinterpret_cast<struct sockaddr_in6*>(&address.addr);
+    ((char*)&ipv6_loopback_addr->sin6_addr)[15] = 1;
+    ipv6_loopback_addr->sin6_family = AF_INET6;
+    ipv6_loopback_addr->sin6_port = numeric_port;
+    address.len = sizeof(struct sockaddr_in6);
+    (*addrs)->emplace_back(address, grpc_core::ChannelArgs());
     // Append the ipv4 loopback address.
-    struct sockaddr_in ipv4_loopback_addr;
-    memset(&ipv4_loopback_addr, 0, sizeof(ipv4_loopback_addr));
-    ((char*)&ipv4_loopback_addr.sin_addr)[0] = 0x7f;
-    ((char*)&ipv4_loopback_addr.sin_addr)[3] = 0x01;
-    ipv4_loopback_addr.sin_family = AF_INET;
-    ipv4_loopback_addr.sin_port = numeric_port;
-    (*addrs)->emplace_back(&ipv4_loopback_addr, sizeof(ipv4_loopback_addr),
-                           grpc_core::ChannelArgs() /* args */);
+    memset(&address, 0, sizeof(address));
+    auto* ipv4_loopback_addr =
+        reinterpret_cast<struct sockaddr_in*>(&address.addr);
+    ((char*)&ipv4_loopback_addr->sin_addr)[0] = 0x7f;
+    ((char*)&ipv4_loopback_addr->sin_addr)[3] = 0x01;
+    ipv4_loopback_addr->sin_family = AF_INET;
+    ipv4_loopback_addr->sin_port = numeric_port;
+    address.len = sizeof(struct sockaddr_in);
+    (*addrs)->emplace_back(address, grpc_core::ChannelArgs());
     // Let the address sorter figure out which one should be tried first.
     grpc_cares_wrapper_address_sorting_sort(r, addrs->get());
     return true;
@@ -1005,7 +1020,7 @@ static bool inner_maybe_resolve_localhost_manually_locked(
 
 static bool grpc_ares_maybe_resolve_localhost_manually_locked(
     const grpc_ares_request* r, const char* name, const char* default_port,
-    std::unique_ptr<grpc_core::ServerAddressList>* addrs) {
+    std::unique_ptr<grpc_core::EndpointAddressesList>* addrs) {
   std::string host;
   std::string port;
   return inner_maybe_resolve_localhost_manually_locked(r, name, default_port,
@@ -1015,7 +1030,7 @@ static bool grpc_ares_maybe_resolve_localhost_manually_locked(
 static bool grpc_ares_maybe_resolve_localhost_manually_locked(
     const grpc_ares_request* /*r*/, const char* /*name*/,
     const char* /*default_port*/,
-    std::unique_ptr<grpc_core::ServerAddressList>* /*addrs*/) {
+    std::unique_ptr<grpc_core::EndpointAddressesList>* /*addrs*/) {
   return false;
 }
 #endif  // GRPC_ARES_RESOLVE_LOCALHOST_MANUALLY
@@ -1023,7 +1038,7 @@ static bool grpc_ares_maybe_resolve_localhost_manually_locked(
 static grpc_ares_request* grpc_dns_lookup_hostname_ares_impl(
     const char* dns_server, const char* name, const char* default_port,
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
-    std::unique_ptr<grpc_core::ServerAddressList>* addrs,
+    std::unique_ptr<grpc_core::EndpointAddressesList>* addrs,
     int query_timeout_ms) {
   grpc_ares_request* r = new grpc_ares_request();
   grpc_core::MutexLock lock(&r->mu);
@@ -1077,7 +1092,7 @@ static grpc_ares_request* grpc_dns_lookup_hostname_ares_impl(
 grpc_ares_request* grpc_dns_lookup_srv_ares_impl(
     const char* dns_server, const char* name,
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
-    std::unique_ptr<grpc_core::ServerAddressList>* balancer_addresses,
+    std::unique_ptr<grpc_core::EndpointAddressesList>* balancer_addresses,
     int query_timeout_ms) {
   grpc_ares_request* r = new grpc_ares_request();
   grpc_core::MutexLock lock(&r->mu);
@@ -1154,13 +1169,13 @@ grpc_ares_request* grpc_dns_lookup_txt_ares_impl(
 grpc_ares_request* (*grpc_dns_lookup_hostname_ares)(
     const char* dns_server, const char* name, const char* default_port,
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
-    std::unique_ptr<grpc_core::ServerAddressList>* addrs,
+    std::unique_ptr<grpc_core::EndpointAddressesList>* addrs,
     int query_timeout_ms) = grpc_dns_lookup_hostname_ares_impl;
 
 grpc_ares_request* (*grpc_dns_lookup_srv_ares)(
     const char* dns_server, const char* name,
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
-    std::unique_ptr<grpc_core::ServerAddressList>* balancer_addresses,
+    std::unique_ptr<grpc_core::EndpointAddressesList>* balancer_addresses,
     int query_timeout_ms) = grpc_dns_lookup_srv_ares_impl;
 
 grpc_ares_request* (*grpc_dns_lookup_txt_ares)(

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.h

@@ -36,7 +36,7 @@
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
-#include "src/core/lib/resolver/server_address.h"
+#include "src/core/lib/resolver/endpoint_addresses.h"
 
 #define GRPC_DNS_ARES_DEFAULT_QUERY_TIMEOUT_MS 120000
 
@@ -63,10 +63,10 @@ struct grpc_ares_request {
   /// closure to call when the request completes
   grpc_closure* on_done ABSL_GUARDED_BY(mu) = nullptr;
   /// the pointer to receive the resolved addresses
-  std::unique_ptr<grpc_core::ServerAddressList>* addresses_out
+  std::unique_ptr<grpc_core::EndpointAddressesList>* addresses_out
       ABSL_GUARDED_BY(mu);
   /// the pointer to receive the resolved balancer addresses
-  std::unique_ptr<grpc_core::ServerAddressList>* balancer_addresses_out
+  std::unique_ptr<grpc_core::EndpointAddressesList>* balancer_addresses_out
       ABSL_GUARDED_BY(mu);
   /// the pointer to receive the service config in JSON
   char** service_config_json_out ABSL_GUARDED_BY(mu) = nullptr;
@@ -92,7 +92,7 @@ struct grpc_ares_request {
 extern grpc_ares_request* (*grpc_dns_lookup_hostname_ares)(
     const char* dns_server, const char* name, const char* default_port,
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
-    std::unique_ptr<grpc_core::ServerAddressList>* addresses,
+    std::unique_ptr<grpc_core::EndpointAddressesList>* addresses,
     int query_timeout_ms);
 
 // Asynchronously resolve a SRV record.
@@ -100,7 +100,7 @@ extern grpc_ares_request* (*grpc_dns_lookup_hostname_ares)(
 extern grpc_ares_request* (*grpc_dns_lookup_srv_ares)(
     const char* dns_server, const char* name,
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
-    std::unique_ptr<grpc_core::ServerAddressList>* balancer_addresses,
+    std::unique_ptr<grpc_core::EndpointAddressesList>* balancer_addresses,
     int query_timeout_ms);
 
 // Asynchronously resolve a TXT record.
@@ -128,9 +128,13 @@ bool grpc_ares_query_ipv6();
 
 // Sorts destinations in lb_addrs according to RFC 6724.
 void grpc_cares_wrapper_address_sorting_sort(
-    const grpc_ares_request* request, grpc_core::ServerAddressList* addresses);
+    const grpc_ares_request* request,
+    grpc_core::EndpointAddressesList* addresses);
 
 // Exposed in this header for C-core tests only
-extern void (*grpc_ares_test_only_inject_config)(ares_channel channel);
+extern void (*grpc_ares_test_only_inject_config)(ares_channel* channel);
+
+// Exposed in this header for C-core tests only
+extern bool g_grpc_ares_test_only_force_tcp;
 
 #endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_C_ARES_GRPC_ARES_WRAPPER_H

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper_windows.cc

@@ -28,7 +28,7 @@
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/socket_windows.h"
-#include "src/core/lib/resolver/server_address.h"
+#include "src/core/lib/resolver/endpoint_addresses.h"
 
 bool grpc_ares_query_ipv6() { return grpc_ipv6_loopback_available(); }
 

data/src/core/ext/filters/client_channel/resolver/dns/dns_resolver_plugin.cc

@@ -0,0 +1,66 @@
+// Copyright 2022 The 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/client_channel/resolver/dns/dns_resolver_plugin.h"
+
+#include <memory>
+
+#include "absl/strings/match.h"
+
+#include <grpc/support/log.h>
+
+#include "src/core/ext/filters/client_channel/resolver/dns/c_ares/dns_resolver_ares.h"
+#include "src/core/ext/filters/client_channel/resolver/dns/event_engine/event_engine_client_channel_resolver.h"
+#include "src/core/ext/filters/client_channel/resolver/dns/native/dns_resolver.h"
+#include "src/core/lib/config/config_vars.h"
+#include "src/core/lib/experiments/experiments.h"
+#include "src/core/lib/gprpp/crash.h"
+#include "src/core/lib/resolver/resolver_factory.h"
+
+namespace grpc_core {
+
+void RegisterDnsResolver(CoreConfiguration::Builder* builder) {
+#ifdef GRPC_IOS_EVENT_ENGINE_CLIENT
+  gpr_log(GPR_DEBUG, "Using EventEngine dns resolver");
+  builder->resolver_registry()->RegisterResolverFactory(
+      std::make_unique<EventEngineClientChannelDNSResolverFactory>());
+  return;
+#endif
+  if (IsEventEngineDnsEnabled()) {
+    gpr_log(GPR_DEBUG, "Using EventEngine dns resolver");
+    builder->resolver_registry()->RegisterResolverFactory(
+        std::make_unique<EventEngineClientChannelDNSResolverFactory>());
+    return;
+  }
+  auto resolver = ConfigVars::Get().DnsResolver();
+  // ---- Ares resolver ----
+  if (ShouldUseAresDnsResolver(resolver)) {
+    gpr_log(GPR_DEBUG, "Using ares dns resolver");
+    RegisterAresDnsResolver(builder);
+    return;
+  }
+  // ---- Native resolver ----
+  if (absl::EqualsIgnoreCase(resolver, "native") ||
+      !builder->resolver_registry()->HasResolverFactory("dns")) {
+    gpr_log(GPR_DEBUG, "Using native dns resolver");
+    RegisterNativeDnsResolver(builder);
+    return;
+  }
+  Crash(
+      "Unable to set DNS resolver! Likely a logic error in gRPC-core, "
+      "please file a bug.");
+}
+
+}  // namespace grpc_core

data/src/core/ext/filters/client_channel/resolver/dns/dns_resolver_plugin.h

@@ -0,0 +1,27 @@
+// Copyright 2022 The 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_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_DNS_RESOLVER_PLUGIN_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_DNS_RESOLVER_PLUGIN_H
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/config/core_configuration.h"
+
+namespace grpc_core {
+
+// Centralized decision logic about which client channel DNS resolver to enable.
+void RegisterDnsResolver(CoreConfiguration::Builder* builder);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_DNS_RESOLVER_PLUGIN_H