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