1 /*
2 *
3 * Copyright 2016 gRPC authors.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 */
18
19 #include <grpc/support/port_platform.h>
20
21 #include "src/core/lib/address_utils/sockaddr_utils.h"
22
23 #include <errno.h>
24 #include <inttypes.h>
25 #include <string.h>
26
27 #include <string>
28
29 #include "absl/strings/str_cat.h"
30 #include "absl/strings/str_format.h"
31
32 #include <grpc/event_engine/event_engine.h>
33 #include <grpc/support/alloc.h>
34 #include <grpc/support/log.h>
35
36 #include "src/core/lib/gpr/string.h"
37 #include "src/core/lib/gprpp/host_port.h"
38 #include "src/core/lib/iomgr/event_engine/resolved_address_internal.h"
39 #include "src/core/lib/iomgr/sockaddr.h"
40 #include "src/core/lib/iomgr/socket_utils.h"
41 #include "src/core/lib/iomgr/unix_sockets_posix.h"
42
43 static const uint8_t kV4MappedPrefix[] = {0, 0, 0, 0, 0, 0,
44 0, 0, 0, 0, 0xff, 0xff};
45
grpc_sockaddr_is_v4mapped(const grpc_resolved_address * resolved_addr,grpc_resolved_address * resolved_addr4_out)46 int grpc_sockaddr_is_v4mapped(const grpc_resolved_address* resolved_addr,
47 grpc_resolved_address* resolved_addr4_out) {
48 GPR_ASSERT(resolved_addr != resolved_addr4_out);
49 const grpc_sockaddr* addr =
50 reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
51 grpc_sockaddr_in* addr4_out =
52 resolved_addr4_out == nullptr
53 ? nullptr
54 : reinterpret_cast<grpc_sockaddr_in*>(resolved_addr4_out->addr);
55 if (addr->sa_family == GRPC_AF_INET6) {
56 const grpc_sockaddr_in6* addr6 =
57 reinterpret_cast<const grpc_sockaddr_in6*>(addr);
58 if (memcmp(addr6->sin6_addr.s6_addr, kV4MappedPrefix,
59 sizeof(kV4MappedPrefix)) == 0) {
60 if (resolved_addr4_out != nullptr) {
61 /* Normalize ::ffff:0.0.0.0/96 to IPv4. */
62 memset(resolved_addr4_out, 0, sizeof(*resolved_addr4_out));
63 addr4_out->sin_family = GRPC_AF_INET;
64 /* s6_addr32 would be nice, but it's non-standard. */
65 memcpy(&addr4_out->sin_addr, &addr6->sin6_addr.s6_addr[12], 4);
66 addr4_out->sin_port = addr6->sin6_port;
67 resolved_addr4_out->len =
68 static_cast<socklen_t>(sizeof(grpc_sockaddr_in));
69 }
70 return 1;
71 }
72 }
73 return 0;
74 }
75
grpc_sockaddr_to_v4mapped(const grpc_resolved_address * resolved_addr,grpc_resolved_address * resolved_addr6_out)76 int grpc_sockaddr_to_v4mapped(const grpc_resolved_address* resolved_addr,
77 grpc_resolved_address* resolved_addr6_out) {
78 GPR_ASSERT(resolved_addr != resolved_addr6_out);
79 const grpc_sockaddr* addr =
80 reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
81 grpc_sockaddr_in6* addr6_out =
82 reinterpret_cast<grpc_sockaddr_in6*>(resolved_addr6_out->addr);
83 if (addr->sa_family == GRPC_AF_INET) {
84 const grpc_sockaddr_in* addr4 =
85 reinterpret_cast<const grpc_sockaddr_in*>(addr);
86 memset(resolved_addr6_out, 0, sizeof(*resolved_addr6_out));
87 addr6_out->sin6_family = GRPC_AF_INET6;
88 memcpy(&addr6_out->sin6_addr.s6_addr[0], kV4MappedPrefix, 12);
89 memcpy(&addr6_out->sin6_addr.s6_addr[12], &addr4->sin_addr, 4);
90 addr6_out->sin6_port = addr4->sin_port;
91 resolved_addr6_out->len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in6));
92 return 1;
93 }
94 return 0;
95 }
96
grpc_sockaddr_is_wildcard(const grpc_resolved_address * resolved_addr,int * port_out)97 int grpc_sockaddr_is_wildcard(const grpc_resolved_address* resolved_addr,
98 int* port_out) {
99 const grpc_sockaddr* addr;
100 grpc_resolved_address addr4_normalized;
101 if (grpc_sockaddr_is_v4mapped(resolved_addr, &addr4_normalized)) {
102 resolved_addr = &addr4_normalized;
103 }
104 addr = reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
105 if (addr->sa_family == GRPC_AF_INET) {
106 /* Check for 0.0.0.0 */
107 const grpc_sockaddr_in* addr4 =
108 reinterpret_cast<const grpc_sockaddr_in*>(addr);
109 if (addr4->sin_addr.s_addr != 0) {
110 return 0;
111 }
112 *port_out = grpc_ntohs(addr4->sin_port);
113 return 1;
114 } else if (addr->sa_family == GRPC_AF_INET6) {
115 /* Check for :: */
116 const grpc_sockaddr_in6* addr6 =
117 reinterpret_cast<const grpc_sockaddr_in6*>(addr);
118 int i;
119 for (i = 0; i < 16; i++) {
120 if (addr6->sin6_addr.s6_addr[i] != 0) {
121 return 0;
122 }
123 }
124 *port_out = grpc_ntohs(addr6->sin6_port);
125 return 1;
126 } else {
127 return 0;
128 }
129 }
130
grpc_sockaddr_make_wildcards(int port,grpc_resolved_address * wild4_out,grpc_resolved_address * wild6_out)131 void grpc_sockaddr_make_wildcards(int port, grpc_resolved_address* wild4_out,
132 grpc_resolved_address* wild6_out) {
133 grpc_sockaddr_make_wildcard4(port, wild4_out);
134 grpc_sockaddr_make_wildcard6(port, wild6_out);
135 }
136
grpc_sockaddr_make_wildcard4(int port,grpc_resolved_address * resolved_wild_out)137 void grpc_sockaddr_make_wildcard4(int port,
138 grpc_resolved_address* resolved_wild_out) {
139 grpc_sockaddr_in* wild_out =
140 reinterpret_cast<grpc_sockaddr_in*>(resolved_wild_out->addr);
141 GPR_ASSERT(port >= 0 && port < 65536);
142 memset(resolved_wild_out, 0, sizeof(*resolved_wild_out));
143 wild_out->sin_family = GRPC_AF_INET;
144 wild_out->sin_port = grpc_htons(static_cast<uint16_t>(port));
145 resolved_wild_out->len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in));
146 }
147
grpc_sockaddr_make_wildcard6(int port,grpc_resolved_address * resolved_wild_out)148 void grpc_sockaddr_make_wildcard6(int port,
149 grpc_resolved_address* resolved_wild_out) {
150 grpc_sockaddr_in6* wild_out =
151 reinterpret_cast<grpc_sockaddr_in6*>(resolved_wild_out->addr);
152 GPR_ASSERT(port >= 0 && port < 65536);
153 memset(resolved_wild_out, 0, sizeof(*resolved_wild_out));
154 wild_out->sin6_family = GRPC_AF_INET6;
155 wild_out->sin6_port = grpc_htons(static_cast<uint16_t>(port));
156 resolved_wild_out->len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in6));
157 }
158
grpc_sockaddr_to_string(const grpc_resolved_address * resolved_addr,bool normalize)159 std::string grpc_sockaddr_to_string(const grpc_resolved_address* resolved_addr,
160 bool normalize) {
161 const int save_errno = errno;
162 grpc_resolved_address addr_normalized;
163 if (normalize && grpc_sockaddr_is_v4mapped(resolved_addr, &addr_normalized)) {
164 resolved_addr = &addr_normalized;
165 }
166 const grpc_sockaddr* addr =
167 reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
168 const void* ip = nullptr;
169 int port = 0;
170 uint32_t sin6_scope_id = 0;
171 if (addr->sa_family == GRPC_AF_INET) {
172 const grpc_sockaddr_in* addr4 =
173 reinterpret_cast<const grpc_sockaddr_in*>(addr);
174 ip = &addr4->sin_addr;
175 port = grpc_ntohs(addr4->sin_port);
176 } else if (addr->sa_family == GRPC_AF_INET6) {
177 const grpc_sockaddr_in6* addr6 =
178 reinterpret_cast<const grpc_sockaddr_in6*>(addr);
179 ip = &addr6->sin6_addr;
180 port = grpc_ntohs(addr6->sin6_port);
181 sin6_scope_id = addr6->sin6_scope_id;
182 }
183 char ntop_buf[GRPC_INET6_ADDRSTRLEN];
184 std::string out;
185 if (ip != nullptr && grpc_inet_ntop(addr->sa_family, ip, ntop_buf,
186 sizeof(ntop_buf)) != nullptr) {
187 if (sin6_scope_id != 0) {
188 // Enclose sin6_scope_id with the format defined in RFC 6874 section 2.
189 std::string host_with_scope =
190 absl::StrFormat("%s%%25%" PRIu32, ntop_buf, sin6_scope_id);
191 out = grpc_core::JoinHostPort(host_with_scope, port);
192 } else {
193 out = grpc_core::JoinHostPort(ntop_buf, port);
194 }
195 } else {
196 out = absl::StrFormat("(sockaddr family=%d)", addr->sa_family);
197 }
198 /* This is probably redundant, but we wouldn't want to log the wrong error. */
199 errno = save_errno;
200 return out;
201 }
202
grpc_string_to_sockaddr(grpc_resolved_address * out,const char * addr,int port)203 grpc_error_handle grpc_string_to_sockaddr(grpc_resolved_address* out,
204 const char* addr, int port) {
205 memset(out, 0, sizeof(grpc_resolved_address));
206 grpc_sockaddr_in6* addr6 = reinterpret_cast<grpc_sockaddr_in6*>(out->addr);
207 grpc_sockaddr_in* addr4 = reinterpret_cast<grpc_sockaddr_in*>(out->addr);
208 if (grpc_inet_pton(GRPC_AF_INET6, addr, &addr6->sin6_addr) == 1) {
209 addr6->sin6_family = GRPC_AF_INET6;
210 out->len = sizeof(grpc_sockaddr_in6);
211 } else if (grpc_inet_pton(GRPC_AF_INET, addr, &addr4->sin_addr) == 1) {
212 addr4->sin_family = GRPC_AF_INET;
213 out->len = sizeof(grpc_sockaddr_in);
214 } else {
215 return GRPC_ERROR_CREATE_FROM_CPP_STRING(
216 absl::StrCat("Failed to parse address:", addr));
217 }
218 grpc_sockaddr_set_port(out, port);
219 return GRPC_ERROR_NONE;
220 }
221
grpc_sockaddr_to_uri(const grpc_resolved_address * resolved_addr)222 std::string grpc_sockaddr_to_uri(const grpc_resolved_address* resolved_addr) {
223 if (resolved_addr->len == 0) return "";
224 grpc_resolved_address addr_normalized;
225 if (grpc_sockaddr_is_v4mapped(resolved_addr, &addr_normalized)) {
226 resolved_addr = &addr_normalized;
227 }
228 const char* scheme = grpc_sockaddr_get_uri_scheme(resolved_addr);
229 if (scheme == nullptr || strcmp("unix", scheme) == 0) {
230 return grpc_sockaddr_to_uri_unix_if_possible(resolved_addr);
231 }
232 std::string path =
233 grpc_sockaddr_to_string(resolved_addr, false /* normalize */);
234 std::string uri_str;
235 if (scheme != nullptr) {
236 uri_str = absl::StrCat(scheme, ":", path);
237 }
238 return uri_str;
239 }
240
grpc_sockaddr_get_uri_scheme(const grpc_resolved_address * resolved_addr)241 const char* grpc_sockaddr_get_uri_scheme(
242 const grpc_resolved_address* resolved_addr) {
243 const grpc_sockaddr* addr =
244 reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
245 switch (addr->sa_family) {
246 case GRPC_AF_INET:
247 return "ipv4";
248 case GRPC_AF_INET6:
249 return "ipv6";
250 case GRPC_AF_UNIX:
251 return "unix";
252 }
253 return nullptr;
254 }
255
grpc_sockaddr_get_family(const grpc_resolved_address * resolved_addr)256 int grpc_sockaddr_get_family(const grpc_resolved_address* resolved_addr) {
257 const grpc_sockaddr* addr =
258 reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
259 return addr->sa_family;
260 }
261
grpc_sockaddr_get_port(const grpc_resolved_address * resolved_addr)262 int grpc_sockaddr_get_port(const grpc_resolved_address* resolved_addr) {
263 const grpc_sockaddr* addr =
264 reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
265 switch (addr->sa_family) {
266 case GRPC_AF_INET:
267 return grpc_ntohs(
268 (reinterpret_cast<const grpc_sockaddr_in*>(addr))->sin_port);
269 case GRPC_AF_INET6:
270 return grpc_ntohs(
271 (reinterpret_cast<const grpc_sockaddr_in6*>(addr))->sin6_port);
272 default:
273 if (grpc_is_unix_socket(resolved_addr)) {
274 return 1;
275 }
276 gpr_log(GPR_ERROR, "Unknown socket family %d in grpc_sockaddr_get_port",
277 addr->sa_family);
278 return 0;
279 }
280 }
281
grpc_sockaddr_set_port(grpc_resolved_address * resolved_addr,int port)282 int grpc_sockaddr_set_port(grpc_resolved_address* resolved_addr, int port) {
283 grpc_sockaddr* addr = reinterpret_cast<grpc_sockaddr*>(resolved_addr->addr);
284 switch (addr->sa_family) {
285 case GRPC_AF_INET:
286 GPR_ASSERT(port >= 0 && port < 65536);
287 (reinterpret_cast<grpc_sockaddr_in*>(addr))->sin_port =
288 grpc_htons(static_cast<uint16_t>(port));
289 return 1;
290 case GRPC_AF_INET6:
291 GPR_ASSERT(port >= 0 && port < 65536);
292 (reinterpret_cast<grpc_sockaddr_in6*>(addr))->sin6_port =
293 grpc_htons(static_cast<uint16_t>(port));
294 return 1;
295 default:
296 gpr_log(GPR_ERROR, "Unknown socket family %d in grpc_sockaddr_set_port",
297 addr->sa_family);
298 return 0;
299 }
300 }
301
grpc_sockaddr_get_packed_host(const grpc_resolved_address * resolved_addr)302 std::string grpc_sockaddr_get_packed_host(
303 const grpc_resolved_address* resolved_addr) {
304 const grpc_sockaddr* addr =
305 reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
306 if (addr->sa_family == GRPC_AF_INET) {
307 const grpc_sockaddr_in* addr4 =
308 reinterpret_cast<const grpc_sockaddr_in*>(addr);
309 const char* addr_bytes = reinterpret_cast<const char*>(&addr4->sin_addr);
310 return std::string(addr_bytes, 4);
311 } else if (addr->sa_family == GRPC_AF_INET6) {
312 const grpc_sockaddr_in6* addr6 =
313 reinterpret_cast<const grpc_sockaddr_in6*>(addr);
314 const char* addr_bytes = reinterpret_cast<const char*>(&addr6->sin6_addr);
315 return std::string(addr_bytes, 16);
316 } else {
317 GPR_ASSERT(false);
318 }
319 }
320
grpc_sockaddr_mask_bits(grpc_resolved_address * address,uint32_t mask_bits)321 void grpc_sockaddr_mask_bits(grpc_resolved_address* address,
322 uint32_t mask_bits) {
323 grpc_sockaddr* addr = reinterpret_cast<grpc_sockaddr*>(address->addr);
324 if (addr->sa_family == GRPC_AF_INET) {
325 grpc_sockaddr_in* addr4 = reinterpret_cast<grpc_sockaddr_in*>(addr);
326 if (mask_bits == 0) {
327 memset(&addr4->sin_addr, 0, sizeof(addr4->sin_addr));
328 return;
329 } else if (mask_bits >= 32) {
330 return;
331 }
332 uint32_t mask_ip_addr = (~(uint32_t(0))) << (32 - mask_bits);
333 addr4->sin_addr.s_addr &= grpc_htonl(mask_ip_addr);
334 } else if (addr->sa_family == GRPC_AF_INET6) {
335 grpc_sockaddr_in6* addr6 = reinterpret_cast<grpc_sockaddr_in6*>(addr);
336 if (mask_bits == 0) {
337 memset(&addr6->sin6_addr, 0, sizeof(addr6->sin6_addr));
338 return;
339 } else if (mask_bits >= 128) {
340 return;
341 }
342 // We cannot use s6_addr32 since it is not defined on all platforms that we
343 // need it on.
344 uint32_t address_parts[4];
345 GPR_ASSERT(sizeof(addr6->sin6_addr) == sizeof(address_parts));
346 memcpy(address_parts, &addr6->sin6_addr, sizeof(grpc_in6_addr));
347 if (mask_bits <= 32) {
348 uint32_t mask_ip_addr = (~(uint32_t(0))) << (32 - mask_bits);
349 address_parts[0] &= grpc_htonl(mask_ip_addr);
350 memset(&address_parts[1], 0, sizeof(uint32_t));
351 memset(&address_parts[2], 0, sizeof(uint32_t));
352 memset(&address_parts[3], 0, sizeof(uint32_t));
353 } else if (mask_bits <= 64) {
354 mask_bits -= 32;
355 uint32_t mask_ip_addr = (~(uint32_t(0))) << (32 - mask_bits);
356 address_parts[1] &= grpc_htonl(mask_ip_addr);
357 memset(&address_parts[2], 0, sizeof(uint32_t));
358 memset(&address_parts[3], 0, sizeof(uint32_t));
359 } else if (mask_bits <= 96) {
360 mask_bits -= 64;
361 uint32_t mask_ip_addr = (~(uint32_t(0))) << (32 - mask_bits);
362 address_parts[2] &= grpc_htonl(mask_ip_addr);
363 memset(&address_parts[3], 0, sizeof(uint32_t));
364 } else {
365 mask_bits -= 96;
366 uint32_t mask_ip_addr = (~(uint32_t(0))) << (32 - mask_bits);
367 address_parts[3] &= grpc_htonl(mask_ip_addr);
368 }
369 memcpy(&addr6->sin6_addr, address_parts, sizeof(grpc_in6_addr));
370 }
371 }
372
grpc_sockaddr_match_subnet(const grpc_resolved_address * address,const grpc_resolved_address * subnet_address,uint32_t mask_bits)373 bool grpc_sockaddr_match_subnet(const grpc_resolved_address* address,
374 const grpc_resolved_address* subnet_address,
375 uint32_t mask_bits) {
376 auto* addr = reinterpret_cast<const grpc_sockaddr*>(address->addr);
377 auto* subnet_addr =
378 reinterpret_cast<const grpc_sockaddr*>(subnet_address->addr);
379 if (addr->sa_family != subnet_addr->sa_family) return false;
380 grpc_resolved_address masked_address;
381 memcpy(&masked_address, address, sizeof(grpc_resolved_address));
382 addr = reinterpret_cast<grpc_sockaddr*>((&masked_address)->addr);
383 grpc_sockaddr_mask_bits(&masked_address, mask_bits);
384 if (addr->sa_family == GRPC_AF_INET) {
385 auto* addr4 = reinterpret_cast<const grpc_sockaddr_in*>(addr);
386 auto* subnet_addr4 = reinterpret_cast<const grpc_sockaddr_in*>(subnet_addr);
387 if (memcmp(&addr4->sin_addr, &subnet_addr4->sin_addr,
388 sizeof(addr4->sin_addr)) == 0) {
389 return true;
390 }
391 } else if (addr->sa_family == GRPC_AF_INET6) {
392 auto* addr6 = reinterpret_cast<const grpc_sockaddr_in6*>(addr);
393 auto* subnet_addr6 =
394 reinterpret_cast<const grpc_sockaddr_in6*>(subnet_addr);
395 if (memcmp(&addr6->sin6_addr, &subnet_addr6->sin6_addr,
396 sizeof(addr6->sin6_addr)) == 0) {
397 return true;
398 }
399 }
400 return false;
401 }
402
403 namespace grpc_event_engine {
404 namespace experimental {
405
ResolvedAddressToURI(const EventEngine::ResolvedAddress & addr)406 std::string ResolvedAddressToURI(const EventEngine::ResolvedAddress& addr) {
407 auto gra = CreateGRPCResolvedAddress(addr);
408 return grpc_sockaddr_to_uri(&gra);
409 }
410
411 } // namespace experimental
412 } // namespace grpc_event_engine
413