Resolve RFC 6761 localhost names to loopback

net/base/net_util.cc

Index: net/base/net_util.cc
diff --git a/net/base/net_util.cc b/net/base/net_util.cc
index 028b56b74a8bb526b4e486bb1c328efda71005d4..dc03a91817efff39282f517310074706a182eaf6 100644
--- a/net/base/net_util.cc
+++ b/net/base/net_util.cc
@@ -45,6 +45,7 @@
 #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"
@@ -146,6 +147,23 @@ static const int kAllowedFtpPorts[] = {
   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
@@ -730,10 +748,35 @@ int GetPortFromSockaddr(const struct sockaddr* address, socklen_t address_len) {
   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;