Debian Codegraph @

src/network/networkd-manager.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <linux/filter.h>
4 #include <linux/nl80211.h>
5 #include <sys/socket.h>
6
7 #include "sd-bus.h"
8 #include "sd-dhcp-relay.h"
9 #include "sd-event.h"
10 #include "sd-netlink.h"
11 #include "sd-resolve.h"
12 #include "sd-varlink.h"
13
14 #include "alloc-util.h"
15 #include "bus-error.h"
16 #include "bus-locator.h"
17 #include "bus-log-control-api.h"
18 #include "bus-object.h"
19 #include "bus-util.h"
20 #include "capability-util.h"
21 #include "common-signal.h"
22 #include "daemon-util.h"
23 #include "device-private.h"
24 #include "device-util.h"
25 #include "env-util.h"
26 #include "errno-util.h"
27 #include "fd-util.h"
28 #include "initrd-util.h"
29 #include "iovec-util.h"
30 #include "mount-util.h"
31 #include "netlink-internal.h"
32 #include "netlink-util.h"
33 #include "networkd-address.h"
34 #include "networkd-address-label.h"
35 #include "networkd-address-pool.h"
36 #include "networkd-link.h"
37 #include "networkd-manager.h"
38 #include "networkd-manager-bus.h"
39 #include "networkd-manager-varlink.h"
40 #include "networkd-neighbor.h"
41 #include "networkd-nexthop.h"
42 #include "networkd-queue.h"
43 #include "networkd-resolve-hook.h"
44 #include "networkd-route.h"
45 #include "networkd-routing-policy-rule.h"
46 #include "networkd-serialize.h"
47 #include "networkd-speed-meter.h"
48 #include "networkd-state-file.h"
49 #include "networkd-varlink-metrics.h"
50 #include "networkd-wifi.h"
51 #include "networkd-wiphy.h"
52 #include "networkd-wwan-bus.h"
53 #include "ordered-set.h"
54 #include "qdisc.h"
55 #include "set.h"
56 #include "stat-util.h"
57 #include "string-util.h"
58 #include "strv.h"
59 #include "tclass.h"
60 #include "tuntap.h"
61 #include "udev-util.h"
62
63 /* use 128 MB for receive socket kernel queue. */
64 #define RCVBUF_SIZE (128*1024*1024)
65
66 static int match_prepare_for_sleep(sd_bus_message *message, void *userdata, sd_bus_error *ret_error) {
67 Manager *m = ASSERT_PTR(userdata);
68 Link *link;
69 int b, r;
70
71 assert(message);
72
73 r = sd_bus_message_read(message, "b", &b);
74 if (r < 0) {
75 bus_log_parse_error(r);
76 return 0;
77 }
78
79 if (b)
80 return 0;
81
82 log_debug("Coming back from suspend, reconfiguring all connections...");
83
84 HASHMAP_FOREACH(link, m->links_by_index)
85 (void) link_reconfigure(link, LINK_RECONFIGURE_UNCONDITIONALLY);
86
87 return 0;
88 }
89
90 static int on_connected(sd_bus_message *message, void *userdata, sd_bus_error *ret_error) {
91 Manager *m = ASSERT_PTR(userdata);
92
93 assert(message);
94
95 /* Did we get a timezone or transient hostname from DHCP while D-Bus wasn't up yet? */
96 if (m->dynamic_hostname)
97 (void) manager_set_hostname(m, m->dynamic_hostname);
98 if (m->dynamic_timezone)
99 (void) manager_set_timezone(m, m->dynamic_timezone);
100 if (m->product_uuid_requested)
101 (void) manager_request_product_uuid(m);
102
103 (void) manager_notify_mm_bus_connected(m);
104
105 return 0;
106 }
107
108 static int manager_connect_bus(Manager *m) {
109 int r;
110
111 assert(m);
112 assert(!m->bus);
113
114 r = bus_open_system_watch_bind_with_description(&m->bus, "bus-api-network");
115 if (r < 0)
116 return log_error_errno(r, "Failed to connect to bus: %m");
117
118 r = bus_add_implementation(m->bus, &manager_object, m);
119 if (r < 0)
120 return r;
121
122 r = bus_log_control_api_register(m->bus);
123 if (r < 0)
124 return r;
125
126 r = sd_bus_request_name_async(m->bus, NULL, "org.freedesktop.network1", 0, NULL, NULL);
127 if (r < 0)
128 return log_error_errno(r, "Failed to request name: %m");
129
130 r = sd_bus_attach_event(m->bus, m->event, 0);
131 if (r < 0)
132 return log_error_errno(r, "Failed to attach bus to event loop: %m");
133
134 r = sd_bus_match_signal_async(
135 m->bus,
136 NULL,
137 "org.freedesktop.DBus.Local",
138 NULL,
139 "org.freedesktop.DBus.Local",
140 "Connected",
141 on_connected, NULL, m);
142 if (r < 0)
143 return log_error_errno(r, "Failed to request match on Connected signal: %m");
144
145 r = bus_match_signal_async(
146 m->bus,
147 NULL,
148 bus_login_mgr,
149 "PrepareForSleep",
150 match_prepare_for_sleep, NULL, m);
151 if (r < 0)
152 log_warning_errno(r, "Failed to request match for PrepareForSleep, ignoring: %m");
153
154 (void) manager_match_mm_signals(m);
155
156 return 0;
157 }
158
159 static int manager_process_uevent(sd_device_monitor *monitor, sd_device *device, void *userdata) {
160 Manager *m = ASSERT_PTR(userdata);
161 sd_device_action_t action;
162 int r;
163
164 assert(device);
165
166 r = sd_device_get_action(device, &action);
167 if (r < 0)
168 return log_device_warning_errno(device, r, "Failed to get udev action, ignoring: %m");
169
170 if (device_in_subsystem(device, "net") > 0)
171 r = manager_udev_process_link(m, device, action);
172 else if (device_in_subsystem(device, "ieee80211") > 0)
173 r = manager_udev_process_wiphy(m, device, action);
174 else if (device_in_subsystem(device, "rfkill") > 0)
175 r = manager_udev_process_rfkill(m, device, action);
176 if (r < 0)
177 log_device_warning_errno(device, r, "Failed to process \"%s\" uevent, ignoring: %m",
178 device_action_to_string(action));
179
180 return 0;
181 }
182
183 static int manager_connect_udev(Manager *m) {
184 int r;
185
186 /* udev does not initialize devices inside containers, so we rely on them being already
187 * initialized before entering the container. */
188 if (!udev_available())
189 return 0;
190
191 r = sd_device_monitor_new(&m->device_monitor);
192 if (r < 0)
193 return log_error_errno(r, "Failed to initialize device monitor: %m");
194
195 r = sd_device_monitor_filter_add_match_subsystem_devtype(m->device_monitor, "net", NULL);
196 if (r < 0)
197 return log_error_errno(r, "Could not add device monitor filter for net subsystem: %m");
198
199 r = sd_device_monitor_filter_add_match_subsystem_devtype(m->device_monitor, "ieee80211", NULL);
200 if (r < 0)
201 return log_error_errno(r, "Could not add device monitor filter for ieee80211 subsystem: %m");
202
203 r = sd_device_monitor_filter_add_match_subsystem_devtype(m->device_monitor, "rfkill", NULL);
204 if (r < 0)
205 return log_error_errno(r, "Could not add device monitor filter for rfkill subsystem: %m");
206
207 r = sd_device_monitor_attach_event(m->device_monitor, m->event);
208 if (r < 0)
209 return log_error_errno(r, "Failed to attach event to device monitor: %m");
210
211 r = sd_device_monitor_start(m->device_monitor, manager_process_uevent, m);
212 if (r < 0)
213 return log_error_errno(r, "Failed to start device monitor: %m");
214
215 return 0;
216 }
217
218 static int manager_listen_fds(Manager *m, int *ret_rtnl_fd, int *ret_varlink_fd, int *ret_varlink_metrics_fd, int *ret_resolve_hook_fd) {
219 _cleanup_strv_free_ char **names = NULL;
220 int n, rtnl_fd = -EBADF, varlink_fd = -EBADF, varlink_metrics_fd = -EBADF, resolve_hook_fd = -EBADF;
221
222 assert(m);
223 assert(ret_rtnl_fd);
224 assert(ret_varlink_fd);
225 assert(ret_varlink_metrics_fd);
226 assert(ret_resolve_hook_fd);
227
228 n = sd_listen_fds_with_names(/* unset_environment= */ true, &names);
229 if (n < 0)
230 return n;
231
232 for (int i = 0; i < n; i++) {
233 int fd = i + SD_LISTEN_FDS_START;
234
235 if (sd_is_socket(fd, AF_NETLINK, SOCK_RAW, -1) > 0) {
236 if (rtnl_fd >= 0) {
237 log_debug("Received multiple netlink sockets, ignoring.");
238 goto unused;
239 }
240
241 rtnl_fd = fd;
242 continue;
243 }
244
245 if (streq(names[i], "varlink")) {
246 varlink_fd = fd;
247 continue;
248 }
249
250 if (streq(names[i], "varlink-metrics")) {
251 varlink_metrics_fd = fd;
252 continue;
253 }
254
255 if (streq(names[i], "resolve-hook")) {
256 resolve_hook_fd = fd;
257 continue;
258 }
259
260 if (manager_set_serialization_fd(m, fd, names[i]) >= 0)
261 continue;
262
263 if (manager_add_tuntap_fd(m, fd, names[i]) >= 0)
264 continue;
265
266 unused:
267 if (m->test_mode)
268 safe_close(fd);
269 else
270 close_and_notify_warn(fd, names[i]);
271 }
272
273 *ret_rtnl_fd = rtnl_fd;
274 *ret_varlink_fd = varlink_fd;
275 *ret_varlink_metrics_fd = varlink_metrics_fd;
276 *ret_resolve_hook_fd = resolve_hook_fd;
277
278 return 0;
279 }
280
281 static int manager_connect_genl(Manager *m) {
282 int r;
283
284 assert(m);
285
286 r = sd_genl_socket_open(&m->genl);
287 if (r < 0)
288 return r;
289
290 r = sd_netlink_increase_rxbuf(m->genl, RCVBUF_SIZE);
291 if (r < 0)
292 log_warning_errno(r, "Failed to increase receive buffer size for general netlink socket, ignoring: %m");
293
294 r = sd_netlink_attach_event(m->genl, m->event, 0);
295 if (r < 0)
296 return r;
297
298 /* If the kernel is built without CONFIG_WIRELESS, the below will fail with -EOPNOTSUPP. */
299 r = genl_add_match(m->genl, NULL, NL80211_GENL_NAME, NL80211_MULTICAST_GROUP_CONFIG, 0,
300 &manager_genl_process_nl80211_config, NULL, m, "network-genl_process_nl80211_config");
301 if (r < 0 && r != -EOPNOTSUPP)
302 return r;
303
304 r = genl_add_match(m->genl, NULL, NL80211_GENL_NAME, NL80211_MULTICAST_GROUP_MLME, 0,
305 &manager_genl_process_nl80211_mlme, NULL, m, "network-genl_process_nl80211_mlme");
306 if (r < 0 && r != -EOPNOTSUPP)
307 return r;
308
309 return 0;
310 }
311
312 static int manager_connect_nfnl(Manager *m) {
313 int r;
314
315 assert(m);
316
317 r = sd_nfnl_socket_open(&m->nfnl);
318 if (r < 0) {
319 log_warning_errno(r, "Failed to open nftables netlink socket. IPMasquerade= and NFTSet= settings will not be applied. Ignoring: %m");
320 return 0;
321 }
322
323 r = sd_netlink_increase_rxbuf(m->nfnl, RCVBUF_SIZE);
324 if (r < 0)
325 log_warning_errno(r, "Failed to increase receive buffer size for nftables netlink socket, ignoring: %m");
326
327 r = sd_netlink_attach_event(m->nfnl, m->event, 0);
328 if (r < 0)
329 return r;
330
331 return 0;
332 }
333
334 static int manager_setup_rtnl_filter(Manager *manager) {
335 struct sock_filter filter[] = {
336 /* Check the packet length. */
337 BPF_STMT(BPF_LD + BPF_W + BPF_LEN, 0), /* A <- packet length */
338 BPF_JUMP(BPF_JMP + BPF_JGE + BPF_K, sizeof(struct nlmsghdr), 1, 0), /* A (packet length) >= sizeof(struct nlmsghdr) ? */
339 BPF_STMT(BPF_RET + BPF_K, 0), /* reject */
340 /* Always accept multipart message. */
341 BPF_STMT(BPF_LD + BPF_H + BPF_ABS, offsetof(struct nlmsghdr, nlmsg_flags)), /* A <- message flags */
342 BPF_JUMP(BPF_JMP + BPF_JSET + BPF_K, htobe16(NLM_F_MULTI), 0, 1), /* message flags has NLM_F_MULTI ? */
343 BPF_STMT(BPF_RET + BPF_K, UINT32_MAX), /* accept */
344 /* Accept all message types except for RTM_NEWNEIGH or RTM_DELNEIGH. */
345 BPF_STMT(BPF_LD + BPF_H + BPF_ABS, offsetof(struct nlmsghdr, nlmsg_type)), /* A <- message type */
346 BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, htobe16(RTM_NEWNEIGH), 2, 0), /* message type == RTM_NEWNEIGH ? */
347 BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, htobe16(RTM_DELNEIGH), 1, 0), /* message type == RTM_DELNEIGH ? */
348 BPF_STMT(BPF_RET + BPF_K, UINT32_MAX), /* accept */
349 /* Check the packet length. */
350 BPF_STMT(BPF_LD + BPF_W + BPF_LEN, 0), /* A <- packet length */
351 BPF_JUMP(BPF_JMP + BPF_JGE + BPF_K, sizeof(struct nlmsghdr) + sizeof(struct ndmsg), 1, 0),
352 /* packet length >= sizeof(struct nlmsghdr) + sizeof(struct ndmsg) ? */
353 BPF_STMT(BPF_RET + BPF_K, 0), /* reject */
354 /* Reject the message when the neighbor state does not have NUD_PERMANENT flag. */
355 BPF_STMT(BPF_LD + BPF_H + BPF_ABS, sizeof(struct nlmsghdr) + offsetof(struct ndmsg, ndm_state)),
356 /* A <- neighbor state */
357 BPF_JUMP(BPF_JMP + BPF_JSET + BPF_K, htobe16(NUD_PERMANENT), 1, 0), /* neighbor state has NUD_PERMANENT ? */
358 BPF_STMT(BPF_RET + BPF_K, 0), /* reject */
359 BPF_STMT(BPF_RET + BPF_K, UINT32_MAX), /* accept */
360 };
361
362 assert(manager);
363 assert(manager->rtnl);
364
365 return sd_netlink_attach_filter(manager->rtnl, ELEMENTSOF(filter), filter);
366 }
367
368 static int manager_connect_rtnl(Manager *m, int fd) {
369 _unused_ _cleanup_close_ int fd_close = fd;
370 int r;
371
372 assert(m);
373
374 /* This takes input fd. */
375
376 if (fd < 0)
377 r = sd_netlink_open(&m->rtnl);
378 else
379 r = sd_netlink_open_fd(&m->rtnl, fd);
380 if (r < 0)
381 return r;
382 TAKE_FD(fd_close);
383
384 /* Bump receiver buffer, but only if we are not called via socket activation, as in that
385 * case systemd sets the receive buffer size for us, and the value in the .socket unit
386 * should take full effect. */
387 if (fd < 0) {
388 r = sd_netlink_increase_rxbuf(m->rtnl, RCVBUF_SIZE);
389 if (r < 0)
390 log_warning_errno(r, "Failed to increase receive buffer size for rtnl socket, ignoring: %m");
391 }
392
393 r = sd_netlink_attach_event(m->rtnl, m->event, 0);
394 if (r < 0)
395 return r;
396
397 r = netlink_add_match(m->rtnl, NULL, RTM_NEWLINK, &manager_rtnl_process_link, NULL, m, "network-rtnl_process_link");
398 if (r < 0)
399 return r;
400
401 r = netlink_add_match(m->rtnl, NULL, RTM_DELLINK, &manager_rtnl_process_link, NULL, m, "network-rtnl_process_link");
402 if (r < 0)
403 return r;
404
405 r = netlink_add_match(m->rtnl, NULL, RTM_NEWQDISC, &manager_rtnl_process_qdisc, NULL, m, "network-rtnl_process_qdisc");
406 if (r < 0)
407 return r;
408
409 r = netlink_add_match(m->rtnl, NULL, RTM_DELQDISC, &manager_rtnl_process_qdisc, NULL, m, "network-rtnl_process_qdisc");
410 if (r < 0)
411 return r;
412
413 r = netlink_add_match(m->rtnl, NULL, RTM_NEWTCLASS, &manager_rtnl_process_tclass, NULL, m, "network-rtnl_process_tclass");
414 if (r < 0)
415 return r;
416
417 r = netlink_add_match(m->rtnl, NULL, RTM_DELTCLASS, &manager_rtnl_process_tclass, NULL, m, "network-rtnl_process_tclass");
418 if (r < 0)
419 return r;
420
421 r = netlink_add_match(m->rtnl, NULL, RTM_NEWADDR, &manager_rtnl_process_address, NULL, m, "network-rtnl_process_address");
422 if (r < 0)
423 return r;
424
425 r = netlink_add_match(m->rtnl, NULL, RTM_DELADDR, &manager_rtnl_process_address, NULL, m, "network-rtnl_process_address");
426 if (r < 0)
427 return r;
428
429 r = netlink_add_match(m->rtnl, NULL, RTM_NEWNEIGH, &manager_rtnl_process_neighbor, NULL, m, "network-rtnl_process_neighbor");
430 if (r < 0)
431 return r;
432
433 r = netlink_add_match(m->rtnl, NULL, RTM_DELNEIGH, &manager_rtnl_process_neighbor, NULL, m, "network-rtnl_process_neighbor");
434 if (r < 0)
435 return r;
436
437 r = netlink_add_match(m->rtnl, NULL, RTM_NEWROUTE, &manager_rtnl_process_route, NULL, m, "network-rtnl_process_route");
438 if (r < 0)
439 return r;
440
441 r = netlink_add_match(m->rtnl, NULL, RTM_DELROUTE, &manager_rtnl_process_route, NULL, m, "network-rtnl_process_route");
442 if (r < 0)
443 return r;
444
445 r = netlink_add_match(m->rtnl, NULL, RTM_NEWRULE, &manager_rtnl_process_rule, NULL, m, "network-rtnl_process_rule");
446 if (r < 0)
447 return r;
448
449 r = netlink_add_match(m->rtnl, NULL, RTM_DELRULE, &manager_rtnl_process_rule, NULL, m, "network-rtnl_process_rule");
450 if (r < 0)
451 return r;
452
453 r = netlink_add_match(m->rtnl, NULL, RTM_NEWNEXTHOP, &manager_rtnl_process_nexthop, NULL, m, "network-rtnl_process_nexthop");
454 if (r < 0)
455 return r;
456
457 r = netlink_add_match(m->rtnl, NULL, RTM_DELNEXTHOP, &manager_rtnl_process_nexthop, NULL, m, "network-rtnl_process_nexthop");
458 if (r < 0)
459 return r;
460
461 return manager_setup_rtnl_filter(m);
462 }
463
464 static int manager_post_handler(sd_event_source *s, void *userdata) {
465 Manager *manager = ASSERT_PTR(userdata);
466
467 /* To release dynamic leases, we need to process queued remove requests before stopping networkd.
468 * This is especially important when KeepConfiguration=no. See issue #34837. */
469 (void) manager_process_remove_requests(manager);
470
471 switch (manager->state) {
472 case MANAGER_RUNNING:
473 (void) manager_process_requests(manager);
474 (void) manager_clean_all(manager);
475 return 0;
476
477 case MANAGER_TERMINATING:
478 case MANAGER_RESTARTING:
479 if (!ordered_set_isempty(manager->remove_request_queue))
480 return 0; /* There are some unissued remove requests. */
481
482 if (netlink_get_reply_callback_count(manager->rtnl) > 0 ||
483 netlink_get_reply_callback_count(manager->genl) > 0 ||
484 netlink_get_reply_callback_count(manager->nfnl) > 0)
485 return 0; /* There are some message calls waiting for their replies. */
486
487 (void) manager_serialize(manager);
488 manager->state = MANAGER_STOPPED;
489 return sd_event_exit(sd_event_source_get_event(s), 0);
490
491 default:
492 assert_not_reached();
493 }
494
495 return 0;
496 }
497
498 static int manager_stop(Manager *manager, ManagerState state) {
499 assert(manager);
500 assert(IN_SET(state, MANAGER_TERMINATING, MANAGER_RESTARTING));
501
502 if (manager->state != MANAGER_RUNNING) {
503 log_debug("Already terminating or restarting systemd-networkd, refusing further operation request.");
504 return 0;
505 }
506
507 switch (state) {
508 case MANAGER_TERMINATING:
509 log_debug("Terminate operation initiated.");
510 break;
511 case MANAGER_RESTARTING:
512 log_debug("Restart operation initiated.");
513 break;
514 default:
515 assert_not_reached();
516 }
517
518 manager->state = state;
519
520 Link *link;
521 HASHMAP_FOREACH(link, manager->links_by_index)
522 (void) link_stop_engines(link, /* may_keep_dynamic= */ true);
523
524 return 0;
525 }
526
527 static int signal_terminate_callback(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
528 return manager_stop(userdata, MANAGER_TERMINATING);
529 }
530
531 static int signal_restart_callback(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
532 return manager_stop(userdata, MANAGER_RESTARTING);
533 }
534
535 static int signal_reload_callback(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
536 Manager *m = ASSERT_PTR(userdata);
537
538 (void) manager_reload(m, /* message= */ NULL, /* varlink= */ NULL);
539
540 return 0;
541 }
542
543 static int manager_set_keep_configuration(Manager *m) {
544 int r;
545
546 assert(m);
547
548 if (in_initrd()) {
549 log_debug("Running in initrd, keep dynamically assigned configurations on stopping networkd by default.");
550 m->keep_configuration = KEEP_CONFIGURATION_DYNAMIC_ON_STOP;
551 return 0;
552 }
553
554 r = path_is_network_fs_harder("/");
555 if (r < 0) {
556 log_warning_errno(r, "Failed to detect if root is network filesystem, assuming not: %m");
557 return 0;
558 }
559 if (r == 0) {
560 m->keep_configuration = _KEEP_CONFIGURATION_INVALID;
561 return 0;
562 }
563
564 log_debug("Running on network filesystem, enabling KeepConfiguration= by default.");
565 m->keep_configuration = KEEP_CONFIGURATION_YES;
566 return 0;
567 }
568
569 int manager_setup(Manager *m) {
570 _cleanup_close_ int rtnl_fd = -EBADF, varlink_fd = -EBADF, varlink_metrics_fd = -EBADF, resolve_hook_fd = -EBADF;
571 int r;
572
573 assert(m);
574
575 r = sd_event_default(&m->event);
576 if (r < 0)
577 return r;
578
579 (void) sd_event_set_watchdog(m->event, true);
580 (void) sd_event_add_signal(m->event, NULL, SIGTERM | SD_EVENT_SIGNAL_PROCMASK, signal_terminate_callback, m);
581 (void) sd_event_add_signal(m->event, NULL, SIGINT | SD_EVENT_SIGNAL_PROCMASK, signal_terminate_callback, m);
582 (void) sd_event_add_signal(m->event, NULL, SIGUSR2 | SD_EVENT_SIGNAL_PROCMASK, signal_restart_callback, m);
583 (void) sd_event_add_signal(m->event, NULL, SIGHUP | SD_EVENT_SIGNAL_PROCMASK, signal_reload_callback, m);
584 (void) sd_event_add_signal(m->event, NULL, (SIGRTMIN+18) | SD_EVENT_SIGNAL_PROCMASK, sigrtmin18_handler, NULL);
585
586 r = sd_event_add_memory_pressure(m->event, NULL, NULL, NULL);
587 if (r < 0)
588 log_debug_errno(r, "Failed to allocate memory pressure event source, ignoring: %m");
589
590 r = sd_event_add_post(m->event, NULL, manager_post_handler, m);
591 if (r < 0)
592 return r;
593
594 r = manager_listen_fds(m, &rtnl_fd, &varlink_fd, &varlink_metrics_fd, &resolve_hook_fd);
595 if (r < 0)
596 return r;
597
598 r = manager_connect_rtnl(m, TAKE_FD(rtnl_fd));
599 if (r < 0)
600 return r;
601
602 r = manager_connect_genl(m);
603 if (r < 0)
604 return r;
605
606 r = manager_connect_nfnl(m);
607 if (r < 0)
608 return r;
609
610 if (m->test_mode)
611 return 0;
612
613 r = manager_varlink_init(m, TAKE_FD(varlink_fd));
614 if (r < 0)
615 return r;
616
617 r = manager_varlink_metrics_init(m, TAKE_FD(varlink_metrics_fd));
618 if (r < 0)
619 return r;
620
621 r = manager_varlink_init_resolve_hook(m, TAKE_FD(resolve_hook_fd));
622 if (r < 0)
623 return r;
624
625 r = manager_connect_bus(m);
626 if (r < 0)
627 return r;
628
629 r = manager_connect_udev(m);
630 if (r < 0)
631 return r;
632
633 r = sd_resolve_default(&m->resolve);
634 if (r < 0)
635 return r;
636
637 r = sd_resolve_attach_event(m->resolve, m->event, 0);
638 if (r < 0)
639 return r;
640
641 r = address_pool_setup_default(m);
642 if (r < 0)
643 return r;
644
645 r = manager_set_keep_configuration(m);
646 if (r < 0)
647 return r;
648
649 m->state_file = strdup("/run/systemd/netif/state");
650 if (!m->state_file)
651 return -ENOMEM;
652
653 return 0;
654 }
655
656 static int persistent_storage_open(void) {
657 _cleanup_close_ int fd = -EBADF;
658 int r;
659
660 r = getenv_bool("SYSTEMD_NETWORK_PERSISTENT_STORAGE_READY");
661 if (r < 0 && r != -ENXIO)
662 return log_debug_errno(r, "Failed to parse $SYSTEMD_NETWORK_PERSISTENT_STORAGE_READY environment variable, ignoring: %m");
663 if (r <= 0)
664 return -EBADF;
665
666 fd = open("/var/lib/systemd/network/", O_CLOEXEC | O_DIRECTORY);
667 if (fd < 0)
668 return log_debug_errno(errno, "Failed to open %s, ignoring: %m", "/var/lib/systemd/network/");
669
670 r = fd_is_read_only_fs(fd);
671 if (r < 0)
672 return log_debug_errno(r, "Failed to check if /var/lib/systemd/network/ is writable: %m");
673 if (r > 0)
674 return log_debug_errno(SYNTHETIC_ERRNO(EROFS), "The directory /var/lib/systemd/network/ is on read-only filesystem.");
675
676 return TAKE_FD(fd);
677 }
678
679 int manager_new(Manager **ret, bool test_mode) {
680 _cleanup_(manager_freep) Manager *m = NULL;
681
682 assert(ret);
683
684 m = new(Manager, 1);
685 if (!m)
686 return -ENOMEM;
687
688 *m = (Manager) {
689 .keep_configuration = _KEEP_CONFIGURATION_INVALID,
690 .ipv6_privacy_extensions = IPV6_PRIVACY_EXTENSIONS_NO,
691 .test_mode = test_mode,
692 .speed_meter_interval_usec = SPEED_METER_DEFAULT_TIME_INTERVAL,
693 .online_state = _LINK_ONLINE_STATE_INVALID,
694 .manage_foreign_routes = true,
695 .manage_foreign_rules = true,
696 .manage_foreign_nexthops = true,
697 .ethtool_fd = -EBADF,
698 .persistent_storage_fd = persistent_storage_open(),
699 .dhcp_use_domains = _USE_DOMAINS_INVALID,
700 .dhcp6_use_domains = _USE_DOMAINS_INVALID,
701 .ndisc_use_domains = _USE_DOMAINS_INVALID,
702 .dhcp_client_identifier = DHCP_CLIENT_ID_DUID,
703 .dhcp_duid.type = DUID_TYPE_EN,
704 .dhcp6_duid.type = DUID_TYPE_EN,
705 .duid_product_uuid.type = DUID_TYPE_UUID,
706 .dhcp_relay_extra_options = TLV_INIT(TLV_DHCP4_SUBOPTION),
707 .dhcp_server_persist_leases = DHCP_SERVER_PERSIST_LEASES_YES,
708 .serialization_fd = -EBADF,
709 .ip_forwarding = { -1, -1, },
710 #if ENABLE_SYSCTL_BPF
711 .cgroup_fd = -EBADF,
712 #endif
713 };
714
715 *ret = TAKE_PTR(m);
716 return 0;
717 }
718
719 Manager* manager_free(Manager *m) {
720 if (!m)
721 return NULL;
722
723 manager_remove_sysctl_monitor(m);
724
725 free(m->state_file);
726
727 m->request_queue = ordered_set_free(m->request_queue);
728 m->remove_request_queue = ordered_set_free(m->remove_request_queue);
729
730 m->new_wlan_ifindices = set_free(m->new_wlan_ifindices);
731
732 m->dirty_links = set_free(m->dirty_links);
733 m->links_by_name = hashmap_free(m->links_by_name);
734 m->links_by_hw_addr = hashmap_free(m->links_by_hw_addr);
735 m->links_by_dhcp_pd_subnet_prefix = hashmap_free(m->links_by_dhcp_pd_subnet_prefix);
736 m->links_by_index = hashmap_free(m->links_by_index);
737
738 m->dhcp_pd_subnet_ids = set_free(m->dhcp_pd_subnet_ids);
739 m->networks = ordered_hashmap_free(m->networks);
740
741 /* The same object may be registered with multiple names, and netdev_detach() may drop multiple entries. */
742 for (NetDev *n; (n = hashmap_first(m->netdevs)); )
743 netdev_detach(n);
744 m->netdevs = hashmap_free(m->netdevs);
745
746 m->tuntap_fds_by_name = hashmap_free(m->tuntap_fds_by_name);
747
748 m->wiphy_by_name = hashmap_free(m->wiphy_by_name);
749 m->wiphy_by_index = hashmap_free(m->wiphy_by_index);
750
751 ordered_set_free(m->address_pools);
752
753 hashmap_free(m->route_table_names_by_number);
754 hashmap_free(m->route_table_numbers_by_name);
755
756 set_free(m->rules);
757
758 sd_bus_slot_unref(m->slot_mm);
759 hashmap_free(m->modems_by_path);
760
761 sd_netlink_unref(m->rtnl);
762 sd_netlink_unref(m->genl);
763 sd_netlink_unref(m->nfnl);
764 sd_resolve_unref(m->resolve);
765
766 iovec_done(&m->dhcp_relay_remote_id);
767 tlv_done(&m->dhcp_relay_extra_options);
768 sd_dhcp_relay_unref(m->dhcp_relay);
769
770 m->routes = set_free(m->routes);
771
772 m->nexthops_by_id = hashmap_free(m->nexthops_by_id);
773 m->nexthop_ids = set_free(m->nexthop_ids);
774
775 m->address_labels_by_section = hashmap_free(m->address_labels_by_section);
776
777 sd_event_source_unref(m->speed_meter_event_source);
778 sd_event_unref(m->event);
779
780 sd_device_monitor_unref(m->device_monitor);
781
782 m->varlink_server = sd_varlink_server_unref(m->varlink_server);
783 m->varlink_resolve_hook_server = sd_varlink_server_unref(m->varlink_resolve_hook_server);
784 m->varlink_metrics_server = sd_varlink_server_unref(m->varlink_metrics_server);
785 m->query_filter_subscriptions = set_free(m->query_filter_subscriptions);
786 hashmap_free(m->polkit_registry);
787 sd_bus_flush_close_unref(m->bus);
788
789 free(m->dynamic_timezone);
790 free(m->dynamic_hostname);
791
792 safe_close(m->ethtool_fd);
793 safe_close(m->persistent_storage_fd);
794
795 m->serialization_fd = safe_close(m->serialization_fd);
796
797 return mfree(m);
798 }
799
800 int manager_start(Manager *m) {
801 Link *link;
802 int r;
803
804 assert(m);
805
806 log_debug("Starting...");
807
808 (void) manager_install_sysctl_monitor(m);
809
810 /* Loading BPF programs requires CAP_SYS_ADMIN and CAP_BPF.
811 * Drop the capabilities here, regardless if the load succeeds or not. */
812 r = drop_capability(CAP_SYS_ADMIN);
813 if (r < 0)
814 log_warning_errno(r, "Failed to drop CAP_SYS_ADMIN, ignoring: %m.");
815
816 r = drop_capability(CAP_BPF);
817 if (r < 0)
818 log_warning_errno(r, "Failed to drop CAP_BPF, ignoring: %m.");
819
820 manager_set_sysctl(m);
821
822 r = manager_request_static_address_labels(m);
823 if (r < 0)
824 return r;
825
826 r = manager_start_speed_meter(m);
827 if (r < 0)
828 return log_error_errno(r, "Failed to initialize speed meter: %m");
829
830 HASHMAP_FOREACH(link, m->links_by_index) {
831 if (link->state != LINK_STATE_PENDING)
832 continue;
833
834 r = link_check_initialized(link);
835 if (r < 0) {
836 log_link_warning_errno(link, r, "Failed to check if link is initialized: %m");
837 link_enter_failed(link);
838 }
839 }
840
841 /* The dirty handler will deal with future serialization, but the first one
842 must be done explicitly. */
843
844 r = manager_save(m);
845 if (r < 0)
846 log_warning_errno(r, "Failed to update state file %s, ignoring: %m", m->state_file);
847
848 HASHMAP_FOREACH(link, m->links_by_index) {
849 r = link_save_and_clean(link);
850 if (r < 0)
851 log_link_warning_errno(link, r, "Failed to update link state file %s, ignoring: %m", link->state_file);
852 }
853
854 log_debug("Started.");
855 return 0;
856 }
857
858 int manager_load_config(Manager *m) {
859 int r;
860
861 log_debug("Loading...");
862
863 r = netdev_load(m);
864 if (r < 0)
865 return log_debug_errno(r, "Failed to load .netdev files: %m");
866
867 manager_clear_unmanaged_tuntap_fds(m);
868
869 r = network_load(m, &m->networks);
870 if (r < 0)
871 return log_debug_errno(r, "Failed to load .network files: %m");
872
873 r = manager_build_dhcp_pd_subnet_ids(m);
874 if (r < 0)
875 return log_debug_errno(r, "Failed to build DHCP-PD subnet ID map: %m");
876
877 r = manager_build_nexthop_ids(m);
878 if (r < 0)
879 return log_debug_errno(r, "Failed to build nexthop ID map: %m");
880
881 log_debug("Loaded.");
882 return 0;
883 }
884
885 int manager_enumerate_internal(
886 Manager *m,
887 sd_netlink *nl,
888 sd_netlink_message *req,
889 int (*process)(sd_netlink *, sd_netlink_message *, Manager *)) {
890
891 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *reply = NULL;
892 int r;
893
894 assert(m);
895 assert(nl);
896 assert(req);
897 assert(process);
898
899 r = sd_netlink_message_set_request_dump(req, true);
900 if (r < 0)
901 return r;
902
903 r = sd_netlink_call(nl, req, 0, &reply);
904 if (r < 0)
905 return r;
906
907 m->enumerating = true;
908 for (sd_netlink_message *reply_one = reply; reply_one; reply_one = sd_netlink_message_next(reply_one))
909 RET_GATHER(r, process(nl, reply_one, m));
910 m->enumerating = false;
911
912 return r;
913 }
914
915 static int manager_enumerate_links(Manager *m) {
916 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
917 int r;
918
919 assert(m);
920 assert(m->rtnl);
921
922 r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
923 if (r < 0)
924 return r;
925
926 r = manager_enumerate_internal(m, m->rtnl, req, manager_rtnl_process_link);
927 if (r < 0)
928 return r;
929
930 req = sd_netlink_message_unref(req);
931
932 r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
933 if (r < 0)
934 return r;
935
936 r = sd_rtnl_message_link_set_family(req, AF_BRIDGE);
937 if (r < 0)
938 return r;
939
940 return manager_enumerate_internal(m, m->rtnl, req, manager_rtnl_process_link);
941 }
942
943 static int manager_enumerate_qdisc(Manager *m) {
944 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
945 int r;
946
947 assert(m);
948 assert(m->rtnl);
949
950 r = sd_rtnl_message_new_traffic_control(m->rtnl, &req, RTM_GETQDISC, 0, 0, 0);
951 if (r < 0)
952 return r;
953
954 return manager_enumerate_internal(m, m->rtnl, req, manager_rtnl_process_qdisc);
955 }
956
957 static int manager_enumerate_tclass(Manager *m) {
958 Link *link;
959 int r = 0;
960
961 assert(m);
962 assert(m->rtnl);
963
964 /* TC class can be enumerated only per link. See tc_dump_tclass() in net/sched/sched_api.c. */
965
966 HASHMAP_FOREACH(link, m->links_by_index)
967 RET_GATHER(r, link_enumerate_tclass(link, 0));
968
969 return r;
970 }
971
972 static int manager_enumerate_addresses(Manager *m) {
973 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
974 int r;
975
976 assert(m);
977 assert(m->rtnl);
978
979 r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, 0, 0);
980 if (r < 0)
981 return r;
982
983 return manager_enumerate_internal(m, m->rtnl, req, manager_rtnl_process_address);
984 }
985
986 static int manager_enumerate_neighbors(Manager *m) {
987 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
988 int r;
989
990 assert(m);
991 assert(m->rtnl);
992
993 r = sd_rtnl_message_new_neigh(m->rtnl, &req, RTM_GETNEIGH, 0, AF_UNSPEC);
994 if (r < 0)
995 return r;
996
997 return manager_enumerate_internal(m, m->rtnl, req, manager_rtnl_process_neighbor);
998 }
999
1000 static int manager_enumerate_routes(Manager *m) {
1001 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1002 int r;
1003
1004 assert(m);
1005 assert(m->rtnl);
1006
1007 if (!m->manage_foreign_routes)
1008 return 0;
1009
1010 r = sd_rtnl_message_new_route(m->rtnl, &req, RTM_GETROUTE, 0, 0);
1011 if (r < 0)
1012 return r;
1013
1014 return manager_enumerate_internal(m, m->rtnl, req, manager_rtnl_process_route);
1015 }
1016
1017 static int manager_enumerate_rules(Manager *m) {
1018 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1019 int r;
1020
1021 assert(m);
1022 assert(m->rtnl);
1023
1024 if (!m->manage_foreign_rules)
1025 return 0;
1026
1027 r = sd_rtnl_message_new_routing_policy_rule(m->rtnl, &req, RTM_GETRULE, 0);
1028 if (r < 0)
1029 return r;
1030
1031 return manager_enumerate_internal(m, m->rtnl, req, manager_rtnl_process_rule);
1032 }
1033
1034 static int manager_enumerate_nexthop(Manager *m) {
1035 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1036 int r;
1037
1038 assert(m);
1039 assert(m->rtnl);
1040
1041 if (!m->manage_foreign_nexthops)
1042 return 0;
1043
1044 r = sd_rtnl_message_new_nexthop(m->rtnl, &req, RTM_GETNEXTHOP, 0, 0);
1045 if (r < 0)
1046 return r;
1047
1048 return manager_enumerate_internal(m, m->rtnl, req, manager_rtnl_process_nexthop);
1049 }
1050
1051 static int manager_enumerate_nl80211_wiphy(Manager *m) {
1052 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1053 int r;
1054
1055 assert(m);
1056 assert(m->genl);
1057
1058 r = sd_genl_message_new(m->genl, NL80211_GENL_NAME, NL80211_CMD_GET_WIPHY, &req);
1059 if (r < 0)
1060 return r;
1061
1062 return manager_enumerate_internal(m, m->genl, req, manager_genl_process_nl80211_wiphy);
1063 }
1064
1065 static int manager_enumerate_nl80211_config(Manager *m) {
1066 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1067 int r;
1068
1069 assert(m);
1070 assert(m->genl);
1071
1072 r = sd_genl_message_new(m->genl, NL80211_GENL_NAME, NL80211_CMD_GET_INTERFACE, &req);
1073 if (r < 0)
1074 return r;
1075
1076 return manager_enumerate_internal(m, m->genl, req, manager_genl_process_nl80211_config);
1077 }
1078
1079 static int manager_enumerate_nl80211_mlme(Manager *m) {
1080 Link *link;
1081 int r;
1082
1083 assert(m);
1084 assert(m->genl);
1085
1086 HASHMAP_FOREACH(link, m->links_by_index) {
1087 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1088
1089 if (link->wlan_iftype != NL80211_IFTYPE_STATION)
1090 continue;
1091
1092 r = sd_genl_message_new(m->genl, NL80211_GENL_NAME, NL80211_CMD_GET_STATION, &req);
1093 if (r < 0)
1094 return r;
1095
1096 r = sd_netlink_message_append_u32(req, NL80211_ATTR_IFINDEX, link->ifindex);
1097 if (r < 0)
1098 return r;
1099
1100 r = manager_enumerate_internal(m, m->genl, req, manager_genl_process_nl80211_mlme);
1101 if (r < 0)
1102 return r;
1103 }
1104
1105 return 0;
1106 }
1107
1108 int manager_enumerate(Manager *m) {
1109 int r;
1110
1111 log_debug("Enumerating...");
1112
1113 r = manager_enumerate_links(m);
1114 if (r < 0)
1115 return log_error_errno(r, "Could not enumerate links: %m");
1116
1117 /* If the kernel is built without CONFIG_NET_SCHED, the below will fail with -EOPNOTSUPP. */
1118 r = manager_enumerate_qdisc(m);
1119 if (r == -EOPNOTSUPP)
1120 log_debug_errno(r, "Could not enumerate QDiscs, ignoring: %m");
1121 else if (r < 0)
1122 return log_error_errno(r, "Could not enumerate QDisc: %m");
1123
1124 /* If the kernel is built without CONFIG_NET_CLS, the below will fail with -EOPNOTSUPP. */
1125 r = manager_enumerate_tclass(m);
1126 if (r == -EOPNOTSUPP)
1127 log_debug_errno(r, "Could not enumerate TClasses, ignoring: %m");
1128 else if (r < 0)
1129 return log_error_errno(r, "Could not enumerate TClass: %m");
1130
1131 r = manager_enumerate_addresses(m);
1132 if (r < 0)
1133 return log_error_errno(r, "Could not enumerate addresses: %m");
1134
1135 r = manager_enumerate_neighbors(m);
1136 if (r < 0)
1137 return log_error_errno(r, "Could not enumerate neighbors: %m");
1138
1139 r = manager_enumerate_nexthop(m);
1140 if (r < 0)
1141 return log_error_errno(r, "Could not enumerate nexthops: %m");
1142
1143 r = manager_enumerate_routes(m);
1144 if (r < 0)
1145 return log_error_errno(r, "Could not enumerate routes: %m");
1146
1147 /* If the kernel is built without CONFIG_FIB_RULES, the below will fail with -EOPNOTSUPP. */
1148 r = manager_enumerate_rules(m);
1149 if (r == -EOPNOTSUPP)
1150 log_debug_errno(r, "Could not enumerate routing policy rules, ignoring: %m");
1151 else if (r < 0)
1152 return log_error_errno(r, "Could not enumerate routing policy rules: %m");
1153
1154 /* If the kernel is built without CONFIG_WIRELESS, the below will fail with -EOPNOTSUPP. */
1155 r = manager_enumerate_nl80211_wiphy(m);
1156 if (r == -EOPNOTSUPP)
1157 log_debug_errno(r, "Could not enumerate wireless LAN phy, ignoring: %m");
1158 else if (r < 0)
1159 return log_error_errno(r, "Could not enumerate wireless LAN phy: %m");
1160
1161 r = manager_enumerate_nl80211_config(m);
1162 if (r == -EOPNOTSUPP)
1163 log_debug_errno(r, "Could not enumerate wireless LAN interfaces, ignoring: %m");
1164 else if (r < 0)
1165 return log_error_errno(r, "Could not enumerate wireless LAN interfaces: %m");
1166
1167 r = manager_enumerate_nl80211_mlme(m);
1168 if (r == -EOPNOTSUPP)
1169 log_debug_errno(r, "Could not enumerate wireless LAN stations, ignoring: %m");
1170 else if (r < 0)
1171 return log_error_errno(r, "Could not enumerate wireless LAN stations: %m");
1172
1173 log_debug("Enumeration completed.");
1174 return 0;
1175 }
1176
1177 static int set_hostname_handler(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
1178 const sd_bus_error *e;
1179 int r;
1180
1181 assert(m);
1182
1183 e = sd_bus_message_get_error(m);
1184 if (e) {
1185 r = sd_bus_error_get_errno(e);
1186 log_warning_errno(r, "Could not set hostname: %s", bus_error_message(e, r));
1187 }
1188
1189 return 1;
1190 }
1191
1192 int manager_set_hostname(Manager *m, const char *hostname) {
1193 int r;
1194
1195 log_debug("Setting transient hostname: '%s'", strna(hostname));
1196
1197 r = free_and_strdup_warn(&m->dynamic_hostname, hostname);
1198 if (r < 0)
1199 return r;
1200
1201 if (sd_bus_is_ready(m->bus) <= 0) {
1202 log_debug("Not connected to system bus, setting system hostname later.");
1203 return 0;
1204 }
1205
1206 r = bus_call_method_async(
1207 m->bus,
1208 NULL,
1209 bus_hostname,
1210 "SetHostname",
1211 set_hostname_handler,
1212 m,
1213 "sb",
1214 hostname,
1215 false);
1216 if (r < 0)
1217 return log_error_errno(r, "Could not set transient hostname: %m");
1218
1219 return 0;
1220 }
1221
1222 static int set_timezone_handler(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
1223 const sd_bus_error *e;
1224 int r;
1225
1226 assert(m);
1227
1228 e = sd_bus_message_get_error(m);
1229 if (e) {
1230 r = sd_bus_error_get_errno(e);
1231 log_warning_errno(r, "Could not set timezone: %s", bus_error_message(e, r));
1232 }
1233
1234 return 1;
1235 }
1236
1237 int manager_set_timezone(Manager *m, const char *tz) {
1238 int r;
1239
1240 assert(m);
1241 assert(tz);
1242
1243 log_debug("Setting system timezone: '%s'", tz);
1244 r = free_and_strdup_warn(&m->dynamic_timezone, tz);
1245 if (r < 0)
1246 return r;
1247
1248 if (sd_bus_is_ready(m->bus) <= 0) {
1249 log_debug("Not connected to system bus, setting system timezone later.");
1250 return 0;
1251 }
1252
1253 r = bus_call_method_async(
1254 m->bus,
1255 NULL,
1256 bus_timedate,
1257 "SetTimezone",
1258 set_timezone_handler,
1259 m,
1260 "sb",
1261 tz,
1262 false);
1263 if (r < 0)
1264 return log_error_errno(r, "Could not set timezone: %m");
1265
1266 return 0;
1267 }
1268
1269 int manager_reload(Manager *m, sd_bus_message *message, sd_varlink *varlink) {
1270 Link *link;
1271 int r;
1272
1273 assert(m);
1274 assert(!message || !varlink); /* D-Bus and Varlink callers are mutually exclusive */
1275
1276 log_debug("Reloading...");
1277 (void) notify_reloading();
1278
1279 r = netdev_reload(m);
1280 if (r < 0) {
1281 log_debug_errno(r, "Failed to reload .netdev files: %m");
1282 goto finish;
1283 }
1284
1285 r = network_reload(m);
1286 if (r < 0) {
1287 log_debug_errno(r, "Failed to reload .network files: %m");
1288 goto finish;
1289 }
1290
1291 HASHMAP_FOREACH(link, m->links_by_index)
1292 (void) link_reconfigure_full(
1293 link,
1294 /* flags= */ 0,
1295 message,
1296 varlink,
1297 /* counter= */ (message || varlink) ? &m->reloading : NULL);
1298
1299 log_debug("Reloaded.");
1300 r = 0;
1301 finish:
1302 (void) sd_notify(/* unset_environment= */ false, NOTIFY_READY_MESSAGE);
1303 return r;
1304 }