1 // Copyright (c) 2019 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "quiche/common/quiche_ip_address.h"
6
7 #include <cstdint>
8
9 #include "quiche/common/platform/api/quiche_test.h"
10 #include "quiche/common/quiche_ip_address_family.h"
11
12 namespace quiche {
13 namespace test {
14 namespace {
15
TEST(QuicheIpAddressTest,IPv4)16 TEST(QuicheIpAddressTest, IPv4) {
17 QuicheIpAddress ip_address;
18 EXPECT_FALSE(ip_address.IsInitialized());
19
20 EXPECT_TRUE(ip_address.FromString("127.0.52.223"));
21 EXPECT_TRUE(ip_address.IsInitialized());
22
23 EXPECT_EQ(IpAddressFamily::IP_V4, ip_address.address_family());
24 EXPECT_TRUE(ip_address.IsIPv4());
25 EXPECT_FALSE(ip_address.IsIPv6());
26
27 EXPECT_EQ("127.0.52.223", ip_address.ToString());
28 const in_addr v4_address = ip_address.GetIPv4();
29 const uint8_t* const v4_address_ptr =
30 reinterpret_cast<const uint8_t*>(&v4_address);
31 EXPECT_EQ(127u, *(v4_address_ptr + 0));
32 EXPECT_EQ(0u, *(v4_address_ptr + 1));
33 EXPECT_EQ(52u, *(v4_address_ptr + 2));
34 EXPECT_EQ(223u, *(v4_address_ptr + 3));
35 }
36
TEST(QuicheIpAddressTest,IPv6)37 TEST(QuicheIpAddressTest, IPv6) {
38 QuicheIpAddress ip_address;
39 EXPECT_FALSE(ip_address.IsInitialized());
40
41 EXPECT_TRUE(ip_address.FromString("fe80::1ff:fe23:4567"));
42 EXPECT_TRUE(ip_address.IsInitialized());
43
44 EXPECT_EQ(IpAddressFamily::IP_V6, ip_address.address_family());
45 EXPECT_FALSE(ip_address.IsIPv4());
46 EXPECT_TRUE(ip_address.IsIPv6());
47
48 EXPECT_EQ("fe80::1ff:fe23:4567", ip_address.ToString());
49 const in6_addr v6_address = ip_address.GetIPv6();
50 const uint16_t* const v6_address_ptr =
51 reinterpret_cast<const uint16_t*>(&v6_address);
52 EXPECT_EQ(0x80feu, *(v6_address_ptr + 0));
53 EXPECT_EQ(0x0000u, *(v6_address_ptr + 1));
54 EXPECT_EQ(0x0000u, *(v6_address_ptr + 2));
55 EXPECT_EQ(0x0000u, *(v6_address_ptr + 3));
56 EXPECT_EQ(0x0000u, *(v6_address_ptr + 4));
57 EXPECT_EQ(0xff01u, *(v6_address_ptr + 5));
58 EXPECT_EQ(0x23feu, *(v6_address_ptr + 6));
59 EXPECT_EQ(0x6745u, *(v6_address_ptr + 7));
60
61 EXPECT_EQ(ip_address, ip_address.Normalized());
62 EXPECT_EQ(ip_address, ip_address.DualStacked());
63 }
64
TEST(QuicheIpAddressTest,FromPackedString)65 TEST(QuicheIpAddressTest, FromPackedString) {
66 QuicheIpAddress loopback4, loopback6;
67 const char loopback4_packed[] = "\x7f\0\0\x01";
68 const char loopback6_packed[] = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01";
69 EXPECT_TRUE(loopback4.FromPackedString(loopback4_packed, 4));
70 EXPECT_TRUE(loopback6.FromPackedString(loopback6_packed, 16));
71 EXPECT_EQ(loopback4, QuicheIpAddress::Loopback4());
72 EXPECT_EQ(loopback6, QuicheIpAddress::Loopback6());
73 }
74
TEST(QuicheIpAddressTest,MappedAddress)75 TEST(QuicheIpAddressTest, MappedAddress) {
76 QuicheIpAddress ipv4_address;
77 QuicheIpAddress mapped_address;
78
79 EXPECT_TRUE(ipv4_address.FromString("127.0.0.1"));
80 EXPECT_TRUE(mapped_address.FromString("::ffff:7f00:1"));
81
82 EXPECT_EQ(mapped_address, ipv4_address.DualStacked());
83 EXPECT_EQ(ipv4_address, mapped_address.Normalized());
84 }
85
TEST(QuicheIpAddressTest,Subnets)86 TEST(QuicheIpAddressTest, Subnets) {
87 struct {
88 const char* address1;
89 const char* address2;
90 int subnet_size;
91 bool same_subnet;
92 } test_cases[] = {
93 {"127.0.0.1", "127.0.0.2", 24, true},
94 {"8.8.8.8", "127.0.0.1", 24, false},
95 {"8.8.8.8", "127.0.0.1", 16, false},
96 {"8.8.8.8", "127.0.0.1", 8, false},
97 {"8.8.8.8", "127.0.0.1", 2, false},
98 {"8.8.8.8", "127.0.0.1", 1, true},
99
100 {"127.0.0.1", "127.0.0.128", 24, true},
101 {"127.0.0.1", "127.0.0.128", 25, false},
102 {"127.0.0.1", "127.0.0.127", 25, true},
103
104 {"127.0.0.1", "127.0.0.0", 30, true},
105 {"127.0.0.1", "127.0.0.1", 30, true},
106 {"127.0.0.1", "127.0.0.2", 30, true},
107 {"127.0.0.1", "127.0.0.3", 30, true},
108 {"127.0.0.1", "127.0.0.4", 30, false},
109
110 {"127.0.0.1", "127.0.0.2", 31, false},
111 {"127.0.0.1", "127.0.0.0", 31, true},
112
113 {"::1", "fe80::1", 8, false},
114 {"::1", "fe80::1", 1, false},
115 {"::1", "fe80::1", 0, true},
116 {"fe80::1", "fe80::2", 126, true},
117 {"fe80::1", "fe80::2", 127, false},
118 };
119
120 for (const auto& test_case : test_cases) {
121 QuicheIpAddress address1, address2;
122 ASSERT_TRUE(address1.FromString(test_case.address1));
123 ASSERT_TRUE(address2.FromString(test_case.address2));
124 EXPECT_EQ(test_case.same_subnet,
125 address1.InSameSubnet(address2, test_case.subnet_size))
126 << "Addresses: " << test_case.address1 << ", " << test_case.address2
127 << "; subnet: /" << test_case.subnet_size;
128 }
129 }
130
TEST(QuicheIpAddress,LoopbackAddresses)131 TEST(QuicheIpAddress, LoopbackAddresses) {
132 QuicheIpAddress loopback4;
133 QuicheIpAddress loopback6;
134 ASSERT_TRUE(loopback4.FromString("127.0.0.1"));
135 ASSERT_TRUE(loopback6.FromString("::1"));
136 EXPECT_EQ(loopback4, QuicheIpAddress::Loopback4());
137 EXPECT_EQ(loopback6, QuicheIpAddress::Loopback6());
138 }
139
140 } // namespace
141 } // namespace test
142 } // namespace quiche
143