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