src/network/networkd-network.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <net/if.h>
   4 #include <netinet/in.h>
   5 #include <linux/netdevice.h>
   6 #include <unistd.h>
   7
   8 #include "alloc-util.h"
   9 #include "conf-files.h"
  10 #include "conf-parser.h"
  11 #include "dns-domain.h"
  12 #include "fd-util.h"
  13 #include "hostname-util.h"
  14 #include "in-addr-util.h"
  15 #include "networkd-dhcp-server.h"
  16 #include "network-internal.h"
  17 #include "networkd-manager.h"
  18 #include "networkd-network.h"
  19 #include "parse-util.h"
  20 #include "path-lookup.h"
  21 #include "set.h"
  22 #include "socket-util.h"
  23 #include "stat-util.h"
  24 #include "string-table.h"
  25 #include "string-util.h"
  26 #include "strv.h"
  27 #include "tc.h"
  28 #include "util.h"
  29
  30 /* Let's assume that anything above this number is a user misconfiguration. */
  31 #define MAX_NTP_SERVERS 128
  32
  33 /* Set defaults following RFC7844 */
  34 void network_apply_anonymize_if_set(Network *network) {
  35         if (!network->dhcp_anonymize)
  36                 return;
  37         /* RFC7844 3.7
  38          SHOULD NOT send the Host Name option */
  39         network->dhcp_send_hostname = false;
  40         /* RFC7844 section 3.:
  41          MAY contain the Client Identifier option
  42          Section 3.5:
  43          clients MUST use client identifiers based solely
  44          on the link-layer address */
  45         /* NOTE: Using MAC, as it does not reveal extra information,
  46         * and some servers might not answer if this option is not sent */
  47         network->dhcp_client_identifier = DHCP_CLIENT_ID_MAC;
  48         /* RFC 7844 3.10:
  49          SHOULD NOT use the Vendor Class Identifier option */
  50         network->dhcp_vendor_class_identifier = mfree(network->dhcp_vendor_class_identifier);
  51         /* RFC7844 section 3.6.:
  52          The client intending to protect its privacy SHOULD only request a
  53          minimal number of options in the PRL and SHOULD also randomly shuffle
  54          the ordering of option codes in the PRL.  If this random ordering
  55          cannot be implemented, the client MAY order the option codes in the
  56          PRL by option code number (lowest to highest).
  57         */
  58         /* NOTE: dhcp_use_mtu is false by default,
  59         * though it was not initiallized to any value in network_load_one.
  60         * Maybe there should be another var called *send*?
  61         * (to use the MTU sent by the server but to do not send
  62         * the option in the PRL). */
  63         network->dhcp_use_mtu = false;
  64         /* NOTE: when Anonymize=yes, the PRL route options are sent by default,
  65          * but this is needed to use them. */
  66         network->dhcp_use_routes = true;
  67         /* RFC7844 section 3.6.
  68         * same comments as previous option */
  69         network->dhcp_use_timezone = false;
  70 }
  71
  72 static int network_resolve_netdev_one(Network *network, const char *name, NetDevKind kind, NetDev **ret_netdev) {
  73         const char *kind_string;
  74         NetDev *netdev;
  75         int r;
  76
  77         /* For test-networkd-conf, the check must be earlier than the assertions. */
  78         if (!name)
  79                 return 0;
  80
  81         assert(network);
  82         assert(network->manager);
  83         assert(network->filename);
  84         assert(ret_netdev);
  85
  86         if (kind == _NETDEV_KIND_TUNNEL)
  87                 kind_string = "tunnel";
  88         else {
  89                 kind_string = netdev_kind_to_string(kind);
  90                 if (!kind_string)
  91                         return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
  92                                                "%s: Invalid NetDev kind of %s, ignoring assignment.",
  93                                                network->filename, name);
  94         }
  95
  96         r = netdev_get(network->manager, name, &netdev);
  97         if (r < 0)
  98                 return log_error_errno(r, "%s: %s NetDev could not be found, ignoring assignment.",
  99                                        network->filename, name);
 100
 101         if (netdev->kind != kind && !(kind == _NETDEV_KIND_TUNNEL &&
 102                                       IN_SET(netdev->kind,
 103                                              NETDEV_KIND_IPIP,
 104                                              NETDEV_KIND_SIT,
 105                                              NETDEV_KIND_GRE,
 106                                              NETDEV_KIND_GRETAP,
 107                                              NETDEV_KIND_IP6GRE,
 108                                              NETDEV_KIND_IP6GRETAP,
 109                                              NETDEV_KIND_VTI,
 110                                              NETDEV_KIND_VTI6,
 111                                              NETDEV_KIND_IP6TNL,
 112                                              NETDEV_KIND_ERSPAN)))
 113                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 114                                        "%s: NetDev %s is not a %s, ignoring assignment",
 115                                        network->filename, name, kind_string);
 116
 117         *ret_netdev = netdev_ref(netdev);
 118         return 1;
 119 }
 120
 121 static int network_resolve_stacked_netdevs(Network *network) {
 122         void *name, *kind;
 123         Iterator i;
 124         int r;
 125
 126         assert(network);
 127
 128         HASHMAP_FOREACH_KEY(kind, name, network->stacked_netdev_names, i) {
 129                 _cleanup_(netdev_unrefp) NetDev *netdev = NULL;
 130
 131                 r = network_resolve_netdev_one(network, name, PTR_TO_INT(kind), &netdev);
 132                 if (r <= 0)
 133                         continue;
 134
 135                 r = hashmap_ensure_allocated(&network->stacked_netdevs, &string_hash_ops);
 136                 if (r < 0)
 137                         return log_oom();
 138
 139                 r = hashmap_put(network->stacked_netdevs, netdev->ifname, netdev);
 140                 if (r < 0)
 141                         return log_error_errno(r, "%s: Failed to add NetDev '%s' to network: %m",
 142                                                network->filename, (const char *) name);
 143
 144                 netdev = NULL;
 145         }
 146
 147         return 0;
 148 }
 149
 150 int network_verify(Network *network) {
 151         RoutePrefix *route_prefix, *route_prefix_next;
 152         RoutingPolicyRule *rule, *rule_next;
 153         Neighbor *neighbor, *neighbor_next;
 154         AddressLabel *label, *label_next;
 155         NextHop *nexthop, *nextnop_next;
 156         Address *address, *address_next;
 157         Prefix *prefix, *prefix_next;
 158         Route *route, *route_next;
 159         FdbEntry *fdb, *fdb_next;
 160         TrafficControl *tc;
 161         Iterator i;
 162
 163         assert(network);
 164         assert(network->filename);
 165
 166         if (set_isempty(network->match_mac) && set_isempty(network->match_permanent_mac) &&
 167             strv_isempty(network->match_path) && strv_isempty(network->match_driver) &&
 168             strv_isempty(network->match_type) && strv_isempty(network->match_name) &&
 169             strv_isempty(network->match_property) && strv_isempty(network->match_wlan_iftype) &&
 170             strv_isempty(network->match_ssid) && !network->conditions)
 171                 return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
 172                                          "%s: No valid settings found in the [Match] section, ignoring file. "
 173                                          "To match all interfaces, add Name=* in the [Match] section.",
 174                                          network->filename);
 175
 176         /* skip out early if configuration does not match the environment */
 177         if (!condition_test_list(network->conditions, environ, NULL, NULL, NULL))
 178                 return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
 179                                        "%s: Conditions in the file do not match the system environment, skipping.",
 180                                        network->filename);
 181
 182         (void) network_resolve_netdev_one(network, network->bond_name, NETDEV_KIND_BOND, &network->bond);
 183         (void) network_resolve_netdev_one(network, network->bridge_name, NETDEV_KIND_BRIDGE, &network->bridge);
 184         (void) network_resolve_netdev_one(network, network->vrf_name, NETDEV_KIND_VRF, &network->vrf);
 185         (void) network_resolve_stacked_netdevs(network);
 186
 187         /* Free unnecessary entries. */
 188         network->bond_name = mfree(network->bond_name);
 189         network->bridge_name = mfree(network->bridge_name);
 190         network->vrf_name = mfree(network->vrf_name);
 191         network->stacked_netdev_names = hashmap_free_free_key(network->stacked_netdev_names);
 192
 193         if (network->bond) {
 194                 /* Bonding slave does not support addressing. */
 195                 if (network->ipv6_accept_ra > 0) {
 196                         log_warning("%s: Cannot enable IPv6AcceptRA= when Bond= is specified, disabling IPv6AcceptRA=.",
 197                                     network->filename);
 198                         network->ipv6_accept_ra = 0;
 199                 }
 200                 if (network->link_local >= 0 && network->link_local != ADDRESS_FAMILY_NO) {
 201                         log_warning("%s: Cannot enable LinkLocalAddressing= when Bond= is specified, disabling LinkLocalAddressing=.",
 202                                     network->filename);
 203                         network->link_local = ADDRESS_FAMILY_NO;
 204                 }
 205                 if (network->dhcp != ADDRESS_FAMILY_NO) {
 206                         log_warning("%s: Cannot enable DHCP= when Bond= is specified, disabling DHCP=.",
 207                                     network->filename);
 208                         network->dhcp = ADDRESS_FAMILY_NO;
 209                 }
 210                 if (network->dhcp_server) {
 211                         log_warning("%s: Cannot enable DHCPServer= when Bond= is specified, disabling DHCPServer=.",
 212                                     network->filename);
 213                         network->dhcp_server = false;
 214                 }
 215                 if (network->n_static_addresses > 0) {
 216                         log_warning("%s: Cannot set addresses when Bond= is specified, ignoring addresses.",
 217                                     network->filename);
 218                         while ((address = network->static_addresses))
 219                                 address_free(address);
 220                 }
 221                 if (network->n_static_routes > 0) {
 222                         log_warning("%s: Cannot set routes when Bond= is specified, ignoring routes.",
 223                                     network->filename);
 224                         while ((route = network->static_routes))
 225                                 route_free(route);
 226                 }
 227         }
 228
 229         if (network->link_local < 0)
 230                 network->link_local = network->bridge ? ADDRESS_FAMILY_NO : ADDRESS_FAMILY_IPV6;
 231
 232         if (!FLAGS_SET(network->link_local, ADDRESS_FAMILY_IPV6)) {
 233                 if (network->ipv6_accept_ra > 0) {
 234                         log_warning("%s: IPv6AcceptRA= is enabled by the .network file but IPv6 link local addressing is disabled. "
 235                                     "Disabling IPv6AcceptRA=.", network->filename);
 236                         network->ipv6_accept_ra = false;
 237                 }
 238
 239                 if (FLAGS_SET(network->dhcp, ADDRESS_FAMILY_IPV6)) {
 240                         log_warning("%s: DHCPv6 client is enabled by the .network file but IPv6 link local addressing is disabled. "
 241                                     "Disabling DHCPv6 client.", network->filename);
 242                         SET_FLAG(network->dhcp, ADDRESS_FAMILY_IPV6, false);
 243                 }
 244
 245                 if (network->router_prefix_delegation != RADV_PREFIX_DELEGATION_NONE) {
 246                         log_warning("%s: IPv6PrefixDelegation= is enabled but IPv6 link local addressing is disabled. "
 247                                     "Disabling IPv6PrefixDelegation=.", network->filename);
 248                         network->router_prefix_delegation = RADV_PREFIX_DELEGATION_NONE;
 249                 }
 250         }
 251
 252         if (FLAGS_SET(network->link_local, ADDRESS_FAMILY_FALLBACK_IPV4) &&
 253             !FLAGS_SET(network->dhcp, ADDRESS_FAMILY_IPV4)) {
 254                 log_warning("%s: fallback assignment of IPv4 link local address is enabled but DHCPv4 is disabled. "
 255                             "Disabling the fallback assignment.", network->filename);
 256                 SET_FLAG(network->link_local, ADDRESS_FAMILY_FALLBACK_IPV4, false);
 257         }
 258
 259         if (network->ipv6_accept_ra < 0 && network->bridge)
 260                 network->ipv6_accept_ra = false;
 261
 262         /* IPMasquerade=yes implies IPForward=yes */
 263         if (network->ip_masquerade)
 264                 network->ip_forward |= ADDRESS_FAMILY_IPV4;
 265
 266         if (network->mtu > 0 && network->dhcp_use_mtu) {
 267                 log_warning("%s: MTUBytes= in [Link] section and UseMTU= in [DHCP] section are set. "
 268                             "Disabling UseMTU=.", network->filename);
 269                 network->dhcp_use_mtu = false;
 270         }
 271
 272         if (network->dhcp_use_gateway < 0)
 273                 network->dhcp_use_gateway = network->dhcp_use_routes;
 274
 275         if (network->ignore_carrier_loss < 0)
 276                 network->ignore_carrier_loss = network->configure_without_carrier;
 277
 278         if (network->dhcp_critical >= 0) {
 279                 if (network->keep_configuration >= 0)
 280                         log_warning("%s: Both KeepConfiguration= and deprecated CriticalConnection= are set. "
 281                                     "Ignoring CriticalConnection=.", network->filename);
 282                 else if (network->dhcp_critical)
 283                         /* CriticalConnection=yes also preserve foreign static configurations. */
 284                         network->keep_configuration = KEEP_CONFIGURATION_YES;
 285                 else
 286                         network->keep_configuration = KEEP_CONFIGURATION_NO;
 287         }
 288
 289         if (network->keep_configuration < 0)
 290                 network->keep_configuration = KEEP_CONFIGURATION_NO;
 291
 292         LIST_FOREACH_SAFE(addresses, address, address_next, network->static_addresses)
 293                 if (address_section_verify(address) < 0)
 294                         address_free(address);
 295
 296         LIST_FOREACH_SAFE(routes, route, route_next, network->static_routes)
 297                 if (route_section_verify(route, network) < 0)
 298                         route_free(route);
 299
 300         LIST_FOREACH_SAFE(nexthops, nexthop, nextnop_next, network->static_nexthops)
 301                 if (nexthop_section_verify(nexthop) < 0)
 302                         nexthop_free(nexthop);
 303
 304         LIST_FOREACH_SAFE(static_fdb_entries, fdb, fdb_next, network->static_fdb_entries)
 305                 if (section_is_invalid(fdb->section))
 306                         fdb_entry_free(fdb);
 307
 308         LIST_FOREACH_SAFE(neighbors, neighbor, neighbor_next, network->neighbors)
 309                 if (neighbor_section_verify(neighbor) < 0)
 310                         neighbor_free(neighbor);
 311
 312         LIST_FOREACH_SAFE(labels, label, label_next, network->address_labels)
 313                 if (section_is_invalid(label->section))
 314                         address_label_free(label);
 315
 316         LIST_FOREACH_SAFE(prefixes, prefix, prefix_next, network->static_prefixes)
 317                 if (section_is_invalid(prefix->section))
 318                         prefix_free(prefix);
 319
 320         LIST_FOREACH_SAFE(route_prefixes, route_prefix, route_prefix_next, network->static_route_prefixes)
 321                 if (section_is_invalid(route_prefix->section))
 322                         route_prefix_free(route_prefix);
 323
 324         LIST_FOREACH_SAFE(rules, rule, rule_next, network->rules)
 325                 if (routing_policy_rule_section_verify(rule) < 0)
 326                         routing_policy_rule_free(rule);
 327
 328         bool has_root = false, has_clsact = false;
 329         ORDERED_HASHMAP_FOREACH(tc, network->tc_by_section, i)
 330                 if (traffic_control_section_verify(tc, &has_root, &has_clsact) < 0)
 331                         traffic_control_free(tc);
 332
 333         return 0;
 334 }
 335
 336 int network_load_one(Manager *manager, OrderedHashmap **networks, const char *filename) {
 337         _cleanup_free_ char *fname = NULL, *name = NULL;
 338         _cleanup_(network_unrefp) Network *network = NULL;
 339         _cleanup_fclose_ FILE *file = NULL;
 340         const char *dropin_dirname;
 341         char *d;
 342         int r;
 343
 344         assert(manager);
 345         assert(filename);
 346
 347         file = fopen(filename, "re");
 348         if (!file) {
 349                 if (errno == ENOENT)
 350                         return 0;
 351
 352                 return -errno;
 353         }
 354
 355         if (null_or_empty_fd(fileno(file))) {
 356                 log_debug("Skipping empty file: %s", filename);
 357                 return 0;
 358         }
 359
 360         fname = strdup(filename);
 361         if (!fname)
 362                 return log_oom();
 363
 364         name = strdup(basename(filename));
 365         if (!name)
 366                 return log_oom();
 367
 368         d = strrchr(name, '.');
 369         if (!d)
 370                 return -EINVAL;
 371
 372         *d = '\0';
 373
 374         dropin_dirname = strjoina(name, ".network.d");
 375
 376         network = new(Network, 1);
 377         if (!network)
 378                 return log_oom();
 379
 380         *network = (Network) {
 381                 .filename = TAKE_PTR(fname),
 382                 .name = TAKE_PTR(name),
 383
 384                 .manager = manager,
 385                 .n_ref = 1,
 386
 387                 .required_for_online = true,
 388                 .required_operstate_for_online = LINK_OPERSTATE_RANGE_DEFAULT,
 389                 .dhcp = ADDRESS_FAMILY_NO,
 390                 .dhcp_critical = -1,
 391                 .dhcp_use_ntp = true,
 392                 .dhcp_use_sip = true,
 393                 .dhcp_use_dns = true,
 394                 .dhcp_use_hostname = true,
 395                 .dhcp_use_routes = true,
 396                 .dhcp_use_gateway = -1,
 397                 /* NOTE: this var might be overwritten by network_apply_anonymize_if_set */
 398                 .dhcp_send_hostname = true,
 399                 .dhcp_send_release = true,
 400                 /* To enable/disable RFC7844 Anonymity Profiles */
 401                 .dhcp_anonymize = false,
 402                 .dhcp_route_metric = DHCP_ROUTE_METRIC,
 403                 /* NOTE: this var might be overwritten by network_apply_anonymize_if_set */
 404                 .dhcp_client_identifier = DHCP_CLIENT_ID_DUID,
 405                 .dhcp_route_table = RT_TABLE_MAIN,
 406                 .dhcp_route_table_set = false,
 407                 /* NOTE: from man: UseMTU=... Defaults to false*/
 408                 .dhcp_use_mtu = false,
 409                 /* NOTE: from man: UseTimezone=... Defaults to "no".*/
 410                 .dhcp_use_timezone = false,
 411                 .rapid_commit = true,
 412
 413                 .dhcp6_route_metric = DHCP_ROUTE_METRIC,
 414                 .dhcp6_use_ntp = true,
 415                 .dhcp6_use_dns = true,
 416
 417                 .dhcp6_pd_assign_prefix = true,
 418
 419                 .dhcp_server_emit[SD_DHCP_LEASE_DNS].emit = true,
 420                 .dhcp_server_emit[SD_DHCP_LEASE_NTP].emit = true,
 421                 .dhcp_server_emit[SD_DHCP_LEASE_SIP].emit = true,
 422
 423                 .dhcp_server_emit_router = true,
 424                 .dhcp_server_emit_timezone = true,
 425
 426                 .router_prefix_subnet_id = -1,
 427                 .router_emit_dns = true,
 428                 .router_emit_domains = true,
 429
 430                 .use_bpdu = -1,
 431                 .hairpin = -1,
 432                 .fast_leave = -1,
 433                 .allow_port_to_be_root = -1,
 434                 .unicast_flood = -1,
 435                 .multicast_flood = -1,
 436                 .multicast_to_unicast = -1,
 437                 .neighbor_suppression = -1,
 438                 .learning = -1,
 439                 .bridge_proxy_arp = -1,
 440                 .bridge_proxy_arp_wifi = -1,
 441                 .priority = LINK_BRIDGE_PORT_PRIORITY_INVALID,
 442                 .multicast_router = _MULTICAST_ROUTER_INVALID,
 443
 444                 .lldp_mode = LLDP_MODE_ROUTERS_ONLY,
 445
 446                 .dns_default_route = -1,
 447                 .llmnr = RESOLVE_SUPPORT_YES,
 448                 .mdns = RESOLVE_SUPPORT_NO,
 449                 .dnssec_mode = _DNSSEC_MODE_INVALID,
 450                 .dns_over_tls_mode = _DNS_OVER_TLS_MODE_INVALID,
 451
 452                 /* If LinkLocalAddressing= is not set, then set to ADDRESS_FAMILY_IPV6 later. */
 453                 .link_local = _ADDRESS_FAMILY_INVALID,
 454
 455                 .ipv4_accept_local = -1,
 456
 457                 .ipv6_privacy_extensions = IPV6_PRIVACY_EXTENSIONS_NO,
 458                 .ipv6_accept_ra = -1,
 459                 .ipv6_dad_transmits = -1,
 460                 .ipv6_hop_limit = -1,
 461                 .ipv6_proxy_ndp = -1,
 462                 .duid.type = _DUID_TYPE_INVALID,
 463                 .proxy_arp = -1,
 464                 .arp = -1,
 465                 .multicast = -1,
 466                 .allmulticast = -1,
 467                 .ipv6_accept_ra_use_dns = true,
 468                 .ipv6_accept_ra_use_autonomous_prefix = true,
 469                 .ipv6_accept_ra_use_onlink_prefix = true,
 470                 .ipv6_accept_ra_route_table = RT_TABLE_MAIN,
 471                 .ipv6_accept_ra_route_table_set = false,
 472                 .ipv6_accept_ra_start_dhcp6_client = true,
 473
 474                 .configure_without_carrier = false,
 475                 .ignore_carrier_loss = -1,
 476                 .keep_configuration = _KEEP_CONFIGURATION_INVALID,
 477                 .ipv6_address_gen_mode = _LINK_IPV6_ADDRESS_GEN_MODE_INVALID,
 478                 .can_triple_sampling = -1,
 479                 .can_termination = -1,
 480                 .ip_service_type = -1,
 481         };
 482
 483         r = config_parse_many(
 484                         filename, NETWORK_DIRS, dropin_dirname,
 485                         "Match\0"
 486                         "Link\0"
 487                         "Network\0"
 488                         "Address\0"
 489                         "Neighbor\0"
 490                         "IPv6AddressLabel\0"
 491                         "RoutingPolicyRule\0"
 492                         "Route\0"
 493                         "NextHop\0"
 494                         "DHCP\0" /* compat */
 495                         "DHCPv4\0"
 496                         "DHCPv6\0"
 497                         "DHCPServer\0"
 498                         "IPv6AcceptRA\0"
 499                         "IPv6NDPProxyAddress\0"
 500                         "Bridge\0"
 501                         "BridgeFDB\0"
 502                         "BridgeVLAN\0"
 503                         "IPv6PrefixDelegation\0"
 504                         "IPv6Prefix\0"
 505                         "IPv6RoutePrefix\0"
 506                         "LLDP\0"
 507                         "TrafficControlQueueingDiscipline\0"
 508                         "CAN\0"
 509                         "QDisc\0"
 510                         "BFIFO\0"
 511                         "CAKE\0"
 512                         "ControlledDelay\0"
 513                         "DeficitRoundRobinScheduler\0"
 514                         "DeficitRoundRobinSchedulerClass\0"
 515                         "EnhancedTransmissionSelection\0"
 516                         "FairQueueing\0"
 517                         "FairQueueingControlledDelay\0"
 518                         "GenericRandomEarlyDetection\0"
 519                         "HeavyHitterFilter\0"
 520                         "HierarchyTokenBucket\0"
 521                         "HierarchyTokenBucketClass\0"
 522                         "NetworkEmulator\0"
 523                         "PFIFO\0"
 524                         "PFIFOFast\0"
 525                         "PFIFOHeadDrop\0"
 526                         "PIE\0"
 527                         "QuickFairQueueing\0"
 528                         "QuickFairQueueingClass\0"
 529                         "StochasticFairBlue\0"
 530                         "StochasticFairnessQueueing\0"
 531                         "TokenBucketFilter\0"
 532                         "TrivialLinkEqualizer\0",
 533                         config_item_perf_lookup, network_network_gperf_lookup,
 534                         CONFIG_PARSE_WARN,
 535                         network,
 536                         &network->timestamp);
 537         if (r < 0)
 538                 return r;
 539
 540         network_apply_anonymize_if_set(network);
 541
 542         r = network_add_ipv4ll_route(network);
 543         if (r < 0)
 544                 log_warning_errno(r, "%s: Failed to add IPv4LL route, ignoring: %m", network->filename);
 545
 546         r = network_add_default_route_on_device(network);
 547         if (r < 0)
 548                 log_warning_errno(r, "%s: Failed to add default route on device, ignoring: %m",
 549                                   network->filename);
 550
 551         if (network_verify(network) < 0)
 552                 /* Ignore .network files that do not match the conditions. */
 553                 return 0;
 554
 555         r = ordered_hashmap_ensure_allocated(networks, &string_hash_ops);
 556         if (r < 0)
 557                 return r;
 558
 559         r = ordered_hashmap_put(*networks, network->name, network);
 560         if (r < 0)
 561                 return r;
 562
 563         network = NULL;
 564         return 0;
 565 }
 566
 567 int network_load(Manager *manager, OrderedHashmap **networks) {
 568         _cleanup_strv_free_ char **files = NULL;
 569         char **f;
 570         int r;
 571
 572         assert(manager);
 573
 574         ordered_hashmap_clear_with_destructor(*networks, network_unref);
 575
 576         r = conf_files_list_strv(&files, ".network", NULL, 0, NETWORK_DIRS);
 577         if (r < 0)
 578                 return log_error_errno(r, "Failed to enumerate network files: %m");
 579
 580         STRV_FOREACH(f, files) {
 581                 r = network_load_one(manager, networks, *f);
 582                 if (r < 0)
 583                         log_error_errno(r, "Failed to load %s, ignoring: %m", *f);
 584         }
 585
 586         return 0;
 587 }
 588
 589 int network_reload(Manager *manager) {
 590         OrderedHashmap *new_networks = NULL;
 591         Network *n, *old;
 592         Iterator i;
 593         int r;
 594
 595         assert(manager);
 596
 597         r = network_load(manager, &new_networks);
 598         if (r < 0)
 599                 goto failure;
 600
 601         ORDERED_HASHMAP_FOREACH(n, new_networks, i) {
 602                 r = network_get_by_name(manager, n->name, &old);
 603                 if (r < 0)
 604                         continue; /* The .network file is new. */
 605
 606                 if (n->timestamp != old->timestamp)
 607                         continue; /* The .network file is modified. */
 608
 609                 if (!streq(n->filename, old->filename))
 610                         continue;
 611
 612                 r = ordered_hashmap_replace(new_networks, old->name, old);
 613                 if (r < 0)
 614                         goto failure;
 615
 616                 network_ref(old);
 617                 network_unref(n);
 618         }
 619
 620         ordered_hashmap_free_with_destructor(manager->networks, network_unref);
 621         manager->networks = new_networks;
 622
 623         return 0;
 624
 625 failure:
 626         ordered_hashmap_free_with_destructor(new_networks, network_unref);
 627
 628         return r;
 629 }
 630
 631 static Network *network_free(Network *network) {
 632         IPv6ProxyNDPAddress *ipv6_proxy_ndp_address;
 633         RoutePrefix *route_prefix;
 634         RoutingPolicyRule *rule;
 635         AddressLabel *label;
 636         FdbEntry *fdb_entry;
 637         Neighbor *neighbor;
 638         Address *address;
 639         NextHop *nexthop;
 640         Prefix *prefix;
 641         Route *route;
 642
 643         if (!network)
 644                 return NULL;
 645
 646         free(network->filename);
 647
 648         set_free_free(network->match_mac);
 649         set_free_free(network->match_permanent_mac);
 650         strv_free(network->match_path);
 651         strv_free(network->match_driver);
 652         strv_free(network->match_type);
 653         strv_free(network->match_name);
 654         strv_free(network->match_property);
 655         strv_free(network->match_wlan_iftype);
 656         strv_free(network->match_ssid);
 657         set_free_free(network->match_bssid);
 658         condition_free_list(network->conditions);
 659
 660         free(network->description);
 661         free(network->dhcp_vendor_class_identifier);
 662         free(network->dhcp_mudurl);
 663         strv_free(network->dhcp_user_class);
 664         free(network->dhcp_hostname);
 665         set_free(network->dhcp_deny_listed_ip);
 666         set_free(network->dhcp_request_options);
 667         set_free(network->dhcp6_request_options);
 668         free(network->mac);
 669         free(network->dhcp6_mudurl);
 670         strv_free(network->dhcp6_user_class);
 671         strv_free(network->dhcp6_vendor_class);
 672
 673         if (network->dhcp_acd)
 674                 sd_ipv4acd_unref(network->dhcp_acd);
 675
 676         strv_free(network->ntp);
 677         free(network->dns);
 678         ordered_set_free_free(network->search_domains);
 679         ordered_set_free_free(network->route_domains);
 680         strv_free(network->bind_carrier);
 681
 682         ordered_set_free_free(network->router_search_domains);
 683         free(network->router_dns);
 684         set_free_free(network->ndisc_deny_listed_prefix);
 685
 686         free(network->bridge_name);
 687         free(network->bond_name);
 688         free(network->vrf_name);
 689         hashmap_free_free_key(network->stacked_netdev_names);
 690         netdev_unref(network->bridge);
 691         netdev_unref(network->bond);
 692         netdev_unref(network->vrf);
 693         hashmap_free_with_destructor(network->stacked_netdevs, netdev_unref);
 694
 695         while ((route = network->static_routes))
 696                 route_free(route);
 697
 698         while ((nexthop = network->static_nexthops))
 699                 nexthop_free(nexthop);
 700
 701         while ((address = network->static_addresses))
 702                 address_free(address);
 703
 704         while ((fdb_entry = network->static_fdb_entries))
 705                 fdb_entry_free(fdb_entry);
 706
 707         while ((ipv6_proxy_ndp_address = network->ipv6_proxy_ndp_addresses))
 708                 ipv6_proxy_ndp_address_free(ipv6_proxy_ndp_address);
 709
 710         while ((neighbor = network->neighbors))
 711                 neighbor_free(neighbor);
 712
 713         while ((label = network->address_labels))
 714                 address_label_free(label);
 715
 716         while ((prefix = network->static_prefixes))
 717                 prefix_free(prefix);
 718
 719         while ((route_prefix = network->static_route_prefixes))
 720                 route_prefix_free(route_prefix);
 721
 722         while ((rule = network->rules))
 723                 routing_policy_rule_free(rule);
 724
 725         hashmap_free(network->addresses_by_section);
 726         hashmap_free(network->routes_by_section);
 727         hashmap_free(network->nexthops_by_section);
 728         hashmap_free(network->fdb_entries_by_section);
 729         hashmap_free(network->neighbors_by_section);
 730         hashmap_free(network->address_labels_by_section);
 731         hashmap_free(network->prefixes_by_section);
 732         hashmap_free(network->route_prefixes_by_section);
 733         hashmap_free(network->rules_by_section);
 734         ordered_hashmap_free_with_destructor(network->tc_by_section, traffic_control_free);
 735
 736         if (network->manager &&
 737             network->manager->duids_requesting_uuid)
 738                 set_remove(network->manager->duids_requesting_uuid, &network->duid);
 739
 740         free(network->name);
 741
 742         free(network->dhcp_server_timezone);
 743
 744         for (sd_dhcp_lease_server_type t = 0; t < _SD_DHCP_LEASE_SERVER_TYPE_MAX; t++)
 745                 free(network->dhcp_server_emit[t].addresses);
 746
 747         set_free_free(network->dnssec_negative_trust_anchors);
 748
 749         free(network->lldp_mud);
 750
 751         ordered_hashmap_free(network->dhcp_client_send_options);
 752         ordered_hashmap_free(network->dhcp_client_send_vendor_options);
 753         ordered_hashmap_free(network->dhcp_server_send_options);
 754         ordered_hashmap_free(network->dhcp_server_send_vendor_options);
 755         ordered_hashmap_free(network->ipv6_tokens);
 756         ordered_hashmap_free(network->dhcp6_client_send_options);
 757         ordered_hashmap_free(network->dhcp6_client_send_vendor_options);
 758
 759         return mfree(network);
 760 }
 761
 762 DEFINE_TRIVIAL_REF_UNREF_FUNC(Network, network, network_free);
 763
 764 int network_get_by_name(Manager *manager, const char *name, Network **ret) {
 765         Network *network;
 766
 767         assert(manager);
 768         assert(name);
 769         assert(ret);
 770
 771         network = ordered_hashmap_get(manager->networks, name);
 772         if (!network)
 773                 return -ENOENT;
 774
 775         *ret = network;
 776
 777         return 0;
 778 }
 779
 780 int network_get(Manager *manager, unsigned short iftype, sd_device *device,
 781                 const char *ifname, char * const *alternative_names, const char *driver,
 782                 const struct ether_addr *mac, const struct ether_addr *permanent_mac,
 783                 enum nl80211_iftype wlan_iftype, const char *ssid, const struct ether_addr *bssid,
 784                 Network **ret) {
 785         Network *network;
 786         Iterator i;
 787
 788         assert(manager);
 789         assert(ret);
 790
 791         ORDERED_HASHMAP_FOREACH(network, manager->networks, i)
 792                 if (net_match_config(network->match_mac, network->match_permanent_mac,
 793                                      network->match_path, network->match_driver,
 794                                      network->match_type, network->match_name, network->match_property,
 795                                      network->match_wlan_iftype, network->match_ssid, network->match_bssid,
 796                                      device, mac, permanent_mac, driver, iftype,
 797                                      ifname, alternative_names, wlan_iftype, ssid, bssid)) {
 798                         if (network->match_name && device) {
 799                                 const char *attr;
 800                                 uint8_t name_assign_type = NET_NAME_UNKNOWN;
 801
 802                                 if (sd_device_get_sysattr_value(device, "name_assign_type", &attr) >= 0)
 803                                         (void) safe_atou8(attr, &name_assign_type);
 804
 805                                 if (name_assign_type == NET_NAME_ENUM)
 806                                         log_warning("%s: found matching network '%s', based on potentially unpredictable ifname",
 807                                                     ifname, network->filename);
 808                                 else
 809                                         log_debug("%s: found matching network '%s'", ifname, network->filename);
 810                         } else
 811                                 log_debug("%s: found matching network '%s'", ifname, network->filename);
 812
 813                         *ret = network;
 814                         return 0;
 815                 }
 816
 817         *ret = NULL;
 818
 819         return -ENOENT;
 820 }
 821
 822 int network_apply(Network *network, Link *link) {
 823         assert(network);
 824         assert(link);
 825
 826         link->network = network_ref(network);
 827
 828         if (network->n_dns > 0 ||
 829             !strv_isempty(network->ntp) ||
 830             !ordered_set_isempty(network->search_domains) ||
 831             !ordered_set_isempty(network->route_domains))
 832                 link_dirty(link);
 833
 834         return 0;
 835 }
 836
 837 bool network_has_static_ipv6_configurations(Network *network) {
 838         Address *address;
 839         Route *route;
 840         FdbEntry *fdb;
 841         Neighbor *neighbor;
 842
 843         assert(network);
 844
 845         LIST_FOREACH(addresses, address, network->static_addresses)
 846                 if (address->family == AF_INET6)
 847                         return true;
 848
 849         LIST_FOREACH(routes, route, network->static_routes)
 850                 if (route->family == AF_INET6)
 851                         return true;
 852
 853         LIST_FOREACH(static_fdb_entries, fdb, network->static_fdb_entries)
 854                 if (fdb->family == AF_INET6)
 855                         return true;
 856
 857         LIST_FOREACH(neighbors, neighbor, network->neighbors)
 858                 if (neighbor->family == AF_INET6)
 859                         return true;
 860
 861         if (!LIST_IS_EMPTY(network->address_labels))
 862                 return true;
 863
 864         if (!LIST_IS_EMPTY(network->static_prefixes))
 865                 return true;
 866
 867         return false;
 868 }
 869
 870 int config_parse_stacked_netdev(const char *unit,
 871                 const char *filename,
 872                 unsigned line,
 873                 const char *section,
 874                 unsigned section_line,
 875                 const char *lvalue,
 876                 int ltype,
 877                 const char *rvalue,
 878                 void *data,
 879                 void *userdata) {
 880         _cleanup_free_ char *name = NULL;
 881         NetDevKind kind = ltype;
 882         Hashmap **h = data;
 883         int r;
 884
 885         assert(filename);
 886         assert(lvalue);
 887         assert(rvalue);
 888         assert(data);
 889         assert(IN_SET(kind,
 890                       NETDEV_KIND_VLAN, NETDEV_KIND_MACVLAN, NETDEV_KIND_MACVTAP,
 891                       NETDEV_KIND_IPVLAN, NETDEV_KIND_IPVTAP, NETDEV_KIND_VXLAN,
 892                       NETDEV_KIND_L2TP, NETDEV_KIND_MACSEC, _NETDEV_KIND_TUNNEL,
 893                       NETDEV_KIND_XFRM));
 894
 895         if (!ifname_valid(rvalue)) {
 896                 log_syntax(unit, LOG_ERR, filename, line, 0,
 897                            "Invalid netdev name in %s=, ignoring assignment: %s", lvalue, rvalue);
 898                 return 0;
 899         }
 900
 901         name = strdup(rvalue);
 902         if (!name)
 903                 return log_oom();
 904
 905         r = hashmap_ensure_allocated(h, &string_hash_ops);
 906         if (r < 0)
 907                 return log_oom();
 908
 909         r = hashmap_put(*h, name, INT_TO_PTR(kind));
 910         if (r < 0)
 911                 log_syntax(unit, LOG_ERR, filename, line, r,
 912                            "Cannot add NetDev '%s' to network, ignoring assignment: %m", name);
 913         else if (r == 0)
 914                 log_syntax(unit, LOG_DEBUG, filename, line, r,
 915                            "NetDev '%s' specified twice, ignoring.", name);
 916         else
 917                 name = NULL;
 918
 919         return 0;
 920 }
 921
 922 int config_parse_domains(
 923                 const char *unit,
 924                 const char *filename,
 925                 unsigned line,
 926                 const char *section,
 927                 unsigned section_line,
 928                 const char *lvalue,
 929                 int ltype,
 930                 const char *rvalue,
 931                 void *data,
 932                 void *userdata) {
 933
 934         const char *p;
 935         Network *n = data;
 936         int r;
 937
 938         assert(n);
 939         assert(lvalue);
 940         assert(rvalue);
 941
 942         if (isempty(rvalue)) {
 943                 n->search_domains = ordered_set_free_free(n->search_domains);
 944                 n->route_domains = ordered_set_free_free(n->route_domains);
 945                 return 0;
 946         }
 947
 948         p = rvalue;
 949         for (;;) {
 950                 _cleanup_free_ char *w = NULL, *normalized = NULL;
 951                 const char *domain;
 952                 bool is_route;
 953
 954                 r = extract_first_word(&p, &w, NULL, 0);
 955                 if (r < 0) {
 956                         log_syntax(unit, LOG_ERR, filename, line, r,
 957                                    "Failed to extract search or route domain, ignoring: %s", rvalue);
 958                         break;
 959                 }
 960                 if (r == 0)
 961                         break;
 962
 963                 is_route = w[0] == '~';
 964                 domain = is_route ? w + 1 : w;
 965
 966                 if (dns_name_is_root(domain) || streq(domain, "*")) {
 967                         /* If the root domain appears as is, or the special token "*" is found, we'll
 968                          * consider this as routing domain, unconditionally. */
 969                         is_route = true;
 970                         domain = "."; /* make sure we don't allow empty strings, thus write the root
 971                                        * domain as "." */
 972                 } else {
 973                         r = dns_name_normalize(domain, 0, &normalized);
 974                         if (r < 0) {
 975                                 log_syntax(unit, LOG_ERR, filename, line, r,
 976                                            "'%s' is not a valid domain name, ignoring.", domain);
 977                                 continue;
 978                         }
 979
 980                         domain = normalized;
 981
 982                         if (is_localhost(domain)) {
 983                                 log_syntax(unit, LOG_ERR, filename, line, 0,
 984                                            "'localhost' domain may not be configured as search or route domain, ignoring assignment: %s",
 985                                            domain);
 986                                 continue;
 987                         }
 988                 }
 989
 990                 OrderedSet **set = is_route ? &n->route_domains : &n->search_domains;
 991                 r = ordered_set_ensure_allocated(set, &string_hash_ops);
 992                 if (r < 0)
 993                         return r;
 994
 995                 r = ordered_set_put_strdup(*set, domain);
 996                 if (r < 0)
 997                         return log_oom();
 998         }
 999
1000         return 0;
1001 }
1002
1003 int config_parse_ipv6token(
1004                 const char* unit,
1005                 const char *filename,
1006                 unsigned line,
1007                 const char *section,
1008                 unsigned section_line,
1009                 const char *lvalue,
1010                 int ltype,
1011                 const char *rvalue,
1012                 void *data,
1013                 void *userdata) {
1014
1015         union in_addr_union buffer;
1016         struct in6_addr *token = data;
1017         int r;
1018
1019         assert(filename);
1020         assert(lvalue);
1021         assert(rvalue);
1022         assert(token);
1023
1024         r = in_addr_from_string(AF_INET6, rvalue, &buffer);
1025         if (r < 0) {
1026                 log_syntax(unit, LOG_ERR, filename, line, r,
1027                            "Failed to parse IPv6 token, ignoring: %s", rvalue);
1028                 return 0;
1029         }
1030
1031         if (in_addr_is_null(AF_INET6, &buffer)) {
1032                 log_syntax(unit, LOG_ERR, filename, line, 0,
1033                            "IPv6 token cannot be the ANY address, ignoring: %s", rvalue);
1034                 return 0;
1035         }
1036
1037         if ((buffer.in6.s6_addr32[0] | buffer.in6.s6_addr32[1]) != 0) {
1038                 log_syntax(unit, LOG_ERR, filename, line, 0,
1039                            "IPv6 token cannot be longer than 64 bits, ignoring: %s", rvalue);
1040                 return 0;
1041         }
1042
1043         *token = buffer.in6;
1044
1045         return 0;
1046 }
1047
1048 static const char* const ipv6_privacy_extensions_table[_IPV6_PRIVACY_EXTENSIONS_MAX] = {
1049         [IPV6_PRIVACY_EXTENSIONS_NO] = "no",
1050         [IPV6_PRIVACY_EXTENSIONS_PREFER_PUBLIC] = "prefer-public",
1051         [IPV6_PRIVACY_EXTENSIONS_YES] = "yes",
1052 };
1053
1054 DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(ipv6_privacy_extensions, IPv6PrivacyExtensions,
1055                                         IPV6_PRIVACY_EXTENSIONS_YES);
1056
1057 int config_parse_ipv6_privacy_extensions(
1058                 const char* unit,
1059                 const char *filename,
1060                 unsigned line,
1061                 const char *section,
1062                 unsigned section_line,
1063                 const char *lvalue,
1064                 int ltype,
1065                 const char *rvalue,
1066                 void *data,
1067                 void *userdata) {
1068
1069         IPv6PrivacyExtensions s, *ipv6_privacy_extensions = data;
1070
1071         assert(filename);
1072         assert(lvalue);
1073         assert(rvalue);
1074         assert(ipv6_privacy_extensions);
1075
1076         s = ipv6_privacy_extensions_from_string(rvalue);
1077         if (s < 0) {
1078                 if (streq(rvalue, "kernel"))
1079                         s = _IPV6_PRIVACY_EXTENSIONS_INVALID;
1080                 else {
1081                         log_syntax(unit, LOG_ERR, filename, line, 0,
1082                                    "Failed to parse IPv6 privacy extensions option, ignoring: %s", rvalue);
1083                         return 0;
1084                 }
1085         }
1086
1087         *ipv6_privacy_extensions = s;
1088
1089         return 0;
1090 }
1091
1092 int config_parse_hostname(
1093                 const char *unit,
1094                 const char *filename,
1095                 unsigned line,
1096                 const char *section,
1097                 unsigned section_line,
1098                 const char *lvalue,
1099                 int ltype,
1100                 const char *rvalue,
1101                 void *data,
1102                 void *userdata) {
1103
1104         _cleanup_free_ char *hn = NULL;
1105         char **hostname = data;
1106         int r;
1107
1108         assert(filename);
1109         assert(lvalue);
1110         assert(rvalue);
1111
1112         r = config_parse_string(unit, filename, line, section, section_line, lvalue, ltype, rvalue, &hn, userdata);
1113         if (r < 0)
1114                 return r;
1115
1116         if (!hostname_is_valid(hn, false)) {
1117                 log_syntax(unit, LOG_ERR, filename, line, 0,
1118                            "Hostname is not valid, ignoring assignment: %s", rvalue);
1119                 return 0;
1120         }
1121
1122         r = dns_name_is_valid(hn);
1123         if (r < 0) {
1124                 log_syntax(unit, LOG_ERR, filename, line, r,
1125                            "Failed to check validity of hostname '%s', ignoring assignment: %m", rvalue);
1126                 return 0;
1127         }
1128         if (r == 0) {
1129                 log_syntax(unit, LOG_ERR, filename, line, 0,
1130                            "Hostname is not a valid DNS domain name, ignoring assignment: %s", rvalue);
1131                 return 0;
1132         }
1133
1134         return free_and_replace(*hostname, hn);
1135 }
1136
1137 int config_parse_timezone(
1138                 const char *unit,
1139                 const char *filename,
1140                 unsigned line,
1141                 const char *section,
1142                 unsigned section_line,
1143                 const char *lvalue,
1144                 int ltype,
1145                 const char *rvalue,
1146                 void *data,
1147                 void *userdata) {
1148
1149         _cleanup_free_ char *tz = NULL;
1150         char **datap = data;
1151         int r;
1152
1153         assert(filename);
1154         assert(lvalue);
1155         assert(rvalue);
1156
1157         r = config_parse_string(unit, filename, line, section, section_line, lvalue, ltype, rvalue, &tz, userdata);
1158         if (r < 0)
1159                 return r;
1160
1161         if (!timezone_is_valid(tz, LOG_ERR)) {
1162                 log_syntax(unit, LOG_ERR, filename, line, 0,
1163                            "Timezone is not valid, ignoring assignment: %s", rvalue);
1164                 return 0;
1165         }
1166
1167         return free_and_replace(*datap, tz);
1168 }
1169
1170 int config_parse_dns(
1171                 const char *unit,
1172                 const char *filename,
1173                 unsigned line,
1174                 const char *section,
1175                 unsigned section_line,
1176                 const char *lvalue,
1177                 int ltype,
1178                 const char *rvalue,
1179                 void *data,
1180                 void *userdata) {
1181
1182         Network *n = userdata;
1183         int r;
1184
1185         assert(filename);
1186         assert(lvalue);
1187         assert(rvalue);
1188
1189         for (;;) {
1190                 _cleanup_free_ char *w = NULL;
1191                 union in_addr_union a;
1192                 struct in_addr_data *m;
1193                 int family;
1194
1195                 r = extract_first_word(&rvalue, &w, NULL, 0);
1196                 if (r == -ENOMEM)
1197                         return log_oom();
1198                 if (r < 0) {
1199                         log_syntax(unit, LOG_ERR, filename, line, r,
1200                                    "Invalid syntax, ignoring: %s", rvalue);
1201                         break;
1202                 }
1203                 if (r == 0)
1204                         break;
1205
1206                 r = in_addr_from_string_auto(w, &family, &a);
1207                 if (r < 0) {
1208                         log_syntax(unit, LOG_ERR, filename, line, r,
1209                                    "Failed to parse dns server address, ignoring: %s", w);
1210                         continue;
1211                 }
1212
1213                 m = reallocarray(n->dns, n->n_dns + 1, sizeof(struct in_addr_data));
1214                 if (!m)
1215                         return log_oom();
1216
1217                 m[n->n_dns++] = (struct in_addr_data) {
1218                         .family = family,
1219                         .address = a,
1220                 };
1221
1222                 n->dns = m;
1223         }
1224
1225         return 0;
1226 }
1227
1228 int config_parse_dnssec_negative_trust_anchors(
1229                 const char *unit,
1230                 const char *filename,
1231                 unsigned line,
1232                 const char *section,
1233                 unsigned section_line,
1234                 const char *lvalue,
1235                 int ltype,
1236                 const char *rvalue,
1237                 void *data,
1238                 void *userdata) {
1239
1240         const char *p = rvalue;
1241         Network *n = data;
1242         int r;
1243
1244         assert(n);
1245         assert(lvalue);
1246         assert(rvalue);
1247
1248         if (isempty(rvalue)) {
1249                 n->dnssec_negative_trust_anchors = set_free_free(n->dnssec_negative_trust_anchors);
1250                 return 0;
1251         }
1252
1253         for (;;) {
1254                 _cleanup_free_ char *w = NULL;
1255
1256                 r = extract_first_word(&p, &w, NULL, 0);
1257                 if (r < 0) {
1258                         log_syntax(unit, LOG_ERR, filename, line, r,
1259                                    "Failed to extract negative trust anchor domain, ignoring: %s", rvalue);
1260                         break;
1261                 }
1262                 if (r == 0)
1263                         break;
1264
1265                 r = dns_name_is_valid(w);
1266                 if (r <= 0) {
1267                         log_syntax(unit, LOG_ERR, filename, line, r,
1268                                    "%s is not a valid domain name, ignoring.", w);
1269                         continue;
1270                 }
1271
1272                 r = set_ensure_consume(&n->dnssec_negative_trust_anchors, &dns_name_hash_ops, TAKE_PTR(w));
1273                 if (r < 0)
1274                         return log_oom();
1275         }
1276
1277         return 0;
1278 }
1279
1280 int config_parse_ntp(
1281                 const char *unit,
1282                 const char *filename,
1283                 unsigned line,
1284                 const char *section,
1285                 unsigned section_line,
1286                 const char *lvalue,
1287                 int ltype,
1288                 const char *rvalue,
1289                 void *data,
1290                 void *userdata) {
1291
1292         char ***l = data;
1293         int r;
1294
1295         assert(l);
1296         assert(lvalue);
1297         assert(rvalue);
1298
1299         if (isempty(rvalue)) {
1300                 *l = strv_free(*l);
1301                 return 0;
1302         }
1303
1304         for (;;) {
1305                 _cleanup_free_ char *w = NULL;
1306
1307                 r = extract_first_word(&rvalue, &w, NULL, 0);
1308                 if (r == -ENOMEM)
1309                         return log_oom();
1310                 if (r < 0) {
1311                         log_syntax(unit, LOG_ERR, filename, line, r,
1312                                    "Failed to extract NTP server name, ignoring: %s", rvalue);
1313                         break;
1314                 }
1315                 if (r == 0)
1316                         break;
1317
1318                 r = dns_name_is_valid_or_address(w);
1319                 if (r <= 0) {
1320                         log_syntax(unit, LOG_ERR, filename, line, r,
1321                                    "%s is not a valid domain name or IP address, ignoring.", w);
1322                         continue;
1323                 }
1324
1325                 if (strv_length(*l) > MAX_NTP_SERVERS) {
1326                         log_syntax(unit, LOG_WARNING, filename, line, 0,
1327                                    "More than %u NTP servers specified, ignoring \"%s\" and any subsequent entries.",
1328                                    MAX_NTP_SERVERS, w);
1329                         break;
1330                 }
1331
1332                 r = strv_consume(l, TAKE_PTR(w));
1333                 if (r < 0)
1334                         return log_oom();
1335         }
1336
1337         return 0;
1338 }
1339
1340 int config_parse_required_for_online(
1341                 const char *unit,
1342                 const char *filename,
1343                 unsigned line,
1344                 const char *section,
1345                 unsigned section_line,
1346                 const char *lvalue,
1347                 int ltype,
1348                 const char *rvalue,
1349                 void *data,
1350                 void *userdata) {
1351
1352         Network *network = data;
1353         LinkOperationalStateRange range;
1354         bool required = true;
1355         int r;
1356
1357         if (isempty(rvalue)) {
1358                 network->required_for_online = true;
1359                 network->required_operstate_for_online = LINK_OPERSTATE_RANGE_DEFAULT;
1360                 return 0;
1361         }
1362
1363         r = parse_operational_state_range(rvalue, &range);
1364         if (r < 0) {
1365                 r = parse_boolean(rvalue);
1366                 if (r < 0) {
1367                         log_syntax(unit, LOG_ERR, filename, line, r,
1368                                    "Failed to parse %s= setting, ignoring assignment: %s",
1369                                    lvalue, rvalue);
1370                         return 0;
1371                 }
1372
1373                 required = r;
1374                 range = LINK_OPERSTATE_RANGE_DEFAULT;
1375         }
1376
1377         network->required_for_online = required;
1378         network->required_operstate_for_online = range;
1379
1380         return 0;
1381 }
1382
1383 DEFINE_CONFIG_PARSE_ENUM(config_parse_keep_configuration, keep_configuration, KeepConfiguration,
1384                          "Failed to parse KeepConfiguration= setting");
1385
1386 static const char* const keep_configuration_table[_KEEP_CONFIGURATION_MAX] = {
1387         [KEEP_CONFIGURATION_NO]           = "no",
1388         [KEEP_CONFIGURATION_DHCP_ON_STOP] = "dhcp-on-stop",
1389         [KEEP_CONFIGURATION_DHCP]         = "dhcp",
1390         [KEEP_CONFIGURATION_STATIC]       = "static",
1391         [KEEP_CONFIGURATION_YES]          = "yes",
1392 };
1393
1394 DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(keep_configuration, KeepConfiguration, KEEP_CONFIGURATION_YES);