src/network/networkd-address.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <net/if.h>
   4
   5 #include "alloc-util.h"
   6 #include "conf-parser.h"
   7 #include "firewall-util.h"
   8 #include "netlink-util.h"
   9 #include "networkd-address.h"
  10 #include "networkd-manager.h"
  11 #include "parse-util.h"
  12 #include "set.h"
  13 #include "socket-util.h"
  14 #include "string-util.h"
  15 #include "strv.h"
  16 #include "utf8.h"
  17 #include "util.h"
  18
  19 #define ADDRESSES_PER_LINK_MAX 2048U
  20 #define STATIC_ADDRESSES_PER_NETWORK_MAX 1024U
  21
  22 int address_new(Address **ret) {
  23         _cleanup_(address_freep) Address *address = NULL;
  24
  25         address = new0(Address, 1);
  26         if (!address)
  27                 return -ENOMEM;
  28
  29         address->family = AF_UNSPEC;
  30         address->scope = RT_SCOPE_UNIVERSE;
  31         address->cinfo.ifa_prefered = CACHE_INFO_INFINITY_LIFE_TIME;
  32         address->cinfo.ifa_valid = CACHE_INFO_INFINITY_LIFE_TIME;
  33
  34         *ret = TAKE_PTR(address);
  35
  36         return 0;
  37 }
  38
  39 int address_new_static(Network *network, const char *filename, unsigned section_line, Address **ret) {
  40         _cleanup_(network_config_section_freep) NetworkConfigSection *n = NULL;
  41         _cleanup_(address_freep) Address *address = NULL;
  42         int r;
  43
  44         assert(network);
  45         assert(ret);
  46         assert(!!filename == (section_line > 0));
  47
  48         if (filename) {
  49                 r = network_config_section_new(filename, section_line, &n);
  50                 if (r < 0)
  51                         return r;
  52
  53                 address = hashmap_get(network->addresses_by_section, n);
  54                 if (address) {
  55                         *ret = TAKE_PTR(address);
  56
  57                         return 0;
  58                 }
  59         }
  60
  61         if (network->n_static_addresses >= STATIC_ADDRESSES_PER_NETWORK_MAX)
  62                 return -E2BIG;
  63
  64         r = address_new(&address);
  65         if (r < 0)
  66                 return r;
  67
  68         if (filename) {
  69                 address->section = TAKE_PTR(n);
  70
  71                 r = hashmap_put(network->addresses_by_section, address->section, address);
  72                 if (r < 0)
  73                         return r;
  74         }
  75
  76         address->network = network;
  77         LIST_APPEND(addresses, network->static_addresses, address);
  78         network->n_static_addresses++;
  79
  80         *ret = TAKE_PTR(address);
  81
  82         return 0;
  83 }
  84
  85 void address_free(Address *address) {
  86         if (!address)
  87                 return;
  88
  89         if (address->network) {
  90                 LIST_REMOVE(addresses, address->network->static_addresses, address);
  91                 assert(address->network->n_static_addresses > 0);
  92                 address->network->n_static_addresses--;
  93
  94                 if (address->section) {
  95                         hashmap_remove(address->network->addresses_by_section, address->section);
  96                         network_config_section_free(address->section);
  97                 }
  98         }
  99
 100         if (address->link) {
 101                 set_remove(address->link->addresses, address);
 102                 set_remove(address->link->addresses_foreign, address);
 103
 104                 if (in_addr_equal(AF_INET6, &address->in_addr, (const union in_addr_union *) &address->link->ipv6ll_address))
 105                         memzero(&address->link->ipv6ll_address, sizeof(struct in6_addr));
 106         }
 107
 108         free(address);
 109 }
 110
 111 static void address_hash_func(const void *b, struct siphash *state) {
 112         const Address *a = b;
 113
 114         assert(a);
 115
 116         siphash24_compress(&a->family, sizeof(a->family), state);
 117
 118         switch (a->family) {
 119         case AF_INET:
 120                 siphash24_compress(&a->prefixlen, sizeof(a->prefixlen), state);
 121
 122                 /* peer prefix */
 123                 if (a->prefixlen != 0) {
 124                         uint32_t prefix;
 125
 126                         if (a->in_addr_peer.in.s_addr != 0)
 127                                 prefix = be32toh(a->in_addr_peer.in.s_addr) >> (32 - a->prefixlen);
 128                         else
 129                                 prefix = be32toh(a->in_addr.in.s_addr) >> (32 - a->prefixlen);
 130
 131                         siphash24_compress(&prefix, sizeof(prefix), state);
 132                 }
 133
 134                 _fallthrough_;
 135         case AF_INET6:
 136                 /* local address */
 137                 siphash24_compress(&a->in_addr, FAMILY_ADDRESS_SIZE(a->family), state);
 138
 139                 break;
 140         default:
 141                 /* treat any other address family as AF_UNSPEC */
 142                 break;
 143         }
 144 }
 145
 146 static int address_compare_func(const void *c1, const void *c2) {
 147         const Address *a1 = c1, *a2 = c2;
 148         int r;
 149
 150         r = CMP(a1->family, a2->family);
 151         if (r != 0)
 152                 return r;
 153
 154         switch (a1->family) {
 155         /* use the same notion of equality as the kernel does */
 156         case AF_INET:
 157                 r = CMP(a1->prefixlen, a2->prefixlen);
 158                 if (r != 0)
 159                         return r;
 160
 161                 /* compare the peer prefixes */
 162                 if (a1->prefixlen != 0) {
 163                         /* make sure we don't try to shift by 32.
 164                          * See ISO/IEC 9899:TC3 § 6.5.7.3. */
 165                         uint32_t b1, b2;
 166
 167                         if (a1->in_addr_peer.in.s_addr != 0)
 168                                 b1 = be32toh(a1->in_addr_peer.in.s_addr) >> (32 - a1->prefixlen);
 169                         else
 170                                 b1 = be32toh(a1->in_addr.in.s_addr) >> (32 - a1->prefixlen);
 171
 172                         if (a2->in_addr_peer.in.s_addr != 0)
 173                                 b2 = be32toh(a2->in_addr_peer.in.s_addr) >> (32 - a1->prefixlen);
 174                         else
 175                                 b2 = be32toh(a2->in_addr.in.s_addr) >> (32 - a1->prefixlen);
 176
 177                         r = CMP(b1, b2);
 178                         if (r != 0)
 179                                 return r;
 180                 }
 181
 182                 _fallthrough_;
 183         case AF_INET6:
 184                 return memcmp(&a1->in_addr, &a2->in_addr, FAMILY_ADDRESS_SIZE(a1->family));
 185         default:
 186                 /* treat any other address family as AF_UNSPEC */
 187                 return 0;
 188         }
 189 }
 190
 191 static const struct hash_ops address_hash_ops = {
 192         .hash = address_hash_func,
 193         .compare = address_compare_func
 194 };
 195
 196 bool address_equal(Address *a1, Address *a2) {
 197         if (a1 == a2)
 198                 return true;
 199
 200         if (!a1 || !a2)
 201                 return false;
 202
 203         return address_compare_func(a1, a2) == 0;
 204 }
 205
 206 static int address_establish(Address *address, Link *link) {
 207         bool masq;
 208         int r;
 209
 210         assert(address);
 211         assert(link);
 212
 213         masq = link->network &&
 214                link->network->ip_masquerade &&
 215                address->family == AF_INET &&
 216                address->scope < RT_SCOPE_LINK;
 217
 218         /* Add firewall entry if this is requested */
 219         if (address->ip_masquerade_done != masq) {
 220                 union in_addr_union masked = address->in_addr;
 221                 in_addr_mask(address->family, &masked, address->prefixlen);
 222
 223                 r = fw_add_masquerade(masq, AF_INET, 0, &masked, address->prefixlen, NULL, NULL, 0);
 224                 if (r < 0)
 225                         log_link_warning_errno(link, r, "Could not enable IP masquerading: %m");
 226
 227                 address->ip_masquerade_done = masq;
 228         }
 229
 230         return 0;
 231 }
 232
 233 static int address_add_internal(Link *link, Set **addresses,
 234                                 int family,
 235                                 const union in_addr_union *in_addr,
 236                                 unsigned char prefixlen,
 237                                 Address **ret) {
 238         _cleanup_(address_freep) Address *address = NULL;
 239         int r;
 240
 241         assert(link);
 242         assert(addresses);
 243         assert(in_addr);
 244
 245         r = address_new(&address);
 246         if (r < 0)
 247                 return r;
 248
 249         address->family = family;
 250         address->in_addr = *in_addr;
 251         address->prefixlen = prefixlen;
 252         /* Consider address tentative until we get the real flags from the kernel */
 253         address->flags = IFA_F_TENTATIVE;
 254
 255         r = set_ensure_allocated(addresses, &address_hash_ops);
 256         if (r < 0)
 257                 return r;
 258
 259         r = set_put(*addresses, address);
 260         if (r < 0)
 261                 return r;
 262
 263         address->link = link;
 264
 265         if (ret)
 266                 *ret = address;
 267
 268         address = NULL;
 269
 270         return 0;
 271 }
 272
 273 int address_add_foreign(Link *link, int family, const union in_addr_union *in_addr, unsigned char prefixlen, Address **ret) {
 274         return address_add_internal(link, &link->addresses_foreign, family, in_addr, prefixlen, ret);
 275 }
 276
 277 int address_add(Link *link, int family, const union in_addr_union *in_addr, unsigned char prefixlen, Address **ret) {
 278         Address *address;
 279         int r;
 280
 281         r = address_get(link, family, in_addr, prefixlen, &address);
 282         if (r == -ENOENT) {
 283                 /* Address does not exist, create a new one */
 284                 r = address_add_internal(link, &link->addresses, family, in_addr, prefixlen, &address);
 285                 if (r < 0)
 286                         return r;
 287         } else if (r == 0) {
 288                 /* Take over a foreign address */
 289                 r = set_ensure_allocated(&link->addresses, &address_hash_ops);
 290                 if (r < 0)
 291                         return r;
 292
 293                 r = set_put(link->addresses, address);
 294                 if (r < 0)
 295                         return r;
 296
 297                 set_remove(link->addresses_foreign, address);
 298         } else if (r == 1) {
 299                 /* Already exists, do nothing */
 300                 ;
 301         } else
 302                 return r;
 303
 304         if (ret)
 305                 *ret = address;
 306
 307         return 0;
 308 }
 309
 310 static int address_release(Address *address) {
 311         int r;
 312
 313         assert(address);
 314         assert(address->link);
 315
 316         /* Remove masquerading firewall entry if it was added */
 317         if (address->ip_masquerade_done) {
 318                 union in_addr_union masked = address->in_addr;
 319                 in_addr_mask(address->family, &masked, address->prefixlen);
 320
 321                 r = fw_add_masquerade(false, AF_INET, 0, &masked, address->prefixlen, NULL, NULL, 0);
 322                 if (r < 0)
 323                         log_link_warning_errno(address->link, r, "Failed to disable IP masquerading: %m");
 324
 325                 address->ip_masquerade_done = false;
 326         }
 327
 328         return 0;
 329 }
 330
 331 int address_update(
 332                 Address *address,
 333                 unsigned char flags,
 334                 unsigned char scope,
 335                 const struct ifa_cacheinfo *cinfo) {
 336
 337         bool ready;
 338         int r;
 339
 340         assert(address);
 341         assert(cinfo);
 342         assert_return(address->link, 1);
 343
 344         if (IN_SET(address->link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 345                 return 1;
 346
 347         ready = address_is_ready(address);
 348
 349         address->flags = flags;
 350         address->scope = scope;
 351         address->cinfo = *cinfo;
 352
 353         link_update_operstate(address->link);
 354
 355         if (!ready && address_is_ready(address)) {
 356                 link_check_ready(address->link);
 357
 358                 if (address->family == AF_INET6 &&
 359                     in_addr_is_link_local(AF_INET6, &address->in_addr) > 0 &&
 360                     in_addr_is_null(AF_INET6, (const union in_addr_union*) &address->link->ipv6ll_address) > 0) {
 361
 362                         r = link_ipv6ll_gained(address->link, &address->in_addr.in6);
 363                         if (r < 0)
 364                                 return r;
 365                 }
 366         }
 367
 368         return 0;
 369 }
 370
 371 int address_drop(Address *address) {
 372         Link *link;
 373         bool ready;
 374
 375         assert(address);
 376
 377         ready = address_is_ready(address);
 378         link = address->link;
 379
 380         address_release(address);
 381         address_free(address);
 382
 383         link_update_operstate(link);
 384
 385         if (link && !ready)
 386                 link_check_ready(link);
 387
 388         return 0;
 389 }
 390
 391 int address_get(Link *link,
 392                 int family,
 393                 const union in_addr_union *in_addr,
 394                 unsigned char prefixlen,
 395                 Address **ret) {
 396
 397         Address address, *existing;
 398
 399         assert(link);
 400         assert(in_addr);
 401
 402         address = (Address) {
 403                 .family = family,
 404                 .in_addr = *in_addr,
 405                 .prefixlen = prefixlen,
 406         };
 407
 408         existing = set_get(link->addresses, &address);
 409         if (existing) {
 410                 if (ret)
 411                         *ret = existing;
 412                 return 1;
 413         }
 414
 415         existing = set_get(link->addresses_foreign, &address);
 416         if (existing) {
 417                 if (ret)
 418                         *ret = existing;
 419                 return 0;
 420         }
 421
 422         return -ENOENT;
 423 }
 424
 425 int address_remove(
 426                 Address *address,
 427                 Link *link,
 428                 sd_netlink_message_handler_t callback) {
 429
 430         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
 431         int r;
 432
 433         assert(address);
 434         assert(IN_SET(address->family, AF_INET, AF_INET6));
 435         assert(link);
 436         assert(link->ifindex > 0);
 437         assert(link->manager);
 438         assert(link->manager->rtnl);
 439
 440         r = sd_rtnl_message_new_addr(link->manager->rtnl, &req, RTM_DELADDR,
 441                                      link->ifindex, address->family);
 442         if (r < 0)
 443                 return log_error_errno(r, "Could not allocate RTM_DELADDR message: %m");
 444
 445         r = sd_rtnl_message_addr_set_prefixlen(req, address->prefixlen);
 446         if (r < 0)
 447                 return log_error_errno(r, "Could not set prefixlen: %m");
 448
 449         if (address->family == AF_INET)
 450                 r = sd_netlink_message_append_in_addr(req, IFA_LOCAL, &address->in_addr.in);
 451         else if (address->family == AF_INET6)
 452                 r = sd_netlink_message_append_in6_addr(req, IFA_LOCAL, &address->in_addr.in6);
 453         if (r < 0)
 454                 return log_error_errno(r, "Could not append IFA_LOCAL attribute: %m");
 455
 456         r = sd_netlink_call_async(link->manager->rtnl, req, callback, NULL, link, 0, NULL);
 457         if (r < 0)
 458                 return log_error_errno(r, "Could not send rtnetlink message: %m");
 459
 460         link_ref(link);
 461
 462         return 0;
 463 }
 464
 465 static int address_acquire(Link *link, Address *original, Address **ret) {
 466         union in_addr_union in_addr = {};
 467         struct in_addr broadcast = {};
 468         _cleanup_(address_freep) Address *na = NULL;
 469         int r;
 470
 471         assert(link);
 472         assert(original);
 473         assert(ret);
 474
 475         /* Something useful was configured? just use it */
 476         if (in_addr_is_null(original->family, &original->in_addr) <= 0)
 477                 return 0;
 478
 479         /* The address is configured to be 0.0.0.0 or [::] by the user?
 480          * Then let's acquire something more useful from the pool. */
 481         r = manager_address_pool_acquire(link->manager, original->family, original->prefixlen, &in_addr);
 482         if (r < 0)
 483                 return log_link_error_errno(link, r, "Failed to acquire address from pool: %m");
 484         if (r == 0) {
 485                 log_link_error(link, "Couldn't find free address for interface, all taken.");
 486                 return -EBUSY;
 487         }
 488
 489         if (original->family == AF_INET) {
 490                 /* Pick first address in range for ourselves ... */
 491                 in_addr.in.s_addr = in_addr.in.s_addr | htobe32(1);
 492
 493                 /* .. and use last as broadcast address */
 494                 if (original->prefixlen > 30)
 495                         broadcast.s_addr = 0;
 496                 else
 497                         broadcast.s_addr = in_addr.in.s_addr | htobe32(0xFFFFFFFFUL >> original->prefixlen);
 498         } else if (original->family == AF_INET6)
 499                 in_addr.in6.s6_addr[15] |= 1;
 500
 501         r = address_new(&na);
 502         if (r < 0)
 503                 return r;
 504
 505         na->family = original->family;
 506         na->prefixlen = original->prefixlen;
 507         na->scope = original->scope;
 508         na->cinfo = original->cinfo;
 509
 510         if (original->label) {
 511                 na->label = strdup(original->label);
 512                 if (!na->label)
 513                         return -ENOMEM;
 514         }
 515
 516         na->broadcast = broadcast;
 517         na->in_addr = in_addr;
 518
 519         LIST_PREPEND(addresses, link->pool_addresses, na);
 520
 521         *ret = TAKE_PTR(na);
 522
 523         return 0;
 524 }
 525
 526 int address_configure(
 527                 Address *address,
 528                 Link *link,
 529                 sd_netlink_message_handler_t callback,
 530                 bool update) {
 531
 532         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
 533         int r;
 534
 535         assert(address);
 536         assert(IN_SET(address->family, AF_INET, AF_INET6));
 537         assert(link);
 538         assert(link->ifindex > 0);
 539         assert(link->manager);
 540         assert(link->manager->rtnl);
 541
 542         /* If this is a new address, then refuse adding more than the limit */
 543         if (address_get(link, address->family, &address->in_addr, address->prefixlen, NULL) <= 0 &&
 544             set_size(link->addresses) >= ADDRESSES_PER_LINK_MAX)
 545                 return -E2BIG;
 546
 547         r = address_acquire(link, address, &address);
 548         if (r < 0)
 549                 return r;
 550
 551         if (update)
 552                 r = sd_rtnl_message_new_addr_update(link->manager->rtnl, &req,
 553                                                     link->ifindex, address->family);
 554         else
 555                 r = sd_rtnl_message_new_addr(link->manager->rtnl, &req, RTM_NEWADDR,
 556                                              link->ifindex, address->family);
 557         if (r < 0)
 558                 return log_error_errno(r, "Could not allocate RTM_NEWADDR message: %m");
 559
 560         r = sd_rtnl_message_addr_set_prefixlen(req, address->prefixlen);
 561         if (r < 0)
 562                 return log_error_errno(r, "Could not set prefixlen: %m");
 563
 564         address->flags |= IFA_F_PERMANENT;
 565
 566         if (address->home_address)
 567                 address->flags |= IFA_F_HOMEADDRESS;
 568
 569         if (address->duplicate_address_detection)
 570                 address->flags |= IFA_F_NODAD;
 571
 572         if (address->manage_temporary_address)
 573                 address->flags |= IFA_F_MANAGETEMPADDR;
 574
 575         if (address->prefix_route)
 576                 address->flags |= IFA_F_NOPREFIXROUTE;
 577
 578         if (address->autojoin)
 579                 address->flags |= IFA_F_MCAUTOJOIN;
 580
 581         r = sd_rtnl_message_addr_set_flags(req, (address->flags & 0xff));
 582         if (r < 0)
 583                 return log_error_errno(r, "Could not set flags: %m");
 584
 585         if (address->flags & ~0xff) {
 586                 r = sd_netlink_message_append_u32(req, IFA_FLAGS, address->flags);
 587                 if (r < 0)
 588                         return log_error_errno(r, "Could not set extended flags: %m");
 589         }
 590
 591         r = sd_rtnl_message_addr_set_scope(req, address->scope);
 592         if (r < 0)
 593                 return log_error_errno(r, "Could not set scope: %m");
 594
 595         if (address->family == AF_INET)
 596                 r = sd_netlink_message_append_in_addr(req, IFA_LOCAL, &address->in_addr.in);
 597         else if (address->family == AF_INET6)
 598                 r = sd_netlink_message_append_in6_addr(req, IFA_LOCAL, &address->in_addr.in6);
 599         if (r < 0)
 600                 return log_error_errno(r, "Could not append IFA_LOCAL attribute: %m");
 601
 602         if (!in_addr_is_null(address->family, &address->in_addr_peer)) {
 603                 if (address->family == AF_INET)
 604                         r = sd_netlink_message_append_in_addr(req, IFA_ADDRESS, &address->in_addr_peer.in);
 605                 else if (address->family == AF_INET6)
 606                         r = sd_netlink_message_append_in6_addr(req, IFA_ADDRESS, &address->in_addr_peer.in6);
 607                 if (r < 0)
 608                         return log_error_errno(r, "Could not append IFA_ADDRESS attribute: %m");
 609         } else {
 610                 if (address->family == AF_INET) {
 611                         if (address->prefixlen <= 30) {
 612                                 r = sd_netlink_message_append_in_addr(req, IFA_BROADCAST, &address->broadcast);
 613                                 if (r < 0)
 614                                         return log_error_errno(r, "Could not append IFA_BROADCAST attribute: %m");
 615                         }
 616                 }
 617         }
 618
 619         if (address->label) {
 620                 r = sd_netlink_message_append_string(req, IFA_LABEL, address->label);
 621                 if (r < 0)
 622                         return log_error_errno(r, "Could not append IFA_LABEL attribute: %m");
 623         }
 624
 625         r = sd_netlink_message_append_cache_info(req, IFA_CACHEINFO,
 626                                               &address->cinfo);
 627         if (r < 0)
 628                 return log_error_errno(r, "Could not append IFA_CACHEINFO attribute: %m");
 629
 630         r = address_establish(address, link);
 631         if (r < 0)
 632                 return r;
 633
 634         r = sd_netlink_call_async(link->manager->rtnl, req, callback, NULL, link, 0, NULL);
 635         if (r < 0) {
 636                 address_release(address);
 637                 return log_error_errno(r, "Could not send rtnetlink message: %m");
 638         }
 639
 640         link_ref(link);
 641
 642         r = address_add(link, address->family, &address->in_addr, address->prefixlen, NULL);
 643         if (r < 0) {
 644                 address_release(address);
 645                 return log_error_errno(r, "Could not add address: %m");
 646         }
 647
 648         return 0;
 649 }
 650
 651 int config_parse_broadcast(
 652                 const char *unit,
 653                 const char *filename,
 654                 unsigned line,
 655                 const char *section,
 656                 unsigned section_line,
 657                 const char *lvalue,
 658                 int ltype,
 659                 const char *rvalue,
 660                 void *data,
 661                 void *userdata) {
 662
 663         Network *network = userdata;
 664         _cleanup_(address_freep) Address *n = NULL;
 665         int r;
 666
 667         assert(filename);
 668         assert(section);
 669         assert(lvalue);
 670         assert(rvalue);
 671         assert(data);
 672
 673         r = address_new_static(network, filename, section_line, &n);
 674         if (r < 0)
 675                 return r;
 676
 677         if (n->family == AF_INET6) {
 678                 log_syntax(unit, LOG_ERR, filename, line, 0, "Broadcast is not valid for IPv6 addresses, ignoring assignment: %s", rvalue);
 679                 return 0;
 680         }
 681
 682         r = in_addr_from_string(AF_INET, rvalue, (union in_addr_union*) &n->broadcast);
 683         if (r < 0) {
 684                 log_syntax(unit, LOG_ERR, filename, line, r, "Broadcast is invalid, ignoring assignment: %s", rvalue);
 685                 return 0;
 686         }
 687
 688         n->family = AF_INET;
 689         n = NULL;
 690
 691         return 0;
 692 }
 693
 694 int config_parse_address(const char *unit,
 695                 const char *filename,
 696                 unsigned line,
 697                 const char *section,
 698                 unsigned section_line,
 699                 const char *lvalue,
 700                 int ltype,
 701                 const char *rvalue,
 702                 void *data,
 703                 void *userdata) {
 704
 705         Network *network = userdata;
 706         _cleanup_(address_freep) Address *n = NULL;
 707         const char *address, *e;
 708         union in_addr_union buffer;
 709         int r, f;
 710
 711         assert(filename);
 712         assert(section);
 713         assert(lvalue);
 714         assert(rvalue);
 715         assert(data);
 716
 717         if (streq(section, "Network")) {
 718                 /* we are not in an Address section, so treat
 719                  * this as the special '0' section */
 720                 r = address_new_static(network, NULL, 0, &n);
 721         } else
 722                 r = address_new_static(network, filename, section_line, &n);
 723
 724         if (r < 0)
 725                 return r;
 726
 727         /* Address=address/prefixlen */
 728
 729         /* prefixlen */
 730         e = strchr(rvalue, '/');
 731         if (e) {
 732                 unsigned i;
 733
 734                 r = safe_atou(e + 1, &i);
 735                 if (r < 0) {
 736                         log_syntax(unit, LOG_ERR, filename, line, r, "Prefix length is invalid, ignoring assignment: %s", e + 1);
 737                         return 0;
 738                 }
 739
 740                 n->prefixlen = (unsigned char) i;
 741
 742                 address = strndupa(rvalue, e - rvalue);
 743         } else
 744                 address = rvalue;
 745
 746         r = in_addr_from_string_auto(address, &f, &buffer);
 747         if (r < 0) {
 748                 log_syntax(unit, LOG_ERR, filename, line, r, "Address is invalid, ignoring assignment: %s", address);
 749                 return 0;
 750         }
 751
 752         if (!e && f == AF_INET) {
 753                 r = in4_addr_default_prefixlen(&buffer.in, &n->prefixlen);
 754                 if (r < 0) {
 755                         log_syntax(unit, LOG_ERR, filename, line, r, "Prefix length not specified, and a default one cannot be deduced for '%s', ignoring assignment", address);
 756                         return 0;
 757                 }
 758         }
 759
 760         if (n->family != AF_UNSPEC && f != n->family) {
 761                 log_syntax(unit, LOG_ERR, filename, line, 0, "Address is incompatible, ignoring assignment: %s", address);
 762                 return 0;
 763         }
 764
 765         n->family = f;
 766
 767         if (streq(lvalue, "Address"))
 768                 n->in_addr = buffer;
 769         else
 770                 n->in_addr_peer = buffer;
 771
 772         if (n->family == AF_INET && n->broadcast.s_addr == 0)
 773                 n->broadcast.s_addr = n->in_addr.in.s_addr | htonl(0xfffffffflu >> n->prefixlen);
 774
 775         n = NULL;
 776
 777         return 0;
 778 }
 779
 780 int config_parse_label(
 781                 const char *unit,
 782                 const char *filename,
 783                 unsigned line,
 784                 const char *section,
 785                 unsigned section_line,
 786                 const char *lvalue,
 787                 int ltype,
 788                 const char *rvalue,
 789                 void *data,
 790                 void *userdata) {
 791
 792         _cleanup_(address_freep) Address *n = NULL;
 793         Network *network = userdata;
 794         int r;
 795
 796         assert(filename);
 797         assert(section);
 798         assert(lvalue);
 799         assert(rvalue);
 800         assert(data);
 801
 802         r = address_new_static(network, filename, section_line, &n);
 803         if (r < 0)
 804                 return r;
 805
 806         if (!address_label_valid(rvalue)) {
 807                 log_syntax(unit, LOG_ERR, filename, line, 0, "Interface label is too long or invalid, ignoring assignment: %s", rvalue);
 808                 return 0;
 809         }
 810
 811         r = free_and_strdup(&n->label, rvalue);
 812         if (r < 0)
 813                 return log_oom();
 814
 815         n = NULL;
 816
 817         return 0;
 818 }
 819
 820 int config_parse_lifetime(const char *unit,
 821                           const char *filename,
 822                           unsigned line,
 823                           const char *section,
 824                           unsigned section_line,
 825                           const char *lvalue,
 826                           int ltype,
 827                           const char *rvalue,
 828                           void *data,
 829                           void *userdata) {
 830         Network *network = userdata;
 831         _cleanup_(address_freep) Address *n = NULL;
 832         unsigned k;
 833         int r;
 834
 835         assert(filename);
 836         assert(section);
 837         assert(lvalue);
 838         assert(rvalue);
 839         assert(data);
 840
 841         r = address_new_static(network, filename, section_line, &n);
 842         if (r < 0)
 843                 return r;
 844
 845         if (STR_IN_SET(rvalue, "forever", "infinity")) {
 846                 n->cinfo.ifa_prefered = CACHE_INFO_INFINITY_LIFE_TIME;
 847                 n = NULL;
 848
 849                 return 0;
 850         }
 851
 852         r = safe_atou(rvalue, &k);
 853         if (r < 0) {
 854                 log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse PreferredLifetime, ignoring: %s", rvalue);
 855                 return 0;
 856         }
 857
 858         if (k != 0)
 859                 log_syntax(unit, LOG_ERR, filename, line, 0, "Invalid PreferredLifetime value, ignoring: %d", k);
 860         else {
 861                 n->cinfo.ifa_prefered = k;
 862                 n = NULL;
 863         }
 864
 865         return 0;
 866 }
 867
 868 int config_parse_address_flags(const char *unit,
 869                                const char *filename,
 870                                unsigned line,
 871                                const char *section,
 872                                unsigned section_line,
 873                                const char *lvalue,
 874                                int ltype,
 875                                const char *rvalue,
 876                                void *data,
 877                                void *userdata) {
 878         Network *network = userdata;
 879         _cleanup_(address_freep) Address *n = NULL;
 880         int r;
 881
 882         assert(filename);
 883         assert(section);
 884         assert(lvalue);
 885         assert(rvalue);
 886         assert(data);
 887
 888         r = address_new_static(network, filename, section_line, &n);
 889         if (r < 0)
 890                 return r;
 891
 892         r = parse_boolean(rvalue);
 893         if (r < 0) {
 894                 log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse address flag, ignoring: %s", rvalue);
 895                 return 0;
 896         }
 897
 898         if (streq(lvalue, "HomeAddress"))
 899                 n->home_address = r;
 900         else if (streq(lvalue, "DuplicateAddressDetection"))
 901                 n->duplicate_address_detection = r;
 902         else if (streq(lvalue, "ManageTemporaryAddress"))
 903                 n->manage_temporary_address = r;
 904         else if (streq(lvalue, "PrefixRoute"))
 905                 n->prefix_route = r;
 906         else if (streq(lvalue, "AutoJoin"))
 907                 n->autojoin = r;
 908
 909         return 0;
 910 }
 911
 912 int config_parse_address_scope(const char *unit,
 913                                const char *filename,
 914                                unsigned line,
 915                                const char *section,
 916                                unsigned section_line,
 917                                const char *lvalue,
 918                                int ltype,
 919                                const char *rvalue,
 920                                void *data,
 921                                void *userdata) {
 922         Network *network = userdata;
 923         _cleanup_(address_freep) Address *n = NULL;
 924         int r;
 925
 926         assert(filename);
 927         assert(section);
 928         assert(lvalue);
 929         assert(rvalue);
 930         assert(data);
 931
 932         r = address_new_static(network, filename, section_line, &n);
 933         if (r < 0)
 934                 return r;
 935
 936         if (streq(rvalue, "host"))
 937                 n->scope = RT_SCOPE_HOST;
 938         else if (streq(rvalue, "link"))
 939                 n->scope = RT_SCOPE_LINK;
 940         else if (streq(rvalue, "global"))
 941                 n->scope = RT_SCOPE_UNIVERSE;
 942         else {
 943                 r = safe_atou8(rvalue , &n->scope);
 944                 if (r < 0) {
 945                         log_syntax(unit, LOG_ERR, filename, line, r, "Could not parse address scope \"%s\", ignoring assignment: %m", rvalue);
 946                         return 0;
 947                 }
 948         }
 949
 950         n = NULL;
 951
 952         return 0;
 953 }
 954
 955 bool address_is_ready(const Address *a) {
 956         assert(a);
 957
 958         if (a->family == AF_INET6)
 959                 return !(a->flags & IFA_F_TENTATIVE);
 960         else
 961                 return !(a->flags & (IFA_F_TENTATIVE | IFA_F_DEPRECATED));
 962 }