Don't probe for IPv6 connectivity when resolving IPv6 literals.

net/dns/host_resolver_impl.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/dns/host_resolver_impl.h"
 
 #if defined(OS_WIN)
 #include <Winsock2.h>
 #elif defined(OS_POSIX)
 #include <netdb.h>
@@ skipping 1863 matching lines @@
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(false, callback.is_null());
 
   // Check that the caller supplied a valid hostname to resolve.
   std::string labeled_hostname;
   if (!DNSDomainFromDot(info.hostname(), &labeled_hostname))
     return ERR_NAME_NOT_RESOLVED;
 
   LogStartRequest(source_net_log, info);
 
+  IPAddressNumber ip_number;
+  IPAddressNumber* ip_number_ptr = nullptr;
+  if (ParseIPLiteralToNumber(info.hostname(), &ip_number))
+    ip_number_ptr = &ip_number;
+
   // Build a key that identifies the request in the cache and in the
   // outstanding jobs map.
-  Key key = GetEffectiveKeyForRequest(info, source_net_log);
+  Key key = GetEffectiveKeyForRequest(info, ip_number_ptr, source_net_log);
 
-  int rv = ResolveHelper(key, info, addresses, source_net_log);
+  int rv = ResolveHelper(key, info, ip_number_ptr, addresses, source_net_log);
   if (rv != ERR_DNS_CACHE_MISS) {
     LogFinishRequest(source_net_log, info, rv);
     RecordTotalTime(HaveDnsConfig(), info.is_speculative(), base::TimeDelta());
     return rv;
   }
 
   // Next we need to attach our request to a "job". This job is responsible for
   // calling "getaddrinfo(hostname)" on a worker thread.
 
   JobMap::iterator jobit = jobs_.find(key);
@@ skipping 25 matching lines @@
   if (out_req)
     *out_req = reinterpret_cast<RequestHandle>(req.get());
 
   job->AddRequest(req.Pass());
   // Completion happens during Job::CompleteRequests().
   return ERR_IO_PENDING;
 }
 
 int HostResolverImpl::ResolveHelper(const Key& key,
                                     const RequestInfo& info,
+                                    const IPAddressNumber* ip_number,
                                     AddressList* addresses,
                                     const BoundNetLog& source_net_log) {
   // The result of |getaddrinfo| for empty hosts is inconsistent across systems.
   // On Windows it gives the default interface's address, whereas on Linux it
   // gives an error. We will make it fail on all platforms for consistency.
   if (info.hostname().empty() || info.hostname().size() > kMaxHostLength)
     return ERR_NAME_NOT_RESOLVED;
 
   int net_error = ERR_UNEXPECTED;
-  if (ResolveAsIP(key, info, &net_error, addresses))
+  if (ResolveAsIP(key, info, ip_number, &net_error, addresses))
     return net_error;
   if (ServeFromCache(key, info, &net_error, addresses)) {
     source_net_log.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_CACHE_HIT);
     return net_error;
   }
   // TODO(szym): Do not do this if nsswitch.conf instructs not to.
   // http://crbug.com/117655
   if (ServeFromHosts(key, info, addresses)) {
     source_net_log.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_HOSTS_HIT);
     return OK;
   }
   return ERR_DNS_CACHE_MISS;
 }
 
 int HostResolverImpl::ResolveFromCache(const RequestInfo& info,
                                        AddressList* addresses,
                                        const BoundNetLog& source_net_log) {
   DCHECK(CalledOnValidThread());
   DCHECK(addresses);
 
   // Update the net log and notify registered observers.
   LogStartRequest(source_net_log, info);
 
-  Key key = GetEffectiveKeyForRequest(info, source_net_log);
+  IPAddressNumber ip_number;
+  IPAddressNumber* ip_number_ptr = nullptr;
+  if (ParseIPLiteralToNumber(info.hostname(), &ip_number))
+    ip_number_ptr = &ip_number;
 
-  int rv = ResolveHelper(key, info, addresses, source_net_log);
+  Key key = GetEffectiveKeyForRequest(info, ip_number_ptr, source_net_log);
+
+  int rv = ResolveHelper(key, info, ip_number_ptr, addresses, source_net_log);
   LogFinishRequest(source_net_log, info, rv);
   return rv;
 }
 
 void HostResolverImpl::CancelRequest(RequestHandle req_handle) {
   DCHECK(CalledOnValidThread());
   Request* req = reinterpret_cast<Request*>(req_handle);
   DCHECK(req);
   Job* job = req->job();
   DCHECK(job);
@@ skipping 34 matching lines @@
   // for it.
   const DnsConfig* dns_config = dns_client_->GetConfig();
   if (dns_config == NULL)
     return new base::DictionaryValue();
 
   return dns_config->ToValue();
 }
 
 bool HostResolverImpl::ResolveAsIP(const Key& key,
                                    const RequestInfo& info,
+                                   const IPAddressNumber* ip_number,
                                    int* net_error,
                                    AddressList* addresses) {
   DCHECK(addresses);
   DCHECK(net_error);
-  IPAddressNumber ip_number;
-  if (!ParseIPLiteralToNumber(key.hostname, &ip_number))
+  if (ip_number == nullptr)
     return false;
 
   DCHECK_EQ(key.host_resolver_flags &
       ~(HOST_RESOLVER_CANONNAME | HOST_RESOLVER_LOOPBACK_ONLY |
         HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6),
             0) << " Unhandled flag";
 
   *net_error = OK;
-  AddressFamily family = GetAddressFamily(ip_number);
+  AddressFamily family = GetAddressFamily(*ip_number);
   if (family == ADDRESS_FAMILY_IPV6 &&
       !probe_ipv6_support_ &&
       default_address_family_ == ADDRESS_FAMILY_IPV4) {
     // Don't return IPv6 addresses if default address family is set to IPv4,
     // and probes are disabled.
     *net_error = ERR_NAME_NOT_RESOLVED;
   } else if (key.address_family != ADDRESS_FAMILY_UNSPECIFIED &&
              key.address_family != family) {
     // Don't return IPv6 addresses for IPv4 queries, and vice versa.
     *net_error = ERR_NAME_NOT_RESOLVED;
   } else {
-    *addresses = AddressList::CreateFromIPAddress(ip_number, info.port());
+    *addresses = AddressList::CreateFromIPAddress(*ip_number, info.port());
     if (key.host_resolver_flags & HOST_RESOLVER_CANONNAME)
       addresses->SetDefaultCanonicalName();
   }
   return true;
 }
 
 bool HostResolverImpl::ServeFromCache(const Key& key,
                                       const RequestInfo& info,
                                       int* net_error,
                                       AddressList* addresses) {
@@ skipping 80 matching lines @@
 
 void HostResolverImpl::SetHaveOnlyLoopbackAddresses(bool result) {
   if (result) {
     additional_resolver_flags_ |= HOST_RESOLVER_LOOPBACK_ONLY;
   } else {
     additional_resolver_flags_ &= ~HOST_RESOLVER_LOOPBACK_ONLY;
   }
 }
 
 HostResolverImpl::Key HostResolverImpl::GetEffectiveKeyForRequest(
-    const RequestInfo& info, const BoundNetLog& net_log) const {
+    const RequestInfo& info,
+    const IPAddressNumber* ip_number,
+    const BoundNetLog& net_log) const {
   HostResolverFlags effective_flags =
       info.host_resolver_flags() | additional_resolver_flags_;
   AddressFamily effective_address_family = info.address_family();
 
   if (info.address_family() == ADDRESS_FAMILY_UNSPECIFIED) {
-    unsigned char ip_number[4];
-    url::Component host_comp(0, info.hostname().size());
-    int num_components;
     if (probe_ipv6_support_ && !use_local_ipv6_ &&
-        // Don't bother IPv6 probing when resolving IPv4 literals.
-        url::IPv4AddressToNumber(info.hostname().c_str(), host_comp, ip_number,
-                                 &num_components) != url::CanonHostInfo::IPV4) {
+        // When resolving IPv4 literals, there's no need to probe for IPv6.
+        // When resolving IPv6 literals, there's no benefit to artificially
+        // limiting our resolution based on a probe.  Prior logic ensures
+        // that this query is UNSPECIFIED (see info.address_family()
+        // check above) and that |default_address_family_| is UNSPECIFIED
+        // (|prove_ipv6_support_| is false if |default_address_family_| is
+        // set) so the code requesting the resolution should be amenable to
+        // receiving a IPv6 resolution.
+        ip_number == nullptr) {
       // Google DNS address.
       const uint8 kIPv6Address[] =
           { 0x20, 0x01, 0x48, 0x60, 0x48, 0x60, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x88 };
       IPAddressNumber address(kIPv6Address,
                               kIPv6Address + arraysize(kIPv6Address));
       BoundNetLog probe_net_log = BoundNetLog::Make(
           net_log.net_log(), NetLog::SOURCE_IPV6_REACHABILITY_CHECK);
       probe_net_log.BeginEvent(NetLog::TYPE_IPV6_REACHABILITY_CHECK,
                                net_log.source().ToEventParametersCallback());
@@ skipping 187 matching lines @@
     dns_client_->SetConfig(dns_config);
     num_dns_failures_ = 0;
     if (dns_client_->GetConfig())
       UMA_HISTOGRAM_BOOLEAN("AsyncDNS.DnsClientEnabled", true);
   }
 
   AbortDnsTasks();
 }
 
 }  // namespace net