grpc 1.47.0-x86_64-linux → 1.49.0.pre1-x86_64-linux

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

@@ -435,7 +435,7 @@ class GrpcPolledFdWindows {
     GPR_ASSERT(!connect_done_);
     connect_done_ = true;
     GPR_ASSERT(wsa_connect_error_ == 0);
-    if (error == GRPC_ERROR_NONE) {
+    if (GRPC_ERROR_IS_NONE(error)) {
       DWORD transferred_bytes = 0;
       DWORD flags;
       BOOL wsa_success =
@@ -579,7 +579,7 @@ class GrpcPolledFdWindows {
   // the entire resolution attempt. Doing so will allow the "inject broken
   // nameserver list" test to pass on Windows.
   void OnIocpReadableLocked(grpc_error_handle error) {
-    if (error == GRPC_ERROR_NONE) {
+    if (GRPC_ERROR_IS_NONE(error)) {
       if (winsocket_->read_info.wsa_error != 0) {
         /* WSAEMSGSIZE would be due to receiving more data
          * than our read buffer's fixed capacity. Assume that
@@ -596,7 +596,7 @@ class GrpcPolledFdWindows {
         }
       }
     }
-    if (error == GRPC_ERROR_NONE) {
+    if (GRPC_ERROR_IS_NONE(error)) {
       read_buf_ = grpc_slice_sub_no_ref(
           read_buf_, 0, winsocket_->read_info.bytes_transferred);
       read_buf_has_data_ = true;
@@ -620,7 +620,7 @@ class GrpcPolledFdWindows {
   void OnIocpWriteableLocked(grpc_error_handle error) {
     GRPC_CARES_TRACE_LOG("OnIocpWriteableInner. fd:|%s|", GetName());
     GPR_ASSERT(socket_type_ == SOCK_STREAM);
-    if (error == GRPC_ERROR_NONE) {
+    if (GRPC_ERROR_IS_NONE(error)) {
       if (winsocket_->write_info.wsa_error != 0) {
         error = GRPC_WSA_ERROR(winsocket_->write_info.wsa_error,
                                "OnIocpWriteableInner");
@@ -632,7 +632,7 @@ class GrpcPolledFdWindows {
       }
     }
     GPR_ASSERT(tcp_write_state_ == WRITE_PENDING);
-    if (error == GRPC_ERROR_NONE) {
+    if (GRPC_ERROR_IS_NONE(error)) {
       tcp_write_state_ = WRITE_WAITING_FOR_VERIFICATION_UPON_RETRY;
       write_buf_ = grpc_slice_sub_no_ref(
           write_buf_, 0, winsocket_->write_info.bytes_transferred);

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

@@ -18,6 +18,13 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <algorithm>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+
+#include "src/core/lib/iomgr/sockaddr.h"
+
 // IWYU pragma: no_include <arpa/nameser.h>
 // IWYU pragma: no_include <inttypes.h>
 // IWYU pragma: no_include <netdb.h>
@@ -36,7 +43,6 @@
 #include <address_sorting/address_sorting.h>
 #include <ares.h>
 
-#include "absl/container/inlined_vector.h"
 #include "absl/memory/memory.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
@@ -289,7 +295,7 @@ static void on_timeout(void* arg, grpc_error_handle error) {
       "err=%s",
       driver->request, driver, driver->shutting_down,
       grpc_error_std_string(error).c_str());
-  if (!driver->shutting_down && error == GRPC_ERROR_NONE) {
+  if (!driver->shutting_down && GRPC_ERROR_IS_NONE(error)) {
     grpc_ares_ev_driver_shutdown_locked(driver);
   }
   grpc_ares_ev_driver_unref(driver);
@@ -315,7 +321,7 @@ static void on_ares_backup_poll_alarm(void* arg, grpc_error_handle error) {
       "err=%s",
       driver->request, driver, driver->shutting_down,
       grpc_error_std_string(error).c_str());
-  if (!driver->shutting_down && error == GRPC_ERROR_NONE) {
+  if (!driver->shutting_down && GRPC_ERROR_IS_NONE(error)) {
     fd_node* fdn = driver->fds;
     while (fdn != nullptr) {
       if (!fdn->already_shutdown) {
@@ -357,7 +363,7 @@ static void on_readable(void* arg, grpc_error_handle error) {
   fdn->readable_registered = false;
   GRPC_CARES_TRACE_LOG("request:%p readable on %s", fdn->ev_driver->request,
                        fdn->grpc_polled_fd->GetName());
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     do {
       ares_process_fd(ev_driver->channel, as, ARES_SOCKET_BAD);
     } while (fdn->grpc_polled_fd->IsFdStillReadableLocked());
@@ -383,7 +389,7 @@ static void on_writable(void* arg, grpc_error_handle error) {
   fdn->writable_registered = false;
   GRPC_CARES_TRACE_LOG("request:%p writable on %s", ev_driver->request,
                        fdn->grpc_polled_fd->GetName());
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     ares_process_fd(ev_driver->channel, ARES_SOCKET_BAD, as);
   } else {
     // If error is not GRPC_ERROR_NONE, it means the fd has been shutdown or
@@ -593,12 +599,10 @@ static void grpc_ares_request_unref_locked(grpc_ares_request* r)
 
 void grpc_ares_complete_request_locked(grpc_ares_request* r)
     ABSL_EXCLUSIVE_LOCKS_REQUIRED(r->mu) {
-  /* Invoke on_done callback and destroy the
-     request */
+  // Invoke on_done callback and destroy the request
   r->ev_driver = nullptr;
-  ServerAddressList* addresses = r->addresses_out->get();
-  if (addresses != nullptr) {
-    grpc_cares_wrapper_address_sorting_sort(r, addresses);
+  if (r->addresses_out != nullptr && *r->addresses_out != nullptr) {
+    grpc_cares_wrapper_address_sorting_sort(r, r->addresses_out->get());
     GRPC_ERROR_UNREF(r->error);
     r->error = GRPC_ERROR_NONE;
     // TODO(apolcyn): allow c-ares to return a service config
@@ -659,13 +663,10 @@ static void on_hostbyname_done_locked(void* arg, int status, int /*timeouts*/,
     }
     ServerAddressList& addresses = **address_list_ptr;
     for (size_t i = 0; hostent->h_addr_list[i] != nullptr; ++i) {
-      absl::InlinedVector<grpc_arg, 1> args_to_add;
+      grpc_core::ChannelArgs args;
       if (hr->is_balancer) {
-        args_to_add.emplace_back(grpc_channel_arg_string_create(
-            const_cast<char*>(GRPC_ARG_DEFAULT_AUTHORITY), hr->host));
+        args = args.Set(GRPC_ARG_DEFAULT_AUTHORITY, hr->host);
       }
-      grpc_channel_args* args = grpc_channel_args_copy_and_add(
-          nullptr, args_to_add.data(), args_to_add.size());
       switch (hostent->h_addrtype) {
         case AF_INET6: {
           size_t addr_len = sizeof(struct sockaddr_in6);
@@ -811,6 +812,7 @@ static void on_txt_done_locked(void* arg, int status, int /*timeouts*/,
   }
   // Clean up.
   ares_free_data(reply);
+  grpc_ares_request_unref_locked(r);
   return;
 fail:
   std::string error_msg =
@@ -822,38 +824,14 @@ fail:
   r->error = grpc_error_add_child(error, r->error);
 }
 
-void grpc_dns_lookup_ares_continue_after_check_localhost_and_ip_literals_locked(
-    grpc_ares_request* r, const char* dns_server, const char* name,
-    const char* default_port, grpc_pollset_set* interested_parties,
-    int query_timeout_ms) ABSL_EXCLUSIVE_LOCKS_REQUIRED(r->mu) {
-  grpc_error_handle error = GRPC_ERROR_NONE;
-  grpc_ares_hostbyname_request* hr = nullptr;
-  /* parse name, splitting it into host and port parts */
-  std::string host;
-  std::string port;
-  grpc_core::SplitHostPort(name, &host, &port);
-  if (host.empty()) {
-    error = grpc_error_set_str(
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("unparseable host:port"),
-        GRPC_ERROR_STR_TARGET_ADDRESS, name);
-    goto error_cleanup;
-  } else if (port.empty()) {
-    if (default_port == nullptr || strlen(default_port) == 0) {
-      error = grpc_error_set_str(
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("no port in name"),
-          GRPC_ERROR_STR_TARGET_ADDRESS, name);
-      goto error_cleanup;
-    }
-    port = default_port;
-  }
-  error = grpc_ares_ev_driver_create_locked(&r->ev_driver, interested_parties,
-                                            query_timeout_ms, r);
-  if (error != GRPC_ERROR_NONE) goto error_cleanup;
-  // If dns_server is specified, use it.
-  if (dns_server != nullptr && dns_server[0] != '\0') {
-    GRPC_CARES_TRACE_LOG("request:%p Using DNS server %s", r, dns_server);
+grpc_error_handle set_request_dns_server(grpc_ares_request* r,
+                                         absl::string_view dns_server)
+    ABSL_EXCLUSIVE_LOCKS_REQUIRED(r->mu) {
+  if (!dns_server.empty()) {
+    GRPC_CARES_TRACE_LOG("request:%p Using DNS server %s", r,
+                         dns_server.data());
     grpc_resolved_address addr;
-    if (grpc_parse_ipv4_hostport(dns_server, &addr, false /* log_errors */)) {
+    if (grpc_parse_ipv4_hostport(dns_server, &addr, /*log_errors=*/false)) {
       r->dns_server_addr.family = AF_INET;
       struct sockaddr_in* in = reinterpret_cast<struct sockaddr_in*>(addr.addr);
       memcpy(&r->dns_server_addr.addr.addr4, &in->sin_addr,
@@ -861,7 +839,7 @@ void grpc_dns_lookup_ares_continue_after_check_localhost_and_ip_literals_locked(
       r->dns_server_addr.tcp_port = grpc_sockaddr_get_port(&addr);
       r->dns_server_addr.udp_port = grpc_sockaddr_get_port(&addr);
     } else if (grpc_parse_ipv6_hostport(dns_server, &addr,
-                                        false /* log_errors */)) {
+                                        /*log_errors=*/false)) {
       r->dns_server_addr.family = AF_INET6;
       struct sockaddr_in6* in6 =
           reinterpret_cast<struct sockaddr_in6*>(addr.addr);
@@ -870,51 +848,49 @@ void grpc_dns_lookup_ares_continue_after_check_localhost_and_ip_literals_locked(
       r->dns_server_addr.tcp_port = grpc_sockaddr_get_port(&addr);
       r->dns_server_addr.udp_port = grpc_sockaddr_get_port(&addr);
     } else {
-      error = grpc_error_set_str(
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("cannot parse authority"),
-          GRPC_ERROR_STR_TARGET_ADDRESS, name);
-      goto error_cleanup;
+      return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+          absl::StrCat("cannot parse authority ", dns_server));
     }
     int status =
         ares_set_servers_ports(r->ev_driver->channel, &r->dns_server_addr);
     if (status != ARES_SUCCESS) {
-      error = GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+      return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
           "C-ares status is not ARES_SUCCESS: ", ares_strerror(status)));
-      goto error_cleanup;
     }
   }
-  r->pending_queries = 1;
-  if (grpc_ares_query_ipv6()) {
-    hr = create_hostbyname_request_locked(r, host.c_str(),
-                                          grpc_strhtons(port.c_str()),
-                                          /*is_balancer=*/false, "AAAA");
-    ares_gethostbyname(r->ev_driver->channel, hr->host, AF_INET6,
-                       on_hostbyname_done_locked, hr);
-  }
-  hr = create_hostbyname_request_locked(r, host.c_str(),
-                                        grpc_strhtons(port.c_str()),
-                                        /*is_balancer=*/false, "A");
-  ares_gethostbyname(r->ev_driver->channel, hr->host, AF_INET,
-                     on_hostbyname_done_locked, hr);
-  if (r->balancer_addresses_out != nullptr) {
-    /* Query the SRV record */
-    std::string service_name = absl::StrCat("_grpclb._tcp.", host);
-    GrpcAresQuery* srv_query = new GrpcAresQuery(r, service_name);
-    ares_query(r->ev_driver->channel, service_name.c_str(), ns_c_in, ns_t_srv,
-               on_srv_query_done_locked, srv_query);
-  }
-  if (r->service_config_json_out != nullptr) {
-    std::string config_name = absl::StrCat("_grpc_config.", host);
-    GrpcAresQuery* txt_query = new GrpcAresQuery(r, config_name);
-    ares_search(r->ev_driver->channel, config_name.c_str(), ns_c_in, ns_t_txt,
-                on_txt_done_locked, txt_query);
-  }
-  grpc_ares_ev_driver_start_locked(r->ev_driver);
-  grpc_ares_request_unref_locked(r);
-  return;
+  return GRPC_ERROR_NONE;
+}
 
-error_cleanup:
-  grpc_core::ExecCtx::Run(DEBUG_LOCATION, r->on_done, error);
+// Common logic for all lookup methods.
+// If an error occurs, callers must run the client callback.
+grpc_error_handle grpc_dns_lookup_ares_continued(
+    grpc_ares_request* r, const char* dns_server, const char* name,
+    const char* default_port, grpc_pollset_set* interested_parties,
+    int query_timeout_ms, std::string* host, std::string* port, bool check_port)
+    ABSL_EXCLUSIVE_LOCKS_REQUIRED(r->mu) {
+  grpc_error_handle error = GRPC_ERROR_NONE;
+  /* parse name, splitting it into host and port parts */
+  grpc_core::SplitHostPort(name, host, port);
+  if (host->empty()) {
+    error = grpc_error_set_str(
+        GRPC_ERROR_CREATE_FROM_STATIC_STRING("unparseable host:port"),
+        GRPC_ERROR_STR_TARGET_ADDRESS, name);
+    return error;
+  } else if (check_port && port->empty()) {
+    if (default_port == nullptr || strlen(default_port) == 0) {
+      error = grpc_error_set_str(
+          GRPC_ERROR_CREATE_FROM_STATIC_STRING("no port in name"),
+          GRPC_ERROR_STR_TARGET_ADDRESS, name);
+      return error;
+    }
+    *port = default_port;
+  }
+  error = grpc_ares_ev_driver_create_locked(&r->ev_driver, interested_parties,
+                                            query_timeout_ms, r);
+  if (!GRPC_ERROR_IS_NONE(error)) return error;
+  // If dns_server is specified, use it.
+  error = set_request_dns_server(r, dns_server);
+  return error;
 }
 
 static bool inner_resolve_as_ip_literal_locked(
@@ -946,7 +922,7 @@ static bool inner_resolve_as_ip_literal_locked(
                                false /* log errors */)) {
     GPR_ASSERT(*addrs == nullptr);
     *addrs = absl::make_unique<ServerAddressList>();
-    (*addrs)->emplace_back(addr.addr, addr.len, nullptr /* args */);
+    (*addrs)->emplace_back(addr.addr, addr.len, grpc_core::ChannelArgs());
     return true;
   }
   return false;
@@ -1012,7 +988,7 @@ static bool inner_maybe_resolve_localhost_manually_locked(
     ipv6_loopback_addr.sin6_family = AF_INET6;
     ipv6_loopback_addr.sin6_port = numeric_port;
     (*addrs)->emplace_back(&ipv6_loopback_addr, sizeof(ipv6_loopback_addr),
-                           nullptr /* args */);
+                           grpc_core::ChannelArgs() /* args */);
     // Append the ipv4 loopback address.
     struct sockaddr_in ipv4_loopback_addr;
     memset(&ipv4_loopback_addr, 0, sizeof(ipv4_loopback_addr));
@@ -1021,7 +997,7 @@ static bool inner_maybe_resolve_localhost_manually_locked(
     ipv4_loopback_addr.sin_family = AF_INET;
     ipv4_loopback_addr.sin_port = numeric_port;
     (*addrs)->emplace_back(&ipv4_loopback_addr, sizeof(ipv4_loopback_addr),
-                           nullptr /* args */);
+                           grpc_core::ChannelArgs() /* args */);
     // Let the address sorter figure out which one should be tried first.
     grpc_cares_wrapper_address_sorting_sort(r, addrs->get());
     return true;
@@ -1046,21 +1022,18 @@ static bool grpc_ares_maybe_resolve_localhost_manually_locked(
 }
 #endif /* GRPC_ARES_RESOLVE_LOCALHOST_MANUALLY */
 
-static grpc_ares_request* grpc_dns_lookup_ares_impl(
+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::ServerAddressList>* balancer_addrs,
-    char** service_config_json, int query_timeout_ms) {
+    int query_timeout_ms) {
   grpc_ares_request* r = new grpc_ares_request();
   grpc_core::MutexLock lock(&r->mu);
   r->ev_driver = nullptr;
   r->on_done = on_done;
   r->addresses_out = addrs;
-  r->balancer_addresses_out = balancer_addrs;
-  r->service_config_json_out = service_config_json;
   GRPC_CARES_TRACE_LOG(
-      "request:%p c-ares grpc_dns_lookup_ares_impl name=%s, "
+      "request:%p c-ares grpc_dns_lookup_hostname_ares_impl name=%s, "
       "default_port=%s",
       r, name, default_port);
   // Early out if the target is an ipv4 or ipv6 literal.
@@ -1074,26 +1047,129 @@ static grpc_ares_request* grpc_dns_lookup_ares_impl(
     grpc_ares_complete_request_locked(r);
     return r;
   }
-  // Don't query for SRV and TXT records if the target is "localhost", so
-  // as to cut down on lookups over the network, especially in tests:
-  // https://github.com/grpc/proposal/pull/79
+  // Look up name using c-ares lib.
+  std::string host;
+  std::string port;
+  grpc_error_handle error = grpc_dns_lookup_ares_continued(
+      r, dns_server, name, default_port, interested_parties, query_timeout_ms,
+      &host, &port, true);
+  if (!GRPC_ERROR_IS_NONE(error)) {
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, r->on_done, error);
+    return r;
+  }
+  r->pending_queries = 1;
+  grpc_ares_hostbyname_request* hr = nullptr;
+  if (grpc_ares_query_ipv6()) {
+    hr = create_hostbyname_request_locked(r, host.c_str(),
+                                          grpc_strhtons(port.c_str()),
+                                          /*is_balancer=*/false, "AAAA");
+    ares_gethostbyname(r->ev_driver->channel, hr->host, AF_INET6,
+                       on_hostbyname_done_locked, hr);
+  }
+  hr = create_hostbyname_request_locked(r, host.c_str(),
+                                        grpc_strhtons(port.c_str()),
+                                        /*is_balancer=*/false, "A");
+  ares_gethostbyname(r->ev_driver->channel, hr->host, AF_INET,
+                     on_hostbyname_done_locked, hr);
+  grpc_ares_ev_driver_start_locked(r->ev_driver);
+  grpc_ares_request_unref_locked(r);
+  return r;
+}
+
+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,
+    int query_timeout_ms) {
+  grpc_ares_request* r = new grpc_ares_request();
+  grpc_core::MutexLock lock(&r->mu);
+  r->ev_driver = nullptr;
+  r->on_done = on_done;
+  r->balancer_addresses_out = balancer_addresses;
+  GRPC_CARES_TRACE_LOG(
+      "request:%p c-ares grpc_dns_lookup_srv_ares_impl name=%s", r, name);
+  grpc_error_handle error = GRPC_ERROR_NONE;
+  // Don't query for SRV records if the target is "localhost"
   if (target_matches_localhost(name)) {
-    r->balancer_addresses_out = nullptr;
-    r->service_config_json_out = nullptr;
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, r->on_done, error);
+    return r;
   }
   // Look up name using c-ares lib.
-  grpc_dns_lookup_ares_continue_after_check_localhost_and_ip_literals_locked(
-      r, dns_server, name, default_port, interested_parties, query_timeout_ms);
+  std::string host;
+  std::string port;
+  error = grpc_dns_lookup_ares_continued(r, dns_server, name, nullptr,
+                                         interested_parties, query_timeout_ms,
+                                         &host, &port, false);
+  if (!GRPC_ERROR_IS_NONE(error)) {
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, r->on_done, error);
+    return r;
+  }
+  r->pending_queries = 1;
+  /* Query the SRV record */
+  std::string service_name = absl::StrCat("_grpclb._tcp.", host);
+  GrpcAresQuery* srv_query = new GrpcAresQuery(r, service_name);
+  ares_query(r->ev_driver->channel, service_name.c_str(), ns_c_in, ns_t_srv,
+             on_srv_query_done_locked, srv_query);
+  grpc_ares_ev_driver_start_locked(r->ev_driver);
+  grpc_ares_request_unref_locked(r);
   return r;
 }
 
-grpc_ares_request* (*grpc_dns_lookup_ares)(
+grpc_ares_request* grpc_dns_lookup_txt_ares_impl(
+    const char* dns_server, const char* name,
+    grpc_pollset_set* interested_parties, grpc_closure* on_done,
+    char** service_config_json, int query_timeout_ms) {
+  grpc_ares_request* r = new grpc_ares_request();
+  grpc_core::MutexLock lock(&r->mu);
+  r->ev_driver = nullptr;
+  r->on_done = on_done;
+  r->service_config_json_out = service_config_json;
+  GRPC_CARES_TRACE_LOG(
+      "request:%p c-ares grpc_dns_lookup_txt_ares_impl name=%s", r, name);
+  grpc_error_handle error = GRPC_ERROR_NONE;
+  // Don't query for TXT records if the target is "localhost"
+  if (target_matches_localhost(name)) {
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, r->on_done, error);
+    return r;
+  }
+  // Look up name using c-ares lib.
+  std::string host;
+  std::string port;
+  error = grpc_dns_lookup_ares_continued(r, dns_server, name, nullptr,
+                                         interested_parties, query_timeout_ms,
+                                         &host, &port, false);
+  if (!GRPC_ERROR_IS_NONE(error)) {
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, r->on_done, error);
+    return r;
+  }
+  r->pending_queries = 1;
+  /* Query the TXT record */
+  std::string config_name = absl::StrCat("_grpc_config.", host);
+  GrpcAresQuery* txt_query = new GrpcAresQuery(r, config_name);
+  ares_search(r->ev_driver->channel, config_name.c_str(), ns_c_in, ns_t_txt,
+              on_txt_done_locked, txt_query);
+  grpc_ares_ev_driver_start_locked(r->ev_driver);
+  grpc_ares_request_unref_locked(r);
+  return r;
+}
+
+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::ServerAddressList>* balancer_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,
+    int query_timeout_ms) = grpc_dns_lookup_srv_ares_impl;
+
+grpc_ares_request* (*grpc_dns_lookup_txt_ares)(
+    const char* dns_server, const char* name,
+    grpc_pollset_set* interested_parties, grpc_closure* on_done,
     char** service_config_json,
-    int query_timeout_ms) = grpc_dns_lookup_ares_impl;
+    int query_timeout_ms) = grpc_dns_lookup_txt_ares_impl;
 
 static void grpc_cancel_ares_request_impl(grpc_ares_request* r) {
   GPR_ASSERT(r != nullptr);

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

@@ -78,23 +78,36 @@ struct grpc_ares_request {
   grpc_error_handle error ABSL_GUARDED_BY(mu) = GRPC_ERROR_NONE;
 };
 
-/* Asynchronously resolve \a name. It will try to resolve grpclb SRV records in
-  addition to the normal address records. For normal address records, it uses
-  \a default_port if a port isn't designated in \a name, otherwise it uses the
-  port in \a name. grpc_ares_init() must be called at least once before this
-  function. The returned grpc_ares_request object is owned by the caller and it
-  is safe to free after on_done is called back.
+/* Asynchronously resolve \a name (A/AAAA records only).
+  It uses \a default_port if a port isn't designated in \a name, otherwise it
+  uses the port in \a name. grpc_ares_init() must be called at least once before
+  this function. The returned grpc_ares_request object is owned by the caller
+  and it is safe to free after on_done is called back.
 
   Note on synchronization: \a as on_done might be called from another thread
   ~immediately, access to the grpc_ares_request* return value must be
   synchronized by the caller. TODO(apolcyn): we should remove this requirement
   by changing this API to use two phase initialization - one API to create
   the grpc_ares_request* and another to start the async work. */
-extern grpc_ares_request* (*grpc_dns_lookup_ares)(
+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,
+    int query_timeout_ms);
+
+// Asynchronously resolve a SRV record.
+// See \a grpc_dns_lookup_hostname_ares for usage details and caveats.
+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,
+    int query_timeout_ms);
+
+// Asynchronously resolve a TXT record.
+// See \a grpc_dns_lookup_hostname_ares for usage details and caveats.
+extern grpc_ares_request* (*grpc_dns_lookup_txt_ares)(
+    const char* dns_server, const char* name,
+    grpc_pollset_set* interested_parties, grpc_closure* on_done,
     char** service_config_json, int query_timeout_ms);
 
 /* Cancel the pending grpc_ares_request \a request */

data/src/core/ext/filters/client_channel/resolver/dns/native/dns_resolver.cc

@@ -16,14 +16,12 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <limits.h>
-
+#include <algorithm>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
-#include "absl/container/inlined_vector.h"
 #include "absl/functional/bind_front.h"
 #include "absl/memory/memory.h"
 #include "absl/status/status.h"
@@ -31,6 +29,7 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
+#include "absl/types/optional.h"
 
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/log.h>
@@ -70,23 +69,35 @@ TraceFlag grpc_trace_dns_resolver(false, "dns_resolver");
 class NativeClientChannelDNSResolver : public PollingResolver {
  public:
   NativeClientChannelDNSResolver(ResolverArgs args,
-                                 const grpc_channel_args* channel_args);
+                                 const ChannelArgs& channel_args);
   ~NativeClientChannelDNSResolver() override;
 
   OrphanablePtr<Orphanable> StartRequest() override;
 
  private:
+  // No-op request class, used so that the PollingResolver code knows
+  // when there is a request in flight, even if the request is not
+  // actually cancellable.
+  class Request : public Orphanable {
+   public:
+    Request() = default;
+
+    void Orphan() override {}
+  };
+
   void OnResolved(
       absl::StatusOr<std::vector<grpc_resolved_address>> addresses_or);
 };
 
 NativeClientChannelDNSResolver::NativeClientChannelDNSResolver(
-    ResolverArgs args, const grpc_channel_args* channel_args)
+    ResolverArgs args, const ChannelArgs& channel_args)
     : PollingResolver(
           std::move(args), channel_args,
-          Duration::Milliseconds(grpc_channel_args_find_integer(
-              channel_args, GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS,
-              {1000 * 30, 0, INT_MAX})),
+          std::max(Duration::Zero(),
+                   channel_args
+                       .GetDurationFromIntMillis(
+                           GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS)
+                       .value_or(Duration::Seconds(30))),
           BackOff::Options()
               .set_initial_backoff(Duration::Milliseconds(
                   GRPC_DNS_INITIAL_CONNECT_BACKOFF_SECONDS * 1000))
@@ -108,15 +119,15 @@ NativeClientChannelDNSResolver::~NativeClientChannelDNSResolver() {
 
 OrphanablePtr<Orphanable> NativeClientChannelDNSResolver::StartRequest() {
   Ref(DEBUG_LOCATION, "dns_request").release();
-  auto dns_request_handle = GetDNSResolver()->ResolveName(
-      name_to_resolve(), kDefaultSecurePort, interested_parties(),
-      absl::bind_front(&NativeClientChannelDNSResolver::OnResolved, this));
+  auto dns_request_handle = GetDNSResolver()->LookupHostname(
+      absl::bind_front(&NativeClientChannelDNSResolver::OnResolved, this),
+      name_to_resolve(), kDefaultSecurePort, kDefaultDNSRequestTimeout,
+      interested_parties(), /*name_server=*/"");
   if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_dns_resolver)) {
     gpr_log(GPR_DEBUG, "[dns_resolver=%p] starting request=%p", this,
             DNSResolver::HandleToString(dns_request_handle).c_str());
   }
-  // Not cancellable.
-  return nullptr;
+  return MakeOrphanable<Request>();
 }
 
 void NativeClientChannelDNSResolver::OnResolved(
@@ -130,7 +141,7 @@ void NativeClientChannelDNSResolver::OnResolved(
   if (addresses_or.ok()) {
     ServerAddressList addresses;
     for (auto& addr : *addresses_or) {
-      addresses.emplace_back(addr, nullptr /* args */);
+      addresses.emplace_back(addr, ChannelArgs());
     }
     result.addresses = std::move(addresses);
   } else {
@@ -138,7 +149,7 @@ void NativeClientChannelDNSResolver::OnResolved(
         absl::StrCat("DNS resolution failed for ", name_to_resolve(), ": ",
                      addresses_or.status().ToString()));
   }
-  result.args = grpc_channel_args_copy(channel_args());
+  result.args = channel_args();
   OnRequestComplete(std::move(result));
   Unref(DEBUG_LOCATION, "dns_request");
 }
@@ -165,9 +176,9 @@ class NativeClientChannelDNSResolverFactory : public ResolverFactory {
 
   OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
     if (!IsValidUri(args.uri)) return nullptr;
-    const grpc_channel_args* channel_args = args.args;
-    return MakeOrphanable<NativeClientChannelDNSResolver>(std::move(args),
-                                                          channel_args);
+    auto channel_args = args.args;
+    return MakeOrphanable<NativeClientChannelDNSResolver>(
+        std::move(args), std::move(channel_args));
   }
 };