Debian Codegraph @

src/network/networkd-sysctl.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <linux/if_arp.h>
4
5 #include "sd-messages.h"
6
7 #include "af-list.h"
8 #include "bpf-util.h"
9 #include "conf-parser.h"
10 #include "alloc-util.h"
11 #include "cgroup-util.h"
12 #include "errno-util.h"
13 #include "event-util.h"
14 #include "fd-util.h"
15 #include "format-util.h"
16 #include "hashmap.h"
17 #include "networkd-link.h"
18 #include "networkd-lldp-tx.h"
19 #include "networkd-manager.h"
20 #include "networkd-ndisc.h"
21 #include "networkd-network.h"
22 #include "networkd-sysctl.h"
23 #include "path-util.h"
24 #include "set.h"
25 #include "socket-util.h"
26 #include "string-table.h"
27 #include "string-util.h"
28 #include "sysctl-util.h"
29
30 #if ENABLE_SYSCTL_BPF
31
32 #include "bpf-link.h"
33 #include "sysctl-monitor-skel.h"
34 #include "sysctl-write-event.h"
35
36 static struct sysctl_monitor_bpf* sysctl_monitor_bpf_free(struct sysctl_monitor_bpf *obj) {
37 sysctl_monitor_bpf__destroy(obj);
38 return NULL;
39 }
40
41 DEFINE_TRIVIAL_CLEANUP_FUNC(struct sysctl_monitor_bpf *, sysctl_monitor_bpf_free);
42
43 static int sysctl_event_handler(void *ctx, void *data, size_t data_sz) {
44 struct sysctl_write_event *we = ASSERT_PTR(data);
45 Hashmap **sysctl_shadow = ASSERT_PTR(ctx);
46 _cleanup_free_ char *path = NULL;
47 char *value;
48
49 /* Returning a negative value interrupts the ring buffer polling,
50 * so do it only in case of a fatal error like a version mismatch. */
51 if (we->version != 1)
52 return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
53 "Unexpected sysctl event, disabling sysctl monitoring: %d", we->version);
54
55 if (we->errorcode != 0) {
56 /* The log message is checked in test-network/systemd-networkd-tests.py. Please update the
57 * test when the log message is changed. */
58 log_warning_errno(we->errorcode, "Sysctl monitor BPF returned error: %m");
59 return 0;
60 }
61
62 path = path_join("/proc/sys", we->path);
63 if (!path) {
64 log_oom_warning();
65 return 0;
66 }
67
68 /* If we never managed this handle, ignore it. */
69 value = hashmap_get(*sysctl_shadow, path);
70 if (!value)
71 return 0;
72
73 if (!strneq(value, we->newvalue, sizeof(we->newvalue)))
74 /* The log message is checked in test-network/systemd-networkd-tests.py. Please update the
75 * test when the log message is changed. */
76 log_struct(LOG_WARNING,
77 LOG_MESSAGE_ID(SD_MESSAGE_SYSCTL_CHANGED_STR),
78 LOG_ITEM("OBJECT_PID=" PID_FMT, we->pid),
79 LOG_ITEM("OBJECT_COMM=%s", empty_to_na(we->comm)),
80 LOG_ITEM("SYSCTL=%s", path),
81 LOG_ITEM("OLDVALUE=%s", we->current),
82 LOG_ITEM("NEWVALUE=%s", we->newvalue),
83 LOG_ITEM("OURVALUE=%s", value),
84 LOG_MESSAGE("Foreign process '%s[" PID_FMT "]' changed sysctl '%s' from '%s' to '%s', conflicting with our setting to '%s'.",
85 empty_to_na(we->comm), we->pid, path, we->current, we->newvalue, value));
86
87 return 0;
88 }
89
90 static int on_ringbuf_io(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
91 struct ring_buffer *rb = ASSERT_PTR(userdata);
92 int r;
93
94 r = sym_ring_buffer__poll(rb, /* timeout_msec= */ 0);
95 if (r < 0 && errno != EINTR)
96 log_error_errno(errno, "Error polling ring buffer: %m");
97
98 return 0;
99 }
100
101 int manager_install_sysctl_monitor(Manager *manager) {
102 _cleanup_(sysctl_monitor_bpf_freep) struct sysctl_monitor_bpf *obj = NULL;
103 _cleanup_(bpf_link_freep) struct bpf_link *sysctl_link = NULL;
104 _cleanup_(bpf_ring_buffer_freep) struct ring_buffer *sysctl_buffer = NULL;
105 _cleanup_close_ int cgroup_fd = -EBADF, root_cgroup_fd = -EBADF;
106 _cleanup_free_ char *cgroup = NULL;
107 int idx = 0, r, fd;
108
109 assert(manager);
110
111 r = DLOPEN_BPF(LOG_DEBUG, SD_ELF_NOTE_DLOPEN_PRIORITY_RECOMMENDED);
112 if (ERRNO_IS_NEG_NOT_SUPPORTED(r))
113 return log_debug_errno(r, "sysctl monitor disabled, as BPF support is not available.");
114 if (r < 0)
115 return log_warning_errno(r, "Failed to load libbpf, not installing sysctl monitor: %m");
116
117 r = cg_pid_get_path(0, &cgroup);
118 if (r < 0)
119 return log_warning_errno(r, "Failed to get cgroup path, ignoring: %m.");
120
121 root_cgroup_fd = cg_path_open("/");
122 if (root_cgroup_fd < 0)
123 return log_warning_errno(root_cgroup_fd, "Failed to open cgroup, ignoring: %m");
124
125 obj = sysctl_monitor_bpf__open_and_load();
126 if (!obj)
127 return log_full_errno(errno == EINVAL ? LOG_DEBUG : LOG_INFO, errno,
128 "Unable to load sysctl monitor BPF program, ignoring: %m");
129
130 cgroup_fd = cg_path_open(cgroup);
131 if (cgroup_fd < 0)
132 return log_warning_errno(cgroup_fd, "Failed to open cgroup: %m");
133
134 if (sym_bpf_map_update_elem(sym_bpf_map__fd(obj->maps.cgroup_map), &idx, &cgroup_fd, BPF_ANY))
135 return log_warning_errno(errno, "Failed to update cgroup map: %m");
136
137 sysctl_link = sym_bpf_program__attach_cgroup(obj->progs.sysctl_monitor, root_cgroup_fd);
138 r = bpf_get_error_translated(sysctl_link);
139 if (r < 0)
140 return log_warning_errno(r, "Unable to attach sysctl monitor BPF program to cgroup, ignoring: %m");
141
142 fd = sym_bpf_map__fd(obj->maps.written_sysctls);
143 if (fd < 0)
144 return log_warning_errno(fd, "Failed to get fd of sysctl maps: %m");
145
146 sysctl_buffer = sym_ring_buffer__new(fd, sysctl_event_handler, &manager->sysctl_shadow, NULL);
147 if (!sysctl_buffer)
148 return log_warning_errno(errno, "Failed to create ring buffer: %m");
149
150 fd = sym_ring_buffer__epoll_fd(sysctl_buffer);
151 if (fd < 0)
152 return log_warning_errno(fd, "Failed to get poll fd of ring buffer: %m");
153
154 r = sd_event_add_io(manager->event, &manager->sysctl_event_source,
155 fd, EPOLLIN, on_ringbuf_io, sysctl_buffer);
156 if (r < 0)
157 return log_warning_errno(r, "Failed to watch sysctl event ringbuffer: %m");
158
159 manager->sysctl_link = TAKE_PTR(sysctl_link);
160 manager->sysctl_skel = TAKE_PTR(obj);
161 manager->sysctl_buffer = TAKE_PTR(sysctl_buffer);
162 manager->cgroup_fd = TAKE_FD(cgroup_fd);
163
164 return 0;
165 }
166
167 void manager_remove_sysctl_monitor(Manager *manager) {
168 assert(manager);
169
170 manager->sysctl_event_source = sd_event_source_disable_unref(manager->sysctl_event_source);
171 manager->sysctl_buffer = bpf_ring_buffer_free(manager->sysctl_buffer);
172 manager->sysctl_link = bpf_link_free(manager->sysctl_link);
173 manager->sysctl_skel = sysctl_monitor_bpf_free(manager->sysctl_skel);
174 manager->cgroup_fd = safe_close(manager->cgroup_fd);
175 manager->sysctl_shadow = hashmap_free(manager->sysctl_shadow);
176 }
177
178 int link_clear_sysctl_shadows(Link *link) {
179 _cleanup_free_ char *ipv4 = NULL, *ipv6 = NULL;
180 char *key = NULL, *value = NULL;
181
182 assert(link);
183 assert(link->manager);
184
185 ipv4 = path_join("/proc/sys/net/ipv4/conf", link->ifname);
186 if (!ipv4)
187 return log_oom();
188
189 ipv6 = path_join("/proc/sys/net/ipv6/conf", link->ifname);
190 if (!ipv6)
191 return log_oom();
192
193 HASHMAP_FOREACH_KEY(value, key, link->manager->sysctl_shadow)
194 if (path_startswith(key, ipv4) || path_startswith(key, ipv6)) {
195 assert_se(hashmap_remove_value(link->manager->sysctl_shadow, key, value));
196 free(key);
197 free(value);
198 }
199
200 return 0;
201 }
202 #endif
203
204 static void manager_set_ip_forwarding(Manager *manager, int family) {
205 int r, t;
206
207 assert(manager);
208 assert(IN_SET(family, AF_INET, AF_INET6));
209
210 if (family == AF_INET6 && !socket_ipv6_is_supported())
211 return;
212
213 t = manager->ip_forwarding[family == AF_INET6];
214 if (t < 0)
215 return; /* keep */
216
217 /* First, set the default value. */
218 r = sysctl_write_ip_property_boolean(family, "default", "forwarding", t, manager_get_sysctl_shadow(manager));
219 if (r < 0)
220 log_warning_errno(r, "Failed to %s the default %s forwarding: %m",
221 enable_disable(t), af_to_ipv4_ipv6(family));
222
223 /* Then, set the value to all interfaces. */
224 r = sysctl_write_ip_property_boolean(family, "all", "forwarding", t, manager_get_sysctl_shadow(manager));
225 if (r < 0)
226 log_warning_errno(r, "Failed to %s %s forwarding for all interfaces: %m",
227 enable_disable(t), af_to_ipv4_ipv6(family));
228 }
229
230 void manager_set_sysctl(Manager *manager) {
231 assert(manager);
232 assert(!manager->test_mode);
233
234 manager_set_ip_forwarding(manager, AF_INET);
235 manager_set_ip_forwarding(manager, AF_INET6);
236 }
237
238 static bool link_is_configured_for_family(Link *link, int family) {
239 assert(link);
240
241 if (!link->network)
242 return false;
243
244 if (link->flags & IFF_LOOPBACK)
245 return false;
246
247 /* CAN devices do not support IP layer. Most of the functions below are never called for CAN devices,
248 * but link_set_ipv6_mtu() may be called after setting interface MTU, and warn about the failure. For
249 * safety, let's unconditionally check if the interface is not a CAN device. */
250 if (IN_SET(family, AF_INET, AF_INET6, AF_MPLS) && link->iftype == ARPHRD_CAN)
251 return false;
252
253 if (family == AF_INET6 && !socket_ipv6_is_supported())
254 return false;
255
256 return true;
257 }
258
259 static int link_update_ipv6_sysctl(Link *link) {
260 assert(link);
261 assert(link->manager);
262
263 if (!link_is_configured_for_family(link, AF_INET6))
264 return 0;
265
266 if (!link_ipv6_enabled(link))
267 return 0;
268
269 return sysctl_write_ip_property_boolean(AF_INET6, link->ifname, "disable_ipv6", false, manager_get_sysctl_shadow(link->manager));
270 }
271
272 static int link_set_proxy_arp(Link *link) {
273 assert(link);
274 assert(link->manager);
275
276 if (!link_is_configured_for_family(link, AF_INET))
277 return 0;
278
279 if (link->network->proxy_arp < 0)
280 return 0;
281
282 return sysctl_write_ip_property_boolean(AF_INET, link->ifname, "proxy_arp", link->network->proxy_arp > 0, manager_get_sysctl_shadow(link->manager));
283 }
284
285 static int link_set_proxy_arp_pvlan(Link *link) {
286 assert(link);
287 assert(link->manager);
288
289 if (!link_is_configured_for_family(link, AF_INET))
290 return 0;
291
292 if (link->network->proxy_arp_pvlan < 0)
293 return 0;
294
295 return sysctl_write_ip_property_boolean(AF_INET, link->ifname, "proxy_arp_pvlan", link->network->proxy_arp_pvlan > 0, manager_get_sysctl_shadow(link->manager));
296 }
297
298 int link_get_ip_forwarding(Link *link, int family) {
299 assert(link);
300 assert(link->manager);
301 assert(link->network);
302 assert(IN_SET(family, AF_INET, AF_INET6));
303
304 /* If it is explicitly specified, then honor the setting. */
305 int t = link->network->ip_forwarding[family == AF_INET6];
306 if (t >= 0)
307 return t;
308
309 /* If IPMasquerade= is enabled, also enable IP forwarding. */
310 if (FLAGS_SET(link->network->ip_masquerade, AF_TO_ADDRESS_FAMILY(family)))
311 return true;
312
313 /* If IPv6SendRA= is enabled, also enable IPv6 forwarding. */
314 if (family == AF_INET6 && link_radv_enabled(link))
315 return true;
316
317 /* Otherwise, use the global setting. */
318 return link->manager->ip_forwarding[family == AF_INET6];
319 }
320
321 static int link_set_ip_forwarding_impl(Link *link, int family) {
322 int r, t;
323
324 assert(link);
325 assert(link->manager);
326 assert(IN_SET(family, AF_INET, AF_INET6));
327
328 if (!link_is_configured_for_family(link, family))
329 return 0;
330
331 t = link_get_ip_forwarding(link, family);
332 if (t < 0)
333 return 0; /* keep */
334
335 r = sysctl_write_ip_property_boolean(family, link->ifname, "forwarding", t, manager_get_sysctl_shadow(link->manager));
336 if (r < 0)
337 return log_link_warning_errno(link, r, "Failed to %s %s forwarding, ignoring: %m",
338 enable_disable(t), af_to_ipv4_ipv6(family));
339
340 return 0;
341 }
342
343 static int link_reapply_ip_forwarding(Link *link, int family) {
344 int r, ret = 0;
345
346 assert(link);
347 assert(IN_SET(family, AF_INET, AF_INET6));
348
349 if (!IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED))
350 return 0;
351
352 (void) link_set_ip_forwarding_impl(link, family);
353
354 r = link_lldp_tx_update_capabilities(link);
355 if (r < 0)
356 RET_GATHER(ret, log_link_warning_errno(link, r, "Could not update LLDP capabilities, ignoring: %m"));
357
358 if (family == AF_INET6 && !link_ndisc_enabled(link)) {
359 r = ndisc_stop(link);
360 if (r < 0)
361 RET_GATHER(ret, log_link_warning_errno(link, r, "Could not stop IPv6 Router Discovery, ignoring: %m"));
362
363 ndisc_flush(link);
364 }
365
366 return ret;
367 }
368
369 static int link_set_ip_forwarding(Link *link, int family) {
370 int r;
371
372 assert(link);
373 assert(link->manager);
374 assert(link->network);
375 assert(IN_SET(family, AF_INET, AF_INET6));
376
377 if (!link_is_configured_for_family(link, family))
378 return 0;
379
380 /* When IPMasquerade= is enabled and the global setting is unset, enable _global_ IP forwarding, and
381 * re-apply per-link setting for all links. */
382 if (FLAGS_SET(link->network->ip_masquerade, AF_TO_ADDRESS_FAMILY(family)) &&
383 link->manager->ip_forwarding[family == AF_INET6] < 0) {
384
385 log_link_notice(link, "IPMasquerade= is enabled on the interface, enabling the global IPv6Forwarding= setting, which may affect NDisc and DHCPv6 client on other interfaces.");
386
387 link->manager->ip_forwarding[family == AF_INET6] = true;
388 manager_set_ip_forwarding(link->manager, family);
389
390 Link *other;
391 HASHMAP_FOREACH(other, link->manager->links_by_index) {
392 r = link_reapply_ip_forwarding(other, family);
393 if (r < 0)
394 link_enter_failed(other);
395 }
396
397 return 0;
398 }
399
400 /* Otherwise, apply per-link setting for _this_ link. */
401 return link_set_ip_forwarding_impl(link, family);
402 }
403
404 static int link_set_ipv4_rp_filter(Link *link) {
405 assert(link);
406 assert(link->manager);
407
408 if (!link_is_configured_for_family(link, AF_INET))
409 return 0;
410
411 if (link->network->ipv4_rp_filter < 0)
412 return 0;
413
414 return sysctl_write_ip_property_int(AF_INET, link->ifname, "rp_filter", link->network->ipv4_rp_filter, manager_get_sysctl_shadow(link->manager));
415 }
416
417 static int link_set_ipv4_force_igmp_version(Link *link) {
418 assert(link);
419
420 if (!link_is_configured_for_family(link, AF_INET))
421 return 0;
422
423 if (link->network->ipv4_force_igmp_version < 0)
424 return 0;
425
426 return sysctl_write_ip_property_int(AF_INET, link->ifname, "force_igmp_version", link->network->ipv4_force_igmp_version, manager_get_sysctl_shadow(link->manager));
427 }
428
429 static int link_set_ipv6_privacy_extensions(Link *link) {
430 IPv6PrivacyExtensions val;
431
432 assert(link);
433 assert(link->manager);
434
435 if (!link_is_configured_for_family(link, AF_INET6))
436 return 0;
437
438 val = link->network->ipv6_privacy_extensions;
439 if (val < 0) /* If not specified, then use the global setting. */
440 val = link->manager->ipv6_privacy_extensions;
441
442 /* When "kernel", do not update the setting. */
443 if (val == IPV6_PRIVACY_EXTENSIONS_KERNEL)
444 return 0;
445
446 return sysctl_write_ip_property_int(AF_INET6, link->ifname, "use_tempaddr", (int) val, manager_get_sysctl_shadow(link->manager));
447 }
448
449 static int link_set_ipv6_accept_ra(Link *link) {
450 assert(link);
451 assert(link->manager);
452
453 if (!link_is_configured_for_family(link, AF_INET6))
454 return 0;
455
456 return sysctl_write_ip_property(AF_INET6, link->ifname, "accept_ra", "0", manager_get_sysctl_shadow(link->manager));
457 }
458
459 static int link_set_ipv6_dad_transmits(Link *link) {
460 assert(link);
461 assert(link->manager);
462
463 if (!link_is_configured_for_family(link, AF_INET6))
464 return 0;
465
466 if (link->network->ipv6_dad_transmits < 0)
467 return 0;
468
469 return sysctl_write_ip_property_int(AF_INET6, link->ifname, "dad_transmits", link->network->ipv6_dad_transmits, manager_get_sysctl_shadow(link->manager));
470 }
471
472 static int link_set_ipv6_hop_limit(Link *link) {
473 assert(link);
474 assert(link->manager);
475
476 if (!link_is_configured_for_family(link, AF_INET6))
477 return 0;
478
479 if (link->network->ipv6_hop_limit <= 0)
480 return 0;
481
482 return sysctl_write_ip_property_int(AF_INET6, link->ifname, "hop_limit", link->network->ipv6_hop_limit, manager_get_sysctl_shadow(link->manager));
483 }
484
485 static int link_set_ipv6_retransmission_time(Link *link) {
486 usec_t retrans_time_ms;
487
488 assert(link);
489 assert(link->manager);
490
491 if (!link_is_configured_for_family(link, AF_INET6))
492 return 0;
493
494 if (!timestamp_is_set(link->network->ipv6_retransmission_time))
495 return 0;
496
497 retrans_time_ms = DIV_ROUND_UP(link->network->ipv6_retransmission_time, USEC_PER_MSEC);
498 if (retrans_time_ms <= 0 || retrans_time_ms > UINT32_MAX)
499 return 0;
500
501 return sysctl_write_ip_neighbor_property_uint32(AF_INET6, link->ifname, "retrans_time_ms", retrans_time_ms, manager_get_sysctl_shadow(link->manager));
502 }
503
504 static int link_set_ipv6_proxy_ndp(Link *link) {
505 bool v;
506
507 assert(link);
508 assert(link->manager);
509
510 if (!link_is_configured_for_family(link, AF_INET6))
511 return 0;
512
513 if (link->network->ipv6_proxy_ndp >= 0)
514 v = link->network->ipv6_proxy_ndp;
515 else
516 v = !set_isempty(link->network->ipv6_proxy_ndp_addresses);
517
518 return sysctl_write_ip_property_boolean(AF_INET6, link->ifname, "proxy_ndp", v, manager_get_sysctl_shadow(link->manager));
519 }
520
521 int link_set_ipv6_mtu(Link *link, int log_level) {
522 uint32_t mtu = 0;
523 int r;
524
525 assert(link);
526 assert(link->manager);
527
528 if (!link_is_configured_for_family(link, AF_INET6))
529 return 0;
530
531 if (!IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED))
532 return 0;
533
534 if (sd_event_source_get_enabled(link->ipv6_mtu_wait_synced_event_source, /* ret= */ NULL) > 0) {
535 log_link_debug(link, "Waiting for IPv6 MTU is synced to link MTU, delaying to set IPv6 MTU.");
536 return 0;
537 }
538
539 assert(link->network);
540
541 if (link->network->ndisc_use_mtu)
542 mtu = link->ndisc_mtu;
543 if (mtu == 0)
544 mtu = link->network->ipv6_mtu;
545 if (mtu == 0)
546 return 0;
547
548 if (mtu > link->mtu) {
549 log_link_full(link, log_level,
550 "Reducing requested IPv6 MTU %"PRIu32" to the interface's maximum MTU %"PRIu32".",
551 mtu, link->mtu);
552 mtu = link->mtu;
553 }
554
555 r = sysctl_write_ip_property_uint32(AF_INET6, link->ifname, "mtu", mtu, manager_get_sysctl_shadow(link->manager));
556 if (r < 0)
557 return log_link_warning_errno(link, r, "Failed to set IPv6 MTU to %"PRIu32": %m", mtu);
558
559 return 0;
560 }
561
562 static int ipv6_mtu_wait_synced_handler(sd_event_source *s, uint64_t usec, void *userdata);
563
564 static int link_set_ipv6_mtu_async_impl(Link *link) {
565 uint32_t current_mtu;
566 int r;
567
568 assert(link);
569
570 /* When the link MTU is updated, it seems that the kernel IPv6 MTU of the interface is asynchronously
571 * reset to the link MTU. Hence, we need to check if it is already reset, and wait for a while if not. */
572
573 if (++link->ipv6_mtu_wait_trial_count >= 10) {
574 log_link_debug(link, "Timed out waiting for IPv6 MTU being synced to link MTU, proceeding anyway.");
575 r = link_set_ipv6_mtu(link, LOG_INFO);
576 if (r < 0)
577 return r;
578
579 return 1; /* done */
580 }
581
582 /* Check if IPv6 MTU is synced. */
583 r = sysctl_read_ip_property_uint32(AF_INET6, link->ifname, "mtu", &current_mtu);
584 if (r < 0)
585 return log_link_warning_errno(link, r, "Failed to read IPv6 MTU: %m");
586
587 if (current_mtu == link->mtu) {
588 /* Already synced. Update IPv6 MTU now. */
589 r = link_set_ipv6_mtu(link, LOG_INFO);
590 if (r < 0)
591 return r;
592
593 return 1; /* done */
594 }
595
596 /* If not, set up a timer event source. */
597 r = event_reset_time_relative(
598 link->manager->event, &link->ipv6_mtu_wait_synced_event_source,
599 CLOCK_BOOTTIME, 100 * USEC_PER_MSEC, 0,
600 ipv6_mtu_wait_synced_handler, link,
601 /* priority= */ 0, "ipv6-mtu-wait-synced", /* force_reset= */ true);
602 if (r < 0)
603 return log_link_warning_errno(link, r, "Failed to configure timer event source for waiting for IPv6 MTU being synced: %m");
604
605 /* Check again. */
606 r = sysctl_read_ip_property_uint32(AF_INET6, link->ifname, "mtu", &current_mtu);
607 if (r < 0)
608 return log_link_warning_errno(link, r, "Failed to read IPv6 MTU: %m");
609
610 if (current_mtu == link->mtu) {
611 /* Synced while setting up the timer event source. Disable it and update IPv6 MTU now. */
612 r = sd_event_source_set_enabled(link->ipv6_mtu_wait_synced_event_source, SD_EVENT_OFF);
613 if (r < 0)
614 log_link_debug_errno(link, r, "Failed to disable timer event source for IPv6 MTU, ignoring: %m");
615
616 r = link_set_ipv6_mtu(link, LOG_INFO);
617 if (r < 0)
618 return r;
619
620 return 1; /* done */
621 }
622
623 log_link_debug(link, "IPv6 MTU is not synced to the link MTU after it is changed. Waiting for a while.");
624 return 0; /* waiting */
625 }
626
627 static int ipv6_mtu_wait_synced_handler(sd_event_source *s, uint64_t usec, void *userdata) {
628 (void) link_set_ipv6_mtu_async_impl(ASSERT_PTR(userdata));
629 return 0;
630 }
631
632 int link_set_ipv6_mtu_async(Link *link) {
633 assert(link);
634
635 link->ipv6_mtu_wait_trial_count = 0;
636 return link_set_ipv6_mtu_async_impl(link);
637 }
638
639 static int link_set_ipv4_accept_local(Link *link) {
640 assert(link);
641 assert(link->manager);
642
643 if (!link_is_configured_for_family(link, AF_INET))
644 return 0;
645
646 if (link->network->ipv4_accept_local < 0)
647 return 0;
648
649 return sysctl_write_ip_property_boolean(AF_INET, link->ifname, "accept_local", link->network->ipv4_accept_local > 0, manager_get_sysctl_shadow(link->manager));
650 }
651
652 static int link_set_ipv4_route_localnet(Link *link) {
653 assert(link);
654 assert(link->manager);
655
656 if (!link_is_configured_for_family(link, AF_INET))
657 return 0;
658
659 if (link->network->ipv4_route_localnet < 0)
660 return 0;
661
662 return sysctl_write_ip_property_boolean(AF_INET, link->ifname, "route_localnet", link->network->ipv4_route_localnet > 0, manager_get_sysctl_shadow(link->manager));
663 }
664
665 static int link_set_ipv4_src_valid_mark(Link *link) {
666 assert(link);
667 assert(link->manager);
668 assert(link->network);
669
670 if (!link_is_configured_for_family(link, AF_INET))
671 return 0;
672
673 if (link->network->ipv4_src_valid_mark < 0)
674 return 0;
675
676 return sysctl_write_ip_property_boolean(AF_INET, link->ifname, "src_valid_mark", link->network->ipv4_src_valid_mark > 0, manager_get_sysctl_shadow(link->manager));
677 }
678
679 static int link_set_ipv4_promote_secondaries(Link *link) {
680 assert(link);
681 assert(link->manager);
682
683 if (!link_is_configured_for_family(link, AF_INET))
684 return 0;
685
686 /* If promote_secondaries is not set, DHCP will work only as long as the IP address does not
687 * changes between leases. The kernel will remove all secondary IP addresses of an interface
688 * otherwise. The way systemd-networkd works is that the new IP of a lease is added as a
689 * secondary IP and when the primary one expires it relies on the kernel to promote the
690 * secondary IP. See also https://github.com/systemd/systemd/issues/7163 */
691 return sysctl_write_ip_property_boolean(AF_INET, link->ifname, "promote_secondaries", true, manager_get_sysctl_shadow(link->manager));
692 }
693
694 static int link_set_mpls_input(Link *link) {
695 assert(link);
696 assert(link->manager);
697
698 if (!link_is_configured_for_family(link, AF_MPLS))
699 return 0;
700
701 if (link->network->mpls_input < 0)
702 return 0;
703
704 return sysctl_write_ip_property_boolean(AF_MPLS, link->ifname, "input", link->network->mpls_input > 0, manager_get_sysctl_shadow(link->manager));
705 }
706
707 int link_set_sysctl(Link *link) {
708 int r;
709
710 assert(link);
711
712 /* If IPv6 configured that is static IPv6 address and IPv6LL autoconfiguration is enabled
713 * for this interface, then enable IPv6 */
714 r = link_update_ipv6_sysctl(link);
715 if (r < 0)
716 log_link_warning_errno(link, r, "Cannot enable IPv6, ignoring: %m");
717
718 r = link_set_proxy_arp(link);
719 if (r < 0)
720 log_link_warning_errno(link, r, "Cannot configure proxy ARP for interface, ignoring: %m");
721
722 r = link_set_proxy_arp_pvlan(link);
723 if (r < 0)
724 log_link_warning_errno(link, r, "Cannot configure proxy ARP private VLAN for interface, ignoring: %m");
725
726 (void) link_set_ip_forwarding(link, AF_INET);
727 (void) link_set_ip_forwarding(link, AF_INET6);
728
729 r = link_set_ipv6_privacy_extensions(link);
730 if (r < 0)
731 log_link_warning_errno(link, r, "Cannot configure IPv6 privacy extensions for interface, ignoring: %m");
732
733 r = link_set_ipv6_accept_ra(link);
734 if (r < 0)
735 log_link_warning_errno(link, r, "Cannot disable kernel IPv6 accept_ra for interface, ignoring: %m");
736
737 r = link_set_ipv6_dad_transmits(link);
738 if (r < 0)
739 log_link_warning_errno(link, r, "Cannot set IPv6 dad transmits for interface, ignoring: %m");
740
741 r = link_set_ipv6_hop_limit(link);
742 if (r < 0)
743 log_link_warning_errno(link, r, "Cannot set IPv6 hop limit for interface, ignoring: %m");
744
745 r = link_set_ipv6_retransmission_time(link);
746 if (r < 0)
747 log_link_warning_errno(link, r, "Cannot set IPv6 retransmission time for interface, ignoring: %m");
748
749 r = link_set_ipv6_proxy_ndp(link);
750 if (r < 0)
751 log_link_warning_errno(link, r, "Cannot set IPv6 proxy NDP, ignoring: %m");
752
753 (void) link_set_ipv6_mtu(link, LOG_INFO);
754
755 r = link_set_ipv6ll_stable_secret(link);
756 if (r < 0)
757 log_link_warning_errno(link, r, "Cannot set stable secret address for IPv6 link-local address: %m");
758
759 r = link_set_ipv4_accept_local(link);
760 if (r < 0)
761 log_link_warning_errno(link, r, "Cannot set IPv4 accept_local flag for interface, ignoring: %m");
762
763 r = link_set_ipv4_route_localnet(link);
764 if (r < 0)
765 log_link_warning_errno(link, r, "Cannot set IPv4 route_localnet flag for interface, ignoring: %m");
766
767 r = link_set_ipv4_src_valid_mark(link);
768 if (r < 0)
769 log_link_warning_errno(link, r, "Cannot set IPv4 src_valid_mark flag for interface, ignoring: %m");
770
771 r = link_set_ipv4_rp_filter(link);
772 if (r < 0)
773 log_link_warning_errno(link, r, "Cannot set IPv4 reverse path filtering for interface, ignoring: %m");
774
775 r = link_set_ipv4_force_igmp_version(link);
776 if (r < 0)
777 log_link_warning_errno(link, r, "Cannot set IPv4 force igmp version, ignoring: %m");
778
779 r = link_set_ipv4_promote_secondaries(link);
780 if (r < 0)
781 log_link_warning_errno(link, r, "Cannot enable promote_secondaries for interface, ignoring: %m");
782
783 r = link_set_mpls_input(link);
784 if (r < 0)
785 log_link_warning_errno(link, r, "Cannot set MPLS input, ignoring: %m");
786
787 return 0;
788 }
789
790 static const char* const ipv6_privacy_extensions_table[_IPV6_PRIVACY_EXTENSIONS_MAX] = {
791 [IPV6_PRIVACY_EXTENSIONS_NO] = "no",
792 [IPV6_PRIVACY_EXTENSIONS_PREFER_PUBLIC] = "prefer-public",
793 [IPV6_PRIVACY_EXTENSIONS_YES] = "yes",
794 [IPV6_PRIVACY_EXTENSIONS_KERNEL] = "kernel",
795 };
796
797 DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(ipv6_privacy_extensions, IPv6PrivacyExtensions,
798 IPV6_PRIVACY_EXTENSIONS_YES);
799 DEFINE_CONFIG_PARSE_ENUM(config_parse_ipv6_privacy_extensions, ipv6_privacy_extensions, IPv6PrivacyExtensions);
800
801 static const char* const ip_reverse_path_filter_table[_IP_REVERSE_PATH_FILTER_MAX] = {
802 [IP_REVERSE_PATH_FILTER_NO] = "no",
803 [IP_REVERSE_PATH_FILTER_STRICT] = "strict",
804 [IP_REVERSE_PATH_FILTER_LOOSE] = "loose",
805 };
806
807 DEFINE_STRING_TABLE_LOOKUP(ip_reverse_path_filter, IPReversePathFilter);
808 DEFINE_CONFIG_PARSE_ENUM(config_parse_ip_reverse_path_filter, ip_reverse_path_filter, IPReversePathFilter);
809
810 int config_parse_ip_forward_deprecated(
811 const char *unit,
812 const char *filename,
813 unsigned line,
814 const char *section,
815 unsigned section_line,
816 const char *lvalue,
817 int ltype,
818 const char *rvalue,
819 void *data,
820 void *userdata) {
821
822 assert(filename);
823
824 log_syntax(unit, LOG_WARNING, filename, line, 0,
825 "IPForward= setting is deprecated. "
826 "Please use IPv4Forwarding= and/or IPv6Forwarding= in networkd.conf for global setting, "
827 "and the same settings in .network files for per-interface setting.");
828 return 0;
829 }
830
831 static const char* const ipv4_force_igmp_version_table[_IPV4_FORCE_IGMP_VERSION_MAX] = {
832 [IPV4_FORCE_IGMP_VERSION_NO] = "no",
833 [IPV4_FORCE_IGMP_VERSION_1] = "v1",
834 [IPV4_FORCE_IGMP_VERSION_2] = "v2",
835 [IPV4_FORCE_IGMP_VERSION_3] = "v3",
836 };
837
838 DEFINE_STRING_TABLE_LOOKUP(ipv4_force_igmp_version, IPv4ForceIgmpVersion);
839 DEFINE_CONFIG_PARSE_ENUM(config_parse_ipv4_force_igmp_version, ipv4_force_igmp_version, IPv4ForceIgmpVersion);