src/network/networkd-network.c

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