1 //
2 // Copyright 2015 gRPC authors.
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16
17 #include <grpc/support/port_platform.h>
18
19 #include "src/core/lib/address_utils/sockaddr_utils.h"
20
21 #include <errno.h>
22 #include <string.h>
23
24 #include <gtest/gtest.h>
25
26 #include <grpc/support/alloc.h>
27 #include <grpc/support/log.h>
28
29 #include "src/core/lib/iomgr/sockaddr.h"
30 #include "src/core/lib/iomgr/socket_utils.h"
31 #include "test/core/util/test_config.h"
32
33 namespace {
34
MakeAddr4(const uint8_t * data,size_t data_len)35 grpc_resolved_address MakeAddr4(const uint8_t* data, size_t data_len) {
36 grpc_resolved_address resolved_addr4;
37 grpc_sockaddr_in* addr4 =
38 reinterpret_cast<grpc_sockaddr_in*>(resolved_addr4.addr);
39 memset(&resolved_addr4, 0, sizeof(resolved_addr4));
40 addr4->sin_family = GRPC_AF_INET;
41 GPR_ASSERT(data_len == sizeof(addr4->sin_addr.s_addr));
42 memcpy(&addr4->sin_addr.s_addr, data, data_len);
43 addr4->sin_port = grpc_htons(12345);
44 resolved_addr4.len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in));
45 return resolved_addr4;
46 }
47
MakeAddr6(const uint8_t * data,size_t data_len)48 grpc_resolved_address MakeAddr6(const uint8_t* data, size_t data_len) {
49 grpc_resolved_address resolved_addr6;
50 grpc_sockaddr_in6* addr6 =
51 reinterpret_cast<grpc_sockaddr_in6*>(resolved_addr6.addr);
52 memset(&resolved_addr6, 0, sizeof(resolved_addr6));
53 addr6->sin6_family = GRPC_AF_INET6;
54 GPR_ASSERT(data_len == sizeof(addr6->sin6_addr.s6_addr));
55 memcpy(&addr6->sin6_addr.s6_addr, data, data_len);
56 addr6->sin6_port = grpc_htons(12345);
57 resolved_addr6.len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in6));
58 return resolved_addr6;
59 }
60
SetIPv6ScopeId(grpc_resolved_address * addr,uint32_t scope_id)61 void SetIPv6ScopeId(grpc_resolved_address* addr, uint32_t scope_id) {
62 grpc_sockaddr_in6* addr6 = reinterpret_cast<grpc_sockaddr_in6*>(addr->addr);
63 ASSERT_EQ(addr6->sin6_family, GRPC_AF_INET6);
64 addr6->sin6_scope_id = scope_id;
65 }
66
67 const uint8_t kMapped[] = {0, 0, 0, 0, 0, 0, 0, 0,
68 0, 0, 0xff, 0xff, 192, 0, 2, 1};
69
70 const uint8_t kNotQuiteMapped[] = {0, 0, 0, 0, 0, 0, 0, 0,
71 0, 0, 0xff, 0xfe, 192, 0, 2, 99};
72 const uint8_t kIPv4[] = {192, 0, 2, 1};
73
74 const uint8_t kIPv6[] = {0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0,
75 0, 0, 0, 0, 0, 0, 0, 1};
76
TEST(SockAddrUtilsTest,SockAddrIsV4Mapped)77 TEST(SockAddrUtilsTest, SockAddrIsV4Mapped) {
78 // v4mapped input should succeed.
79 grpc_resolved_address input6 = MakeAddr6(kMapped, sizeof(kMapped));
80 ASSERT_TRUE(grpc_sockaddr_is_v4mapped(&input6, nullptr));
81 grpc_resolved_address output4;
82 ASSERT_TRUE(grpc_sockaddr_is_v4mapped(&input6, &output4));
83 grpc_resolved_address expect4 = MakeAddr4(kIPv4, sizeof(kIPv4));
84 ASSERT_EQ(memcmp(&expect4, &output4, sizeof(expect4)), 0);
85
86 // Non-v4mapped input should fail.
87 input6 = MakeAddr6(kNotQuiteMapped, sizeof(kNotQuiteMapped));
88 ASSERT_FALSE(grpc_sockaddr_is_v4mapped(&input6, nullptr));
89 ASSERT_FALSE(grpc_sockaddr_is_v4mapped(&input6, &output4));
90 // Output is unchanged.
91 ASSERT_EQ(memcmp(&expect4, &output4, sizeof(expect4)), 0);
92
93 // Plain IPv4 input should also fail.
94 grpc_resolved_address input4 = MakeAddr4(kIPv4, sizeof(kIPv4));
95 ASSERT_FALSE(grpc_sockaddr_is_v4mapped(&input4, nullptr));
96 }
97
TEST(SockAddrUtilsTest,SockAddrToV4Mapped)98 TEST(SockAddrUtilsTest, SockAddrToV4Mapped) {
99 // IPv4 input should succeed.
100 grpc_resolved_address input4 = MakeAddr4(kIPv4, sizeof(kIPv4));
101 grpc_resolved_address output6;
102 ASSERT_TRUE(grpc_sockaddr_to_v4mapped(&input4, &output6));
103 grpc_resolved_address expect6 = MakeAddr6(kMapped, sizeof(kMapped));
104 ASSERT_EQ(memcmp(&expect6, &output6, sizeof(output6)), 0);
105
106 // IPv6 input should fail.
107 grpc_resolved_address input6 = MakeAddr6(kIPv6, sizeof(kIPv6));
108 ASSERT_TRUE(!grpc_sockaddr_to_v4mapped(&input6, &output6));
109 // Output is unchanged.
110 ASSERT_EQ(memcmp(&expect6, &output6, sizeof(output6)), 0);
111
112 // Already-v4mapped input should also fail.
113 input6 = MakeAddr6(kMapped, sizeof(kMapped));
114 ASSERT_TRUE(!grpc_sockaddr_to_v4mapped(&input6, &output6));
115 }
116
TEST(SockAddrUtilsTest,SockAddrIsWildCard)117 TEST(SockAddrUtilsTest, SockAddrIsWildCard) {
118 // Generate wildcards.
119 grpc_resolved_address wild4;
120 grpc_resolved_address wild6;
121 grpc_sockaddr_make_wildcards(555, &wild4, &wild6);
122 grpc_resolved_address wild_mapped;
123 ASSERT_TRUE(grpc_sockaddr_to_v4mapped(&wild4, &wild_mapped));
124
125 // Test 0.0.0.0:555
126 int port = -1;
127 ASSERT_TRUE(grpc_sockaddr_is_wildcard(&wild4, &port));
128 ASSERT_TRUE(port == 555);
129 grpc_sockaddr_in* wild4_addr =
130 reinterpret_cast<grpc_sockaddr_in*>(&wild4.addr);
131 memset(&wild4_addr->sin_addr.s_addr, 0xbd, 1);
132 ASSERT_FALSE(grpc_sockaddr_is_wildcard(&wild4, &port));
133
134 // Test [::]:555
135 port = -1;
136 ASSERT_TRUE(grpc_sockaddr_is_wildcard(&wild6, &port));
137 ASSERT_EQ(port, 555);
138 grpc_sockaddr_in6* wild6_addr =
139 reinterpret_cast<grpc_sockaddr_in6*>(&wild6.addr);
140 memset(&wild6_addr->sin6_addr.s6_addr, 0xbd, 1);
141 ASSERT_FALSE(grpc_sockaddr_is_wildcard(&wild6, &port));
142
143 // Test [::ffff:0.0.0.0]:555
144 port = -1;
145 ASSERT_TRUE(grpc_sockaddr_is_wildcard(&wild_mapped, &port));
146 ASSERT_EQ(port, 555);
147 grpc_sockaddr_in6* wild_mapped_addr =
148 reinterpret_cast<grpc_sockaddr_in6*>(&wild_mapped.addr);
149 memset(&wild_mapped_addr->sin6_addr.s6_addr, 0xbd, 1);
150 ASSERT_FALSE(grpc_sockaddr_is_wildcard(&wild_mapped, &port));
151
152 // Test AF_UNSPEC.
153 port = -1;
154 grpc_resolved_address phony;
155 memset(&phony, 0, sizeof(phony));
156 ASSERT_FALSE(grpc_sockaddr_is_wildcard(&phony, &port));
157 ASSERT_EQ(port, -1);
158 }
159
TEST(SockAddrUtilsTest,SockAddrToString)160 TEST(SockAddrUtilsTest, SockAddrToString) {
161 errno = 0x7EADBEEF;
162
163 grpc_resolved_address input4 = MakeAddr4(kIPv4, sizeof(kIPv4));
164 EXPECT_EQ(grpc_sockaddr_to_string(&input4, false), "192.0.2.1:12345");
165 EXPECT_EQ(grpc_sockaddr_to_string(&input4, true), "192.0.2.1:12345");
166 EXPECT_EQ(grpc_sockaddr_to_uri(&input4), "ipv4:192.0.2.1:12345");
167
168 grpc_resolved_address input6 = MakeAddr6(kIPv6, sizeof(kIPv6));
169 EXPECT_EQ(grpc_sockaddr_to_string(&input6, false), "[2001:db8::1]:12345");
170 EXPECT_EQ(grpc_sockaddr_to_string(&input6, true), "[2001:db8::1]:12345");
171 EXPECT_EQ(grpc_sockaddr_to_uri(&input6), "ipv6:[2001:db8::1]:12345");
172
173 SetIPv6ScopeId(&input6, 2);
174 EXPECT_EQ(grpc_sockaddr_to_string(&input6, false), "[2001:db8::1%252]:12345");
175 EXPECT_EQ(grpc_sockaddr_to_string(&input6, true), "[2001:db8::1%252]:12345");
176 EXPECT_EQ(grpc_sockaddr_to_uri(&input6), "ipv6:[2001:db8::1%252]:12345");
177
178 SetIPv6ScopeId(&input6, 101);
179 EXPECT_EQ(grpc_sockaddr_to_string(&input6, false),
180 "[2001:db8::1%25101]:12345");
181 EXPECT_EQ(grpc_sockaddr_to_string(&input6, true),
182 "[2001:db8::1%25101]:12345");
183 EXPECT_EQ(grpc_sockaddr_to_uri(&input6), "ipv6:[2001:db8::1%25101]:12345");
184
185 input6 = MakeAddr6(kMapped, sizeof(kMapped));
186 EXPECT_EQ(grpc_sockaddr_to_string(&input6, false),
187 "[::ffff:192.0.2.1]:12345");
188 EXPECT_EQ(grpc_sockaddr_to_string(&input6, true), "192.0.2.1:12345");
189 EXPECT_EQ(grpc_sockaddr_to_uri(&input6), "ipv4:192.0.2.1:12345");
190
191 input6 = MakeAddr6(kNotQuiteMapped, sizeof(kNotQuiteMapped));
192 EXPECT_EQ(grpc_sockaddr_to_string(&input6, false), "[::fffe:c000:263]:12345");
193 EXPECT_EQ(grpc_sockaddr_to_string(&input6, true), "[::fffe:c000:263]:12345");
194 EXPECT_EQ(grpc_sockaddr_to_uri(&input6), "ipv6:[::fffe:c000:263]:12345");
195
196 grpc_resolved_address phony;
197 memset(&phony, 0, sizeof(phony));
198 grpc_sockaddr* phony_addr = reinterpret_cast<grpc_sockaddr*>(phony.addr);
199 phony_addr->sa_family = 123;
200 EXPECT_EQ(grpc_sockaddr_to_string(&phony, false), "(sockaddr family=123)");
201 EXPECT_EQ(grpc_sockaddr_to_string(&phony, true), "(sockaddr family=123)");
202 EXPECT_TRUE(grpc_sockaddr_to_uri(&phony).empty());
203 }
204
TEST(SockAddrUtilsTest,SockAddrSetGetPort)205 TEST(SockAddrUtilsTest, SockAddrSetGetPort) {
206 grpc_resolved_address input4 = MakeAddr4(kIPv4, sizeof(kIPv4));
207 ASSERT_EQ(grpc_sockaddr_get_port(&input4), 12345);
208 ASSERT_TRUE(grpc_sockaddr_set_port(&input4, 54321));
209 ASSERT_EQ(grpc_sockaddr_get_port(&input4), 54321);
210
211 grpc_resolved_address input6 = MakeAddr6(kIPv6, sizeof(kIPv6));
212 ASSERT_EQ(grpc_sockaddr_get_port(&input6), 12345);
213 ASSERT_TRUE(grpc_sockaddr_set_port(&input6, 54321));
214 ASSERT_EQ(grpc_sockaddr_get_port(&input6), 54321);
215
216 grpc_resolved_address phony;
217 memset(&phony, 0, sizeof(phony));
218 grpc_sockaddr* phony_addr = reinterpret_cast<grpc_sockaddr*>(phony.addr);
219 phony_addr->sa_family = 123;
220 ASSERT_EQ(grpc_sockaddr_get_port(&phony), false);
221 ASSERT_EQ(grpc_sockaddr_set_port(&phony, 1234), false);
222 }
223
VerifySocketAddressMatch(const std::string & ip_address,const std::string & subnet,uint32_t mask_bits,bool success)224 void VerifySocketAddressMatch(const std::string& ip_address,
225 const std::string& subnet, uint32_t mask_bits,
226 bool success) {
227 grpc_resolved_address addr;
228 ASSERT_EQ(grpc_string_to_sockaddr(&addr, ip_address.c_str(), false),
229 GRPC_ERROR_NONE);
230 // Setting the port has no effect on the match.
231 grpc_sockaddr_set_port(&addr, 12345);
232 grpc_resolved_address subnet_addr;
233 ASSERT_EQ(grpc_string_to_sockaddr(&subnet_addr, subnet.c_str(), false),
234 GRPC_ERROR_NONE);
235 grpc_sockaddr_mask_bits(&subnet_addr, mask_bits);
236 EXPECT_EQ(grpc_sockaddr_match_subnet(&addr, &subnet_addr, mask_bits), success)
237 << "IP=" << ip_address << " Subnet=" << subnet << " Mask=" << mask_bits;
238 }
239
VerifySocketAddressMatchSuccess(const std::string & ip_address,const std::string & subnet,uint32_t mask_bits)240 void VerifySocketAddressMatchSuccess(const std::string& ip_address,
241 const std::string& subnet,
242 uint32_t mask_bits) {
243 // If the IP address matches the subnet for a particular length, then it would
244 // match for all lengths [0, mask_bits]
245 for (uint32_t i = 0; i <= mask_bits; i++) {
246 VerifySocketAddressMatch(ip_address, subnet, i, true);
247 }
248 }
249
VerifySocketAddressMatchFailure(const std::string & ip_address,const std::string & subnet,uint32_t mask_bits)250 void VerifySocketAddressMatchFailure(const std::string& ip_address,
251 const std::string& subnet,
252 uint32_t mask_bits) {
253 // If the IP address fails matching the subnet for a particular length, then
254 // it would also fail for all lengths [mask_bits, 128]
255 for (auto i = mask_bits; i <= 128; i++) {
256 VerifySocketAddressMatch(ip_address, subnet, i, false);
257 }
258 }
259
TEST(SockAddrUtilsTest,SockAddrMatchSubnet)260 TEST(SockAddrUtilsTest, SockAddrMatchSubnet) {
261 // IPv4 Tests
262 VerifySocketAddressMatchSuccess("192.168.1.1", "192.168.1.1", 32);
263 VerifySocketAddressMatchSuccess("255.255.255.255", "255.255.255.255", 32);
264 VerifySocketAddressMatchFailure("192.168.1.1", "192.168.1.2", 31);
265 VerifySocketAddressMatchFailure("192.168.1.1", "191.0.0.0", 8);
266 VerifySocketAddressMatchFailure("192.168.1.1", "0.0.0.0", 1);
267 // IPv6 Tests
268 VerifySocketAddressMatchSuccess("2001:db8::", "2001::", 16);
269 VerifySocketAddressMatchSuccess("2001:db8:cfe:134:3ab:3456:78:9",
270 "2001:db8:cfe:134:3ab:3456:78:9", 128);
271 VerifySocketAddressMatchSuccess("FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF",
272 "FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF",
273 128);
274 VerifySocketAddressMatchFailure("2001:db8:cfe:134:3ab:3456:78:9",
275 "3001:2:3:4:5:6:7:8", 4);
276 VerifySocketAddressMatchFailure("FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF",
277 "::", 1);
278 }
279
280 } // namespace
281
main(int argc,char ** argv)282 int main(int argc, char** argv) {
283 grpc::testing::TestEnvironment env(argc, argv);
284 ::testing::InitGoogleTest(&argc, argv);
285 int retval = RUN_ALL_TESTS();
286 return retval;
287 }
288