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 "src/core/lib/address_utils/sockaddr_utils.h"
18
19 #include <errno.h>
20 #include <stdint.h>
21 #include <string.h>
22
23 #include "absl/status/status.h"
24 #include "absl/status/statusor.h"
25 #include "absl/strings/str_cat.h"
26 #include "gtest/gtest.h"
27
28 #include <grpc/support/port_platform.h>
29
30 #include "src/core/lib/iomgr/port.h"
31 #include "src/core/lib/iomgr/resolved_address.h"
32 #ifdef GRPC_HAVE_UNIX_SOCKET
33 #ifdef GPR_WINDOWS
34 // clang-format off
35 #include <ws2def.h>
36 #include <afunix.h>
37 // clang-format on
38 #else
39 #include <sys/un.h>
40 #endif // GPR_WINDOWS
41 #endif // GRPC_HAVE_UNIX_SOCKET
42
43 #include <string>
44
45 #include <grpc/support/log.h>
46
47 #include "src/core/lib/address_utils/parse_address.h"
48 #include "src/core/lib/iomgr/sockaddr.h"
49 #include "src/core/lib/iomgr/socket_utils.h"
50 #include "test/core/util/test_config.h"
51
52 namespace {
53
MakeAddr4(const uint8_t * data,size_t data_len)54 grpc_resolved_address MakeAddr4(const uint8_t* data, size_t data_len) {
55 grpc_resolved_address resolved_addr4;
56 grpc_sockaddr_in* addr4 =
57 reinterpret_cast<grpc_sockaddr_in*>(resolved_addr4.addr);
58 memset(&resolved_addr4, 0, sizeof(resolved_addr4));
59 addr4->sin_family = GRPC_AF_INET;
60 GPR_ASSERT(data_len == sizeof(addr4->sin_addr.s_addr));
61 memcpy(&addr4->sin_addr.s_addr, data, data_len);
62 addr4->sin_port = grpc_htons(12345);
63 resolved_addr4.len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in));
64 return resolved_addr4;
65 }
66
MakeAddr6(const uint8_t * data,size_t data_len)67 grpc_resolved_address MakeAddr6(const uint8_t* data, size_t data_len) {
68 grpc_resolved_address resolved_addr6;
69 grpc_sockaddr_in6* addr6 =
70 reinterpret_cast<grpc_sockaddr_in6*>(resolved_addr6.addr);
71 memset(&resolved_addr6, 0, sizeof(resolved_addr6));
72 addr6->sin6_family = GRPC_AF_INET6;
73 GPR_ASSERT(data_len == sizeof(addr6->sin6_addr.s6_addr));
74 memcpy(&addr6->sin6_addr.s6_addr, data, data_len);
75 addr6->sin6_port = grpc_htons(12345);
76 resolved_addr6.len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in6));
77 return resolved_addr6;
78 }
79
SetIPv6ScopeId(grpc_resolved_address * addr,uint32_t scope_id)80 void SetIPv6ScopeId(grpc_resolved_address* addr, uint32_t scope_id) {
81 grpc_sockaddr_in6* addr6 = reinterpret_cast<grpc_sockaddr_in6*>(addr->addr);
82 ASSERT_EQ(addr6->sin6_family, GRPC_AF_INET6);
83 addr6->sin6_scope_id = scope_id;
84 }
85
86 const uint8_t kMapped[] = {0, 0, 0, 0, 0, 0, 0, 0,
87 0, 0, 0xff, 0xff, 192, 0, 2, 1};
88
89 const uint8_t kNotQuiteMapped[] = {0, 0, 0, 0, 0, 0, 0, 0,
90 0, 0, 0xff, 0xfe, 192, 0, 2, 99};
91 const uint8_t kIPv4[] = {192, 0, 2, 1};
92
93 const uint8_t kIPv6[] = {0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0,
94 0, 0, 0, 0, 0, 0, 0, 1};
95
TEST(SockAddrUtilsTest,SockAddrIsV4Mapped)96 TEST(SockAddrUtilsTest, SockAddrIsV4Mapped) {
97 // v4mapped input should succeed.
98 grpc_resolved_address input6 = MakeAddr6(kMapped, sizeof(kMapped));
99 ASSERT_TRUE(grpc_sockaddr_is_v4mapped(&input6, nullptr));
100 grpc_resolved_address output4;
101 ASSERT_TRUE(grpc_sockaddr_is_v4mapped(&input6, &output4));
102 grpc_resolved_address expect4 = MakeAddr4(kIPv4, sizeof(kIPv4));
103 ASSERT_EQ(memcmp(&expect4, &output4, sizeof(expect4)), 0);
104
105 // Non-v4mapped input should fail.
106 input6 = MakeAddr6(kNotQuiteMapped, sizeof(kNotQuiteMapped));
107 ASSERT_FALSE(grpc_sockaddr_is_v4mapped(&input6, nullptr));
108 ASSERT_FALSE(grpc_sockaddr_is_v4mapped(&input6, &output4));
109 // Output is unchanged.
110 ASSERT_EQ(memcmp(&expect4, &output4, sizeof(expect4)), 0);
111
112 // Plain IPv4 input should also fail.
113 grpc_resolved_address input4 = MakeAddr4(kIPv4, sizeof(kIPv4));
114 ASSERT_FALSE(grpc_sockaddr_is_v4mapped(&input4, nullptr));
115 }
116
TEST(SockAddrUtilsTest,SockAddrToV4Mapped)117 TEST(SockAddrUtilsTest, SockAddrToV4Mapped) {
118 // IPv4 input should succeed.
119 grpc_resolved_address input4 = MakeAddr4(kIPv4, sizeof(kIPv4));
120 grpc_resolved_address output6;
121 ASSERT_TRUE(grpc_sockaddr_to_v4mapped(&input4, &output6));
122 grpc_resolved_address expect6 = MakeAddr6(kMapped, sizeof(kMapped));
123 ASSERT_EQ(memcmp(&expect6, &output6, sizeof(output6)), 0);
124
125 // IPv6 input should fail.
126 grpc_resolved_address input6 = MakeAddr6(kIPv6, sizeof(kIPv6));
127 ASSERT_TRUE(!grpc_sockaddr_to_v4mapped(&input6, &output6));
128 // Output is unchanged.
129 ASSERT_EQ(memcmp(&expect6, &output6, sizeof(output6)), 0);
130
131 // Already-v4mapped input should also fail.
132 input6 = MakeAddr6(kMapped, sizeof(kMapped));
133 ASSERT_TRUE(!grpc_sockaddr_to_v4mapped(&input6, &output6));
134 }
135
TEST(SockAddrUtilsTest,SockAddrIsWildCard)136 TEST(SockAddrUtilsTest, SockAddrIsWildCard) {
137 // Generate wildcards.
138 grpc_resolved_address wild4;
139 grpc_resolved_address wild6;
140 grpc_sockaddr_make_wildcards(555, &wild4, &wild6);
141 grpc_resolved_address wild_mapped;
142 ASSERT_TRUE(grpc_sockaddr_to_v4mapped(&wild4, &wild_mapped));
143
144 // Test 0.0.0.0:555
145 int port = -1;
146 ASSERT_TRUE(grpc_sockaddr_is_wildcard(&wild4, &port));
147 ASSERT_TRUE(port == 555);
148 grpc_sockaddr_in* wild4_addr =
149 reinterpret_cast<grpc_sockaddr_in*>(&wild4.addr);
150 memset(&wild4_addr->sin_addr.s_addr, 0xbd, 1);
151 ASSERT_FALSE(grpc_sockaddr_is_wildcard(&wild4, &port));
152
153 // Test [::]:555
154 port = -1;
155 ASSERT_TRUE(grpc_sockaddr_is_wildcard(&wild6, &port));
156 ASSERT_EQ(port, 555);
157 grpc_sockaddr_in6* wild6_addr =
158 reinterpret_cast<grpc_sockaddr_in6*>(&wild6.addr);
159 memset(&wild6_addr->sin6_addr.s6_addr, 0xbd, 1);
160 ASSERT_FALSE(grpc_sockaddr_is_wildcard(&wild6, &port));
161
162 // Test [::ffff:0.0.0.0]:555
163 port = -1;
164 ASSERT_TRUE(grpc_sockaddr_is_wildcard(&wild_mapped, &port));
165 ASSERT_EQ(port, 555);
166 grpc_sockaddr_in6* wild_mapped_addr =
167 reinterpret_cast<grpc_sockaddr_in6*>(&wild_mapped.addr);
168 memset(&wild_mapped_addr->sin6_addr.s6_addr, 0xbd, 1);
169 ASSERT_FALSE(grpc_sockaddr_is_wildcard(&wild_mapped, &port));
170
171 // Test AF_UNSPEC.
172 port = -1;
173 grpc_resolved_address phony;
174 memset(&phony, 0, sizeof(phony));
175 ASSERT_FALSE(grpc_sockaddr_is_wildcard(&phony, &port));
176 ASSERT_EQ(port, -1);
177 }
178
TEST(SockAddrUtilsTest,SockAddrToString)179 TEST(SockAddrUtilsTest, SockAddrToString) {
180 errno = 0x7EADBEEF;
181
182 grpc_resolved_address input4 = MakeAddr4(kIPv4, sizeof(kIPv4));
183 EXPECT_EQ(grpc_sockaddr_to_string(&input4, false).value(), "192.0.2.1:12345");
184 EXPECT_EQ(grpc_sockaddr_to_string(&input4, true).value(), "192.0.2.1:12345");
185 EXPECT_EQ(grpc_sockaddr_to_uri(&input4).value(), "ipv4:192.0.2.1:12345");
186
187 grpc_resolved_address input6 = MakeAddr6(kIPv6, sizeof(kIPv6));
188 EXPECT_EQ(grpc_sockaddr_to_string(&input6, false).value(),
189 "[2001:db8::1]:12345");
190 EXPECT_EQ(grpc_sockaddr_to_string(&input6, true).value(),
191 "[2001:db8::1]:12345");
192 EXPECT_EQ(grpc_sockaddr_to_uri(&input6).value(),
193 "ipv6:%5B2001:db8::1%5D:12345");
194
195 SetIPv6ScopeId(&input6, 2);
196 EXPECT_EQ(grpc_sockaddr_to_string(&input6, false).value(),
197 "[2001:db8::1%2]:12345");
198 EXPECT_EQ(grpc_sockaddr_to_string(&input6, true).value(),
199 "[2001:db8::1%2]:12345");
200 EXPECT_EQ(grpc_sockaddr_to_uri(&input6).value(),
201 "ipv6:%5B2001:db8::1%252%5D:12345");
202
203 SetIPv6ScopeId(&input6, 101);
204 EXPECT_EQ(grpc_sockaddr_to_string(&input6, false).value(),
205 "[2001:db8::1%101]:12345");
206 EXPECT_EQ(grpc_sockaddr_to_string(&input6, true).value(),
207 "[2001:db8::1%101]:12345");
208 EXPECT_EQ(grpc_sockaddr_to_uri(&input6).value(),
209 "ipv6:%5B2001:db8::1%25101%5D:12345");
210
211 grpc_resolved_address input6x = MakeAddr6(kMapped, sizeof(kMapped));
212 EXPECT_EQ(grpc_sockaddr_to_string(&input6x, false).value(),
213 "[::ffff:192.0.2.1]:12345");
214 EXPECT_EQ(grpc_sockaddr_to_string(&input6x, true).value(), "192.0.2.1:12345");
215 EXPECT_EQ(grpc_sockaddr_to_uri(&input6x).value(), "ipv4:192.0.2.1:12345");
216
217 grpc_resolved_address input6y =
218 MakeAddr6(kNotQuiteMapped, sizeof(kNotQuiteMapped));
219 EXPECT_EQ(grpc_sockaddr_to_string(&input6y, false).value(),
220 "[::fffe:c000:263]:12345");
221 EXPECT_EQ(grpc_sockaddr_to_string(&input6y, true).value(),
222 "[::fffe:c000:263]:12345");
223 EXPECT_EQ(grpc_sockaddr_to_uri(&input6y).value(),
224 "ipv6:%5B::fffe:c000:263%5D:12345");
225
226 grpc_resolved_address phony;
227 memset(&phony, 0, sizeof(phony));
228 grpc_sockaddr* phony_addr = reinterpret_cast<grpc_sockaddr*>(phony.addr);
229 phony_addr->sa_family = 123;
230 EXPECT_EQ(grpc_sockaddr_to_string(&phony, false).status(),
231 absl::InvalidArgumentError("Unknown sockaddr family: 123"));
232 EXPECT_EQ(grpc_sockaddr_to_string(&phony, true).status(),
233 absl::InvalidArgumentError("Unknown sockaddr family: 123"));
234 EXPECT_EQ(grpc_sockaddr_to_uri(&phony).status(),
235 absl::InvalidArgumentError("Empty address"));
236
237 #ifdef GRPC_HAVE_UNIX_SOCKET
238 grpc_resolved_address inputun;
239 struct sockaddr_un* sock_un = reinterpret_cast<struct sockaddr_un*>(&inputun);
240 ASSERT_EQ(grpc_core::UnixSockaddrPopulate("/some/unix/path", &inputun),
241 absl::OkStatus());
242 EXPECT_EQ(grpc_sockaddr_to_string(&inputun, true).value(), "/some/unix/path");
243
244 std::string max_filepath(sizeof(sock_un->sun_path) - 1, 'x');
245 ASSERT_EQ(grpc_core::UnixSockaddrPopulate(max_filepath, &inputun),
246 absl::OkStatus());
247 EXPECT_EQ(grpc_sockaddr_to_string(&inputun, true).value(), max_filepath);
248
249 ASSERT_EQ(grpc_core::UnixSockaddrPopulate(max_filepath, &inputun),
250 absl::OkStatus());
251 sock_un->sun_path[sizeof(sockaddr_un::sun_path) - 1] = 'x';
252 EXPECT_EQ(grpc_sockaddr_to_string(&inputun, true).status(),
253 absl::InvalidArgumentError("UDS path is not null-terminated"));
254
255 ASSERT_EQ(grpc_core::UnixAbstractSockaddrPopulate("some_unix_path", &inputun),
256 absl::OkStatus());
257 EXPECT_EQ(grpc_sockaddr_to_string(&inputun, true).value(),
258 absl::StrCat(std::string(1, '\0'), "some_unix_path"));
259
260 std::string max_abspath(sizeof(sock_un->sun_path) - 1, '\0');
261 ASSERT_EQ(grpc_core::UnixAbstractSockaddrPopulate(max_abspath, &inputun),
262 absl::OkStatus());
263 EXPECT_EQ(grpc_sockaddr_to_string(&inputun, true).value(),
264 absl::StrCat(std::string(1, '\0'), max_abspath));
265
266 ASSERT_EQ(grpc_core::UnixAbstractSockaddrPopulate("", &inputun),
267 absl::OkStatus());
268 inputun.len = sizeof(sock_un->sun_family);
269 EXPECT_EQ(grpc_sockaddr_to_string(&inputun, true).status(),
270 absl::InvalidArgumentError("empty UDS abstract path"));
271 #endif
272
273 #ifdef GRPC_HAVE_VSOCK
274 grpc_resolved_address inputvm;
275 ASSERT_EQ(grpc_core::VSockaddrPopulate("-1:12345", &inputvm),
276 absl::OkStatus());
277 EXPECT_EQ(grpc_sockaddr_to_string(&inputvm, true).value(),
278 absl::StrCat((uint32_t)-1, ":12345"));
279 #endif
280 }
281
282 #ifdef GRPC_HAVE_UNIX_SOCKET
283
TEST(SockAddrUtilsTest,UnixSockAddrToUri)284 TEST(SockAddrUtilsTest, UnixSockAddrToUri) {
285 grpc_resolved_address addr;
286 ASSERT_TRUE(absl::OkStatus() ==
287 grpc_core::UnixSockaddrPopulate("sample-path", &addr));
288 EXPECT_EQ(grpc_sockaddr_to_uri(&addr).value(), "unix:sample-path");
289
290 ASSERT_TRUE(absl::OkStatus() ==
291 grpc_core::UnixAbstractSockaddrPopulate("no-nulls", &addr));
292 EXPECT_EQ(grpc_sockaddr_to_uri(&addr).value(), "unix-abstract:no-nulls");
293
294 ASSERT_TRUE(absl::OkStatus() ==
295 grpc_core::UnixAbstractSockaddrPopulate(
296 std::string("path_\0with_null", 15), &addr));
297 EXPECT_EQ(grpc_sockaddr_to_uri(&addr).value(),
298 "unix-abstract:path_%00with_null");
299 }
300
301 #endif // GRPC_HAVE_UNIX_SOCKET
302
303 #ifdef GRPC_HAVE_VSOCK
304
TEST(SockAddrUtilsTest,VSockAddrToUri)305 TEST(SockAddrUtilsTest, VSockAddrToUri) {
306 grpc_resolved_address addr;
307 ASSERT_TRUE(absl::OkStatus() ==
308 grpc_core::VSockaddrPopulate("-1:12345", &addr));
309 EXPECT_EQ(grpc_sockaddr_to_uri(&addr).value(),
310 absl::StrCat("vsock:", (uint32_t)-1, ":12345"));
311 }
312
313 #endif // GRPC_HAVE_VSOCK
314
TEST(SockAddrUtilsTest,SockAddrSetGetPort)315 TEST(SockAddrUtilsTest, SockAddrSetGetPort) {
316 grpc_resolved_address input4 = MakeAddr4(kIPv4, sizeof(kIPv4));
317 ASSERT_EQ(grpc_sockaddr_get_port(&input4), 12345);
318 ASSERT_TRUE(grpc_sockaddr_set_port(&input4, 54321));
319 ASSERT_EQ(grpc_sockaddr_get_port(&input4), 54321);
320
321 grpc_resolved_address input6 = MakeAddr6(kIPv6, sizeof(kIPv6));
322 ASSERT_EQ(grpc_sockaddr_get_port(&input6), 12345);
323 ASSERT_TRUE(grpc_sockaddr_set_port(&input6, 54321));
324 ASSERT_EQ(grpc_sockaddr_get_port(&input6), 54321);
325
326 grpc_resolved_address phony;
327 memset(&phony, 0, sizeof(phony));
328 grpc_sockaddr* phony_addr = reinterpret_cast<grpc_sockaddr*>(phony.addr);
329 phony_addr->sa_family = 123;
330 ASSERT_EQ(grpc_sockaddr_get_port(&phony), false);
331 ASSERT_EQ(grpc_sockaddr_set_port(&phony, 1234), false);
332 }
333
VerifySocketAddressMatch(const std::string & ip_address,const std::string & subnet,uint32_t mask_bits,bool success)334 void VerifySocketAddressMatch(const std::string& ip_address,
335 const std::string& subnet, uint32_t mask_bits,
336 bool success) {
337 // Setting the port has no effect on the match.
338 auto addr = grpc_core::StringToSockaddr(ip_address, /*port=*/12345);
339 ASSERT_TRUE(addr.ok()) << addr.status();
340 auto subnet_addr = grpc_core::StringToSockaddr(subnet, /*port=*/0);
341 ASSERT_TRUE(subnet_addr.ok()) << subnet_addr.status();
342 grpc_sockaddr_mask_bits(&*subnet_addr, mask_bits);
343 EXPECT_EQ(grpc_sockaddr_match_subnet(&*addr, &*subnet_addr, mask_bits),
344 success)
345 << "IP=" << ip_address << " Subnet=" << subnet << " Mask=" << mask_bits;
346 }
347
VerifySocketAddressMatchSuccess(const std::string & ip_address,const std::string & subnet,uint32_t mask_bits)348 void VerifySocketAddressMatchSuccess(const std::string& ip_address,
349 const std::string& subnet,
350 uint32_t mask_bits) {
351 // If the IP address matches the subnet for a particular length, then it would
352 // match for all lengths [0, mask_bits]
353 for (uint32_t i = 0; i <= mask_bits; i++) {
354 VerifySocketAddressMatch(ip_address, subnet, i, true);
355 }
356 }
357
VerifySocketAddressMatchFailure(const std::string & ip_address,const std::string & subnet,uint32_t mask_bits)358 void VerifySocketAddressMatchFailure(const std::string& ip_address,
359 const std::string& subnet,
360 uint32_t mask_bits) {
361 // If the IP address fails matching the subnet for a particular length, then
362 // it would also fail for all lengths [mask_bits, 128]
363 for (auto i = mask_bits; i <= 128; i++) {
364 VerifySocketAddressMatch(ip_address, subnet, i, false);
365 }
366 }
367
TEST(SockAddrUtilsTest,SockAddrMatchSubnet)368 TEST(SockAddrUtilsTest, SockAddrMatchSubnet) {
369 // IPv4 Tests
370 VerifySocketAddressMatchSuccess("192.168.1.1", "192.168.1.1", 32);
371 VerifySocketAddressMatchSuccess("255.255.255.255", "255.255.255.255", 32);
372 VerifySocketAddressMatchFailure("192.168.1.1", "192.168.1.2", 31);
373 VerifySocketAddressMatchFailure("192.168.1.1", "191.0.0.0", 8);
374 VerifySocketAddressMatchFailure("192.168.1.1", "0.0.0.0", 1);
375 // IPv6 Tests
376 VerifySocketAddressMatchSuccess("2001:db8::", "2001::", 16);
377 VerifySocketAddressMatchSuccess("2001:db8:cfe:134:3ab:3456:78:9",
378 "2001:db8:cfe:134:3ab:3456:78:9", 128);
379 VerifySocketAddressMatchSuccess("FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF",
380 "FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF",
381 128);
382 VerifySocketAddressMatchFailure("2001:db8:cfe:134:3ab:3456:78:9",
383 "3001:2:3:4:5:6:7:8", 4);
384 VerifySocketAddressMatchFailure("FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF",
385 "::", 1);
386 }
387
388 } // namespace
389
main(int argc,char ** argv)390 int main(int argc, char** argv) {
391 grpc::testing::TestEnvironment env(&argc, argv);
392 ::testing::InitGoogleTest(&argc, argv);
393 int retval = RUN_ALL_TESTS();
394 return retval;
395 }
396