2 * Copyright 2017 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 <sys/types.h>
21 #include <folly/Bits.h>
22 #include <folly/Format.h>
23 #include <folly/IPAddress.h>
24 #include <folly/MacAddress.h>
25 #include <folly/String.h>
26 #include <folly/detail/IPAddressSource.h>
27 #include <folly/portability/GMock.h>
28 #include <folly/portability/GTest.h>
30 using namespace folly;
32 using namespace testing;
34 typedef std::vector<uint8_t> ByteVector;
42 const std::string& address,
43 const ByteVector& bytes,
45 : address(address), bytes(bytes), version(version) {}
46 AddressData(const std::string& address, uint8_t version)
47 : address(address), bytes(), version(version) {}
48 explicit AddressData(const std::string& address)
49 : address(address), bytes(), version(0) {}
50 AddressData() : address(""), bytes(), version(0) {}
52 static in_addr parseAddress4(const std::string& src) {
54 inet_pton(AF_INET, src.c_str(), &addr);
58 static in6_addr parseAddress6(const std::string& src) {
60 inet_pton(AF_INET6, src.c_str(), &addr);
70 static const uint8_t IS_LOCAL = 1 << 0;
71 static const uint8_t IS_NONROUTABLE = 1 << 1;
72 static const uint8_t IS_PRIVATE = 1 << 2;
73 static const uint8_t IS_ZERO = 1 << 3;
74 static const uint8_t IS_LINK_LOCAL = 1 << 4;
75 static const uint8_t IS_MULTICAST = 1 << 5;
76 static const uint8_t IS_LINK_LOCAL_BROADCAST = 1 << 6;
78 AddressFlags(const std::string& addr, uint8_t version, uint8_t flags)
79 : address(addr), flags(flags), version(version) {}
81 bool isLoopback() const {
82 return (flags & IS_LOCAL);
84 bool isNonroutable() const {
85 return (flags & IS_NONROUTABLE);
87 bool isPrivate() const {
88 return (flags & IS_PRIVATE);
91 return (flags & IS_ZERO);
93 bool isLinkLocal() const {
94 return (flags & IS_LINK_LOCAL);
96 bool isLinkLocalBroadcast() const {
97 return (flags & IS_LINK_LOCAL_BROADCAST);
105 MaskData(const std::string& addr, uint8_t mask, const std::string& subnet)
106 : address(addr), mask(mask), subnet(subnet) {}
109 struct MaskBoundaryData : MaskData {
112 const std::string& addr,
114 const std::string& subnet,
116 : MaskData(addr, mask, subnet), inSubnet(inSubnet) {}
119 struct SerializeData {
123 SerializeData(const std::string& addr, const ByteVector& bytes)
124 : address(addr), bytes(bytes) {}
127 struct IPAddressTest : TestWithParam<AddressData> {
128 void ExpectIsValid(const IPAddress& addr) {
129 AddressData param = GetParam();
130 EXPECT_EQ(param.version, addr.version());
131 EXPECT_EQ(param.address, addr.str());
132 if (param.version == 4) {
133 in_addr v4addr = AddressData::parseAddress4(param.address);
134 EXPECT_EQ(0, memcmp(&v4addr, addr.asV4().toByteArray().data(), 4));
135 EXPECT_TRUE(addr.isV4());
136 EXPECT_FALSE(addr.isV6());
138 in6_addr v6addr = AddressData::parseAddress6(param.address);
139 EXPECT_EQ(0, memcmp(&v6addr, addr.asV6().toByteArray().data(), 16));
140 EXPECT_TRUE(addr.isV6());
141 EXPECT_FALSE(addr.isV4());
145 struct IPAddressFlagTest : TestWithParam<AddressFlags> {};
146 struct IPAddressCtorTest : TestWithParam<std::string> {};
147 struct IPAddressCtorBinaryTest : TestWithParam<ByteVector> {};
148 struct IPAddressMappedTest
149 : TestWithParam<std::pair<std::string, std::string>> {};
150 struct IPAddressMaskTest : TestWithParam<MaskData> {};
151 struct IPAddressMaskBoundaryTest : TestWithParam<MaskBoundaryData> {};
152 struct IPAddressSerializeTest : TestWithParam<SerializeData> {};
153 struct IPAddressByteAccessorTest : TestWithParam<AddressData> {};
154 struct IPAddressBitAccessorTest : TestWithParam<AddressData> {};
156 // tests code example
157 TEST(IPAddress, CodeExample) {
158 EXPECT_EQ(4, sizeof(IPAddressV4));
159 EXPECT_EQ(20, sizeof(IPAddressV6));
160 EXPECT_EQ(24, sizeof(IPAddress));
161 IPAddress uninitaddr;
162 IPAddress v4addr("192.0.2.129");
163 IPAddress v6map("::ffff:192.0.2.129");
164 ASSERT_TRUE(uninitaddr.empty());
165 ASSERT_FALSE(v4addr.empty());
166 ASSERT_FALSE(v6map.empty());
167 EXPECT_TRUE(v4addr.inSubnet("192.0.2.0/24"));
168 EXPECT_TRUE(v4addr.inSubnet(IPAddress("192.0.2.0"), 24));
169 EXPECT_TRUE(v4addr.inSubnet("192.0.2.128/30"));
170 EXPECT_FALSE(v4addr.inSubnet("192.0.2.128/32"));
171 EXPECT_EQ(2164392128, v4addr.asV4().toLong());
172 EXPECT_EQ(3221226113, v4addr.asV4().toLongHBO());
173 ASSERT_FALSE(uninitaddr.isV4());
174 ASSERT_FALSE(uninitaddr.isV6());
175 ASSERT_TRUE(v4addr.isV4());
176 ASSERT_TRUE(v6map.isV6());
177 EXPECT_TRUE(v4addr == v6map);
178 ASSERT_TRUE(v6map.isIPv4Mapped());
179 EXPECT_TRUE(v4addr.asV4() == IPAddress::createIPv4(v6map));
180 EXPECT_TRUE(IPAddress::createIPv6(v4addr) == v6map.asV6());
183 TEST(IPAddress, Scope) {
184 // Test that link-local scope is saved
185 auto str = "fe80::62eb:69ff:fe9b:ba60%eth0";
187 EXPECT_EQ(str, a2.str());
189 sockaddr_in6 sock = a2.toSockAddr();
190 EXPECT_NE(0, sock.sin6_scope_id);
193 EXPECT_EQ(str, a1.str());
198 EXPECT_TRUE(a2 < a1);
201 TEST(IPAddress, ScopeNumeric) {
202 // it's very unlikely that the host running these
203 // tests will have 42 network interfaces
204 auto str = "fe80::62eb:69ff:fe9b:ba60%42";
206 EXPECT_EQ(str, a2.str());
208 sockaddr_in6 sock = a2.toSockAddr();
209 EXPECT_NE(0, sock.sin6_scope_id);
212 EXPECT_EQ(str, a1.str());
217 EXPECT_TRUE(a2 < a1);
220 TEST(IPAddress, Ordering) {
221 IPAddress a1("0.1.1.1");
222 IPAddress a2("1.1.1.0");
223 EXPECT_TRUE(a1 < a2);
225 IPAddress b1("::ffff:0.1.1.1");
226 IPAddress b2("::ffff:1.1.1.0");
227 EXPECT_TRUE(b1 < b2);
230 TEST(IPAddress, InvalidAddressFamilyExceptions) {
234 EXPECT_THROW(addr.asV4(), InvalidAddressFamilyException);
239 EXPECT_THROW(addr.asV6(), InvalidAddressFamilyException);
245 addr.sin_family = AF_UNSPEC;
247 EXPECT_THROW(IPAddress((sockaddr *)&addr), InvalidAddressFamilyException);
251 TEST(IPAddress, CreateNetwork) {
252 // test valid IPv4 network
254 auto net = IPAddress::createNetwork("192.168.0.1/24");
255 ASSERT_TRUE(net.first.isV4());
256 EXPECT_EQ("192.168.0.0", net.first.str());
257 EXPECT_EQ(24, net.second);
258 EXPECT_EQ("192.168.0.0/24", IPAddress::networkToString(net));
260 // test valid IPv4 network without applying mask
262 auto net = IPAddress::createNetwork("192.168.0.1/24", -1, false);
263 ASSERT_TRUE(net.first.isV4());
264 EXPECT_EQ("192.168.0.1", net.first.str());
265 EXPECT_EQ(24, net.second);
266 EXPECT_EQ("192.168.0.1/24", IPAddress::networkToString(net));
268 // test valid IPv6 network
270 auto net = IPAddress::createNetwork("1999::1/24");
271 ASSERT_TRUE(net.first.isV6());
272 EXPECT_EQ("1999::", net.first.str());
273 EXPECT_EQ(24, net.second);
274 EXPECT_EQ("1999::/24", IPAddress::networkToString(net));
276 // test valid IPv6 network without applying mask
278 auto net = IPAddress::createNetwork("1999::1/24", -1, false);
279 ASSERT_TRUE(net.first.isV6());
280 EXPECT_EQ("1999::1", net.first.str());
281 EXPECT_EQ(24, net.second);
282 EXPECT_EQ("1999::1/24", IPAddress::networkToString(net));
285 EXPECT_THROW(IPAddress::createNetwork(""), IPAddressFormatException);
286 // test multi slash string
287 EXPECT_THROW(IPAddress::createNetwork("192.168.0.1/24/36"),
288 IPAddressFormatException);
289 // test no slash string with default IPv4
291 auto net = IPAddress::createNetwork("192.168.0.1");
292 ASSERT_TRUE(net.first.isV4());
293 EXPECT_EQ("192.168.0.1", net.first.str());
294 EXPECT_EQ(32, net.second); // auto-detected
295 net = IPAddress::createNetwork("192.168.0.1", -1, false);
296 ASSERT_TRUE(net.first.isV4());
297 EXPECT_EQ("192.168.0.1", net.first.str());
298 EXPECT_EQ(32, net.second);
300 // test no slash string with default IPv6
302 auto net = IPAddress::createNetwork("1999::1");
303 ASSERT_TRUE(net.first.isV6());
304 EXPECT_EQ("1999::1", net.first.str());
305 EXPECT_EQ(128, net.second);
307 // test no slash string with invalid default
308 EXPECT_THROW(IPAddress::createNetwork("192.168.0.1", 33),
309 IPAddressFormatException);
313 // test assignment operators
314 TEST(IPAddress, Assignment) {
315 static const string kIPv4Addr = "69.63.189.16";
316 static const string kIPv6Addr = "2620:0:1cfe:face:b00c::3";
318 // Test assigning IPAddressV6 addr to IPAddress (was V4)
320 IPAddress addr(kIPv4Addr);
321 IPAddressV6 addrV6 = IPAddress(kIPv6Addr).asV6();
322 EXPECT_TRUE(addr.isV4());
323 EXPECT_EQ(kIPv4Addr, addr.str());
325 EXPECT_TRUE(addr.isV6());
326 EXPECT_EQ(kIPv6Addr, addr.str());
328 // Test assigning IPAddressV4 addr to IPAddress (was V6)
330 IPAddress addr(kIPv6Addr);
331 IPAddressV4 addrV4 = IPAddress(kIPv4Addr).asV4();
332 EXPECT_TRUE(addr.isV6());
333 EXPECT_EQ(kIPv6Addr, addr.str());
335 EXPECT_TRUE(addr.isV4());
336 EXPECT_EQ(kIPv4Addr, addr.str());
338 // Test assigning IPAddress(v6) to IPAddress (was v4)
340 IPAddress addr(kIPv4Addr);
341 IPAddress addrV6 = IPAddress(kIPv6Addr);
342 EXPECT_TRUE(addr.isV4());
343 EXPECT_EQ(kIPv4Addr, addr.str());
345 EXPECT_TRUE(addr.isV6());
346 EXPECT_EQ(kIPv6Addr, addr.str());
348 // Test assigning IPAddress(v4) to IPAddress (was v6)
350 IPAddress addr(kIPv6Addr);
351 IPAddress addrV4 = IPAddress(kIPv4Addr);
352 EXPECT_TRUE(addr.isV6());
353 EXPECT_EQ(kIPv6Addr, addr.str());
355 EXPECT_TRUE(addr.isV4());
356 EXPECT_EQ(kIPv4Addr, addr.str());
360 // Test the default constructors
361 TEST(IPAddress, CtorDefault) {
363 EXPECT_EQ(IPAddressV4("0.0.0.0"), v4);
365 EXPECT_EQ(IPAddressV6("::0"), v6);
368 TEST(IPAddressV4, validate) {
369 EXPECT_TRUE(IPAddressV4::validate("0.0.0.0"));
370 EXPECT_FALSE(IPAddressV4::validate("0.0.0."));
371 EXPECT_TRUE(IPAddressV4::validate("127.127.127.127"));
374 TEST(IPAddressV6, validate) {
375 EXPECT_TRUE(IPAddressV6::validate("2620:0:1cfe:face:b00c::3"));
376 EXPECT_FALSE(IPAddressV6::validate("0.0.0.0"));
377 EXPECT_TRUE(IPAddressV6::validate("[2620:0:1cfe:face:b00c::3]"));
378 EXPECT_TRUE(IPAddressV6::validate("::ffff:0.1.1.1"));
379 EXPECT_TRUE(IPAddressV6::validate("2620:0000:1cfe:face:b00c:0000:0000:0003"));
381 IPAddressV6::validate("2620:0000:1cfe:face:b00c:0000:127.127.127.127"));
384 TEST(IPAddress, validate) {
385 EXPECT_TRUE(IPAddress::validate("0.0.0.0"));
386 EXPECT_TRUE(IPAddress::validate("::"));
387 EXPECT_FALSE(IPAddress::validate("asdf"));
390 // Test addresses constructed using a in[6]_addr value
391 TEST_P(IPAddressTest, CtorAddress) {
392 AddressData param = GetParam();
393 IPAddress strAddr(param.address);
396 if (param.version == 4) {
397 in_addr v4addr = detail::Bytes::mkAddress4(¶m.bytes[0]);
398 address = IPAddress(v4addr);
400 in6_addr v6addr = detail::Bytes::mkAddress6(¶m.bytes[0]);
401 address = IPAddress(v6addr);
403 ExpectIsValid(address);
404 EXPECT_EQ(strAddr, address);
407 // Test addresses constructed using a binary address
408 TEST_P(IPAddressTest, CtorBinary) {
409 AddressData param = GetParam();
412 if (param.version == 4) {
413 in_addr v4addr = AddressData::parseAddress4(param.address);
414 address = IPAddress::fromBinary(ByteRange((unsigned char*)&v4addr, 4));
416 in6_addr v6addr = AddressData::parseAddress6(param.address);
417 address = IPAddress::fromBinary(ByteRange((unsigned char*)&v6addr, 16));
420 ExpectIsValid(address);
421 EXPECT_EQ(IPAddress(param.address), address);
424 // Test addresses constructed using a string
425 TEST_P(IPAddressTest, CtorString) {
426 AddressData param = GetParam();
427 IPAddress address(param.address);
429 ExpectIsValid(address);
431 // Test the direct version-specific constructor
432 if (param.version == 4) {
433 IPAddressV4 v4(param.address);
434 ExpectIsValid(IPAddress(v4));
435 EXPECT_THROW(IPAddressV6 v6(param.address), IPAddressFormatException);
436 } else if (param.version == 6) {
437 IPAddressV6 v6(param.address);
438 ExpectIsValid(IPAddress(v6));
439 EXPECT_THROW(IPAddressV4 v4(param.address), IPAddressFormatException);
443 TEST(IPAddress, CtorSockaddr) {
449 sin_addr.s_addr = htonl(2122547223);
450 addr.sin_family = AF_INET;
451 addr.sin_addr = sin_addr;
453 IPAddress ipAddr((sockaddr *)&addr);
454 EXPECT_TRUE(ipAddr.isV4());
455 EXPECT_EQ("126.131.128.23", ipAddr.str());
461 memset(&addr, 0, sizeof(addr));
464 // 2620:0:1cfe:face:b00c::3
465 38,32,0,0,28,254,250,206,176,12,0,0,0,0,0,3
467 std::memcpy(sin_addr.s6_addr, sec.data(), 16);
468 addr.sin6_family = AF_INET6;
469 addr.sin6_addr = sin_addr;
471 IPAddress ipAddr((sockaddr *)&addr);
472 EXPECT_TRUE(ipAddr.isV6());
473 EXPECT_EQ("2620:0:1cfe:face:b00c::3", ipAddr.str());
475 // test nullptr exception
477 sockaddr *addr = nullptr;
478 EXPECT_THROW(IPAddress((const sockaddr*)addr), IPAddressFormatException);
480 // test invalid family exception
485 sin_addr.s_addr = htonl(2122547223);
486 addr.sin_family = AF_UNSPEC;
487 addr.sin_addr = sin_addr;
489 EXPECT_THROW(IPAddress((sockaddr *)&addr), IPAddressFormatException);
493 TEST(IPAddress, ToSockaddrStorage) {
496 string strAddr("126.131.128.23");
497 IPAddress addr(strAddr);
498 sockaddr_storage out;
500 ASSERT_TRUE(addr.isV4()); // test invariant
501 EXPECT_GT(addr.toSockaddrStorage(&out), 0);
503 IPAddress sockAddr((sockaddr*)&out);
504 ASSERT_TRUE(sockAddr.isV4());
505 EXPECT_EQ(strAddr, sockAddr.str());
509 string strAddr("2620:0:1cfe:face:b00c::3");
510 IPAddress addr(strAddr);
511 sockaddr_storage out;
513 ASSERT_TRUE(addr.isV6()); // test invariant
514 EXPECT_GT(addr.toSockaddrStorage(&out), 0);
516 IPAddress sockAddr((sockaddr*)&out);
517 ASSERT_TRUE(sockAddr.isV6());
518 EXPECT_EQ(strAddr, sockAddr.str());
520 // test nullptr exception
522 sockaddr_storage *out = nullptr;
523 IPAddress addr("127.0.0.1");
524 EXPECT_THROW(addr.toSockaddrStorage(out), IPAddressFormatException);
526 // test invalid family exception
529 sockaddr_storage out;
530 ASSERT_EQ(AF_UNSPEC, addr.family());
531 EXPECT_THROW(addr.toSockaddrStorage(&out), InvalidAddressFamilyException);
535 TEST(IPAddress, ToString) {
536 // Test with IPAddressV4
537 IPAddressV4 addr_10_0_0_1("10.0.0.1");
538 EXPECT_EQ("10.0.0.1", folly::to<string>(addr_10_0_0_1));
539 // Test with IPAddressV6
540 IPAddressV6 addr_1("::1");
541 EXPECT_EQ("::1", folly::to<string>(addr_1));
542 // Test with IPAddress, both V4 and V6
543 IPAddress addr_10_1_2_3("10.1.2.3");
544 EXPECT_EQ("10.1.2.3", folly::to<string>(addr_10_1_2_3));
545 IPAddress addr_1_2_3("1:2::3");
546 EXPECT_EQ("1:2::3", folly::to<string>(addr_1_2_3));
548 // Test a combination of all the above arguments
549 EXPECT_EQ("1:2::3 - 10.0.0.1 - ::1 - 10.1.2.3",
550 folly::to<string>(addr_1_2_3, " - ", addr_10_0_0_1,
551 " - ", addr_1, " - ", addr_10_1_2_3));
554 TEST(IPaddress, toInverseArpaName) {
555 IPAddressV4 addr_ipv4("10.0.0.1");
556 EXPECT_EQ("1.0.0.10.in-addr.arpa", addr_ipv4.toInverseArpaName());
557 IPAddressV6 addr_ipv6("2620:0000:1cfe:face:b00c:0000:0000:0003");
561 "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"),
562 addr_ipv6.toInverseArpaName());
565 TEST(IPaddress, fromInverseArpaName) {
567 IPAddressV4("10.0.0.1"),
568 IPAddressV4::fromInverseArpaName("1.0.0.10.in-addr.arpa"));
570 IPAddressV6("2620:0000:1cfe:face:b00c:0000:0000:0003"),
571 IPAddressV6::fromInverseArpaName(sformat(
573 "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")));
576 // Test that invalid string values are killed
577 TEST_P(IPAddressCtorTest, InvalidCreation) {
578 string addr = GetParam();
579 EXPECT_THROW(IPAddress((const string)addr), IPAddressFormatException)
580 << "IPAddress(" << addr << ") "
581 << "should have thrown an IPAddressFormatException";
584 // Test that invalid binary values throw an exception
585 TEST_P(IPAddressCtorBinaryTest, InvalidBinary) {
586 auto bin = GetParam();
587 EXPECT_THROW(IPAddress::fromBinary(ByteRange(&bin[0], bin.size())),
588 IPAddressFormatException);
591 TEST(IPAddressSource, ToHex) {
592 vector<std::uint8_t> data = {{0xff, 0x20, 0x45}};
593 EXPECT_EQ(detail::Bytes::toHex(data.data(), 0), "");
594 EXPECT_EQ(detail::Bytes::toHex(data.data(), 1), "ff");
595 EXPECT_EQ(detail::Bytes::toHex(data.data(), 2), "ff20");
596 EXPECT_EQ(detail::Bytes::toHex(data.data(), 3), "ff2045");
599 // Test toFullyQualified()
600 TEST(IPAddress, ToFullyQualifiedFb) {
601 IPAddress ip("2620:0:1cfe:face:b00c::3");
602 EXPECT_EQ("2620:0000:1cfe:face:b00c:0000:0000:0003", ip.toFullyQualified())
605 TEST(IPAddress, ToFullyQualifiedLocal) {
607 EXPECT_EQ("0000:0000:0000:0000:0000:0000:0000:0001", ip.toFullyQualified())
610 TEST(IPAddress, ToFullyQualifiedAppendV6) {
611 IPAddress ip("2620:0:1cfe:face:b00c::3");
613 ip.toFullyQualifiedAppend(result);
614 EXPECT_EQ("2620:0000:1cfe:face:b00c:0000:0000:0003", result) << ip;
616 TEST(IPAddress, ToFullyQualifiedAppendV4) {
617 IPAddress ip("127.0.0.1");
619 ip.toFullyQualifiedAppend(result);
620 EXPECT_EQ("127.0.0.1", result) << ip;
622 TEST(IPAddress, ToFullyQualifiedSizeV6) {
623 auto actual = IPAddressV6::kToFullyQualifiedSize;
624 auto expected = IPAddress("::").toFullyQualified().size();
625 EXPECT_EQ(expected, actual);
627 TEST(IPAddress, MaxToFullyQualifiedSizeV4) {
628 auto actual = IPAddressV4::kMaxToFullyQualifiedSize;
629 auto expected = IPAddress("255.255.255.255").toFullyQualified().size();
630 EXPECT_EQ(expected, actual);
633 // test v4-v6 mapped addresses
634 TEST_P(IPAddressMappedTest, MappedEqual) {
635 auto param = GetParam();
636 string mappedIp = param.first;
637 string otherIp = param.second;
639 auto mapped = IPAddress(mappedIp);
640 auto expected = IPAddress(otherIp);
642 EXPECT_EQ(expected, mapped);
646 v6addr = mapped.asV4().createIPv6();
647 } else if (expected.isV4()) {
648 v6addr = expected.asV4().createIPv6();
650 EXPECT_TRUE(v6addr.isV6());
651 EXPECT_TRUE(mapped == v6addr);
652 EXPECT_TRUE(expected == v6addr);
655 // Test subnet mask calculations
656 TEST_P(IPAddressMaskTest, Masks) {
657 auto param = GetParam();
659 IPAddress ip(param.address);
660 IPAddress masked = ip.mask(param.mask);
661 EXPECT_EQ(param.subnet, masked.str())
662 << param.address << "/" << folly::to<std::string>(param.mask) << " -> "
666 // Test inSubnet calculations
667 TEST_P(IPAddressMaskTest, InSubnet) {
668 auto param = GetParam();
670 IPAddress ip(param.address);
671 IPAddress subnet(param.subnet);
672 EXPECT_TRUE(ip.inSubnet(subnet, param.mask));
675 // Test boundary conditions for subnet calculations
676 TEST_P(IPAddressMaskBoundaryTest, NonMaskedSubnet) {
677 auto param = GetParam();
678 IPAddress ip(param.address);
679 IPAddress subnet(param.subnet);
680 EXPECT_EQ(param.inSubnet, ip.inSubnet(subnet, param.mask));
683 TEST(IPAddress, UnitializedEqual) {
685 IPAddress ip4("127.0.0.1");
686 EXPECT_FALSE(addrEmpty == ip4);
687 EXPECT_FALSE(ip4 == addrEmpty);
688 IPAddress ip6("::1");
689 EXPECT_FALSE(addrEmpty == ip6);
690 EXPECT_FALSE(ip6 == addrEmpty);
691 IPAddress ip6Map("::ffff:192.0.2.129");
692 EXPECT_FALSE(addrEmpty == ip6Map);
693 EXPECT_FALSE(ip6Map == addrEmpty);
694 IPAddress ip4Zero("0.0.0.0");
695 EXPECT_FALSE(addrEmpty == ip4Zero);
696 EXPECT_FALSE(ip4Zero == addrEmpty);
697 IPAddress ip6Zero("::");
698 EXPECT_FALSE(addrEmpty == ip6Zero);
699 EXPECT_FALSE(ip6Zero == addrEmpty);
700 EXPECT_EQ(addrEmpty, addrEmpty);
703 // Test subnet calcs with 6to4 addresses
704 TEST(IPAddress, InSubnetWith6to4) {
705 auto ip = IPAddress("2002:c000:022a::"); // 192.0.2.42
706 auto subnet = IPAddress("192.0.0.0");
707 EXPECT_TRUE(ip.inSubnet(subnet, 16));
709 auto ip2 = IPAddress("192.0.0.1");
710 auto subnet2 = IPAddress("2002:c000:0000::"); // 192.0.0.0
711 EXPECT_TRUE(ip2.inSubnet(subnet2, 14));
713 auto ip3 = IPAddress("2002:c000:022a::"); // 192.0.2.42
714 auto subnet3 = IPAddress("2002:c000:0000::"); // 192.0.0.0
715 EXPECT_TRUE(ip3.inSubnet(subnet3, 16));
718 static const vector<string> ipv4Strs = {
723 TEST(IPAddress, getIPv6For6To4) {
724 for (auto ipv4Str : ipv4Strs) {
725 auto ip = IPAddress(ipv4Str);
726 EXPECT_TRUE(ip.isV4());
727 IPAddressV4 ipv4 = ip.asV4();
728 auto ipv6 = ipv4.getIPv6For6To4();
729 EXPECT_EQ(ipv6.type(), IPAddressV6::Type::T6TO4);
730 auto ipv4New = ipv6.getIPv4For6To4();
731 EXPECT_TRUE(ipv4Str.compare(ipv4New.str()) == 0);
735 static const vector<pair<string, uint8_t> > invalidMasks = {
739 TEST(IPAddress, InvalidMask) {
740 for (auto& tc : invalidMasks) {
741 auto ip = IPAddress(tc.first);
742 EXPECT_THROW(ip.mask(tc.second), IPAddressFormatException);
746 static const vector<pair<string, IPAddressV6::Type> > v6types = {
747 {"::1", IPAddressV6::Type::NORMAL},
748 {"2620:0:1cfe:face:b00c::3", IPAddressV6::Type::NORMAL},
749 {"2001:0000:4136:e378:8000:63bf:3fff:fdd2", IPAddressV6::Type::TEREDO},
750 {"2002:c000:022a::", IPAddressV6::Type::T6TO4},
752 TEST(IPAddress, V6Types) {
753 auto mkName = [&](const IPAddressV6::Type t) -> string {
755 case IPAddressV6::Type::TEREDO:
757 case IPAddressV6::Type::T6TO4:
764 for (auto& tc : v6types) {
765 auto ip = IPAddress(tc.first);
766 EXPECT_TRUE(ip.isV6());
767 IPAddressV6 ipv6 = ip.asV6();
768 EXPECT_EQ(tc.second, ipv6.type())
769 << "expected " << mkName(tc.second) << ", got " << mkName(ipv6.type());
771 case IPAddressV6::Type::TEREDO:
772 EXPECT_TRUE(ipv6.isTeredo()) << "isTeredo was false";
773 EXPECT_FALSE(ipv6.is6To4()) << "is6To4 was true";
775 case IPAddressV6::Type::T6TO4:
776 EXPECT_TRUE(ipv6.is6To4()) << "is6To4 was false";
777 EXPECT_FALSE(ipv6.isTeredo()) << "isTeredo was true";
779 case IPAddressV6::Type::NORMAL:
780 EXPECT_FALSE(ipv6.is6To4()) << "is6To4 was true";
781 EXPECT_FALSE(ipv6.isTeredo()) << "isTeredo was true";
784 throw std::range_error("Invalid expected type: " +
785 folly::to<std::string>(tc.second));
790 static const vector<pair<string, uint32_t> > provideToLong = {
792 {"10.0.0.0", 167772160},
793 {"126.131.128.23", 2122547223},
794 {"192.168.0.0", 3232235520},
796 TEST(IPAddress, ToLong) {
797 for (auto& tc : provideToLong) {
798 auto ip = IPAddress(tc.first);
799 EXPECT_TRUE(ip.isV4());
800 IPAddressV4 ipv4 = ip.asV4();
801 EXPECT_EQ(tc.second, ipv4.toLongHBO());
803 auto ip2 = IPAddress::fromLongHBO(tc.second);
804 EXPECT_TRUE(ip2.isV4());
805 EXPECT_TRUE(tc.first.compare(ip2.str()) == 0);
806 EXPECT_EQ(tc.second, ip2.asV4().toLongHBO());
808 auto nla = htonl(tc.second);
809 auto ip3 = IPAddress::fromLong(nla);
810 EXPECT_TRUE(ip3.isV4());
811 EXPECT_TRUE(tc.first.compare(ip3.str()) == 0);
812 EXPECT_EQ(nla, ip3.asV4().toLong());
816 TEST(IPAddress, fromBinaryV4) {
817 for (auto& tc : provideToLong) {
818 SCOPED_TRACE(tc.first);
823 data.u32 = Endian::big(tc.second);
824 ByteRange bytes(data.u8, 4);
826 auto fromBin = IPAddressV4::fromBinary(bytes);
827 IPAddressV4 fromStr(tc.first);
828 EXPECT_EQ(fromStr, fromBin);
830 IPAddressV4 addr2("0.0.0.0");
831 addr2 = IPAddressV4::fromBinary(bytes);
832 EXPECT_EQ(fromStr, addr2);
834 IPAddress genericAddr = IPAddress::fromBinary(bytes);
835 ASSERT_TRUE(genericAddr.isV4());
836 EXPECT_EQ(fromStr, genericAddr.asV4());
837 EXPECT_EQ(ByteRange(genericAddr.bytes(), genericAddr.byteCount()), bytes);
841 EXPECT_THROW(IPAddressV4::fromBinary(ByteRange(data, 3)),
842 IPAddressFormatException);
843 EXPECT_THROW(IPAddressV4::fromBinary(ByteRange(data, 16)),
844 IPAddressFormatException);
845 EXPECT_THROW(IPAddressV4::fromBinary(ByteRange(data, 20)),
846 IPAddressFormatException);
849 TEST(IPAddress, toBinaryV4) {
850 for (auto& tc : provideToLong) {
851 SCOPED_TRACE(tc.first);
856 data.u32 = Endian::big(tc.second);
857 ByteRange bytes(data.u8, 4);
859 auto fromBin = IPAddressV4::fromBinary(bytes);
860 auto toBin = fromBin.toBinary();
861 EXPECT_EQ(bytes, toBin);
865 static const vector<pair<string, vector<uint8_t> > > provideBinary16Bytes = {
867 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
868 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
870 {0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
871 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02}},
872 {"fe80::0012:34ff:fe56:78ab",
873 {0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
874 0x00, 0x12, 0x34, 0xff, 0xfe, 0x56, 0x78, 0xab}},
875 {"2001:db8:1234:5678:90ab:cdef:8765:4321",
876 {0x20, 0x01, 0x0d, 0xb8, 0x12, 0x34, 0x56, 0x78,
877 0x90, 0xab, 0xcd, 0xef, 0x87, 0x65, 0x43, 0x21}},
879 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
880 0xff, 0xff, 0x00, 0x00, 0xc0, 0xa8, 0x00, 0x01}},
883 TEST(IPAddress, fromBinaryV6) {
884 for (auto& tc : provideBinary16Bytes) {
885 SCOPED_TRACE(tc.first);
886 ByteRange bytes(&tc.second.front(), tc.second.size());
888 auto fromBin = IPAddressV6::fromBinary(bytes);
889 IPAddressV6 fromStr(tc.first);
890 EXPECT_EQ(fromStr, fromBin);
892 IPAddressV6 addr2("::0");
893 addr2 = IPAddressV6::fromBinary(bytes);
894 EXPECT_EQ(fromStr, addr2);
896 IPAddress genericAddr = IPAddress::fromBinary(bytes);
897 ASSERT_TRUE(genericAddr.isV6());
898 EXPECT_EQ(fromStr, genericAddr.asV6());
899 EXPECT_EQ(ByteRange(genericAddr.bytes(), genericAddr.byteCount()), bytes);
903 EXPECT_THROW(IPAddressV6::fromBinary(ByteRange(data, 3)),
904 IPAddressFormatException);
905 EXPECT_THROW(IPAddressV6::fromBinary(ByteRange(data, 4)),
906 IPAddressFormatException);
907 EXPECT_THROW(IPAddressV6::fromBinary(ByteRange(data, 20)),
908 IPAddressFormatException);
911 TEST(IPAddress, toBinaryV6) {
912 for (auto& tc : provideBinary16Bytes) {
913 SCOPED_TRACE(tc.first);
914 ByteRange bytes(&tc.second.front(), tc.second.size());
916 auto fromBin = IPAddressV6::fromBinary(bytes);
917 auto toBin = fromBin.toBinary();
918 EXPECT_EQ(bytes, toBin);
922 TEST_P(IPAddressFlagTest, IsLoopback) {
923 AddressFlags param = GetParam();
924 IPAddress addr(param.address);
926 EXPECT_EQ(param.version, addr.version());
927 EXPECT_EQ(param.isLoopback(), addr.isLoopback());
930 TEST_P(IPAddressFlagTest, IsPrivate) {
931 AddressFlags param = GetParam();
932 IPAddress addr(param.address);
934 EXPECT_EQ(param.version, addr.version());
935 EXPECT_EQ(param.isPrivate(), addr.isPrivate()) << addr;
938 TEST_P(IPAddressFlagTest, IsNonroutable) {
939 AddressFlags param = GetParam();
940 IPAddress addr(param.address);
942 EXPECT_EQ(param.version, addr.version());
943 EXPECT_EQ(param.isNonroutable(), addr.isNonroutable()) << addr;
946 TEST_P(IPAddressFlagTest, IsZero) {
947 AddressFlags param = GetParam();
948 IPAddress addr(param.address);
950 EXPECT_EQ(param.version, addr.version());
951 EXPECT_EQ(param.isZero(), addr.isZero()) << addr;
954 TEST_P(IPAddressFlagTest, IsLinkLocal) {
955 AddressFlags param = GetParam();
956 IPAddress addr(param.address);
957 EXPECT_EQ(param.isLinkLocal(), addr.isLinkLocal()) << addr;
960 TEST(IPAddress, CreateLinkLocal) {
961 IPAddressV6 addr(IPAddressV6::LINK_LOCAL, MacAddress("00:05:73:f9:46:fc"));
962 EXPECT_EQ(IPAddressV6("fe80::0205:73ff:fef9:46fc"), addr);
964 addr = IPAddressV6(IPAddressV6::LINK_LOCAL, MacAddress("02:00:00:12:34:56"));
965 EXPECT_EQ(IPAddressV6("fe80::ff:fe12:3456"), addr);
968 TEST_P(IPAddressFlagTest, IsLinkLocalBroadcast) {
969 AddressFlags param = GetParam();
970 IPAddress addr(param.address);
971 EXPECT_EQ(param.version, addr.version());
972 EXPECT_EQ(param.isLinkLocalBroadcast(), addr.isLinkLocalBroadcast());
975 TEST(IPAddress, SolicitedNodeAddress) {
976 // An example from RFC 4291 section 2.7.1
977 EXPECT_EQ(IPAddressV6("ff02::1:ff0e:8c6c"),
978 IPAddressV6("4037::01:800:200e:8c6c").getSolicitedNodeAddress());
980 // An example from wikipedia
981 // (http://en.wikipedia.org/wiki/Solicited-node_multicast_address)
982 EXPECT_EQ(IPAddressV6("ff02::1:ff28:9c5a"),
983 IPAddressV6("fe80::2aa:ff:fe28:9c5a").getSolicitedNodeAddress());
986 TEST_P(IPAddressByteAccessorTest, CheckBytes) {
987 auto addrData = GetParam();
988 IPAddress ip(addrData.address);
990 for (auto byitr = addrData.bytes.begin(); i < ip.byteCount(); ++i, ++byitr) {
991 EXPECT_EQ(*byitr, ip.getNthMSByte(i));
992 EXPECT_EQ(*byitr, ip.isV4() ?
993 ip.asV4().getNthMSByte(i) : ip.asV6().getNthMSByte(i));
996 for (auto byritr = addrData.bytes.rbegin(); i < ip.byteCount(); ++i,
998 EXPECT_EQ(*byritr, ip.getNthLSByte(i));
999 EXPECT_EQ(*byritr, ip.isV4() ?
1000 ip.asV4().getNthLSByte(i) : ip.asV6().getNthLSByte(i));
1004 TEST_P(IPAddressBitAccessorTest, CheckBits) {
1005 auto addrData = GetParam();
1006 auto littleEndianAddrData = addrData.bytes;
1007 //IPAddress stores address data in n/w byte order.
1008 reverse(littleEndianAddrData.begin(), littleEndianAddrData.end());
1009 //Bit iterator goes from LSBit to MSBit
1010 //We will traverse the IPAddress bits from 0 to bitCount -1
1011 auto bitr = folly::makeBitIterator(littleEndianAddrData.begin());
1012 IPAddress ip(addrData.address);
1013 for (size_t i = 0; i < ip.bitCount(); ++i) {
1014 auto msbIndex = ip.bitCount() - i - 1;
1015 EXPECT_EQ(*bitr, ip.getNthMSBit(msbIndex));
1016 EXPECT_EQ(*bitr, ip.isV4() ? ip.asV4().getNthMSBit(msbIndex) :
1017 ip.asV6().getNthMSBit(msbIndex));
1018 EXPECT_EQ(*bitr, ip.getNthLSBit(i));
1019 EXPECT_EQ(*bitr, ip.isV4() ? ip.asV4().getNthLSBit(i) :
1020 ip.asV6().getNthLSBit(i));
1025 TEST(IPAddress, InvalidByteAccess) {
1026 IPAddress ip4("10.10.10.10");
1027 //MSByte, LSByte accessors are 0 indexed
1028 EXPECT_THROW(ip4.getNthMSByte(ip4.byteCount()), std::invalid_argument);
1029 EXPECT_THROW(ip4.getNthLSByte(ip4.byteCount()), std::invalid_argument);
1030 EXPECT_THROW(ip4.getNthMSByte(-1), std::invalid_argument);
1031 EXPECT_THROW(ip4.getNthLSByte(-1), std::invalid_argument);
1032 auto asV4 = ip4.asV4();
1033 EXPECT_THROW(asV4.getNthMSByte(asV4.byteCount()), std::invalid_argument);
1034 EXPECT_THROW(asV4.getNthLSByte(asV4.byteCount()), std::invalid_argument);
1035 EXPECT_THROW(asV4.getNthMSByte(-1), std::invalid_argument);
1036 EXPECT_THROW(asV4.getNthLSByte(-1), std::invalid_argument);
1038 IPAddress ip6("2620:0:1cfe:face:b00c::3");
1039 EXPECT_THROW(ip6.getNthMSByte(ip6.byteCount()), std::invalid_argument);
1040 EXPECT_THROW(ip6.getNthLSByte(ip6.byteCount()), std::invalid_argument);
1041 EXPECT_THROW(ip6.getNthMSByte(-1), std::invalid_argument);
1042 EXPECT_THROW(ip6.getNthLSByte(-1), std::invalid_argument);
1043 auto asV6 = ip6.asV6();
1044 EXPECT_THROW(asV6.getNthMSByte(asV6.byteCount()), std::invalid_argument);
1045 EXPECT_THROW(asV6.getNthLSByte(asV6.byteCount()), std::invalid_argument);
1046 EXPECT_THROW(asV6.getNthMSByte(-1), std::invalid_argument);
1047 EXPECT_THROW(asV6.getNthLSByte(-1), std::invalid_argument);
1051 TEST(IPAddress, InvalidBBitAccess) {
1052 IPAddress ip4("10.10.10.10");
1053 //MSByte, LSByte accessors are 0 indexed
1054 EXPECT_THROW(ip4.getNthMSBit(ip4.bitCount()), std::invalid_argument);
1055 EXPECT_THROW(ip4.getNthLSBit(ip4.bitCount()), std::invalid_argument);
1056 EXPECT_THROW(ip4.getNthMSBit(-1), std::invalid_argument);
1057 EXPECT_THROW(ip4.getNthLSBit(-1), std::invalid_argument);
1058 auto asV4 = ip4.asV4();
1059 EXPECT_THROW(asV4.getNthMSBit(asV4.bitCount()), std::invalid_argument);
1060 EXPECT_THROW(asV4.getNthLSBit(asV4.bitCount()), std::invalid_argument);
1061 EXPECT_THROW(asV4.getNthMSBit(-1), std::invalid_argument);
1062 EXPECT_THROW(asV4.getNthLSBit(-1), std::invalid_argument);
1064 IPAddress ip6("2620:0:1cfe:face:b00c::3");
1065 EXPECT_THROW(ip6.getNthMSBit(ip6.bitCount()), std::invalid_argument);
1066 EXPECT_THROW(ip6.getNthLSBit(ip6.bitCount()), std::invalid_argument);
1067 EXPECT_THROW(ip6.getNthMSBit(-1), std::invalid_argument);
1068 EXPECT_THROW(ip6.getNthLSBit(-1), std::invalid_argument);
1069 auto asV6 = ip6.asV6();
1070 EXPECT_THROW(asV6.getNthMSBit(asV6.bitCount()), std::invalid_argument);
1071 EXPECT_THROW(asV6.getNthLSBit(asV6.bitCount()), std::invalid_argument);
1072 EXPECT_THROW(asV6.getNthMSBit(-1), std::invalid_argument);
1073 EXPECT_THROW(asV6.getNthLSBit(-1), std::invalid_argument);
1076 TEST(IPAddress, StringFormat) {
1078 for (int i = 0; i < 8; ++i) {
1079 auto t = htons(0x0123 + ((i % 4) * 0x4444));
1083 a6.s6_addr16[i] = t;
1086 EXPECT_EQ("0123:4567:89ab:cdef:0123:4567:89ab:cdef",
1087 detail::fastIpv6ToString(a6));
1090 a4.s_addr = htonl(0x01020304);
1091 EXPECT_EQ("1.2.3.4", detail::fastIpv4ToString(a4));
1094 TEST(IPAddress, getMacAddressFromLinkLocal) {
1095 IPAddressV6 ip6("fe80::f652:14ff:fec5:74d8");
1096 EXPECT_TRUE(ip6.getMacAddressFromLinkLocal().hasValue());
1097 EXPECT_EQ("f4:52:14:c5:74:d8", ip6.getMacAddressFromLinkLocal()->toString());
1100 TEST(IPAddress, getMacAddressFromLinkLocal_Negative) {
1101 IPAddressV6 no_link_local_ip6("2803:6082:a2:4447::1");
1102 EXPECT_FALSE(no_link_local_ip6.getMacAddressFromLinkLocal().hasValue());
1103 no_link_local_ip6 = IPAddressV6("fe80::f652:14ff:ccc5:74d8");
1104 EXPECT_FALSE(no_link_local_ip6.getMacAddressFromLinkLocal().hasValue());
1105 no_link_local_ip6 = IPAddressV6("fe80::f652:14ff:ffc5:74d8");
1106 EXPECT_FALSE(no_link_local_ip6.getMacAddressFromLinkLocal().hasValue());
1107 no_link_local_ip6 = IPAddressV6("fe81::f652:14ff:ffc5:74d8");
1108 EXPECT_FALSE(no_link_local_ip6.getMacAddressFromLinkLocal().hasValue());
1111 TEST(IPAddress, LongestCommonPrefix) {
1112 IPAddress ip10("10.0.0.0");
1113 IPAddress ip11("11.0.0.0");
1114 IPAddress ip12("12.0.0.0");
1115 IPAddress ip128("128.0.0.0");
1116 IPAddress ip10dot10("10.10.0.0");
1117 auto prefix = IPAddress::longestCommonPrefix({ip10, 8}, {ip128, 8});
1118 auto prefix4 = IPAddressV4::longestCommonPrefix({ip10.asV4(), 8},
1120 // No bits match b/w 128/8 and 10/8
1121 EXPECT_EQ(IPAddress("0.0.0.0"), prefix.first);
1122 EXPECT_EQ(0, prefix.second);
1123 EXPECT_EQ(IPAddressV4("0.0.0.0"), prefix4.first);
1124 EXPECT_EQ(0, prefix4.second);
1126 prefix = IPAddress::longestCommonPrefix({ip10, 8}, {ip10dot10, 16});
1127 prefix4 = IPAddressV4::longestCommonPrefix({ip10.asV4(), 8},
1128 {ip10dot10.asV4(), 16});
1129 // Between 10/8 and 10.10/16, 10/8 is the longest common match
1130 EXPECT_EQ(ip10, prefix.first);
1131 EXPECT_EQ(8, prefix.second);
1132 EXPECT_EQ(ip10.asV4(), prefix4.first);
1133 EXPECT_EQ(8, prefix4.second);
1135 prefix = IPAddress::longestCommonPrefix({ip11, 8}, {ip12, 8});
1136 prefix4 = IPAddressV4::longestCommonPrefix({ip11.asV4(), 8},
1138 // 12 = 1100, 11 = 1011, longest match - 1000 = 8
1139 EXPECT_EQ(IPAddress("8.0.0.0"), prefix.first);
1140 EXPECT_EQ(5, prefix.second);
1141 EXPECT_EQ(IPAddressV4("8.0.0.0"), prefix4.first);
1142 EXPECT_EQ(5, prefix4.second);
1144 // Between 128/1 and 128/2, longest match 128/1
1145 prefix = IPAddress::longestCommonPrefix({ip128, 1}, {ip128, 2});
1146 prefix4 = IPAddressV4::longestCommonPrefix({ip128.asV4(), 1},
1148 EXPECT_EQ(ip128, prefix.first);
1149 EXPECT_EQ(1, prefix.second);
1150 EXPECT_EQ(ip128.asV4(), prefix4.first);
1151 EXPECT_EQ(1, prefix4.second);
1153 IPAddress ip6("2620:0:1cfe:face:b00c::3");
1154 prefix = IPAddress::longestCommonPrefix({ip6, ip6.bitCount()},
1155 {ip6, ip6.bitCount()});
1156 auto prefix6 = IPAddressV6::longestCommonPrefix(
1157 {ip6.asV6(), IPAddressV6::bitCount()},
1158 {ip6.asV6(), IPAddressV6::bitCount()});
1159 // Longest common b/w me and myself is myself
1160 EXPECT_EQ(ip6, prefix.first);
1161 EXPECT_EQ(ip6.bitCount(), prefix.second);
1162 EXPECT_EQ(ip6.asV6(), prefix6.first);
1163 EXPECT_EQ(ip6.asV6().bitCount(), prefix6.second);
1165 IPAddress ip6Zero("::");
1166 prefix = IPAddress::longestCommonPrefix({ip6, ip6.bitCount()}, {ip6Zero, 0});
1167 prefix6 = IPAddressV6::longestCommonPrefix(
1168 {ip6.asV6(), IPAddressV6::bitCount()},
1169 {ip6Zero.asV6(), 0});
1170 // Longest common b/w :: (ipv6 equivalent of 0/0) is ::
1171 EXPECT_EQ(ip6Zero, prefix.first);
1172 EXPECT_EQ(0, prefix.second);
1174 // Exceptional cases
1175 EXPECT_THROW(IPAddress::longestCommonPrefix({ip10, 8}, {ip6, 128}),
1176 std::invalid_argument);
1177 EXPECT_THROW(IPAddress::longestCommonPrefix({ip10, ip10.bitCount() + 1},
1179 std::invalid_argument);
1180 EXPECT_THROW(IPAddressV4::longestCommonPrefix(
1181 {ip10.asV4(), IPAddressV4::bitCount() + 1},
1183 std::invalid_argument);
1184 EXPECT_THROW(IPAddress::longestCommonPrefix({ip6, ip6.bitCount() + 1},
1185 {ip6, ip6.bitCount()}),
1186 std::invalid_argument);
1187 EXPECT_THROW(IPAddressV6::longestCommonPrefix(
1188 {ip6.asV6(), IPAddressV6::bitCount() + 1},
1189 {ip6.asV6(), IPAddressV6::bitCount()}),
1190 std::invalid_argument);
1194 static const vector<AddressData> validAddressProvider = {
1195 AddressData("127.0.0.1", {127,0,0,1}, 4),
1196 AddressData("69.63.189.16", {69,63,189,16}, 4),
1197 AddressData("0.0.0.0", {0,0,0,0}, 4),
1199 {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1}, 6),
1200 AddressData("2620:0:1cfe:face:b00c::3",
1201 {38,32,0,0,28,254,250,206,176,12,0,0,0,0,0,3}, 6),
1204 static const vector<string> invalidAddressProvider = {
1210 "127.0.0.1,127.0.0.1",
1214 static const vector<ByteVector> invalidBinaryProvider = {
1215 {0x31, 0x32, 0x37, 0x2e, 0x30, 0x30, 0x2e, 0x30, 0x2e, 0x31},
1221 {0x00, 0x00, 0x00, 0x00, 0x00},
1225 static const uint8_t IS_LOCAL = AddressFlags::IS_LOCAL;
1226 static const uint8_t IS_NONROUTABLE = AddressFlags::IS_NONROUTABLE;
1227 static const uint8_t IS_PRIVATE = AddressFlags::IS_PRIVATE;
1228 static const uint8_t IS_ZERO = AddressFlags::IS_ZERO;
1229 static const uint8_t IS_LINK_LOCAL =
1230 AddressFlags::IS_LINK_LOCAL | IS_NONROUTABLE;
1231 static const uint8_t IS_PVT_NONROUTE = IS_NONROUTABLE | IS_PRIVATE;
1232 static const uint8_t IS_MULTICAST = AddressFlags::IS_MULTICAST;
1233 static const uint8_t IS_LINK_LOCAL_BROADCAST =
1234 AddressFlags::IS_LINK_LOCAL_BROADCAST;
1236 static vector<AddressFlags> flagProvider = {
1238 AddressFlags("69.63.176.1", 4, 0),
1239 AddressFlags("128.12.65.3", 4, 0),
1240 AddressFlags("192.0.1.0", 4, 0),
1241 AddressFlags("198.51.101.0", 4, 0),
1242 AddressFlags("203.0.114.0", 4, 0),
1243 AddressFlags("128.12.64.115", 4, 0),
1246 AddressFlags("2620:0:1cfe:face:b00c::3", 6, 0),
1249 AddressFlags("127.0.0.1", 4, IS_LOCAL | IS_PVT_NONROUTE),
1250 AddressFlags("::1", 6, IS_LOCAL | IS_PVT_NONROUTE),
1253 AddressFlags("169.254.0.1", 4, IS_LINK_LOCAL | IS_PVT_NONROUTE),
1256 AddressFlags("10.0.0.0", 4, IS_PVT_NONROUTE),
1257 AddressFlags("10.11.12.13", 4, IS_PVT_NONROUTE),
1258 AddressFlags("10.255.255.255", 4, IS_PVT_NONROUTE),
1259 AddressFlags("127.128.129.200", 4, IS_LOCAL | IS_PVT_NONROUTE),
1260 AddressFlags("127.255.255.255", 4, IS_LOCAL | IS_PVT_NONROUTE),
1261 AddressFlags("169.254.0.0", 4, IS_LINK_LOCAL | IS_PVT_NONROUTE),
1262 AddressFlags("192.168.0.0", 4, IS_PVT_NONROUTE),
1263 AddressFlags("192.168.200.255", 4, IS_PVT_NONROUTE),
1264 AddressFlags("192.168.255.255", 4, IS_PVT_NONROUTE),
1267 AddressFlags("fd01:1637:1c56:66af::", 6, IS_PVT_NONROUTE),
1270 AddressFlags("0.0.0.0", 4, IS_NONROUTABLE | IS_ZERO),
1271 AddressFlags("0.255.255.255", 4, IS_NONROUTABLE),
1272 AddressFlags("192.0.0.0", 4, IS_NONROUTABLE),
1273 AddressFlags("192.0.2.0", 4, IS_NONROUTABLE),
1274 AddressFlags("198.18.0.0", 4, IS_NONROUTABLE),
1275 AddressFlags("198.19.255.255", 4, IS_NONROUTABLE),
1276 AddressFlags("198.51.100.0", 4, IS_NONROUTABLE),
1277 AddressFlags("198.51.100.255", 4, IS_NONROUTABLE),
1278 AddressFlags("203.0.113.0", 4, IS_NONROUTABLE),
1279 AddressFlags("203.0.113.255", 4, IS_NONROUTABLE),
1280 AddressFlags("224.0.0.0", 4, IS_NONROUTABLE | IS_MULTICAST),
1281 AddressFlags("240.0.0.0", 4, IS_NONROUTABLE),
1282 AddressFlags("224.0.0.0", 4, IS_NONROUTABLE),
1283 // v4 link local broadcast
1284 AddressFlags("255.255.255.255", 4, IS_NONROUTABLE | IS_LINK_LOCAL_BROADCAST),
1287 AddressFlags("1999::1", 6, IS_NONROUTABLE),
1288 AddressFlags("0::0", 6, IS_NONROUTABLE | IS_ZERO),
1289 AddressFlags("0::0:0", 6, IS_NONROUTABLE | IS_ZERO),
1290 AddressFlags("0:0:0::0", 6, IS_NONROUTABLE | IS_ZERO),
1293 AddressFlags("fe80::0205:73ff:fef9:46fc", 6, IS_LINK_LOCAL),
1294 AddressFlags("fe80::0012:34ff:fe56:7890", 6, IS_LINK_LOCAL),
1297 AddressFlags("224.0.0.1", 4, IS_MULTICAST | IS_NONROUTABLE) ,
1298 AddressFlags("224.0.0.251", 4, IS_MULTICAST | IS_NONROUTABLE),
1299 AddressFlags("239.12.34.56", 4, IS_MULTICAST | IS_NONROUTABLE),
1302 AddressFlags("ff00::", 6, IS_MULTICAST | IS_NONROUTABLE),
1303 AddressFlags("ff02:ffff::1", 6, IS_MULTICAST | IS_NONROUTABLE),
1304 AddressFlags("ff02::101", 6, IS_MULTICAST | IS_NONROUTABLE),
1305 AddressFlags("ff0e::101", 6, IS_MULTICAST),
1306 // v6 link local broadcast
1307 AddressFlags("ff02::1", 6, IS_NONROUTABLE | IS_LINK_LOCAL_BROADCAST),
1310 static const vector<pair<string, string> > mapProvider = {
1311 {"::ffff:192.0.2.128", "192.0.2.128"},
1312 {"192.0.2.128", "::ffff:192.0.2.128"},
1313 {"::FFFF:129.144.52.38", "129.144.52.38"},
1314 {"129.144.52.38", "::FFFF:129.144.52.38"},
1315 {"0:0:0:0:0:FFFF:222.1.41.90", "222.1.41.90"},
1316 {"::FFFF:222.1.41.90", "222.1.41.90"},
1319 static const vector<MaskData> masksProvider = {
1320 MaskData("255.255.255.255", 1, "128.0.0.0"),
1321 MaskData("255.255.255.255", 2, "192.0.0.0"),
1322 MaskData("192.0.2.42", 16, "192.0.0.0"),
1323 MaskData("255.255.255.255", 24, "255.255.255.0"),
1324 MaskData("255.255.255.255", 32, "255.255.255.255"),
1325 MaskData("10.10.10.10", 0, "0.0.0.0"),
1326 MaskData("::1", 64, "::"),
1327 MaskData("2620:0:1cfe:face:b00c::3", 1, "::"),
1328 MaskData("2620:0:1cfe:face:b00c::3", 3, "2000::"),
1329 MaskData("2620:0:1cfe:face:b00c::3", 6, "2400::"),
1330 MaskData("2620:0:1cfe:face:b00c::3", 7, "2600::"),
1331 MaskData("2620:0:1cfe:face:b00c::3", 11, "2620::"),
1332 MaskData("2620:0:1cfe:face:b00c::3", 36, "2620:0:1000::"),
1333 MaskData("2620:0:1cfe:face:b00c::3", 37, "2620:0:1800::"),
1334 MaskData("2620:0:1cfe:face:b00c::3", 38, "2620:0:1c00::"),
1335 MaskData("2620:0:1cfe:face:b00c::3", 41, "2620:0:1c80::"),
1336 MaskData("2620:0:1cfe:face:b00c::3", 42, "2620:0:1cc0::"),
1337 MaskData("2620:0:1cfe:face:b00c::3", 43, "2620:0:1ce0::"),
1338 MaskData("2620:0:1cfe:face:b00c::3", 44, "2620:0:1cf0::"),
1339 MaskData("2620:0:1cfe:face:b00c::3", 45, "2620:0:1cf8::"),
1340 MaskData("2620:0:1cfe:face:b00c::3", 46, "2620:0:1cfc::"),
1341 MaskData("2620:0:1cfe:face:b00c::3", 47, "2620:0:1cfe::"),
1342 MaskData("2620:0:1cfe:face:b00c::3", 49, "2620:0:1cfe:8000::"),
1343 MaskData("2620:0:1cfe:face:b00c::3", 50, "2620:0:1cfe:c000::"),
1344 MaskData("2620:0:1cfe:face:b00c::3", 51, "2620:0:1cfe:e000::"),
1345 MaskData("2620:0:1cfe:face:b00c::3", 52, "2620:0:1cfe:f000::"),
1346 MaskData("2620:0:1cfe:face:b00c::3", 53, "2620:0:1cfe:f800::"),
1347 MaskData("2620:0:1cfe:face:b00c::3", 55, "2620:0:1cfe:fa00::"),
1348 MaskData("2620:0:1cfe:face:b00c::3", 57, "2620:0:1cfe:fa80::"),
1349 MaskData("2620:0:1cfe:face:b00c::3", 58, "2620:0:1cfe:fac0::"),
1350 MaskData("2620:0:1cfe:face:b00c::3", 61, "2620:0:1cfe:fac8::"),
1351 MaskData("2620:0:1cfe:face:b00c::3", 62, "2620:0:1cfe:facc::"),
1352 MaskData("2620:0:1cfe:face:b00c::3", 63, "2620:0:1cfe:face::"),
1353 MaskData("2620:0:1cfe:face:b00c::3", 65, "2620:0:1cfe:face:8000::"),
1354 MaskData("2620:0:1cfe:face:b00c::3", 67, "2620:0:1cfe:face:a000::"),
1355 MaskData("2620:0:1cfe:face:b00c::3", 68, "2620:0:1cfe:face:b000::"),
1356 MaskData("2620:0:1cfe:face:b00c::3", 77, "2620:0:1cfe:face:b008::"),
1357 MaskData("2620:0:1cfe:face:b00c::3", 78, "2620:0:1cfe:face:b00c::"),
1358 MaskData("2620:0:1cfe:face:b00c::3", 127, "2620:0:1cfe:face:b00c::2"),
1359 MaskData("2620:0:1cfe:face:b00c::3", 128, "2620:0:1cfe:face:b00c::3"),
1360 MaskData("2620:0:1cfe:face:b00c::3", 0, "::")
1363 static const vector<MaskBoundaryData> maskBoundaryProvider = {
1364 MaskBoundaryData("10.1.1.1", 24, "10.1.1.1", true),
1365 MaskBoundaryData("10.1.1.1", 8, "10.1.2.3", true),
1366 MaskBoundaryData("2620:0:1cfe:face:b00c::1", 48, "2620:0:1cfe::", true),
1367 // addresses that are NOT in the same subnet once mask is applied
1368 MaskBoundaryData("10.1.1.1", 24, "10.1.2.1", false),
1369 MaskBoundaryData("10.1.1.1", 16, "10.2.3.4", false),
1370 MaskBoundaryData("2620:0:1cfe:face:b00c::1", 48, "2620:0:1cfc::", false),
1373 INSTANTIATE_TEST_CASE_P(IPAddress,
1375 ::testing::ValuesIn(validAddressProvider));
1376 INSTANTIATE_TEST_CASE_P(IPAddress,
1378 ::testing::ValuesIn(flagProvider));
1379 INSTANTIATE_TEST_CASE_P(IPAddress,
1380 IPAddressMappedTest,
1381 ::testing::ValuesIn(mapProvider));
1382 INSTANTIATE_TEST_CASE_P(IPAddress,
1384 ::testing::ValuesIn(invalidAddressProvider));
1385 INSTANTIATE_TEST_CASE_P(IPAddress,
1386 IPAddressCtorBinaryTest,
1387 ::testing::ValuesIn(invalidBinaryProvider));
1388 INSTANTIATE_TEST_CASE_P(IPAddress,
1390 ::testing::ValuesIn(masksProvider));
1391 INSTANTIATE_TEST_CASE_P(IPAddress,
1392 IPAddressMaskBoundaryTest,
1393 ::testing::ValuesIn(maskBoundaryProvider));
1394 INSTANTIATE_TEST_CASE_P(IPAddress,
1395 IPAddressByteAccessorTest,
1396 ::testing::ValuesIn(validAddressProvider));
1397 INSTANTIATE_TEST_CASE_P(IPAddress,
1398 IPAddressBitAccessorTest,
1399 ::testing::ValuesIn(validAddressProvider));
1401 TEST(IPAddressV4, fetchMask) {
1402 struct X : private IPAddressV4 {
1403 using IPAddressV4::fetchMask;
1408 ::testing::ElementsAreArray(ByteArray4{{0x00, 0x00, 0x00, 0x00}}));
1412 ::testing::ElementsAreArray(ByteArray4{{0x80, 0x00, 0x00, 0x00}}));
1416 ::testing::ElementsAreArray(ByteArray4{{0xff, 0xff, 0xff, 0xfe}}));
1420 ::testing::ElementsAreArray(ByteArray4{{0xff, 0xff, 0xff, 0xff}}));
1423 TEST(IPAddressV6, fetchMask) {
1424 using ByteArray8 = std::array<uint8_t, 8>;
1426 struct X : private IPAddressV6 {
1427 using IPAddressV6::fetchMask;
1430 auto join = [](std::array<ByteArray8, 2> parts) {
1431 ByteArray16 _return;
1432 std::memcpy(_return.data(), parts.data(), _return.size());
1438 ::testing::ElementsAreArray(join({{
1439 ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
1440 ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
1445 ::testing::ElementsAreArray(join({{
1446 ByteArray8{{0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
1447 ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
1452 ::testing::ElementsAreArray(join({{
1453 ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe}},
1454 ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
1459 ::testing::ElementsAreArray(join({{
1460 ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
1461 ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
1466 ::testing::ElementsAreArray(join({{
1467 ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
1468 ByteArray8{{0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
1473 ::testing::ElementsAreArray(join({{
1474 ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
1475 ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe}},
1480 ::testing::ElementsAreArray(join({{
1481 ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
1482 ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},