folly/test/IPAddressTest.cpp

   1 /*
   2  * Copyright 2017 Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <folly/test/IPAddressTest.h>
  18
  19 #include <folly/Bits.h>
  20 #include <folly/Format.h>
  21 #include <folly/MacAddress.h>
  22 #include <folly/String.h>
  23 #include <folly/detail/IPAddressSource.h>
  24 #include <folly/portability/GMock.h>
  25 #include <folly/portability/GTest.h>
  26
  27 using namespace folly;
  28 using namespace std;
  29
  30 // tests code example
  31 TEST(IPAddress, CodeExample) {
  32   EXPECT_EQ(4, sizeof(IPAddressV4));
  33   EXPECT_EQ(20, sizeof(IPAddressV6));
  34   EXPECT_EQ(24, sizeof(IPAddress));
  35   IPAddress uninitaddr;
  36   IPAddress v4addr("192.0.2.129");
  37   IPAddress v6map("::ffff:192.0.2.129");
  38   ASSERT_TRUE(uninitaddr.empty());
  39   ASSERT_FALSE(v4addr.empty());
  40   ASSERT_FALSE(v6map.empty());
  41   EXPECT_TRUE(v4addr.inSubnet("192.0.2.0/24"));
  42   EXPECT_TRUE(v4addr.inSubnet(IPAddress("192.0.2.0"), 24));
  43   EXPECT_TRUE(v4addr.inSubnet("192.0.2.128/30"));
  44   EXPECT_FALSE(v4addr.inSubnet("192.0.2.128/32"));
  45   EXPECT_EQ(2164392128, v4addr.asV4().toLong());
  46   EXPECT_EQ(3221226113, v4addr.asV4().toLongHBO());
  47   ASSERT_FALSE(uninitaddr.isV4());
  48   ASSERT_FALSE(uninitaddr.isV6());
  49   ASSERT_TRUE(v4addr.isV4());
  50   ASSERT_TRUE(v6map.isV6());
  51   EXPECT_TRUE(v4addr == v6map);
  52   ASSERT_TRUE(v6map.isIPv4Mapped());
  53   EXPECT_TRUE(v4addr.asV4() == IPAddress::createIPv4(v6map));
  54   EXPECT_TRUE(IPAddress::createIPv6(v4addr) == v6map.asV6());
  55 }
  56
  57 TEST(IPAddress, Scope) {
  58   // Test that link-local scope is saved
  59   auto str = "fe80::62eb:69ff:fe9b:ba60%eth0";
  60   IPAddressV6 a2(str);
  61   EXPECT_EQ(str, a2.str());
  62
  63   sockaddr_in6 sock = a2.toSockAddr();
  64   EXPECT_NE(0, sock.sin6_scope_id);
  65
  66   IPAddress a1(str);
  67   EXPECT_EQ(str, a1.str());
  68
  69   a2.setScopeId(0);
  70   EXPECT_NE(a1, a2);
  71
  72   EXPECT_TRUE(a2 < a1);
  73 }
  74
  75 TEST(IPAddress, ScopeNumeric) {
  76   // it's very unlikely that the host running these
  77   // tests will have 42 network interfaces
  78   auto str = "fe80::62eb:69ff:fe9b:ba60%42";
  79   IPAddressV6 a2(str);
  80   EXPECT_EQ(str, a2.str());
  81
  82   sockaddr_in6 sock = a2.toSockAddr();
  83   EXPECT_NE(0, sock.sin6_scope_id);
  84
  85   IPAddress a1(str);
  86   EXPECT_EQ(str, a1.str());
  87
  88   a2.setScopeId(0);
  89   EXPECT_NE(a1, a2);
  90
  91   EXPECT_TRUE(a2 < a1);
  92 }
  93
  94 TEST(IPAddress, Ordering) {
  95   IPAddress a1("0.1.1.1");
  96   IPAddress a2("1.1.1.0");
  97   EXPECT_TRUE(a1 < a2);
  98
  99   IPAddress b1("::ffff:0.1.1.1");
 100   IPAddress b2("::ffff:1.1.1.0");
 101   EXPECT_TRUE(b1 < b2);
 102 }
 103
 104 TEST(IPAddress, InvalidAddressFamilyExceptions) {
 105   // asV4
 106   {
 107     IPAddress addr;
 108     EXPECT_THROW(addr.asV4(), InvalidAddressFamilyException);
 109   }
 110   // asV6
 111   {
 112     IPAddress addr;
 113     EXPECT_THROW(addr.asV6(), InvalidAddressFamilyException);
 114   }
 115   // sockaddr ctor
 116   {
 117     // setup
 118     sockaddr_in addr;
 119     addr.sin_family = AF_UNSPEC;
 120
 121     EXPECT_THROW(IPAddress((sockaddr *)&addr), InvalidAddressFamilyException);
 122   }
 123 }
 124
 125 TEST(IPAddress, CreateNetwork) {
 126   // test valid IPv4 network
 127   {
 128     auto net = IPAddress::createNetwork("192.168.0.1/24");
 129     ASSERT_TRUE(net.first.isV4());
 130     EXPECT_EQ("192.168.0.0", net.first.str());
 131     EXPECT_EQ(24, net.second);
 132     EXPECT_EQ("192.168.0.0/24", IPAddress::networkToString(net));
 133   }
 134   // test valid IPv4 network without applying mask
 135   {
 136     auto net = IPAddress::createNetwork("192.168.0.1/24", -1, false);
 137     ASSERT_TRUE(net.first.isV4());
 138     EXPECT_EQ("192.168.0.1", net.first.str());
 139     EXPECT_EQ(24, net.second);
 140     EXPECT_EQ("192.168.0.1/24", IPAddress::networkToString(net));
 141   }
 142   // test valid IPv6 network
 143   {
 144     auto net = IPAddress::createNetwork("1999::1/24");
 145     ASSERT_TRUE(net.first.isV6());
 146     EXPECT_EQ("1999::", net.first.str());
 147     EXPECT_EQ(24, net.second);
 148     EXPECT_EQ("1999::/24", IPAddress::networkToString(net));
 149   }
 150   // test valid IPv6 network without applying mask
 151   {
 152     auto net = IPAddress::createNetwork("1999::1/24", -1, false);
 153     ASSERT_TRUE(net.first.isV6());
 154     EXPECT_EQ("1999::1", net.first.str());
 155     EXPECT_EQ(24, net.second);
 156     EXPECT_EQ("1999::1/24", IPAddress::networkToString(net));
 157   }
 158   // test empty string
 159   EXPECT_THROW(IPAddress::createNetwork(""), IPAddressFormatException);
 160   // test multi slash string
 161   EXPECT_THROW(IPAddress::createNetwork("192.168.0.1/24/36"),
 162                                         IPAddressFormatException);
 163   // test no slash string with default IPv4
 164   {
 165     auto net = IPAddress::createNetwork("192.168.0.1");
 166     ASSERT_TRUE(net.first.isV4());
 167     EXPECT_EQ("192.168.0.1", net.first.str());
 168     EXPECT_EQ(32, net.second);  // auto-detected
 169     net = IPAddress::createNetwork("192.168.0.1", -1, false);
 170     ASSERT_TRUE(net.first.isV4());
 171     EXPECT_EQ("192.168.0.1", net.first.str());
 172     EXPECT_EQ(32, net.second);
 173   }
 174   // test no slash string with default IPv6
 175   {
 176     auto net = IPAddress::createNetwork("1999::1");
 177     ASSERT_TRUE(net.first.isV6());
 178     EXPECT_EQ("1999::1", net.first.str());
 179     EXPECT_EQ(128, net.second);
 180   }
 181   // test no slash string with invalid default
 182   EXPECT_THROW(IPAddress::createNetwork("192.168.0.1", 33),
 183                IPAddressFormatException);
 184
 185 }
 186
 187 // test assignment operators
 188 TEST(IPAddress, Assignment) {
 189   static const string kIPv4Addr = "69.63.189.16";
 190   static const string kIPv6Addr = "2620:0:1cfe:face:b00c::3";
 191
 192   // Test assigning IPAddressV6 addr to IPAddress (was V4)
 193   {
 194     IPAddress addr(kIPv4Addr);
 195     IPAddressV6 addrV6 = IPAddress(kIPv6Addr).asV6();
 196     EXPECT_TRUE(addr.isV4());
 197     EXPECT_EQ(kIPv4Addr, addr.str());
 198     addr = addrV6;
 199     EXPECT_TRUE(addr.isV6());
 200     EXPECT_EQ(kIPv6Addr, addr.str());
 201   }
 202   // Test assigning IPAddressV4 addr to IPAddress (was V6)
 203   {
 204     IPAddress addr(kIPv6Addr);
 205     IPAddressV4 addrV4 = IPAddress(kIPv4Addr).asV4();
 206     EXPECT_TRUE(addr.isV6());
 207     EXPECT_EQ(kIPv6Addr, addr.str());
 208     addr = addrV4;
 209     EXPECT_TRUE(addr.isV4());
 210     EXPECT_EQ(kIPv4Addr, addr.str());
 211   }
 212   // Test assigning IPAddress(v6) to IPAddress (was v4)
 213   {
 214     IPAddress addr(kIPv4Addr);
 215     IPAddress addrV6 = IPAddress(kIPv6Addr);
 216     EXPECT_TRUE(addr.isV4());
 217     EXPECT_EQ(kIPv4Addr, addr.str());
 218     addr = addrV6;
 219     EXPECT_TRUE(addr.isV6());
 220     EXPECT_EQ(kIPv6Addr, addr.str());
 221   }
 222   // Test assigning IPAddress(v4) to IPAddress (was v6)
 223   {
 224     IPAddress addr(kIPv6Addr);
 225     IPAddress addrV4 = IPAddress(kIPv4Addr);
 226     EXPECT_TRUE(addr.isV6());
 227     EXPECT_EQ(kIPv6Addr, addr.str());
 228     addr = addrV4;
 229     EXPECT_TRUE(addr.isV4());
 230     EXPECT_EQ(kIPv4Addr, addr.str());
 231   }
 232 }
 233
 234 // Test the default constructors
 235 TEST(IPAddress, CtorDefault) {
 236   IPAddressV4 v4;
 237   EXPECT_EQ(IPAddressV4("0.0.0.0"), v4);
 238   IPAddressV6 v6;
 239   EXPECT_EQ(IPAddressV6("::0"), v6);
 240 }
 241
 242 TEST(IPAddressV4, validate) {
 243   EXPECT_TRUE(IPAddressV4::validate("0.0.0.0"));
 244   EXPECT_FALSE(IPAddressV4::validate("0.0.0."));
 245   EXPECT_TRUE(IPAddressV4::validate("127.127.127.127"));
 246 }
 247
 248 TEST(IPAddressV6, validate) {
 249   EXPECT_TRUE(IPAddressV6::validate("2620:0:1cfe:face:b00c::3"));
 250   EXPECT_FALSE(IPAddressV6::validate("0.0.0.0"));
 251   EXPECT_TRUE(IPAddressV6::validate("[2620:0:1cfe:face:b00c::3]"));
 252   EXPECT_TRUE(IPAddressV6::validate("::ffff:0.1.1.1"));
 253   EXPECT_TRUE(IPAddressV6::validate("2620:0000:1cfe:face:b00c:0000:0000:0003"));
 254   EXPECT_TRUE(
 255       IPAddressV6::validate("2620:0000:1cfe:face:b00c:0000:127.127.127.127"));
 256 }
 257
 258 TEST(IPAddress, validate) {
 259   EXPECT_TRUE(IPAddress::validate("0.0.0.0"));
 260   EXPECT_TRUE(IPAddress::validate("::"));
 261   EXPECT_FALSE(IPAddress::validate("asdf"));
 262 }
 263
 264 // Test addresses constructed using a in[6]_addr value
 265 TEST_P(IPAddressTest, CtorAddress) {
 266   AddressData param = GetParam();
 267   IPAddress strAddr(param.address);
 268   IPAddress address;
 269
 270   if (param.version == 4) {
 271     in_addr v4addr = detail::Bytes::mkAddress4(&param.bytes[0]);
 272     address = IPAddress(v4addr);
 273   } else {
 274     in6_addr v6addr = detail::Bytes::mkAddress6(&param.bytes[0]);
 275     address = IPAddress(v6addr);
 276   }
 277   ExpectIsValid(address);
 278   EXPECT_EQ(strAddr, address);
 279 }
 280
 281 // Test addresses constructed using a binary address
 282 TEST_P(IPAddressTest, CtorBinary) {
 283   AddressData param = GetParam();
 284   IPAddress address;
 285
 286   if (param.version == 4) {
 287     in_addr v4addr = AddressData::parseAddress4(param.address);
 288     address = IPAddress::fromBinary(ByteRange((unsigned char*)&v4addr, 4));
 289   } else {
 290     in6_addr v6addr = AddressData::parseAddress6(param.address);
 291     address = IPAddress::fromBinary(ByteRange((unsigned char*)&v6addr, 16));
 292   }
 293
 294   ExpectIsValid(address);
 295   EXPECT_EQ(IPAddress(param.address), address);
 296 }
 297
 298 // Test addresses constructed using a string
 299 TEST_P(IPAddressTest, CtorString) {
 300   AddressData param = GetParam();
 301   IPAddress address(param.address);
 302
 303   ExpectIsValid(address);
 304
 305   // Test the direct version-specific constructor
 306   if (param.version == 4) {
 307     IPAddressV4 v4(param.address);
 308     ExpectIsValid(IPAddress(v4));
 309     EXPECT_THROW(IPAddressV6 v6(param.address), IPAddressFormatException);
 310   } else if (param.version == 6) {
 311     IPAddressV6 v6(param.address);
 312     ExpectIsValid(IPAddress(v6));
 313     EXPECT_THROW(IPAddressV4 v4(param.address), IPAddressFormatException);
 314   }
 315 }
 316
 317 TEST(IPAddress, CtorSockaddr) {
 318   // test v4 address
 319   {
 320     // setup
 321     sockaddr_in addr;
 322     in_addr sin_addr;
 323     sin_addr.s_addr = htonl(2122547223);
 324     addr.sin_family = AF_INET;
 325     addr.sin_addr = sin_addr;
 326
 327     IPAddress ipAddr((sockaddr *)&addr);
 328     EXPECT_TRUE(ipAddr.isV4());
 329     EXPECT_EQ("126.131.128.23", ipAddr.str());
 330   }
 331   // test v6 address
 332   {
 333     // setup
 334     sockaddr_in6 addr;
 335     memset(&addr, 0, sizeof(addr));
 336     in6_addr sin_addr;
 337     ByteArray16 sec{{
 338       // 2620:0:1cfe:face:b00c::3
 339       38,32,0,0,28,254,250,206,176,12,0,0,0,0,0,3
 340     }};
 341     std::memcpy(sin_addr.s6_addr, sec.data(), 16);
 342     addr.sin6_family = AF_INET6;
 343     addr.sin6_addr = sin_addr;
 344
 345     IPAddress ipAddr((sockaddr *)&addr);
 346     EXPECT_TRUE(ipAddr.isV6());
 347     EXPECT_EQ("2620:0:1cfe:face:b00c::3", ipAddr.str());
 348   }
 349   // test nullptr exception
 350   {
 351     sockaddr *addr = nullptr;
 352     EXPECT_THROW(IPAddress((const sockaddr*)addr), IPAddressFormatException);
 353   }
 354   // test invalid family exception
 355   {
 356     // setup
 357     sockaddr_in addr;
 358     in_addr sin_addr;
 359     sin_addr.s_addr = htonl(2122547223);
 360     addr.sin_family = AF_UNSPEC;
 361     addr.sin_addr = sin_addr;
 362
 363     EXPECT_THROW(IPAddress((sockaddr *)&addr), IPAddressFormatException);
 364   }
 365 }
 366
 367 TEST(IPAddress, ToSockaddrStorage) {
 368   // test v4 address
 369   {
 370     string strAddr("126.131.128.23");
 371     IPAddress addr(strAddr);
 372     sockaddr_storage out;
 373
 374     ASSERT_TRUE(addr.isV4()); // test invariant
 375     EXPECT_GT(addr.toSockaddrStorage(&out), 0);
 376
 377     IPAddress sockAddr((sockaddr*)&out);
 378     ASSERT_TRUE(sockAddr.isV4());
 379     EXPECT_EQ(strAddr, sockAddr.str());
 380   }
 381   // test v6 address
 382   {
 383     string strAddr("2620:0:1cfe:face:b00c::3");
 384     IPAddress addr(strAddr);
 385     sockaddr_storage out;
 386
 387     ASSERT_TRUE(addr.isV6()); // test invariant
 388     EXPECT_GT(addr.toSockaddrStorage(&out), 0);
 389
 390     IPAddress sockAddr((sockaddr*)&out);
 391     ASSERT_TRUE(sockAddr.isV6());
 392     EXPECT_EQ(strAddr, sockAddr.str());
 393   }
 394   // test nullptr exception
 395   {
 396     sockaddr_storage *out = nullptr;
 397     IPAddress addr("127.0.0.1");
 398     EXPECT_THROW(addr.toSockaddrStorage(out), IPAddressFormatException);
 399   }
 400   // test invalid family exception
 401   {
 402     IPAddress addr;
 403     sockaddr_storage out;
 404     ASSERT_EQ(AF_UNSPEC, addr.family());
 405     EXPECT_THROW(addr.toSockaddrStorage(&out), InvalidAddressFamilyException);
 406   }
 407 }
 408
 409 TEST(IPAddress, ToString) {
 410   // Test with IPAddressV4
 411   IPAddressV4 addr_10_0_0_1("10.0.0.1");
 412   EXPECT_EQ("10.0.0.1", folly::to<string>(addr_10_0_0_1));
 413   // Test with IPAddressV6
 414   IPAddressV6 addr_1("::1");
 415   EXPECT_EQ("::1", folly::to<string>(addr_1));
 416   // Test with IPAddress, both V4 and V6
 417   IPAddress addr_10_1_2_3("10.1.2.3");
 418   EXPECT_EQ("10.1.2.3", folly::to<string>(addr_10_1_2_3));
 419   IPAddress addr_1_2_3("1:2::3");
 420   EXPECT_EQ("1:2::3", folly::to<string>(addr_1_2_3));
 421
 422   // Test a combination of all the above arguments
 423   EXPECT_EQ("1:2::3 - 10.0.0.1 - ::1 - 10.1.2.3",
 424             folly::to<string>(addr_1_2_3, " - ", addr_10_0_0_1,
 425                               " - ", addr_1, " - ", addr_10_1_2_3));
 426 }
 427
 428 TEST(IPaddress, toInverseArpaName) {
 429   IPAddressV4 addr_ipv4("10.0.0.1");
 430   EXPECT_EQ("1.0.0.10.in-addr.arpa", addr_ipv4.toInverseArpaName());
 431   IPAddressV6 addr_ipv6("2620:0000:1cfe:face:b00c:0000:0000:0003");
 432   EXPECT_EQ(
 433       sformat(
 434           "{}.ip6.arpa",
 435           "3.0.0.0.0.0.0.0.0.0.0.0.c.0.0.b.e.c.a.f.e.f.c.1.0.0.0.0.0.2.6.2"),
 436       addr_ipv6.toInverseArpaName());
 437 }
 438
 439 TEST(IPaddress, fromInverseArpaName) {
 440   EXPECT_EQ(
 441       IPAddressV4("10.0.0.1"),
 442       IPAddressV4::fromInverseArpaName("1.0.0.10.in-addr.arpa"));
 443   EXPECT_EQ(
 444       IPAddressV6("2620:0000:1cfe:face:b00c:0000:0000:0003"),
 445       IPAddressV6::fromInverseArpaName(sformat(
 446           "{}.ip6.arpa",
 447           "3.0.0.0.0.0.0.0.0.0.0.0.c.0.0.b.e.c.a.f.e.f.c.1.0.0.0.0.0.2.6.2")));
 448 }
 449
 450 // Test that invalid string values are killed
 451 TEST_P(IPAddressCtorTest, InvalidCreation) {
 452   string addr = GetParam();
 453   EXPECT_THROW(IPAddress((const string)addr), IPAddressFormatException)
 454       << "IPAddress(" << addr << ") "
 455       << "should have thrown an IPAddressFormatException";
 456 }
 457
 458 // Test that invalid binary values throw an exception
 459 TEST_P(IPAddressCtorBinaryTest, InvalidBinary) {
 460   auto bin = GetParam();
 461   EXPECT_THROW(IPAddress::fromBinary(ByteRange(&bin[0], bin.size())),
 462                IPAddressFormatException);
 463 }
 464
 465 TEST(IPAddressSource, ToHex) {
 466   vector<std::uint8_t> data = {{0xff, 0x20, 0x45}};
 467   EXPECT_EQ(detail::Bytes::toHex(data.data(), 0), "");
 468   EXPECT_EQ(detail::Bytes::toHex(data.data(), 1), "ff");
 469   EXPECT_EQ(detail::Bytes::toHex(data.data(), 2), "ff20");
 470   EXPECT_EQ(detail::Bytes::toHex(data.data(), 3), "ff2045");
 471 }
 472
 473 // Test toFullyQualified()
 474 TEST(IPAddress, ToFullyQualifiedFb) {
 475   IPAddress ip("2620:0:1cfe:face:b00c::3");
 476   EXPECT_EQ("2620:0000:1cfe:face:b00c:0000:0000:0003", ip.toFullyQualified())
 477       << ip;
 478 }
 479 TEST(IPAddress, ToFullyQualifiedLocal) {
 480   IPAddress ip("::1");
 481   EXPECT_EQ("0000:0000:0000:0000:0000:0000:0000:0001", ip.toFullyQualified())
 482       << ip;
 483 }
 484 TEST(IPAddress, ToFullyQualifiedAppendV6) {
 485   IPAddress ip("2620:0:1cfe:face:b00c::3");
 486   std::string result;
 487   ip.toFullyQualifiedAppend(result);
 488   EXPECT_EQ("2620:0000:1cfe:face:b00c:0000:0000:0003", result) << ip;
 489 }
 490 TEST(IPAddress, ToFullyQualifiedAppendV4) {
 491   IPAddress ip("127.0.0.1");
 492   std::string result;
 493   ip.toFullyQualifiedAppend(result);
 494   EXPECT_EQ("127.0.0.1", result) << ip;
 495 }
 496 TEST(IPAddress, ToFullyQualifiedSizeV6) {
 497   auto actual = IPAddressV6::kToFullyQualifiedSize;
 498   auto expected = IPAddress("::").toFullyQualified().size();
 499   EXPECT_EQ(expected, actual);
 500 }
 501 TEST(IPAddress, MaxToFullyQualifiedSizeV4) {
 502   auto actual = IPAddressV4::kMaxToFullyQualifiedSize;
 503   auto expected = IPAddress("255.255.255.255").toFullyQualified().size();
 504   EXPECT_EQ(expected, actual);
 505 }
 506
 507 // test v4-v6 mapped addresses
 508 TEST_P(IPAddressMappedTest, MappedEqual) {
 509   auto param = GetParam();
 510   string mappedIp = param.first;
 511   string otherIp = param.second;
 512
 513   auto mapped = IPAddress(mappedIp);
 514   auto expected = IPAddress(otherIp);
 515
 516   EXPECT_EQ(expected, mapped);
 517
 518   IPAddress v6addr;
 519   if (mapped.isV4()) {
 520     v6addr = mapped.asV4().createIPv6();
 521   } else if (expected.isV4()) {
 522     v6addr = expected.asV4().createIPv6();
 523   }
 524   EXPECT_TRUE(v6addr.isV6());
 525   EXPECT_TRUE(mapped == v6addr);
 526   EXPECT_TRUE(expected == v6addr);
 527 }
 528
 529 // Test subnet mask calculations
 530 TEST_P(IPAddressMaskTest, Masks) {
 531   auto param = GetParam();
 532
 533   IPAddress ip(param.address);
 534   IPAddress masked = ip.mask(param.mask);
 535   EXPECT_EQ(param.subnet, masked.str())
 536       << param.address << "/" << folly::to<std::string>(param.mask) << " -> "
 537       << param.subnet;
 538 }
 539
 540 // Test inSubnet calculations
 541 TEST_P(IPAddressMaskTest, InSubnet) {
 542   auto param = GetParam();
 543
 544   IPAddress ip(param.address);
 545   IPAddress subnet(param.subnet);
 546   EXPECT_TRUE(ip.inSubnet(subnet, param.mask));
 547 }
 548
 549 // Test boundary conditions for subnet calculations
 550 TEST_P(IPAddressMaskBoundaryTest, NonMaskedSubnet) {
 551   auto param = GetParam();
 552   IPAddress ip(param.address);
 553   IPAddress subnet(param.subnet);
 554   EXPECT_EQ(param.inSubnet, ip.inSubnet(subnet, param.mask));
 555 }
 556
 557 TEST(IPAddress, UnitializedEqual) {
 558   IPAddress addrEmpty;
 559   IPAddress ip4("127.0.0.1");
 560   EXPECT_FALSE(addrEmpty == ip4);
 561   EXPECT_FALSE(ip4 == addrEmpty);
 562   IPAddress ip6("::1");
 563   EXPECT_FALSE(addrEmpty == ip6);
 564   EXPECT_FALSE(ip6 == addrEmpty);
 565   IPAddress ip6Map("::ffff:192.0.2.129");
 566   EXPECT_FALSE(addrEmpty == ip6Map);
 567   EXPECT_FALSE(ip6Map == addrEmpty);
 568   IPAddress ip4Zero("0.0.0.0");
 569   EXPECT_FALSE(addrEmpty == ip4Zero);
 570   EXPECT_FALSE(ip4Zero == addrEmpty);
 571   IPAddress ip6Zero("::");
 572   EXPECT_FALSE(addrEmpty == ip6Zero);
 573   EXPECT_FALSE(ip6Zero == addrEmpty);
 574   EXPECT_EQ(addrEmpty, addrEmpty);
 575 }
 576
 577 // Test subnet calcs with 6to4 addresses
 578 TEST(IPAddress, InSubnetWith6to4) {
 579   auto ip = IPAddress("2002:c000:022a::"); // 192.0.2.42
 580   auto subnet = IPAddress("192.0.0.0");
 581   EXPECT_TRUE(ip.inSubnet(subnet, 16));
 582
 583   auto ip2 = IPAddress("192.0.0.1");
 584   auto subnet2 = IPAddress("2002:c000:0000::"); // 192.0.0.0
 585   EXPECT_TRUE(ip2.inSubnet(subnet2, 14));
 586
 587   auto ip3 = IPAddress("2002:c000:022a::"); // 192.0.2.42
 588   auto subnet3 = IPAddress("2002:c000:0000::"); // 192.0.0.0
 589   EXPECT_TRUE(ip3.inSubnet(subnet3, 16));
 590 }
 591
 592 static const vector<string> ipv4Strs = {
 593   "127.0.0.1",
 594   "198.168.0.1",
 595   "8.8.0.0",
 596 };
 597 TEST(IPAddress, getIPv6For6To4) {
 598   for (auto ipv4Str : ipv4Strs) {
 599     auto ip = IPAddress(ipv4Str);
 600     EXPECT_TRUE(ip.isV4());
 601     IPAddressV4 ipv4 = ip.asV4();
 602     auto ipv6 = ipv4.getIPv6For6To4();
 603     EXPECT_EQ(ipv6.type(), IPAddressV6::Type::T6TO4);
 604     auto ipv4New = ipv6.getIPv4For6To4();
 605     EXPECT_TRUE(ipv4Str.compare(ipv4New.str()) == 0);
 606   }
 607 }
 608
 609 static const vector<pair<string, uint8_t> > invalidMasks = {
 610   {"127.0.0.1", 33},
 611   {"::1", 129},
 612 };
 613 TEST(IPAddress, InvalidMask) {
 614   for (auto& tc : invalidMasks) {
 615     auto ip = IPAddress(tc.first);
 616     EXPECT_THROW(ip.mask(tc.second), IPAddressFormatException);
 617   }
 618 }
 619
 620 static const vector<pair<string, IPAddressV6::Type> > v6types = {
 621   {"::1", IPAddressV6::Type::NORMAL},
 622   {"2620:0:1cfe:face:b00c::3", IPAddressV6::Type::NORMAL},
 623   {"2001:0000:4136:e378:8000:63bf:3fff:fdd2", IPAddressV6::Type::TEREDO},
 624   {"2002:c000:022a::", IPAddressV6::Type::T6TO4},
 625 };
 626 TEST(IPAddress, V6Types) {
 627   auto mkName = [&](const IPAddressV6::Type t) -> string {
 628     switch (t) {
 629       case IPAddressV6::Type::TEREDO:
 630         return "teredo";
 631       case IPAddressV6::Type::T6TO4:
 632         return "6to4";
 633       default:
 634         return "default";
 635     }
 636   };
 637
 638   for (auto& tc : v6types) {
 639     auto ip = IPAddress(tc.first);
 640     EXPECT_TRUE(ip.isV6());
 641     IPAddressV6 ipv6 = ip.asV6();
 642     EXPECT_EQ(tc.second, ipv6.type())
 643         << "expected " << mkName(tc.second) << ", got " << mkName(ipv6.type());
 644     switch (tc.second) {
 645       case IPAddressV6::Type::TEREDO:
 646         EXPECT_TRUE(ipv6.isTeredo()) << "isTeredo was false";
 647         EXPECT_FALSE(ipv6.is6To4()) << "is6To4 was true";
 648         break;
 649       case IPAddressV6::Type::T6TO4:
 650         EXPECT_TRUE(ipv6.is6To4()) << "is6To4 was false";
 651         EXPECT_FALSE(ipv6.isTeredo()) << "isTeredo was true";
 652         break;
 653       case IPAddressV6::Type::NORMAL:
 654         EXPECT_FALSE(ipv6.is6To4()) << "is6To4 was true";
 655         EXPECT_FALSE(ipv6.isTeredo()) << "isTeredo was true";
 656         break;
 657       default:
 658         throw std::range_error("Invalid expected type: " +
 659                                folly::to<std::string>(tc.second));
 660     }
 661   }
 662 }
 663
 664 static const vector<pair<string, uint32_t> > provideToLong = {
 665   {"0.0.0.0", 0},
 666   {"10.0.0.0", 167772160},
 667   {"126.131.128.23", 2122547223},
 668   {"192.168.0.0", 3232235520},
 669 };
 670 TEST(IPAddress, ToLong) {
 671   for (auto& tc : provideToLong) {
 672     auto ip = IPAddress(tc.first);
 673     EXPECT_TRUE(ip.isV4());
 674     IPAddressV4 ipv4 = ip.asV4();
 675     EXPECT_EQ(tc.second, ipv4.toLongHBO());
 676
 677     auto ip2 = IPAddress::fromLongHBO(tc.second);
 678     EXPECT_TRUE(ip2.isV4());
 679     EXPECT_TRUE(tc.first.compare(ip2.str()) == 0);
 680     EXPECT_EQ(tc.second, ip2.asV4().toLongHBO());
 681
 682     auto nla = htonl(tc.second);
 683     auto ip3 = IPAddress::fromLong(nla);
 684     EXPECT_TRUE(ip3.isV4());
 685     EXPECT_TRUE(tc.first.compare(ip3.str()) == 0);
 686     EXPECT_EQ(nla, ip3.asV4().toLong());
 687   }
 688 }
 689
 690 TEST(IPAddress, fromBinaryV4) {
 691   for (auto& tc : provideToLong) {
 692     SCOPED_TRACE(tc.first);
 693     union {
 694       uint8_t u8[4];
 695       uint32_t u32;
 696     } data;
 697     data.u32 = Endian::big(tc.second);
 698     ByteRange bytes(data.u8, 4);
 699
 700     auto fromBin = IPAddressV4::fromBinary(bytes);
 701     IPAddressV4 fromStr(tc.first);
 702     EXPECT_EQ(fromStr, fromBin);
 703
 704     IPAddressV4 addr2("0.0.0.0");
 705     addr2 = IPAddressV4::fromBinary(bytes);
 706     EXPECT_EQ(fromStr, addr2);
 707
 708     IPAddress genericAddr = IPAddress::fromBinary(bytes);
 709     ASSERT_TRUE(genericAddr.isV4());
 710     EXPECT_EQ(fromStr, genericAddr.asV4());
 711     EXPECT_EQ(ByteRange(genericAddr.bytes(), genericAddr.byteCount()), bytes);
 712   }
 713
 714   uint8_t data[20];
 715   EXPECT_THROW(IPAddressV4::fromBinary(ByteRange(data, 3)),
 716                IPAddressFormatException);
 717   EXPECT_THROW(IPAddressV4::fromBinary(ByteRange(data, 16)),
 718                IPAddressFormatException);
 719   EXPECT_THROW(IPAddressV4::fromBinary(ByteRange(data, 20)),
 720                IPAddressFormatException);
 721 }
 722
 723 TEST(IPAddress, toBinaryV4) {
 724   for (auto& tc : provideToLong) {
 725     SCOPED_TRACE(tc.first);
 726     union {
 727       uint8_t u8[4];
 728       uint32_t u32;
 729     } data;
 730     data.u32 = Endian::big(tc.second);
 731     ByteRange bytes(data.u8, 4);
 732
 733     auto fromBin = IPAddressV4::fromBinary(bytes);
 734     auto toBin = fromBin.toBinary();
 735     EXPECT_EQ(bytes, toBin);
 736   }
 737 }
 738
 739 static const vector<pair<string, vector<uint8_t> > > provideBinary16Bytes = {
 740   {"::0",
 741     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 742      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
 743   {"1::2",
 744     {0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 745      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02}},
 746   {"fe80::0012:34ff:fe56:78ab",
 747     {0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 748      0x00, 0x12, 0x34, 0xff, 0xfe, 0x56, 0x78, 0xab}},
 749   {"2001:db8:1234:5678:90ab:cdef:8765:4321",
 750     {0x20, 0x01, 0x0d, 0xb8, 0x12, 0x34, 0x56, 0x78,
 751      0x90, 0xab, 0xcd, 0xef, 0x87, 0x65, 0x43, 0x21}},
 752   {"::ffff:0:c0a8:1",
 753     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 754      0xff, 0xff, 0x00, 0x00, 0xc0, 0xa8, 0x00, 0x01}},
 755 };
 756
 757 TEST(IPAddress, fromBinaryV6) {
 758   for (auto& tc : provideBinary16Bytes) {
 759     SCOPED_TRACE(tc.first);
 760     ByteRange bytes(&tc.second.front(), tc.second.size());
 761
 762     auto fromBin = IPAddressV6::fromBinary(bytes);
 763     IPAddressV6 fromStr(tc.first);
 764     EXPECT_EQ(fromStr, fromBin);
 765
 766     IPAddressV6 addr2("::0");
 767     addr2 = IPAddressV6::fromBinary(bytes);
 768     EXPECT_EQ(fromStr, addr2);
 769
 770     IPAddress genericAddr = IPAddress::fromBinary(bytes);
 771     ASSERT_TRUE(genericAddr.isV6());
 772     EXPECT_EQ(fromStr, genericAddr.asV6());
 773     EXPECT_EQ(ByteRange(genericAddr.bytes(), genericAddr.byteCount()), bytes);
 774   }
 775
 776   uint8_t data[20];
 777   EXPECT_THROW(IPAddressV6::fromBinary(ByteRange(data, 3)),
 778                IPAddressFormatException);
 779   EXPECT_THROW(IPAddressV6::fromBinary(ByteRange(data, 4)),
 780                IPAddressFormatException);
 781   EXPECT_THROW(IPAddressV6::fromBinary(ByteRange(data, 20)),
 782                IPAddressFormatException);
 783 }
 784
 785 TEST(IPAddress, toBinaryV6) {
 786   for (auto& tc : provideBinary16Bytes) {
 787     SCOPED_TRACE(tc.first);
 788     ByteRange bytes(&tc.second.front(), tc.second.size());
 789
 790     auto fromBin = IPAddressV6::fromBinary(bytes);
 791     auto toBin = fromBin.toBinary();
 792     EXPECT_EQ(bytes, toBin);
 793   }
 794 }
 795
 796 TEST_P(IPAddressFlagTest, IsLoopback) {
 797   AddressFlags param = GetParam();
 798   IPAddress addr(param.address);
 799
 800   EXPECT_EQ(param.version, addr.version());
 801   EXPECT_EQ(param.isLoopback(), addr.isLoopback());
 802 }
 803
 804 TEST_P(IPAddressFlagTest, IsPrivate) {
 805   AddressFlags param = GetParam();
 806   IPAddress addr(param.address);
 807
 808   EXPECT_EQ(param.version, addr.version());
 809   EXPECT_EQ(param.isPrivate(), addr.isPrivate()) << addr;
 810 }
 811
 812 TEST_P(IPAddressFlagTest, IsNonroutable) {
 813   AddressFlags param = GetParam();
 814   IPAddress addr(param.address);
 815
 816   EXPECT_EQ(param.version, addr.version());
 817   EXPECT_EQ(param.isNonroutable(), addr.isNonroutable()) << addr;
 818 }
 819
 820 TEST_P(IPAddressFlagTest, IsZero) {
 821   AddressFlags param = GetParam();
 822   IPAddress addr(param.address);
 823
 824   EXPECT_EQ(param.version, addr.version());
 825   EXPECT_EQ(param.isZero(), addr.isZero()) << addr;
 826 }
 827
 828 TEST_P(IPAddressFlagTest, IsLinkLocal) {
 829   AddressFlags param = GetParam();
 830   IPAddress addr(param.address);
 831   EXPECT_EQ(param.isLinkLocal(), addr.isLinkLocal()) << addr;
 832 }
 833
 834 TEST(IPAddress, CreateLinkLocal) {
 835   IPAddressV6 addr(IPAddressV6::LINK_LOCAL, MacAddress("00:05:73:f9:46:fc"));
 836   EXPECT_EQ(IPAddressV6("fe80::0205:73ff:fef9:46fc"), addr);
 837
 838   addr = IPAddressV6(IPAddressV6::LINK_LOCAL, MacAddress("02:00:00:12:34:56"));
 839   EXPECT_EQ(IPAddressV6("fe80::ff:fe12:3456"), addr);
 840 }
 841
 842 TEST_P(IPAddressFlagTest, IsLinkLocalBroadcast) {
 843   AddressFlags param = GetParam();
 844   IPAddress addr(param.address);
 845   EXPECT_EQ(param.version, addr.version());
 846   EXPECT_EQ(param.isLinkLocalBroadcast(), addr.isLinkLocalBroadcast());
 847 }
 848
 849 TEST(IPAddress, SolicitedNodeAddress) {
 850   // An example from RFC 4291 section 2.7.1
 851   EXPECT_EQ(IPAddressV6("ff02::1:ff0e:8c6c"),
 852             IPAddressV6("4037::01:800:200e:8c6c").getSolicitedNodeAddress());
 853
 854   // An example from wikipedia
 855   // (http://en.wikipedia.org/wiki/Solicited-node_multicast_address)
 856   EXPECT_EQ(IPAddressV6("ff02::1:ff28:9c5a"),
 857             IPAddressV6("fe80::2aa:ff:fe28:9c5a").getSolicitedNodeAddress());
 858 }
 859
 860 TEST_P(IPAddressByteAccessorTest, CheckBytes) {
 861   auto addrData = GetParam();
 862   IPAddress ip(addrData.address);
 863   size_t i = 0;
 864   for (auto byitr = addrData.bytes.begin(); i < ip.byteCount(); ++i, ++byitr) {
 865     EXPECT_EQ(*byitr, ip.getNthMSByte(i));
 866     EXPECT_EQ(*byitr, ip.isV4() ?
 867           ip.asV4().getNthMSByte(i) : ip.asV6().getNthMSByte(i));
 868   }
 869   i = 0;
 870   for (auto byritr = addrData.bytes.rbegin(); i < ip.byteCount(); ++i,
 871       ++byritr) {
 872     EXPECT_EQ(*byritr, ip.getNthLSByte(i));
 873     EXPECT_EQ(*byritr, ip.isV4() ?
 874         ip.asV4().getNthLSByte(i) : ip.asV6().getNthLSByte(i));
 875   }
 876 }
 877
 878 TEST_P(IPAddressBitAccessorTest, CheckBits) {
 879   auto addrData = GetParam();
 880   auto littleEndianAddrData = addrData.bytes;
 881   //IPAddress stores address data in n/w byte order.
 882   reverse(littleEndianAddrData.begin(), littleEndianAddrData.end());
 883   //Bit iterator goes from LSBit to MSBit
 884   //We will traverse the IPAddress bits from 0 to bitCount -1
 885   auto bitr = folly::makeBitIterator(littleEndianAddrData.begin());
 886   IPAddress ip(addrData.address);
 887   for (size_t i = 0; i < ip.bitCount(); ++i) {
 888     auto msbIndex = ip.bitCount() - i - 1;
 889     EXPECT_EQ(*bitr, ip.getNthMSBit(msbIndex));
 890     EXPECT_EQ(*bitr, ip.isV4() ? ip.asV4().getNthMSBit(msbIndex) :
 891           ip.asV6().getNthMSBit(msbIndex));
 892     EXPECT_EQ(*bitr, ip.getNthLSBit(i));
 893     EXPECT_EQ(*bitr, ip.isV4() ? ip.asV4().getNthLSBit(i) :
 894         ip.asV6().getNthLSBit(i));
 895     ++bitr;
 896   }
 897 }
 898
 899 TEST(IPAddress, InvalidByteAccess) {
 900   IPAddress ip4("10.10.10.10");
 901   //MSByte, LSByte accessors are 0 indexed
 902   EXPECT_THROW(ip4.getNthMSByte(ip4.byteCount()), std::invalid_argument);
 903   EXPECT_THROW(ip4.getNthLSByte(ip4.byteCount()), std::invalid_argument);
 904   EXPECT_THROW(ip4.getNthMSByte(-1), std::invalid_argument);
 905   EXPECT_THROW(ip4.getNthLSByte(-1), std::invalid_argument);
 906   auto asV4 = ip4.asV4();
 907   EXPECT_THROW(asV4.getNthMSByte(asV4.byteCount()), std::invalid_argument);
 908   EXPECT_THROW(asV4.getNthLSByte(asV4.byteCount()), std::invalid_argument);
 909   EXPECT_THROW(asV4.getNthMSByte(-1), std::invalid_argument);
 910   EXPECT_THROW(asV4.getNthLSByte(-1), std::invalid_argument);
 911
 912   IPAddress ip6("2620:0:1cfe:face:b00c::3");
 913   EXPECT_THROW(ip6.getNthMSByte(ip6.byteCount()), std::invalid_argument);
 914   EXPECT_THROW(ip6.getNthLSByte(ip6.byteCount()), std::invalid_argument);
 915   EXPECT_THROW(ip6.getNthMSByte(-1), std::invalid_argument);
 916   EXPECT_THROW(ip6.getNthLSByte(-1), std::invalid_argument);
 917   auto asV6 = ip6.asV6();
 918   EXPECT_THROW(asV6.getNthMSByte(asV6.byteCount()), std::invalid_argument);
 919   EXPECT_THROW(asV6.getNthLSByte(asV6.byteCount()), std::invalid_argument);
 920   EXPECT_THROW(asV6.getNthMSByte(-1), std::invalid_argument);
 921   EXPECT_THROW(asV6.getNthLSByte(-1), std::invalid_argument);
 922
 923 }
 924
 925 TEST(IPAddress, InvalidBBitAccess) {
 926   IPAddress ip4("10.10.10.10");
 927   //MSByte, LSByte accessors are 0 indexed
 928   EXPECT_THROW(ip4.getNthMSBit(ip4.bitCount()), std::invalid_argument);
 929   EXPECT_THROW(ip4.getNthLSBit(ip4.bitCount()), std::invalid_argument);
 930   EXPECT_THROW(ip4.getNthMSBit(-1), std::invalid_argument);
 931   EXPECT_THROW(ip4.getNthLSBit(-1), std::invalid_argument);
 932   auto asV4 = ip4.asV4();
 933   EXPECT_THROW(asV4.getNthMSBit(asV4.bitCount()), std::invalid_argument);
 934   EXPECT_THROW(asV4.getNthLSBit(asV4.bitCount()), std::invalid_argument);
 935   EXPECT_THROW(asV4.getNthMSBit(-1), std::invalid_argument);
 936   EXPECT_THROW(asV4.getNthLSBit(-1), std::invalid_argument);
 937
 938   IPAddress ip6("2620:0:1cfe:face:b00c::3");
 939   EXPECT_THROW(ip6.getNthMSBit(ip6.bitCount()), std::invalid_argument);
 940   EXPECT_THROW(ip6.getNthLSBit(ip6.bitCount()), std::invalid_argument);
 941   EXPECT_THROW(ip6.getNthMSBit(-1), std::invalid_argument);
 942   EXPECT_THROW(ip6.getNthLSBit(-1), std::invalid_argument);
 943   auto asV6 = ip6.asV6();
 944   EXPECT_THROW(asV6.getNthMSBit(asV6.bitCount()), std::invalid_argument);
 945   EXPECT_THROW(asV6.getNthLSBit(asV6.bitCount()), std::invalid_argument);
 946   EXPECT_THROW(asV6.getNthMSBit(-1), std::invalid_argument);
 947   EXPECT_THROW(asV6.getNthLSBit(-1), std::invalid_argument);
 948 }
 949
 950 TEST(IPAddress, StringFormat) {
 951   in6_addr a6;
 952   for (int i = 0; i < 8; ++i) {
 953     auto t = htons(0x0123 + ((i % 4) * 0x4444));
 954 #ifdef _WIN32
 955     a6.u.Word[i] = t;
 956 #else
 957     a6.s6_addr16[i] = t;
 958 #endif
 959   }
 960   EXPECT_EQ("0123:4567:89ab:cdef:0123:4567:89ab:cdef",
 961             detail::fastIpv6ToString(a6));
 962
 963   in_addr a4;
 964   a4.s_addr = htonl(0x01020304);
 965   EXPECT_EQ("1.2.3.4", detail::fastIpv4ToString(a4));
 966 }
 967
 968 TEST(IPAddress, getMacAddressFromLinkLocal) {
 969   IPAddressV6 ip6("fe80::f652:14ff:fec5:74d8");
 970   EXPECT_TRUE(ip6.getMacAddressFromLinkLocal().hasValue());
 971   EXPECT_EQ("f4:52:14:c5:74:d8", ip6.getMacAddressFromLinkLocal()->toString());
 972 }
 973
 974 TEST(IPAddress, getMacAddressFromLinkLocal_Negative) {
 975   IPAddressV6 no_link_local_ip6("2803:6082:a2:4447::1");
 976   EXPECT_FALSE(no_link_local_ip6.getMacAddressFromLinkLocal().hasValue());
 977   no_link_local_ip6 = IPAddressV6("fe80::f652:14ff:ccc5:74d8");
 978   EXPECT_FALSE(no_link_local_ip6.getMacAddressFromLinkLocal().hasValue());
 979   no_link_local_ip6 = IPAddressV6("fe80::f652:14ff:ffc5:74d8");
 980   EXPECT_FALSE(no_link_local_ip6.getMacAddressFromLinkLocal().hasValue());
 981   no_link_local_ip6 = IPAddressV6("fe81::f652:14ff:ffc5:74d8");
 982   EXPECT_FALSE(no_link_local_ip6.getMacAddressFromLinkLocal().hasValue());
 983 }
 984
 985 TEST(IPAddress, LongestCommonPrefix) {
 986   IPAddress ip10("10.0.0.0");
 987   IPAddress ip11("11.0.0.0");
 988   IPAddress ip12("12.0.0.0");
 989   IPAddress ip128("128.0.0.0");
 990   IPAddress ip10dot10("10.10.0.0");
 991   auto prefix = IPAddress::longestCommonPrefix({ip10, 8}, {ip128, 8});
 992   auto prefix4 = IPAddressV4::longestCommonPrefix({ip10.asV4(), 8},
 993                                                   {ip128.asV4(), 8});
 994   // No bits match b/w 128/8 and 10/8
 995   EXPECT_EQ(IPAddress("0.0.0.0"), prefix.first);
 996   EXPECT_EQ(0, prefix.second);
 997   EXPECT_EQ(IPAddressV4("0.0.0.0"), prefix4.first);
 998   EXPECT_EQ(0, prefix4.second);
 999
1000   prefix = IPAddress::longestCommonPrefix({ip10, 8}, {ip10dot10, 16});
1001   prefix4 = IPAddressV4::longestCommonPrefix({ip10.asV4(), 8},
1002                                              {ip10dot10.asV4(), 16});
1003   // Between 10/8 and 10.10/16, 10/8 is the longest common match
1004   EXPECT_EQ(ip10, prefix.first);
1005   EXPECT_EQ(8, prefix.second);
1006   EXPECT_EQ(ip10.asV4(), prefix4.first);
1007   EXPECT_EQ(8, prefix4.second);
1008
1009   prefix = IPAddress::longestCommonPrefix({ip11, 8}, {ip12, 8});
1010   prefix4 = IPAddressV4::longestCommonPrefix({ip11.asV4(), 8},
1011                                              {ip12.asV4(), 8});
1012   // 12 = 1100, 11 = 1011, longest match - 1000 = 8
1013   EXPECT_EQ(IPAddress("8.0.0.0"), prefix.first);
1014   EXPECT_EQ(5, prefix.second);
1015   EXPECT_EQ(IPAddressV4("8.0.0.0"), prefix4.first);
1016   EXPECT_EQ(5, prefix4.second);
1017
1018   // Between 128/1 and 128/2, longest match 128/1
1019   prefix = IPAddress::longestCommonPrefix({ip128, 1}, {ip128, 2});
1020   prefix4 = IPAddressV4::longestCommonPrefix({ip128.asV4(), 1},
1021                                              {ip128.asV4(), 2});
1022   EXPECT_EQ(ip128, prefix.first);
1023   EXPECT_EQ(1, prefix.second);
1024   EXPECT_EQ(ip128.asV4(), prefix4.first);
1025   EXPECT_EQ(1, prefix4.second);
1026
1027   IPAddress ip6("2620:0:1cfe:face:b00c::3");
1028   prefix = IPAddress::longestCommonPrefix({ip6, ip6.bitCount()},
1029                                           {ip6, ip6.bitCount()});
1030   auto prefix6 = IPAddressV6::longestCommonPrefix(
1031     {ip6.asV6(), IPAddressV6::bitCount()},
1032     {ip6.asV6(), IPAddressV6::bitCount()});
1033   // Longest common b/w me and myself is myself
1034   EXPECT_EQ(ip6, prefix.first);
1035   EXPECT_EQ(ip6.bitCount(), prefix.second);
1036   EXPECT_EQ(ip6.asV6(), prefix6.first);
1037   EXPECT_EQ(ip6.asV6().bitCount(), prefix6.second);
1038
1039   IPAddress ip6Zero("::");
1040   prefix = IPAddress::longestCommonPrefix({ip6, ip6.bitCount()}, {ip6Zero, 0});
1041   prefix6 = IPAddressV6::longestCommonPrefix(
1042     {ip6.asV6(), IPAddressV6::bitCount()},
1043     {ip6Zero.asV6(), 0});
1044   // Longest common b/w :: (ipv6 equivalent of 0/0) is ::
1045   EXPECT_EQ(ip6Zero, prefix.first);
1046   EXPECT_EQ(0, prefix.second);
1047
1048   // Exceptional cases
1049   EXPECT_THROW(IPAddress::longestCommonPrefix({ip10, 8}, {ip6, 128}),
1050                std::invalid_argument);
1051   EXPECT_THROW(IPAddress::longestCommonPrefix({ip10, ip10.bitCount() + 1},
1052                                               {ip10, 8}),
1053                std::invalid_argument);
1054   EXPECT_THROW(IPAddressV4::longestCommonPrefix(
1055                  {ip10.asV4(), IPAddressV4::bitCount() + 1},
1056                  {ip10.asV4(), 8}),
1057                std::invalid_argument);
1058   EXPECT_THROW(IPAddress::longestCommonPrefix({ip6, ip6.bitCount() + 1},
1059                                               {ip6, ip6.bitCount()}),
1060                std::invalid_argument);
1061   EXPECT_THROW(IPAddressV6::longestCommonPrefix(
1062                  {ip6.asV6(), IPAddressV6::bitCount() + 1},
1063                  {ip6.asV6(), IPAddressV6::bitCount()}),
1064                std::invalid_argument);
1065
1066 }
1067
1068 static const vector<AddressData> validAddressProvider = {
1069   AddressData("127.0.0.1", {127,0,0,1}, 4),
1070   AddressData("69.63.189.16", {69,63,189,16}, 4),
1071   AddressData("0.0.0.0", {0,0,0,0}, 4),
1072   AddressData("::1",
1073               {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1}, 6),
1074   AddressData("2620:0:1cfe:face:b00c::3",
1075               {38,32,0,0,28,254,250,206,176,12,0,0,0,0,0,3}, 6),
1076 };
1077
1078 static const vector<string> invalidAddressProvider = {
1079   "",
1080   "foo",
1081   "1.1.1.256",
1082   "1",
1083   ":1",
1084   "127.0.0.1,127.0.0.1",
1085   "[1234]",
1086 };
1087
1088 static const vector<ByteVector> invalidBinaryProvider = {
1089   {0x31, 0x32, 0x37, 0x2e, 0x30, 0x30, 0x2e, 0x30, 0x2e, 0x31},
1090   // foo
1091   {0x66, 0x6f, 0x6f},
1092   {0x00},
1093   {0x00, 0x00},
1094   {0x00, 0x00, 0x00},
1095   {0x00, 0x00, 0x00, 0x00, 0x00},
1096   {0xff},
1097 };
1098
1099 static const uint8_t IS_LOCAL = AddressFlags::IS_LOCAL;
1100 static const uint8_t IS_NONROUTABLE = AddressFlags::IS_NONROUTABLE;
1101 static const uint8_t IS_PRIVATE = AddressFlags::IS_PRIVATE;
1102 static const uint8_t IS_ZERO = AddressFlags::IS_ZERO;
1103 static const uint8_t IS_LINK_LOCAL =
1104   AddressFlags::IS_LINK_LOCAL | IS_NONROUTABLE;
1105 static const uint8_t IS_PVT_NONROUTE = IS_NONROUTABLE | IS_PRIVATE;
1106 static const uint8_t IS_MULTICAST = AddressFlags::IS_MULTICAST;
1107 static const uint8_t IS_LINK_LOCAL_BROADCAST =
1108 AddressFlags::IS_LINK_LOCAL_BROADCAST;
1109
1110 static vector<AddressFlags> flagProvider = {
1111   // public v4
1112   AddressFlags("69.63.176.1", 4, 0),
1113   AddressFlags("128.12.65.3", 4, 0),
1114   AddressFlags("192.0.1.0", 4, 0),
1115   AddressFlags("198.51.101.0", 4, 0),
1116   AddressFlags("203.0.114.0", 4, 0),
1117   AddressFlags("128.12.64.115", 4, 0),
1118
1119   // public v6
1120   AddressFlags("2620:0:1cfe:face:b00c::3", 6, 0),
1121
1122   // localhost
1123   AddressFlags("127.0.0.1", 4, IS_LOCAL | IS_PVT_NONROUTE),
1124   AddressFlags("::1", 6, IS_LOCAL | IS_PVT_NONROUTE),
1125
1126   // link-local v4
1127   AddressFlags("169.254.0.1", 4, IS_LINK_LOCAL | IS_PVT_NONROUTE),
1128
1129   // private v4
1130   AddressFlags("10.0.0.0", 4, IS_PVT_NONROUTE),
1131   AddressFlags("10.11.12.13", 4, IS_PVT_NONROUTE),
1132   AddressFlags("10.255.255.255", 4, IS_PVT_NONROUTE),
1133   AddressFlags("127.128.129.200", 4, IS_LOCAL | IS_PVT_NONROUTE),
1134   AddressFlags("127.255.255.255", 4, IS_LOCAL | IS_PVT_NONROUTE),
1135   AddressFlags("169.254.0.0", 4, IS_LINK_LOCAL | IS_PVT_NONROUTE),
1136   AddressFlags("192.168.0.0", 4, IS_PVT_NONROUTE),
1137   AddressFlags("192.168.200.255", 4, IS_PVT_NONROUTE),
1138   AddressFlags("192.168.255.255", 4, IS_PVT_NONROUTE),
1139
1140   // private v6
1141   AddressFlags("fd01:1637:1c56:66af::", 6, IS_PVT_NONROUTE),
1142
1143   // non routable v4
1144   AddressFlags("0.0.0.0", 4, IS_NONROUTABLE | IS_ZERO),
1145   AddressFlags("0.255.255.255", 4, IS_NONROUTABLE),
1146   AddressFlags("192.0.0.0", 4, IS_NONROUTABLE),
1147   AddressFlags("192.0.2.0", 4, IS_NONROUTABLE),
1148   AddressFlags("198.18.0.0", 4, IS_NONROUTABLE),
1149   AddressFlags("198.19.255.255", 4, IS_NONROUTABLE),
1150   AddressFlags("198.51.100.0", 4, IS_NONROUTABLE),
1151   AddressFlags("198.51.100.255", 4, IS_NONROUTABLE),
1152   AddressFlags("203.0.113.0", 4, IS_NONROUTABLE),
1153   AddressFlags("203.0.113.255", 4, IS_NONROUTABLE),
1154   AddressFlags("224.0.0.0", 4, IS_NONROUTABLE | IS_MULTICAST),
1155   AddressFlags("240.0.0.0", 4, IS_NONROUTABLE),
1156   AddressFlags("224.0.0.0", 4, IS_NONROUTABLE),
1157   // v4 link local broadcast
1158   AddressFlags("255.255.255.255", 4, IS_NONROUTABLE | IS_LINK_LOCAL_BROADCAST),
1159
1160   // non routable v6
1161   AddressFlags("1999::1", 6, IS_NONROUTABLE),
1162   AddressFlags("0::0", 6, IS_NONROUTABLE | IS_ZERO),
1163   AddressFlags("0::0:0", 6, IS_NONROUTABLE | IS_ZERO),
1164   AddressFlags("0:0:0::0", 6, IS_NONROUTABLE | IS_ZERO),
1165
1166   // link-local v6
1167   AddressFlags("fe80::0205:73ff:fef9:46fc", 6, IS_LINK_LOCAL),
1168   AddressFlags("fe80::0012:34ff:fe56:7890", 6, IS_LINK_LOCAL),
1169
1170   // multicast v4
1171   AddressFlags("224.0.0.1", 4, IS_MULTICAST | IS_NONROUTABLE) ,
1172   AddressFlags("224.0.0.251", 4, IS_MULTICAST | IS_NONROUTABLE),
1173   AddressFlags("239.12.34.56", 4, IS_MULTICAST | IS_NONROUTABLE),
1174
1175   // multicast v6
1176   AddressFlags("ff00::", 6, IS_MULTICAST | IS_NONROUTABLE),
1177   AddressFlags("ff02:ffff::1", 6, IS_MULTICAST | IS_NONROUTABLE),
1178   AddressFlags("ff02::101", 6, IS_MULTICAST | IS_NONROUTABLE),
1179   AddressFlags("ff0e::101", 6, IS_MULTICAST),
1180   // v6 link local broadcast
1181   AddressFlags("ff02::1", 6, IS_NONROUTABLE | IS_LINK_LOCAL_BROADCAST),
1182 };
1183
1184 static const vector<pair<string, string> > mapProvider = {
1185   {"::ffff:192.0.2.128", "192.0.2.128"},
1186   {"192.0.2.128", "::ffff:192.0.2.128"},
1187   {"::FFFF:129.144.52.38", "129.144.52.38"},
1188   {"129.144.52.38", "::FFFF:129.144.52.38"},
1189   {"0:0:0:0:0:FFFF:222.1.41.90", "222.1.41.90"},
1190   {"::FFFF:222.1.41.90", "222.1.41.90"},
1191 };
1192
1193 static const vector<MaskData> masksProvider = {
1194   MaskData("255.255.255.255", 1, "128.0.0.0"),
1195   MaskData("255.255.255.255", 2, "192.0.0.0"),
1196   MaskData("192.0.2.42", 16, "192.0.0.0"),
1197   MaskData("255.255.255.255", 24, "255.255.255.0"),
1198   MaskData("255.255.255.255", 32, "255.255.255.255"),
1199   MaskData("10.10.10.10", 0, "0.0.0.0"),
1200   MaskData("::1", 64, "::"),
1201   MaskData("2620:0:1cfe:face:b00c::3", 1, "::"),
1202   MaskData("2620:0:1cfe:face:b00c::3", 3, "2000::"),
1203   MaskData("2620:0:1cfe:face:b00c::3", 6, "2400::"),
1204   MaskData("2620:0:1cfe:face:b00c::3", 7, "2600::"),
1205   MaskData("2620:0:1cfe:face:b00c::3", 11, "2620::"),
1206   MaskData("2620:0:1cfe:face:b00c::3", 36, "2620:0:1000::"),
1207   MaskData("2620:0:1cfe:face:b00c::3", 37, "2620:0:1800::"),
1208   MaskData("2620:0:1cfe:face:b00c::3", 38, "2620:0:1c00::"),
1209   MaskData("2620:0:1cfe:face:b00c::3", 41, "2620:0:1c80::"),
1210   MaskData("2620:0:1cfe:face:b00c::3", 42, "2620:0:1cc0::"),
1211   MaskData("2620:0:1cfe:face:b00c::3", 43, "2620:0:1ce0::"),
1212   MaskData("2620:0:1cfe:face:b00c::3", 44, "2620:0:1cf0::"),
1213   MaskData("2620:0:1cfe:face:b00c::3", 45, "2620:0:1cf8::"),
1214   MaskData("2620:0:1cfe:face:b00c::3", 46, "2620:0:1cfc::"),
1215   MaskData("2620:0:1cfe:face:b00c::3", 47, "2620:0:1cfe::"),
1216   MaskData("2620:0:1cfe:face:b00c::3", 49, "2620:0:1cfe:8000::"),
1217   MaskData("2620:0:1cfe:face:b00c::3", 50, "2620:0:1cfe:c000::"),
1218   MaskData("2620:0:1cfe:face:b00c::3", 51, "2620:0:1cfe:e000::"),
1219   MaskData("2620:0:1cfe:face:b00c::3", 52, "2620:0:1cfe:f000::"),
1220   MaskData("2620:0:1cfe:face:b00c::3", 53, "2620:0:1cfe:f800::"),
1221   MaskData("2620:0:1cfe:face:b00c::3", 55, "2620:0:1cfe:fa00::"),
1222   MaskData("2620:0:1cfe:face:b00c::3", 57, "2620:0:1cfe:fa80::"),
1223   MaskData("2620:0:1cfe:face:b00c::3", 58, "2620:0:1cfe:fac0::"),
1224   MaskData("2620:0:1cfe:face:b00c::3", 61, "2620:0:1cfe:fac8::"),
1225   MaskData("2620:0:1cfe:face:b00c::3", 62, "2620:0:1cfe:facc::"),
1226   MaskData("2620:0:1cfe:face:b00c::3", 63, "2620:0:1cfe:face::"),
1227   MaskData("2620:0:1cfe:face:b00c::3", 65, "2620:0:1cfe:face:8000::"),
1228   MaskData("2620:0:1cfe:face:b00c::3", 67, "2620:0:1cfe:face:a000::"),
1229   MaskData("2620:0:1cfe:face:b00c::3", 68, "2620:0:1cfe:face:b000::"),
1230   MaskData("2620:0:1cfe:face:b00c::3", 77, "2620:0:1cfe:face:b008::"),
1231   MaskData("2620:0:1cfe:face:b00c::3", 78, "2620:0:1cfe:face:b00c::"),
1232   MaskData("2620:0:1cfe:face:b00c::3", 127, "2620:0:1cfe:face:b00c::2"),
1233   MaskData("2620:0:1cfe:face:b00c::3", 128, "2620:0:1cfe:face:b00c::3"),
1234   MaskData("2620:0:1cfe:face:b00c::3", 0, "::")
1235 };
1236
1237 static const vector<MaskBoundaryData> maskBoundaryProvider = {
1238   MaskBoundaryData("10.1.1.1", 24, "10.1.1.1", true),
1239   MaskBoundaryData("10.1.1.1", 8, "10.1.2.3", true),
1240   MaskBoundaryData("2620:0:1cfe:face:b00c::1", 48, "2620:0:1cfe::", true),
1241   // addresses that are NOT in the same subnet once mask is applied
1242   MaskBoundaryData("10.1.1.1", 24, "10.1.2.1", false),
1243   MaskBoundaryData("10.1.1.1", 16, "10.2.3.4", false),
1244   MaskBoundaryData("2620:0:1cfe:face:b00c::1", 48, "2620:0:1cfc::", false),
1245 };
1246
1247 INSTANTIATE_TEST_CASE_P(IPAddress,
1248                         IPAddressTest,
1249                         ::testing::ValuesIn(validAddressProvider));
1250 INSTANTIATE_TEST_CASE_P(IPAddress,
1251                         IPAddressFlagTest,
1252                         ::testing::ValuesIn(flagProvider));
1253 INSTANTIATE_TEST_CASE_P(IPAddress,
1254                         IPAddressMappedTest,
1255                         ::testing::ValuesIn(mapProvider));
1256 INSTANTIATE_TEST_CASE_P(IPAddress,
1257                         IPAddressCtorTest,
1258                         ::testing::ValuesIn(invalidAddressProvider));
1259 INSTANTIATE_TEST_CASE_P(IPAddress,
1260                         IPAddressCtorBinaryTest,
1261                         ::testing::ValuesIn(invalidBinaryProvider));
1262 INSTANTIATE_TEST_CASE_P(IPAddress,
1263                         IPAddressMaskTest,
1264                         ::testing::ValuesIn(masksProvider));
1265 INSTANTIATE_TEST_CASE_P(IPAddress,
1266                         IPAddressMaskBoundaryTest,
1267                         ::testing::ValuesIn(maskBoundaryProvider));
1268 INSTANTIATE_TEST_CASE_P(IPAddress,
1269                         IPAddressByteAccessorTest,
1270                         ::testing::ValuesIn(validAddressProvider));
1271 INSTANTIATE_TEST_CASE_P(IPAddress,
1272                         IPAddressBitAccessorTest,
1273                         ::testing::ValuesIn(validAddressProvider));
1274
1275 TEST(IPAddressV4, fetchMask) {
1276   struct X : private IPAddressV4 {
1277     using IPAddressV4::fetchMask;
1278   };
1279
1280   EXPECT_THAT(
1281       X::fetchMask(0),
1282       ::testing::ElementsAreArray(ByteArray4{{0x00, 0x00, 0x00, 0x00}}));
1283
1284   EXPECT_THAT(
1285       X::fetchMask(1),
1286       ::testing::ElementsAreArray(ByteArray4{{0x80, 0x00, 0x00, 0x00}}));
1287
1288   EXPECT_THAT(
1289       X::fetchMask(31),
1290       ::testing::ElementsAreArray(ByteArray4{{0xff, 0xff, 0xff, 0xfe}}));
1291
1292   EXPECT_THAT(
1293       X::fetchMask(32),
1294       ::testing::ElementsAreArray(ByteArray4{{0xff, 0xff, 0xff, 0xff}}));
1295 }
1296
1297 TEST(IPAddressV6, fetchMask) {
1298   using ByteArray8 = std::array<uint8_t, 8>;
1299
1300   struct X : private IPAddressV6 {
1301     using IPAddressV6::fetchMask;
1302   };
1303
1304   auto join = [](std::array<ByteArray8, 2> parts) {
1305     ByteArray16 _return;
1306     std::memcpy(_return.data(), parts.data(), _return.size());
1307     return _return;
1308   };
1309
1310   EXPECT_THAT(
1311       X::fetchMask(0),
1312       ::testing::ElementsAreArray(join({{
1313           ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
1314           ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
1315       }})));
1316
1317   EXPECT_THAT(
1318       X::fetchMask(1),
1319       ::testing::ElementsAreArray(join({{
1320           ByteArray8{{0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
1321           ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
1322       }})));
1323
1324   EXPECT_THAT(
1325       X::fetchMask(63),
1326       ::testing::ElementsAreArray(join({{
1327           ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe}},
1328           ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
1329       }})));
1330
1331   EXPECT_THAT(
1332       X::fetchMask(64),
1333       ::testing::ElementsAreArray(join({{
1334           ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
1335           ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
1336       }})));
1337
1338   EXPECT_THAT(
1339       X::fetchMask(65),
1340       ::testing::ElementsAreArray(join({{
1341           ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
1342           ByteArray8{{0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
1343       }})));
1344
1345   EXPECT_THAT(
1346       X::fetchMask(127),
1347       ::testing::ElementsAreArray(join({{
1348           ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
1349           ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe}},
1350       }})));
1351
1352   EXPECT_THAT(
1353       X::fetchMask(128),
1354       ::testing::ElementsAreArray(join({{
1355           ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
1356           ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
1357       }})));
1358 }