Add IP address handling to net::IsHostnameNonUnique

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 <algorithm>
 #include <iterator>
 #include <map>
 
@@ skipping 1373 matching lines @@
 }
 
 std::string GetHostAndOptionalPort(const GURL& url) {
   // For IPv6 literals, GURL::host() already includes the brackets
   // so it is safe to just append a colon.
   if (url.has_port())
     return base::StringPrintf("%s:%s", url.host().c_str(), url.port().c_str());
   return url.host();
 }
 
-// static
 bool IsHostnameNonUnique(const std::string& hostname) {
   // CanonicalizeHost requires surrounding brackets to parse an IPv6 address.
   const std::string host_or_ip = hostname.find(':') != std::string::npos ?
       "[" + hostname + "]" : hostname;
   url_canon::CanonHostInfo host_info;
   std::string canonical_name = CanonicalizeHost(host_or_ip, &host_info);
 
   // If canonicalization fails, then the input is truly malformed. However,
   // to avoid mis-reporting bad inputs as "non-unique", treat them as unique.
   if (canonical_name.empty())
     return false;
 
-  // If |hostname| is an IP address, presume it's unique.
-  // TODO(rsleevi): In the future, this should also reject IP addresses in
-  // IANA-reserved ranges.
-  if (host_info.IsIPAddress())
-    return false;
+  // If |hostname| is an IP address, check to see if it's in an IANA-reserved
+  // range.
+  if (host_info.IsIPAddress()) {
+    switch (host_info.family) {
+      case url_canon::CanonHostInfo::IPV4:
+        return IsIPAddressReserved(hostname, true);
+      case url_canon::CanonHostInfo::IPV6:
+        return IsIPAddressReserved(hostname, false);
+      case url_canon::CanonHostInfo::NEUTRAL:
+      case url_canon::CanonHostInfo::BROKEN:
+        return false;
+    }
+  }
 
   // Check for a registry controlled portion of |hostname|, ignoring private
   // registries, as they already chain to ICANN-administered registries,
   // and explicitly ignoring unknown registries.
   //
   // Note: This means that as new gTLDs are introduced on the Internet, they
   // will be treated as non-unique until the registry controlled domain list
   // is updated. However, because gTLDs are expected to provide significant
   // advance notice to deprecate older versions of this code, this an
   // acceptable tradeoff.
   return 0 == registry_controlled_domains::GetRegistryLength(
                   canonical_name,
                   registry_controlled_domains::EXCLUDE_UNKNOWN_REGISTRIES,
                   registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES);
 }
 
+bool IsIPAddressReserved(const std::string& hostname, bool ipv4) {
+  LOG(INFO) << "IsIPAddressReserved " << hostname;
+  IPAddressNumber host_addr;
+  if (!ParseIPLiteralToNumber(hostname, &host_addr)) return false;

[Ryan Sleevi, 2013/08/07 19:04:44]

nit: linebreak for the if.

[felt, 2013/08/08 19:35:33]

Done.

+
+  // We shouldn't compare IPv4 to IPv6, so we keep separate arrays.
+  static const char* const reserved_ipv4[] = {
+    "0.0.0.0/8", "10.0.0.0/8", "100.64.0.0/10", "127.0.0.0/8",
+    "169.254.0.0/16", "172.16.0.0/12", "192.0.2.0/24", "192.88.99.0/24",
+    "192.168.0.0/16", "198.18.0.0/15", "198.51.100.0/24", "203.0.113.0/24",
+    "224.0.0.0/8", "225.0.0.0/8", "226.0.0.0/8", "227.0.0.0/8", "228.0.0.0/8",
+    "229.0.0.0/8", "230.0.0.0/8", "231.0.0.0/8", "232.0.0.0/8", "233.0.0.0/8",
+    "234.0.0.0/8", "235.0.0.0/8", "236.0.0.0/8", "237.0.0.0/8", "238.0.0.0/8",
+    "239.0.0.0/8", "240.0.0.0/8", "241.0.0.0/8", "242.0.0.0/8", "243.0.0.0/8",
+    "244.0.0.0/8", "245.0.0.0/8", "246.0.0.0/8", "247.0.0.0/8", "248.0.0.0/8",
+    "249.0.0.0/8", "250.0.0.0/8", "251.0.0.0/8", "252.0.0.0/8", "253.0.0.0/8",
+    "254.0.0.0/8", "255.0.0.0/8"
+  };

[Ryan Sleevi, 2013/08/07 19:04:44]

List the sources for these.

eg:
http://www.iana.org/assignments/ipv4-address-space/ipv4-address-space.xhtml
http://www.iana.org/assignments/iana-ipv4-special-registry/iana-ipv4-special-...

[felt, 2013/08/08 19:35:33]

Done.

+  static const char* const reserved_ipv6[] = {
+    "0000::/8", "::1/128", "0100::/8", "0200::/7", "0400::/6", "0800::/5",
+    "1000::/4", "4000::/3", "6000::/3", "8000::/3", "a000::/3", "c000::/3",
+    "e000::/4", "f000::/5", "f800::/6", "FC00::/7", "fe00::/9", "fe80::/10",
+    "fec0::/10"

[Ryan Sleevi, 2013/08/07 19:04:44]

List the sources for this data:

http://www.iana.org/assignments/ipv6-address-space/ipv6-address-space.xhtml

Also, find your minimal ranges - eg: 0000::/8 contains ::1/128, so there's no
need for the subset check.

[felt, 2013/08/08 19:35:33]

Done
Done.

+  };

[Ryan Sleevi, 2013/08/07 19:04:44]

Rather than storing these as strings (and re-parsing on every single function
call), we should be storing these in their parsed bitmask forms.

[felt, 2013/08/08 19:35:33]

Done.

+
+  size_t array_size =
+      ipv4 ? arraysize(reserved_ipv4) : arraysize(reserved_ipv6);
+  for (size_t i = 0; i < array_size; i++) {
+    IPAddressNumber reserved_address;
+    size_t prefix_length;
+    DCHECK(ParseCIDRBlock(ipv4 ? reserved_ipv4[i] : reserved_ipv6[i],
+                          &reserved_address,
+                          &prefix_length));
+    LOG(INFO) << ipv4;
+    LOG(INFO) << i;
+    if (IPNumberMatchesPrefix(host_addr, reserved_address, prefix_length))
+      return true;
+  }
+  return false;
+}
+
 // Extracts the address and port portions of a sockaddr.
 bool GetIPAddressFromSockAddr(const struct sockaddr* sock_addr,
                               socklen_t sock_addr_len,
                               const uint8** address,
                               size_t* address_len,
                               uint16* port) {
   if (sock_addr->sa_family == AF_INET) {
     if (sock_addr_len < static_cast<socklen_t>(sizeof(struct sockaddr_in)))
       return false;
     const struct sockaddr_in* addr =
@@ skipping 643 matching lines @@
 
 NetworkInterface::NetworkInterface(const std::string& name,
                                    const IPAddressNumber& address)
     : name(name), address(address) {
 }
 
 NetworkInterface::~NetworkInterface() {
 }
 
 }  // namespace net