Resolve RFC 6761 localhost names to 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 27 matching lines @@
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_byteorder.h"
 #include "base/values.h"
+#include "net/base/address_list.h"
 #include "net/base/dns_util.h"
 #include "net/base/ip_address_number.h"
 #include "net/base/net_module.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/grit/net_resources.h"
 #include "net/http/http_content_disposition.h"
 #include "url/gurl.h"
 #include "url/third_party/mozilla/url_parse.h"
 #include "url/url_canon.h"
 #include "url/url_canon_ip.h"
@@ skipping 81 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
 };
 
+bool IsLocalHostname(const std::string& host) {
+  std::string lowercased_host = base::StringToLowerASCII(host);

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

Suggestion: To reduce comparisons for the forms, and thus reduce copy paste,
since you're copying the string regardless here, you could do

std::string lowercase_host = base::StringToLowerASCII(host);
if (!lowercase_host.empty() && lowercase_host.rbegin() == '.')
  lowercase_host.resize(lowercase_host.size() - 1);

return (lowercased_host == "localhost" ||
        lowercased_host == "localhost.localdomain" ||
        IsLocalhostTLD(lowercased_host));

[Incidentally, this is similar to the suggestion I made on IsLocalhostTLD]

You could further optimize by having an IsNormalizedLocalhostTLD() internal
function (e.g. not part of the .h) that expects the string to already be
lowercased and w/ the trailing . removed. That would prevent further additional
copies of the string being made, which is presumably going to be the hot-path
general case here (that is, we expect *most* names going through the resolver to
*not* be localhost). IsLocalhostTLD() would just normalize first.

[Further refactoring would be]

std::string NormalizeHostname(const std::string& host) {
  std::string result = base::StringToLowerASCII(host);
  if (!result.empty() && result.rbegin() == '.')
    result.resize(result.size() - 1);
  return result;
}

bool IsNormalizedLocalhostTLD(host) {
  return EndsWith(host, ".localhost", true);
}

bool IsLocalHostname(const std::string& host) {
  return host == "localhost" || host == "localhost.localdomain" ||
         IsNormalizedLocalhostTLD(host);
}

bool IsLocal6Hostname(const std::string& host) {
  return host == "localhost6" || host == "localhost6.localdomain6"
}

}  // namespace

bool IsLocalhost(const std::string& host) {
  std::string normalized_host = NormalizeHostname(host);
  if (IsLocalHostname(normalized_host) || IsLocal6Hostname(normalized_host))
    return true;
  ... // stuff here
}

bool IsLocalhostTLD(const std::string& host) {
  return IsNormalizedLocalhostTLD(NormalizeHostname(host));
}

This reduces it to 1 copy, 1 character conversion, and a more efficient string
comparison (because it can now be done case sensitively)

If we had an EndsWith that took iterators, we could get away with avoiding a
string copy for the IsLocalhostTLD, which could offer more minor perf gains. I
started writing up a version of what that would look like, and then I looked in
aghast horror at the template hell I wrote (it involves "template typename
template" declarations, the use of std::distance(), and other gross things).
Hopefully the above isn't 'too' gross a refactoring.

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

Done.

+  return (lowercased_host == "localhost" ||
+          lowercased_host == "localhost.localdomain" ||
+          lowercased_host == "localhost." ||
+          lowercased_host == "localhost.localdomain." ||
+          IsLocalhostTLD(lowercased_host));
+}
+
+bool IsLocal6Hostname(const std::string& host) {
+  std::string lowercased_host = base::StringToLowerASCII(host);
+  return (lowercased_host == "localhost6" ||
+          lowercased_host == "localhost6.localdomain6" ||
+          lowercased_host == "localhost6." ||
+          lowercased_host == "localhost6.localdomain6.");
+}
+
 }  // namespace
 
 static base::LazyInstance<std::multiset<int> >::Leaky
     g_explicitly_allowed_ports = LAZY_INSTANCE_INITIALIZER;
 
 size_t GetCountOfExplicitlyAllowedPorts() {
   return g_explicitly_allowed_ports.Get().size();
 }
 
 std::string GetSpecificHeader(const std::string& headers,
@@ skipping 564 matching lines @@
   }
 }
 
 int GetPortFromSockaddr(const struct sockaddr* address, socklen_t address_len) {
   const uint16_t* port_field = GetPortFieldFromSockaddr(address, address_len);
   if (!port_field)
     return -1;
   return base::NetToHost16(*port_field);
 }
 
+bool ResolveLocalHostname(const std::string& host,
+                          uint16_t port,
+                          AddressList* address_list) {
+  const unsigned char kLocalhostIPv4[] = {127, 0, 0, 1};
+  const unsigned char kLocalhostIPv6[] = {
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};

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

nit: Can make these static (so that they're in the rodata section of the
executable)

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

Done.

+
+  address_list->clear();
+
+  bool isLocal6 = IsLocal6Hostname(host);

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

naming: is_local6

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

Done.

+  if (!isLocal6 && !IsLocalHostname(host))
+    return false;
+
+  address_list->push_back(
+      IPEndPoint(IPAddressNumber(kLocalhostIPv6,
+                                 kLocalhostIPv6 + arraysize(kLocalhostIPv6)),
+                 port));
+  if (!isLocal6) {
+    address_list->push_back(
+        IPEndPoint(IPAddressNumber(kLocalhostIPv4,
+                                   kLocalhostIPv4 + arraysize(kLocalhostIPv4)),
+                   port));
+  }
+
+  return true;
+}
+
 bool IsLocalhost(const std::string& host) {
-  if (host == "localhost" || host == "localhost.localdomain" ||
-      host == "localhost6" || host == "localhost6.localdomain6" ||
-      IsLocalhostTLD(host))
+  if (IsLocalHostname(host) || IsLocal6Hostname(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) {
@@ skipping 51 matching lines @@
   };
   const std::string& host = url.host();
   for (const char* suffix : kGoogleHostSuffixes) {
     if (EndsWith(host, suffix, false))
       return true;
   }
   return false;
 }
 
 }  // namespace net