Resolve RFC 6761 localhost names to loopback

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 56 matching lines @@
 
 // Default TTL for successful resolutions with ProcTask.
 const unsigned kCacheEntryTTLSeconds = 60;
 
 // Default TTL for unsuccessful resolutions with ProcTask.
 const unsigned kNegativeCacheEntryTTLSeconds = 0;
 
 // Minimum TTL for successful resolutions with DnsTask.
 const unsigned kMinimumTTLSeconds = kCacheEntryTTLSeconds;
 
-const char kLocalhost[] = "localhost.";
-
 // Time between IPv6 probes, i.e. for how long results of each IPv6 probe are
 // cached.
 const int kIPv6ProbePeriodMs = 1000;
 
 // Google DNS address used for IPv6 probes.
 const uint8_t kIPv6ProbeAddress[] =
     { 0x20, 0x01, 0x48, 0x60, 0x48, 0x60, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x88 };
 
 // We use a separate histogram name for each platform to facilitate the
@@ skipping 1222 matching lines @@
     // The dispatcher could have started |this| in the above call to Add, which
     // could have called Schedule again. In that case |handle| will be null,
     // but |handle_| may have been set by the other nested call to Schedule.
     if (!handle.is_null()) {
       DCHECK(handle_.is_null());
       handle_ = handle;
     }
   }
 
   void AddRequest(scoped_ptr<Request> req) {
-    // .localhost queries are redirected to "localhost." to make sure
-    // that they are never sent out on the network, per RFC 6761.
-    if (IsLocalhostTLD(req->info().hostname())) {
-      DCHECK_EQ(key_.hostname, kLocalhost);
-    } else {
-      DCHECK_EQ(key_.hostname, req->info().hostname());
-    }
+    DCHECK_EQ(key_.hostname, req->info().hostname());
 
     req->set_job(this);
     priority_tracker_.Add(req->priority());
 
     req->source_net_log().AddEvent(
         NetLog::TYPE_HOST_RESOLVER_IMPL_JOB_ATTACH,
         net_log_.source().ToEventParametersCallback());
 
     net_log_.AddEvent(
         NetLog::TYPE_HOST_RESOLVER_IMPL_JOB_REQUEST_ATTACH,
@@ skipping 652 matching lines @@
   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;
   }
+
+  if (ServeLocalhost(key, info, addresses))
+    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.
@@ skipping 142 matching lines @@
       IsAllIPv4Loopback(*addresses)) {
     Key new_key(key);
     new_key.address_family = ADDRESS_FAMILY_UNSPECIFIED;
     new_key.host_resolver_flags &=
         ~HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
     return ServeFromHosts(new_key, info, addresses);
   }
   return !addresses->empty();
 }
 
+bool HostResolverImpl::ServeLocalhost(const Key& key,
+                                      const RequestInfo& info,
+                                      AddressList* addresses) {
+  AddressList resolved_addresses;
+  if (!ResolveLocalHostname(key.hostname, info.port(), &resolved_addresses))
+    return false;
+
+  addresses->clear();
+
+  // If the family was restricted to IPv4 due to a detected lack of IPv6
+  // support, resolve with no restrictions. (See SystemHostResolverCall
+  // for rationale.)
+  bool no_ipv6 = key.address_family == ADDRESS_FAMILY_IPV4 &&
+                 !(key.host_resolver_flags &
+                   HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6);
+
+  for (const auto& address : resolved_addresses) {
+    if (address.GetFamily() == ADDRESS_FAMILY_IPV6) {
+      if (!no_ipv6)
+        addresses->push_back(address);
+    } else if (key.address_family != ADDRESS_FAMILY_IPV6) {

[Ryan Sleevi, 2015/06/12 01:00:04]

I don't understand this clause - could you elaborate?

It would *seem* like the logic would be something like

for (const auto& address : resolved_addresses) {
  if (key.address_family == ADDRESS_FAMILY_UNSPECIFIED ||
      key.address_family == address.GetFamily() ||
      (address.GetFamily() == ADDRESS_FAMILY_IPV6 &&
       key.address_family == ADDRESS_FAMILY_IPV4 &&
       (key.host_resolver_flags &
HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6)))
    addresses->push_back(address);
}

That is -
- Return all addresses if they don't care
- Return all addresses that specifically match what they care about
- Return IPv6 addresses if they requested IPv4 only due to detected lack of
support
- Otherwise, don't include the address


Is that a fair summary of the intended logic?

[estark, 2015/06/12 05:59:46]

This is the logic I intended to write:

If the address is IPv6:
    - include it if they didn't specifically ask for IPv4 OR if they
specifically asked for IPv4 due to detected lack of IPv6 support
Otherwise (i.e. if the address is IPv4):
    - include it if they didn't specifically ask for IPv6

Which I think gives the same results as yours, just written differently. Yours
is probably easier to read though, so I changed it to that.

+      addresses->push_back(address);
+    }
+  }
+
+  return true;
+}
+
 void HostResolverImpl::CacheResult(const Key& key,
                                    const HostCache::Entry& entry,
                                    base::TimeDelta ttl) {
   if (cache_.get())
     cache_->Set(key, entry, base::TimeTicks::Now(), ttl);
 }
 
 void HostResolverImpl::RemoveJob(Job* job) {
   DCHECK(job);
   JobMap::iterator it = jobs_.find(job->key());
@@ skipping 26 matching lines @@
         // check above) so the code requesting the resolution should be amenable
         // to receiving a IPv6 resolution.
         ip_number == nullptr) {
       if (!IsIPv6Reachable(net_log)) {
         effective_address_family = ADDRESS_FAMILY_IPV4;
         effective_flags |= HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
       }
     }
   }
 
-  std::string hostname = info.hostname();
-  // Redirect .localhost queries to "localhost." to make sure that they
-  // are never sent out on the network, per RFC 6761.
-  if (IsLocalhostTLD(info.hostname()))
-    hostname = kLocalhost;
-
-  return Key(hostname, effective_address_family, effective_flags);
+  return Key(info.hostname(), effective_address_family, effective_flags);
 }
 
 bool HostResolverImpl::IsIPv6Reachable(const BoundNetLog& net_log) {
   base::TimeTicks now = base::TimeTicks::Now();
   bool cached = true;
   if ((now - last_ipv6_probe_time_).InMilliseconds() > kIPv6ProbePeriodMs) {
     IPAddressNumber address(kIPv6ProbeAddress,
                             kIPv6ProbeAddress + arraysize(kIPv6ProbeAddress));
     last_ipv6_probe_result_ = IsGloballyReachable(address, net_log);
     last_ipv6_probe_time_ = now;
@@ 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