2 * Copyright 2014 Facebook, Inc.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 #include "IPAddressTest.h"
19 #include <gtest/gtest.h>
21 #include <folly/Bits.h>
22 #include <folly/Format.h>
23 #include <folly/String.h>
24 #include <folly/MacAddress.h>
26 using namespace folly;
30 TEST(IPAddress, CodeExample) {
31 EXPECT_EQ(4, sizeof(IPAddressV4));
32 EXPECT_EQ(16, sizeof(IPAddressV6));
33 EXPECT_EQ(20, sizeof(IPAddress));
34 IPAddress v4addr("192.0.2.129");
35 IPAddress v6map("::ffff:192.0.2.129");
36 EXPECT_TRUE(v4addr.inSubnet("192.0.2.0/24"));
37 EXPECT_TRUE(v4addr.inSubnet(IPAddress("192.0.2.0"), 24));
38 EXPECT_TRUE(v4addr.inSubnet("192.0.2.128/30"));
39 EXPECT_FALSE(v4addr.inSubnet("192.0.2.128/32"));
40 EXPECT_EQ(2164392128, v4addr.asV4().toLong());
41 EXPECT_EQ(3221226113, v4addr.asV4().toLongHBO());
42 ASSERT_TRUE(v4addr.isV4());
43 ASSERT_TRUE(v6map.isV6());
44 EXPECT_TRUE(v4addr == v6map);
45 ASSERT_TRUE(v6map.isIPv4Mapped());
46 EXPECT_TRUE(v4addr.asV4() == IPAddress::createIPv4(v6map));
47 EXPECT_TRUE(IPAddress::createIPv6(v4addr) == v6map.asV6());
50 TEST(IPAddress, Ordering) {
51 IPAddress a1("0.1.1.1");
52 IPAddress a2("1.1.1.0");
55 IPAddress b1("::ffff:0.1.1.1");
56 IPAddress b2("::ffff:1.1.1.0");
60 TEST(IPAddress, InvalidAddressFamilyExceptions) {
64 EXPECT_THROW(addr.asV4(), InvalidAddressFamilyException);
69 EXPECT_THROW(addr.asV6(), InvalidAddressFamilyException);
75 addr.sin_family = AF_UNSPEC;
77 EXPECT_THROW(IPAddress((sockaddr *)&addr), InvalidAddressFamilyException);
81 TEST(IPAddress, CreateNetwork) {
82 // test valid IPv4 network
84 auto net = IPAddress::createNetwork("192.168.0.1/24");
85 ASSERT_TRUE(net.first.isV4());
86 EXPECT_EQ("192.168.0.0", net.first.str());
87 EXPECT_EQ(24, net.second);
88 EXPECT_EQ("192.168.0.0/24", IPAddress::networkToString(net));
90 // test valid IPv4 network without applying mask
92 auto net = IPAddress::createNetwork("192.168.0.1/24", -1, false);
93 ASSERT_TRUE(net.first.isV4());
94 EXPECT_EQ("192.168.0.1", net.first.str());
95 EXPECT_EQ(24, net.second);
96 EXPECT_EQ("192.168.0.1/24", IPAddress::networkToString(net));
98 // test valid IPv6 network
100 auto net = IPAddress::createNetwork("1999::1/24");
101 ASSERT_TRUE(net.first.isV6());
102 EXPECT_EQ("1999::", net.first.str());
103 EXPECT_EQ(24, net.second);
104 EXPECT_EQ("1999::/24", IPAddress::networkToString(net));
106 // test valid IPv6 network without applying mask
108 auto net = IPAddress::createNetwork("1999::1/24", -1, false);
109 ASSERT_TRUE(net.first.isV6());
110 EXPECT_EQ("1999::1", net.first.str());
111 EXPECT_EQ(24, net.second);
112 EXPECT_EQ("1999::1/24", IPAddress::networkToString(net));
115 EXPECT_THROW(IPAddress::createNetwork(""), IPAddressFormatException);
116 // test multi slash string
117 EXPECT_THROW(IPAddress::createNetwork("192.168.0.1/24/36"),
118 IPAddressFormatException);
119 // test no slash string with default IPv4
121 auto net = IPAddress::createNetwork("192.168.0.1");
122 ASSERT_TRUE(net.first.isV4());
123 EXPECT_EQ("192.168.0.1", net.first.str());
124 EXPECT_EQ(32, net.second); // auto-detected
125 net = IPAddress::createNetwork("192.168.0.1", -1, false);
126 ASSERT_TRUE(net.first.isV4());
127 EXPECT_EQ("192.168.0.1", net.first.str());
128 EXPECT_EQ(32, net.second);
130 // test no slash string with default IPv6
132 auto net = IPAddress::createNetwork("1999::1");
133 ASSERT_TRUE(net.first.isV6());
134 EXPECT_EQ("1999::1", net.first.str());
135 EXPECT_EQ(128, net.second);
137 // test no slash string with invalid default
138 EXPECT_THROW(IPAddress::createNetwork("192.168.0.1", 33),
139 IPAddressFormatException);
143 // test assignment operators
144 TEST(IPAddress, Assignment) {
145 static const string kIPv4Addr = "69.63.189.16";
146 static const string kIPv6Addr = "2620:0:1cfe:face:b00c::3";
148 // Test assigning IPAddressV6 addr to IPAddress (was V4)
150 IPAddress addr(kIPv4Addr);
151 IPAddressV6 addrV6 = IPAddress(kIPv6Addr).asV6();
152 EXPECT_TRUE(addr.isV4());
153 EXPECT_EQ(kIPv4Addr, addr.str());
155 EXPECT_TRUE(addr.isV6());
156 EXPECT_EQ(kIPv6Addr, addr.str());
158 // Test assigning IPAddressV4 addr to IPAddress (was V6)
160 IPAddress addr(kIPv6Addr);
161 IPAddressV4 addrV4 = IPAddress(kIPv4Addr).asV4();
162 EXPECT_TRUE(addr.isV6());
163 EXPECT_EQ(kIPv6Addr, addr.str());
165 EXPECT_TRUE(addr.isV4());
166 EXPECT_EQ(kIPv4Addr, addr.str());
168 // Test assigning IPAddress(v6) to IPAddress (was v4)
170 IPAddress addr(kIPv4Addr);
171 IPAddress addrV6 = IPAddress(kIPv6Addr);
172 EXPECT_TRUE(addr.isV4());
173 EXPECT_EQ(kIPv4Addr, addr.str());
175 EXPECT_TRUE(addr.isV6());
176 EXPECT_EQ(kIPv6Addr, addr.str());
178 // Test assigning IPAddress(v4) to IPAddress (was v6)
180 IPAddress addr(kIPv6Addr);
181 IPAddress addrV4 = IPAddress(kIPv4Addr);
182 EXPECT_TRUE(addr.isV6());
183 EXPECT_EQ(kIPv6Addr, addr.str());
185 EXPECT_TRUE(addr.isV4());
186 EXPECT_EQ(kIPv4Addr, addr.str());
190 // Test the default constructors
191 TEST(IPAddress, CtorDefault) {
193 EXPECT_EQ(IPAddressV4("0.0.0.0"), v4);
195 EXPECT_EQ(IPAddressV6("::0"), v6);
198 // Test addresses constructed using a in[6]_addr value
199 TEST_P(IPAddressTest, CtorAddress) {
200 AddressData param = GetParam();
201 IPAddress strAddr(param.address);
204 if (param.version == 4) {
205 in_addr v4addr = detail::Bytes::mkAddress4(¶m.bytes[0]);
206 address = IPAddress(v4addr);
208 in6_addr v6addr = detail::Bytes::mkAddress6(¶m.bytes[0]);
209 address = IPAddress(v6addr);
211 ExpectIsValid(address);
212 EXPECT_EQ(strAddr, address);
215 // Test addresses constructed using a binary address
216 TEST_P(IPAddressTest, CtorBinary) {
217 AddressData param = GetParam();
220 if (param.version == 4) {
221 in_addr v4addr = AddressData::parseAddress4(param.address);
222 address = IPAddress::fromBinary(ByteRange((unsigned char*)&v4addr, 4));
224 in6_addr v6addr = AddressData::parseAddress6(param.address);
225 address = IPAddress::fromBinary(ByteRange((unsigned char*)&v6addr, 16));
228 ExpectIsValid(address);
229 EXPECT_EQ(IPAddress(param.address), address);
232 // Test addresses constructed using a string
233 TEST_P(IPAddressTest, CtorString) {
234 AddressData param = GetParam();
235 IPAddress address(param.address);
237 ExpectIsValid(address);
239 // Test the direct version-specific constructor
240 if (param.version == 4) {
241 IPAddressV4 v4(param.address);
242 ExpectIsValid(IPAddress(v4));
243 EXPECT_THROW(IPAddressV6 v6(param.address), IPAddressFormatException);
244 } else if (param.version == 6) {
245 IPAddressV6 v6(param.address);
246 ExpectIsValid(IPAddress(v6));
247 EXPECT_THROW(IPAddressV4 v4(param.address), IPAddressFormatException);
251 TEST(IPAddress, CtorSockaddr) {
257 sin_addr.s_addr = htonl(2122547223);
258 addr.sin_family = AF_INET;
259 addr.sin_addr = sin_addr;
261 IPAddress ipAddr((sockaddr *)&addr);
262 EXPECT_TRUE(ipAddr.isV4());
263 EXPECT_EQ("126.131.128.23", ipAddr.str());
271 // 2620:0:1cfe:face:b00c::3
272 38,32,0,0,28,254,250,206,176,12,0,0,0,0,0,3
274 std::memcpy(sin_addr.s6_addr, sec.data(), 16);
275 addr.sin6_family = AF_INET6;
276 addr.sin6_addr = sin_addr;
278 IPAddress ipAddr((sockaddr *)&addr);
279 EXPECT_TRUE(ipAddr.isV6());
280 EXPECT_EQ("2620:0:1cfe:face:b00c::3", ipAddr.str());
282 // test nullptr exception
284 sockaddr *addr = nullptr;
285 EXPECT_THROW(IPAddress((const sockaddr*)addr), IPAddressFormatException);
287 // test invalid family exception
292 sin_addr.s_addr = htonl(2122547223);
293 addr.sin_family = AF_UNSPEC;
294 addr.sin_addr = sin_addr;
296 EXPECT_THROW(IPAddress((sockaddr *)&addr), IPAddressFormatException);
300 TEST(IPAddress, ToSockaddrStorage) {
303 string strAddr("126.131.128.23");
304 IPAddress addr(strAddr);
305 sockaddr_storage out;
307 ASSERT_TRUE(addr.isV4()); // test invariant
308 EXPECT_GT(addr.toSockaddrStorage(&out), 0);
310 IPAddress sockAddr((sockaddr*)&out);
311 ASSERT_TRUE(sockAddr.isV4());
312 EXPECT_EQ(strAddr, sockAddr.str());
316 string strAddr("2620:0:1cfe:face:b00c::3");
317 IPAddress addr(strAddr);
318 sockaddr_storage out;
320 ASSERT_TRUE(addr.isV6()); // test invariant
321 EXPECT_GT(addr.toSockaddrStorage(&out), 0);
323 IPAddress sockAddr((sockaddr*)&out);
324 ASSERT_TRUE(sockAddr.isV6());
325 EXPECT_EQ(strAddr, sockAddr.str());
327 // test nullptr exception
329 sockaddr_storage *out = nullptr;
330 IPAddress addr("127.0.0.1");
331 EXPECT_THROW(addr.toSockaddrStorage(out), IPAddressFormatException);
333 // test invalid family exception
336 sockaddr_storage out;
337 ASSERT_EQ(AF_UNSPEC, addr.family());
338 EXPECT_THROW(addr.toSockaddrStorage(&out), InvalidAddressFamilyException);
342 TEST(IPAddress, ToString) {
343 // Test with IPAddressV4
344 IPAddressV4 addr_10_0_0_1("10.0.0.1");
345 EXPECT_EQ("10.0.0.1", folly::to<string>(addr_10_0_0_1));
346 // Test with IPAddressV6
347 IPAddressV6 addr_1("::1");
348 EXPECT_EQ("::1", folly::to<string>(addr_1));
349 // Test with IPAddress, both V4 and V6
350 IPAddress addr_10_1_2_3("10.1.2.3");
351 EXPECT_EQ("10.1.2.3", folly::to<string>(addr_10_1_2_3));
352 IPAddress addr_1_2_3("1:2::3");
353 EXPECT_EQ("1:2::3", folly::to<string>(addr_1_2_3));
355 // Test a combination of all the above arguments
356 EXPECT_EQ("1:2::3 - 10.0.0.1 - ::1 - 10.1.2.3",
357 folly::to<string>(addr_1_2_3, " - ", addr_10_0_0_1,
358 " - ", addr_1, " - ", addr_10_1_2_3));
361 // Test that invalid string values are killed
362 TEST_P(IPAddressCtorTest, InvalidCreation) {
363 string addr = GetParam();
364 EXPECT_THROW(IPAddress((const string)addr), IPAddressFormatException)
365 << "IPAddress(" << addr << ") "
366 << "should have thrown an IPAddressFormatException";
369 // Test that invalid binary values throw an exception
370 TEST_P(IPAddressCtorBinaryTest, InvalidBinary) {
371 auto bin = GetParam();
372 EXPECT_THROW(IPAddress::fromBinary(ByteRange(&bin[0], bin.size())),
373 IPAddressFormatException);
376 // Test toFullyQualified()
377 TEST(IPAddress, ToFullyQualifiedFb) {
378 IPAddress ip("2620:0:1cfe:face:b00c::3");
379 EXPECT_EQ("2620:0000:1cfe:face:b00c:0000:0000:0003", ip.toFullyQualified())
382 TEST(IPAddress, ToFullyQualifiedLocal) {
384 EXPECT_EQ("0000:0000:0000:0000:0000:0000:0000:0001", ip.toFullyQualified())
388 // test v4-v6 mapped addresses
389 TEST_P(IPAddressMappedTest, MappedEqual) {
390 auto param = GetParam();
391 string mappedIp = param.first;
392 string otherIp = param.second;
394 auto mapped = IPAddress(mappedIp);
395 auto expected = IPAddress(otherIp);
397 EXPECT_EQ(expected, mapped);
401 v6addr = mapped.asV4().createIPv6();
402 } else if (expected.isV4()) {
403 v6addr = expected.asV4().createIPv6();
405 EXPECT_TRUE(v6addr.isV6());
406 EXPECT_TRUE(mapped == v6addr);
407 EXPECT_TRUE(expected == v6addr);
410 // Test subnet mask calculations
411 TEST_P(IPAddressMaskTest, Masks) {
412 auto param = GetParam();
414 IPAddress ip(param.address);
415 IPAddress masked = ip.mask(param.mask);
416 EXPECT_EQ(param.subnet, masked.str())
417 << param.address << "/" << to_string(param.mask)
418 << " -> " << param.subnet;
421 // Test inSubnet calculations
422 TEST_P(IPAddressMaskTest, InSubnet) {
423 auto param = GetParam();
425 IPAddress ip(param.address);
426 IPAddress subnet(param.subnet);
427 EXPECT_TRUE(ip.inSubnet(subnet, param.mask));
430 // Test boundary conditions for subnet calculations
431 TEST_P(IPAddressMaskBoundaryTest, NonMaskedSubnet) {
432 auto param = GetParam();
433 IPAddress ip(param.address);
434 IPAddress subnet(param.subnet);
435 EXPECT_EQ(param.inSubnet, ip.inSubnet(subnet, param.mask));
438 // Test subnet calcs with 6to4 addresses
439 TEST(IPAddress, InSubnetWith6to4) {
440 auto ip = IPAddress("2002:c000:022a::"); // 192.0.2.42
441 auto subnet = IPAddress("192.0.0.0");
442 EXPECT_TRUE(ip.inSubnet(subnet, 16));
444 auto ip2 = IPAddress("192.0.0.1");
445 auto subnet2 = IPAddress("2002:c000:0000::"); // 192.0.0.0
446 EXPECT_TRUE(ip2.inSubnet(subnet2, 14));
448 auto ip3 = IPAddress("2002:c000:022a::"); // 192.0.2.42
449 auto subnet3 = IPAddress("2002:c000:0000::"); // 192.0.0.0
450 EXPECT_TRUE(ip3.inSubnet(subnet3, 16));
453 static vector<pair<string, uint8_t> > invalidMasks = {
457 TEST(IPAddress, InvalidMask) {
458 for (auto& tc : invalidMasks) {
459 uint8_t mask = tc.second;
460 auto ip = IPAddress(tc.first);
461 EXPECT_THROW(ip.mask(tc.second), IPAddressFormatException);
465 static vector<pair<string, IPAddressV6::Type> > v6types = {
466 {"::1", IPAddressV6::Type::NORMAL},
467 {"2620:0:1cfe:face:b00c::3", IPAddressV6::Type::NORMAL},
468 {"2001:0000:4136:e378:8000:63bf:3fff:fdd2", IPAddressV6::Type::TEREDO},
469 {"2002:c000:022a::", IPAddressV6::Type::T6TO4},
471 TEST(IPAddress, V6Types) {
472 auto mkName = [&](const IPAddressV6::Type t) -> string {
474 case IPAddressV6::Type::TEREDO:
476 case IPAddressV6::Type::T6TO4:
483 for (auto& tc : v6types) {
484 auto ip = IPAddress(tc.first);
485 EXPECT_TRUE(ip.isV6());
486 IPAddressV6 ipv6 = ip.asV6();
487 EXPECT_EQ(tc.second, ipv6.type())
488 << "expected " << mkName(tc.second) << ", got " << mkName(ipv6.type());
490 case IPAddressV6::Type::TEREDO:
491 EXPECT_TRUE(ipv6.isTeredo()) << "isTeredo was false";
492 EXPECT_FALSE(ipv6.is6To4()) << "is6To4 was true";
494 case IPAddressV6::Type::T6TO4:
495 EXPECT_TRUE(ipv6.is6To4()) << "is6To4 was false";
496 EXPECT_FALSE(ipv6.isTeredo()) << "isTeredo was true";
498 case IPAddressV6::Type::NORMAL:
499 EXPECT_FALSE(ipv6.is6To4()) << "is6To4 was true";
500 EXPECT_FALSE(ipv6.isTeredo()) << "isTeredo was true";
503 throw std::range_error("Invalid expected type: " +
504 to_string(tc.second));
509 static vector<pair<string, uint32_t> > provideToLong = {
511 {"10.0.0.0", 167772160},
512 {"126.131.128.23", 2122547223},
513 {"192.168.0.0", 3232235520},
515 TEST(IPAddress, ToLong) {
516 for (auto& tc : provideToLong) {
517 auto ip = IPAddress(tc.first);
518 EXPECT_TRUE(ip.isV4());
519 IPAddressV4 ipv4 = ip.asV4();
520 EXPECT_EQ(tc.second, ipv4.toLongHBO());
522 auto ip2 = IPAddress::fromLongHBO(tc.second);
523 EXPECT_TRUE(ip2.isV4());
524 EXPECT_TRUE(tc.first.compare(ip2.str()) == 0);
525 EXPECT_EQ(tc.second, ip2.asV4().toLongHBO());
527 auto nla = htonl(tc.second);
528 auto ip3 = IPAddress::fromLong(nla);
529 EXPECT_TRUE(ip3.isV4());
530 EXPECT_TRUE(tc.first.compare(ip3.str()) == 0);
531 EXPECT_EQ(nla, ip3.asV4().toLong());
535 TEST(IPAddress, fromBinaryV4) {
536 for (auto& tc : provideToLong) {
537 SCOPED_TRACE(tc.first);
542 data.u32 = Endian::big(tc.second);
543 ByteRange bytes(data.u8, 4);
545 auto fromBin = IPAddressV4::fromBinary(bytes);
546 IPAddressV4 fromStr(tc.first);
547 EXPECT_EQ(fromStr, fromBin);
549 IPAddressV4 addr2("0.0.0.0");
550 addr2 = IPAddressV4::fromBinary(bytes);
551 EXPECT_EQ(fromStr, addr2);
553 IPAddress genericAddr = IPAddress::fromBinary(bytes);
554 ASSERT_TRUE(genericAddr.isV4());
555 EXPECT_EQ(fromStr, genericAddr.asV4());
556 EXPECT_EQ(ByteRange(genericAddr.bytes(), genericAddr.byteCount()), bytes);
560 EXPECT_THROW(IPAddressV4::fromBinary(ByteRange(data, 3)),
561 IPAddressFormatException);
562 EXPECT_THROW(IPAddressV4::fromBinary(ByteRange(data, 16)),
563 IPAddressFormatException);
564 EXPECT_THROW(IPAddressV4::fromBinary(ByteRange(data, 20)),
565 IPAddressFormatException);
568 static vector<pair<string, vector<uint8_t> > > provideBinary16Bytes = {
570 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
571 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
573 {0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
574 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02}},
575 {"fe80::0012:34ff:fe56:78ab",
576 {0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
577 0x00, 0x12, 0x34, 0xff, 0xfe, 0x56, 0x78, 0xab}},
578 {"2001:db8:1234:5678:90ab:cdef:8765:4321",
579 {0x20, 0x01, 0x0d, 0xb8, 0x12, 0x34, 0x56, 0x78,
580 0x90, 0xab, 0xcd, 0xef, 0x87, 0x65, 0x43, 0x21}},
582 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
583 0xff, 0xff, 0x00, 0x00, 0xc0, 0xa8, 0x00, 0x01}},
586 TEST(IPAddress, fromBinaryV6) {
587 for (auto& tc : provideBinary16Bytes) {
588 SCOPED_TRACE(tc.first);
589 ByteRange bytes(&tc.second.front(), tc.second.size());
591 auto fromBin = IPAddressV6::fromBinary(bytes);
592 IPAddressV6 fromStr(tc.first);
593 EXPECT_EQ(fromStr, fromBin);
595 IPAddressV6 addr2("::0");
596 addr2 = IPAddressV6::fromBinary(bytes);
597 EXPECT_EQ(fromStr, addr2);
599 IPAddress genericAddr = IPAddress::fromBinary(bytes);
600 ASSERT_TRUE(genericAddr.isV6());
601 EXPECT_EQ(fromStr, genericAddr.asV6());
602 EXPECT_EQ(ByteRange(genericAddr.bytes(), genericAddr.byteCount()), bytes);
606 EXPECT_THROW(IPAddressV6::fromBinary(ByteRange(data, 3)),
607 IPAddressFormatException);
608 EXPECT_THROW(IPAddressV6::fromBinary(ByteRange(data, 4)),
609 IPAddressFormatException);
610 EXPECT_THROW(IPAddressV6::fromBinary(ByteRange(data, 20)),
611 IPAddressFormatException);
614 TEST_P(IPAddressFlagTest, IsLoopback) {
615 AddressFlags param = GetParam();
616 IPAddress addr(param.address);
618 EXPECT_EQ(param.version, addr.version());
619 EXPECT_EQ(param.isLoopback(), addr.isLoopback());
622 TEST_P(IPAddressFlagTest, IsPrivate) {
623 AddressFlags param = GetParam();
624 IPAddress addr(param.address);
626 EXPECT_EQ(param.version, addr.version());
627 EXPECT_EQ(param.isPrivate(), addr.isPrivate()) << addr;
630 TEST_P(IPAddressFlagTest, IsNonroutable) {
631 AddressFlags param = GetParam();
632 IPAddress addr(param.address);
634 EXPECT_EQ(param.version, addr.version());
635 EXPECT_EQ(param.isNonroutable(), addr.isNonroutable()) << addr;
638 TEST_P(IPAddressFlagTest, IsZero) {
639 AddressFlags param = GetParam();
640 IPAddress addr(param.address);
642 EXPECT_EQ(param.version, addr.version());
643 EXPECT_EQ(param.isZero(), addr.isZero()) << addr;
646 TEST_P(IPAddressFlagTest, IsLinkLocal) {
647 AddressFlags param = GetParam();
648 if (param.version != 6) {
651 IPAddressV6 addr(param.address);
652 EXPECT_EQ(param.isLinkLocal(), addr.isLinkLocal()) << addr;
655 TEST(IPAddress, CreateLinkLocal) {
656 IPAddressV6 addr(IPAddressV6::LINK_LOCAL, MacAddress("00:05:73:f9:46:fc"));
657 EXPECT_EQ(IPAddressV6("fe80::0205:73ff:fef9:46fc"), addr);
659 addr = IPAddressV6(IPAddressV6::LINK_LOCAL, MacAddress("02:00:00:12:34:56"));
660 EXPECT_EQ(IPAddressV6("fe80::ff:fe12:3456"), addr);
663 TEST_P(IPAddressFlagTest, IsLinkLocalBroadcast) {
664 AddressFlags param = GetParam();
665 IPAddress addr(param.address);
666 EXPECT_EQ(param.version, addr.version());
667 EXPECT_EQ(param.isLinkLocalBroadcast(), addr.isLinkLocalBroadcast());
670 TEST(IPAddress, SolicitedNodeAddress) {
671 // An example from RFC 4291 section 2.7.1
672 EXPECT_EQ(IPAddressV6("ff02::1:ff0e:8c6c"),
673 IPAddressV6("4037::01:800:200e:8c6c").getSolicitedNodeAddress());
675 // An example from wikipedia
676 // (http://en.wikipedia.org/wiki/Solicited-node_multicast_address)
677 EXPECT_EQ(IPAddressV6("ff02::1:ff28:9c5a"),
678 IPAddressV6("fe80::2aa:ff:fe28:9c5a").getSolicitedNodeAddress());
681 TEST_P(IPAddressByteAccessorTest, CheckBytes) {
682 auto addrData = GetParam();
683 IPAddress ip(addrData.address);
685 for (auto byitr = addrData.bytes.begin(); i < ip.byteCount(); ++i, ++byitr) {
686 EXPECT_EQ(*byitr, ip.getNthMSByte(i));
687 EXPECT_EQ(*byitr, ip.isV4() ?
688 ip.asV4().getNthMSByte(i) : ip.asV6().getNthMSByte(i));
691 for (auto byritr = addrData.bytes.rbegin(); i < ip.byteCount(); ++i,
693 EXPECT_EQ(*byritr, ip.getNthLSByte(i));
694 EXPECT_EQ(*byritr, ip.isV4() ?
695 ip.asV4().getNthLSByte(i) : ip.asV6().getNthLSByte(i));
699 TEST_P(IPAddressBitAccessorTest, CheckBits) {
700 auto addrData = GetParam();
701 auto littleEndianAddrData = addrData.bytes;
702 //IPAddress stores address data in n/w byte order.
703 reverse(littleEndianAddrData.begin(), littleEndianAddrData.end());
704 //Bit iterator goes from LSBit to MSBit
705 //We will traverse the IPAddress bits from 0 to bitCount -1
706 auto bitr = folly::makeBitIterator(littleEndianAddrData.begin());
707 IPAddress ip(addrData.address);
708 for (auto i = 0; i < ip.bitCount(); ++i) {
709 auto msbIndex = ip.bitCount() - i - 1;
710 EXPECT_EQ(*bitr, ip.getNthMSBit(msbIndex));
711 EXPECT_EQ(*bitr, ip.isV4() ? ip.asV4().getNthMSBit(msbIndex) :
712 ip.asV6().getNthMSBit(msbIndex));
713 EXPECT_EQ(*bitr, ip.getNthLSBit(i));
714 EXPECT_EQ(*bitr, ip.isV4() ? ip.asV4().getNthLSBit(i) :
715 ip.asV6().getNthLSBit(i));
720 TEST(IPAddress, InvalidByteAccess) {
721 IPAddress ip4("10.10.10.10");
722 //MSByte, LSByte accessors are 0 indexed
723 EXPECT_THROW(ip4.getNthMSByte(ip4.byteCount()), std::invalid_argument);
724 EXPECT_THROW(ip4.getNthLSByte(ip4.byteCount()), std::invalid_argument);
725 EXPECT_THROW(ip4.getNthMSByte(-1), std::invalid_argument);
726 EXPECT_THROW(ip4.getNthLSByte(-1), std::invalid_argument);
727 auto asV4 = ip4.asV4();
728 EXPECT_THROW(asV4.getNthMSByte(asV4.byteCount()), std::invalid_argument);
729 EXPECT_THROW(asV4.getNthLSByte(asV4.byteCount()), std::invalid_argument);
730 EXPECT_THROW(asV4.getNthMSByte(-1), std::invalid_argument);
731 EXPECT_THROW(asV4.getNthLSByte(-1), std::invalid_argument);
733 IPAddress ip6("2620:0:1cfe:face:b00c::3");
734 EXPECT_THROW(ip6.getNthMSByte(ip6.byteCount()), std::invalid_argument);
735 EXPECT_THROW(ip6.getNthLSByte(ip6.byteCount()), std::invalid_argument);
736 EXPECT_THROW(ip6.getNthMSByte(-1), std::invalid_argument);
737 EXPECT_THROW(ip6.getNthLSByte(-1), std::invalid_argument);
738 auto asV6 = ip6.asV6();
739 EXPECT_THROW(asV6.getNthMSByte(asV6.byteCount()), std::invalid_argument);
740 EXPECT_THROW(asV6.getNthLSByte(asV6.byteCount()), std::invalid_argument);
741 EXPECT_THROW(asV6.getNthMSByte(-1), std::invalid_argument);
742 EXPECT_THROW(asV6.getNthLSByte(-1), std::invalid_argument);
746 TEST(IPAddress, InvalidBBitAccess) {
747 IPAddress ip4("10.10.10.10");
748 //MSByte, LSByte accessors are 0 indexed
749 EXPECT_THROW(ip4.getNthMSBit(ip4.bitCount()), std::invalid_argument);
750 EXPECT_THROW(ip4.getNthLSBit(ip4.bitCount()), std::invalid_argument);
751 EXPECT_THROW(ip4.getNthMSBit(-1), std::invalid_argument);
752 EXPECT_THROW(ip4.getNthLSBit(-1), std::invalid_argument);
753 auto asV4 = ip4.asV4();
754 EXPECT_THROW(asV4.getNthMSBit(asV4.bitCount()), std::invalid_argument);
755 EXPECT_THROW(asV4.getNthLSBit(asV4.bitCount()), std::invalid_argument);
756 EXPECT_THROW(asV4.getNthMSBit(-1), std::invalid_argument);
757 EXPECT_THROW(asV4.getNthLSBit(-1), std::invalid_argument);
759 IPAddress ip6("2620:0:1cfe:face:b00c::3");
760 EXPECT_THROW(ip6.getNthMSBit(ip6.bitCount()), std::invalid_argument);
761 EXPECT_THROW(ip6.getNthLSBit(ip6.bitCount()), std::invalid_argument);
762 EXPECT_THROW(ip6.getNthMSBit(-1), std::invalid_argument);
763 EXPECT_THROW(ip6.getNthLSBit(-1), std::invalid_argument);
764 auto asV6 = ip6.asV6();
765 EXPECT_THROW(asV6.getNthMSBit(asV6.bitCount()), std::invalid_argument);
766 EXPECT_THROW(asV6.getNthLSBit(asV6.bitCount()), std::invalid_argument);
767 EXPECT_THROW(asV6.getNthMSBit(-1), std::invalid_argument);
768 EXPECT_THROW(asV6.getNthLSBit(-1), std::invalid_argument);
771 TEST(IPAddress, LongestCommonPrefix) {
772 IPAddress ip10("10.0.0.0");
773 IPAddress ip11("11.0.0.0");
774 IPAddress ip12("12.0.0.0");
775 IPAddress ip128("128.0.0.0");
776 IPAddress ip10dot10("10.10.0.0");
777 auto prefix = IPAddress::longestCommonPrefix({ip10, 8}, {ip128, 8});
778 auto prefix4 = IPAddressV4::longestCommonPrefix({ip10.asV4(), 8},
780 // No bits match b/w 128/8 and 10/8
781 EXPECT_EQ(IPAddress("0.0.0.0"), prefix.first);
782 EXPECT_EQ(0, prefix.second);
783 EXPECT_EQ(IPAddressV4("0.0.0.0"), prefix4.first);
784 EXPECT_EQ(0, prefix4.second);
786 prefix = IPAddress::longestCommonPrefix({ip10, 8}, {ip10dot10, 16});
787 prefix4 = IPAddressV4::longestCommonPrefix({ip10.asV4(), 8},
788 {ip10dot10.asV4(), 16});
789 // Between 10/8 and 10.10/16, 10/8 is the longest common match
790 EXPECT_EQ(ip10, prefix.first);
791 EXPECT_EQ(8, prefix.second);
792 EXPECT_EQ(ip10.asV4(), prefix4.first);
793 EXPECT_EQ(8, prefix4.second);
795 prefix = IPAddress::longestCommonPrefix({ip11, 8}, {ip12, 8});
796 prefix4 = IPAddressV4::longestCommonPrefix({ip11.asV4(), 8},
798 // 12 = 1100, 11 = 1011, longest match - 1000 = 8
799 EXPECT_EQ(IPAddress("8.0.0.0"), prefix.first);
800 EXPECT_EQ(5, prefix.second);
801 EXPECT_EQ(IPAddressV4("8.0.0.0"), prefix4.first);
802 EXPECT_EQ(5, prefix4.second);
804 // Between 128/1 and 128/2, longest match 128/1
805 prefix = IPAddress::longestCommonPrefix({ip128, 1}, {ip128, 2});
806 prefix4 = IPAddressV4::longestCommonPrefix({ip128.asV4(), 1},
808 EXPECT_EQ(ip128, prefix.first);
809 EXPECT_EQ(1, prefix.second);
810 EXPECT_EQ(ip128.asV4(), prefix4.first);
811 EXPECT_EQ(1, prefix4.second);
813 IPAddress ip6("2620:0:1cfe:face:b00c::3");
814 prefix = IPAddress::longestCommonPrefix({ip6, ip6.bitCount()},
815 {ip6, ip6.bitCount()});
816 auto prefix6 = IPAddressV6::longestCommonPrefix(
817 {ip6.asV6(), IPAddressV6::bitCount()},
818 {ip6.asV6(), IPAddressV6::bitCount()});
819 // Longest common b/w me and myself is myself
820 EXPECT_EQ(ip6, prefix.first);
821 EXPECT_EQ(ip6.bitCount(), prefix.second);
822 EXPECT_EQ(ip6.asV6(), prefix6.first);
823 EXPECT_EQ(ip6.asV6().bitCount(), prefix6.second);
825 IPAddress ip6Zero("::");
826 prefix = IPAddress::longestCommonPrefix({ip6, ip6.bitCount()}, {ip6Zero, 0});
827 prefix6 = IPAddressV6::longestCommonPrefix(
828 {ip6.asV6(), IPAddressV6::bitCount()},
829 {ip6Zero.asV6(), 0});
830 // Longest common b/w :: (ipv6 equivalent of 0/0) is ::
831 EXPECT_EQ(ip6Zero, prefix.first);
832 EXPECT_EQ(0, prefix.second);
835 EXPECT_THROW(IPAddress::longestCommonPrefix({ip10, 8}, {ip6, 128}),
836 std::invalid_argument);
837 EXPECT_THROW(IPAddress::longestCommonPrefix({ip10, ip10.bitCount() + 1},
839 std::invalid_argument);
840 EXPECT_THROW(IPAddressV4::longestCommonPrefix(
841 {ip10.asV4(), IPAddressV4::bitCount() + 1},
843 std::invalid_argument);
844 EXPECT_THROW(IPAddress::longestCommonPrefix({ip6, ip6.bitCount() + 1},
845 {ip6, ip6.bitCount()}),
846 std::invalid_argument);
847 EXPECT_THROW(IPAddressV6::longestCommonPrefix(
848 {ip6.asV6(), IPAddressV6::bitCount() + 1},
849 {ip6.asV6(), IPAddressV6::bitCount()}),
850 std::invalid_argument);
854 static vector<AddressData> validAddressProvider = {
855 AddressData("127.0.0.1", {127,0,0,1}, 4),
856 AddressData("69.63.189.16", {69,63,189,16}, 4),
857 AddressData("0.0.0.0", {0,0,0,0}, 4),
859 {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1}, 6),
860 AddressData("2620:0:1cfe:face:b00c::3",
861 {38,32,0,0,28,254,250,206,176,12,0,0,0,0,0,3}, 6),
864 static vector<string> invalidAddressProvider = {
870 "127.0.0.1,127.0.0.1",
874 static vector<ByteVector> invalidBinaryProvider = {
875 {0x31, 0x32, 0x37, 0x2e, 0x30, 0x30, 0x2e, 0x30, 0x2e, 0x31},
881 {0x00, 0x00, 0x00, 0x00, 0x00},
885 static const uint8_t IS_LOCAL = AddressFlags::IS_LOCAL;
886 static const uint8_t IS_NONROUTABLE = AddressFlags::IS_NONROUTABLE;
887 static const uint8_t IS_PRIVATE = AddressFlags::IS_PRIVATE;
888 static const uint8_t IS_ZERO = AddressFlags::IS_ZERO;
889 static const uint8_t IS_LINK_LOCAL =
890 AddressFlags::IS_LINK_LOCAL | IS_NONROUTABLE;
891 static const uint8_t IS_PVT_NONROUTE = IS_NONROUTABLE | IS_PRIVATE;
892 static const uint8_t IS_MULTICAST = AddressFlags::IS_MULTICAST;
893 static const uint8_t IS_LINK_LOCAL_BROADCAST =
894 AddressFlags::IS_LINK_LOCAL_BROADCAST;
896 static vector<AddressFlags> flagProvider = {
898 AddressFlags("69.63.176.1", 4, 0),
899 AddressFlags("128.12.65.3", 4, 0),
900 AddressFlags("192.0.1.0", 4, 0),
901 AddressFlags("198.51.101.0", 4, 0),
902 AddressFlags("203.0.114.0", 4, 0),
903 AddressFlags("128.12.64.115", 4, 0),
906 AddressFlags("2620:0:1cfe:face:b00c::3", 6, 0),
909 AddressFlags("127.0.0.1", 4, IS_LOCAL | IS_PVT_NONROUTE),
910 AddressFlags("::1", 6, IS_LOCAL | IS_PVT_NONROUTE),
913 AddressFlags("10.0.0.0", 4, IS_PVT_NONROUTE),
914 AddressFlags("10.11.12.13", 4, IS_PVT_NONROUTE),
915 AddressFlags("10.255.255.255", 4, IS_PVT_NONROUTE),
916 AddressFlags("127.128.129.200", 4, IS_PVT_NONROUTE),
917 AddressFlags("127.255.255.255", 4, IS_PVT_NONROUTE),
918 AddressFlags("169.254.0.0", 4, IS_PVT_NONROUTE),
919 AddressFlags("192.168.0.0", 4, IS_PVT_NONROUTE),
920 AddressFlags("192.168.200.255", 4, IS_PVT_NONROUTE),
921 AddressFlags("192.168.255.255", 4, IS_PVT_NONROUTE),
924 AddressFlags("fd01:1637:1c56:66af::", 6, IS_PVT_NONROUTE),
927 AddressFlags("0.0.0.0", 4, IS_NONROUTABLE | IS_ZERO),
928 AddressFlags("0.255.255.255", 4, IS_NONROUTABLE),
929 AddressFlags("192.0.0.0", 4, IS_NONROUTABLE),
930 AddressFlags("192.0.2.0", 4, IS_NONROUTABLE),
931 AddressFlags("198.18.0.0", 4, IS_NONROUTABLE),
932 AddressFlags("198.19.255.255", 4, IS_NONROUTABLE),
933 AddressFlags("198.51.100.0", 4, IS_NONROUTABLE),
934 AddressFlags("198.51.100.255", 4, IS_NONROUTABLE),
935 AddressFlags("203.0.113.0", 4, IS_NONROUTABLE),
936 AddressFlags("203.0.113.255", 4, IS_NONROUTABLE),
937 AddressFlags("224.0.0.0", 4, IS_NONROUTABLE | IS_MULTICAST),
938 AddressFlags("240.0.0.0", 4, IS_NONROUTABLE),
939 AddressFlags("224.0.0.0", 4, IS_NONROUTABLE),
940 // v4 link local broadcast
941 AddressFlags("255.255.255.255", 4, IS_NONROUTABLE | IS_LINK_LOCAL_BROADCAST),
944 AddressFlags("1999::1", 6, IS_NONROUTABLE),
945 AddressFlags("0::0", 6, IS_NONROUTABLE | IS_ZERO),
946 AddressFlags("0::0:0", 6, IS_NONROUTABLE | IS_ZERO),
947 AddressFlags("0:0:0::0", 6, IS_NONROUTABLE | IS_ZERO),
950 AddressFlags("fe80::0205:73ff:fef9:46fc", 6, IS_LINK_LOCAL),
951 AddressFlags("fe80::0012:34ff:fe56:7890", 6, IS_LINK_LOCAL),
954 AddressFlags("224.0.0.1", 4, IS_MULTICAST | IS_NONROUTABLE) ,
955 AddressFlags("224.0.0.251", 4, IS_MULTICAST | IS_NONROUTABLE),
956 AddressFlags("239.12.34.56", 4, IS_MULTICAST | IS_NONROUTABLE),
959 AddressFlags("ff00::", 6, IS_MULTICAST | IS_NONROUTABLE),
960 AddressFlags("ff02:ffff::1", 6, IS_MULTICAST | IS_NONROUTABLE),
961 AddressFlags("ff02::101", 6, IS_MULTICAST | IS_NONROUTABLE),
962 AddressFlags("ff0e::101", 6, IS_MULTICAST),
963 // v6 link local broadcast
964 AddressFlags("ff02::1", 6, IS_NONROUTABLE | IS_LINK_LOCAL_BROADCAST),
967 static vector<pair<string, string> > mapProvider = {
968 {"::ffff:192.0.2.128", "192.0.2.128"},
969 {"192.0.2.128", "::ffff:192.0.2.128"},
970 {"::FFFF:129.144.52.38", "129.144.52.38"},
971 {"129.144.52.38", "::FFFF:129.144.52.38"},
972 {"0:0:0:0:0:FFFF:222.1.41.90", "222.1.41.90"},
973 {"::FFFF:222.1.41.90", "222.1.41.90"},
976 static vector<MaskData> masksProvider = {
977 MaskData("255.255.255.255", 1, "128.0.0.0"),
978 MaskData("255.255.255.255", 2, "192.0.0.0"),
979 MaskData("192.0.2.42", 16, "192.0.0.0"),
980 MaskData("255.255.255.255", 24, "255.255.255.0"),
981 MaskData("255.255.255.255", 32, "255.255.255.255"),
982 MaskData("10.10.10.10", 0, "0.0.0.0"),
983 MaskData("::1", 64, "::"),
984 MaskData("2620:0:1cfe:face:b00c::3", 1, "::"),
985 MaskData("2620:0:1cfe:face:b00c::3", 3, "2000::"),
986 MaskData("2620:0:1cfe:face:b00c::3", 6, "2400::"),
987 MaskData("2620:0:1cfe:face:b00c::3", 7, "2600::"),
988 MaskData("2620:0:1cfe:face:b00c::3", 11, "2620::"),
989 MaskData("2620:0:1cfe:face:b00c::3", 36, "2620:0:1000::"),
990 MaskData("2620:0:1cfe:face:b00c::3", 37, "2620:0:1800::"),
991 MaskData("2620:0:1cfe:face:b00c::3", 38, "2620:0:1c00::"),
992 MaskData("2620:0:1cfe:face:b00c::3", 41, "2620:0:1c80::"),
993 MaskData("2620:0:1cfe:face:b00c::3", 42, "2620:0:1cc0::"),
994 MaskData("2620:0:1cfe:face:b00c::3", 43, "2620:0:1ce0::"),
995 MaskData("2620:0:1cfe:face:b00c::3", 44, "2620:0:1cf0::"),
996 MaskData("2620:0:1cfe:face:b00c::3", 45, "2620:0:1cf8::"),
997 MaskData("2620:0:1cfe:face:b00c::3", 46, "2620:0:1cfc::"),
998 MaskData("2620:0:1cfe:face:b00c::3", 47, "2620:0:1cfe::"),
999 MaskData("2620:0:1cfe:face:b00c::3", 49, "2620:0:1cfe:8000::"),
1000 MaskData("2620:0:1cfe:face:b00c::3", 50, "2620:0:1cfe:c000::"),
1001 MaskData("2620:0:1cfe:face:b00c::3", 51, "2620:0:1cfe:e000::"),
1002 MaskData("2620:0:1cfe:face:b00c::3", 52, "2620:0:1cfe:f000::"),
1003 MaskData("2620:0:1cfe:face:b00c::3", 53, "2620:0:1cfe:f800::"),
1004 MaskData("2620:0:1cfe:face:b00c::3", 55, "2620:0:1cfe:fa00::"),
1005 MaskData("2620:0:1cfe:face:b00c::3", 57, "2620:0:1cfe:fa80::"),
1006 MaskData("2620:0:1cfe:face:b00c::3", 58, "2620:0:1cfe:fac0::"),
1007 MaskData("2620:0:1cfe:face:b00c::3", 61, "2620:0:1cfe:fac8::"),
1008 MaskData("2620:0:1cfe:face:b00c::3", 62, "2620:0:1cfe:facc::"),
1009 MaskData("2620:0:1cfe:face:b00c::3", 63, "2620:0:1cfe:face::"),
1010 MaskData("2620:0:1cfe:face:b00c::3", 65, "2620:0:1cfe:face:8000::"),
1011 MaskData("2620:0:1cfe:face:b00c::3", 67, "2620:0:1cfe:face:a000::"),
1012 MaskData("2620:0:1cfe:face:b00c::3", 68, "2620:0:1cfe:face:b000::"),
1013 MaskData("2620:0:1cfe:face:b00c::3", 77, "2620:0:1cfe:face:b008::"),
1014 MaskData("2620:0:1cfe:face:b00c::3", 78, "2620:0:1cfe:face:b00c::"),
1015 MaskData("2620:0:1cfe:face:b00c::3", 127, "2620:0:1cfe:face:b00c::2"),
1016 MaskData("2620:0:1cfe:face:b00c::3", 128, "2620:0:1cfe:face:b00c::3"),
1017 MaskData("2620:0:1cfe:face:b00c::3", 0, "::")
1020 static vector<MaskBoundaryData> maskBoundaryProvider = {
1021 MaskBoundaryData("10.1.1.1", 24, "10.1.1.1", true),
1022 MaskBoundaryData("10.1.1.1", 8, "10.1.2.3", true),
1023 MaskBoundaryData("2620:0:1cfe:face:b00c::1", 48, "2620:0:1cfe::", true),
1024 // addresses that are NOT in the same subnet once mask is applied
1025 MaskBoundaryData("10.1.1.1", 24, "10.1.2.1", false),
1026 MaskBoundaryData("10.1.1.1", 16, "10.2.3.4", false),
1027 MaskBoundaryData("2620:0:1cfe:face:b00c::1", 48, "2620:0:1cfc::", false),
1030 INSTANTIATE_TEST_CASE_P(IPAddress,
1032 ::testing::ValuesIn(validAddressProvider));
1033 INSTANTIATE_TEST_CASE_P(IPAddress,
1035 ::testing::ValuesIn(flagProvider));
1036 INSTANTIATE_TEST_CASE_P(IPAddress,
1037 IPAddressMappedTest,
1038 ::testing::ValuesIn(mapProvider));
1039 INSTANTIATE_TEST_CASE_P(IPAddress,
1041 ::testing::ValuesIn(invalidAddressProvider));
1042 INSTANTIATE_TEST_CASE_P(IPAddress,
1043 IPAddressCtorBinaryTest,
1044 ::testing::ValuesIn(invalidBinaryProvider));
1045 INSTANTIATE_TEST_CASE_P(IPAddress,
1047 ::testing::ValuesIn(masksProvider));
1048 INSTANTIATE_TEST_CASE_P(IPAddress,
1049 IPAddressMaskBoundaryTest,
1050 ::testing::ValuesIn(maskBoundaryProvider));
1051 INSTANTIATE_TEST_CASE_P(IPAddress,
1052 IPAddressByteAccessorTest,
1053 ::testing::ValuesIn(validAddressProvider));
1054 INSTANTIATE_TEST_CASE_P(IPAddress,
1055 IPAddressBitAccessorTest,
1056 ::testing::ValuesIn(validAddressProvider));