src/network/networkd-network.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <linux/netdevice.h>
   4
   5 #include "alloc-util.h"
   6 #include "conf-files.h"
   7 #include "conf-parser.h"
   8 #include "dns-domain.h"
   9 #include "fd-util.h"
  10 #include "hostname-util.h"
  11 #include "in-addr-util.h"
  12 #include "network-internal.h"
  13 #include "networkd-manager.h"
  14 #include "networkd-network.h"
  15 #include "parse-util.h"
  16 #include "set.h"
  17 #include "socket-util.h"
  18 #include "stat-util.h"
  19 #include "string-table.h"
  20 #include "string-util.h"
  21 #include "strv.h"
  22 #include "util.h"
  23
  24 /* Let's assume that anything above this number is a user misconfiguration. */
  25 #define MAX_NTP_SERVERS 128
  26
  27 /* Set defaults following RFC7844 */
  28 void network_apply_anonymize_if_set(Network *network) {
  29         if (!network->dhcp_anonymize)
  30                 return;
  31         /* RFC7844 3.7
  32          SHOULD NOT send the Host Name option */
  33         network->dhcp_send_hostname = false;
  34         /* RFC7844 section 3.:
  35          MAY contain the Client Identifier option
  36          Section 3.5:
  37          clients MUST use client identifiers based solely
  38          on the link-layer address */
  39         /* NOTE: Using MAC, as it does not reveal extra information,
  40         * and some servers might not answer if this option is not sent */
  41         network->dhcp_client_identifier = DHCP_CLIENT_ID_MAC;
  42         /* RFC 7844 3.10:
  43          SHOULD NOT use the Vendor Class Identifier option */
  44         network->dhcp_vendor_class_identifier = mfree(network->dhcp_vendor_class_identifier);
  45         /* RFC7844 section 3.6.:
  46          The client intending to protect its privacy SHOULD only request a
  47          minimal number of options in the PRL and SHOULD also randomly shuffle
  48          the ordering of option codes in the PRL.  If this random ordering
  49          cannot be implemented, the client MAY order the option codes in the
  50          PRL by option code number (lowest to highest).
  51         */
  52         /* NOTE: dhcp_use_mtu is false by default,
  53         * though it was not initiallized to any value in network_load_one.
  54         * Maybe there should be another var called *send*?
  55         * (to use the MTU sent by the server but to do not send
  56         * the option in the PRL). */
  57         network->dhcp_use_mtu = false;
  58         /* NOTE: when Anonymize=yes, the PRL route options are sent by default,
  59          * but this is needed to use them. */
  60         network->dhcp_use_routes = true;
  61         /* RFC7844 section 3.6.
  62         * same comments as previous option */
  63         network->dhcp_use_timezone = false;
  64 }
  65
  66 static int network_resolve_netdev_one(Network *network, const char *name, NetDevKind kind, NetDev **ret_netdev) {
  67         const char *kind_string;
  68         NetDev *netdev;
  69         int r;
  70
  71         /* For test-networkd-conf, the check must be earlier than the assertions. */
  72         if (!name)
  73                 return 0;
  74
  75         assert(network);
  76         assert(network->manager);
  77         assert(network->filename);
  78         assert(ret_netdev);
  79
  80         if (kind == _NETDEV_KIND_TUNNEL)
  81                 kind_string = "tunnel";
  82         else {
  83                 kind_string = netdev_kind_to_string(kind);
  84                 if (!kind_string)
  85                         return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
  86                                                "%s: Invalid NetDev kind of %s, ignoring assignment.",
  87                                                network->filename, name);
  88         }
  89
  90         r = netdev_get(network->manager, name, &netdev);
  91         if (r < 0)
  92                 return log_error_errno(r, "%s: %s NetDev could not be found, ignoring assignment.",
  93                                        network->filename, name);
  94
  95         if (netdev->kind != kind && !(kind == _NETDEV_KIND_TUNNEL &&
  96                                       IN_SET(netdev->kind,
  97                                              NETDEV_KIND_IPIP,
  98                                              NETDEV_KIND_SIT,
  99                                              NETDEV_KIND_GRE,
 100                                              NETDEV_KIND_GRETAP,
 101                                              NETDEV_KIND_IP6GRE,
 102                                              NETDEV_KIND_IP6GRETAP,
 103                                              NETDEV_KIND_VTI,
 104                                              NETDEV_KIND_VTI6,
 105                                              NETDEV_KIND_IP6TNL,
 106                                              NETDEV_KIND_ERSPAN)))
 107                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 108                                        "%s: NetDev %s is not a %s, ignoring assignment",
 109                                        network->filename, name, kind_string);
 110
 111         *ret_netdev = netdev_ref(netdev);
 112         return 1;
 113 }
 114
 115 static int network_resolve_stacked_netdevs(Network *network) {
 116         void *name, *kind;
 117         Iterator i;
 118         int r;
 119
 120         assert(network);
 121
 122         HASHMAP_FOREACH_KEY(kind, name, network->stacked_netdev_names, i) {
 123                 _cleanup_(netdev_unrefp) NetDev *netdev = NULL;
 124
 125                 r = network_resolve_netdev_one(network, name, PTR_TO_INT(kind), &netdev);
 126                 if (r <= 0)
 127                         continue;
 128
 129                 r = hashmap_ensure_allocated(&network->stacked_netdevs, &string_hash_ops);
 130                 if (r < 0)
 131                         return log_oom();
 132
 133                 r = hashmap_put(network->stacked_netdevs, netdev->ifname, netdev);
 134                 if (r < 0)
 135                         return log_error_errno(r, "%s: Failed to add NetDev '%s' to network: %m",
 136                                                network->filename, (const char *) name);
 137
 138                 netdev = NULL;
 139         }
 140
 141         return 0;
 142 }
 143
 144 static uint32_t network_get_stacked_netdevs_mtu(Network *network) {
 145         uint32_t mtu = 0;
 146         NetDev *dev;
 147         Iterator i;
 148
 149         HASHMAP_FOREACH(dev, network->stacked_netdevs, i)
 150                 if (dev->kind == NETDEV_KIND_VLAN && dev->mtu > 0)
 151                         /* See vlan_dev_change_mtu() in kernel.
 152                          * Note that the additional 4bytes may not be necessary for all devices. */
 153                         mtu = MAX(mtu, dev->mtu + 4);
 154
 155                 else if (dev->kind == NETDEV_KIND_MACVLAN && dev->mtu > mtu)
 156                         /* See macvlan_change_mtu() in kernel. */
 157                         mtu = dev->mtu;
 158
 159         return mtu;
 160 }
 161
 162 int network_verify(Network *network) {
 163         Address *address, *address_next;
 164         Route *route, *route_next;
 165         FdbEntry *fdb, *fdb_next;
 166         Neighbor *neighbor, *neighbor_next;
 167         AddressLabel *label, *label_next;
 168         Prefix *prefix, *prefix_next;
 169         RoutingPolicyRule *rule, *rule_next;
 170         uint32_t mtu;
 171
 172         assert(network);
 173         assert(network->filename);
 174
 175         if (set_isempty(network->match_mac) && strv_isempty(network->match_path) &&
 176             strv_isempty(network->match_driver) && strv_isempty(network->match_type) &&
 177             strv_isempty(network->match_name) && !network->conditions)
 178                 log_warning("%s: No valid settings found in the [Match] section. "
 179                             "The file will match all interfaces. "
 180                             "If that is intended, please add Name=* in the [Match] section.",
 181                             network->filename);
 182
 183         /* skip out early if configuration does not match the environment */
 184         if (!condition_test_list(network->conditions, NULL, NULL, NULL))
 185                 return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
 186                                        "%s: Conditions in the file do not match the system environment, skipping.",
 187                                        network->filename);
 188
 189         (void) network_resolve_netdev_one(network, network->bond_name, NETDEV_KIND_BOND, &network->bond);
 190         (void) network_resolve_netdev_one(network, network->bridge_name, NETDEV_KIND_BRIDGE, &network->bridge);
 191         (void) network_resolve_netdev_one(network, network->vrf_name, NETDEV_KIND_VRF, &network->vrf);
 192         (void) network_resolve_stacked_netdevs(network);
 193
 194         /* Free unnecessary entries. */
 195         network->bond_name = mfree(network->bond_name);
 196         network->bridge_name = mfree(network->bridge_name);
 197         network->vrf_name = mfree(network->vrf_name);
 198         network->stacked_netdev_names = hashmap_free_free_key(network->stacked_netdev_names);
 199
 200         if (network->bond) {
 201                 /* Bonding slave does not support addressing. */
 202                 if (network->ipv6_accept_ra > 0) {
 203                         log_warning("%s: Cannot enable IPv6AcceptRA= when Bond= is specified, disabling IPv6AcceptRA=.",
 204                                     network->filename);
 205                         network->ipv6_accept_ra = 0;
 206                 }
 207                 if (network->link_local >= 0 && network->link_local != ADDRESS_FAMILY_NO) {
 208                         log_warning("%s: Cannot enable LinkLocalAddressing= when Bond= is specified, disabling LinkLocalAddressing=.",
 209                                     network->filename);
 210                         network->link_local = ADDRESS_FAMILY_NO;
 211                 }
 212                 if (network->dhcp != ADDRESS_FAMILY_NO) {
 213                         log_warning("%s: Cannot enable DHCP= when Bond= is specified, disabling DHCP=.",
 214                                     network->filename);
 215                         network->dhcp = ADDRESS_FAMILY_NO;
 216                 }
 217                 if (network->dhcp_server) {
 218                         log_warning("%s: Cannot enable DHCPServer= when Bond= is specified, disabling DHCPServer=.",
 219                                     network->filename);
 220                         network->dhcp_server = false;
 221                 }
 222                 if (network->n_static_addresses > 0) {
 223                         log_warning("%s: Cannot set addresses when Bond= is specified, ignoring addresses.",
 224                                     network->filename);
 225                         while ((address = network->static_addresses))
 226                                 address_free(address);
 227                 }
 228                 if (network->n_static_routes > 0) {
 229                         log_warning("%s: Cannot set routes when Bond= is specified, ignoring routes.",
 230                                     network->filename);
 231                         while ((route = network->static_routes))
 232                                 route_free(route);
 233                 }
 234         }
 235
 236         if (network->link_local < 0)
 237                 network->link_local = network->bridge ? ADDRESS_FAMILY_NO : ADDRESS_FAMILY_IPV6;
 238
 239         if (FLAGS_SET(network->link_local, ADDRESS_FAMILY_FALLBACK_IPV4) &&
 240             !FLAGS_SET(network->dhcp, ADDRESS_FAMILY_IPV4)) {
 241                 log_warning("%s: fallback assignment of IPv4 link local address is enabled but DHCPv4 is disabled. "
 242                             "Disabling the fallback assignment.", network->filename);
 243                 SET_FLAG(network->link_local, ADDRESS_FAMILY_FALLBACK_IPV4, false);
 244         }
 245
 246         if (network->ipv6_accept_ra < 0 && network->bridge)
 247                 network->ipv6_accept_ra = false;
 248
 249         /* IPMasquerade=yes implies IPForward=yes */
 250         if (network->ip_masquerade)
 251                 network->ip_forward |= ADDRESS_FAMILY_IPV4;
 252
 253         network->mtu_is_set = network->mtu > 0;
 254         mtu = network_get_stacked_netdevs_mtu(network);
 255         if (network->mtu < mtu) {
 256                 if (network->mtu_is_set)
 257                         log_notice("%s: Bumping MTUBytes= from %"PRIu32" to %"PRIu32" because of stacked device",
 258                                    network->filename, network->mtu, mtu);
 259                 network->mtu = mtu;
 260         }
 261
 262         if (network->mtu_is_set && network->dhcp_use_mtu) {
 263                 log_warning("%s: MTUBytes= in [Link] section and UseMTU= in [DHCP] section are set. "
 264                             "Disabling UseMTU=.", network->filename);
 265                 network->dhcp_use_mtu = false;
 266         }
 267
 268         LIST_FOREACH_SAFE(addresses, address, address_next, network->static_addresses)
 269                 if (address_section_verify(address) < 0)
 270                         address_free(address);
 271
 272         LIST_FOREACH_SAFE(routes, route, route_next, network->static_routes)
 273                 if (route_section_verify(route, network) < 0)
 274                         route_free(route);
 275
 276         LIST_FOREACH_SAFE(static_fdb_entries, fdb, fdb_next, network->static_fdb_entries)
 277                 if (section_is_invalid(fdb->section))
 278                         fdb_entry_free(fdb);
 279
 280         LIST_FOREACH_SAFE(neighbors, neighbor, neighbor_next, network->neighbors)
 281                 if (section_is_invalid(neighbor->section))
 282                         neighbor_free(neighbor);
 283
 284         LIST_FOREACH_SAFE(labels, label, label_next, network->address_labels)
 285                 if (section_is_invalid(label->section))
 286                         address_label_free(label);
 287
 288         LIST_FOREACH_SAFE(prefixes, prefix, prefix_next, network->static_prefixes)
 289                 if (section_is_invalid(prefix->section))
 290                         prefix_free(prefix);
 291
 292         LIST_FOREACH_SAFE(rules, rule, rule_next, network->rules)
 293                 if (section_is_invalid(rule->section))
 294                         routing_policy_rule_free(rule);
 295
 296         return 0;
 297 }
 298
 299 int network_load_one(Manager *manager, const char *filename) {
 300         _cleanup_free_ char *fname = NULL, *name = NULL;
 301         _cleanup_(network_freep) Network *network = NULL;
 302         _cleanup_fclose_ FILE *file = NULL;
 303         const char *dropin_dirname;
 304         char *d;
 305         int r;
 306
 307         assert(manager);
 308         assert(filename);
 309
 310         file = fopen(filename, "re");
 311         if (!file) {
 312                 if (errno == ENOENT)
 313                         return 0;
 314
 315                 return -errno;
 316         }
 317
 318         if (null_or_empty_fd(fileno(file))) {
 319                 log_debug("Skipping empty file: %s", filename);
 320                 return 0;
 321         }
 322
 323         fname = strdup(filename);
 324         if (!fname)
 325                 return log_oom();
 326
 327         name = strdup(basename(filename));
 328         if (!name)
 329                 return log_oom();
 330
 331         d = strrchr(name, '.');
 332         if (!d)
 333                 return -EINVAL;
 334
 335         *d = '\0';
 336
 337         dropin_dirname = strjoina(name, ".network.d");
 338
 339         network = new(Network, 1);
 340         if (!network)
 341                 return log_oom();
 342
 343         *network = (Network) {
 344                 .filename = TAKE_PTR(fname),
 345                 .name = TAKE_PTR(name),
 346
 347                 .required_for_online = true,
 348                 .required_operstate_for_online = LINK_OPERSTATE_DEGRADED,
 349                 .dhcp = ADDRESS_FAMILY_NO,
 350                 .dhcp_use_ntp = true,
 351                 .dhcp_use_dns = true,
 352                 .dhcp_use_hostname = true,
 353                 .dhcp_use_routes = true,
 354                 /* NOTE: this var might be overwritten by network_apply_anonymize_if_set */
 355                 .dhcp_send_hostname = true,
 356                 /* To enable/disable RFC7844 Anonymity Profiles */
 357                 .dhcp_anonymize = false,
 358                 .dhcp_route_metric = DHCP_ROUTE_METRIC,
 359                 /* NOTE: this var might be overwrite by network_apply_anonymize_if_set */
 360                 .dhcp_client_identifier = DHCP_CLIENT_ID_DUID,
 361                 .dhcp_route_table = RT_TABLE_MAIN,
 362                 .dhcp_route_table_set = false,
 363                 /* NOTE: from man: UseMTU=... Defaults to false*/
 364                 .dhcp_use_mtu = false,
 365                 /* NOTE: from man: UseTimezone=... Defaults to "no".*/
 366                 .dhcp_use_timezone = false,
 367                 .rapid_commit = true,
 368
 369                 .dhcp_server_emit_dns = true,
 370                 .dhcp_server_emit_ntp = true,
 371                 .dhcp_server_emit_router = true,
 372                 .dhcp_server_emit_timezone = true,
 373
 374                 .router_emit_dns = true,
 375                 .router_emit_domains = true,
 376
 377                 .use_bpdu = -1,
 378                 .hairpin = -1,
 379                 .fast_leave = -1,
 380                 .allow_port_to_be_root = -1,
 381                 .unicast_flood = -1,
 382                 .multicast_flood = -1,
 383                 .multicast_to_unicast = -1,
 384                 .neighbor_suppression = -1,
 385                 .learning = -1,
 386                 .priority = LINK_BRIDGE_PORT_PRIORITY_INVALID,
 387
 388                 .lldp_mode = LLDP_MODE_ROUTERS_ONLY,
 389
 390                 .dns_default_route = -1,
 391                 .llmnr = RESOLVE_SUPPORT_YES,
 392                 .mdns = RESOLVE_SUPPORT_NO,
 393                 .dnssec_mode = _DNSSEC_MODE_INVALID,
 394                 .dns_over_tls_mode = _DNS_OVER_TLS_MODE_INVALID,
 395
 396                 /* If LinkLocalAddressing= is not set, then set to ADDRESS_FAMILY_IPV6 later. */
 397                 .link_local = _ADDRESS_FAMILY_BOOLEAN_INVALID,
 398
 399                 .ipv6_privacy_extensions = IPV6_PRIVACY_EXTENSIONS_NO,
 400                 .ipv6_accept_ra = -1,
 401                 .ipv6_dad_transmits = -1,
 402                 .ipv6_hop_limit = -1,
 403                 .ipv6_proxy_ndp = -1,
 404                 .duid.type = _DUID_TYPE_INVALID,
 405                 .proxy_arp = -1,
 406                 .arp = -1,
 407                 .multicast = -1,
 408                 .allmulticast = -1,
 409                 .ipv6_accept_ra_use_dns = true,
 410                 .ipv6_accept_ra_use_autonomous_prefix = true,
 411                 .ipv6_accept_ra_use_onlink_prefix = true,
 412                 .ipv6_accept_ra_route_table = RT_TABLE_MAIN,
 413                 .ipv6_accept_ra_route_table_set = false,
 414
 415                 .can_triple_sampling = -1,
 416         };
 417
 418         r = config_parse_many(filename, NETWORK_DIRS, dropin_dirname,
 419                               "Match\0"
 420                               "Link\0"
 421                               "Network\0"
 422                               "Address\0"
 423                               "Neighbor\0"
 424                               "IPv6AddressLabel\0"
 425                               "RoutingPolicyRule\0"
 426                               "Route\0"
 427                               "DHCP\0"
 428                               "DHCPv4\0" /* compat */
 429                               "DHCPServer\0"
 430                               "IPv6AcceptRA\0"
 431                               "IPv6NDPProxyAddress\0"
 432                               "Bridge\0"
 433                               "BridgeFDB\0"
 434                               "BridgeVLAN\0"
 435                               "IPv6PrefixDelegation\0"
 436                               "IPv6Prefix\0"
 437                               "CAN\0",
 438                               config_item_perf_lookup, network_network_gperf_lookup,
 439                               CONFIG_PARSE_WARN, network);
 440         if (r < 0)
 441                 return r;
 442
 443         network_apply_anonymize_if_set(network);
 444
 445         r = network_add_ipv4ll_route(network);
 446         if (r < 0)
 447                 log_warning_errno(r, "%s: Failed to add IPv4LL route, ignoring: %m", network->filename);
 448
 449         LIST_PREPEND(networks, manager->networks, network);
 450         network->manager = manager;
 451
 452         r = hashmap_ensure_allocated(&manager->networks_by_name, &string_hash_ops);
 453         if (r < 0)
 454                 return r;
 455
 456         r = hashmap_put(manager->networks_by_name, network->name, network);
 457         if (r < 0)
 458                 return r;
 459
 460         if (network_verify(network) < 0)
 461                 return 0;
 462
 463         network = NULL;
 464         return 0;
 465 }
 466
 467 int network_load(Manager *manager) {
 468         Network *network;
 469         _cleanup_strv_free_ char **files = NULL;
 470         char **f;
 471         int r;
 472
 473         assert(manager);
 474
 475         while ((network = manager->networks))
 476                 network_free(network);
 477
 478         r = conf_files_list_strv(&files, ".network", NULL, 0, NETWORK_DIRS);
 479         if (r < 0)
 480                 return log_error_errno(r, "Failed to enumerate network files: %m");
 481
 482         STRV_FOREACH_BACKWARDS(f, files) {
 483                 r = network_load_one(manager, *f);
 484                 if (r < 0)
 485                         return r;
 486         }
 487
 488         return 0;
 489 }
 490
 491 void network_free(Network *network) {
 492         IPv6ProxyNDPAddress *ipv6_proxy_ndp_address;
 493         RoutingPolicyRule *rule;
 494         FdbEntry *fdb_entry;
 495         Neighbor *neighbor;
 496         AddressLabel *label;
 497         Prefix *prefix;
 498         Address *address;
 499         Route *route;
 500
 501         if (!network)
 502                 return;
 503
 504         free(network->filename);
 505
 506         set_free_free(network->match_mac);
 507         strv_free(network->match_path);
 508         strv_free(network->match_driver);
 509         strv_free(network->match_type);
 510         strv_free(network->match_name);
 511         condition_free_list(network->conditions);
 512
 513         free(network->description);
 514         free(network->dhcp_vendor_class_identifier);
 515         strv_free(network->dhcp_user_class);
 516         free(network->dhcp_hostname);
 517
 518         free(network->mac);
 519
 520         strv_free(network->ntp);
 521         free(network->dns);
 522         ordered_set_free_free(network->search_domains);
 523         ordered_set_free_free(network->route_domains);
 524         strv_free(network->bind_carrier);
 525
 526         ordered_set_free_free(network->router_search_domains);
 527         free(network->router_dns);
 528
 529         free(network->bridge_name);
 530         free(network->bond_name);
 531         free(network->vrf_name);
 532         hashmap_free_free_key(network->stacked_netdev_names);
 533         netdev_unref(network->bridge);
 534         netdev_unref(network->bond);
 535         netdev_unref(network->vrf);
 536         hashmap_free_with_destructor(network->stacked_netdevs, netdev_unref);
 537
 538         while ((route = network->static_routes))
 539                 route_free(route);
 540
 541         while ((address = network->static_addresses))
 542                 address_free(address);
 543
 544         while ((fdb_entry = network->static_fdb_entries))
 545                 fdb_entry_free(fdb_entry);
 546
 547         while ((ipv6_proxy_ndp_address = network->ipv6_proxy_ndp_addresses))
 548                 ipv6_proxy_ndp_address_free(ipv6_proxy_ndp_address);
 549
 550         while ((neighbor = network->neighbors))
 551                 neighbor_free(neighbor);
 552
 553         while ((label = network->address_labels))
 554                 address_label_free(label);
 555
 556         while ((prefix = network->static_prefixes))
 557                 prefix_free(prefix);
 558
 559         while ((rule = network->rules))
 560                 routing_policy_rule_free(rule);
 561
 562         hashmap_free(network->addresses_by_section);
 563         hashmap_free(network->routes_by_section);
 564         hashmap_free(network->fdb_entries_by_section);
 565         hashmap_free(network->neighbors_by_section);
 566         hashmap_free(network->address_labels_by_section);
 567         hashmap_free(network->prefixes_by_section);
 568         hashmap_free(network->rules_by_section);
 569
 570         if (network->manager) {
 571                 if (network->manager->networks)
 572                         LIST_REMOVE(networks, network->manager->networks, network);
 573
 574                 if (network->manager->networks_by_name && network->name)
 575                         hashmap_remove(network->manager->networks_by_name, network->name);
 576
 577                 if (network->manager->duids_requesting_uuid)
 578                         set_remove(network->manager->duids_requesting_uuid, &network->duid);
 579         }
 580
 581         free(network->name);
 582
 583         free(network->dhcp_server_timezone);
 584         free(network->dhcp_server_dns);
 585         free(network->dhcp_server_ntp);
 586
 587         set_free_free(network->dnssec_negative_trust_anchors);
 588
 589         free(network);
 590 }
 591
 592 int network_get_by_name(Manager *manager, const char *name, Network **ret) {
 593         Network *network;
 594
 595         assert(manager);
 596         assert(name);
 597         assert(ret);
 598
 599         network = hashmap_get(manager->networks_by_name, name);
 600         if (!network)
 601                 return -ENOENT;
 602
 603         *ret = network;
 604
 605         return 0;
 606 }
 607
 608 int network_get(Manager *manager, sd_device *device,
 609                 const char *ifname, const struct ether_addr *address,
 610                 Network **ret) {
 611         const char *path = NULL, *driver = NULL, *devtype = NULL;
 612         Network *network;
 613
 614         assert(manager);
 615         assert(ret);
 616
 617         if (device) {
 618                 (void) sd_device_get_property_value(device, "ID_PATH", &path);
 619
 620                 (void) sd_device_get_property_value(device, "ID_NET_DRIVER", &driver);
 621
 622                 (void) sd_device_get_devtype(device, &devtype);
 623         }
 624
 625         LIST_FOREACH(networks, network, manager->networks) {
 626                 if (net_match_config(network->match_mac, network->match_path,
 627                                      network->match_driver, network->match_type,
 628                                      network->match_name,
 629                                      address, path, driver, devtype, ifname)) {
 630                         if (network->match_name && device) {
 631                                 const char *attr;
 632                                 uint8_t name_assign_type = NET_NAME_UNKNOWN;
 633
 634                                 if (sd_device_get_sysattr_value(device, "name_assign_type", &attr) >= 0)
 635                                         (void) safe_atou8(attr, &name_assign_type);
 636
 637                                 if (name_assign_type == NET_NAME_ENUM)
 638                                         log_warning("%s: found matching network '%s', based on potentially unpredictable ifname",
 639                                                     ifname, network->filename);
 640                                 else
 641                                         log_debug("%s: found matching network '%s'", ifname, network->filename);
 642                         } else
 643                                 log_debug("%s: found matching network '%s'", ifname, network->filename);
 644
 645                         *ret = network;
 646                         return 0;
 647                 }
 648         }
 649
 650         *ret = NULL;
 651
 652         return -ENOENT;
 653 }
 654
 655 int network_apply(Network *network, Link *link) {
 656         assert(network);
 657         assert(link);
 658
 659         link->network = network;
 660
 661         if (network->n_dns > 0 ||
 662             !strv_isempty(network->ntp) ||
 663             !ordered_set_isempty(network->search_domains) ||
 664             !ordered_set_isempty(network->route_domains))
 665                 link_dirty(link);
 666
 667         return 0;
 668 }
 669
 670 bool network_has_static_ipv6_addresses(Network *network) {
 671         Address *address;
 672
 673         assert(network);
 674
 675         LIST_FOREACH(addresses, address, network->static_addresses) {
 676                 if (address->family == AF_INET6)
 677                         return true;
 678         }
 679
 680         return false;
 681 }
 682
 683 int config_parse_stacked_netdev(const char *unit,
 684                 const char *filename,
 685                 unsigned line,
 686                 const char *section,
 687                 unsigned section_line,
 688                 const char *lvalue,
 689                 int ltype,
 690                 const char *rvalue,
 691                 void *data,
 692                 void *userdata) {
 693         _cleanup_free_ char *name = NULL;
 694         NetDevKind kind = ltype;
 695         Hashmap **h = data;
 696         int r;
 697
 698         assert(filename);
 699         assert(lvalue);
 700         assert(rvalue);
 701         assert(data);
 702         assert(IN_SET(kind,
 703                       NETDEV_KIND_VLAN, NETDEV_KIND_MACVLAN, NETDEV_KIND_MACVTAP,
 704                       NETDEV_KIND_IPVLAN, NETDEV_KIND_VXLAN, NETDEV_KIND_L2TP,
 705                       NETDEV_KIND_MACSEC, _NETDEV_KIND_TUNNEL));
 706
 707         if (!ifname_valid(rvalue)) {
 708                 log_syntax(unit, LOG_ERR, filename, line, 0,
 709                            "Invalid netdev name in %s=, ignoring assignment: %s", lvalue, rvalue);
 710                 return 0;
 711         }
 712
 713         name = strdup(rvalue);
 714         if (!name)
 715                 return log_oom();
 716
 717         r = hashmap_ensure_allocated(h, &string_hash_ops);
 718         if (r < 0)
 719                 return log_oom();
 720
 721         r = hashmap_put(*h, name, INT_TO_PTR(kind));
 722         if (r < 0)
 723                 log_syntax(unit, LOG_ERR, filename, line, r,
 724                            "Cannot add NetDev '%s' to network, ignoring assignment: %m", name);
 725         else if (r == 0)
 726                 log_syntax(unit, LOG_DEBUG, filename, line, r,
 727                            "NetDev '%s' specified twice, ignoring.", name);
 728         else
 729                 name = NULL;
 730
 731         return 0;
 732 }
 733
 734 int config_parse_domains(
 735                 const char *unit,
 736                 const char *filename,
 737                 unsigned line,
 738                 const char *section,
 739                 unsigned section_line,
 740                 const char *lvalue,
 741                 int ltype,
 742                 const char *rvalue,
 743                 void *data,
 744                 void *userdata) {
 745
 746         const char *p;
 747         Network *n = data;
 748         int r;
 749
 750         assert(n);
 751         assert(lvalue);
 752         assert(rvalue);
 753
 754         if (isempty(rvalue)) {
 755                 n->search_domains = ordered_set_free_free(n->search_domains);
 756                 n->route_domains = ordered_set_free_free(n->route_domains);
 757                 return 0;
 758         }
 759
 760         p = rvalue;
 761         for (;;) {
 762                 _cleanup_free_ char *w = NULL, *normalized = NULL;
 763                 const char *domain;
 764                 bool is_route;
 765
 766                 r = extract_first_word(&p, &w, NULL, 0);
 767                 if (r < 0) {
 768                         log_syntax(unit, LOG_ERR, filename, line, r,
 769                                    "Failed to extract search or route domain, ignoring: %s", rvalue);
 770                         break;
 771                 }
 772                 if (r == 0)
 773                         break;
 774
 775                 is_route = w[0] == '~';
 776                 domain = is_route ? w + 1 : w;
 777
 778                 if (dns_name_is_root(domain) || streq(domain, "*")) {
 779                         /* If the root domain appears as is, or the special token "*" is found, we'll
 780                          * consider this as routing domain, unconditionally. */
 781                         is_route = true;
 782                         domain = "."; /* make sure we don't allow empty strings, thus write the root
 783                                        * domain as "." */
 784                 } else {
 785                         r = dns_name_normalize(domain, 0, &normalized);
 786                         if (r < 0) {
 787                                 log_syntax(unit, LOG_ERR, filename, line, r,
 788                                            "'%s' is not a valid domain name, ignoring.", domain);
 789                                 continue;
 790                         }
 791
 792                         domain = normalized;
 793
 794                         if (is_localhost(domain)) {
 795                                 log_syntax(unit, LOG_ERR, filename, line, 0,
 796                                            "'localhost' domain may not be configured as search or route domain, ignoring assignment: %s",
 797                                            domain);
 798                                 continue;
 799                         }
 800                 }
 801
 802                 OrderedSet **set = is_route ? &n->route_domains : &n->search_domains;
 803                 r = ordered_set_ensure_allocated(set, &string_hash_ops);
 804                 if (r < 0)
 805                         return r;
 806
 807                 r = ordered_set_put_strdup(*set, domain);
 808                 if (r < 0)
 809                         return log_oom();
 810         }
 811
 812         return 0;
 813 }
 814
 815 int config_parse_ipv4ll(
 816                 const char* unit,
 817                 const char *filename,
 818                 unsigned line,
 819                 const char *section,
 820                 unsigned section_line,
 821                 const char *lvalue,
 822                 int ltype,
 823                 const char *rvalue,
 824                 void *data,
 825                 void *userdata) {
 826
 827         AddressFamilyBoolean *link_local = data;
 828         int r;
 829
 830         assert(filename);
 831         assert(lvalue);
 832         assert(rvalue);
 833         assert(data);
 834
 835         /* Note that this is mostly like
 836          * config_parse_address_family_boolean(), except that it
 837          * applies only to IPv4 */
 838
 839         r = parse_boolean(rvalue);
 840         if (r < 0) {
 841                 log_syntax(unit, LOG_ERR, filename, line, r,
 842                            "Failed to parse %s=%s, ignoring assignment. "
 843                            "Note that the setting %s= is deprecated, please use LinkLocalAddressing= instead.",
 844                            lvalue, rvalue, lvalue);
 845                 return 0;
 846         }
 847
 848         SET_FLAG(*link_local, ADDRESS_FAMILY_IPV4, r);
 849
 850         log_syntax(unit, LOG_WARNING, filename, line, 0,
 851                    "%s=%s is deprecated, please use LinkLocalAddressing=%s instead.",
 852                    lvalue, rvalue, address_family_boolean_to_string(*link_local));
 853
 854         return 0;
 855 }
 856
 857 int config_parse_dhcp(
 858                 const char* unit,
 859                 const char *filename,
 860                 unsigned line,
 861                 const char *section,
 862                 unsigned section_line,
 863                 const char *lvalue,
 864                 int ltype,
 865                 const char *rvalue,
 866                 void *data,
 867                 void *userdata) {
 868
 869         AddressFamilyBoolean *dhcp = data, s;
 870
 871         assert(filename);
 872         assert(lvalue);
 873         assert(rvalue);
 874         assert(data);
 875
 876         /* Note that this is mostly like
 877          * config_parse_address_family_boolean(), except that it
 878          * understands some old names for the enum values */
 879
 880         s = address_family_boolean_from_string(rvalue);
 881         if (s < 0) {
 882
 883                 /* Previously, we had a slightly different enum here,
 884                  * support its values for compatibility. */
 885
 886                 if (streq(rvalue, "none"))
 887                         s = ADDRESS_FAMILY_NO;
 888                 else if (streq(rvalue, "v4"))
 889                         s = ADDRESS_FAMILY_IPV4;
 890                 else if (streq(rvalue, "v6"))
 891                         s = ADDRESS_FAMILY_IPV6;
 892                 else if (streq(rvalue, "both"))
 893                         s = ADDRESS_FAMILY_YES;
 894                 else {
 895                         log_syntax(unit, LOG_ERR, filename, line, 0,
 896                                    "Failed to parse DHCP option, ignoring: %s", rvalue);
 897                         return 0;
 898                 }
 899
 900                 log_syntax(unit, LOG_WARNING, filename, line, 0,
 901                            "DHCP=%s is deprecated, please use DHCP=%s instead.",
 902                            rvalue, address_family_boolean_to_string(s));
 903         }
 904
 905         *dhcp = s;
 906         return 0;
 907 }
 908
 909 static const char* const dhcp_client_identifier_table[_DHCP_CLIENT_ID_MAX] = {
 910         [DHCP_CLIENT_ID_MAC] = "mac",
 911         [DHCP_CLIENT_ID_DUID] = "duid",
 912         [DHCP_CLIENT_ID_DUID_ONLY] = "duid-only",
 913 };
 914
 915 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING(dhcp_client_identifier, DHCPClientIdentifier);
 916 DEFINE_CONFIG_PARSE_ENUM(config_parse_dhcp_client_identifier, dhcp_client_identifier, DHCPClientIdentifier,
 917                          "Failed to parse client identifier type");
 918
 919 int config_parse_ipv6token(
 920                 const char* unit,
 921                 const char *filename,
 922                 unsigned line,
 923                 const char *section,
 924                 unsigned section_line,
 925                 const char *lvalue,
 926                 int ltype,
 927                 const char *rvalue,
 928                 void *data,
 929                 void *userdata) {
 930
 931         union in_addr_union buffer;
 932         struct in6_addr *token = data;
 933         int r;
 934
 935         assert(filename);
 936         assert(lvalue);
 937         assert(rvalue);
 938         assert(token);
 939
 940         r = in_addr_from_string(AF_INET6, rvalue, &buffer);
 941         if (r < 0) {
 942                 log_syntax(unit, LOG_ERR, filename, line, r,
 943                            "Failed to parse IPv6 token, ignoring: %s", rvalue);
 944                 return 0;
 945         }
 946
 947         if (in_addr_is_null(AF_INET6, &buffer)) {
 948                 log_syntax(unit, LOG_ERR, filename, line, 0,
 949                            "IPv6 token cannot be the ANY address, ignoring: %s", rvalue);
 950                 return 0;
 951         }
 952
 953         if ((buffer.in6.s6_addr32[0] | buffer.in6.s6_addr32[1]) != 0) {
 954                 log_syntax(unit, LOG_ERR, filename, line, 0,
 955                            "IPv6 token cannot be longer than 64 bits, ignoring: %s", rvalue);
 956                 return 0;
 957         }
 958
 959         *token = buffer.in6;
 960
 961         return 0;
 962 }
 963
 964 static const char* const ipv6_privacy_extensions_table[_IPV6_PRIVACY_EXTENSIONS_MAX] = {
 965         [IPV6_PRIVACY_EXTENSIONS_NO] = "no",
 966         [IPV6_PRIVACY_EXTENSIONS_PREFER_PUBLIC] = "prefer-public",
 967         [IPV6_PRIVACY_EXTENSIONS_YES] = "yes",
 968 };
 969
 970 DEFINE_STRING_TABLE_LOOKUP(ipv6_privacy_extensions, IPv6PrivacyExtensions);
 971
 972 int config_parse_ipv6_privacy_extensions(
 973                 const char* unit,
 974                 const char *filename,
 975                 unsigned line,
 976                 const char *section,
 977                 unsigned section_line,
 978                 const char *lvalue,
 979                 int ltype,
 980                 const char *rvalue,
 981                 void *data,
 982                 void *userdata) {
 983
 984         IPv6PrivacyExtensions *ipv6_privacy_extensions = data;
 985         int k;
 986
 987         assert(filename);
 988         assert(lvalue);
 989         assert(rvalue);
 990         assert(ipv6_privacy_extensions);
 991
 992         /* Our enum shall be a superset of booleans, hence first try
 993          * to parse as boolean, and then as enum */
 994
 995         k = parse_boolean(rvalue);
 996         if (k > 0)
 997                 *ipv6_privacy_extensions = IPV6_PRIVACY_EXTENSIONS_YES;
 998         else if (k == 0)
 999                 *ipv6_privacy_extensions = IPV6_PRIVACY_EXTENSIONS_NO;
1000         else {
1001                 IPv6PrivacyExtensions s;
1002
1003                 s = ipv6_privacy_extensions_from_string(rvalue);
1004                 if (s < 0) {
1005
1006                         if (streq(rvalue, "kernel"))
1007                                 s = _IPV6_PRIVACY_EXTENSIONS_INVALID;
1008                         else {
1009                                 log_syntax(unit, LOG_ERR, filename, line, 0,
1010                                            "Failed to parse IPv6 privacy extensions option, ignoring: %s", rvalue);
1011                                 return 0;
1012                         }
1013                 }
1014
1015                 *ipv6_privacy_extensions = s;
1016         }
1017
1018         return 0;
1019 }
1020
1021 int config_parse_hostname(
1022                 const char *unit,
1023                 const char *filename,
1024                 unsigned line,
1025                 const char *section,
1026                 unsigned section_line,
1027                 const char *lvalue,
1028                 int ltype,
1029                 const char *rvalue,
1030                 void *data,
1031                 void *userdata) {
1032
1033         _cleanup_free_ char *hn = NULL;
1034         char **hostname = data;
1035         int r;
1036
1037         assert(filename);
1038         assert(lvalue);
1039         assert(rvalue);
1040
1041         r = config_parse_string(unit, filename, line, section, section_line, lvalue, ltype, rvalue, &hn, userdata);
1042         if (r < 0)
1043                 return r;
1044
1045         if (!hostname_is_valid(hn, false)) {
1046                 log_syntax(unit, LOG_ERR, filename, line, 0,
1047                            "Hostname is not valid, ignoring assignment: %s", rvalue);
1048                 return 0;
1049         }
1050
1051         r = dns_name_is_valid(hn);
1052         if (r < 0) {
1053                 log_syntax(unit, LOG_ERR, filename, line, r,
1054                            "Failed to check validity of hostname '%s', ignoring assignment: %m", rvalue);
1055                 return 0;
1056         }
1057         if (r == 0) {
1058                 log_syntax(unit, LOG_ERR, filename, line, 0,
1059                            "Hostname is not a valid DNS domain name, ignoring assignment: %s", rvalue);
1060                 return 0;
1061         }
1062
1063         return free_and_replace(*hostname, hn);
1064 }
1065
1066 int config_parse_timezone(
1067                 const char *unit,
1068                 const char *filename,
1069                 unsigned line,
1070                 const char *section,
1071                 unsigned section_line,
1072                 const char *lvalue,
1073                 int ltype,
1074                 const char *rvalue,
1075                 void *data,
1076                 void *userdata) {
1077
1078         _cleanup_free_ char *tz = NULL;
1079         char **datap = data;
1080         int r;
1081
1082         assert(filename);
1083         assert(lvalue);
1084         assert(rvalue);
1085
1086         r = config_parse_string(unit, filename, line, section, section_line, lvalue, ltype, rvalue, &tz, userdata);
1087         if (r < 0)
1088                 return r;
1089
1090         if (!timezone_is_valid(tz, LOG_ERR)) {
1091                 log_syntax(unit, LOG_ERR, filename, line, 0,
1092                            "Timezone is not valid, ignoring assignment: %s", rvalue);
1093                 return 0;
1094         }
1095
1096         return free_and_replace(*datap, tz);
1097 }
1098
1099 int config_parse_dhcp_server_dns(
1100                 const char *unit,
1101                 const char *filename,
1102                 unsigned line,
1103                 const char *section,
1104                 unsigned section_line,
1105                 const char *lvalue,
1106                 int ltype,
1107                 const char *rvalue,
1108                 void *data,
1109                 void *userdata) {
1110
1111         Network *n = data;
1112         const char *p = rvalue;
1113         int r;
1114
1115         assert(filename);
1116         assert(lvalue);
1117         assert(rvalue);
1118
1119         for (;;) {
1120                 _cleanup_free_ char *w = NULL;
1121                 struct in_addr a, *m;
1122
1123                 r = extract_first_word(&p, &w, NULL, 0);
1124                 if (r == -ENOMEM)
1125                         return log_oom();
1126                 if (r < 0) {
1127                         log_syntax(unit, LOG_ERR, filename, line, r,
1128                                    "Failed to extract word, ignoring: %s", rvalue);
1129                         return 0;
1130                 }
1131                 if (r == 0)
1132                         break;
1133
1134                 if (inet_pton(AF_INET, w, &a) <= 0) {
1135                         log_syntax(unit, LOG_ERR, filename, line, 0,
1136                                    "Failed to parse DNS server address, ignoring: %s", w);
1137                         continue;
1138                 }
1139
1140                 m = reallocarray(n->dhcp_server_dns, n->n_dhcp_server_dns + 1, sizeof(struct in_addr));
1141                 if (!m)
1142                         return log_oom();
1143
1144                 m[n->n_dhcp_server_dns++] = a;
1145                 n->dhcp_server_dns = m;
1146         }
1147
1148         return 0;
1149 }
1150
1151 int config_parse_radv_dns(
1152                 const char *unit,
1153                 const char *filename,
1154                 unsigned line,
1155                 const char *section,
1156                 unsigned section_line,
1157                 const char *lvalue,
1158                 int ltype,
1159                 const char *rvalue,
1160                 void *data,
1161                 void *userdata) {
1162
1163         Network *n = data;
1164         const char *p = rvalue;
1165         int r;
1166
1167         assert(filename);
1168         assert(lvalue);
1169         assert(rvalue);
1170
1171         for (;;) {
1172                 _cleanup_free_ char *w = NULL;
1173                 union in_addr_union a;
1174
1175                 r = extract_first_word(&p, &w, NULL, 0);
1176                 if (r == -ENOMEM)
1177                         return log_oom();
1178                 if (r < 0) {
1179                         log_syntax(unit, LOG_ERR, filename, line, r,
1180                                    "Failed to extract word, ignoring: %s", rvalue);
1181                         return 0;
1182                 }
1183                 if (r == 0)
1184                         break;
1185
1186                 if (in_addr_from_string(AF_INET6, w, &a) >= 0) {
1187                         struct in6_addr *m;
1188
1189                         m = reallocarray(n->router_dns, n->n_router_dns + 1, sizeof(struct in6_addr));
1190                         if (!m)
1191                                 return log_oom();
1192
1193                         m[n->n_router_dns++] = a.in6;
1194                         n->router_dns = m;
1195
1196                 } else
1197                         log_syntax(unit, LOG_ERR, filename, line, 0,
1198                                    "Failed to parse DNS server address, ignoring: %s", w);
1199         }
1200
1201         return 0;
1202 }
1203
1204 int config_parse_radv_search_domains(
1205                 const char *unit,
1206                 const char *filename,
1207                 unsigned line,
1208                 const char *section,
1209                 unsigned section_line,
1210                 const char *lvalue,
1211                 int ltype,
1212                 const char *rvalue,
1213                 void *data,
1214                 void *userdata) {
1215
1216         Network *n = data;
1217         const char *p = rvalue;
1218         int r;
1219
1220         assert(filename);
1221         assert(lvalue);
1222         assert(rvalue);
1223
1224         for (;;) {
1225                 _cleanup_free_ char *w = NULL, *idna = NULL;
1226
1227                 r = extract_first_word(&p, &w, NULL, 0);
1228                 if (r == -ENOMEM)
1229                         return log_oom();
1230                 if (r < 0) {
1231                         log_syntax(unit, LOG_ERR, filename, line, r,
1232                                    "Failed to extract word, ignoring: %s", rvalue);
1233                         return 0;
1234                 }
1235                 if (r == 0)
1236                         break;
1237
1238                 r = dns_name_apply_idna(w, &idna);
1239                 if (r < 0) {
1240                         log_syntax(unit, LOG_ERR, filename, line, r,
1241                                    "Failed to apply IDNA to domain name '%s', ignoring: %m", w);
1242                         continue;
1243                 } else if (r == 0)
1244                         /* transfer ownership to simplify subsequent operations */
1245                         idna = TAKE_PTR(w);
1246
1247                 r = ordered_set_ensure_allocated(&n->router_search_domains, &string_hash_ops);
1248                 if (r < 0)
1249                         return r;
1250
1251                 r = ordered_set_consume(n->router_search_domains, TAKE_PTR(idna));
1252                 if (r < 0)
1253                         return r;
1254         }
1255
1256         return 0;
1257 }
1258
1259 int config_parse_dhcp_server_ntp(
1260                 const char *unit,
1261                 const char *filename,
1262                 unsigned line,
1263                 const char *section,
1264                 unsigned section_line,
1265                 const char *lvalue,
1266                 int ltype,
1267                 const char *rvalue,
1268                 void *data,
1269                 void *userdata) {
1270
1271         Network *n = data;
1272         const char *p = rvalue;
1273         int r;
1274
1275         assert(filename);
1276         assert(lvalue);
1277         assert(rvalue);
1278
1279         for (;;) {
1280                 _cleanup_free_ char *w = NULL;
1281                 struct in_addr a, *m;
1282
1283                 r = extract_first_word(&p, &w, NULL, 0);
1284                 if (r == -ENOMEM)
1285                         return log_oom();
1286                 if (r < 0) {
1287                         log_syntax(unit, LOG_ERR, filename, line, r,
1288                                    "Failed to extract word, ignoring: %s", rvalue);
1289                         return 0;
1290                 }
1291                 if (r == 0)
1292                         return 0;
1293
1294                 if (inet_pton(AF_INET, w, &a) <= 0) {
1295                         log_syntax(unit, LOG_ERR, filename, line, 0,
1296                                    "Failed to parse NTP server address, ignoring: %s", w);
1297                         continue;
1298                 }
1299
1300                 m = reallocarray(n->dhcp_server_ntp, n->n_dhcp_server_ntp + 1, sizeof(struct in_addr));
1301                 if (!m)
1302                         return log_oom();
1303
1304                 m[n->n_dhcp_server_ntp++] = a;
1305                 n->dhcp_server_ntp = m;
1306         }
1307 }
1308
1309 int config_parse_dns(
1310                 const char *unit,
1311                 const char *filename,
1312                 unsigned line,
1313                 const char *section,
1314                 unsigned section_line,
1315                 const char *lvalue,
1316                 int ltype,
1317                 const char *rvalue,
1318                 void *data,
1319                 void *userdata) {
1320
1321         Network *n = userdata;
1322         int r;
1323
1324         assert(filename);
1325         assert(lvalue);
1326         assert(rvalue);
1327
1328         for (;;) {
1329                 _cleanup_free_ char *w = NULL;
1330                 union in_addr_union a;
1331                 struct in_addr_data *m;
1332                 int family;
1333
1334                 r = extract_first_word(&rvalue, &w, NULL, 0);
1335                 if (r == -ENOMEM)
1336                         return log_oom();
1337                 if (r < 0) {
1338                         log_syntax(unit, LOG_ERR, filename, line, r,
1339                                    "Invalid syntax, ignoring: %s", rvalue);
1340                         break;
1341                 }
1342                 if (r == 0)
1343                         break;
1344
1345                 r = in_addr_from_string_auto(w, &family, &a);
1346                 if (r < 0) {
1347                         log_syntax(unit, LOG_ERR, filename, line, r,
1348                                    "Failed to parse dns server address, ignoring: %s", w);
1349                         continue;
1350                 }
1351
1352                 m = reallocarray(n->dns, n->n_dns + 1, sizeof(struct in_addr_data));
1353                 if (!m)
1354                         return log_oom();
1355
1356                 m[n->n_dns++] = (struct in_addr_data) {
1357                         .family = family,
1358                         .address = a,
1359                 };
1360
1361                 n->dns = m;
1362         }
1363
1364         return 0;
1365 }
1366
1367 int config_parse_dnssec_negative_trust_anchors(
1368                 const char *unit,
1369                 const char *filename,
1370                 unsigned line,
1371                 const char *section,
1372                 unsigned section_line,
1373                 const char *lvalue,
1374                 int ltype,
1375                 const char *rvalue,
1376                 void *data,
1377                 void *userdata) {
1378
1379         const char *p = rvalue;
1380         Network *n = data;
1381         int r;
1382
1383         assert(n);
1384         assert(lvalue);
1385         assert(rvalue);
1386
1387         if (isempty(rvalue)) {
1388                 n->dnssec_negative_trust_anchors = set_free_free(n->dnssec_negative_trust_anchors);
1389                 return 0;
1390         }
1391
1392         for (;;) {
1393                 _cleanup_free_ char *w = NULL;
1394
1395                 r = extract_first_word(&p, &w, NULL, 0);
1396                 if (r < 0) {
1397                         log_syntax(unit, LOG_ERR, filename, line, r,
1398                                    "Failed to extract negative trust anchor domain, ignoring: %s", rvalue);
1399                         break;
1400                 }
1401                 if (r == 0)
1402                         break;
1403
1404                 r = dns_name_is_valid(w);
1405                 if (r <= 0) {
1406                         log_syntax(unit, LOG_ERR, filename, line, r,
1407                                    "%s is not a valid domain name, ignoring.", w);
1408                         continue;
1409                 }
1410
1411                 r = set_ensure_allocated(&n->dnssec_negative_trust_anchors, &dns_name_hash_ops);
1412                 if (r < 0)
1413                         return log_oom();
1414
1415                 r = set_put(n->dnssec_negative_trust_anchors, w);
1416                 if (r < 0)
1417                         return log_oom();
1418                 if (r > 0)
1419                         w = NULL;
1420         }
1421
1422         return 0;
1423 }
1424
1425 int config_parse_ntp(
1426                 const char *unit,
1427                 const char *filename,
1428                 unsigned line,
1429                 const char *section,
1430                 unsigned section_line,
1431                 const char *lvalue,
1432                 int ltype,
1433                 const char *rvalue,
1434                 void *data,
1435                 void *userdata) {
1436
1437         char ***l = data;
1438         int r;
1439
1440         assert(l);
1441         assert(lvalue);
1442         assert(rvalue);
1443
1444         if (isempty(rvalue)) {
1445                 *l = strv_free(*l);
1446                 return 0;
1447         }
1448
1449         for (;;) {
1450                 _cleanup_free_ char *w = NULL;
1451
1452                 r = extract_first_word(&rvalue, &w, NULL, 0);
1453                 if (r == -ENOMEM)
1454                         return log_oom();
1455                 if (r < 0) {
1456                         log_syntax(unit, LOG_ERR, filename, line, r,
1457                                    "Failed to extract NTP server name, ignoring: %s", rvalue);
1458                         break;
1459                 }
1460                 if (r == 0)
1461                         break;
1462
1463                 r = dns_name_is_valid_or_address(w);
1464                 if (r <= 0) {
1465                         log_syntax(unit, LOG_ERR, filename, line, r,
1466                                    "%s is not a valid domain name or IP address, ignoring.", w);
1467                         continue;
1468                 }
1469
1470                 if (strv_length(*l) > MAX_NTP_SERVERS) {
1471                         log_syntax(unit, LOG_WARNING, filename, line, 0,
1472                                    "More than %u NTP servers specified, ignoring \"%s\" and any subsequent entries.",
1473                                    MAX_NTP_SERVERS, w);
1474                         break;
1475                 }
1476
1477                 r = strv_consume(l, TAKE_PTR(w));
1478                 if (r < 0)
1479                         return log_oom();
1480         }
1481
1482         return 0;
1483 }
1484
1485 int config_parse_dhcp_user_class(
1486                 const char *unit,
1487                 const char *filename,
1488                 unsigned line,
1489                 const char *section,
1490                 unsigned section_line,
1491                 const char *lvalue,
1492                 int ltype,
1493                 const char *rvalue,
1494                 void *data,
1495                 void *userdata) {
1496
1497         char ***l = data;
1498         int r;
1499
1500         assert(l);
1501         assert(lvalue);
1502         assert(rvalue);
1503
1504         if (isempty(rvalue)) {
1505                 *l = strv_free(*l);
1506                 return 0;
1507         }
1508
1509         for (;;) {
1510                 _cleanup_free_ char *w = NULL;
1511
1512                 r = extract_first_word(&rvalue, &w, NULL, 0);
1513                 if (r == -ENOMEM)
1514                         return log_oom();
1515                 if (r < 0) {
1516                         log_syntax(unit, LOG_ERR, filename, line, r,
1517                                    "Failed to split user classes option, ignoring: %s", rvalue);
1518                         break;
1519                 }
1520                 if (r == 0)
1521                         break;
1522
1523                 if (strlen(w) > 255) {
1524                         log_syntax(unit, LOG_ERR, filename, line, 0,
1525                                    "%s length is not in the range 1-255, ignoring.", w);
1526                         continue;
1527                 }
1528
1529                 r = strv_push(l, w);
1530                 if (r < 0)
1531                         return log_oom();
1532
1533                 w = NULL;
1534         }
1535
1536         return 0;
1537 }
1538
1539 int config_parse_section_route_table(
1540                 const char *unit,
1541                 const char *filename,
1542                 unsigned line,
1543                 const char *section,
1544                 unsigned section_line,
1545                 const char *lvalue,
1546                 int ltype,
1547                 const char *rvalue,
1548                 void *data,
1549                 void *userdata) {
1550
1551         Network *network = data;
1552         uint32_t rt;
1553         int r;
1554
1555         assert(filename);
1556         assert(lvalue);
1557         assert(rvalue);
1558         assert(data);
1559
1560         r = safe_atou32(rvalue, &rt);
1561         if (r < 0) {
1562                 log_syntax(unit, LOG_ERR, filename, line, r,
1563                            "Failed to parse RouteTable=%s, ignoring assignment: %m", rvalue);
1564                 return 0;
1565         }
1566
1567         if (streq_ptr(section, "DHCP")) {
1568                 network->dhcp_route_table = rt;
1569                 network->dhcp_route_table_set = true;
1570         } else { /* section is IPv6AcceptRA */
1571                 network->ipv6_accept_ra_route_table = rt;
1572                 network->ipv6_accept_ra_route_table_set = true;
1573         }
1574
1575         return 0;
1576 }
1577
1578 int config_parse_dhcp_max_attempts(
1579                 const char *unit,
1580                 const char *filename,
1581                 unsigned line,
1582                 const char *section,
1583                 unsigned section_line,
1584                 const char *lvalue,
1585                 int ltype,
1586                 const char *rvalue,
1587                 void *data,
1588                 void *userdata) {
1589
1590         Network *network = data;
1591         uint64_t a;
1592         int r;
1593
1594         assert(network);
1595         assert(lvalue);
1596         assert(rvalue);
1597
1598         if (isempty(rvalue)) {
1599                 network->dhcp_max_attempts = 0;
1600                 return 0;
1601         }
1602
1603         if (streq(rvalue, "infinity")) {
1604                 network->dhcp_max_attempts = (uint64_t) -1;
1605                 return 0;
1606         }
1607
1608         r = safe_atou64(rvalue, &a);
1609         if (r < 0) {
1610                 log_syntax(unit, LOG_ERR, filename, line, r,
1611                            "Failed to parse DHCP maximum attempts, ignoring: %s", rvalue);
1612                 return 0;
1613         }
1614
1615         if (a == 0) {
1616                 log_syntax(unit, LOG_ERR, filename, line, 0,
1617                            "%s= must be positive integer or 'infinity', ignoring: %s", lvalue, rvalue);
1618                 return 0;
1619         }
1620
1621         network->dhcp_max_attempts = a;
1622
1623         return 0;
1624 }
1625
1626 DEFINE_CONFIG_PARSE_ENUM(config_parse_dhcp_use_domains, dhcp_use_domains, DHCPUseDomains,
1627                          "Failed to parse DHCP use domains setting");
1628
1629 static const char* const dhcp_use_domains_table[_DHCP_USE_DOMAINS_MAX] = {
1630         [DHCP_USE_DOMAINS_NO] = "no",
1631         [DHCP_USE_DOMAINS_ROUTE] = "route",
1632         [DHCP_USE_DOMAINS_YES] = "yes",
1633 };
1634
1635 DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(dhcp_use_domains, DHCPUseDomains, DHCP_USE_DOMAINS_YES);
1636
1637 DEFINE_CONFIG_PARSE_ENUM(config_parse_lldp_mode, lldp_mode, LLDPMode, "Failed to parse LLDP= setting.");
1638
1639 static const char* const lldp_mode_table[_LLDP_MODE_MAX] = {
1640         [LLDP_MODE_NO] = "no",
1641         [LLDP_MODE_YES] = "yes",
1642         [LLDP_MODE_ROUTERS_ONLY] = "routers-only",
1643 };
1644
1645 DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(lldp_mode, LLDPMode, LLDP_MODE_YES);
1646
1647 int config_parse_iaid(const char *unit,
1648                       const char *filename,
1649                       unsigned line,
1650                       const char *section,
1651                       unsigned section_line,
1652                       const char *lvalue,
1653                       int ltype,
1654                       const char *rvalue,
1655                       void *data,
1656                       void *userdata) {
1657         Network *network = data;
1658         uint32_t iaid;
1659         int r;
1660
1661         assert(filename);
1662         assert(lvalue);
1663         assert(rvalue);
1664         assert(network);
1665
1666         r = safe_atou32(rvalue, &iaid);
1667         if (r < 0) {
1668                 log_syntax(unit, LOG_ERR, filename, line, r,
1669                            "Unable to read IAID, ignoring assignment: %s", rvalue);
1670                 return 0;
1671         }
1672
1673         network->iaid = iaid;
1674         network->iaid_set = true;
1675
1676         return 0;
1677 }
1678
1679 int config_parse_required_for_online(
1680                 const char *unit,
1681                 const char *filename,
1682                 unsigned line,
1683                 const char *section,
1684                 unsigned section_line,
1685                 const char *lvalue,
1686                 int ltype,
1687                 const char *rvalue,
1688                 void *data,
1689                 void *userdata) {
1690
1691         Network *network = data;
1692         LinkOperationalState s;
1693         bool required = true;
1694         int r;
1695
1696         if (isempty(rvalue)) {
1697                 network->required_for_online = true;
1698                 network->required_operstate_for_online = LINK_OPERSTATE_DEGRADED;
1699                 return 0;
1700         }
1701
1702         s = link_operstate_from_string(rvalue);
1703         if (s < 0) {
1704                 r = parse_boolean(rvalue);
1705                 if (r < 0) {
1706                         log_syntax(unit, LOG_ERR, filename, line, r,
1707                                    "Failed to parse %s= setting, ignoring assignment: %s",
1708                                    lvalue, rvalue);
1709                         return 0;
1710                 }
1711
1712                 required = r;
1713                 s = LINK_OPERSTATE_DEGRADED;
1714         }
1715
1716         network->required_for_online = required;
1717         network->required_operstate_for_online = s;
1718
1719         return 0;
1720 }