1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 #include <netinet/in.h>
4 #include <sys/socket.h>
7 #include <linux/fib_rules.h>
10 #include "sd-netlink.h"
12 #include "alloc-util.h"
14 #include "conf-parser.h"
16 #include "device-private.h"
17 #include "device-util.h"
18 #include "dns-domain.h"
21 #include "local-addresses.h"
22 #include "netlink-util.h"
23 #include "network-internal.h"
24 #include "networkd-dhcp6.h"
25 #include "networkd-link-bus.h"
26 #include "networkd-manager-bus.h"
27 #include "networkd-manager.h"
28 #include "networkd-network-bus.h"
29 #include "networkd-speed-meter.h"
30 #include "ordered-set.h"
31 #include "path-util.h"
34 #include "sysctl-util.h"
35 #include "tmpfile-util.h"
36 #include "udev-util.h"
39 /* use 8 MB for receive socket kernel queue. */
40 #define RCVBUF_SIZE (8*1024*1024)
42 static int setup_default_address_pool(Manager
*m
) {
48 /* Add in the well-known private address ranges. */
50 r
= address_pool_new_from_string(m
, &p
, AF_INET6
, "fd00::", 8);
54 r
= address_pool_new_from_string(m
, &p
, AF_INET
, "10.0.0.0", 8);
58 r
= address_pool_new_from_string(m
, &p
, AF_INET
, "172.16.0.0", 12);
62 r
= address_pool_new_from_string(m
, &p
, AF_INET
, "192.168.0.0", 16);
69 static int manager_reset_all(Manager
*m
) {
76 HASHMAP_FOREACH(link
, m
->links
, i
) {
77 r
= link_carrier_reset(link
);
79 log_link_warning_errno(link
, r
, "Could not reset carrier: %m");
85 static int match_prepare_for_sleep(sd_bus_message
*message
, void *userdata
, sd_bus_error
*ret_error
) {
86 Manager
*m
= userdata
;
92 r
= sd_bus_message_read(message
, "b", &b
);
94 log_debug_errno(r
, "Failed to parse PrepareForSleep signal: %m");
101 log_debug("Coming back from suspend, resetting all connections...");
103 (void) manager_reset_all(m
);
108 static int on_connected(sd_bus_message
*message
, void *userdata
, sd_bus_error
*ret_error
) {
109 Manager
*m
= userdata
;
114 /* Did we get a timezone or transient hostname from DHCP while D-Bus wasn't up yet? */
115 if (m
->dynamic_hostname
)
116 (void) manager_set_hostname(m
, m
->dynamic_hostname
);
117 if (m
->dynamic_timezone
)
118 (void) manager_set_timezone(m
, m
->dynamic_timezone
);
119 if (m
->links_requesting_uuid
)
120 (void) manager_request_product_uuid(m
, NULL
);
125 int manager_connect_bus(Manager
*m
) {
133 r
= bus_open_system_watch_bind_with_description(&m
->bus
, "bus-api-network");
135 return log_error_errno(r
, "Failed to connect to bus: %m");
137 r
= sd_bus_add_object_vtable(m
->bus
, NULL
, "/org/freedesktop/network1", "org.freedesktop.network1.Manager", manager_vtable
, m
);
139 return log_error_errno(r
, "Failed to add manager object vtable: %m");
141 r
= sd_bus_add_fallback_vtable(m
->bus
, NULL
, "/org/freedesktop/network1/link", "org.freedesktop.network1.Link", link_vtable
, link_object_find
, m
);
143 return log_error_errno(r
, "Failed to add link object vtable: %m");
145 r
= sd_bus_add_node_enumerator(m
->bus
, NULL
, "/org/freedesktop/network1/link", link_node_enumerator
, m
);
147 return log_error_errno(r
, "Failed to add link enumerator: %m");
149 r
= sd_bus_add_fallback_vtable(m
->bus
, NULL
, "/org/freedesktop/network1/network", "org.freedesktop.network1.Network", network_vtable
, network_object_find
, m
);
151 return log_error_errno(r
, "Failed to add network object vtable: %m");
153 r
= sd_bus_add_node_enumerator(m
->bus
, NULL
, "/org/freedesktop/network1/network", network_node_enumerator
, m
);
155 return log_error_errno(r
, "Failed to add network enumerator: %m");
157 r
= sd_bus_request_name_async(m
->bus
, NULL
, "org.freedesktop.network1", 0, NULL
, NULL
);
159 return log_error_errno(r
, "Failed to request name: %m");
161 r
= sd_bus_attach_event(m
->bus
, m
->event
, 0);
163 return log_error_errno(r
, "Failed to attach bus to event loop: %m");
165 r
= sd_bus_match_signal_async(
168 "org.freedesktop.DBus.Local",
170 "org.freedesktop.DBus.Local",
172 on_connected
, NULL
, m
);
174 return log_error_errno(r
, "Failed to request match on Connected signal: %m");
176 r
= sd_bus_match_signal_async(
179 "org.freedesktop.login1",
180 "/org/freedesktop/login1",
181 "org.freedesktop.login1.Manager",
183 match_prepare_for_sleep
, NULL
, m
);
185 log_warning_errno(r
, "Failed to request match for PrepareForSleep, ignoring: %m");
190 static int manager_udev_process_link(sd_device_monitor
*monitor
, sd_device
*device
, void *userdata
) {
191 Manager
*m
= userdata
;
199 r
= device_get_action(device
, &action
);
201 log_device_debug_errno(device
, r
, "Failed to get udev action, ignoring device: %m");
205 if (!IN_SET(action
, DEVICE_ACTION_ADD
, DEVICE_ACTION_CHANGE
, DEVICE_ACTION_MOVE
)) {
206 log_device_debug(device
, "Ignoring udev %s event for device.", device_action_to_string(action
));
210 r
= sd_device_get_ifindex(device
, &ifindex
);
212 log_device_debug_errno(device
, r
, "Ignoring udev ADD event for device without ifindex or with invalid ifindex: %m");
216 r
= device_is_renaming(device
);
218 log_device_error_errno(device
, r
, "Failed to determine the device is renamed or not, ignoring '%s' uevent: %m",
219 device_action_to_string(action
));
223 log_device_debug(device
, "Interface is under renaming, wait for the interface to be renamed: %m");
227 r
= link_get(m
, ifindex
, &link
);
230 log_debug_errno(r
, "Failed to get link from ifindex %i, ignoring: %m", ifindex
);
234 (void) link_initialized(link
, device
);
239 static int manager_connect_udev(Manager
*m
) {
242 /* udev does not initialize devices inside containers,
243 * so we rely on them being already initialized before
244 * entering the container */
245 if (detect_container() > 0)
248 r
= sd_device_monitor_new(&m
->device_monitor
);
250 return log_error_errno(r
, "Failed to initialize device monitor: %m");
252 r
= sd_device_monitor_filter_add_match_subsystem_devtype(m
->device_monitor
, "net", NULL
);
254 return log_error_errno(r
, "Could not add device monitor filter: %m");
256 r
= sd_device_monitor_attach_event(m
->device_monitor
, m
->event
);
258 return log_error_errno(r
, "Failed to attach event to device monitor: %m");
260 r
= sd_device_monitor_start(m
->device_monitor
, manager_udev_process_link
, m
);
262 return log_error_errno(r
, "Failed to start device monitor: %m");
267 int manager_rtnl_process_route(sd_netlink
*rtnl
, sd_netlink_message
*message
, void *userdata
) {
268 Manager
*m
= userdata
;
271 uint32_t ifindex
, priority
= 0;
272 unsigned char protocol
, scope
, tos
, table
, rt_type
;
274 unsigned char dst_prefixlen
, src_prefixlen
;
275 union in_addr_union dst
= IN_ADDR_NULL
, gw
= IN_ADDR_NULL
, src
= IN_ADDR_NULL
, prefsrc
= IN_ADDR_NULL
;
283 if (sd_netlink_message_is_error(message
)) {
284 r
= sd_netlink_message_get_errno(message
);
286 log_warning_errno(r
, "rtnl: failed to receive route message, ignoring: %m");
291 r
= sd_netlink_message_get_type(message
, &type
);
293 log_warning_errno(r
, "rtnl: could not get message type, ignoring: %m");
295 } else if (!IN_SET(type
, RTM_NEWROUTE
, RTM_DELROUTE
)) {
296 log_warning("rtnl: received unexpected message type %u when processing route, ignoring.", type
);
300 r
= sd_netlink_message_read_u32(message
, RTA_OIF
, &ifindex
);
302 log_debug("rtnl: received route message without ifindex, ignoring");
305 log_warning_errno(r
, "rtnl: could not get ifindex from route message, ignoring: %m");
307 } else if (ifindex
<= 0) {
308 log_warning("rtnl: received route message with invalid ifindex %d, ignoring.", ifindex
);
312 r
= link_get(m
, ifindex
, &link
);
313 if (r
< 0 || !link
) {
314 /* when enumerating we might be out of sync, but we will
315 * get the route again, so just ignore it */
317 log_warning("rtnl: received route message for link (%d) we do not know about, ignoring", ifindex
);
321 r
= sd_rtnl_message_route_get_family(message
, &family
);
322 if (r
< 0 || !IN_SET(family
, AF_INET
, AF_INET6
)) {
323 log_link_warning(link
, "rtnl: received route message with invalid family, ignoring");
327 r
= sd_rtnl_message_route_get_protocol(message
, &protocol
);
329 log_warning_errno(r
, "rtnl: received route message with invalid route protocol: %m");
335 r
= sd_netlink_message_read_in_addr(message
, RTA_DST
, &dst
.in
);
336 if (r
< 0 && r
!= -ENODATA
) {
337 log_link_warning_errno(link
, r
, "rtnl: received route message without valid destination, ignoring: %m");
341 r
= sd_netlink_message_read_in_addr(message
, RTA_GATEWAY
, &gw
.in
);
342 if (r
< 0 && r
!= -ENODATA
) {
343 log_link_warning_errno(link
, r
, "rtnl: received route message without valid gateway, ignoring: %m");
347 r
= sd_netlink_message_read_in_addr(message
, RTA_SRC
, &src
.in
);
348 if (r
< 0 && r
!= -ENODATA
) {
349 log_link_warning_errno(link
, r
, "rtnl: received route message without valid source, ignoring: %m");
353 r
= sd_netlink_message_read_in_addr(message
, RTA_PREFSRC
, &prefsrc
.in
);
354 if (r
< 0 && r
!= -ENODATA
) {
355 log_link_warning_errno(link
, r
, "rtnl: received route message without valid preferred source, ignoring: %m");
362 r
= sd_netlink_message_read_in6_addr(message
, RTA_DST
, &dst
.in6
);
363 if (r
< 0 && r
!= -ENODATA
) {
364 log_link_warning_errno(link
, r
, "rtnl: received route message without valid destination, ignoring: %m");
368 r
= sd_netlink_message_read_in6_addr(message
, RTA_GATEWAY
, &gw
.in6
);
369 if (r
< 0 && r
!= -ENODATA
) {
370 log_link_warning_errno(link
, r
, "rtnl: received route message without valid gateway, ignoring: %m");
374 r
= sd_netlink_message_read_in6_addr(message
, RTA_SRC
, &src
.in6
);
375 if (r
< 0 && r
!= -ENODATA
) {
376 log_link_warning_errno(link
, r
, "rtnl: received route message without valid source, ignoring: %m");
380 r
= sd_netlink_message_read_in6_addr(message
, RTA_PREFSRC
, &prefsrc
.in6
);
381 if (r
< 0 && r
!= -ENODATA
) {
382 log_link_warning_errno(link
, r
, "rtnl: received route message without valid preferred source, ignoring: %m");
389 assert_not_reached("Received route message with unsupported address family");
393 r
= sd_rtnl_message_route_get_dst_prefixlen(message
, &dst_prefixlen
);
395 log_link_warning_errno(link
, r
, "rtnl: received route message with invalid destination prefixlen, ignoring: %m");
399 r
= sd_rtnl_message_route_get_src_prefixlen(message
, &src_prefixlen
);
401 log_link_warning_errno(link
, r
, "rtnl: received route message with invalid source prefixlen, ignoring: %m");
405 r
= sd_rtnl_message_route_get_scope(message
, &scope
);
407 log_link_warning_errno(link
, r
, "rtnl: received route message with invalid scope, ignoring: %m");
411 r
= sd_rtnl_message_route_get_tos(message
, &tos
);
413 log_link_warning_errno(link
, r
, "rtnl: received route message with invalid tos, ignoring: %m");
417 r
= sd_rtnl_message_route_get_type(message
, &rt_type
);
419 log_link_warning_errno(link
, r
, "rtnl: received route message with invalid type, ignoring: %m");
423 r
= sd_rtnl_message_route_get_table(message
, &table
);
425 log_link_warning_errno(link
, r
, "rtnl: received route message with invalid table, ignoring: %m");
429 r
= sd_netlink_message_read_u32(message
, RTA_PRIORITY
, &priority
);
430 if (r
< 0 && r
!= -ENODATA
) {
431 log_link_warning_errno(link
, r
, "rtnl: received route message with invalid priority, ignoring: %m");
435 (void) route_get(link
, family
, &dst
, dst_prefixlen
, &gw
, tos
, priority
, table
, &route
);
438 _cleanup_free_
char *buf_dst
= NULL
, *buf_dst_prefixlen
= NULL
,
439 *buf_src
= NULL
, *buf_gw
= NULL
, *buf_prefsrc
= NULL
;
440 char buf_scope
[ROUTE_SCOPE_STR_MAX
], buf_table
[ROUTE_TABLE_STR_MAX
],
441 buf_protocol
[ROUTE_PROTOCOL_STR_MAX
];
443 if (!in_addr_is_null(family
, &dst
)) {
444 (void) in_addr_to_string(family
, &dst
, &buf_dst
);
445 (void) asprintf(&buf_dst_prefixlen
, "/%u", dst_prefixlen
);
447 if (!in_addr_is_null(family
, &src
))
448 (void) in_addr_to_string(family
, &src
, &buf_src
);
449 if (!in_addr_is_null(family
, &gw
))
450 (void) in_addr_to_string(family
, &gw
, &buf_gw
);
451 if (!in_addr_is_null(family
, &prefsrc
))
452 (void) in_addr_to_string(family
, &prefsrc
, &buf_prefsrc
);
455 "%s route: dst: %s%s, src: %s, gw: %s, prefsrc: %s, scope: %s, table: %s, proto: %s, type: %s",
456 type
== RTM_DELROUTE
? "Forgetting" : route
? "Updating remembered" : "Remembering",
457 strna(buf_dst
), strempty(buf_dst_prefixlen
),
458 strna(buf_src
), strna(buf_gw
), strna(buf_prefsrc
),
459 format_route_scope(scope
, buf_scope
, sizeof buf_scope
),
460 format_route_table(table
, buf_table
, sizeof buf_table
),
461 format_route_protocol(protocol
, buf_protocol
, sizeof buf_protocol
),
462 strna(route_type_to_string(rt_type
)));
468 /* A route appeared that we did not request */
469 r
= route_add_foreign(link
, family
, &dst
, dst_prefixlen
, &gw
, tos
, priority
, table
, &route
);
471 log_link_warning_errno(link
, r
, "Failed to remember foreign route, ignoring: %m");
476 route_update(route
, &src
, src_prefixlen
, &gw
, &prefsrc
, scope
, protocol
, rt_type
);
485 assert_not_reached("Received route message with invalid RTNL message type");
491 int manager_rtnl_process_address(sd_netlink
*rtnl
, sd_netlink_message
*message
, void *userdata
) {
492 _cleanup_free_
char *buf
= NULL
;
493 Manager
*m
= userdata
;
496 unsigned char flags
, prefixlen
, scope
;
497 union in_addr_union in_addr
= IN_ADDR_NULL
;
498 struct ifa_cacheinfo cinfo
;
499 Address
*address
= NULL
;
500 char valid_buf
[FORMAT_TIMESPAN_MAX
];
501 const char *valid_str
= NULL
;
502 int ifindex
, family
, r
;
508 if (sd_netlink_message_is_error(message
)) {
509 r
= sd_netlink_message_get_errno(message
);
511 log_warning_errno(r
, "rtnl: failed to receive address message, ignoring: %m");
516 r
= sd_netlink_message_get_type(message
, &type
);
518 log_warning_errno(r
, "rtnl: could not get message type, ignoring: %m");
520 } else if (!IN_SET(type
, RTM_NEWADDR
, RTM_DELADDR
)) {
521 log_warning("rtnl: received unexpected message type %u when processing address, ignoring.", type
);
525 r
= sd_rtnl_message_addr_get_ifindex(message
, &ifindex
);
527 log_warning_errno(r
, "rtnl: could not get ifindex from message, ignoring: %m");
529 } else if (ifindex
<= 0) {
530 log_warning("rtnl: received address message with invalid ifindex %d, ignoring.", ifindex
);
534 r
= link_get(m
, ifindex
, &link
);
535 if (r
< 0 || !link
) {
536 /* when enumerating we might be out of sync, but we will get the address again, so just
539 log_warning("rtnl: received address for link '%d' we don't know about, ignoring.", ifindex
);
543 r
= sd_rtnl_message_addr_get_family(message
, &family
);
544 if (r
< 0 || !IN_SET(family
, AF_INET
, AF_INET6
)) {
545 log_link_warning(link
, "rtnl: received address message with invalid family, ignoring.");
549 r
= sd_rtnl_message_addr_get_prefixlen(message
, &prefixlen
);
551 log_link_warning_errno(link
, r
, "rtnl: received address message with invalid prefixlen, ignoring: %m");
555 r
= sd_rtnl_message_addr_get_scope(message
, &scope
);
557 log_link_warning_errno(link
, r
, "rtnl: received address message with invalid scope, ignoring: %m");
561 r
= sd_rtnl_message_addr_get_flags(message
, &flags
);
563 log_link_warning_errno(link
, r
, "rtnl: received address message with invalid flags, ignoring: %m");
569 r
= sd_netlink_message_read_in_addr(message
, IFA_LOCAL
, &in_addr
.in
);
571 log_link_warning_errno(link
, r
, "rtnl: received address message without valid address, ignoring: %m");
578 r
= sd_netlink_message_read_in6_addr(message
, IFA_ADDRESS
, &in_addr
.in6
);
580 log_link_warning_errno(link
, r
, "rtnl: received address message without valid address, ignoring: %m");
587 assert_not_reached("Received unsupported address family");
590 r
= in_addr_to_string(family
, &in_addr
, &buf
);
592 log_link_warning_errno(link
, r
, "Could not print address: %m");
594 r
= sd_netlink_message_read_cache_info(message
, IFA_CACHEINFO
, &cinfo
);
595 if (r
< 0 && r
!= -ENODATA
) {
596 log_link_warning_errno(link
, r
, "rtnl: cannot get IFA_CACHEINFO attribute, ignoring: %m");
598 } else if (r
>= 0 && cinfo
.ifa_valid
!= CACHE_INFO_INFINITY_LIFE_TIME
)
599 valid_str
= format_timespan(valid_buf
, FORMAT_TIMESPAN_MAX
,
600 cinfo
.ifa_valid
* USEC_PER_SEC
,
603 (void) address_get(link
, family
, &in_addr
, prefixlen
, &address
);
608 log_link_debug(link
, "Remembering updated address: %s/%u (valid %s%s)",
609 strnull(buf
), prefixlen
,
610 valid_str
? "for " : "forever", strempty(valid_str
));
612 /* An address appeared that we did not request */
613 r
= address_add_foreign(link
, family
, &in_addr
, prefixlen
, &address
);
615 log_link_warning_errno(link
, r
, "Failed to remember foreign address %s/%u, ignoring: %m",
616 strnull(buf
), prefixlen
);
619 log_link_debug(link
, "Remembering foreign address: %s/%u (valid %s%s)",
620 strnull(buf
), prefixlen
,
621 valid_str
? "for " : "forever", strempty(valid_str
));
624 /* address_update() logs internally, so we don't need to. */
625 (void) address_update(address
, flags
, scope
, &cinfo
);
631 log_link_debug(link
, "Forgetting address: %s/%u (valid %s%s)",
632 strnull(buf
), prefixlen
,
633 valid_str
? "for " : "forever", strempty(valid_str
));
634 (void) address_drop(address
);
636 log_link_info(link
, "Kernel removed an address we don't remember: %s/%u (valid %s%s), ignoring.",
637 strnull(buf
), prefixlen
,
638 valid_str
? "for " : "forever", strempty(valid_str
));
643 assert_not_reached("Received invalid RTNL message type");
649 static int manager_rtnl_process_link(sd_netlink
*rtnl
, sd_netlink_message
*message
, void *userdata
) {
650 Manager
*m
= userdata
;
652 NetDev
*netdev
= NULL
;
661 if (sd_netlink_message_is_error(message
)) {
662 r
= sd_netlink_message_get_errno(message
);
664 log_warning_errno(r
, "rtnl: Could not receive link message, ignoring: %m");
669 r
= sd_netlink_message_get_type(message
, &type
);
671 log_warning_errno(r
, "rtnl: Could not get message type, ignoring: %m");
673 } else if (!IN_SET(type
, RTM_NEWLINK
, RTM_DELLINK
)) {
674 log_warning("rtnl: Received unexpected message type %u when processing link, ignoring.", type
);
678 r
= sd_rtnl_message_link_get_ifindex(message
, &ifindex
);
680 log_warning_errno(r
, "rtnl: Could not get ifindex from link message, ignoring: %m");
682 } else if (ifindex
<= 0) {
683 log_warning("rtnl: received link message with invalid ifindex %d, ignoring.", ifindex
);
687 r
= sd_netlink_message_read_string(message
, IFLA_IFNAME
, &name
);
689 log_warning_errno(r
, "rtnl: Received link message without ifname, ignoring: %m");
693 (void) link_get(m
, ifindex
, &link
);
694 (void) netdev_get(m
, name
, &netdev
);
699 /* link is new, so add it */
700 r
= link_add(m
, message
, &link
);
702 log_warning_errno(r
, "Could not process new link message, ignoring: %m");
708 /* netdev exists, so make sure the ifindex matches */
709 r
= netdev_set_ifindex(netdev
, message
);
711 log_warning_errno(r
, "Could not process new link message for netdev, ignoring: %m");
716 r
= link_update(link
, message
);
718 log_warning_errno(r
, "Could not process link message, ignoring: %m");
731 assert_not_reached("Received link message with invalid RTNL message type.");
737 int manager_rtnl_process_rule(sd_netlink
*rtnl
, sd_netlink_message
*message
, void *userdata
) {
738 _cleanup_(routing_policy_rule_freep
) RoutingPolicyRule
*tmp
= NULL
;
739 RoutingPolicyRule
*rule
= NULL
;
740 const char *iif
= NULL
, *oif
= NULL
;
741 Manager
*m
= userdata
;
750 if (sd_netlink_message_is_error(message
)) {
751 r
= sd_netlink_message_get_errno(message
);
753 log_warning_errno(r
, "rtnl: failed to receive rule message, ignoring: %m");
758 r
= sd_netlink_message_get_type(message
, &type
);
760 log_warning_errno(r
, "rtnl: could not get message type, ignoring: %m");
762 } else if (!IN_SET(type
, RTM_NEWRULE
, RTM_DELRULE
)) {
763 log_warning("rtnl: received unexpected message type %u when processing rule, ignoring.", type
);
767 r
= routing_policy_rule_new(&tmp
);
773 r
= sd_rtnl_message_get_family(message
, &tmp
->family
);
775 log_warning_errno(r
, "rtnl: could not get rule family, ignoring: %m");
777 } else if (!IN_SET(tmp
->family
, AF_INET
, AF_INET6
)) {
778 log_debug("rtnl: received rule message with invalid family %d, ignoring.", tmp
->family
);
782 switch (tmp
->family
) {
784 r
= sd_netlink_message_read_in_addr(message
, FRA_SRC
, &tmp
->from
.in
);
785 if (r
< 0 && r
!= -ENODATA
) {
786 log_warning_errno(r
, "rtnl: could not get FRA_SRC attribute, ignoring: %m");
789 r
= sd_rtnl_message_routing_policy_rule_get_rtm_src_prefixlen(message
, &tmp
->from_prefixlen
);
791 log_warning_errno(r
, "rtnl: received rule message without valid source prefix length, ignoring: %m");
796 r
= sd_netlink_message_read_in_addr(message
, FRA_DST
, &tmp
->to
.in
);
797 if (r
< 0 && r
!= -ENODATA
) {
798 log_warning_errno(r
, "rtnl: could not get FRA_DST attribute, ignoring: %m");
801 r
= sd_rtnl_message_routing_policy_rule_get_rtm_dst_prefixlen(message
, &tmp
->to_prefixlen
);
803 log_warning_errno(r
, "rtnl: received rule message without valid destination prefix length, ignoring: %m");
811 r
= sd_netlink_message_read_in6_addr(message
, FRA_SRC
, &tmp
->from
.in6
);
812 if (r
< 0 && r
!= -ENODATA
) {
813 log_warning_errno(r
, "rtnl: could not get FRA_SRC attribute, ignoring: %m");
816 r
= sd_rtnl_message_routing_policy_rule_get_rtm_src_prefixlen(message
, &tmp
->from_prefixlen
);
818 log_warning_errno(r
, "rtnl: received rule message without valid source prefix length, ignoring: %m");
823 r
= sd_netlink_message_read_in6_addr(message
, FRA_DST
, &tmp
->to
.in6
);
824 if (r
< 0 && r
!= -ENODATA
) {
825 log_warning_errno(r
, "rtnl: could not get FRA_DST attribute, ignoring: %m");
828 r
= sd_rtnl_message_routing_policy_rule_get_rtm_dst_prefixlen(message
, &tmp
->to_prefixlen
);
830 log_warning_errno(r
, "rtnl: received rule message without valid destination prefix length, ignoring: %m");
838 assert_not_reached("Received rule message with unsupported address family");
841 if (tmp
->from_prefixlen
== 0 && tmp
->to_prefixlen
== 0)
844 r
= sd_rtnl_message_routing_policy_rule_get_flags(message
, &flags
);
846 log_warning_errno(r
, "rtnl: received rule message without valid flag, ignoring: %m");
849 tmp
->invert_rule
= flags
& FIB_RULE_INVERT
;
851 r
= sd_netlink_message_read_u32(message
, FRA_FWMARK
, &tmp
->fwmark
);
852 if (r
< 0 && r
!= -ENODATA
) {
853 log_warning_errno(r
, "rtnl: could not get FRA_FWMARK attribute, ignoring: %m");
857 r
= sd_netlink_message_read_u32(message
, FRA_FWMASK
, &tmp
->fwmask
);
858 if (r
< 0 && r
!= -ENODATA
) {
859 log_warning_errno(r
, "rtnl: could not get FRA_FWMASK attribute, ignoring: %m");
863 r
= sd_netlink_message_read_u32(message
, FRA_PRIORITY
, &tmp
->priority
);
864 if (r
< 0 && r
!= -ENODATA
) {
865 log_warning_errno(r
, "rtnl: could not get FRA_PRIORITY attribute, ignoring: %m");
869 r
= sd_netlink_message_read_u32(message
, FRA_TABLE
, &tmp
->table
);
870 if (r
< 0 && r
!= -ENODATA
) {
871 log_warning_errno(r
, "rtnl: could not get FRA_TABLE attribute, ignoring: %m");
875 r
= sd_rtnl_message_routing_policy_rule_get_tos(message
, &tmp
->tos
);
876 if (r
< 0 && r
!= -ENODATA
) {
877 log_warning_errno(r
, "rtnl: could not get ip rule TOS, ignoring: %m");
881 r
= sd_netlink_message_read_string(message
, FRA_IIFNAME
, &iif
);
882 if (r
< 0 && r
!= -ENODATA
) {
883 log_warning_errno(r
, "rtnl: could not get FRA_IIFNAME attribute, ignoring: %m");
886 r
= free_and_strdup(&tmp
->iif
, iif
);
890 r
= sd_netlink_message_read_string(message
, FRA_OIFNAME
, &oif
);
891 if (r
< 0 && r
!= -ENODATA
) {
892 log_warning_errno(r
, "rtnl: could not get FRA_OIFNAME attribute, ignoring: %m");
895 r
= free_and_strdup(&tmp
->oif
, oif
);
899 r
= sd_netlink_message_read_u8(message
, FRA_IP_PROTO
, &tmp
->protocol
);
900 if (r
< 0 && r
!= -ENODATA
) {
901 log_warning_errno(r
, "rtnl: could not get FRA_IP_PROTO attribute, ignoring: %m");
905 r
= sd_netlink_message_read(message
, FRA_SPORT_RANGE
, sizeof(tmp
->sport
), &tmp
->sport
);
906 if (r
< 0 && r
!= -ENODATA
) {
907 log_warning_errno(r
, "rtnl: could not get FRA_SPORT_RANGE attribute, ignoring: %m");
911 r
= sd_netlink_message_read(message
, FRA_DPORT_RANGE
, sizeof(tmp
->dport
), &tmp
->dport
);
912 if (r
< 0 && r
!= -ENODATA
) {
913 log_warning_errno(r
, "rtnl: could not get FRA_DPORT_RANGE attribute, ignoring: %m");
917 (void) routing_policy_rule_get(m
, tmp
, &rule
);
922 r
= routing_policy_rule_add_foreign(m
, tmp
, &rule
);
924 log_warning_errno(r
, "Could not remember foreign rule, ignoring: %m");
930 routing_policy_rule_free(rule
);
935 assert_not_reached("Received invalid RTNL message type");
941 static int systemd_netlink_fd(void) {
942 int n
, fd
, rtnl_fd
= -EINVAL
;
944 n
= sd_listen_fds(true);
948 for (fd
= SD_LISTEN_FDS_START
; fd
< SD_LISTEN_FDS_START
+ n
; fd
++) {
949 if (sd_is_socket(fd
, AF_NETLINK
, SOCK_RAW
, -1) > 0) {
960 static int manager_connect_genl(Manager
*m
) {
965 r
= sd_genl_socket_open(&m
->genl
);
969 r
= sd_netlink_inc_rcvbuf(m
->genl
, RCVBUF_SIZE
);
973 r
= sd_netlink_attach_event(m
->genl
, m
->event
, 0);
980 static int manager_connect_rtnl(Manager
*m
) {
985 fd
= systemd_netlink_fd();
987 r
= sd_netlink_open(&m
->rtnl
);
989 r
= sd_netlink_open_fd(&m
->rtnl
, fd
);
993 r
= sd_netlink_inc_rcvbuf(m
->rtnl
, RCVBUF_SIZE
);
997 r
= sd_netlink_attach_event(m
->rtnl
, m
->event
, 0);
1001 r
= sd_netlink_add_match(m
->rtnl
, NULL
, RTM_NEWLINK
, &manager_rtnl_process_link
, NULL
, m
, "network-rtnl_process_link");
1005 r
= sd_netlink_add_match(m
->rtnl
, NULL
, RTM_DELLINK
, &manager_rtnl_process_link
, NULL
, m
, "network-rtnl_process_link");
1009 r
= sd_netlink_add_match(m
->rtnl
, NULL
, RTM_NEWADDR
, &manager_rtnl_process_address
, NULL
, m
, "network-rtnl_process_address");
1013 r
= sd_netlink_add_match(m
->rtnl
, NULL
, RTM_DELADDR
, &manager_rtnl_process_address
, NULL
, m
, "network-rtnl_process_address");
1017 r
= sd_netlink_add_match(m
->rtnl
, NULL
, RTM_NEWROUTE
, &manager_rtnl_process_route
, NULL
, m
, "network-rtnl_process_route");
1021 r
= sd_netlink_add_match(m
->rtnl
, NULL
, RTM_DELROUTE
, &manager_rtnl_process_route
, NULL
, m
, "network-rtnl_process_route");
1025 r
= sd_netlink_add_match(m
->rtnl
, NULL
, RTM_NEWRULE
, &manager_rtnl_process_rule
, NULL
, m
, "network-rtnl_process_rule");
1029 r
= sd_netlink_add_match(m
->rtnl
, NULL
, RTM_DELRULE
, &manager_rtnl_process_rule
, NULL
, m
, "network-rtnl_process_rule");
1036 static int ordered_set_put_in_addr_data(OrderedSet
*s
, const struct in_addr_data
*address
) {
1043 r
= in_addr_to_string(address
->family
, &address
->address
, &p
);
1047 r
= ordered_set_consume(s
, p
);
1054 static int ordered_set_put_in_addr_datav(OrderedSet
*s
, const struct in_addr_data
*addresses
, unsigned n
) {
1059 assert(addresses
|| n
== 0);
1061 for (i
= 0; i
< n
; i
++) {
1062 r
= ordered_set_put_in_addr_data(s
, addresses
+i
);
1072 static int ordered_set_put_in4_addr(OrderedSet
*s
, const struct in_addr
*address
) {
1079 r
= in_addr_to_string(AF_INET
, (const union in_addr_union
*) address
, &p
);
1083 r
= ordered_set_consume(s
, p
);
1090 static int ordered_set_put_in4_addrv(OrderedSet
*s
,
1091 const struct in_addr
*addresses
,
1093 bool (*predicate
)(const struct in_addr
*addr
)) {
1098 assert(n
== 0 || addresses
);
1100 for (i
= 0; i
< n
; i
++) {
1101 if (predicate
&& !predicate(&addresses
[i
]))
1103 r
= ordered_set_put_in4_addr(s
, addresses
+i
);
1113 static int manager_save(Manager
*m
) {
1114 _cleanup_ordered_set_free_free_ OrderedSet
*dns
= NULL
, *ntp
= NULL
, *search_domains
= NULL
, *route_domains
= NULL
;
1117 _cleanup_free_
char *temp_path
= NULL
;
1118 _cleanup_strv_free_
char **p
= NULL
;
1119 _cleanup_fclose_
FILE *f
= NULL
;
1120 LinkOperationalState operstate
= LINK_OPERSTATE_OFF
;
1121 LinkCarrierState carrier_state
= LINK_CARRIER_STATE_OFF
;
1122 LinkAddressState address_state
= LINK_ADDRESS_STATE_OFF
;
1123 const char *operstate_str
, *carrier_state_str
, *address_state_str
;
1127 assert(m
->state_file
);
1129 /* We add all NTP and DNS server to a set, to filter out duplicates */
1130 dns
= ordered_set_new(&string_hash_ops
);
1134 ntp
= ordered_set_new(&string_hash_ops
);
1138 search_domains
= ordered_set_new(&dns_name_hash_ops
);
1139 if (!search_domains
)
1142 route_domains
= ordered_set_new(&dns_name_hash_ops
);
1146 HASHMAP_FOREACH(link
, m
->links
, i
) {
1147 if (link
->flags
& IFF_LOOPBACK
)
1150 if (link
->operstate
> operstate
)
1151 operstate
= link
->operstate
;
1153 if (link
->carrier_state
> carrier_state
)
1154 carrier_state
= link
->carrier_state
;
1156 if (link
->address_state
> address_state
)
1157 address_state
= link
->address_state
;
1162 /* First add the static configured entries */
1163 r
= ordered_set_put_in_addr_datav(dns
, link
->network
->dns
, link
->network
->n_dns
);
1167 r
= ordered_set_put_strdupv(ntp
, link
->ntp
?: link
->network
->ntp
);
1171 r
= ordered_set_put_string_set(search_domains
, link
->search_domains
?: link
->network
->search_domains
);
1175 r
= ordered_set_put_string_set(route_domains
, link
->route_domains
?: link
->network
->route_domains
);
1179 if (!link
->dhcp_lease
)
1182 /* Secondly, add the entries acquired via DHCP */
1183 if (link
->network
->dhcp_use_dns
) {
1184 const struct in_addr
*addresses
;
1186 r
= sd_dhcp_lease_get_dns(link
->dhcp_lease
, &addresses
);
1188 r
= ordered_set_put_in4_addrv(dns
, addresses
, r
, in4_addr_is_non_local
);
1191 } else if (r
< 0 && r
!= -ENODATA
)
1195 if (link
->network
->dhcp_use_ntp
) {
1196 const struct in_addr
*addresses
;
1198 r
= sd_dhcp_lease_get_ntp(link
->dhcp_lease
, &addresses
);
1200 r
= ordered_set_put_in4_addrv(ntp
, addresses
, r
, in4_addr_is_non_local
);
1203 } else if (r
< 0 && r
!= -ENODATA
)
1207 if (link
->network
->dhcp_use_domains
!= DHCP_USE_DOMAINS_NO
) {
1208 const char *domainname
;
1209 char **domains
= NULL
;
1211 OrderedSet
*target_domains
= (link
->network
->dhcp_use_domains
== DHCP_USE_DOMAINS_YES
) ? search_domains
: route_domains
;
1212 r
= sd_dhcp_lease_get_domainname(link
->dhcp_lease
, &domainname
);
1214 r
= ordered_set_put_strdup(target_domains
, domainname
);
1217 } else if (r
!= -ENODATA
)
1220 r
= sd_dhcp_lease_get_search_domains(link
->dhcp_lease
, &domains
);
1222 r
= ordered_set_put_strdupv(target_domains
, domains
);
1225 } else if (r
!= -ENODATA
)
1230 if (carrier_state
>= LINK_CARRIER_STATE_ENSLAVED
)
1231 carrier_state
= LINK_CARRIER_STATE_CARRIER
;
1233 operstate_str
= link_operstate_to_string(operstate
);
1234 assert(operstate_str
);
1236 carrier_state_str
= link_carrier_state_to_string(carrier_state
);
1237 assert(carrier_state_str
);
1239 address_state_str
= link_address_state_to_string(address_state
);
1240 assert(address_state_str
);
1242 r
= fopen_temporary(m
->state_file
, &f
, &temp_path
);
1246 (void) fchmod(fileno(f
), 0644);
1249 "# This is private data. Do not parse.\n"
1251 "CARRIER_STATE=%s\n"
1252 "ADDRESS_STATE=%s\n",
1253 operstate_str
, carrier_state_str
, address_state_str
);
1255 ordered_set_print(f
, "DNS=", dns
);
1256 ordered_set_print(f
, "NTP=", ntp
);
1257 ordered_set_print(f
, "DOMAINS=", search_domains
);
1258 ordered_set_print(f
, "ROUTE_DOMAINS=", route_domains
);
1260 r
= routing_policy_serialize_rules(m
->rules
, f
);
1264 r
= fflush_and_check(f
);
1268 if (rename(temp_path
, m
->state_file
) < 0) {
1273 if (m
->operational_state
!= operstate
) {
1274 m
->operational_state
= operstate
;
1275 if (strv_extend(&p
, "OperationalState") < 0)
1279 if (m
->carrier_state
!= carrier_state
) {
1280 m
->carrier_state
= carrier_state
;
1281 if (strv_extend(&p
, "CarrierState") < 0)
1285 if (m
->address_state
!= address_state
) {
1286 m
->address_state
= address_state
;
1287 if (strv_extend(&p
, "AddressState") < 0)
1292 r
= manager_send_changed_strv(m
, p
);
1294 log_error_errno(r
, "Could not emit changed properties: %m");
1302 (void) unlink(m
->state_file
);
1303 (void) unlink(temp_path
);
1305 return log_error_errno(r
, "Failed to save network state to %s: %m", m
->state_file
);
1308 static int manager_dirty_handler(sd_event_source
*s
, void *userdata
) {
1309 Manager
*m
= userdata
;
1318 SET_FOREACH(link
, m
->dirty_links
, i
)
1319 if (link_save(link
) >= 0)
1325 int manager_new(Manager
**ret
) {
1326 _cleanup_(manager_freep
) Manager
*m
= NULL
;
1329 m
= new(Manager
, 1);
1334 .speed_meter_interval_usec
= SPEED_METER_DEFAULT_TIME_INTERVAL
,
1337 m
->state_file
= strdup("/run/systemd/netif/state");
1341 r
= sd_event_default(&m
->event
);
1345 (void) sd_event_set_watchdog(m
->event
, true);
1346 (void) sd_event_add_signal(m
->event
, NULL
, SIGTERM
, NULL
, NULL
);
1347 (void) sd_event_add_signal(m
->event
, NULL
, SIGINT
, NULL
, NULL
);
1349 r
= sd_event_add_post(m
->event
, NULL
, manager_dirty_handler
, m
);
1353 r
= manager_connect_rtnl(m
);
1357 r
= manager_connect_genl(m
);
1361 r
= manager_connect_udev(m
);
1365 r
= sd_resolve_default(&m
->resolve
);
1369 r
= sd_resolve_attach_event(m
->resolve
, m
->event
, 0);
1373 r
= setup_default_address_pool(m
);
1377 m
->duid
.type
= DUID_TYPE_EN
;
1379 (void) routing_policy_load_rules(m
->state_file
, &m
->rules_saved
);
1386 void manager_free(Manager
*m
) {
1394 free(m
->state_file
);
1396 while ((a
= hashmap_first_key(m
->dhcp6_prefixes
)))
1397 (void) dhcp6_prefix_remove(m
, a
);
1398 m
->dhcp6_prefixes
= hashmap_free(m
->dhcp6_prefixes
);
1400 while ((link
= hashmap_steal_first(m
->links
))) {
1401 if (link
->dhcp6_client
)
1402 (void) dhcp6_lease_pd_prefix_lost(link
->dhcp6_client
, link
);
1404 (void) link_stop_clients(link
, true);
1409 m
->dirty_links
= set_free_with_destructor(m
->dirty_links
, link_unref
);
1410 m
->links_requesting_uuid
= set_free_with_destructor(m
->links_requesting_uuid
, link_unref
);
1411 m
->links
= hashmap_free_with_destructor(m
->links
, link_unref
);
1413 m
->duids_requesting_uuid
= set_free(m
->duids_requesting_uuid
);
1414 m
->networks
= ordered_hashmap_free_with_destructor(m
->networks
, network_unref
);
1416 m
->netdevs
= hashmap_free_with_destructor(m
->netdevs
, netdev_unref
);
1418 while ((pool
= m
->address_pools
))
1419 address_pool_free(pool
);
1421 /* routing_policy_rule_free() access m->rules and m->rules_foreign.
1422 * So, it is necessary to set NULL after the sets are freed. */
1423 m
->rules
= set_free_with_destructor(m
->rules
, routing_policy_rule_free
);
1424 m
->rules_foreign
= set_free_with_destructor(m
->rules_foreign
, routing_policy_rule_free
);
1425 set_free_with_destructor(m
->rules_saved
, routing_policy_rule_free
);
1427 sd_netlink_unref(m
->rtnl
);
1428 sd_netlink_unref(m
->genl
);
1429 sd_resolve_unref(m
->resolve
);
1431 sd_event_source_unref(m
->speed_meter_event_source
);
1432 sd_event_unref(m
->event
);
1434 sd_device_monitor_unref(m
->device_monitor
);
1436 bus_verify_polkit_async_registry_free(m
->polkit_registry
);
1437 sd_bus_flush_close_unref(m
->bus
);
1439 free(m
->dynamic_timezone
);
1440 free(m
->dynamic_hostname
);
1445 int manager_start(Manager
*m
) {
1452 r
= manager_start_speed_meter(m
);
1454 return log_error_errno(r
, "Failed to initialize speed meter: %m");
1456 /* The dirty handler will deal with future serialization, but the first one
1457 must be done explicitly. */
1461 HASHMAP_FOREACH(link
, m
->links
, i
)
1467 int manager_load_config(Manager
*m
) {
1470 /* update timestamp */
1471 paths_check_timestamp(NETWORK_DIRS
, &m
->network_dirs_ts_usec
, true);
1477 r
= network_load(m
);
1484 bool manager_should_reload(Manager
*m
) {
1485 return paths_check_timestamp(NETWORK_DIRS
, &m
->network_dirs_ts_usec
, false);
1488 int manager_rtnl_enumerate_links(Manager
*m
) {
1489 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
, *reply
= NULL
;
1490 sd_netlink_message
*link
;
1496 r
= sd_rtnl_message_new_link(m
->rtnl
, &req
, RTM_GETLINK
, 0);
1500 r
= sd_netlink_message_request_dump(req
, true);
1504 r
= sd_netlink_call(m
->rtnl
, req
, 0, &reply
);
1508 for (link
= reply
; link
; link
= sd_netlink_message_next(link
)) {
1511 m
->enumerating
= true;
1513 k
= manager_rtnl_process_link(m
->rtnl
, link
, m
);
1517 m
->enumerating
= false;
1523 int manager_rtnl_enumerate_addresses(Manager
*m
) {
1524 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
, *reply
= NULL
;
1525 sd_netlink_message
*addr
;
1531 r
= sd_rtnl_message_new_addr(m
->rtnl
, &req
, RTM_GETADDR
, 0, 0);
1535 r
= sd_netlink_message_request_dump(req
, true);
1539 r
= sd_netlink_call(m
->rtnl
, req
, 0, &reply
);
1543 for (addr
= reply
; addr
; addr
= sd_netlink_message_next(addr
)) {
1546 m
->enumerating
= true;
1548 k
= manager_rtnl_process_address(m
->rtnl
, addr
, m
);
1552 m
->enumerating
= false;
1558 int manager_rtnl_enumerate_routes(Manager
*m
) {
1559 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
, *reply
= NULL
;
1560 sd_netlink_message
*route
;
1566 r
= sd_rtnl_message_new_route(m
->rtnl
, &req
, RTM_GETROUTE
, 0, 0);
1570 r
= sd_netlink_message_request_dump(req
, true);
1574 r
= sd_netlink_call(m
->rtnl
, req
, 0, &reply
);
1578 for (route
= reply
; route
; route
= sd_netlink_message_next(route
)) {
1581 m
->enumerating
= true;
1583 k
= manager_rtnl_process_route(m
->rtnl
, route
, m
);
1587 m
->enumerating
= false;
1593 int manager_rtnl_enumerate_rules(Manager
*m
) {
1594 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
, *reply
= NULL
;
1595 sd_netlink_message
*rule
;
1601 r
= sd_rtnl_message_new_routing_policy_rule(m
->rtnl
, &req
, RTM_GETRULE
, 0);
1605 r
= sd_netlink_message_request_dump(req
, true);
1609 r
= sd_netlink_call(m
->rtnl
, req
, 0, &reply
);
1611 if (r
== -EOPNOTSUPP
) {
1612 log_debug("FIB Rules are not supported by the kernel. Ignoring.");
1619 for (rule
= reply
; rule
; rule
= sd_netlink_message_next(rule
)) {
1622 m
->enumerating
= true;
1624 k
= manager_rtnl_process_rule(m
->rtnl
, rule
, m
);
1628 m
->enumerating
= false;
1634 int manager_address_pool_acquire(Manager
*m
, int family
, unsigned prefixlen
, union in_addr_union
*found
) {
1639 assert(prefixlen
> 0);
1642 LIST_FOREACH(address_pools
, p
, m
->address_pools
) {
1643 if (p
->family
!= family
)
1646 r
= address_pool_acquire(p
, prefixlen
, found
);
1654 Link
* manager_find_uplink(Manager
*m
, Link
*exclude
) {
1655 _cleanup_free_
struct local_address
*gateways
= NULL
;
1660 /* Looks for a suitable "uplink", via black magic: an
1661 * interface that is up and where the default route with the
1662 * highest priority points to. */
1664 n
= local_gateways(m
->rtnl
, 0, AF_UNSPEC
, &gateways
);
1666 log_warning_errno(n
, "Failed to determine list of default gateways: %m");
1670 for (i
= 0; i
< n
; i
++) {
1673 link
= hashmap_get(m
->links
, INT_TO_PTR(gateways
[i
].ifindex
));
1675 log_debug("Weird, found a gateway for a link we don't know. Ignoring.");
1679 if (link
== exclude
)
1682 if (link
->operstate
< LINK_OPERSTATE_ROUTABLE
)
1691 void manager_dirty(Manager
*manager
) {
1694 /* the serialized state in /run is no longer up-to-date */
1695 manager
->dirty
= true;
1698 static int set_hostname_handler(sd_bus_message
*m
, void *userdata
, sd_bus_error
*ret_error
) {
1699 Manager
*manager
= userdata
;
1700 const sd_bus_error
*e
;
1705 e
= sd_bus_message_get_error(m
);
1707 log_warning_errno(sd_bus_error_get_errno(e
), "Could not set hostname: %s", e
->message
);
1712 int manager_set_hostname(Manager
*m
, const char *hostname
) {
1715 log_debug("Setting transient hostname: '%s'", strna(hostname
));
1717 if (free_and_strdup(&m
->dynamic_hostname
, hostname
) < 0)
1720 if (!m
->bus
|| sd_bus_is_ready(m
->bus
) <= 0) {
1721 log_debug("Not connected to system bus, setting hostname later.");
1725 r
= sd_bus_call_method_async(
1728 "org.freedesktop.hostname1",
1729 "/org/freedesktop/hostname1",
1730 "org.freedesktop.hostname1",
1732 set_hostname_handler
,
1739 return log_error_errno(r
, "Could not set transient hostname: %m");
1744 static int set_timezone_handler(sd_bus_message
*m
, void *userdata
, sd_bus_error
*ret_error
) {
1745 Manager
*manager
= userdata
;
1746 const sd_bus_error
*e
;
1751 e
= sd_bus_message_get_error(m
);
1753 log_warning_errno(sd_bus_error_get_errno(e
), "Could not set timezone: %s", e
->message
);
1758 int manager_set_timezone(Manager
*m
, const char *tz
) {
1764 log_debug("Setting system timezone: '%s'", tz
);
1765 if (free_and_strdup(&m
->dynamic_timezone
, tz
) < 0)
1768 if (!m
->bus
|| sd_bus_is_ready(m
->bus
) <= 0) {
1769 log_debug("Not connected to system bus, setting timezone later.");
1773 r
= sd_bus_call_method_async(
1776 "org.freedesktop.timedate1",
1777 "/org/freedesktop/timedate1",
1778 "org.freedesktop.timedate1",
1780 set_timezone_handler
,
1786 return log_error_errno(r
, "Could not set timezone: %m");
1791 int manager_request_product_uuid(Manager
*m
, Link
*link
) {
1796 if (m
->has_product_uuid
)
1799 log_debug("Requesting product UUID");
1804 assert_se(duid
= link_get_duid(link
));
1806 r
= set_ensure_allocated(&m
->links_requesting_uuid
, NULL
);
1810 r
= set_ensure_allocated(&m
->duids_requesting_uuid
, NULL
);
1814 r
= set_put(m
->links_requesting_uuid
, link
);
1818 r
= set_put(m
->duids_requesting_uuid
, duid
);
1823 if (!m
->bus
|| sd_bus_is_ready(m
->bus
) <= 0) {
1824 log_debug("Not connected to system bus, requesting product UUID later.");
1828 r
= sd_bus_call_method_async(
1831 "org.freedesktop.hostname1",
1832 "/org/freedesktop/hostname1",
1833 "org.freedesktop.hostname1",
1835 get_product_uuid_handler
,
1840 return log_warning_errno(r
, "Failed to get product UUID: %m");