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