net/base/ip_address_number_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/base/ip_address_number.h"
   6
   7 #include "base/format_macros.h"
   8 #include "base/strings/string_number_conversions.h"
   9 #include "base/strings/stringprintf.h"
  10 #include "net/base/net_util.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13 namespace net {
  14
  15 namespace {
  16
  17 // Helper to strignize an IP number (used to define expectations).
  18 std::string DumpIPNumber(const IPAddressNumber& v) {
  19   std::string out;
  20   for (size_t i = 0; i < v.size(); ++i) {
  21     if (i != 0)
  22       out.append(",");
  23     out.append(base::IntToString(static_cast<int>(v[i])));
  24   }
  25   return out;
  26 }
  27
  28 TEST(IpAddressNumberTest, IPAddressToString) {
  29   uint8_t addr1[4] = {0, 0, 0, 0};
  30   EXPECT_EQ("0.0.0.0", IPAddressToString(addr1, sizeof(addr1)));
  31
  32   uint8_t addr2[4] = {192, 168, 0, 1};
  33   EXPECT_EQ("192.168.0.1", IPAddressToString(addr2, sizeof(addr2)));
  34
  35   uint8_t addr3[16] = {0xFE, 0xDC, 0xBA, 0x98};
  36   EXPECT_EQ("fedc:ba98::", IPAddressToString(addr3, sizeof(addr3)));
  37 }
  38
  39 TEST(IpAddressNumberTest, IPAddressToStringWithPort) {
  40   uint8_t addr1[4] = {0, 0, 0, 0};
  41   EXPECT_EQ("0.0.0.0:3", IPAddressToStringWithPort(addr1, sizeof(addr1), 3));
  42
  43   uint8_t addr2[4] = {192, 168, 0, 1};
  44   EXPECT_EQ("192.168.0.1:99",
  45             IPAddressToStringWithPort(addr2, sizeof(addr2), 99));
  46
  47   uint8_t addr3[16] = {0xFE, 0xDC, 0xBA, 0x98};
  48   EXPECT_EQ("[fedc:ba98::]:8080",
  49             IPAddressToStringWithPort(addr3, sizeof(addr3), 8080));
  50 }
  51
  52 // Test that invalid IP literals fail to parse.
  53 TEST(IpAddressNumberTest, ParseIPLiteralToNumber_FailParse) {
  54   IPAddressNumber number;
  55
  56   EXPECT_FALSE(ParseIPLiteralToNumber("bad value", &number));
  57   EXPECT_FALSE(ParseIPLiteralToNumber("bad:value", &number));
  58   EXPECT_FALSE(ParseIPLiteralToNumber(std::string(), &number));
  59   EXPECT_FALSE(ParseIPLiteralToNumber("192.168.0.1:30", &number));
  60   EXPECT_FALSE(ParseIPLiteralToNumber("  192.168.0.1  ", &number));
  61   EXPECT_FALSE(ParseIPLiteralToNumber("[::1]", &number));
  62 }
  63
  64 // Test parsing an IPv4 literal.
  65 TEST(IpAddressNumberTest, ParseIPLiteralToNumber_IPv4) {
  66   IPAddressNumber number;
  67   EXPECT_TRUE(ParseIPLiteralToNumber("192.168.0.1", &number));
  68   EXPECT_EQ("192,168,0,1", DumpIPNumber(number));
  69   EXPECT_EQ("192.168.0.1", IPAddressToString(number));
  70 }
  71
  72 // Test parsing an IPv6 literal.
  73 TEST(IpAddressNumberTest, ParseIPLiteralToNumber_IPv6) {
  74   IPAddressNumber number;
  75   EXPECT_TRUE(ParseIPLiteralToNumber("1:abcd::3:4:ff", &number));
  76   EXPECT_EQ("0,1,171,205,0,0,0,0,0,0,0,3,0,4,0,255", DumpIPNumber(number));
  77   EXPECT_EQ("1:abcd::3:4:ff", IPAddressToString(number));
  78 }
  79
  80 // Test mapping an IPv4 address to an IPv6 address.
  81 TEST(IpAddressNumberTest, ConvertIPv4NumberToIPv6Number) {
  82   IPAddressNumber ipv4_number;
  83   EXPECT_TRUE(ParseIPLiteralToNumber("192.168.0.1", &ipv4_number));
  84
  85   IPAddressNumber ipv6_number =
  86       ConvertIPv4NumberToIPv6Number(ipv4_number);
  87
  88   // ::ffff:192.168.0.1
  89   EXPECT_EQ("0,0,0,0,0,0,0,0,0,0,255,255,192,168,0,1",
  90             DumpIPNumber(ipv6_number));
  91   EXPECT_EQ("::ffff:c0a8:1", IPAddressToString(ipv6_number));
  92 }
  93
  94 TEST(IpAddressNumberTest, ParseURLHostnameToNumber_FailParse) {
  95   IPAddressNumber number;
  96
  97   EXPECT_FALSE(ParseURLHostnameToNumber("bad value", &number));
  98   EXPECT_FALSE(ParseURLHostnameToNumber("bad:value", &number));
  99   EXPECT_FALSE(ParseURLHostnameToNumber(std::string(), &number));
 100   EXPECT_FALSE(ParseURLHostnameToNumber("192.168.0.1:30", &number));
 101   EXPECT_FALSE(ParseURLHostnameToNumber("  192.168.0.1  ", &number));
 102   EXPECT_FALSE(ParseURLHostnameToNumber("::1", &number));
 103 }
 104
 105 TEST(IpAddressNumberTest, ParseURLHostnameToNumber_IPv4) {
 106   IPAddressNumber number;
 107   EXPECT_TRUE(ParseURLHostnameToNumber("192.168.0.1", &number));
 108   EXPECT_EQ("192,168,0,1", DumpIPNumber(number));
 109   EXPECT_EQ("192.168.0.1", IPAddressToString(number));
 110 }
 111
 112 TEST(IpAddressNumberTest, ParseURLHostnameToNumber_IPv6) {
 113   IPAddressNumber number;
 114   EXPECT_TRUE(ParseURLHostnameToNumber("[1:abcd::3:4:ff]", &number));
 115   EXPECT_EQ("0,1,171,205,0,0,0,0,0,0,0,3,0,4,0,255", DumpIPNumber(number));
 116   EXPECT_EQ("1:abcd::3:4:ff", IPAddressToString(number));
 117 }
 118
 119 TEST(IpAddressNumberTest, IsIPv4Mapped) {
 120   IPAddressNumber ipv4_number;
 121   EXPECT_TRUE(ParseIPLiteralToNumber("192.168.0.1", &ipv4_number));
 122   EXPECT_FALSE(IsIPv4Mapped(ipv4_number));
 123
 124   IPAddressNumber ipv6_number;
 125   EXPECT_TRUE(ParseIPLiteralToNumber("::1", &ipv4_number));
 126   EXPECT_FALSE(IsIPv4Mapped(ipv6_number));
 127
 128   IPAddressNumber ipv4mapped_number;
 129   EXPECT_TRUE(ParseIPLiteralToNumber("::ffff:0101:1", &ipv4mapped_number));
 130   EXPECT_TRUE(IsIPv4Mapped(ipv4mapped_number));
 131 }
 132
 133 TEST(IpAddressNumberTest, ConvertIPv4MappedToIPv4) {
 134   IPAddressNumber ipv4mapped_number;
 135   EXPECT_TRUE(ParseIPLiteralToNumber("::ffff:0101:1", &ipv4mapped_number));
 136   IPAddressNumber expected;
 137   EXPECT_TRUE(ParseIPLiteralToNumber("1.1.0.1", &expected));
 138   IPAddressNumber result = ConvertIPv4MappedToIPv4(ipv4mapped_number);
 139   EXPECT_EQ(expected, result);
 140 }
 141
 142 // Test parsing invalid CIDR notation literals.
 143 TEST(IpAddressNumberTest, ParseCIDRBlock_Invalid) {
 144   const char* const bad_literals[] = {
 145       "foobar",
 146       "",
 147       "192.168.0.1",
 148       "::1",
 149       "/",
 150       "/1",
 151       "1",
 152       "192.168.1.1/-1",
 153       "192.168.1.1/33",
 154       "::1/-3",
 155       "a::3/129",
 156       "::1/x",
 157       "192.168.0.1//11"
 158   };
 159
 160   for (size_t i = 0; i < arraysize(bad_literals); ++i) {
 161     IPAddressNumber ip_number;
 162     size_t prefix_length_in_bits;
 163
 164     EXPECT_FALSE(ParseCIDRBlock(bad_literals[i],
 165                                      &ip_number,
 166                                      &prefix_length_in_bits));
 167   }
 168 }
 169
 170 // Test parsing a valid CIDR notation literal.
 171 TEST(IpAddressNumberTest, ParseCIDRBlock_Valid) {
 172   IPAddressNumber ip_number;
 173   size_t prefix_length_in_bits;
 174
 175   EXPECT_TRUE(ParseCIDRBlock("192.168.0.1/11",
 176                                   &ip_number,
 177                                   &prefix_length_in_bits));
 178
 179   EXPECT_EQ("192,168,0,1", DumpIPNumber(ip_number));
 180   EXPECT_EQ(11u, prefix_length_in_bits);
 181 }
 182
 183 TEST(IpAddressNumberTest, IPNumberMatchesPrefix) {
 184   struct {
 185     const char* const cidr_literal;
 186     const char* const ip_literal;
 187     bool expected_to_match;
 188   } tests[] = {
 189     // IPv4 prefix with IPv4 inputs.
 190     {
 191       "10.10.1.32/27",
 192       "10.10.1.44",
 193       true
 194     },
 195     {
 196       "10.10.1.32/27",
 197       "10.10.1.90",
 198       false
 199     },
 200     {
 201       "10.10.1.32/27",
 202       "10.10.1.90",
 203       false
 204     },
 205
 206     // IPv6 prefix with IPv6 inputs.
 207     {
 208       "2001:db8::/32",
 209       "2001:DB8:3:4::5",
 210       true
 211     },
 212     {
 213       "2001:db8::/32",
 214       "2001:c8::",
 215       false
 216     },
 217
 218     // IPv6 prefix with IPv4 inputs.
 219     {
 220       "2001:db8::/33",
 221       "192.168.0.1",
 222       false
 223     },
 224     {
 225       "::ffff:192.168.0.1/112",
 226       "192.168.33.77",
 227       true
 228     },
 229
 230     // IPv4 prefix with IPv6 inputs.
 231     {
 232       "10.11.33.44/16",
 233       "::ffff:0a0b:89",
 234       true
 235     },
 236     {
 237       "10.11.33.44/16",
 238       "::ffff:10.12.33.44",
 239       false
 240     },
 241   };
 242   for (size_t i = 0; i < arraysize(tests); ++i) {
 243     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: %s, %s", i,
 244                                     tests[i].cidr_literal,
 245                                     tests[i].ip_literal));
 246
 247     IPAddressNumber ip_number;
 248     EXPECT_TRUE(ParseIPLiteralToNumber(tests[i].ip_literal, &ip_number));
 249
 250     IPAddressNumber ip_prefix;
 251     size_t prefix_length_in_bits;
 252
 253     EXPECT_TRUE(ParseCIDRBlock(tests[i].cidr_literal,
 254                                &ip_prefix,
 255                                &prefix_length_in_bits));
 256
 257     EXPECT_EQ(tests[i].expected_to_match,
 258               IPNumberMatchesPrefix(ip_number,
 259                                     ip_prefix,
 260                                     prefix_length_in_bits));
 261   }
 262 }
 263
 264 }  // anonymous namespace
 265
 266 }  // namespace net