1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 This file is part of systemd.
5 Copyright 2013 Tom Gundersen <teg@jklm.no>
8 #include <sys/socket.h>
10 #include <linux/fib_rules.h>
11 #include <stdio_ext.h>
13 #include "sd-daemon.h"
14 #include "sd-netlink.h"
16 #include "alloc-util.h"
18 #include "conf-parser.h"
20 #include "dns-domain.h"
23 #include "libudev-private.h"
24 #include "local-addresses.h"
25 #include "netlink-util.h"
26 #include "networkd-manager.h"
27 #include "ordered-set.h"
28 #include "path-util.h"
30 #include "udev-util.h"
33 /* use 8 MB for receive socket kernel queue. */
34 #define RCVBUF_SIZE (8*1024*1024)
36 const char* const network_dirs
[] = {
37 "/etc/systemd/network",
38 "/run/systemd/network",
39 "/usr/lib/systemd/network",
41 "/lib/systemd/network",
45 static int setup_default_address_pool(Manager
*m
) {
51 /* Add in the well-known private address ranges. */
53 r
= address_pool_new_from_string(m
, &p
, AF_INET6
, "fc00::", 7);
57 r
= address_pool_new_from_string(m
, &p
, AF_INET
, "192.168.0.0", 16);
61 r
= address_pool_new_from_string(m
, &p
, AF_INET
, "172.16.0.0", 12);
65 r
= address_pool_new_from_string(m
, &p
, AF_INET
, "10.0.0.0", 8);
72 static int manager_reset_all(Manager
*m
) {
79 HASHMAP_FOREACH(link
, m
->links
, i
) {
80 r
= link_carrier_reset(link
);
82 log_link_warning_errno(link
, r
, "Could not reset carrier: %m");
88 static int match_prepare_for_sleep(sd_bus_message
*message
, void *userdata
, sd_bus_error
*ret_error
) {
89 Manager
*m
= userdata
;
95 r
= sd_bus_message_read(message
, "b", &b
);
97 log_debug_errno(r
, "Failed to parse PrepareForSleep signal: %m");
104 log_debug("Coming back from suspend, resetting all connections...");
106 (void) manager_reset_all(m
);
111 static int on_connected(sd_bus_message
*message
, void *userdata
, sd_bus_error
*ret_error
) {
112 Manager
*m
= userdata
;
117 /* Did we get a timezone or transient hostname from DHCP while D-Bus wasn't up yet? */
118 if (m
->dynamic_hostname
)
119 (void) manager_set_hostname(m
, m
->dynamic_hostname
);
120 if (m
->dynamic_timezone
)
121 (void) manager_set_timezone(m
, m
->dynamic_timezone
);
126 int manager_connect_bus(Manager
*m
) {
134 r
= bus_open_system_watch_bind_with_description(&m
->bus
, "bus-api-network");
136 return log_error_errno(r
, "Failed to connect to bus: %m");
138 r
= sd_bus_add_object_vtable(m
->bus
, NULL
, "/org/freedesktop/network1", "org.freedesktop.network1.Manager", manager_vtable
, m
);
140 return log_error_errno(r
, "Failed to add manager object vtable: %m");
142 r
= sd_bus_add_fallback_vtable(m
->bus
, NULL
, "/org/freedesktop/network1/link", "org.freedesktop.network1.Link", link_vtable
, link_object_find
, m
);
144 return log_error_errno(r
, "Failed to add link object vtable: %m");
146 r
= sd_bus_add_node_enumerator(m
->bus
, NULL
, "/org/freedesktop/network1/link", link_node_enumerator
, m
);
148 return log_error_errno(r
, "Failed to add link enumerator: %m");
150 r
= sd_bus_add_fallback_vtable(m
->bus
, NULL
, "/org/freedesktop/network1/network", "org.freedesktop.network1.Network", network_vtable
, network_object_find
, m
);
152 return log_error_errno(r
, "Failed to add network object vtable: %m");
154 r
= sd_bus_add_node_enumerator(m
->bus
, NULL
, "/org/freedesktop/network1/network", network_node_enumerator
, m
);
156 return log_error_errno(r
, "Failed to add network enumerator: %m");
158 r
= bus_request_name_async_may_reload_dbus(m
->bus
, NULL
, "org.freedesktop.network1", 0, NULL
);
160 return log_error_errno(r
, "Failed to request name: %m");
162 r
= sd_bus_attach_event(m
->bus
, m
->event
, 0);
164 return log_error_errno(r
, "Failed to attach bus to event loop: %m");
166 r
= sd_bus_match_signal_async(
169 "org.freedesktop.DBus.Local",
171 "org.freedesktop.DBus.Local",
173 on_connected
, NULL
, m
);
175 return log_error_errno(r
, "Failed to request match on Connected signal: %m");
177 r
= sd_bus_match_signal_async(
179 &m
->prepare_for_sleep_slot
,
180 "org.freedesktop.login1",
181 "/org/freedesktop/login1",
182 "org.freedesktop.login1.Manager",
184 match_prepare_for_sleep
, NULL
, m
);
186 log_warning_errno(r
, "Failed to request match for PrepareForSleep, ignoring: %m");
191 static int manager_udev_process_link(Manager
*m
, struct udev_device
*device
) {
198 if (!streq_ptr(udev_device_get_action(device
), "add"))
201 ifindex
= udev_device_get_ifindex(device
);
203 log_debug("Ignoring udev ADD event for device with invalid ifindex");
207 r
= link_get(m
, ifindex
, &link
);
213 r
= link_initialized(link
, device
);
220 static int manager_dispatch_link_udev(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
) {
221 Manager
*m
= userdata
;
222 struct udev_monitor
*monitor
= m
->udev_monitor
;
223 _cleanup_(udev_device_unrefp
) struct udev_device
*device
= NULL
;
225 device
= udev_monitor_receive_device(monitor
);
229 (void) manager_udev_process_link(m
, device
);
234 static int manager_connect_udev(Manager
*m
) {
237 /* udev does not initialize devices inside containers,
238 * so we rely on them being already initialized before
239 * entering the container */
240 if (detect_container() > 0)
243 m
->udev
= udev_new();
247 m
->udev_monitor
= udev_monitor_new_from_netlink(m
->udev
, "udev");
248 if (!m
->udev_monitor
)
251 r
= udev_monitor_filter_add_match_subsystem_devtype(m
->udev_monitor
, "net", NULL
);
253 return log_error_errno(r
, "Could not add udev monitor filter: %m");
255 r
= udev_monitor_enable_receiving(m
->udev_monitor
);
257 log_error("Could not enable udev monitor");
261 r
= sd_event_add_io(m
->event
,
262 &m
->udev_event_source
,
263 udev_monitor_get_fd(m
->udev_monitor
),
264 EPOLLIN
, manager_dispatch_link_udev
,
269 r
= sd_event_source_set_description(m
->udev_event_source
, "networkd-udev");
276 int manager_rtnl_process_route(sd_netlink
*rtnl
, sd_netlink_message
*message
, void *userdata
) {
277 Manager
*m
= userdata
;
280 uint32_t ifindex
, priority
= 0;
281 unsigned char protocol
, scope
, tos
, table
, rt_type
;
283 unsigned char dst_prefixlen
, src_prefixlen
;
284 union in_addr_union dst
= {}, gw
= {}, src
= {}, prefsrc
= {};
292 if (sd_netlink_message_is_error(message
)) {
293 r
= sd_netlink_message_get_errno(message
);
295 log_warning_errno(r
, "rtnl: failed to receive route, ignoring: %m");
300 r
= sd_netlink_message_get_type(message
, &type
);
302 log_warning_errno(r
, "rtnl: could not get message type, ignoring: %m");
304 } else if (!IN_SET(type
, RTM_NEWROUTE
, RTM_DELROUTE
)) {
305 log_warning("rtnl: received unexpected message type when processing route, ignoring");
309 r
= sd_netlink_message_read_u32(message
, RTA_OIF
, &ifindex
);
311 log_debug("rtnl: received route without ifindex, ignoring");
314 log_warning_errno(r
, "rtnl: could not get ifindex from route, ignoring: %m");
316 } else if (ifindex
<= 0) {
317 log_warning("rtnl: received route message with invalid ifindex, ignoring: %d", ifindex
);
320 r
= link_get(m
, ifindex
, &link
);
321 if (r
< 0 || !link
) {
322 /* when enumerating we might be out of sync, but we will
323 * get the route again, so just ignore it */
325 log_warning("rtnl: received route for nonexistent link (%d), ignoring", ifindex
);
330 r
= sd_rtnl_message_route_get_family(message
, &family
);
331 if (r
< 0 || !IN_SET(family
, AF_INET
, AF_INET6
)) {
332 log_link_warning(link
, "rtnl: received address with invalid family, ignoring");
336 r
= sd_rtnl_message_route_get_protocol(message
, &protocol
);
338 log_warning_errno(r
, "rtnl: could not get route protocol: %m");
344 r
= sd_netlink_message_read_in_addr(message
, RTA_DST
, &dst
.in
);
345 if (r
< 0 && r
!= -ENODATA
) {
346 log_link_warning_errno(link
, r
, "rtnl: received route without valid destination, ignoring: %m");
350 r
= sd_netlink_message_read_in_addr(message
, RTA_GATEWAY
, &gw
.in
);
351 if (r
< 0 && r
!= -ENODATA
) {
352 log_link_warning_errno(link
, r
, "rtnl: received route with invalid gateway, ignoring: %m");
356 r
= sd_netlink_message_read_in_addr(message
, RTA_SRC
, &src
.in
);
357 if (r
< 0 && r
!= -ENODATA
) {
358 log_link_warning_errno(link
, r
, "rtnl: received route with invalid source, ignoring: %m");
362 r
= sd_netlink_message_read_in_addr(message
, RTA_PREFSRC
, &prefsrc
.in
);
363 if (r
< 0 && r
!= -ENODATA
) {
364 log_link_warning_errno(link
, r
, "rtnl: received route with invalid preferred source, ignoring: %m");
371 r
= sd_netlink_message_read_in6_addr(message
, RTA_DST
, &dst
.in6
);
372 if (r
< 0 && r
!= -ENODATA
) {
373 log_link_warning_errno(link
, r
, "rtnl: received route without valid destination, ignoring: %m");
377 r
= sd_netlink_message_read_in6_addr(message
, RTA_GATEWAY
, &gw
.in6
);
378 if (r
< 0 && r
!= -ENODATA
) {
379 log_link_warning_errno(link
, r
, "rtnl: received route with invalid gateway, ignoring: %m");
383 r
= sd_netlink_message_read_in6_addr(message
, RTA_SRC
, &src
.in6
);
384 if (r
< 0 && r
!= -ENODATA
) {
385 log_link_warning_errno(link
, r
, "rtnl: received route with invalid source, ignoring: %m");
389 r
= sd_netlink_message_read_in6_addr(message
, RTA_PREFSRC
, &prefsrc
.in6
);
390 if (r
< 0 && r
!= -ENODATA
) {
391 log_link_warning_errno(link
, r
, "rtnl: received route with invalid preferred source, ignoring: %m");
398 assert_not_reached("Received unsupported address family");
402 r
= sd_rtnl_message_route_get_dst_prefixlen(message
, &dst_prefixlen
);
404 log_link_warning_errno(link
, r
, "rtnl: received route with invalid destination prefixlen, ignoring: %m");
408 r
= sd_rtnl_message_route_get_src_prefixlen(message
, &src_prefixlen
);
410 log_link_warning_errno(link
, r
, "rtnl: received route with invalid source prefixlen, ignoring: %m");
414 r
= sd_rtnl_message_route_get_scope(message
, &scope
);
416 log_link_warning_errno(link
, r
, "rtnl: received route with invalid scope, ignoring: %m");
420 r
= sd_rtnl_message_route_get_tos(message
, &tos
);
422 log_link_warning_errno(link
, r
, "rtnl: received route with invalid tos, ignoring: %m");
426 r
= sd_rtnl_message_route_get_type(message
, &rt_type
);
428 log_link_warning_errno(link
, r
, "rtnl: received route with invalid type, ignoring: %m");
432 r
= sd_rtnl_message_route_get_table(message
, &table
);
434 log_link_warning_errno(link
, r
, "rtnl: received route with invalid table, ignoring: %m");
438 r
= sd_netlink_message_read_u32(message
, RTA_PRIORITY
, &priority
);
439 if (r
< 0 && r
!= -ENODATA
) {
440 log_link_warning_errno(link
, r
, "rtnl: received route with invalid priority, ignoring: %m");
444 (void) route_get(link
, family
, &dst
, dst_prefixlen
, tos
, priority
, table
, &route
);
449 /* A route appeared that we did not request */
450 r
= route_add_foreign(link
, family
, &dst
, dst_prefixlen
, tos
, priority
, table
, &route
);
452 log_link_warning_errno(link
, r
, "Failed to add route, ignoring: %m");
457 route_update(route
, &src
, src_prefixlen
, &gw
, &prefsrc
, scope
, protocol
, rt_type
);
466 assert_not_reached("Received invalid RTNL message type");
472 int manager_rtnl_process_address(sd_netlink
*rtnl
, sd_netlink_message
*message
, void *userdata
) {
473 Manager
*m
= userdata
;
478 unsigned char prefixlen
;
480 union in_addr_union in_addr
;
481 struct ifa_cacheinfo cinfo
;
482 Address
*address
= NULL
;
483 char buf
[INET6_ADDRSTRLEN
], valid_buf
[FORMAT_TIMESPAN_MAX
];
484 const char *valid_str
= NULL
;
491 if (sd_netlink_message_is_error(message
)) {
492 r
= sd_netlink_message_get_errno(message
);
494 log_warning_errno(r
, "rtnl: failed to receive address, ignoring: %m");
499 r
= sd_netlink_message_get_type(message
, &type
);
501 log_warning_errno(r
, "rtnl: could not get message type, ignoring: %m");
503 } else if (!IN_SET(type
, RTM_NEWADDR
, RTM_DELADDR
)) {
504 log_warning("rtnl: received unexpected message type when processing address, ignoring");
508 r
= sd_rtnl_message_addr_get_ifindex(message
, &ifindex
);
510 log_warning_errno(r
, "rtnl: could not get ifindex from address, ignoring: %m");
512 } else if (ifindex
<= 0) {
513 log_warning("rtnl: received address message with invalid ifindex, ignoring: %d", ifindex
);
516 r
= link_get(m
, ifindex
, &link
);
517 if (r
< 0 || !link
) {
518 /* when enumerating we might be out of sync, but we will
519 * get the address again, so just ignore it */
521 log_warning("rtnl: received address for nonexistent link (%d), ignoring", ifindex
);
526 r
= sd_rtnl_message_addr_get_family(message
, &family
);
527 if (r
< 0 || !IN_SET(family
, AF_INET
, AF_INET6
)) {
528 log_link_warning(link
, "rtnl: received address with invalid family, ignoring");
532 r
= sd_rtnl_message_addr_get_prefixlen(message
, &prefixlen
);
534 log_link_warning_errno(link
, r
, "rtnl: received address with invalid prefixlen, ignoring: %m");
538 r
= sd_rtnl_message_addr_get_scope(message
, &scope
);
540 log_link_warning_errno(link
, r
, "rtnl: received address with invalid scope, ignoring: %m");
544 r
= sd_rtnl_message_addr_get_flags(message
, &flags
);
546 log_link_warning_errno(link
, r
, "rtnl: received address with invalid flags, ignoring: %m");
552 r
= sd_netlink_message_read_in_addr(message
, IFA_LOCAL
, &in_addr
.in
);
554 log_link_warning_errno(link
, r
, "rtnl: received address without valid address, ignoring: %m");
561 r
= sd_netlink_message_read_in6_addr(message
, IFA_ADDRESS
, &in_addr
.in6
);
563 log_link_warning_errno(link
, r
, "rtnl: received address without valid address, ignoring: %m");
570 assert_not_reached("Received unsupported address family");
573 if (!inet_ntop(family
, &in_addr
, buf
, INET6_ADDRSTRLEN
)) {
574 log_link_warning(link
, "Could not print address, ignoring");
578 r
= sd_netlink_message_read_cache_info(message
, IFA_CACHEINFO
, &cinfo
);
579 if (r
< 0 && r
!= -ENODATA
) {
580 log_link_warning_errno(link
, r
, "rtnl: cannot get IFA_CACHEINFO attribute, ignoring: %m");
583 if (cinfo
.ifa_valid
!= CACHE_INFO_INFINITY_LIFE_TIME
)
584 valid_str
= format_timespan(valid_buf
, FORMAT_TIMESPAN_MAX
,
585 cinfo
.ifa_valid
* USEC_PER_SEC
,
589 (void) address_get(link
, family
, &in_addr
, prefixlen
, &address
);
594 log_link_debug(link
, "Updating address: %s/%u (valid %s%s)", buf
, prefixlen
,
595 valid_str
? "for " : "forever", strempty(valid_str
));
597 /* An address appeared that we did not request */
598 r
= address_add_foreign(link
, family
, &in_addr
, prefixlen
, &address
);
600 log_link_warning_errno(link
, r
, "Failed to add address %s/%u, ignoring: %m", buf
, prefixlen
);
603 log_link_debug(link
, "Adding address: %s/%u (valid %s%s)", buf
, prefixlen
,
604 valid_str
? "for " : "forever", strempty(valid_str
));
607 r
= address_update(address
, flags
, scope
, &cinfo
);
609 log_link_warning_errno(link
, r
, "Failed to update address %s/%u, ignoring: %m", buf
, prefixlen
);
618 log_link_debug(link
, "Removing address: %s/%u (valid %s%s)", buf
, prefixlen
,
619 valid_str
? "for " : "forever", strempty(valid_str
));
620 (void) address_drop(address
);
622 log_link_warning(link
, "Removing non-existent address: %s/%u (valid %s%s), ignoring", buf
, prefixlen
,
623 valid_str
? "for " : "forever", strempty(valid_str
));
627 assert_not_reached("Received invalid RTNL message type");
633 static int manager_rtnl_process_link(sd_netlink
*rtnl
, sd_netlink_message
*message
, void *userdata
) {
634 Manager
*m
= userdata
;
636 NetDev
*netdev
= NULL
;
645 if (sd_netlink_message_is_error(message
)) {
646 r
= sd_netlink_message_get_errno(message
);
648 log_warning_errno(r
, "rtnl: Could not receive link, ignoring: %m");
653 r
= sd_netlink_message_get_type(message
, &type
);
655 log_warning_errno(r
, "rtnl: Could not get message type, ignoring: %m");
657 } else if (!IN_SET(type
, RTM_NEWLINK
, RTM_DELLINK
)) {
658 log_warning("rtnl: Received unexpected message type when processing link, ignoring");
662 r
= sd_rtnl_message_link_get_ifindex(message
, &ifindex
);
664 log_warning_errno(r
, "rtnl: Could not get ifindex from link, ignoring: %m");
666 } else if (ifindex
<= 0) {
667 log_warning("rtnl: received link message with invalid ifindex %d, ignoring", ifindex
);
671 r
= sd_netlink_message_read_string(message
, IFLA_IFNAME
, &name
);
673 log_warning_errno(r
, "rtnl: Received link message without ifname, ignoring: %m");
677 (void) link_get(m
, ifindex
, &link
);
678 (void) netdev_get(m
, name
, &netdev
);
683 /* link is new, so add it */
684 r
= link_add(m
, message
, &link
);
686 log_warning_errno(r
, "Could not add new link, ignoring: %m");
692 /* netdev exists, so make sure the ifindex matches */
693 r
= netdev_set_ifindex(netdev
, message
);
695 log_warning_errno(r
, "Could not set ifindex on netdev, ignoring: %m");
700 r
= link_update(link
, message
);
702 log_warning_errno(r
, "Could not update link, ignoring: %m");
715 assert_not_reached("Received invalid RTNL message type.");
721 int manager_rtnl_process_rule(sd_netlink
*rtnl
, sd_netlink_message
*message
, void *userdata
) {
722 uint8_t tos
= 0, to_prefixlen
= 0, from_prefixlen
= 0;
723 union in_addr_union to
= {}, from
= {};
724 RoutingPolicyRule
*rule
= NULL
;
725 uint32_t fwmark
= 0, table
= 0;
726 char *iif
= NULL
, *oif
= NULL
;
727 Manager
*m
= userdata
;
736 if (sd_netlink_message_is_error(message
)) {
737 r
= sd_netlink_message_get_errno(message
);
739 log_warning_errno(r
, "rtnl: failed to receive rule, ignoring: %m");
744 r
= sd_netlink_message_get_type(message
, &type
);
746 log_warning_errno(r
, "rtnl: could not get message type, ignoring: %m");
748 } else if (!IN_SET(type
, RTM_NEWRULE
, RTM_DELRULE
)) {
749 log_warning("rtnl: received unexpected message type '%u' when processing rule, ignoring", type
);
753 r
= sd_rtnl_message_get_family(message
, &family
);
755 log_warning_errno(r
, "rtnl: could not get rule family, ignoring: %m");
757 } else if (!IN_SET(family
, AF_INET
, AF_INET6
)) {
758 log_debug("rtnl: received address with invalid family %u, ignoring", family
);
764 r
= sd_netlink_message_read_in_addr(message
, FRA_SRC
, &from
.in
);
765 if (r
< 0 && r
!= -ENODATA
) {
766 log_warning_errno(r
, "rtnl: could not get FRA_SRC attribute, ignoring: %m");
769 r
= sd_rtnl_message_routing_policy_rule_get_rtm_src_prefixlen(message
, &from_prefixlen
);
771 log_warning_errno(r
, "rtnl: failed to retrive rule from prefix length, ignoring: %m");
776 r
= sd_netlink_message_read_in_addr(message
, FRA_DST
, &to
.in
);
777 if (r
< 0 && r
!= -ENODATA
) {
778 log_warning_errno(r
, "rtnl: could not get FRA_DST attribute, ignoring: %m");
781 r
= sd_rtnl_message_routing_policy_rule_get_rtm_dst_prefixlen(message
, &to_prefixlen
);
783 log_warning_errno(r
, "rtnl: failed to retrive rule to prefix length, ignoring: %m");
791 r
= sd_netlink_message_read_in6_addr(message
, FRA_SRC
, &from
.in6
);
792 if (r
< 0 && r
!= -ENODATA
) {
793 log_warning_errno(r
, "rtnl: could not get FRA_SRC attribute, ignoring: %m");
796 r
= sd_rtnl_message_routing_policy_rule_get_rtm_src_prefixlen(message
, &from_prefixlen
);
798 log_warning_errno(r
, "rtnl: failed to retrive rule from prefix length, ignoring: %m");
803 r
= sd_netlink_message_read_in6_addr(message
, FRA_DST
, &to
.in6
);
804 if (r
< 0 && r
!= -ENODATA
) {
805 log_warning_errno(r
, "rtnl: could not get FRA_DST attribute, ignoring: %m");
808 r
= sd_rtnl_message_routing_policy_rule_get_rtm_dst_prefixlen(message
, &to_prefixlen
);
810 log_warning_errno(r
, "rtnl: failed to retrive rule to prefix length, ignoring: %m");
818 assert_not_reached("Received unsupported address family");
821 if (from_prefixlen
== 0 && to_prefixlen
== 0)
824 r
= sd_netlink_message_read_u32(message
, FRA_FWMARK
, &fwmark
);
825 if (r
< 0 && r
!= -ENODATA
) {
826 log_warning_errno(r
, "rtnl: could not get FRA_FWMARK attribute, ignoring: %m");
830 r
= sd_netlink_message_read_u32(message
, FRA_TABLE
, &table
);
831 if (r
< 0 && r
!= -ENODATA
) {
832 log_warning_errno(r
, "rtnl: could not get FRA_TABLE attribute, ignoring: %m");
836 r
= sd_rtnl_message_routing_policy_rule_get_tos(message
, &tos
);
837 if (r
< 0 && r
!= -ENODATA
) {
838 log_warning_errno(r
, "rtnl: could not get ip rule TOS, ignoring: %m");
842 r
= sd_netlink_message_read_string(message
, FRA_IIFNAME
, (const char **) &iif
);
843 if (r
< 0 && r
!= -ENODATA
) {
844 log_warning_errno(r
, "rtnl: could not get FRA_IIFNAME attribute, ignoring: %m");
848 r
= sd_netlink_message_read_string(message
, FRA_OIFNAME
, (const char **) &oif
);
849 if (r
< 0 && r
!= -ENODATA
) {
850 log_warning_errno(r
, "rtnl: could not get FRA_OIFNAME attribute, ignoring: %m");
854 (void) routing_policy_rule_get(m
, family
, &from
, from_prefixlen
, &to
, to_prefixlen
, tos
, fwmark
, table
, iif
, oif
, &rule
);
859 r
= routing_policy_rule_add_foreign(m
, family
, &from
, from_prefixlen
, &to
, to_prefixlen
, tos
, fwmark
, table
, iif
, oif
, &rule
);
861 log_warning_errno(r
, "Could not add rule, ignoring: %m");
867 routing_policy_rule_free(rule
);
872 assert_not_reached("Received invalid RTNL message type");
878 static int systemd_netlink_fd(void) {
879 int n
, fd
, rtnl_fd
= -EINVAL
;
881 n
= sd_listen_fds(true);
885 for (fd
= SD_LISTEN_FDS_START
; fd
< SD_LISTEN_FDS_START
+ n
; fd
++) {
886 if (sd_is_socket(fd
, AF_NETLINK
, SOCK_RAW
, -1) > 0) {
897 static int manager_connect_genl(Manager
*m
) {
902 r
= sd_genl_socket_open(&m
->genl
);
906 r
= sd_netlink_inc_rcvbuf(m
->genl
, RCVBUF_SIZE
);
910 r
= sd_netlink_attach_event(m
->genl
, m
->event
, 0);
917 static int manager_connect_rtnl(Manager
*m
) {
922 fd
= systemd_netlink_fd();
924 r
= sd_netlink_open(&m
->rtnl
);
926 r
= sd_netlink_open_fd(&m
->rtnl
, fd
);
930 r
= sd_netlink_inc_rcvbuf(m
->rtnl
, RCVBUF_SIZE
);
934 r
= sd_netlink_attach_event(m
->rtnl
, m
->event
, 0);
938 r
= sd_netlink_add_match(m
->rtnl
, RTM_NEWLINK
, &manager_rtnl_process_link
, m
);
942 r
= sd_netlink_add_match(m
->rtnl
, RTM_DELLINK
, &manager_rtnl_process_link
, m
);
946 r
= sd_netlink_add_match(m
->rtnl
, RTM_NEWADDR
, &manager_rtnl_process_address
, m
);
950 r
= sd_netlink_add_match(m
->rtnl
, RTM_DELADDR
, &manager_rtnl_process_address
, m
);
954 r
= sd_netlink_add_match(m
->rtnl
, RTM_NEWROUTE
, &manager_rtnl_process_route
, m
);
958 r
= sd_netlink_add_match(m
->rtnl
, RTM_DELROUTE
, &manager_rtnl_process_route
, m
);
962 r
= sd_netlink_add_match(m
->rtnl
, RTM_NEWRULE
, &manager_rtnl_process_rule
, m
);
966 r
= sd_netlink_add_match(m
->rtnl
, RTM_DELRULE
, &manager_rtnl_process_rule
, m
);
973 static int ordered_set_put_in_addr_data(OrderedSet
*s
, const struct in_addr_data
*address
) {
980 r
= in_addr_to_string(address
->family
, &address
->address
, &p
);
984 r
= ordered_set_consume(s
, p
);
991 static int ordered_set_put_in_addr_datav(OrderedSet
*s
, const struct in_addr_data
*addresses
, unsigned n
) {
996 assert(addresses
|| n
== 0);
998 for (i
= 0; i
< n
; i
++) {
999 r
= ordered_set_put_in_addr_data(s
, addresses
+i
);
1009 static int ordered_set_put_in4_addr(OrderedSet
*s
, const struct in_addr
*address
) {
1016 r
= in_addr_to_string(AF_INET
, (const union in_addr_union
*) address
, &p
);
1020 r
= ordered_set_consume(s
, p
);
1027 static int ordered_set_put_in4_addrv(OrderedSet
*s
, const struct in_addr
*addresses
, unsigned n
) {
1032 assert(n
== 0 || addresses
);
1034 for (i
= 0; i
< n
; i
++) {
1035 r
= ordered_set_put_in4_addr(s
, addresses
+i
);
1045 static void print_string_set(FILE *f
, const char *field
, OrderedSet
*s
) {
1050 if (ordered_set_isempty(s
))
1055 ORDERED_SET_FOREACH(p
, s
, i
)
1056 fputs_with_space(f
, p
, NULL
, &space
);
1061 static int manager_save(Manager
*m
) {
1062 _cleanup_ordered_set_free_free_ OrderedSet
*dns
= NULL
, *ntp
= NULL
, *search_domains
= NULL
, *route_domains
= NULL
;
1065 _cleanup_free_
char *temp_path
= NULL
;
1066 _cleanup_fclose_
FILE *f
= NULL
;
1067 LinkOperationalState operstate
= LINK_OPERSTATE_OFF
;
1068 const char *operstate_str
;
1072 assert(m
->state_file
);
1074 /* We add all NTP and DNS server to a set, to filter out duplicates */
1075 dns
= ordered_set_new(&string_hash_ops
);
1079 ntp
= ordered_set_new(&string_hash_ops
);
1083 search_domains
= ordered_set_new(&dns_name_hash_ops
);
1084 if (!search_domains
)
1087 route_domains
= ordered_set_new(&dns_name_hash_ops
);
1091 HASHMAP_FOREACH(link
, m
->links
, i
) {
1092 if (link
->flags
& IFF_LOOPBACK
)
1095 if (link
->operstate
> operstate
)
1096 operstate
= link
->operstate
;
1101 /* First add the static configured entries */
1102 r
= ordered_set_put_in_addr_datav(dns
, link
->network
->dns
, link
->network
->n_dns
);
1106 r
= ordered_set_put_strdupv(ntp
, link
->network
->ntp
);
1110 r
= ordered_set_put_strdupv(search_domains
, link
->network
->search_domains
);
1114 r
= ordered_set_put_strdupv(route_domains
, link
->network
->route_domains
);
1118 if (!link
->dhcp_lease
)
1121 /* Secondly, add the entries acquired via DHCP */
1122 if (link
->network
->dhcp_use_dns
) {
1123 const struct in_addr
*addresses
;
1125 r
= sd_dhcp_lease_get_dns(link
->dhcp_lease
, &addresses
);
1127 r
= ordered_set_put_in4_addrv(dns
, addresses
, r
);
1130 } else if (r
< 0 && r
!= -ENODATA
)
1134 if (link
->network
->dhcp_use_ntp
) {
1135 const struct in_addr
*addresses
;
1137 r
= sd_dhcp_lease_get_ntp(link
->dhcp_lease
, &addresses
);
1139 r
= ordered_set_put_in4_addrv(ntp
, addresses
, r
);
1142 } else if (r
< 0 && r
!= -ENODATA
)
1146 if (link
->network
->dhcp_use_domains
!= DHCP_USE_DOMAINS_NO
) {
1147 const char *domainname
;
1148 char **domains
= NULL
;
1150 OrderedSet
*target_domains
= (link
->network
->dhcp_use_domains
== DHCP_USE_DOMAINS_YES
) ? search_domains
: route_domains
;
1151 r
= sd_dhcp_lease_get_domainname(link
->dhcp_lease
, &domainname
);
1153 r
= ordered_set_put_strdup(target_domains
, domainname
);
1156 } else if (r
!= -ENODATA
)
1159 r
= sd_dhcp_lease_get_search_domains(link
->dhcp_lease
, &domains
);
1161 r
= ordered_set_put_strdupv(target_domains
, domains
);
1164 } else if (r
!= -ENODATA
)
1169 operstate_str
= link_operstate_to_string(operstate
);
1170 assert(operstate_str
);
1172 r
= fopen_temporary(m
->state_file
, &f
, &temp_path
);
1176 (void) __fsetlocking(f
, FSETLOCKING_BYCALLER
);
1177 (void) fchmod(fileno(f
), 0644);
1180 "# This is private data. Do not parse.\n"
1181 "OPER_STATE=%s\n", operstate_str
);
1183 print_string_set(f
, "DNS=", dns
);
1184 print_string_set(f
, "NTP=", ntp
);
1185 print_string_set(f
, "DOMAINS=", search_domains
);
1186 print_string_set(f
, "ROUTE_DOMAINS=", route_domains
);
1188 r
= routing_policy_serialize_rules(m
->rules
, f
);
1192 r
= fflush_and_check(f
);
1196 if (rename(temp_path
, m
->state_file
) < 0) {
1201 if (m
->operational_state
!= operstate
) {
1202 m
->operational_state
= operstate
;
1203 r
= manager_send_changed(m
, "OperationalState", NULL
);
1205 log_error_errno(r
, "Could not emit changed OperationalState: %m");
1213 (void) unlink(m
->state_file
);
1214 (void) unlink(temp_path
);
1216 return log_error_errno(r
, "Failed to save network state to %s: %m", m
->state_file
);
1219 static int manager_dirty_handler(sd_event_source
*s
, void *userdata
) {
1220 Manager
*m
= userdata
;
1230 SET_FOREACH(link
, m
->dirty_links
, i
) {
1231 r
= link_save(link
);
1239 Link
*manager_dhcp6_prefix_get(Manager
*m
, struct in6_addr
*addr
) {
1240 assert_return(m
, NULL
);
1241 assert_return(m
->dhcp6_prefixes
, NULL
);
1242 assert_return(addr
, NULL
);
1244 return hashmap_get(m
->dhcp6_prefixes
, addr
);
1247 static int dhcp6_route_add_callback(sd_netlink
*nl
, sd_netlink_message
*m
,
1251 union in_addr_union prefix
;
1252 _cleanup_free_
char *buf
= NULL
;
1254 r
= sd_netlink_message_get_errno(m
);
1256 log_link_debug_errno(l
, r
, "Received error adding DHCPv6 Prefix Delegation route: %m");
1260 r
= sd_netlink_message_read_in6_addr(m
, RTA_DST
, &prefix
.in6
);
1262 log_link_debug_errno(l
, r
, "Could not read IPv6 address from DHCPv6 Prefix Delegation while adding route: %m");
1266 (void) in_addr_to_string(AF_INET6
, &prefix
, &buf
);
1267 log_link_debug(l
, "Added DHCPv6 Prefix Deleagtion route %s/64",
1273 int manager_dhcp6_prefix_add(Manager
*m
, struct in6_addr
*addr
, Link
*link
) {
1277 assert_return(m
, -EINVAL
);
1278 assert_return(m
->dhcp6_prefixes
, -ENODATA
);
1279 assert_return(addr
, -EINVAL
);
1281 r
= route_add(link
, AF_INET6
, (union in_addr_union
*) addr
, 64,
1286 r
= route_configure(route
, link
, dhcp6_route_add_callback
);
1290 return hashmap_put(m
->dhcp6_prefixes
, addr
, link
);
1293 static int dhcp6_route_remove_callback(sd_netlink
*nl
, sd_netlink_message
*m
,
1297 union in_addr_union prefix
;
1298 _cleanup_free_
char *buf
= NULL
;
1300 r
= sd_netlink_message_get_errno(m
);
1302 log_link_debug_errno(l
, r
, "Received error on DHCPv6 Prefix Delegation route removal: %m");
1306 r
= sd_netlink_message_read_in6_addr(m
, RTA_DST
, &prefix
.in6
);
1308 log_link_debug_errno(l
, r
, "Could not read IPv6 address from DHCPv6 Prefix Delegation while removing route: %m");
1312 (void) in_addr_to_string(AF_INET6
, &prefix
, &buf
);
1313 log_link_debug(l
, "Removed DHCPv6 Prefix Delegation route %s/64",
1319 int manager_dhcp6_prefix_remove(Manager
*m
, struct in6_addr
*addr
) {
1324 assert_return(m
, -EINVAL
);
1325 assert_return(m
->dhcp6_prefixes
, -ENODATA
);
1326 assert_return(addr
, -EINVAL
);
1328 l
= hashmap_remove(m
->dhcp6_prefixes
, addr
);
1332 (void) sd_radv_remove_prefix(l
->radv
, addr
, 64);
1333 r
= route_get(l
, AF_INET6
, (union in_addr_union
*) addr
, 64,
1336 (void) route_remove(route
, l
, dhcp6_route_remove_callback
);
1341 int manager_dhcp6_prefix_remove_all(Manager
*m
, Link
*link
) {
1344 struct in6_addr
*addr
;
1346 assert_return(m
, -EINVAL
);
1347 assert_return(link
, -EINVAL
);
1349 HASHMAP_FOREACH_KEY(l
, addr
, m
->dhcp6_prefixes
, i
) {
1353 (void) manager_dhcp6_prefix_remove(m
, addr
);
1359 static void dhcp6_prefixes_hash_func(const void *p
, struct siphash
*state
) {
1360 const struct in6_addr
*addr
= p
;
1364 siphash24_compress(addr
, sizeof(*addr
), state
);
1367 static int dhcp6_prefixes_compare_func(const void *_a
, const void *_b
) {
1368 const struct in6_addr
*a
= _a
, *b
= _b
;
1370 return memcmp(a
, b
, sizeof(*a
));
1373 static const struct hash_ops dhcp6_prefixes_hash_ops
= {
1374 .hash
= dhcp6_prefixes_hash_func
,
1375 .compare
= dhcp6_prefixes_compare_func
,
1378 int manager_new(Manager
**ret
, sd_event
*event
) {
1379 _cleanup_(manager_freep
) Manager
*m
= NULL
;
1382 m
= new0(Manager
, 1);
1386 m
->state_file
= strdup("/run/systemd/netif/state");
1390 m
->event
= sd_event_ref(event
);
1392 r
= sd_event_add_post(m
->event
, NULL
, manager_dirty_handler
, m
);
1396 r
= manager_connect_rtnl(m
);
1400 r
= manager_connect_genl(m
);
1404 r
= manager_connect_udev(m
);
1408 m
->netdevs
= hashmap_new(&string_hash_ops
);
1412 LIST_HEAD_INIT(m
->networks
);
1414 r
= sd_resolve_default(&m
->resolve
);
1418 r
= sd_resolve_attach_event(m
->resolve
, m
->event
, 0);
1422 r
= setup_default_address_pool(m
);
1426 m
->dhcp6_prefixes
= hashmap_new(&dhcp6_prefixes_hash_ops
);
1427 if (!m
->dhcp6_prefixes
)
1430 m
->duid
.type
= DUID_TYPE_EN
;
1432 (void) routing_policy_load_rules(m
->state_file
, &m
->rules_saved
);
1439 void manager_free(Manager
*m
) {
1448 free(m
->state_file
);
1450 while ((network
= m
->networks
))
1451 network_free(network
);
1453 while ((link
= hashmap_first(m
->dhcp6_prefixes
)))
1455 hashmap_free(m
->dhcp6_prefixes
);
1457 while ((link
= hashmap_first(m
->links
)))
1459 hashmap_free(m
->links
);
1461 hashmap_free(m
->networks_by_name
);
1463 while ((netdev
= hashmap_first(m
->netdevs
)))
1464 netdev_unref(netdev
);
1465 hashmap_free(m
->netdevs
);
1467 while ((pool
= m
->address_pools
))
1468 address_pool_free(pool
);
1471 set_free(m
->rules_foreign
);
1473 set_free_with_destructor(m
->rules_saved
, routing_policy_rule_free
);
1475 sd_netlink_unref(m
->rtnl
);
1476 sd_event_unref(m
->event
);
1478 sd_resolve_unref(m
->resolve
);
1480 sd_event_source_unref(m
->udev_event_source
);
1481 udev_monitor_unref(m
->udev_monitor
);
1482 udev_unref(m
->udev
);
1484 sd_bus_unref(m
->bus
);
1485 sd_bus_slot_unref(m
->prepare_for_sleep_slot
);
1486 sd_bus_slot_unref(m
->connected_slot
);
1488 free(m
->dynamic_timezone
);
1489 free(m
->dynamic_hostname
);
1494 int manager_start(Manager
*m
) {
1500 /* The dirty handler will deal with future serialization, but the first one
1501 must be done explicitly. */
1505 HASHMAP_FOREACH(link
, m
->links
, i
)
1511 int manager_load_config(Manager
*m
) {
1514 /* update timestamp */
1515 paths_check_timestamp(network_dirs
, &m
->network_dirs_ts_usec
, true);
1521 r
= network_load(m
);
1528 bool manager_should_reload(Manager
*m
) {
1529 return paths_check_timestamp(network_dirs
, &m
->network_dirs_ts_usec
, false);
1532 int manager_rtnl_enumerate_links(Manager
*m
) {
1533 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
, *reply
= NULL
;
1534 sd_netlink_message
*link
;
1540 r
= sd_rtnl_message_new_link(m
->rtnl
, &req
, RTM_GETLINK
, 0);
1544 r
= sd_netlink_message_request_dump(req
, true);
1548 r
= sd_netlink_call(m
->rtnl
, req
, 0, &reply
);
1552 for (link
= reply
; link
; link
= sd_netlink_message_next(link
)) {
1555 m
->enumerating
= true;
1557 k
= manager_rtnl_process_link(m
->rtnl
, link
, m
);
1561 m
->enumerating
= false;
1567 int manager_rtnl_enumerate_addresses(Manager
*m
) {
1568 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
, *reply
= NULL
;
1569 sd_netlink_message
*addr
;
1575 r
= sd_rtnl_message_new_addr(m
->rtnl
, &req
, RTM_GETADDR
, 0, 0);
1579 r
= sd_netlink_message_request_dump(req
, true);
1583 r
= sd_netlink_call(m
->rtnl
, req
, 0, &reply
);
1587 for (addr
= reply
; addr
; addr
= sd_netlink_message_next(addr
)) {
1590 m
->enumerating
= true;
1592 k
= manager_rtnl_process_address(m
->rtnl
, addr
, m
);
1596 m
->enumerating
= false;
1602 int manager_rtnl_enumerate_routes(Manager
*m
) {
1603 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
, *reply
= NULL
;
1604 sd_netlink_message
*route
;
1610 r
= sd_rtnl_message_new_route(m
->rtnl
, &req
, RTM_GETROUTE
, 0, 0);
1614 r
= sd_netlink_message_request_dump(req
, true);
1618 r
= sd_netlink_call(m
->rtnl
, req
, 0, &reply
);
1622 for (route
= reply
; route
; route
= sd_netlink_message_next(route
)) {
1625 m
->enumerating
= true;
1627 k
= manager_rtnl_process_route(m
->rtnl
, route
, m
);
1631 m
->enumerating
= false;
1637 int manager_rtnl_enumerate_rules(Manager
*m
) {
1638 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
, *reply
= NULL
;
1639 sd_netlink_message
*rule
;
1645 r
= sd_rtnl_message_new_routing_policy_rule(m
->rtnl
, &req
, RTM_GETRULE
, 0);
1649 r
= sd_netlink_message_request_dump(req
, true);
1653 r
= sd_netlink_call(m
->rtnl
, req
, 0, &reply
);
1655 if (r
== -EOPNOTSUPP
) {
1656 log_debug("FIB Rules are not supported by the kernel. Ignoring.");
1663 for (rule
= reply
; rule
; rule
= sd_netlink_message_next(rule
)) {
1666 m
->enumerating
= true;
1668 k
= manager_rtnl_process_rule(m
->rtnl
, rule
, m
);
1672 m
->enumerating
= false;
1678 int manager_address_pool_acquire(Manager
*m
, int family
, unsigned prefixlen
, union in_addr_union
*found
) {
1683 assert(prefixlen
> 0);
1686 LIST_FOREACH(address_pools
, p
, m
->address_pools
) {
1687 if (p
->family
!= family
)
1690 r
= address_pool_acquire(p
, prefixlen
, found
);
1698 Link
* manager_find_uplink(Manager
*m
, Link
*exclude
) {
1699 _cleanup_free_
struct local_address
*gateways
= NULL
;
1704 /* Looks for a suitable "uplink", via black magic: an
1705 * interface that is up and where the default route with the
1706 * highest priority points to. */
1708 n
= local_gateways(m
->rtnl
, 0, AF_UNSPEC
, &gateways
);
1710 log_warning_errno(n
, "Failed to determine list of default gateways: %m");
1714 for (i
= 0; i
< n
; i
++) {
1717 link
= hashmap_get(m
->links
, INT_TO_PTR(gateways
[i
].ifindex
));
1719 log_debug("Weird, found a gateway for a link we don't know. Ignoring.");
1723 if (link
== exclude
)
1726 if (link
->operstate
< LINK_OPERSTATE_ROUTABLE
)
1735 void manager_dirty(Manager
*manager
) {
1738 /* the serialized state in /run is no longer up-to-date */
1739 manager
->dirty
= true;
1742 static int set_hostname_handler(sd_bus_message
*m
, void *userdata
, sd_bus_error
*ret_error
) {
1743 Manager
*manager
= userdata
;
1744 const sd_bus_error
*e
;
1749 e
= sd_bus_message_get_error(m
);
1751 log_warning_errno(sd_bus_error_get_errno(e
), "Could not set hostname: %s", e
->message
);
1756 int manager_set_hostname(Manager
*m
, const char *hostname
) {
1759 log_debug("Setting transient hostname: '%s'", strna(hostname
));
1761 if (free_and_strdup(&m
->dynamic_hostname
, hostname
) < 0)
1764 if (!m
->bus
|| sd_bus_is_ready(m
->bus
) <= 0) {
1765 log_info("Not connected to system bus, not setting hostname.");
1769 r
= sd_bus_call_method_async(
1772 "org.freedesktop.hostname1",
1773 "/org/freedesktop/hostname1",
1774 "org.freedesktop.hostname1",
1776 set_hostname_handler
,
1783 return log_error_errno(r
, "Could not set transient hostname: %m");
1788 static int set_timezone_handler(sd_bus_message
*m
, void *userdata
, sd_bus_error
*ret_error
) {
1789 Manager
*manager
= userdata
;
1790 const sd_bus_error
*e
;
1795 e
= sd_bus_message_get_error(m
);
1797 log_warning_errno(sd_bus_error_get_errno(e
), "Could not set timezone: %s", e
->message
);
1802 int manager_set_timezone(Manager
*m
, const char *tz
) {
1808 log_debug("Setting system timezone: '%s'", tz
);
1809 if (free_and_strdup(&m
->dynamic_timezone
, tz
) < 0)
1812 if (!m
->bus
|| sd_bus_is_ready(m
->bus
) <= 0) {
1813 log_info("Not connected to system bus, not setting timezone.");
1817 r
= sd_bus_call_method_async(
1820 "org.freedesktop.timedate1",
1821 "/org/freedesktop/timedate1",
1822 "org.freedesktop.timedate1",
1824 set_timezone_handler
,
1830 return log_error_errno(r
, "Could not set timezone: %m");