1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 Copyright 2014 Lennart Poettering
13 #include "alloc-util.h"
14 #include "in-addr-util.h"
16 #include "parse-util.h"
19 bool in4_addr_is_null(const struct in_addr
*a
) {
22 return a
->s_addr
== 0;
25 int in_addr_is_null(int family
, const union in_addr_union
*u
) {
28 if (family
== AF_INET
)
29 return in4_addr_is_null(&u
->in
);
31 if (family
== AF_INET6
)
32 return IN6_IS_ADDR_UNSPECIFIED(&u
->in6
);
37 bool in4_addr_is_link_local(const struct in_addr
*a
) {
40 return (be32toh(a
->s_addr
) & UINT32_C(0xFFFF0000)) == (UINT32_C(169) << 24 | UINT32_C(254) << 16);
43 int in_addr_is_link_local(int family
, const union in_addr_union
*u
) {
46 if (family
== AF_INET
)
47 return in4_addr_is_link_local(&u
->in
);
49 if (family
== AF_INET6
)
50 return IN6_IS_ADDR_LINKLOCAL(&u
->in6
);
55 int in_addr_is_multicast(int family
, const union in_addr_union
*u
) {
58 if (family
== AF_INET
)
59 return IN_MULTICAST(be32toh(u
->in
.s_addr
));
61 if (family
== AF_INET6
)
62 return IN6_IS_ADDR_MULTICAST(&u
->in6
);
67 bool in4_addr_is_localhost(const struct in_addr
*a
) {
70 /* All of 127.x.x.x is localhost. */
71 return (be32toh(a
->s_addr
) & UINT32_C(0xFF000000)) == UINT32_C(127) << 24;
74 int in_addr_is_localhost(int family
, const union in_addr_union
*u
) {
77 if (family
== AF_INET
)
78 return in4_addr_is_localhost(&u
->in
);
80 if (family
== AF_INET6
)
81 return IN6_IS_ADDR_LOOPBACK(&u
->in6
);
86 int in_addr_equal(int family
, const union in_addr_union
*a
, const union in_addr_union
*b
) {
90 if (family
== AF_INET
)
91 return a
->in
.s_addr
== b
->in
.s_addr
;
93 if (family
== AF_INET6
)
95 a
->in6
.s6_addr32
[0] == b
->in6
.s6_addr32
[0] &&
96 a
->in6
.s6_addr32
[1] == b
->in6
.s6_addr32
[1] &&
97 a
->in6
.s6_addr32
[2] == b
->in6
.s6_addr32
[2] &&
98 a
->in6
.s6_addr32
[3] == b
->in6
.s6_addr32
[3];
100 return -EAFNOSUPPORT
;
103 int in_addr_prefix_intersect(
105 const union in_addr_union
*a
,
107 const union in_addr_union
*b
,
108 unsigned bprefixlen
) {
115 /* Checks whether there are any addresses that are in both
118 m
= MIN(aprefixlen
, bprefixlen
);
120 if (family
== AF_INET
) {
123 x
= be32toh(a
->in
.s_addr
^ b
->in
.s_addr
);
124 nm
= (m
== 0) ? 0 : 0xFFFFFFFFUL
<< (32 - m
);
126 return (x
& nm
) == 0;
129 if (family
== AF_INET6
) {
135 for (i
= 0; i
< 16; i
++) {
138 x
= a
->in6
.s6_addr
[i
] ^ b
->in6
.s6_addr
[i
];
141 nm
= 0xFF << (8 - m
);
157 return -EAFNOSUPPORT
;
160 int in_addr_prefix_next(int family
, union in_addr_union
*u
, unsigned prefixlen
) {
163 /* Increases the network part of an address by one. Returns
164 * positive it that succeeds, or 0 if this overflows. */
169 if (family
== AF_INET
) {
175 c
= be32toh(u
->in
.s_addr
);
176 n
= c
+ (1UL << (32 - prefixlen
));
179 n
&= 0xFFFFFFFFUL
<< (32 - prefixlen
);
181 u
->in
.s_addr
= htobe32(n
);
185 if (family
== AF_INET6
) {
186 struct in6_addr add
= {}, result
;
187 uint8_t overflow
= 0;
193 /* First calculate what we have to add */
194 add
.s6_addr
[(prefixlen
-1) / 8] = 1 << (7 - (prefixlen
-1) % 8);
196 for (i
= 16; i
> 0; i
--) {
199 result
.s6_addr
[j
] = u
->in6
.s6_addr
[j
] + add
.s6_addr
[j
] + overflow
;
200 overflow
= (result
.s6_addr
[j
] < u
->in6
.s6_addr
[j
]);
210 return -EAFNOSUPPORT
;
213 int in_addr_to_string(int family
, const union in_addr_union
*u
, char **ret
) {
220 if (family
== AF_INET
)
222 else if (family
== AF_INET6
)
223 l
= INET6_ADDRSTRLEN
;
225 return -EAFNOSUPPORT
;
232 if (!inet_ntop(family
, u
, x
, l
)) {
234 return errno
> 0 ? -errno
: -EINVAL
;
241 int in_addr_ifindex_to_string(int family
, const union in_addr_union
*u
, int ifindex
, char **ret
) {
249 /* Much like in_addr_to_string(), but optionally appends the zone interface index to the address, to properly
250 * handle IPv6 link-local addresses. */
252 if (family
!= AF_INET6
)
257 r
= in_addr_is_link_local(family
, u
);
263 l
= INET6_ADDRSTRLEN
+ 1 + DECIMAL_STR_MAX(ifindex
) + 1;
269 if (!inet_ntop(family
, u
, x
, l
)) {
271 return errno
> 0 ? -errno
: -EINVAL
;
274 sprintf(strchr(x
, 0), "%%%i", ifindex
);
280 return in_addr_to_string(family
, u
, ret
);
283 int in_addr_from_string(int family
, const char *s
, union in_addr_union
*ret
) {
284 union in_addr_union buffer
;
287 if (!IN_SET(family
, AF_INET
, AF_INET6
))
288 return -EAFNOSUPPORT
;
291 if (inet_pton(family
, s
, ret
?: &buffer
) <= 0)
292 return errno
> 0 ? -errno
: -EINVAL
;
297 int in_addr_from_string_auto(const char *s
, int *ret_family
, union in_addr_union
*ret
) {
302 r
= in_addr_from_string(AF_INET
, s
, ret
);
305 *ret_family
= AF_INET
;
309 r
= in_addr_from_string(AF_INET6
, s
, ret
);
312 *ret_family
= AF_INET6
;
319 int in_addr_ifindex_from_string_auto(const char *s
, int *family
, union in_addr_union
*ret
, int *ifindex
) {
327 /* Similar to in_addr_from_string_auto() but also parses an optionally appended IPv6 zone suffix ("scope id")
328 * if one is found. */
330 suffix
= strchr(s
, '%');
334 /* If we shall return the interface index, try to parse it */
335 r
= parse_ifindex(suffix
+ 1, &ifi
);
339 u
= if_nametoindex(suffix
+ 1);
347 s
= strndupa(s
, suffix
- s
);
350 r
= in_addr_from_string_auto(s
, family
, ret
);
360 unsigned char in4_addr_netmask_to_prefixlen(const struct in_addr
*addr
) {
363 return 32 - u32ctz(be32toh(addr
->s_addr
));
366 struct in_addr
* in4_addr_prefixlen_to_netmask(struct in_addr
*addr
, unsigned char prefixlen
) {
368 assert(prefixlen
<= 32);
370 /* Shifting beyond 32 is not defined, handle this specially. */
374 addr
->s_addr
= htobe32((0xffffffff << (32 - prefixlen
)) & 0xffffffff);
379 int in4_addr_default_prefixlen(const struct in_addr
*addr
, unsigned char *prefixlen
) {
380 uint8_t msb_octet
= *(uint8_t*) addr
;
382 /* addr may not be aligned, so make sure we only access it byte-wise */
388 /* class A, leading bits: 0 */
390 else if (msb_octet
< 192)
391 /* class B, leading bits 10 */
393 else if (msb_octet
< 224)
394 /* class C, leading bits 110 */
397 /* class D or E, no default prefixlen */
403 int in4_addr_default_subnet_mask(const struct in_addr
*addr
, struct in_addr
*mask
) {
404 unsigned char prefixlen
;
410 r
= in4_addr_default_prefixlen(addr
, &prefixlen
);
414 in4_addr_prefixlen_to_netmask(mask
, prefixlen
);
418 int in_addr_mask(int family
, union in_addr_union
*addr
, unsigned char prefixlen
) {
421 if (family
== AF_INET
) {
424 if (!in4_addr_prefixlen_to_netmask(&mask
, prefixlen
))
427 addr
->in
.s_addr
&= mask
.s_addr
;
431 if (family
== AF_INET6
) {
434 for (i
= 0; i
< 16; i
++) {
437 if (prefixlen
>= 8) {
441 mask
= 0xFF << (8 - prefixlen
);
445 addr
->in6
.s6_addr
[i
] &= mask
;
451 return -EAFNOSUPPORT
;
454 int in_addr_prefix_covers(int family
,
455 const union in_addr_union
*prefix
,
456 unsigned char prefixlen
,
457 const union in_addr_union
*address
) {
459 union in_addr_union masked_prefix
, masked_address
;
465 masked_prefix
= *prefix
;
466 r
= in_addr_mask(family
, &masked_prefix
, prefixlen
);
470 masked_address
= *address
;
471 r
= in_addr_mask(family
, &masked_address
, prefixlen
);
475 return in_addr_equal(family
, &masked_prefix
, &masked_address
);
478 int in_addr_parse_prefixlen(int family
, const char *p
, unsigned char *ret
) {
482 if (!IN_SET(family
, AF_INET
, AF_INET6
))
483 return -EAFNOSUPPORT
;
485 r
= safe_atou8(p
, &u
);
489 if (u
> FAMILY_ADDRESS_SIZE(family
) * 8)
496 int in_addr_prefix_from_string(
499 union in_addr_union
*ret_prefix
,
500 unsigned char *ret_prefixlen
) {
502 union in_addr_union buffer
;
509 if (!IN_SET(family
, AF_INET
, AF_INET6
))
510 return -EAFNOSUPPORT
;
514 l
= strndupa(p
, e
- p
);
518 r
= in_addr_from_string(family
, l
, &buffer
);
523 r
= in_addr_parse_prefixlen(family
, e
+1, &k
);
527 k
= FAMILY_ADDRESS_SIZE(family
) * 8;
530 *ret_prefix
= buffer
;
537 int in_addr_prefix_from_string_auto(
540 union in_addr_union
*ret_prefix
,
541 unsigned char *ret_prefixlen
) {
543 union in_addr_union buffer
;
552 l
= strndupa(p
, e
- p
);
556 r
= in_addr_from_string_auto(l
, &family
, &buffer
);
561 r
= in_addr_parse_prefixlen(family
, e
+1, &k
);
565 k
= FAMILY_ADDRESS_SIZE(family
) * 8;
568 *ret_family
= family
;
570 *ret_prefix
= buffer
;