1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 #include <sys/socket.h>
5 #include <linux/fib_rules.h>
9 #include "sd-netlink.h"
11 #include "alloc-util.h"
13 #include "conf-parser.h"
15 #include "device-private.h"
16 #include "device-util.h"
17 #include "dns-domain.h"
20 #include "local-addresses.h"
21 #include "netlink-util.h"
22 #include "network-internal.h"
23 #include "networkd-manager.h"
24 #include "ordered-set.h"
25 #include "path-util.h"
28 #include "sysctl-util.h"
29 #include "tmpfile-util.h"
30 #include "udev-util.h"
33 /* use 8 MB for receive socket kernel queue. */
34 #define RCVBUF_SIZE (8*1024*1024)
36 static int setup_default_address_pool(Manager
*m
) {
42 /* Add in the well-known private address ranges. */
44 r
= address_pool_new_from_string(m
, &p
, AF_INET6
, "fd00::", 8);
48 r
= address_pool_new_from_string(m
, &p
, AF_INET
, "10.0.0.0", 8);
52 r
= address_pool_new_from_string(m
, &p
, AF_INET
, "172.16.0.0", 12);
56 r
= address_pool_new_from_string(m
, &p
, AF_INET
, "192.168.0.0", 16);
63 static int manager_reset_all(Manager
*m
) {
70 HASHMAP_FOREACH(link
, m
->links
, i
) {
71 r
= link_carrier_reset(link
);
73 log_link_warning_errno(link
, r
, "Could not reset carrier: %m");
79 static int match_prepare_for_sleep(sd_bus_message
*message
, void *userdata
, sd_bus_error
*ret_error
) {
80 Manager
*m
= userdata
;
86 r
= sd_bus_message_read(message
, "b", &b
);
88 log_debug_errno(r
, "Failed to parse PrepareForSleep signal: %m");
95 log_debug("Coming back from suspend, resetting all connections...");
97 (void) manager_reset_all(m
);
102 static int on_connected(sd_bus_message
*message
, void *userdata
, sd_bus_error
*ret_error
) {
103 Manager
*m
= userdata
;
108 /* Did we get a timezone or transient hostname from DHCP while D-Bus wasn't up yet? */
109 if (m
->dynamic_hostname
)
110 (void) manager_set_hostname(m
, m
->dynamic_hostname
);
111 if (m
->dynamic_timezone
)
112 (void) manager_set_timezone(m
, m
->dynamic_timezone
);
113 if (m
->links_requesting_uuid
)
114 (void) manager_request_product_uuid(m
, NULL
);
119 int manager_connect_bus(Manager
*m
) {
127 r
= bus_open_system_watch_bind_with_description(&m
->bus
, "bus-api-network");
129 return log_error_errno(r
, "Failed to connect to bus: %m");
131 r
= sd_bus_add_object_vtable(m
->bus
, NULL
, "/org/freedesktop/network1", "org.freedesktop.network1.Manager", manager_vtable
, m
);
133 return log_error_errno(r
, "Failed to add manager object vtable: %m");
135 r
= sd_bus_add_fallback_vtable(m
->bus
, NULL
, "/org/freedesktop/network1/link", "org.freedesktop.network1.Link", link_vtable
, link_object_find
, m
);
137 return log_error_errno(r
, "Failed to add link object vtable: %m");
139 r
= sd_bus_add_node_enumerator(m
->bus
, NULL
, "/org/freedesktop/network1/link", link_node_enumerator
, m
);
141 return log_error_errno(r
, "Failed to add link enumerator: %m");
143 r
= sd_bus_add_fallback_vtable(m
->bus
, NULL
, "/org/freedesktop/network1/network", "org.freedesktop.network1.Network", network_vtable
, network_object_find
, m
);
145 return log_error_errno(r
, "Failed to add network object vtable: %m");
147 r
= sd_bus_add_node_enumerator(m
->bus
, NULL
, "/org/freedesktop/network1/network", network_node_enumerator
, m
);
149 return log_error_errno(r
, "Failed to add network enumerator: %m");
151 r
= sd_bus_request_name_async(m
->bus
, NULL
, "org.freedesktop.network1", 0, NULL
, NULL
);
153 return log_error_errno(r
, "Failed to request name: %m");
155 r
= sd_bus_attach_event(m
->bus
, m
->event
, 0);
157 return log_error_errno(r
, "Failed to attach bus to event loop: %m");
159 r
= sd_bus_match_signal_async(
162 "org.freedesktop.DBus.Local",
164 "org.freedesktop.DBus.Local",
166 on_connected
, NULL
, m
);
168 return log_error_errno(r
, "Failed to request match on Connected signal: %m");
170 r
= sd_bus_match_signal_async(
173 "org.freedesktop.login1",
174 "/org/freedesktop/login1",
175 "org.freedesktop.login1.Manager",
177 match_prepare_for_sleep
, NULL
, m
);
179 log_warning_errno(r
, "Failed to request match for PrepareForSleep, ignoring: %m");
184 static int manager_udev_process_link(sd_device_monitor
*monitor
, sd_device
*device
, void *userdata
) {
185 Manager
*m
= userdata
;
193 r
= device_get_action(device
, &action
);
195 log_device_debug_errno(device
, r
, "Failed to get udev action, ignoring device: %m");
199 if (!IN_SET(action
, DEVICE_ACTION_ADD
, DEVICE_ACTION_CHANGE
, DEVICE_ACTION_MOVE
)) {
200 log_device_debug(device
, "Ignoring udev %s event for device.", device_action_to_string(action
));
204 r
= sd_device_get_ifindex(device
, &ifindex
);
206 log_device_debug_errno(device
, r
, "Ignoring udev ADD event for device without ifindex or with invalid ifindex: %m");
210 r
= device_is_renaming(device
);
212 log_device_error_errno(device
, r
, "Failed to determine the device is renamed or not, ignoring '%s' uevent: %m",
213 device_action_to_string(action
));
217 log_device_debug(device
, "Interface is under renaming, wait for the interface to be renamed: %m");
221 r
= link_get(m
, ifindex
, &link
);
224 log_debug_errno(r
, "Failed to get link from ifindex %i, ignoring: %m", ifindex
);
228 (void) link_initialized(link
, device
);
233 static int manager_connect_udev(Manager
*m
) {
236 /* udev does not initialize devices inside containers,
237 * so we rely on them being already initialized before
238 * entering the container */
239 if (detect_container() > 0)
242 r
= sd_device_monitor_new(&m
->device_monitor
);
244 return log_error_errno(r
, "Failed to initialize device monitor: %m");
246 r
= sd_device_monitor_filter_add_match_subsystem_devtype(m
->device_monitor
, "net", NULL
);
248 return log_error_errno(r
, "Could not add device monitor filter: %m");
250 r
= sd_device_monitor_attach_event(m
->device_monitor
, m
->event
);
252 return log_error_errno(r
, "Failed to attach event to device monitor: %m");
254 r
= sd_device_monitor_start(m
->device_monitor
, manager_udev_process_link
, m
);
256 return log_error_errno(r
, "Failed to start device monitor: %m");
261 int manager_rtnl_process_route(sd_netlink
*rtnl
, sd_netlink_message
*message
, void *userdata
) {
262 Manager
*m
= userdata
;
265 uint32_t ifindex
, priority
= 0;
266 unsigned char protocol
, scope
, tos
, table
, rt_type
;
268 unsigned char dst_prefixlen
, src_prefixlen
;
269 union in_addr_union dst
= {}, gw
= {}, src
= {}, prefsrc
= {};
277 if (sd_netlink_message_is_error(message
)) {
278 r
= sd_netlink_message_get_errno(message
);
280 log_warning_errno(r
, "rtnl: failed to receive route, ignoring: %m");
285 r
= sd_netlink_message_get_type(message
, &type
);
287 log_warning_errno(r
, "rtnl: could not get message type, ignoring: %m");
289 } else if (!IN_SET(type
, RTM_NEWROUTE
, RTM_DELROUTE
)) {
290 log_warning("rtnl: received unexpected message type when processing route, ignoring");
294 r
= sd_netlink_message_read_u32(message
, RTA_OIF
, &ifindex
);
296 log_debug("rtnl: received route without ifindex, ignoring");
299 log_warning_errno(r
, "rtnl: could not get ifindex from route, ignoring: %m");
301 } else if (ifindex
<= 0) {
302 log_warning("rtnl: received route message with invalid ifindex, ignoring: %d", ifindex
);
305 r
= link_get(m
, ifindex
, &link
);
306 if (r
< 0 || !link
) {
307 /* when enumerating we might be out of sync, but we will
308 * get the route again, so just ignore it */
310 log_warning("rtnl: received route for nonexistent link (%d), ignoring", ifindex
);
315 r
= sd_rtnl_message_route_get_family(message
, &family
);
316 if (r
< 0 || !IN_SET(family
, AF_INET
, AF_INET6
)) {
317 log_link_warning(link
, "rtnl: received address with invalid family, ignoring");
321 r
= sd_rtnl_message_route_get_protocol(message
, &protocol
);
323 log_warning_errno(r
, "rtnl: could not get route protocol: %m");
329 r
= sd_netlink_message_read_in_addr(message
, RTA_DST
, &dst
.in
);
330 if (r
< 0 && r
!= -ENODATA
) {
331 log_link_warning_errno(link
, r
, "rtnl: received route without valid destination, ignoring: %m");
335 r
= sd_netlink_message_read_in_addr(message
, RTA_GATEWAY
, &gw
.in
);
336 if (r
< 0 && r
!= -ENODATA
) {
337 log_link_warning_errno(link
, r
, "rtnl: received route with invalid gateway, ignoring: %m");
341 r
= sd_netlink_message_read_in_addr(message
, RTA_SRC
, &src
.in
);
342 if (r
< 0 && r
!= -ENODATA
) {
343 log_link_warning_errno(link
, r
, "rtnl: received route with invalid source, ignoring: %m");
347 r
= sd_netlink_message_read_in_addr(message
, RTA_PREFSRC
, &prefsrc
.in
);
348 if (r
< 0 && r
!= -ENODATA
) {
349 log_link_warning_errno(link
, r
, "rtnl: received route with invalid preferred source, ignoring: %m");
356 r
= sd_netlink_message_read_in6_addr(message
, RTA_DST
, &dst
.in6
);
357 if (r
< 0 && r
!= -ENODATA
) {
358 log_link_warning_errno(link
, r
, "rtnl: received route without valid destination, ignoring: %m");
362 r
= sd_netlink_message_read_in6_addr(message
, RTA_GATEWAY
, &gw
.in6
);
363 if (r
< 0 && r
!= -ENODATA
) {
364 log_link_warning_errno(link
, r
, "rtnl: received route with invalid gateway, ignoring: %m");
368 r
= sd_netlink_message_read_in6_addr(message
, RTA_SRC
, &src
.in6
);
369 if (r
< 0 && r
!= -ENODATA
) {
370 log_link_warning_errno(link
, r
, "rtnl: received route with invalid source, ignoring: %m");
374 r
= sd_netlink_message_read_in6_addr(message
, RTA_PREFSRC
, &prefsrc
.in6
);
375 if (r
< 0 && r
!= -ENODATA
) {
376 log_link_warning_errno(link
, r
, "rtnl: received route with invalid preferred source, ignoring: %m");
383 assert_not_reached("Received unsupported address family");
387 r
= sd_rtnl_message_route_get_dst_prefixlen(message
, &dst_prefixlen
);
389 log_link_warning_errno(link
, r
, "rtnl: received route with invalid destination prefixlen, ignoring: %m");
393 r
= sd_rtnl_message_route_get_src_prefixlen(message
, &src_prefixlen
);
395 log_link_warning_errno(link
, r
, "rtnl: received route with invalid source prefixlen, ignoring: %m");
399 r
= sd_rtnl_message_route_get_scope(message
, &scope
);
401 log_link_warning_errno(link
, r
, "rtnl: received route with invalid scope, ignoring: %m");
405 r
= sd_rtnl_message_route_get_tos(message
, &tos
);
407 log_link_warning_errno(link
, r
, "rtnl: received route with invalid tos, ignoring: %m");
411 r
= sd_rtnl_message_route_get_type(message
, &rt_type
);
413 log_link_warning_errno(link
, r
, "rtnl: received route with invalid type, ignoring: %m");
417 r
= sd_rtnl_message_route_get_table(message
, &table
);
419 log_link_warning_errno(link
, r
, "rtnl: received route with invalid table, ignoring: %m");
423 r
= sd_netlink_message_read_u32(message
, RTA_PRIORITY
, &priority
);
424 if (r
< 0 && r
!= -ENODATA
) {
425 log_link_warning_errno(link
, r
, "rtnl: received route with invalid priority, ignoring: %m");
429 (void) route_get(link
, family
, &dst
, dst_prefixlen
, tos
, priority
, table
, &route
);
432 _cleanup_free_
char *buf_dst
= NULL
, *buf_dst_prefixlen
= NULL
,
433 *buf_src
= NULL
, *buf_gw
= NULL
, *buf_prefsrc
= NULL
;
435 if (!in_addr_is_null(family
, &dst
)) {
436 (void) in_addr_to_string(family
, &dst
, &buf_dst
);
437 (void) asprintf(&buf_dst_prefixlen
, "/%u", dst_prefixlen
);
439 if (!in_addr_is_null(family
, &src
))
440 (void) in_addr_to_string(family
, &src
, &buf_src
);
441 if (!in_addr_is_null(family
, &gw
))
442 (void) in_addr_to_string(family
, &gw
, &buf_gw
);
443 if (!in_addr_is_null(family
, &prefsrc
))
444 (void) in_addr_to_string(family
, &prefsrc
, &buf_prefsrc
);
447 "%s route: dst: %s%s, src: %s, gw: %s, prefsrc: %s",
448 type
== RTM_DELROUTE
? "Removing" : route
? "Updating" : "Adding",
449 strna(buf_dst
), strempty(buf_dst_prefixlen
),
450 strna(buf_src
), strna(buf_gw
), strna(buf_prefsrc
));
456 /* A route appeared that we did not request */
457 r
= route_add_foreign(link
, family
, &dst
, dst_prefixlen
, tos
, priority
, table
, &route
);
459 log_link_warning_errno(link
, r
, "Failed to add route, ignoring: %m");
464 route_update(route
, &src
, src_prefixlen
, &gw
, &prefsrc
, scope
, protocol
, rt_type
);
473 assert_not_reached("Received invalid RTNL message type");
479 int manager_rtnl_process_address(sd_netlink
*rtnl
, sd_netlink_message
*message
, void *userdata
) {
480 Manager
*m
= userdata
;
485 unsigned char prefixlen
;
487 union in_addr_union in_addr
;
488 struct ifa_cacheinfo cinfo
;
489 Address
*address
= NULL
;
490 char buf
[INET6_ADDRSTRLEN
], valid_buf
[FORMAT_TIMESPAN_MAX
];
491 const char *valid_str
= NULL
;
498 if (sd_netlink_message_is_error(message
)) {
499 r
= sd_netlink_message_get_errno(message
);
501 log_warning_errno(r
, "rtnl: failed to receive address, ignoring: %m");
506 r
= sd_netlink_message_get_type(message
, &type
);
508 log_warning_errno(r
, "rtnl: could not get message type, ignoring: %m");
510 } else if (!IN_SET(type
, RTM_NEWADDR
, RTM_DELADDR
)) {
511 log_warning("rtnl: received unexpected message type when processing address, ignoring");
515 r
= sd_rtnl_message_addr_get_ifindex(message
, &ifindex
);
517 log_warning_errno(r
, "rtnl: could not get ifindex from address, ignoring: %m");
519 } else if (ifindex
<= 0) {
520 log_warning("rtnl: received address message with invalid ifindex, ignoring: %d", ifindex
);
523 r
= link_get(m
, ifindex
, &link
);
524 if (r
< 0 || !link
) {
525 /* when enumerating we might be out of sync, but we will
526 * get the address again, so just ignore it */
528 log_warning("rtnl: received address for nonexistent link (%d), ignoring", ifindex
);
533 r
= sd_rtnl_message_addr_get_family(message
, &family
);
534 if (r
< 0 || !IN_SET(family
, AF_INET
, AF_INET6
)) {
535 log_link_warning(link
, "rtnl: received address with invalid family, ignoring");
539 r
= sd_rtnl_message_addr_get_prefixlen(message
, &prefixlen
);
541 log_link_warning_errno(link
, r
, "rtnl: received address with invalid prefixlen, ignoring: %m");
545 r
= sd_rtnl_message_addr_get_scope(message
, &scope
);
547 log_link_warning_errno(link
, r
, "rtnl: received address with invalid scope, ignoring: %m");
551 r
= sd_rtnl_message_addr_get_flags(message
, &flags
);
553 log_link_warning_errno(link
, r
, "rtnl: received address with invalid flags, ignoring: %m");
559 r
= sd_netlink_message_read_in_addr(message
, IFA_LOCAL
, &in_addr
.in
);
561 log_link_warning_errno(link
, r
, "rtnl: received address without valid address, ignoring: %m");
568 r
= sd_netlink_message_read_in6_addr(message
, IFA_ADDRESS
, &in_addr
.in6
);
570 log_link_warning_errno(link
, r
, "rtnl: received address without valid address, ignoring: %m");
577 assert_not_reached("Received unsupported address family");
580 if (!inet_ntop(family
, &in_addr
, buf
, INET6_ADDRSTRLEN
)) {
581 log_link_warning(link
, "Could not print address, ignoring");
585 r
= sd_netlink_message_read_cache_info(message
, IFA_CACHEINFO
, &cinfo
);
586 if (r
< 0 && r
!= -ENODATA
) {
587 log_link_warning_errno(link
, r
, "rtnl: cannot get IFA_CACHEINFO attribute, ignoring: %m");
590 if (cinfo
.ifa_valid
!= CACHE_INFO_INFINITY_LIFE_TIME
)
591 valid_str
= format_timespan(valid_buf
, FORMAT_TIMESPAN_MAX
,
592 cinfo
.ifa_valid
* USEC_PER_SEC
,
596 (void) address_get(link
, family
, &in_addr
, prefixlen
, &address
);
601 log_link_debug(link
, "Updating address: %s/%u (valid %s%s)", buf
, prefixlen
,
602 valid_str
? "for " : "forever", strempty(valid_str
));
604 /* An address appeared that we did not request */
605 r
= address_add_foreign(link
, family
, &in_addr
, prefixlen
, &address
);
607 log_link_warning_errno(link
, r
, "Failed to add address %s/%u, ignoring: %m", buf
, prefixlen
);
610 log_link_debug(link
, "Adding address: %s/%u (valid %s%s)", buf
, prefixlen
,
611 valid_str
? "for " : "forever", strempty(valid_str
));
614 r
= address_update(address
, flags
, scope
, &cinfo
);
616 log_link_warning_errno(link
, r
, "Failed to update address %s/%u, ignoring: %m", buf
, prefixlen
);
625 log_link_debug(link
, "Removing address: %s/%u (valid %s%s)", buf
, prefixlen
,
626 valid_str
? "for " : "forever", strempty(valid_str
));
627 (void) address_drop(address
);
629 log_link_warning(link
, "Removing non-existent address: %s/%u (valid %s%s), ignoring", buf
, prefixlen
,
630 valid_str
? "for " : "forever", strempty(valid_str
));
634 assert_not_reached("Received invalid RTNL message type");
640 static int manager_rtnl_process_link(sd_netlink
*rtnl
, sd_netlink_message
*message
, void *userdata
) {
641 Manager
*m
= userdata
;
643 NetDev
*netdev
= NULL
;
652 if (sd_netlink_message_is_error(message
)) {
653 r
= sd_netlink_message_get_errno(message
);
655 log_warning_errno(r
, "rtnl: Could not receive link, ignoring: %m");
660 r
= sd_netlink_message_get_type(message
, &type
);
662 log_warning_errno(r
, "rtnl: Could not get message type, ignoring: %m");
664 } else if (!IN_SET(type
, RTM_NEWLINK
, RTM_DELLINK
)) {
665 log_warning("rtnl: Received unexpected message type when processing link, ignoring");
669 r
= sd_rtnl_message_link_get_ifindex(message
, &ifindex
);
671 log_warning_errno(r
, "rtnl: Could not get ifindex from link, ignoring: %m");
673 } else if (ifindex
<= 0) {
674 log_warning("rtnl: received link message with invalid ifindex %d, ignoring", ifindex
);
678 r
= sd_netlink_message_read_string(message
, IFLA_IFNAME
, &name
);
680 log_warning_errno(r
, "rtnl: Received link message without ifname, ignoring: %m");
684 (void) link_get(m
, ifindex
, &link
);
685 (void) netdev_get(m
, name
, &netdev
);
690 /* link is new, so add it */
691 r
= link_add(m
, message
, &link
);
693 log_warning_errno(r
, "Could not add new link, ignoring: %m");
699 /* netdev exists, so make sure the ifindex matches */
700 r
= netdev_set_ifindex(netdev
, message
);
702 log_warning_errno(r
, "Could not set ifindex on netdev, ignoring: %m");
707 r
= link_update(link
, message
);
709 log_warning_errno(r
, "Could not update link, ignoring: %m");
722 assert_not_reached("Received invalid RTNL message type.");
728 int manager_rtnl_process_rule(sd_netlink
*rtnl
, sd_netlink_message
*message
, void *userdata
) {
729 uint8_t tos
= 0, to_prefixlen
= 0, from_prefixlen
= 0, protocol
= 0;
730 struct fib_rule_port_range sport
= {}, dport
= {};
731 union in_addr_union to
= {}, from
= {};
732 RoutingPolicyRule
*rule
= NULL
;
733 uint32_t fwmark
= 0, table
= 0;
734 const char *iif
= NULL
, *oif
= NULL
;
735 Manager
*m
= userdata
;
744 if (sd_netlink_message_is_error(message
)) {
745 r
= sd_netlink_message_get_errno(message
);
747 log_warning_errno(r
, "rtnl: failed to receive rule, ignoring: %m");
752 r
= sd_netlink_message_get_type(message
, &type
);
754 log_warning_errno(r
, "rtnl: could not get message type, ignoring: %m");
756 } else if (!IN_SET(type
, RTM_NEWRULE
, RTM_DELRULE
)) {
757 log_warning("rtnl: received unexpected message type '%u' when processing rule, ignoring", type
);
761 r
= sd_rtnl_message_get_family(message
, &family
);
763 log_warning_errno(r
, "rtnl: could not get rule family, ignoring: %m");
765 } else if (!IN_SET(family
, AF_INET
, AF_INET6
)) {
766 log_debug("rtnl: received address with invalid family %u, ignoring", family
);
772 r
= sd_netlink_message_read_in_addr(message
, FRA_SRC
, &from
.in
);
773 if (r
< 0 && r
!= -ENODATA
) {
774 log_warning_errno(r
, "rtnl: could not get FRA_SRC attribute, ignoring: %m");
777 r
= sd_rtnl_message_routing_policy_rule_get_rtm_src_prefixlen(message
, &from_prefixlen
);
779 log_warning_errno(r
, "rtnl: failed to retrieve rule from prefix length, ignoring: %m");
784 r
= sd_netlink_message_read_in_addr(message
, FRA_DST
, &to
.in
);
785 if (r
< 0 && r
!= -ENODATA
) {
786 log_warning_errno(r
, "rtnl: could not get FRA_DST attribute, ignoring: %m");
789 r
= sd_rtnl_message_routing_policy_rule_get_rtm_dst_prefixlen(message
, &to_prefixlen
);
791 log_warning_errno(r
, "rtnl: failed to retrieve rule to prefix length, ignoring: %m");
799 r
= sd_netlink_message_read_in6_addr(message
, FRA_SRC
, &from
.in6
);
800 if (r
< 0 && r
!= -ENODATA
) {
801 log_warning_errno(r
, "rtnl: could not get FRA_SRC attribute, ignoring: %m");
804 r
= sd_rtnl_message_routing_policy_rule_get_rtm_src_prefixlen(message
, &from_prefixlen
);
806 log_warning_errno(r
, "rtnl: failed to retrieve rule from prefix length, ignoring: %m");
811 r
= sd_netlink_message_read_in6_addr(message
, FRA_DST
, &to
.in6
);
812 if (r
< 0 && r
!= -ENODATA
) {
813 log_warning_errno(r
, "rtnl: could not get FRA_DST attribute, ignoring: %m");
816 r
= sd_rtnl_message_routing_policy_rule_get_rtm_dst_prefixlen(message
, &to_prefixlen
);
818 log_warning_errno(r
, "rtnl: failed to retrieve rule to prefix length, ignoring: %m");
826 assert_not_reached("Received unsupported address family");
829 if (from_prefixlen
== 0 && to_prefixlen
== 0)
832 r
= sd_netlink_message_read_u32(message
, FRA_FWMARK
, &fwmark
);
833 if (r
< 0 && r
!= -ENODATA
) {
834 log_warning_errno(r
, "rtnl: could not get FRA_FWMARK attribute, ignoring: %m");
838 r
= sd_netlink_message_read_u32(message
, FRA_TABLE
, &table
);
839 if (r
< 0 && r
!= -ENODATA
) {
840 log_warning_errno(r
, "rtnl: could not get FRA_TABLE attribute, ignoring: %m");
844 r
= sd_rtnl_message_routing_policy_rule_get_tos(message
, &tos
);
845 if (r
< 0 && r
!= -ENODATA
) {
846 log_warning_errno(r
, "rtnl: could not get ip rule TOS, ignoring: %m");
850 r
= sd_netlink_message_read_string(message
, FRA_IIFNAME
, &iif
);
851 if (r
< 0 && r
!= -ENODATA
) {
852 log_warning_errno(r
, "rtnl: could not get FRA_IIFNAME attribute, ignoring: %m");
856 r
= sd_netlink_message_read_string(message
, FRA_OIFNAME
, &oif
);
857 if (r
< 0 && r
!= -ENODATA
) {
858 log_warning_errno(r
, "rtnl: could not get FRA_OIFNAME attribute, ignoring: %m");
862 r
= sd_netlink_message_read_u8(message
, FRA_IP_PROTO
, &protocol
);
863 if (r
< 0 && r
!= -ENODATA
) {
864 log_warning_errno(r
, "rtnl: could not get FRA_IP_PROTO attribute, ignoring: %m");
868 r
= sd_netlink_message_read(message
, FRA_SPORT_RANGE
, sizeof(sport
), (void *) &sport
);
869 if (r
< 0 && r
!= -ENODATA
) {
870 log_warning_errno(r
, "rtnl: could not get FRA_SPORT_RANGE attribute, ignoring: %m");
874 r
= sd_netlink_message_read(message
, FRA_DPORT_RANGE
, sizeof(dport
), (void *) &dport
);
875 if (r
< 0 && r
!= -ENODATA
) {
876 log_warning_errno(r
, "rtnl: could not get FRA_DPORT_RANGE attribute, ignoring: %m");
880 (void) routing_policy_rule_get(m
, family
, &from
, from_prefixlen
, &to
, to_prefixlen
, tos
, fwmark
, table
, iif
, oif
, protocol
, &sport
, &dport
, &rule
);
885 r
= routing_policy_rule_add_foreign(m
, family
, &from
, from_prefixlen
, &to
, to_prefixlen
, tos
, fwmark
, table
, iif
, oif
, protocol
, &sport
, &dport
, &rule
);
887 log_warning_errno(r
, "Could not add rule, ignoring: %m");
893 routing_policy_rule_free(rule
);
898 assert_not_reached("Received invalid RTNL message type");
904 static int systemd_netlink_fd(void) {
905 int n
, fd
, rtnl_fd
= -EINVAL
;
907 n
= sd_listen_fds(true);
911 for (fd
= SD_LISTEN_FDS_START
; fd
< SD_LISTEN_FDS_START
+ n
; fd
++) {
912 if (sd_is_socket(fd
, AF_NETLINK
, SOCK_RAW
, -1) > 0) {
923 static int manager_connect_genl(Manager
*m
) {
928 r
= sd_genl_socket_open(&m
->genl
);
932 r
= sd_netlink_inc_rcvbuf(m
->genl
, RCVBUF_SIZE
);
936 r
= sd_netlink_attach_event(m
->genl
, m
->event
, 0);
943 static int manager_connect_rtnl(Manager
*m
) {
948 fd
= systemd_netlink_fd();
950 r
= sd_netlink_open(&m
->rtnl
);
952 r
= sd_netlink_open_fd(&m
->rtnl
, fd
);
956 r
= sd_netlink_inc_rcvbuf(m
->rtnl
, RCVBUF_SIZE
);
960 r
= sd_netlink_attach_event(m
->rtnl
, m
->event
, 0);
964 r
= sd_netlink_add_match(m
->rtnl
, NULL
, RTM_NEWLINK
, &manager_rtnl_process_link
, NULL
, m
, "network-rtnl_process_link");
968 r
= sd_netlink_add_match(m
->rtnl
, NULL
, RTM_DELLINK
, &manager_rtnl_process_link
, NULL
, m
, "network-rtnl_process_link");
972 r
= sd_netlink_add_match(m
->rtnl
, NULL
, RTM_NEWADDR
, &manager_rtnl_process_address
, NULL
, m
, "network-rtnl_process_address");
976 r
= sd_netlink_add_match(m
->rtnl
, NULL
, RTM_DELADDR
, &manager_rtnl_process_address
, NULL
, m
, "network-rtnl_process_address");
980 r
= sd_netlink_add_match(m
->rtnl
, NULL
, RTM_NEWROUTE
, &manager_rtnl_process_route
, NULL
, m
, "network-rtnl_process_route");
984 r
= sd_netlink_add_match(m
->rtnl
, NULL
, RTM_DELROUTE
, &manager_rtnl_process_route
, NULL
, m
, "network-rtnl_process_route");
988 r
= sd_netlink_add_match(m
->rtnl
, NULL
, RTM_NEWRULE
, &manager_rtnl_process_rule
, NULL
, m
, "network-rtnl_process_rule");
992 r
= sd_netlink_add_match(m
->rtnl
, NULL
, RTM_DELRULE
, &manager_rtnl_process_rule
, NULL
, m
, "network-rtnl_process_rule");
999 static int ordered_set_put_in_addr_data(OrderedSet
*s
, const struct in_addr_data
*address
) {
1006 r
= in_addr_to_string(address
->family
, &address
->address
, &p
);
1010 r
= ordered_set_consume(s
, p
);
1017 static int ordered_set_put_in_addr_datav(OrderedSet
*s
, const struct in_addr_data
*addresses
, unsigned n
) {
1022 assert(addresses
|| n
== 0);
1024 for (i
= 0; i
< n
; i
++) {
1025 r
= ordered_set_put_in_addr_data(s
, addresses
+i
);
1035 static int ordered_set_put_in4_addr(OrderedSet
*s
, const struct in_addr
*address
) {
1042 r
= in_addr_to_string(AF_INET
, (const union in_addr_union
*) address
, &p
);
1046 r
= ordered_set_consume(s
, p
);
1053 static int ordered_set_put_in4_addrv(OrderedSet
*s
,
1054 const struct in_addr
*addresses
,
1056 bool (*predicate
)(const struct in_addr
*addr
)) {
1061 assert(n
== 0 || addresses
);
1063 for (i
= 0; i
< n
; i
++) {
1064 if (predicate
&& !predicate(&addresses
[i
]))
1066 r
= ordered_set_put_in4_addr(s
, addresses
+i
);
1076 static int manager_save(Manager
*m
) {
1077 _cleanup_ordered_set_free_free_ OrderedSet
*dns
= NULL
, *ntp
= NULL
, *search_domains
= NULL
, *route_domains
= NULL
;
1080 _cleanup_free_
char *temp_path
= NULL
;
1081 _cleanup_fclose_
FILE *f
= NULL
;
1082 LinkOperationalState operstate
= LINK_OPERSTATE_OFF
;
1083 const char *operstate_str
;
1087 assert(m
->state_file
);
1089 /* We add all NTP and DNS server to a set, to filter out duplicates */
1090 dns
= ordered_set_new(&string_hash_ops
);
1094 ntp
= ordered_set_new(&string_hash_ops
);
1098 search_domains
= ordered_set_new(&dns_name_hash_ops
);
1099 if (!search_domains
)
1102 route_domains
= ordered_set_new(&dns_name_hash_ops
);
1106 HASHMAP_FOREACH(link
, m
->links
, i
) {
1107 if (link
->flags
& IFF_LOOPBACK
)
1110 if (link
->operstate
> operstate
)
1111 operstate
= link
->operstate
;
1116 /* First add the static configured entries */
1117 r
= ordered_set_put_in_addr_datav(dns
, link
->network
->dns
, link
->network
->n_dns
);
1121 r
= ordered_set_put_strdupv(ntp
, link
->network
->ntp
);
1125 r
= ordered_set_put_string_set(search_domains
, link
->network
->search_domains
);
1129 r
= ordered_set_put_string_set(route_domains
, link
->network
->route_domains
);
1133 if (!link
->dhcp_lease
)
1136 /* Secondly, add the entries acquired via DHCP */
1137 if (link
->network
->dhcp_use_dns
) {
1138 const struct in_addr
*addresses
;
1140 r
= sd_dhcp_lease_get_dns(link
->dhcp_lease
, &addresses
);
1142 r
= ordered_set_put_in4_addrv(dns
, addresses
, r
, in4_addr_is_non_local
);
1145 } else if (r
< 0 && r
!= -ENODATA
)
1149 if (link
->network
->dhcp_use_ntp
) {
1150 const struct in_addr
*addresses
;
1152 r
= sd_dhcp_lease_get_ntp(link
->dhcp_lease
, &addresses
);
1154 r
= ordered_set_put_in4_addrv(ntp
, addresses
, r
, in4_addr_is_non_local
);
1157 } else if (r
< 0 && r
!= -ENODATA
)
1161 if (link
->network
->dhcp_use_domains
!= DHCP_USE_DOMAINS_NO
) {
1162 const char *domainname
;
1163 char **domains
= NULL
;
1165 OrderedSet
*target_domains
= (link
->network
->dhcp_use_domains
== DHCP_USE_DOMAINS_YES
) ? search_domains
: route_domains
;
1166 r
= sd_dhcp_lease_get_domainname(link
->dhcp_lease
, &domainname
);
1168 r
= ordered_set_put_strdup(target_domains
, domainname
);
1171 } else if (r
!= -ENODATA
)
1174 r
= sd_dhcp_lease_get_search_domains(link
->dhcp_lease
, &domains
);
1176 r
= ordered_set_put_strdupv(target_domains
, domains
);
1179 } else if (r
!= -ENODATA
)
1184 operstate_str
= link_operstate_to_string(operstate
);
1185 assert(operstate_str
);
1187 r
= fopen_temporary(m
->state_file
, &f
, &temp_path
);
1191 (void) fchmod(fileno(f
), 0644);
1194 "# This is private data. Do not parse.\n"
1195 "OPER_STATE=%s\n", operstate_str
);
1197 ordered_set_print(f
, "DNS=", dns
);
1198 ordered_set_print(f
, "NTP=", ntp
);
1199 ordered_set_print(f
, "DOMAINS=", search_domains
);
1200 ordered_set_print(f
, "ROUTE_DOMAINS=", route_domains
);
1202 r
= routing_policy_serialize_rules(m
->rules
, f
);
1206 r
= fflush_and_check(f
);
1210 if (rename(temp_path
, m
->state_file
) < 0) {
1215 if (m
->operational_state
!= operstate
) {
1216 m
->operational_state
= operstate
;
1217 r
= manager_send_changed(m
, "OperationalState", NULL
);
1219 log_error_errno(r
, "Could not emit changed OperationalState: %m");
1227 (void) unlink(m
->state_file
);
1228 (void) unlink(temp_path
);
1230 return log_error_errno(r
, "Failed to save network state to %s: %m", m
->state_file
);
1233 static int manager_dirty_handler(sd_event_source
*s
, void *userdata
) {
1234 Manager
*m
= userdata
;
1243 SET_FOREACH(link
, m
->dirty_links
, i
)
1244 if (link_save(link
) >= 0)
1250 Link
*manager_dhcp6_prefix_get(Manager
*m
, struct in6_addr
*addr
) {
1251 assert_return(m
, NULL
);
1252 assert_return(addr
, NULL
);
1254 return hashmap_get(m
->dhcp6_prefixes
, addr
);
1257 static int dhcp6_route_add_handler(sd_netlink
*nl
, sd_netlink_message
*m
, Link
*link
) {
1262 r
= sd_netlink_message_get_errno(m
);
1263 if (r
< 0 && r
!= -EEXIST
)
1264 log_link_debug_errno(link
, r
, "Received error adding DHCPv6 Prefix Delegation route: %m");
1269 static void dhcp6_prefixes_hash_func(const struct in6_addr
*addr
, struct siphash
*state
) {
1272 siphash24_compress(addr
, sizeof(*addr
), state
);
1275 static int dhcp6_prefixes_compare_func(const struct in6_addr
*a
, const struct in6_addr
*b
) {
1276 return memcmp(a
, b
, sizeof(*a
));
1279 DEFINE_PRIVATE_HASH_OPS(dhcp6_prefixes_hash_ops
, struct in6_addr
, dhcp6_prefixes_hash_func
, dhcp6_prefixes_compare_func
);
1281 int manager_dhcp6_prefix_add(Manager
*m
, struct in6_addr
*addr
, Link
*link
) {
1282 _cleanup_free_
char *buf
= NULL
;
1286 assert_return(m
, -EINVAL
);
1287 assert_return(addr
, -EINVAL
);
1289 r
= route_add(link
, AF_INET6
, (union in_addr_union
*) addr
, 64,
1294 r
= route_configure(route
, link
, dhcp6_route_add_handler
);
1298 (void) in_addr_to_string(AF_INET6
, (union in_addr_union
*) addr
, &buf
);
1299 log_link_debug(link
, "Adding prefix route %s/64", strnull(buf
));
1301 r
= hashmap_ensure_allocated(&m
->dhcp6_prefixes
, &dhcp6_prefixes_hash_ops
);
1305 return hashmap_put(m
->dhcp6_prefixes
, addr
, link
);
1308 static int dhcp6_route_remove_handler(sd_netlink
*nl
, sd_netlink_message
*m
, Link
*link
) {
1313 r
= sd_netlink_message_get_errno(m
);
1315 log_link_debug_errno(link
, r
, "Received error on DHCPv6 Prefix Delegation route removal: %m");
1320 static int manager_dhcp6_prefix_remove(Manager
*m
, struct in6_addr
*addr
) {
1321 _cleanup_free_
char *buf
= NULL
;
1326 assert_return(m
, -EINVAL
);
1327 assert_return(addr
, -EINVAL
);
1329 l
= hashmap_remove(m
->dhcp6_prefixes
, addr
);
1333 (void) sd_radv_remove_prefix(l
->radv
, addr
, 64);
1334 r
= route_get(l
, AF_INET6
, (union in_addr_union
*) addr
, 64,
1339 r
= route_remove(route
, l
, dhcp6_route_remove_handler
);
1343 (void) in_addr_to_string(AF_INET6
, (union in_addr_union
*) addr
, &buf
);
1344 log_link_debug(l
, "Removing prefix route %s/64", strnull(buf
));
1349 int manager_dhcp6_prefix_remove_all(Manager
*m
, Link
*link
) {
1350 struct in6_addr
*addr
;
1354 assert_return(m
, -EINVAL
);
1355 assert_return(link
, -EINVAL
);
1357 HASHMAP_FOREACH_KEY(l
, addr
, m
->dhcp6_prefixes
, i
) {
1361 (void) manager_dhcp6_prefix_remove(m
, addr
);
1367 int manager_new(Manager
**ret
) {
1368 _cleanup_(manager_freep
) Manager
*m
= NULL
;
1371 m
= new0(Manager
, 1);
1375 m
->state_file
= strdup("/run/systemd/netif/state");
1379 m
->sysctl_ipv6_enabled
= -1;
1381 r
= sd_event_default(&m
->event
);
1385 (void) sd_event_set_watchdog(m
->event
, true);
1386 (void) sd_event_add_signal(m
->event
, NULL
, SIGTERM
, NULL
, NULL
);
1387 (void) sd_event_add_signal(m
->event
, NULL
, SIGINT
, NULL
, NULL
);
1389 r
= sd_event_add_post(m
->event
, NULL
, manager_dirty_handler
, m
);
1393 r
= manager_connect_rtnl(m
);
1397 r
= manager_connect_genl(m
);
1401 r
= manager_connect_udev(m
);
1405 LIST_HEAD_INIT(m
->networks
);
1407 r
= sd_resolve_default(&m
->resolve
);
1411 r
= sd_resolve_attach_event(m
->resolve
, m
->event
, 0);
1415 r
= setup_default_address_pool(m
);
1419 m
->duid
.type
= DUID_TYPE_EN
;
1421 (void) routing_policy_load_rules(m
->state_file
, &m
->rules_saved
);
1428 void manager_free(Manager
*m
) {
1435 free(m
->state_file
);
1437 while ((link
= hashmap_first(m
->dhcp6_prefixes
)))
1438 manager_dhcp6_prefix_remove_all(m
, link
);
1439 hashmap_free(m
->dhcp6_prefixes
);
1441 while ((link
= hashmap_steal_first(m
->links
))) {
1442 if (link
->dhcp6_client
)
1443 (void) dhcp6_lease_pd_prefix_lost(link
->dhcp6_client
, link
);
1445 link_stop_clients(link
);
1450 m
->dirty_links
= set_free_with_destructor(m
->dirty_links
, link_unref
);
1451 m
->links_requesting_uuid
= set_free_with_destructor(m
->links_requesting_uuid
, link_unref
);
1452 m
->links
= hashmap_free_with_destructor(m
->links
, link_unref
);
1454 m
->duids_requesting_uuid
= set_free(m
->duids_requesting_uuid
);
1455 m
->networks_by_name
= hashmap_free_with_destructor(m
->networks_by_name
, network_unref
);
1457 m
->netdevs
= hashmap_free_with_destructor(m
->netdevs
, netdev_unref
);
1459 while ((pool
= m
->address_pools
))
1460 address_pool_free(pool
);
1462 /* routing_policy_rule_free() access m->rules and m->rules_foreign.
1463 * So, it is necessary to set NULL after the sets are freed. */
1464 m
->rules
= set_free_with_destructor(m
->rules
, routing_policy_rule_free
);
1465 m
->rules_foreign
= set_free_with_destructor(m
->rules_foreign
, routing_policy_rule_free
);
1466 set_free_with_destructor(m
->rules_saved
, routing_policy_rule_free
);
1468 sd_netlink_unref(m
->rtnl
);
1469 sd_netlink_unref(m
->genl
);
1470 sd_resolve_unref(m
->resolve
);
1472 sd_event_unref(m
->event
);
1474 sd_device_monitor_unref(m
->device_monitor
);
1476 sd_bus_flush_close_unref(m
->bus
);
1478 free(m
->dynamic_timezone
);
1479 free(m
->dynamic_hostname
);
1484 int manager_start(Manager
*m
) {
1490 /* The dirty handler will deal with future serialization, but the first one
1491 must be done explicitly. */
1495 HASHMAP_FOREACH(link
, m
->links
, i
)
1501 int manager_load_config(Manager
*m
) {
1504 /* update timestamp */
1505 paths_check_timestamp(NETWORK_DIRS
, &m
->network_dirs_ts_usec
, true);
1511 r
= network_load(m
);
1518 bool manager_should_reload(Manager
*m
) {
1519 return paths_check_timestamp(NETWORK_DIRS
, &m
->network_dirs_ts_usec
, false);
1522 int manager_rtnl_enumerate_links(Manager
*m
) {
1523 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
, *reply
= NULL
;
1524 sd_netlink_message
*link
;
1530 r
= sd_rtnl_message_new_link(m
->rtnl
, &req
, RTM_GETLINK
, 0);
1534 r
= sd_netlink_message_request_dump(req
, true);
1538 r
= sd_netlink_call(m
->rtnl
, req
, 0, &reply
);
1542 for (link
= reply
; link
; link
= sd_netlink_message_next(link
)) {
1545 m
->enumerating
= true;
1547 k
= manager_rtnl_process_link(m
->rtnl
, link
, m
);
1551 m
->enumerating
= false;
1557 int manager_rtnl_enumerate_addresses(Manager
*m
) {
1558 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
, *reply
= NULL
;
1559 sd_netlink_message
*addr
;
1565 r
= sd_rtnl_message_new_addr(m
->rtnl
, &req
, RTM_GETADDR
, 0, 0);
1569 r
= sd_netlink_message_request_dump(req
, true);
1573 r
= sd_netlink_call(m
->rtnl
, req
, 0, &reply
);
1577 for (addr
= reply
; addr
; addr
= sd_netlink_message_next(addr
)) {
1580 m
->enumerating
= true;
1582 k
= manager_rtnl_process_address(m
->rtnl
, addr
, m
);
1586 m
->enumerating
= false;
1592 int manager_rtnl_enumerate_routes(Manager
*m
) {
1593 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
, *reply
= NULL
;
1594 sd_netlink_message
*route
;
1600 r
= sd_rtnl_message_new_route(m
->rtnl
, &req
, RTM_GETROUTE
, 0, 0);
1604 r
= sd_netlink_message_request_dump(req
, true);
1608 r
= sd_netlink_call(m
->rtnl
, req
, 0, &reply
);
1612 for (route
= reply
; route
; route
= sd_netlink_message_next(route
)) {
1615 m
->enumerating
= true;
1617 k
= manager_rtnl_process_route(m
->rtnl
, route
, m
);
1621 m
->enumerating
= false;
1627 int manager_rtnl_enumerate_rules(Manager
*m
) {
1628 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
, *reply
= NULL
;
1629 sd_netlink_message
*rule
;
1635 r
= sd_rtnl_message_new_routing_policy_rule(m
->rtnl
, &req
, RTM_GETRULE
, 0);
1639 r
= sd_netlink_message_request_dump(req
, true);
1643 r
= sd_netlink_call(m
->rtnl
, req
, 0, &reply
);
1645 if (r
== -EOPNOTSUPP
) {
1646 log_debug("FIB Rules are not supported by the kernel. Ignoring.");
1653 for (rule
= reply
; rule
; rule
= sd_netlink_message_next(rule
)) {
1656 m
->enumerating
= true;
1658 k
= manager_rtnl_process_rule(m
->rtnl
, rule
, m
);
1662 m
->enumerating
= false;
1668 int manager_address_pool_acquire(Manager
*m
, int family
, unsigned prefixlen
, union in_addr_union
*found
) {
1673 assert(prefixlen
> 0);
1676 LIST_FOREACH(address_pools
, p
, m
->address_pools
) {
1677 if (p
->family
!= family
)
1680 r
= address_pool_acquire(p
, prefixlen
, found
);
1688 Link
* manager_find_uplink(Manager
*m
, Link
*exclude
) {
1689 _cleanup_free_
struct local_address
*gateways
= NULL
;
1694 /* Looks for a suitable "uplink", via black magic: an
1695 * interface that is up and where the default route with the
1696 * highest priority points to. */
1698 n
= local_gateways(m
->rtnl
, 0, AF_UNSPEC
, &gateways
);
1700 log_warning_errno(n
, "Failed to determine list of default gateways: %m");
1704 for (i
= 0; i
< n
; i
++) {
1707 link
= hashmap_get(m
->links
, INT_TO_PTR(gateways
[i
].ifindex
));
1709 log_debug("Weird, found a gateway for a link we don't know. Ignoring.");
1713 if (link
== exclude
)
1716 if (link
->operstate
< LINK_OPERSTATE_ROUTABLE
)
1725 void manager_dirty(Manager
*manager
) {
1728 /* the serialized state in /run is no longer up-to-date */
1729 manager
->dirty
= true;
1732 static int set_hostname_handler(sd_bus_message
*m
, void *userdata
, sd_bus_error
*ret_error
) {
1733 Manager
*manager
= userdata
;
1734 const sd_bus_error
*e
;
1739 e
= sd_bus_message_get_error(m
);
1741 log_warning_errno(sd_bus_error_get_errno(e
), "Could not set hostname: %s", e
->message
);
1746 int manager_set_hostname(Manager
*m
, const char *hostname
) {
1749 log_debug("Setting transient hostname: '%s'", strna(hostname
));
1751 if (free_and_strdup(&m
->dynamic_hostname
, hostname
) < 0)
1754 if (!m
->bus
|| sd_bus_is_ready(m
->bus
) <= 0) {
1755 log_debug("Not connected to system bus, setting hostname later.");
1759 r
= sd_bus_call_method_async(
1762 "org.freedesktop.hostname1",
1763 "/org/freedesktop/hostname1",
1764 "org.freedesktop.hostname1",
1766 set_hostname_handler
,
1773 return log_error_errno(r
, "Could not set transient hostname: %m");
1778 static int set_timezone_handler(sd_bus_message
*m
, void *userdata
, sd_bus_error
*ret_error
) {
1779 Manager
*manager
= userdata
;
1780 const sd_bus_error
*e
;
1785 e
= sd_bus_message_get_error(m
);
1787 log_warning_errno(sd_bus_error_get_errno(e
), "Could not set timezone: %s", e
->message
);
1792 int manager_set_timezone(Manager
*m
, const char *tz
) {
1798 log_debug("Setting system timezone: '%s'", tz
);
1799 if (free_and_strdup(&m
->dynamic_timezone
, tz
) < 0)
1802 if (!m
->bus
|| sd_bus_is_ready(m
->bus
) <= 0) {
1803 log_debug("Not connected to system bus, setting timezone later.");
1807 r
= sd_bus_call_method_async(
1810 "org.freedesktop.timedate1",
1811 "/org/freedesktop/timedate1",
1812 "org.freedesktop.timedate1",
1814 set_timezone_handler
,
1820 return log_error_errno(r
, "Could not set timezone: %m");
1825 int manager_request_product_uuid(Manager
*m
, Link
*link
) {
1830 if (m
->has_product_uuid
)
1833 log_debug("Requesting product UUID");
1838 assert_se(duid
= link_get_duid(link
));
1840 r
= set_ensure_allocated(&m
->links_requesting_uuid
, NULL
);
1844 r
= set_ensure_allocated(&m
->duids_requesting_uuid
, NULL
);
1848 r
= set_put(m
->links_requesting_uuid
, link
);
1852 r
= set_put(m
->duids_requesting_uuid
, duid
);
1857 if (!m
->bus
|| sd_bus_is_ready(m
->bus
) <= 0) {
1858 log_debug("Not connected to system bus, requesting product UUID later.");
1862 r
= sd_bus_call_method_async(
1865 "org.freedesktop.hostname1",
1866 "/org/freedesktop/hostname1",
1867 "org.freedesktop.hostname1",
1869 get_product_uuid_handler
,
1874 return log_warning_errno(r
, "Failed to get product UUID: %m");
1879 int manager_sysctl_ipv6_enabled(Manager
*manager
) {
1880 _cleanup_free_
char *value
= NULL
;
1883 if (manager
->sysctl_ipv6_enabled
>= 0)
1884 return manager
->sysctl_ipv6_enabled
;
1886 r
= sysctl_read_ip_property(AF_INET6
, "all", "disable_ipv6", &value
);
1888 return log_warning_errno(r
, "Failed to read net.ipv6.conf.all.disable_ipv6 sysctl property: %m");
1890 manager
->sysctl_ipv6_enabled
= value
[0] == '0';
1891 return manager
->sysctl_ipv6_enabled
;