Always treat .localhost as loopback

net/base/net_util.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/base/net_util.h"
 
 #include <errno.h>
 #include <string.h>
 
 #include <algorithm>
@@ skipping 126 matching lines @@
           // third_party/WebKit/Source/platform/weborigin/KURL.cpp,
           // KURL::port())
 };
 
 // FTP overrides the following restricted ports.
 static const int kAllowedFtpPorts[] = {
   21,   // ftp data
   22,   // ssh
 };
 
+static const char kLocalhostTLD[] = ".localhost";
+static const size_t kLocalhostTLDLength = arraysize(kLocalhostTLD) - 1;

[Ryan Sleevi, 2015/03/24 23:15:20]

Turns out you could move these to line 1024, since you never use this outside
this scope.

[estark, 2015/03/25 23:53:33]

Done.

+
 bool IPNumberPrefixCheck(const IPAddressNumber& ip_number,
                          const unsigned char* ip_prefix,
                          size_t prefix_length_in_bits) {
   // Compare all the bytes that fall entirely within the prefix.
   int num_entire_bytes_in_prefix = prefix_length_in_bits / 8;
   for (int i = 0; i < num_entire_bytes_in_prefix; ++i) {
     if (ip_number[i] != ip_prefix[i])
       return false;
   }
 
@@ skipping 820 matching lines @@
   const uint16* port_field = GetPortFieldFromSockaddr(address, address_len);
   if (!port_field)
     return -1;
   return base::NetToHost16(*port_field);
 }
 
 bool IsLocalhost(const std::string& host) {
   if (host == "localhost" ||
       host == "localhost.localdomain" ||
       host == "localhost6" ||
-      host == "localhost6.localdomain6")
+      host == "localhost6.localdomain6" ||
+      IsLocalhostTLD(host))
     return true;
 
   IPAddressNumber ip_number;
   if (ParseIPLiteralToNumber(host, &ip_number)) {
     size_t size = ip_number.size();
     switch (size) {
       case kIPv4AddressSize: {
         IPAddressNumber localhost_prefix;
         localhost_prefix.push_back(127);
         for (int i = 0; i < 3; ++i) {
           localhost_prefix.push_back(0);
         }
         return IPNumberMatchesPrefix(ip_number, localhost_prefix, 8);
       }
 
       case kIPv6AddressSize: {
         struct in6_addr sin6_addr;
         memcpy(&sin6_addr, &ip_number[0], kIPv6AddressSize);
         return !!IN6_IS_ADDR_LOOPBACK(&sin6_addr);
       }
 
       default:
         NOTREACHED();
     }
   }
 
   return false;
 }
 
+bool IsLocalhostTLD(const std::string& host) {
+  if (host.empty())
+    return false;
+
+  size_t host_len = host.size();
+  if (*host.rbegin() == '.')
+    --host_len;
+  if (host_len < kLocalhostTLDLength)
+    return false;
+
+  const char* host_suffix = host.data() + host_len - kLocalhostTLDLength;
+  return base::strncasecmp(host_suffix, kLocalhostTLD, kLocalhostTLDLength) ==
+         0;
+}
+
 NetworkInterface::NetworkInterface()
     : type(NetworkChangeNotifier::CONNECTION_UNKNOWN), prefix_length(0) {
 }
 
 NetworkInterface::NetworkInterface(const std::string& name,
                                    const std::string& friendly_name,
                                    uint32 interface_index,
                                    NetworkChangeNotifier::ConnectionType type,
                                    const IPAddressNumber& address,
                                    uint32 prefix_length,
@@ skipping 29 matching lines @@
 
 unsigned MaskPrefixLength(const IPAddressNumber& mask) {
   IPAddressNumber all_ones(mask.size(), 0xFF);
   return CommonPrefixLength(mask, all_ones);
 }
 
 ScopedWifiOptions::~ScopedWifiOptions() {
 }
 
 }  // namespace net