Resolve RFC 6761 localhost names to loopback

net/dns/host_resolver_impl.h

 // 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.
 
 #ifndef NET_DNS_HOST_RESOLVER_IMPL_H_
 #define NET_DNS_HOST_RESOLVER_IMPL_H_
 
 #include <map>
 
 #include "base/basictypes.h"
@@ skipping 143 matching lines @@
   typedef std::map<Key, Job*> JobMap;
   typedef ScopedVector<Request> RequestsList;
 
   // Number of consecutive failures of DnsTask (with successful fallback to
   // ProcTask) before the DnsClient is disabled until the next DNS change.
   static const unsigned kMaximumDnsFailures;
 
   // Helper used by |Resolve()| and |ResolveFromCache()|.  Performs IP
   // literal, cache and HOSTS lookup (if enabled), returns OK if successful,
   // ERR_NAME_NOT_RESOLVED if either hostname is invalid or IP literal is
-  // incompatible, ERR_DNS_CACHE_MISS if entry was not found in cache and HOSTS.
+  // incompatible, ERR_DNS_CACHE_MISS if entry was not found in cache and
+  // HOSTS and is not localhost.
   int ResolveHelper(const Key& key,
                     const RequestInfo& info,
                     const IPAddressNumber* ip_address,
                     AddressList* addresses,
                     const BoundNetLog& request_net_log);
 
   // Tries to resolve |key| as an IP, returns true and sets |net_error| if
   // succeeds, returns false otherwise.
   bool ResolveAsIP(const Key& key,
                    const RequestInfo& info,
                    const IPAddressNumber* ip_address,
                    int* net_error,
                    AddressList* addresses);
 
   // If |key| is not found in cache returns false, otherwise returns
   // true, sets |net_error| to the cached error code and fills |addresses|
   // if it is a positive entry.
   bool ServeFromCache(const Key& key,
                       const RequestInfo& info,
                       int* net_error,
                       AddressList* addresses);
 
   // If we have a DnsClient with a valid DnsConfig, and |key| is found in the
   // HOSTS file, returns true and fills |addresses|. Otherwise returns false.
   bool ServeFromHosts(const Key& key,
                       const RequestInfo& info,
                       AddressList* addresses);
 
+  // If |key| is for a localhost name (RFC 6761), returns true and fills
+  // |addresses| with the loopback IP. Otherwise returns false.
+  bool ServeLocalhost(const Key& key,
+                      const RequestInfo& info,
+                      AddressList* addresses);
+
   // Callback from HaveOnlyLoopbackAddresses probe.
   void SetHaveOnlyLoopbackAddresses(bool result);
 
   // Returns the (hostname, address_family) key to use for |info|, choosing an
   // "effective" address family by inheriting the resolver's default address
   // family when the request leaves it unspecified.
   Key GetEffectiveKeyForRequest(const RequestInfo& info,
                                 const IPAddressNumber* ip_number,
                                 const BoundNetLog& net_log);
 
@@ skipping 93 matching lines @@
   base::WeakPtrFactory<HostResolverImpl> weak_ptr_factory_;
 
   base::WeakPtrFactory<HostResolverImpl> probe_weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(HostResolverImpl);
 };
 
 }  // namespace net
 
 #endif  // NET_DNS_HOST_RESOLVER_IMPL_H_