src/network/networkd-network.c

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