| 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", ¤t_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", ¤t_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); |