Debian Codegraph @

src/basic/in-addr-util.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <arpa/inet.h>
4 #include <endian.h>
5 #include <stdio.h>
6
7 #include "alloc-util.h"
8 #include "errno-util.h"
9 #include "hash-funcs.h"
10 #include "in-addr-util.h"
11 #include "logarithm.h"
12 #include "memory-util.h"
13 #include "parse-util.h"
14 #include "random-util.h"
15 #include "siphash24.h"
16 #include "stdio-util.h"
17 #include "string-util.h"
18
19 bool in4_addr_is_null(const struct in_addr *a) {
20 assert(a);
21
22 return a->s_addr == 0;
23 }
24
25 bool in6_addr_is_null(const struct in6_addr *a) {
26 assert(a);
27
28 return eqzero(a->s6_addr32);
29 }
30
31 int in_addr_is_null(int family, const union in_addr_union *u) {
32 assert(u);
33
34 if (family == AF_INET)
35 return in4_addr_is_null(&u->in);
36
37 if (family == AF_INET6)
38 return in6_addr_is_null(&u->in6);
39
40 return -EAFNOSUPPORT;
41 }
42
43 bool in4_addr_is_link_local(const struct in_addr *a) {
44 assert(a);
45
46 return (be32toh(a->s_addr) & UINT32_C(0xFFFF0000)) == (UINT32_C(169) << 24 | UINT32_C(254) << 16);
47 }
48
49 bool in4_addr_is_link_local_dynamic(const struct in_addr *a) {
50 assert(a);
51
52 if (!in4_addr_is_link_local(a))
53 return false;
54
55 /* 169.254.0.0/24 and 169.254.255.0/24 must not be used for the dynamic IPv4LL assignment.
56 * See RFC 3927 Section 2.1:
57 * The IPv4 prefix 169.254/16 is registered with the IANA for this purpose. The first 256 and last
58 * 256 addresses in the 169.254/16 prefix are reserved for future use and MUST NOT be selected by a
59 * host using this dynamic configuration mechanism. */
60 return !IN_SET(be32toh(a->s_addr) & 0x0000FF00U, 0x0000U, 0xFF00U);
61 }
62
63 bool in6_addr_is_link_local(const struct in6_addr *a) {
64 assert(a);
65
66 return (a->s6_addr32[0] & htobe32(0xffc00000)) == htobe32(0xfe800000);
67 }
68
69 int in_addr_is_link_local(int family, const union in_addr_union *u) {
70 assert(u);
71
72 if (family == AF_INET)
73 return in4_addr_is_link_local(&u->in);
74
75 if (family == AF_INET6)
76 return in6_addr_is_link_local(&u->in6);
77
78 return -EAFNOSUPPORT;
79 }
80
81 bool in6_addr_is_link_local_all_nodes(const struct in6_addr *a) {
82 assert(a);
83
84 /* ff02::1 */
85 return be32toh(a->s6_addr32[0]) == UINT32_C(0xff020000) &&
86 a->s6_addr32[1] == 0 &&
87 a->s6_addr32[2] == 0 &&
88 be32toh(a->s6_addr32[3]) == UINT32_C(0x00000001);
89 }
90
91 bool in4_addr_is_multicast(const struct in_addr *a) {
92 assert(a);
93
94 return IN_MULTICAST(be32toh(a->s_addr));
95 }
96
97 bool in6_addr_is_multicast(const struct in6_addr *a) {
98 assert(a);
99
100 return a->s6_addr[0] == 0xff;
101 }
102
103 int in_addr_is_multicast(int family, const union in_addr_union *u) {
104 assert(u);
105
106 if (family == AF_INET)
107 return in4_addr_is_multicast(&u->in);
108
109 if (family == AF_INET6)
110 return in6_addr_is_multicast(&u->in6);
111
112 return -EAFNOSUPPORT;
113 }
114
115 bool in4_addr_is_local_multicast(const struct in_addr *a) {
116 assert(a);
117
118 return (be32toh(a->s_addr) & UINT32_C(0xffffff00)) == UINT32_C(0xe0000000);
119 }
120
121 bool in4_addr_is_localhost(const struct in_addr *a) {
122 assert(a);
123
124 /* All of 127.x.x.x is localhost. */
125 return (be32toh(a->s_addr) & UINT32_C(0xFF000000)) == UINT32_C(127) << 24;
126 }
127
128 bool in4_addr_is_non_local(const struct in_addr *a) {
129 /* Whether the address is not null and not localhost.
130 *
131 * As such, it is suitable to configure as DNS/NTP server from DHCP. */
132 return !in4_addr_is_null(a) &&
133 !in4_addr_is_localhost(a);
134 }
135
136 static bool in6_addr_is_loopback(const struct in6_addr *a) {
137 return memcmp(a, &(struct in6_addr) IN6ADDR_LOOPBACK_INIT, sizeof(struct in6_addr)) == 0;
138 }
139
140 int in_addr_is_localhost(int family, const union in_addr_union *u) {
141 assert(u);
142
143 if (family == AF_INET)
144 return in4_addr_is_localhost(&u->in);
145
146 if (family == AF_INET6)
147 return in6_addr_is_loopback(&u->in6);
148
149 return -EAFNOSUPPORT;
150 }
151
152 int in_addr_is_localhost_one(int family, const union in_addr_union *u) {
153 assert(u);
154
155 if (family == AF_INET)
156 /* 127.0.0.1 */
157 return be32toh(u->in.s_addr) == UINT32_C(0x7F000001);
158
159 if (family == AF_INET6)
160 return in6_addr_is_loopback(&u->in6);
161
162 return -EAFNOSUPPORT;
163 }
164
165 bool in6_addr_is_ipv4_mapped_address(const struct in6_addr *a) {
166 return a->s6_addr32[0] == 0 &&
167 a->s6_addr32[1] == 0 &&
168 a->s6_addr32[2] == htobe32(UINT32_C(0x0000ffff));
169 }
170
171 bool in4_addr_equal(const struct in_addr *a, const struct in_addr *b) {
172 assert(a);
173 assert(b);
174
175 return a->s_addr == b->s_addr;
176 }
177
178 bool in6_addr_equal(const struct in6_addr *a, const struct in6_addr *b) {
179 assert(a);
180 assert(b);
181
182 return memcmp(a, b, sizeof(struct in6_addr)) == 0;
183 }
184
185 int in_addr_equal(int family, const union in_addr_union *a, const union in_addr_union *b) {
186 assert(a);
187 assert(b);
188
189 if (family == AF_INET)
190 return in4_addr_equal(&a->in, &b->in);
191
192 if (family == AF_INET6)
193 return in6_addr_equal(&a->in6, &b->in6);
194
195 return -EAFNOSUPPORT;
196 }
197
198 bool in4_addr_prefix_intersect(
199 const struct in_addr *a,
200 unsigned aprefixlen,
201 const struct in_addr *b,
202 unsigned bprefixlen) {
203
204 assert(a);
205 assert(b);
206
207 unsigned m = MIN3(aprefixlen, bprefixlen, (unsigned) (sizeof(struct in_addr) * 8));
208 if (m == 0)
209 return true; /* Let's return earlier, to avoid shift by 32. */
210
211 uint32_t x = be32toh(a->s_addr ^ b->s_addr);
212 uint32_t n = 0xFFFFFFFFUL << (32 - m);
213 return (x & n) == 0;
214 }
215
216 bool in6_addr_prefix_intersect(
217 const struct in6_addr *a,
218 unsigned aprefixlen,
219 const struct in6_addr *b,
220 unsigned bprefixlen) {
221
222 assert(a);
223 assert(b);
224
225 unsigned m = MIN3(aprefixlen, bprefixlen, (unsigned) (sizeof(struct in6_addr) * 8));
226 if (m == 0)
227 return true;
228
229 for (size_t i = 0; i < sizeof(struct in6_addr); i++) {
230 uint8_t x = a->s6_addr[i] ^ b->s6_addr[i];
231 uint8_t n = m < 8 ? (0xFF << (8 - m)) : 0xFF;
232 if ((x & n) != 0)
233 return false;
234
235 if (m <= 8)
236 break;
237
238 m -= 8;
239 }
240
241 return true;
242 }
243
244 int in_addr_prefix_intersect(
245 int family,
246 const union in_addr_union *a,
247 unsigned aprefixlen,
248 const union in_addr_union *b,
249 unsigned bprefixlen) {
250
251 assert(a);
252 assert(b);
253
254 /* Checks whether there are any addresses that are in both networks. */
255
256 if (family == AF_INET)
257 return in4_addr_prefix_intersect(&a->in, aprefixlen, &b->in, bprefixlen);
258
259 if (family == AF_INET6)
260 return in6_addr_prefix_intersect(&a->in6, aprefixlen, &b->in6, bprefixlen);
261
262 return -EAFNOSUPPORT;
263 }
264
265 int in_addr_prefix_next(int family, union in_addr_union *u, unsigned prefixlen) {
266 assert(u);
267
268 /* Increases the network part of an address by one. Returns 0 if that succeeds, or -ERANGE if
269 * this overflows. */
270
271 return in_addr_prefix_nth(family, u, prefixlen, 1);
272 }
273
274 /*
275 * Calculates the nth prefix of size prefixlen starting from the address denoted by u.
276 *
277 * On success 0 will be returned and the calculated prefix will be available in
278 * u. In case the calculation cannot be performed (invalid prefix length,
279 * overflows would occur) -ERANGE is returned. If the address family given isn't
280 * supported -EAFNOSUPPORT will be returned.
281 *
282 * Examples:
283 * - in_addr_prefix_nth(AF_INET, 192.168.0.0, 24, 2), returns 0, writes 192.168.2.0 to u
284 * - in_addr_prefix_nth(AF_INET, 192.168.0.0, 24, 0), returns 0, no data written
285 * - in_addr_prefix_nth(AF_INET, 255.255.255.0, 24, 1), returns -ERANGE, no data written
286 * - in_addr_prefix_nth(AF_INET, 255.255.255.0, 0, 1), returns -ERANGE, no data written
287 * - in_addr_prefix_nth(AF_INET6, 2001:db8, 64, 0xff00) returns 0, writes 2001:0db8:0000:ff00:: to u
288 */
289 int in_addr_prefix_nth(int family, union in_addr_union *u, unsigned prefixlen, uint64_t nth) {
290 assert(u);
291
292 if (prefixlen <= 0)
293 return -ERANGE;
294
295 if (family == AF_INET) {
296 uint32_t c, n, t;
297
298 if (prefixlen > 32)
299 return -ERANGE;
300
301 c = be32toh(u->in.s_addr);
302
303 t = nth << (32 - prefixlen);
304
305 /* Check for wrap */
306 if (c > UINT32_MAX - t)
307 return -ERANGE;
308
309 n = c + t;
310
311 n &= UINT32_C(0xFFFFFFFF) << (32 - prefixlen);
312 u->in.s_addr = htobe32(n);
313 return 0;
314 }
315
316 if (family == AF_INET6) {
317 bool overflow = false;
318
319 if (prefixlen > 128)
320 return -ERANGE;
321
322 for (unsigned i = 16; i > 0; i--) {
323 unsigned t, j = i - 1, p = j * 8;
324
325 if (p >= prefixlen) {
326 u->in6.s6_addr[j] = 0;
327 continue;
328 }
329
330 if (prefixlen - p < 8) {
331 u->in6.s6_addr[j] &= 0xff << (8 - (prefixlen - p));
332 t = u->in6.s6_addr[j] + ((nth & 0xff) << (8 - (prefixlen - p)));
333 nth >>= prefixlen - p;
334 } else {
335 t = u->in6.s6_addr[j] + (nth & 0xff) + overflow;
336 nth >>= 8;
337 }
338
339 overflow = t > UINT8_MAX;
340 u->in6.s6_addr[j] = (uint8_t) (t & 0xff);
341 }
342
343 if (overflow || nth != 0)
344 return -ERANGE;
345
346 return 0;
347 }
348
349 return -EAFNOSUPPORT;
350 }
351
352 int in_addr_random_prefix(
353 int family,
354 union in_addr_union *u,
355 unsigned prefixlen_fixed_part,
356 unsigned prefixlen) {
357
358 assert(u);
359
360 /* Random network part of an address by one. */
361
362 if (prefixlen <= 0)
363 return 0;
364
365 if (family == AF_INET) {
366 uint32_t c, n;
367
368 if (prefixlen_fixed_part > 32)
369 prefixlen_fixed_part = 32;
370 if (prefixlen > 32)
371 prefixlen = 32;
372 if (prefixlen_fixed_part >= prefixlen)
373 return -EINVAL;
374
375 c = be32toh(u->in.s_addr);
376 c &= ((UINT32_C(1) << prefixlen_fixed_part) - 1) << (32 - prefixlen_fixed_part);
377
378 random_bytes(&n, sizeof(n));
379 n &= ((UINT32_C(1) << (prefixlen - prefixlen_fixed_part)) - 1) << (32 - prefixlen);
380
381 u->in.s_addr = htobe32(n | c);
382 return 1;
383 }
384
385 if (family == AF_INET6) {
386 struct in6_addr n;
387 unsigned i, j;
388
389 if (prefixlen_fixed_part > 128)
390 prefixlen_fixed_part = 128;
391 if (prefixlen > 128)
392 prefixlen = 128;
393 if (prefixlen_fixed_part >= prefixlen)
394 return -EINVAL;
395
396 random_bytes(&n, sizeof(n));
397
398 for (i = 0; i < 16; i++) {
399 uint8_t mask_fixed_part = 0, mask = 0;
400
401 if (i < (prefixlen_fixed_part + 7) / 8) {
402 if (i < prefixlen_fixed_part / 8)
403 mask_fixed_part = 0xffu;
404 else {
405 j = prefixlen_fixed_part % 8;
406 mask_fixed_part = ((UINT8_C(1) << (j + 1)) - 1) << (8 - j);
407 }
408 }
409
410 if (i < (prefixlen + 7) / 8) {
411 if (i < prefixlen / 8)
412 mask = 0xffu ^ mask_fixed_part;
413 else {
414 j = prefixlen % 8;
415 mask = (((UINT8_C(1) << (j + 1)) - 1) << (8 - j)) ^ mask_fixed_part;
416 }
417 }
418
419 u->in6.s6_addr[i] &= mask_fixed_part;
420 u->in6.s6_addr[i] |= n.s6_addr[i] & mask;
421 }
422
423 return 1;
424 }
425
426 return -EAFNOSUPPORT;
427 }
428
429 int in_addr_prefix_range(
430 int family,
431 const union in_addr_union *in,
432 unsigned prefixlen,
433 union in_addr_union *ret_start,
434 union in_addr_union *ret_end) {
435
436 union in_addr_union start, end;
437 int r;
438
439 assert(in);
440
441 if (!IN_SET(family, AF_INET, AF_INET6))
442 return -EAFNOSUPPORT;
443
444 if (ret_start) {
445 start = *in;
446 r = in_addr_prefix_nth(family, &start, prefixlen, 0);
447 if (r < 0)
448 return r;
449 }
450
451 if (ret_end) {
452 end = *in;
453 r = in_addr_prefix_nth(family, &end, prefixlen, 1);
454 if (r < 0)
455 return r;
456 }
457
458 if (ret_start)
459 *ret_start = start;
460 if (ret_end)
461 *ret_end = end;
462
463 return 0;
464 }
465
466 int in_addr_to_string(int family, const union in_addr_union *u, char **ret) {
467 _cleanup_free_ char *x = NULL;
468 size_t l;
469
470 assert(u);
471 assert(ret);
472
473 if (family == AF_INET)
474 l = INET_ADDRSTRLEN;
475 else if (family == AF_INET6)
476 l = INET6_ADDRSTRLEN;
477 else
478 return -EAFNOSUPPORT;
479
480 x = new(char, l);
481 if (!x)
482 return -ENOMEM;
483
484 errno = 0;
485 if (!typesafe_inet_ntop(family, u, x, l))
486 return errno_or_else(EINVAL);
487
488 *ret = TAKE_PTR(x);
489 return 0;
490 }
491
492 const char* typesafe_inet_ntop(int family, const union in_addr_union *a, char *buf, size_t len) {
493 return inet_ntop(family, a, buf, len);
494 }
495
496 const char* typesafe_inet_ntop4(const struct in_addr *a, char *buf, size_t len) {
497 return inet_ntop(AF_INET, a, buf, len);
498 }
499
500 const char* typesafe_inet_ntop6(const struct in6_addr *a, char *buf, size_t len) {
501 return inet_ntop(AF_INET6, a, buf, len);
502 }
503
504 int in_addr_prefix_to_string(
505 int family,
506 const union in_addr_union *u,
507 unsigned prefixlen,
508 char *buf,
509 size_t buf_len) {
510
511 assert(u);
512 assert(buf);
513
514 if (!IN_SET(family, AF_INET, AF_INET6))
515 return -EAFNOSUPPORT;
516
517 errno = 0;
518 if (!typesafe_inet_ntop(family, u, buf, buf_len))
519 return errno_or_else(ENOSPC);
520
521 size_t l = strlen(buf);
522 if (!snprintf_ok(buf + l, buf_len - l, "/%u", prefixlen))
523 return -ENOSPC;
524 return 0;
525 }
526
527 int in_addr_port_ifindex_name_to_string(int family, const union in_addr_union *u, uint16_t port, int ifindex, const char *server_name, char **ret) {
528 _cleanup_free_ char *ip_str = NULL, *x = NULL;
529 int r;
530
531 assert(IN_SET(family, AF_INET, AF_INET6));
532 assert(u);
533 assert(ret);
534
535 /* Much like in_addr_to_string(), but optionally appends the zone interface index to the address, to properly
536 * handle IPv6 link-local addresses. */
537
538 r = in_addr_to_string(family, u, &ip_str);
539 if (r < 0)
540 return r;
541
542 if (family == AF_INET6) {
543 r = in_addr_is_link_local(family, u);
544 if (r < 0)
545 return r;
546 if (r == 0)
547 ifindex = 0;
548 } else
549 ifindex = 0; /* For IPv4 address, ifindex is always ignored. */
550
551 if (port == 0 && ifindex == 0 && isempty(server_name)) {
552 *ret = TAKE_PTR(ip_str);
553 return 0;
554 }
555
556 const char *separator = isempty(server_name) ? "" : "#";
557 server_name = strempty(server_name);
558
559 if (port > 0) {
560 if (family == AF_INET6) {
561 if (ifindex > 0)
562 x = asprintf_safe("[%s]:%"PRIu16"%%%i%s%s", ip_str, port, ifindex, separator, server_name);
563 else
564 x = asprintf_safe("[%s]:%"PRIu16"%s%s", ip_str, port, separator, server_name);
565 } else
566 x = asprintf_safe("%s:%"PRIu16"%s%s", ip_str, port, separator, server_name);
567 } else {
568 if (ifindex > 0)
569 x = asprintf_safe("%s%%%i%s%s", ip_str, ifindex, separator, server_name);
570 else
571 x = strjoin(ip_str, separator, server_name);
572 }
573 if (!x)
574 return -ENOMEM;
575
576 *ret = TAKE_PTR(x);
577 return 0;
578 }
579
580 int in_addr_from_string(int family, const char *s, union in_addr_union *ret) {
581 union in_addr_union buffer;
582 assert(s);
583
584 if (!IN_SET(family, AF_INET, AF_INET6))
585 return -EAFNOSUPPORT;
586
587 errno = 0;
588 if (inet_pton(family, s, ret ?: &buffer) <= 0)
589 return errno_or_else(EINVAL);
590
591 return 0;
592 }
593
594 int in_addr_from_string_auto(const char *s, int *ret_family, union in_addr_union *ret) {
595 int r;
596
597 assert(s);
598
599 r = in_addr_from_string(AF_INET, s, ret);
600 if (r >= 0) {
601 if (ret_family)
602 *ret_family = AF_INET;
603 return 0;
604 }
605
606 r = in_addr_from_string(AF_INET6, s, ret);
607 if (r >= 0) {
608 if (ret_family)
609 *ret_family = AF_INET6;
610 return 0;
611 }
612
613 return -EINVAL;
614 }
615
616 unsigned char in4_addr_netmask_to_prefixlen(const struct in_addr *addr) {
617 assert(addr);
618
619 return 32U - u32ctz(be32toh(addr->s_addr));
620 }
621
622 /* Calculate an IPv4 netmask from prefix length, for example /8 -> 255.0.0.0. */
623 struct in_addr* in4_addr_prefixlen_to_netmask(struct in_addr *addr, unsigned char prefixlen) {
624 assert(addr);
625 assert(prefixlen <= 32);
626
627 /* Shifting beyond 32 is not defined, handle this specially. */
628 if (prefixlen == 0)
629 addr->s_addr = 0;
630 else
631 addr->s_addr = htobe32((0xffffffff << (32 - prefixlen)) & 0xffffffff);
632
633 return addr;
634 }
635
636 /* Calculate an IPv6 netmask from prefix length, for example /16 -> ffff::. */
637 struct in6_addr* in6_addr_prefixlen_to_netmask(struct in6_addr *addr, unsigned char prefixlen) {
638 assert(addr);
639 assert(prefixlen <= 128);
640
641 for (unsigned i = 0; i < 16; i++) {
642 uint8_t mask;
643
644 if (prefixlen >= 8) {
645 mask = 0xFF;
646 prefixlen -= 8;
647 } else if (prefixlen > 0) {
648 mask = 0xFF << (8 - prefixlen);
649 prefixlen = 0;
650 } else {
651 assert(prefixlen == 0);
652 mask = 0;
653 }
654
655 addr->s6_addr[i] = mask;
656 }
657
658 return addr;
659 }
660
661 /* Calculate an IPv4 or IPv6 netmask from prefix length, for example /8 -> 255.0.0.0 or /16 -> ffff::. */
662 int in_addr_prefixlen_to_netmask(int family, union in_addr_union *addr, unsigned char prefixlen) {
663 assert(addr);
664
665 switch (family) {
666 case AF_INET:
667 in4_addr_prefixlen_to_netmask(&addr->in, prefixlen);
668 return 0;
669 case AF_INET6:
670 in6_addr_prefixlen_to_netmask(&addr->in6, prefixlen);
671 return 0;
672 default:
673 return -EAFNOSUPPORT;
674 }
675 }
676
677 int in4_addr_default_prefixlen(const struct in_addr *addr, unsigned char *prefixlen) {
678 uint8_t msb_octet = *(uint8_t*) addr;
679
680 /* addr may not be aligned, so make sure we only access it byte-wise */
681
682 assert(addr);
683 assert(prefixlen);
684
685 if (msb_octet < 128)
686 /* class A, leading bits: 0 */
687 *prefixlen = 8;
688 else if (msb_octet < 192)
689 /* class B, leading bits 10 */
690 *prefixlen = 16;
691 else if (msb_octet < 224)
692 /* class C, leading bits 110 */
693 *prefixlen = 24;
694 else
695 /* class D or E, no default prefixlen */
696 return -ERANGE;
697
698 return 0;
699 }
700
701 int in4_addr_default_subnet_mask(const struct in_addr *addr, struct in_addr *mask) {
702 unsigned char prefixlen;
703 int r;
704
705 assert(addr);
706 assert(mask);
707
708 r = in4_addr_default_prefixlen(addr, &prefixlen);
709 if (r < 0)
710 return r;
711
712 in4_addr_prefixlen_to_netmask(mask, prefixlen);
713 return 0;
714 }
715
716 int in4_addr_mask(struct in_addr *addr, unsigned char prefixlen) {
717 struct in_addr mask;
718
719 assert(addr);
720
721 if (!in4_addr_prefixlen_to_netmask(&mask, prefixlen))
722 return -EINVAL;
723
724 addr->s_addr &= mask.s_addr;
725 return 0;
726 }
727
728 int in6_addr_mask(struct in6_addr *addr, unsigned char prefixlen) {
729 unsigned i;
730
731 for (i = 0; i < 16; i++) {
732 uint8_t mask;
733
734 if (prefixlen >= 8) {
735 mask = 0xFF;
736 prefixlen -= 8;
737 } else if (prefixlen > 0) {
738 mask = 0xFF << (8 - prefixlen);
739 prefixlen = 0;
740 } else {
741 assert(prefixlen == 0);
742 mask = 0;
743 }
744
745 addr->s6_addr[i] &= mask;
746 }
747
748 return 0;
749 }
750
751 int in_addr_mask(int family, union in_addr_union *addr, unsigned char prefixlen) {
752 assert(addr);
753
754 switch (family) {
755 case AF_INET:
756 return in4_addr_mask(&addr->in, prefixlen);
757 case AF_INET6:
758 return in6_addr_mask(&addr->in6, prefixlen);
759 default:
760 return -EAFNOSUPPORT;
761 }
762 }
763
764 int in4_addr_prefix_covers_full(
765 const struct in_addr *prefix,
766 unsigned char prefixlen,
767 const struct in_addr *address,
768 unsigned char address_prefixlen) {
769
770 struct in_addr masked_prefix, masked_address;
771 int r;
772
773 assert(prefix);
774 assert(address);
775
776 if (prefixlen > address_prefixlen)
777 return false;
778
779 masked_prefix = *prefix;
780 r = in4_addr_mask(&masked_prefix, prefixlen);
781 if (r < 0)
782 return r;
783
784 masked_address = *address;
785 r = in4_addr_mask(&masked_address, prefixlen);
786 if (r < 0)
787 return r;
788
789 return in4_addr_equal(&masked_prefix, &masked_address);
790 }
791
792 int in6_addr_prefix_covers_full(
793 const struct in6_addr *prefix,
794 unsigned char prefixlen,
795 const struct in6_addr *address,
796 unsigned char address_prefixlen) {
797
798 struct in6_addr masked_prefix, masked_address;
799 int r;
800
801 assert(prefix);
802 assert(address);
803
804 if (prefixlen > address_prefixlen)
805 return false;
806
807 masked_prefix = *prefix;
808 r = in6_addr_mask(&masked_prefix, prefixlen);
809 if (r < 0)
810 return r;
811
812 masked_address = *address;
813 r = in6_addr_mask(&masked_address, prefixlen);
814 if (r < 0)
815 return r;
816
817 return in6_addr_equal(&masked_prefix, &masked_address);
818 }
819
820 int in_addr_prefix_covers_full(
821 int family,
822 const union in_addr_union *prefix,
823 unsigned char prefixlen,
824 const union in_addr_union *address,
825 unsigned char address_prefixlen) {
826
827 assert(prefix);
828 assert(address);
829
830 switch (family) {
831 case AF_INET:
832 return in4_addr_prefix_covers_full(&prefix->in, prefixlen, &address->in, address_prefixlen);
833 case AF_INET6:
834 return in6_addr_prefix_covers_full(&prefix->in6, prefixlen, &address->in6, address_prefixlen);
835 default:
836 return -EAFNOSUPPORT;
837 }
838 }
839
840 int in_addr_parse_prefixlen(int family, const char *p, unsigned char *ret) {
841 uint8_t u;
842 int r;
843
844 assert(ret);
845
846 if (!IN_SET(family, AF_INET, AF_INET6))
847 return -EAFNOSUPPORT;
848
849 r = safe_atou8(p, &u);
850 if (r < 0)
851 return r;
852
853 if (u > FAMILY_ADDRESS_SIZE(family) * 8)
854 return -ERANGE;
855
856 *ret = u;
857 return 0;
858 }
859
860 int in_addr_prefix_from_string(
861 const char *p,
862 int family,
863 union in_addr_union *ret_prefix,
864 unsigned char *ret_prefixlen) {
865
866 _cleanup_free_ char *str = NULL;
867 union in_addr_union buffer;
868 const char *e, *l;
869 unsigned char k;
870 int r;
871
872 assert(p);
873
874 if (!IN_SET(family, AF_INET, AF_INET6))
875 return -EAFNOSUPPORT;
876
877 e = strchr(p, '/');
878 if (e) {
879 str = strndup(p, e - p);
880 if (!str)
881 return -ENOMEM;
882
883 l = str;
884 } else
885 l = p;
886
887 r = in_addr_from_string(family, l, &buffer);
888 if (r < 0)
889 return r;
890
891 if (e) {
892 r = in_addr_parse_prefixlen(family, e+1, &k);
893 if (r < 0)
894 return r;
895 } else
896 k = FAMILY_ADDRESS_SIZE(family) * 8;
897
898 if (ret_prefix)
899 *ret_prefix = buffer;
900 if (ret_prefixlen)
901 *ret_prefixlen = k;
902
903 return 0;
904 }
905
906 int in_addr_prefix_from_string_auto_full(
907 const char *p,
908 InAddrPrefixLenMode mode,
909 int *ret_family,
910 union in_addr_union *ret_prefix,
911 unsigned char *ret_prefixlen) {
912
913 _cleanup_free_ char *str = NULL;
914 union in_addr_union buffer;
915 const char *e, *l;
916 unsigned char k;
917 int family, r;
918
919 assert(p);
920
921 e = strchr(p, '/');
922 if (e) {
923 str = strndup(p, e - p);
924 if (!str)
925 return -ENOMEM;
926
927 l = str;
928 } else
929 l = p;
930
931 r = in_addr_from_string_auto(l, &family, &buffer);
932 if (r < 0)
933 return r;
934
935 if (e) {
936 r = in_addr_parse_prefixlen(family, e+1, &k);
937 if (r < 0)
938 return r;
939 } else
940 switch (mode) {
941 case PREFIXLEN_FULL:
942 k = FAMILY_ADDRESS_SIZE(family) * 8;
943 break;
944 case PREFIXLEN_REFUSE:
945 return -ENOANO; /* To distinguish this error from others. */
946 default:
947 assert_not_reached();
948 }
949
950 if (ret_family)
951 *ret_family = family;
952 if (ret_prefix)
953 *ret_prefix = buffer;
954 if (ret_prefixlen)
955 *ret_prefixlen = k;
956
957 return 0;
958 }
959
960 void in_addr_hash_func(const union in_addr_union *u, int family, struct siphash *state) {
961 assert(u);
962 assert(state);
963
964 siphash24_compress(u->bytes, FAMILY_ADDRESS_SIZE(family), state);
965 }
966
967 void in_addr_data_hash_func(const struct in_addr_data *a, struct siphash *state) {
968 assert(a);
969 assert(state);
970
971 siphash24_compress_typesafe(a->family, state);
972 in_addr_hash_func(&a->address, a->family, state);
973 }
974
975 int in_addr_data_compare_func(const struct in_addr_data *x, const struct in_addr_data *y) {
976 int r;
977
978 assert(x);
979 assert(y);
980
981 r = CMP(x->family, y->family);
982 if (r != 0)
983 return r;
984
985 return memcmp(&x->address, &y->address, FAMILY_ADDRESS_SIZE(x->family));
986 }
987
988 DEFINE_HASH_OPS(
989 in_addr_data_hash_ops,
990 struct in_addr_data,
991 in_addr_data_hash_func,
992 in_addr_data_compare_func);
993
994 DEFINE_HASH_OPS_WITH_KEY_DESTRUCTOR(
995 in_addr_data_hash_ops_free,
996 struct in_addr_data,
997 in_addr_data_hash_func,
998 in_addr_data_compare_func,
999 free);
1000
1001 void in6_addr_hash_func(const struct in6_addr *addr, struct siphash *state) {
1002 assert(addr);
1003 assert(state);
1004
1005 siphash24_compress_typesafe(*addr, state);
1006 }
1007
1008 int in6_addr_compare_func(const struct in6_addr *a, const struct in6_addr *b) {
1009 assert(a);
1010 assert(b);
1011
1012 return memcmp(a, b, sizeof(*a));
1013 }
1014
1015 DEFINE_HASH_OPS(
1016 in6_addr_hash_ops,
1017 struct in6_addr,
1018 in6_addr_hash_func,
1019 in6_addr_compare_func);
1020
1021 DEFINE_HASH_OPS_WITH_KEY_DESTRUCTOR(
1022 in6_addr_hash_ops_free,
1023 struct in6_addr,
1024 in6_addr_hash_func,
1025 in6_addr_compare_func,
1026 free);