src/basic/in-addr-util.c

   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                                 r = asprintf(&x, "[%s]:%"PRIu16"%%%i%s%s", ip_str, port, ifindex, separator, server_name);
 563                         else
 564                                 r = asprintf(&x, "[%s]:%"PRIu16"%s%s", ip_str, port, separator, server_name);
 565                 } else
 566                         r = asprintf(&x, "%s:%"PRIu16"%s%s", ip_str, port, separator, server_name);
 567         } else {
 568                 if (ifindex > 0)
 569                         r = asprintf(&x, "%s%%%i%s%s", ip_str, ifindex, separator, server_name);
 570                 else {
 571                         x = strjoin(ip_str, separator, server_name);
 572                         r = x ? 0 : -ENOMEM;
 573                 }
 574         }
 575         if (r < 0)
 576                 return -ENOMEM;
 577
 578         *ret = TAKE_PTR(x);
 579         return 0;
 580 }
 581
 582 int in_addr_from_string(int family, const char *s, union in_addr_union *ret) {
 583         union in_addr_union buffer;
 584         assert(s);
 585
 586         if (!IN_SET(family, AF_INET, AF_INET6))
 587                 return -EAFNOSUPPORT;
 588
 589         errno = 0;
 590         if (inet_pton(family, s, ret ?: &buffer) <= 0)
 591                 return errno_or_else(EINVAL);
 592
 593         return 0;
 594 }
 595
 596 int in_addr_from_string_auto(const char *s, int *ret_family, union in_addr_union *ret) {
 597         int r;
 598
 599         assert(s);
 600
 601         r = in_addr_from_string(AF_INET, s, ret);
 602         if (r >= 0) {
 603                 if (ret_family)
 604                         *ret_family = AF_INET;
 605                 return 0;
 606         }
 607
 608         r = in_addr_from_string(AF_INET6, s, ret);
 609         if (r >= 0) {
 610                 if (ret_family)
 611                         *ret_family = AF_INET6;
 612                 return 0;
 613         }
 614
 615         return -EINVAL;
 616 }
 617
 618 unsigned char in4_addr_netmask_to_prefixlen(const struct in_addr *addr) {
 619         assert(addr);
 620
 621         return 32U - u32ctz(be32toh(addr->s_addr));
 622 }
 623
 624 /* Calculate an IPv4 netmask from prefix length, for example /8 -> 255.0.0.0. */
 625 struct in_addr* in4_addr_prefixlen_to_netmask(struct in_addr *addr, unsigned char prefixlen) {
 626         assert(addr);
 627         assert(prefixlen <= 32);
 628
 629         /* Shifting beyond 32 is not defined, handle this specially. */
 630         if (prefixlen == 0)
 631                 addr->s_addr = 0;
 632         else
 633                 addr->s_addr = htobe32((0xffffffff << (32 - prefixlen)) & 0xffffffff);
 634
 635         return addr;
 636 }
 637
 638 /* Calculate an IPv6 netmask from prefix length, for example /16 -> ffff::. */
 639 struct in6_addr* in6_addr_prefixlen_to_netmask(struct in6_addr *addr, unsigned char prefixlen) {
 640         assert(addr);
 641         assert(prefixlen <= 128);
 642
 643         for (unsigned i = 0; i < 16; i++) {
 644                 uint8_t mask;
 645
 646                 if (prefixlen >= 8) {
 647                         mask = 0xFF;
 648                         prefixlen -= 8;
 649                 } else if (prefixlen > 0) {
 650                         mask = 0xFF << (8 - prefixlen);
 651                         prefixlen = 0;
 652                 } else {
 653                         assert(prefixlen == 0);
 654                         mask = 0;
 655                 }
 656
 657                 addr->s6_addr[i] = mask;
 658         }
 659
 660         return addr;
 661 }
 662
 663 /* Calculate an IPv4 or IPv6 netmask from prefix length, for example /8 -> 255.0.0.0 or /16 -> ffff::. */
 664 int in_addr_prefixlen_to_netmask(int family, union in_addr_union *addr, unsigned char prefixlen) {
 665         assert(addr);
 666
 667         switch (family) {
 668         case AF_INET:
 669                 in4_addr_prefixlen_to_netmask(&addr->in, prefixlen);
 670                 return 0;
 671         case AF_INET6:
 672                 in6_addr_prefixlen_to_netmask(&addr->in6, prefixlen);
 673                 return 0;
 674         default:
 675                 return -EAFNOSUPPORT;
 676         }
 677 }
 678
 679 int in4_addr_default_prefixlen(const struct in_addr *addr, unsigned char *prefixlen) {
 680         uint8_t msb_octet = *(uint8_t*) addr;
 681
 682         /* addr may not be aligned, so make sure we only access it byte-wise */
 683
 684         assert(addr);
 685         assert(prefixlen);
 686
 687         if (msb_octet < 128)
 688                 /* class A, leading bits: 0 */
 689                 *prefixlen = 8;
 690         else if (msb_octet < 192)
 691                 /* class B, leading bits 10 */
 692                 *prefixlen = 16;
 693         else if (msb_octet < 224)
 694                 /* class C, leading bits 110 */
 695                 *prefixlen = 24;
 696         else
 697                 /* class D or E, no default prefixlen */
 698                 return -ERANGE;
 699
 700         return 0;
 701 }
 702
 703 int in4_addr_default_subnet_mask(const struct in_addr *addr, struct in_addr *mask) {
 704         unsigned char prefixlen;
 705         int r;
 706
 707         assert(addr);
 708         assert(mask);
 709
 710         r = in4_addr_default_prefixlen(addr, &prefixlen);
 711         if (r < 0)
 712                 return r;
 713
 714         in4_addr_prefixlen_to_netmask(mask, prefixlen);
 715         return 0;
 716 }
 717
 718 int in4_addr_mask(struct in_addr *addr, unsigned char prefixlen) {
 719         struct in_addr mask;
 720
 721         assert(addr);
 722
 723         if (!in4_addr_prefixlen_to_netmask(&mask, prefixlen))
 724                 return -EINVAL;
 725
 726         addr->s_addr &= mask.s_addr;
 727         return 0;
 728 }
 729
 730 int in6_addr_mask(struct in6_addr *addr, unsigned char prefixlen) {
 731         unsigned i;
 732
 733         for (i = 0; i < 16; i++) {
 734                 uint8_t mask;
 735
 736                 if (prefixlen >= 8) {
 737                         mask = 0xFF;
 738                         prefixlen -= 8;
 739                 } else if (prefixlen > 0) {
 740                         mask = 0xFF << (8 - prefixlen);
 741                         prefixlen = 0;
 742                 } else {
 743                         assert(prefixlen == 0);
 744                         mask = 0;
 745                 }
 746
 747                 addr->s6_addr[i] &= mask;
 748         }
 749
 750         return 0;
 751 }
 752
 753 int in_addr_mask(int family, union in_addr_union *addr, unsigned char prefixlen) {
 754         assert(addr);
 755
 756         switch (family) {
 757         case AF_INET:
 758                 return in4_addr_mask(&addr->in, prefixlen);
 759         case AF_INET6:
 760                 return in6_addr_mask(&addr->in6, prefixlen);
 761         default:
 762                 return -EAFNOSUPPORT;
 763         }
 764 }
 765
 766 int in4_addr_prefix_covers_full(
 767                 const struct in_addr *prefix,
 768                 unsigned char prefixlen,
 769                 const struct in_addr *address,
 770                 unsigned char address_prefixlen) {
 771
 772         struct in_addr masked_prefix, masked_address;
 773         int r;
 774
 775         assert(prefix);
 776         assert(address);
 777
 778         if (prefixlen > address_prefixlen)
 779                 return false;
 780
 781         masked_prefix = *prefix;
 782         r = in4_addr_mask(&masked_prefix, prefixlen);
 783         if (r < 0)
 784                 return r;
 785
 786         masked_address = *address;
 787         r = in4_addr_mask(&masked_address, prefixlen);
 788         if (r < 0)
 789                 return r;
 790
 791         return in4_addr_equal(&masked_prefix, &masked_address);
 792 }
 793
 794 int in6_addr_prefix_covers_full(
 795                 const struct in6_addr *prefix,
 796                 unsigned char prefixlen,
 797                 const struct in6_addr *address,
 798                 unsigned char address_prefixlen) {
 799
 800         struct in6_addr masked_prefix, masked_address;
 801         int r;
 802
 803         assert(prefix);
 804         assert(address);
 805
 806         if (prefixlen > address_prefixlen)
 807                 return false;
 808
 809         masked_prefix = *prefix;
 810         r = in6_addr_mask(&masked_prefix, prefixlen);
 811         if (r < 0)
 812                 return r;
 813
 814         masked_address = *address;
 815         r = in6_addr_mask(&masked_address, prefixlen);
 816         if (r < 0)
 817                 return r;
 818
 819         return in6_addr_equal(&masked_prefix, &masked_address);
 820 }
 821
 822 int in_addr_prefix_covers_full(
 823                 int family,
 824                 const union in_addr_union *prefix,
 825                 unsigned char prefixlen,
 826                 const union in_addr_union *address,
 827                 unsigned char address_prefixlen) {
 828
 829         assert(prefix);
 830         assert(address);
 831
 832         switch (family) {
 833         case AF_INET:
 834                 return in4_addr_prefix_covers_full(&prefix->in, prefixlen, &address->in, address_prefixlen);
 835         case AF_INET6:
 836                 return in6_addr_prefix_covers_full(&prefix->in6, prefixlen, &address->in6, address_prefixlen);
 837         default:
 838                 return -EAFNOSUPPORT;
 839         }
 840 }
 841
 842 int in_addr_parse_prefixlen(int family, const char *p, unsigned char *ret) {
 843         uint8_t u;
 844         int r;
 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);