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 <folly/test/IPAddressTest.h>
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>
27 using namespace folly;
31 TEST(IPAddress, CodeExample) {
32 EXPECT_EQ(4, sizeof(IPAddressV4));
33 EXPECT_EQ(20, sizeof(IPAddressV6));
34 EXPECT_EQ(24, sizeof(IPAddress));
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());
57 TEST(IPAddress, Scope) {
58 // Test that link-local scope is saved
59 auto str = "fe80::62eb:69ff:fe9b:ba60%eth0";
61 EXPECT_EQ(str, a2.str());
63 sockaddr_in6 sock = a2.toSockAddr();
64 EXPECT_NE(0, sock.sin6_scope_id);
67 EXPECT_EQ(str, a1.str());
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";
80 EXPECT_EQ(str, a2.str());
82 sockaddr_in6 sock = a2.toSockAddr();
83 EXPECT_NE(0, sock.sin6_scope_id);
86 EXPECT_EQ(str, a1.str());
94 TEST(IPAddress, Ordering) {
95 IPAddress a1("0.1.1.1");
96 IPAddress a2("1.1.1.0");
99 IPAddress b1("::ffff:0.1.1.1");
100 IPAddress b2("::ffff:1.1.1.0");
101 EXPECT_TRUE(b1 < b2);
104 TEST(IPAddress, InvalidAddressFamilyExceptions) {
108 EXPECT_THROW(addr.asV4(), InvalidAddressFamilyException);
113 EXPECT_THROW(addr.asV6(), InvalidAddressFamilyException);
119 addr.sin_family = AF_UNSPEC;
121 EXPECT_THROW(IPAddress((sockaddr *)&addr), InvalidAddressFamilyException);
125 TEST(IPAddress, CreateNetwork) {
126 // test valid IPv4 network
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));
134 // test valid IPv4 network without applying mask
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));
142 // test valid IPv6 network
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));
150 // test valid IPv6 network without applying mask
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));
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
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);
174 // test no slash string with default IPv6
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);
181 // test no slash string with invalid default
182 EXPECT_THROW(IPAddress::createNetwork("192.168.0.1", 33),
183 IPAddressFormatException);
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";
192 // Test assigning IPAddressV6 addr to IPAddress (was V4)
194 IPAddress addr(kIPv4Addr);
195 IPAddressV6 addrV6 = IPAddress(kIPv6Addr).asV6();
196 EXPECT_TRUE(addr.isV4());
197 EXPECT_EQ(kIPv4Addr, addr.str());
199 EXPECT_TRUE(addr.isV6());
200 EXPECT_EQ(kIPv6Addr, addr.str());
202 // Test assigning IPAddressV4 addr to IPAddress (was V6)
204 IPAddress addr(kIPv6Addr);
205 IPAddressV4 addrV4 = IPAddress(kIPv4Addr).asV4();
206 EXPECT_TRUE(addr.isV6());
207 EXPECT_EQ(kIPv6Addr, addr.str());
209 EXPECT_TRUE(addr.isV4());
210 EXPECT_EQ(kIPv4Addr, addr.str());
212 // Test assigning IPAddress(v6) to IPAddress (was v4)
214 IPAddress addr(kIPv4Addr);
215 IPAddress addrV6 = IPAddress(kIPv6Addr);
216 EXPECT_TRUE(addr.isV4());
217 EXPECT_EQ(kIPv4Addr, addr.str());
219 EXPECT_TRUE(addr.isV6());
220 EXPECT_EQ(kIPv6Addr, addr.str());
222 // Test assigning IPAddress(v4) to IPAddress (was v6)
224 IPAddress addr(kIPv6Addr);
225 IPAddress addrV4 = IPAddress(kIPv4Addr);
226 EXPECT_TRUE(addr.isV6());
227 EXPECT_EQ(kIPv6Addr, addr.str());
229 EXPECT_TRUE(addr.isV4());
230 EXPECT_EQ(kIPv4Addr, addr.str());
234 // Test the default constructors
235 TEST(IPAddress, CtorDefault) {
237 EXPECT_EQ(IPAddressV4("0.0.0.0"), v4);
239 EXPECT_EQ(IPAddressV6("::0"), v6);
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"));
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"));
255 IPAddressV6::validate("2620:0000:1cfe:face:b00c:0000:127.127.127.127"));
258 TEST(IPAddress, validate) {
259 EXPECT_TRUE(IPAddress::validate("0.0.0.0"));
260 EXPECT_TRUE(IPAddress::validate("::"));
261 EXPECT_FALSE(IPAddress::validate("asdf"));
264 // Test addresses constructed using a in[6]_addr value
265 TEST_P(IPAddressTest, CtorAddress) {
266 AddressData param = GetParam();
267 IPAddress strAddr(param.address);
270 if (param.version == 4) {
271 in_addr v4addr = detail::Bytes::mkAddress4(¶m.bytes[0]);
272 address = IPAddress(v4addr);
274 in6_addr v6addr = detail::Bytes::mkAddress6(¶m.bytes[0]);
275 address = IPAddress(v6addr);
277 ExpectIsValid(address);
278 EXPECT_EQ(strAddr, address);
281 // Test addresses constructed using a binary address
282 TEST_P(IPAddressTest, CtorBinary) {
283 AddressData param = GetParam();
286 if (param.version == 4) {
287 in_addr v4addr = AddressData::parseAddress4(param.address);
288 address = IPAddress::fromBinary(ByteRange((unsigned char*)&v4addr, 4));
290 in6_addr v6addr = AddressData::parseAddress6(param.address);
291 address = IPAddress::fromBinary(ByteRange((unsigned char*)&v6addr, 16));
294 ExpectIsValid(address);
295 EXPECT_EQ(IPAddress(param.address), address);
298 // Test addresses constructed using a string
299 TEST_P(IPAddressTest, CtorString) {
300 AddressData param = GetParam();
301 IPAddress address(param.address);
303 ExpectIsValid(address);
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);
317 TEST(IPAddress, CtorSockaddr) {
323 sin_addr.s_addr = htonl(2122547223);
324 addr.sin_family = AF_INET;
325 addr.sin_addr = sin_addr;
327 IPAddress ipAddr((sockaddr *)&addr);
328 EXPECT_TRUE(ipAddr.isV4());
329 EXPECT_EQ("126.131.128.23", ipAddr.str());
335 memset(&addr, 0, sizeof(addr));
338 // 2620:0:1cfe:face:b00c::3
339 38,32,0,0,28,254,250,206,176,12,0,0,0,0,0,3
341 std::memcpy(sin_addr.s6_addr, sec.data(), 16);
342 addr.sin6_family = AF_INET6;
343 addr.sin6_addr = sin_addr;
345 IPAddress ipAddr((sockaddr *)&addr);
346 EXPECT_TRUE(ipAddr.isV6());
347 EXPECT_EQ("2620:0:1cfe:face:b00c::3", ipAddr.str());
349 // test nullptr exception
351 sockaddr *addr = nullptr;
352 EXPECT_THROW(IPAddress((const sockaddr*)addr), IPAddressFormatException);
354 // test invalid family exception
359 sin_addr.s_addr = htonl(2122547223);
360 addr.sin_family = AF_UNSPEC;
361 addr.sin_addr = sin_addr;
363 EXPECT_THROW(IPAddress((sockaddr *)&addr), IPAddressFormatException);
367 TEST(IPAddress, ToSockaddrStorage) {
370 string strAddr("126.131.128.23");
371 IPAddress addr(strAddr);
372 sockaddr_storage out;
374 ASSERT_TRUE(addr.isV4()); // test invariant
375 EXPECT_GT(addr.toSockaddrStorage(&out), 0);
377 IPAddress sockAddr((sockaddr*)&out);
378 ASSERT_TRUE(sockAddr.isV4());
379 EXPECT_EQ(strAddr, sockAddr.str());
383 string strAddr("2620:0:1cfe:face:b00c::3");
384 IPAddress addr(strAddr);
385 sockaddr_storage out;
387 ASSERT_TRUE(addr.isV6()); // test invariant
388 EXPECT_GT(addr.toSockaddrStorage(&out), 0);
390 IPAddress sockAddr((sockaddr*)&out);
391 ASSERT_TRUE(sockAddr.isV6());
392 EXPECT_EQ(strAddr, sockAddr.str());
394 // test nullptr exception
396 sockaddr_storage *out = nullptr;
397 IPAddress addr("127.0.0.1");
398 EXPECT_THROW(addr.toSockaddrStorage(out), IPAddressFormatException);
400 // test invalid family exception
403 sockaddr_storage out;
404 ASSERT_EQ(AF_UNSPEC, addr.family());
405 EXPECT_THROW(addr.toSockaddrStorage(&out), InvalidAddressFamilyException);
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));
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));
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");
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());
439 TEST(IPaddress, fromInverseArpaName) {
441 IPAddressV4("10.0.0.1"),
442 IPAddressV4::fromInverseArpaName("1.0.0.10.in-addr.arpa"));
444 IPAddressV6("2620:0000:1cfe:face:b00c:0000:0000:0003"),
445 IPAddressV6::fromInverseArpaName(sformat(
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")));
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";
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);
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");
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())
479 TEST(IPAddress, ToFullyQualifiedLocal) {
481 EXPECT_EQ("0000:0000:0000:0000:0000:0000:0000:0001", ip.toFullyQualified())
484 TEST(IPAddress, ToFullyQualifiedAppendV6) {
485 IPAddress ip("2620:0:1cfe:face:b00c::3");
487 ip.toFullyQualifiedAppend(result);
488 EXPECT_EQ("2620:0000:1cfe:face:b00c:0000:0000:0003", result) << ip;
490 TEST(IPAddress, ToFullyQualifiedAppendV4) {
491 IPAddress ip("127.0.0.1");
493 ip.toFullyQualifiedAppend(result);
494 EXPECT_EQ("127.0.0.1", result) << ip;
496 TEST(IPAddress, ToFullyQualifiedSizeV6) {
497 auto actual = IPAddressV6::kToFullyQualifiedSize;
498 auto expected = IPAddress("::").toFullyQualified().size();
499 EXPECT_EQ(expected, actual);
501 TEST(IPAddress, MaxToFullyQualifiedSizeV4) {
502 auto actual = IPAddressV4::kMaxToFullyQualifiedSize;
503 auto expected = IPAddress("255.255.255.255").toFullyQualified().size();
504 EXPECT_EQ(expected, actual);
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;
513 auto mapped = IPAddress(mappedIp);
514 auto expected = IPAddress(otherIp);
516 EXPECT_EQ(expected, mapped);
520 v6addr = mapped.asV4().createIPv6();
521 } else if (expected.isV4()) {
522 v6addr = expected.asV4().createIPv6();
524 EXPECT_TRUE(v6addr.isV6());
525 EXPECT_TRUE(mapped == v6addr);
526 EXPECT_TRUE(expected == v6addr);
529 // Test subnet mask calculations
530 TEST_P(IPAddressMaskTest, Masks) {
531 auto param = GetParam();
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) << " -> "
540 // Test inSubnet calculations
541 TEST_P(IPAddressMaskTest, InSubnet) {
542 auto param = GetParam();
544 IPAddress ip(param.address);
545 IPAddress subnet(param.subnet);
546 EXPECT_TRUE(ip.inSubnet(subnet, param.mask));
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));
557 TEST(IPAddress, UnitializedEqual) {
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);
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));
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));
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));
592 static const vector<string> ipv4Strs = {
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);
609 static const vector<pair<string, uint8_t> > invalidMasks = {
613 TEST(IPAddress, InvalidMask) {
614 for (auto& tc : invalidMasks) {
615 auto ip = IPAddress(tc.first);
616 EXPECT_THROW(ip.mask(tc.second), IPAddressFormatException);
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},
626 TEST(IPAddress, V6Types) {
627 auto mkName = [&](const IPAddressV6::Type t) -> string {
629 case IPAddressV6::Type::TEREDO:
631 case IPAddressV6::Type::T6TO4:
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());
645 case IPAddressV6::Type::TEREDO:
646 EXPECT_TRUE(ipv6.isTeredo()) << "isTeredo was false";
647 EXPECT_FALSE(ipv6.is6To4()) << "is6To4 was true";
649 case IPAddressV6::Type::T6TO4:
650 EXPECT_TRUE(ipv6.is6To4()) << "is6To4 was false";
651 EXPECT_FALSE(ipv6.isTeredo()) << "isTeredo was true";
653 case IPAddressV6::Type::NORMAL:
654 EXPECT_FALSE(ipv6.is6To4()) << "is6To4 was true";
655 EXPECT_FALSE(ipv6.isTeredo()) << "isTeredo was true";
658 throw std::range_error("Invalid expected type: " +
659 folly::to<std::string>(tc.second));
664 static const vector<pair<string, uint32_t> > provideToLong = {
666 {"10.0.0.0", 167772160},
667 {"126.131.128.23", 2122547223},
668 {"192.168.0.0", 3232235520},
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());
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());
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());
690 TEST(IPAddress, fromBinaryV4) {
691 for (auto& tc : provideToLong) {
692 SCOPED_TRACE(tc.first);
697 data.u32 = Endian::big(tc.second);
698 ByteRange bytes(data.u8, 4);
700 auto fromBin = IPAddressV4::fromBinary(bytes);
701 IPAddressV4 fromStr(tc.first);
702 EXPECT_EQ(fromStr, fromBin);
704 IPAddressV4 addr2("0.0.0.0");
705 addr2 = IPAddressV4::fromBinary(bytes);
706 EXPECT_EQ(fromStr, addr2);
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);
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);
723 TEST(IPAddress, toBinaryV4) {
724 for (auto& tc : provideToLong) {
725 SCOPED_TRACE(tc.first);
730 data.u32 = Endian::big(tc.second);
731 ByteRange bytes(data.u8, 4);
733 auto fromBin = IPAddressV4::fromBinary(bytes);
734 auto toBin = fromBin.toBinary();
735 EXPECT_EQ(bytes, toBin);
739 static const vector<pair<string, vector<uint8_t> > > provideBinary16Bytes = {
741 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
742 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
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}},
753 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
754 0xff, 0xff, 0x00, 0x00, 0xc0, 0xa8, 0x00, 0x01}},
757 TEST(IPAddress, fromBinaryV6) {
758 for (auto& tc : provideBinary16Bytes) {
759 SCOPED_TRACE(tc.first);
760 ByteRange bytes(&tc.second.front(), tc.second.size());
762 auto fromBin = IPAddressV6::fromBinary(bytes);
763 IPAddressV6 fromStr(tc.first);
764 EXPECT_EQ(fromStr, fromBin);
766 IPAddressV6 addr2("::0");
767 addr2 = IPAddressV6::fromBinary(bytes);
768 EXPECT_EQ(fromStr, addr2);
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);
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);
785 TEST(IPAddress, toBinaryV6) {
786 for (auto& tc : provideBinary16Bytes) {
787 SCOPED_TRACE(tc.first);
788 ByteRange bytes(&tc.second.front(), tc.second.size());
790 auto fromBin = IPAddressV6::fromBinary(bytes);
791 auto toBin = fromBin.toBinary();
792 EXPECT_EQ(bytes, toBin);
796 TEST_P(IPAddressFlagTest, IsLoopback) {
797 AddressFlags param = GetParam();
798 IPAddress addr(param.address);
800 EXPECT_EQ(param.version, addr.version());
801 EXPECT_EQ(param.isLoopback(), addr.isLoopback());
804 TEST_P(IPAddressFlagTest, IsPrivate) {
805 AddressFlags param = GetParam();
806 IPAddress addr(param.address);
808 EXPECT_EQ(param.version, addr.version());
809 EXPECT_EQ(param.isPrivate(), addr.isPrivate()) << addr;
812 TEST_P(IPAddressFlagTest, IsNonroutable) {
813 AddressFlags param = GetParam();
814 IPAddress addr(param.address);
816 EXPECT_EQ(param.version, addr.version());
817 EXPECT_EQ(param.isNonroutable(), addr.isNonroutable()) << addr;
820 TEST_P(IPAddressFlagTest, IsZero) {
821 AddressFlags param = GetParam();
822 IPAddress addr(param.address);
824 EXPECT_EQ(param.version, addr.version());
825 EXPECT_EQ(param.isZero(), addr.isZero()) << addr;
828 TEST_P(IPAddressFlagTest, IsLinkLocal) {
829 AddressFlags param = GetParam();
830 IPAddress addr(param.address);
831 EXPECT_EQ(param.isLinkLocal(), addr.isLinkLocal()) << addr;
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);
838 addr = IPAddressV6(IPAddressV6::LINK_LOCAL, MacAddress("02:00:00:12:34:56"));
839 EXPECT_EQ(IPAddressV6("fe80::ff:fe12:3456"), addr);
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());
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());
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());
860 TEST_P(IPAddressByteAccessorTest, CheckBytes) {
861 auto addrData = GetParam();
862 IPAddress ip(addrData.address);
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));
870 for (auto byritr = addrData.bytes.rbegin(); i < ip.byteCount(); ++i,
872 EXPECT_EQ(*byritr, ip.getNthLSByte(i));
873 EXPECT_EQ(*byritr, ip.isV4() ?
874 ip.asV4().getNthLSByte(i) : ip.asV6().getNthLSByte(i));
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));
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);
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);
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);
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);
950 TEST(IPAddress, StringFormat) {
952 for (int i = 0; i < 8; ++i) {
953 auto t = htons(0x0123 + ((i % 4) * 0x4444));
960 EXPECT_EQ("0123:4567:89ab:cdef:0123:4567:89ab:cdef",
961 detail::fastIpv6ToString(a6));
964 a4.s_addr = htonl(0x01020304);
965 EXPECT_EQ("1.2.3.4", detail::fastIpv4ToString(a4));
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());
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());
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},
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);
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);
1009 prefix = IPAddress::longestCommonPrefix({ip11, 8}, {ip12, 8});
1010 prefix4 = IPAddressV4::longestCommonPrefix({ip11.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);
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},
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);
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);
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);
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},
1053 std::invalid_argument);
1054 EXPECT_THROW(IPAddressV4::longestCommonPrefix(
1055 {ip10.asV4(), IPAddressV4::bitCount() + 1},
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);
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),
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),
1078 static const vector<string> invalidAddressProvider = {
1084 "127.0.0.1,127.0.0.1",
1088 static const vector<ByteVector> invalidBinaryProvider = {
1089 {0x31, 0x32, 0x37, 0x2e, 0x30, 0x30, 0x2e, 0x30, 0x2e, 0x31},
1095 {0x00, 0x00, 0x00, 0x00, 0x00},
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;
1110 static vector<AddressFlags> flagProvider = {
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),
1120 AddressFlags("2620:0:1cfe:face:b00c::3", 6, 0),
1123 AddressFlags("127.0.0.1", 4, IS_LOCAL | IS_PVT_NONROUTE),
1124 AddressFlags("::1", 6, IS_LOCAL | IS_PVT_NONROUTE),
1127 AddressFlags("169.254.0.1", 4, IS_LINK_LOCAL | IS_PVT_NONROUTE),
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),
1141 AddressFlags("fd01:1637:1c56:66af::", 6, IS_PVT_NONROUTE),
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),
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),
1167 AddressFlags("fe80::0205:73ff:fef9:46fc", 6, IS_LINK_LOCAL),
1168 AddressFlags("fe80::0012:34ff:fe56:7890", 6, IS_LINK_LOCAL),
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),
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),
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"},
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, "::")
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),
1247 INSTANTIATE_TEST_CASE_P(IPAddress,
1249 ::testing::ValuesIn(validAddressProvider));
1250 INSTANTIATE_TEST_CASE_P(IPAddress,
1252 ::testing::ValuesIn(flagProvider));
1253 INSTANTIATE_TEST_CASE_P(IPAddress,
1254 IPAddressMappedTest,
1255 ::testing::ValuesIn(mapProvider));
1256 INSTANTIATE_TEST_CASE_P(IPAddress,
1258 ::testing::ValuesIn(invalidAddressProvider));
1259 INSTANTIATE_TEST_CASE_P(IPAddress,
1260 IPAddressCtorBinaryTest,
1261 ::testing::ValuesIn(invalidBinaryProvider));
1262 INSTANTIATE_TEST_CASE_P(IPAddress,
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));
1275 TEST(IPAddressV6, fetchMask) {
1276 using ByteArray8 = std::array<uint8_t, 8>;
1278 struct X : private IPAddressV6 {
1279 using IPAddressV6::fetchMask;
1282 auto join = [](std::array<ByteArray8, 2> parts) {
1283 ByteArray16 _return;
1284 std::memcpy(_return.data(), parts.data(), _return.size());
1290 ::testing::ElementsAreArray(join({{
1291 ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
1292 ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
1297 ::testing::ElementsAreArray(join({{
1298 ByteArray8{{0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
1299 ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
1304 ::testing::ElementsAreArray(join({{
1305 ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe}},
1306 ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
1311 ::testing::ElementsAreArray(join({{
1312 ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
1313 ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
1318 ::testing::ElementsAreArray(join({{
1319 ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
1320 ByteArray8{{0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
1325 ::testing::ElementsAreArray(join({{
1326 ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
1327 ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe}},
1332 ::testing::ElementsAreArray(join({{
1333 ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
1334 ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},