Move some net::IPAddressNumber implementations to net::IPAddress.

net/base/ip_address_number.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/ip_address_number.h"
 
 #include <limits.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 "url/gurl.h"
 #include "url/url_canon_ip.h"
 
 namespace net {
 
-namespace {
-
-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;
-  }
-
-  // In case the prefix was not a multiple of 8, there will be 1 byte
-  // which is only partially masked.
-  int remaining_bits = prefix_length_in_bits % 8;
-  if (remaining_bits != 0) {
-    unsigned char mask = 0xFF << (8 - remaining_bits);
-    int i = num_entire_bytes_in_prefix;
-    if ((ip_number[i] & mask) != (ip_prefix[i] & mask))
-      return false;
-  }
-  return true;
-}
-
-}  // namespace
-
-// Don't compare IPv4 and IPv6 addresses (they have different range
-// reservations). Keep separate reservation arrays for each IP type, and
-// consolidate adjacent reserved ranges within a reservation array when
-// possible.
-// Sources for info:
-// www.iana.org/assignments/ipv4-address-space/ipv4-address-space.xhtml
-// www.iana.org/assignments/ipv6-address-space/ipv6-address-space.xhtml
-// They're formatted here with the prefix as the last element. For example:
-// 10.0.0.0/8 becomes 10,0,0,0,8 and fec0::/10 becomes 0xfe,0xc0,0,0,0...,10.
-bool IsIPAddressReserved(const IPAddressNumber& host_addr) {
-  static const unsigned char kReservedIPv4[][5] = {
-      { 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,3 }
-  };
-  static const unsigned char kReservedIPv6[][17] = {
-      { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8 },
-      { 0x40,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2 },
-      { 0x80,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2 },
-      { 0xc0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3 },
-      { 0xe0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4 },
-      { 0xf0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5 },
-      { 0xf8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6 },
-      { 0xfc,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7 },
-      { 0xfe,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9 },
-      { 0xfe,0x80,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10 },
-      { 0xfe,0xc0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10 },
-  };
-  size_t array_size = 0;
-  const unsigned char* array = NULL;
-  switch (host_addr.size()) {
-    case kIPv4AddressSize:
-      array_size = arraysize(kReservedIPv4);
-      array = kReservedIPv4[0];
-      break;
-    case kIPv6AddressSize:
-      array_size = arraysize(kReservedIPv6);
-      array = kReservedIPv6[0];
-      break;
-  }
-  if (!array)
-    return false;
-  size_t width = host_addr.size() + 1;
-  for (size_t i = 0; i < array_size; ++i, array += width) {
-    if (IPNumberPrefixCheck(host_addr, array, array[width-1]))
-      return true;
-  }
-  return false;
-}
-
 std::string IPAddressToString(const uint8_t* address, size_t address_len) {
   std::string str;
   url::StdStringCanonOutput output(&str);
 
   if (address_len == kIPv4AddressSize) {
     url::AppendIPv4Address(address, &output);
   } else if (address_len == kIPv6AddressSize) {
     url::AppendIPv6Address(address, &output);
   }
 
@@ skipping 82 matching lines @@
                     address.begin() + arraysize(kIPv4MappedPrefix),
                     kIPv4MappedPrefix);
 }
 
 IPAddressNumber ConvertIPv4MappedToIPv4(const IPAddressNumber& address) {
   DCHECK(IsIPv4Mapped(address));
   return IPAddressNumber(address.begin() + arraysize(kIPv4MappedPrefix),
                          address.end());
 }
 
-bool IPNumberMatchesPrefix(const IPAddressNumber& ip_number,
-                           const IPAddressNumber& ip_prefix,
-                           size_t prefix_length_in_bits) {
-  // Both the input IP address and the prefix IP address should be
-  // either IPv4 or IPv6.
-  DCHECK(ip_number.size() == 4 || ip_number.size() == 16);
-  DCHECK(ip_prefix.size() == 4 || ip_prefix.size() == 16);
-
-  DCHECK_LE(prefix_length_in_bits, ip_prefix.size() * 8);
-
-  // In case we have an IPv6 / IPv4 mismatch, convert the IPv4 addresses to
-  // IPv6 addresses in order to do the comparison.
-  if (ip_number.size() != ip_prefix.size()) {
-    if (ip_number.size() == 4) {
-      return IPNumberMatchesPrefix(ConvertIPv4NumberToIPv6Number(ip_number),
-                                   ip_prefix, prefix_length_in_bits);
-    }
-    return IPNumberMatchesPrefix(ip_number,
-                                 ConvertIPv4NumberToIPv6Number(ip_prefix),
-                                 96 + prefix_length_in_bits);
-  }
-
-  return IPNumberPrefixCheck(ip_number, &ip_prefix[0], prefix_length_in_bits);
-}
-
 unsigned CommonPrefixLength(const IPAddressNumber& a1,
                             const IPAddressNumber& a2) {
   DCHECK_EQ(a1.size(), a2.size());
   for (size_t i = 0; i < a1.size(); ++i) {
     unsigned diff = a1[i] ^ a2[i];
     if (!diff)
       continue;
     for (unsigned j = 0; j < CHAR_BIT; ++j) {
       if (diff & (1 << (CHAR_BIT - 1)))
         return i * CHAR_BIT + j;
       diff <<= 1;
     }
     NOTREACHED();
   }
   return a1.size() * CHAR_BIT;
 }
 
 unsigned MaskPrefixLength(const IPAddressNumber& mask) {
   IPAddressNumber all_ones(mask.size(), 0xFF);
   return CommonPrefixLength(mask, all_ones);
 }
 
 }  // namespace net