Resolve RFC 6761 localhost names to loopback

net/dns/host_resolver_impl.cc

Index: net/dns/host_resolver_impl.cc
diff --git a/net/dns/host_resolver_impl.cc b/net/dns/host_resolver_impl.cc
index 970ec1f457ade5ba90b1b2ac6224f57e782c0271..4639737d662db475bfc1bed201c311f0ab930b64 100644
--- a/net/dns/host_resolver_impl.cc
+++ b/net/dns/host_resolver_impl.cc
@@ -74,8 +74,6 @@ 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;
@@ -1318,13 +1316,7 @@ class HostResolverImpl::Job : public PrioritizedDispatcher::Job,
   }
 
   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());
@@ -1997,6 +1989,10 @@ int HostResolverImpl::ResolveHelper(const Key& key,
     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;
 }
 
@@ -2159,6 +2155,34 @@ bool HostResolverImpl::ServeFromHosts(const Key& key,
   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) {
@@ -2205,13 +2229,7 @@ HostResolverImpl::Key HostResolverImpl::GetEffectiveKeyForRequest(
     }
   }
 
-  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) {