2 This file is part of systemd.
4 Copyright 2013 Tom Gundersen <teg@jklm.no>
6 systemd is free software; you can redistribute it and/or modify it
7 under the terms of the GNU Lesser General Public License as published by
8 the Free Software Foundation; either version 2.1 of the License, or
9 (at your option) any later version.
11 systemd is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public License
17 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 #include <sys/socket.h>
22 #include <linux/fib_rules.h>
24 #include "sd-daemon.h"
25 #include "sd-netlink.h"
27 #include "alloc-util.h"
29 #include "conf-parser.h"
31 #include "dns-domain.h"
34 #include "libudev-private.h"
35 #include "local-addresses.h"
36 #include "netlink-util.h"
37 #include "networkd-manager.h"
38 #include "ordered-set.h"
39 #include "path-util.h"
41 #include "udev-util.h"
44 /* use 8 MB for receive socket kernel queue. */
45 #define RCVBUF_SIZE (8*1024*1024)
47 const char* const network_dirs
[] = {
48 "/etc/systemd/network",
49 "/run/systemd/network",
50 "/usr/lib/systemd/network",
52 "/lib/systemd/network",
56 static int setup_default_address_pool(Manager
*m
) {
62 /* Add in the well-known private address ranges. */
64 r
= address_pool_new_from_string(m
, &p
, AF_INET6
, "fc00::", 7);
68 r
= address_pool_new_from_string(m
, &p
, AF_INET
, "192.168.0.0", 16);
72 r
= address_pool_new_from_string(m
, &p
, AF_INET
, "172.16.0.0", 12);
76 r
= address_pool_new_from_string(m
, &p
, AF_INET
, "10.0.0.0", 8);
83 static int on_bus_retry(sd_event_source
*s
, usec_t usec
, void *userdata
) {
84 Manager
*m
= userdata
;
89 m
->bus_retry_event_source
= sd_event_source_unref(m
->bus_retry_event_source
);
91 manager_connect_bus(m
);
96 static int manager_reset_all(Manager
*m
) {
103 HASHMAP_FOREACH(link
, m
->links
, i
) {
104 r
= link_carrier_reset(link
);
106 log_link_warning_errno(link
, r
, "Could not reset carrier: %m");
112 static int match_prepare_for_sleep(sd_bus_message
*message
, void *userdata
, sd_bus_error
*ret_error
) {
113 Manager
*m
= userdata
;
118 r
= sd_bus_message_read(message
, "b", &b
);
120 log_debug_errno(r
, "Failed to parse PrepareForSleep signal: %m");
127 log_debug("Coming back from suspend, resetting all connections...");
129 manager_reset_all(m
);
134 int manager_connect_bus(Manager
*m
) {
139 r
= sd_bus_default_system(&m
->bus
);
141 /* We failed to connect? Yuck, we must be in early
142 * boot. Let's try in 5s again. */
144 log_debug_errno(r
, "Failed to connect to bus, trying again in 5s: %m");
146 r
= sd_event_add_time(m
->event
, &m
->bus_retry_event_source
, CLOCK_MONOTONIC
, now(CLOCK_MONOTONIC
) + 5*USEC_PER_SEC
, 0, on_bus_retry
, m
);
148 return log_error_errno(r
, "Failed to install bus reconnect time event: %m");
156 r
= sd_bus_add_match(m
->bus
, &m
->prepare_for_sleep_slot
,
158 "sender='org.freedesktop.login1',"
159 "interface='org.freedesktop.login1.Manager',"
160 "member='PrepareForSleep',"
161 "path='/org/freedesktop/login1'",
162 match_prepare_for_sleep
,
165 return log_error_errno(r
, "Failed to add match for PrepareForSleep: %m");
167 r
= sd_bus_add_object_vtable(m
->bus
, NULL
, "/org/freedesktop/network1", "org.freedesktop.network1.Manager", manager_vtable
, m
);
169 return log_error_errno(r
, "Failed to add manager object vtable: %m");
171 r
= sd_bus_add_fallback_vtable(m
->bus
, NULL
, "/org/freedesktop/network1/link", "org.freedesktop.network1.Link", link_vtable
, link_object_find
, m
);
173 return log_error_errno(r
, "Failed to add link object vtable: %m");
175 r
= sd_bus_add_node_enumerator(m
->bus
, NULL
, "/org/freedesktop/network1/link", link_node_enumerator
, m
);
177 return log_error_errno(r
, "Failed to add link enumerator: %m");
179 r
= sd_bus_add_fallback_vtable(m
->bus
, NULL
, "/org/freedesktop/network1/network", "org.freedesktop.network1.Network", network_vtable
, network_object_find
, m
);
181 return log_error_errno(r
, "Failed to add network object vtable: %m");
183 r
= sd_bus_add_node_enumerator(m
->bus
, NULL
, "/org/freedesktop/network1/network", network_node_enumerator
, m
);
185 return log_error_errno(r
, "Failed to add network enumerator: %m");
187 r
= sd_bus_request_name(m
->bus
, "org.freedesktop.network1", 0);
189 return log_error_errno(r
, "Failed to register name: %m");
191 r
= sd_bus_attach_event(m
->bus
, m
->event
, 0);
193 return log_error_errno(r
, "Failed to attach bus to event loop: %m");
195 /* Did we get a timezone or transient hostname from DHCP while D-Bus wasn't up yet? */
196 if (m
->dynamic_hostname
) {
197 r
= manager_set_hostname(m
, m
->dynamic_hostname
);
201 if (m
->dynamic_timezone
) {
202 r
= manager_set_timezone(m
, m
->dynamic_timezone
);
210 static int manager_udev_process_link(Manager
*m
, struct udev_device
*device
) {
217 if (!streq_ptr(udev_device_get_action(device
), "add"))
220 ifindex
= udev_device_get_ifindex(device
);
222 log_debug("Ignoring udev ADD event for device with invalid ifindex");
226 r
= link_get(m
, ifindex
, &link
);
232 r
= link_initialized(link
, device
);
239 static int manager_dispatch_link_udev(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
) {
240 Manager
*m
= userdata
;
241 struct udev_monitor
*monitor
= m
->udev_monitor
;
242 _cleanup_udev_device_unref_
struct udev_device
*device
= NULL
;
244 device
= udev_monitor_receive_device(monitor
);
248 manager_udev_process_link(m
, device
);
252 static int manager_connect_udev(Manager
*m
) {
255 /* udev does not initialize devices inside containers,
256 * so we rely on them being already initialized before
257 * entering the container */
258 if (detect_container() > 0)
261 m
->udev
= udev_new();
265 m
->udev_monitor
= udev_monitor_new_from_netlink(m
->udev
, "udev");
266 if (!m
->udev_monitor
)
269 r
= udev_monitor_filter_add_match_subsystem_devtype(m
->udev_monitor
, "net", NULL
);
271 return log_error_errno(r
, "Could not add udev monitor filter: %m");
273 r
= udev_monitor_enable_receiving(m
->udev_monitor
);
275 log_error("Could not enable udev monitor");
279 r
= sd_event_add_io(m
->event
,
280 &m
->udev_event_source
,
281 udev_monitor_get_fd(m
->udev_monitor
),
282 EPOLLIN
, manager_dispatch_link_udev
,
287 r
= sd_event_source_set_description(m
->udev_event_source
, "networkd-udev");
294 int manager_rtnl_process_route(sd_netlink
*rtnl
, sd_netlink_message
*message
, void *userdata
) {
295 Manager
*m
= userdata
;
298 uint32_t ifindex
, priority
= 0;
299 unsigned char protocol
, scope
, tos
, table
, rt_type
;
301 unsigned char dst_prefixlen
, src_prefixlen
;
302 union in_addr_union dst
= {}, gw
= {}, src
= {}, prefsrc
= {};
310 if (sd_netlink_message_is_error(message
)) {
311 r
= sd_netlink_message_get_errno(message
);
313 log_warning_errno(r
, "rtnl: failed to receive route: %m");
318 r
= sd_netlink_message_get_type(message
, &type
);
320 log_warning_errno(r
, "rtnl: could not get message type: %m");
322 } else if (!IN_SET(type
, RTM_NEWROUTE
, RTM_DELROUTE
)) {
323 log_warning("rtnl: received unexpected message type when processing route");
327 r
= sd_netlink_message_read_u32(message
, RTA_OIF
, &ifindex
);
329 log_debug("rtnl: received route without ifindex, ignoring");
332 log_warning_errno(r
, "rtnl: could not get ifindex from route, ignoring: %m");
334 } else if (ifindex
<= 0) {
335 log_warning("rtnl: received route message with invalid ifindex, ignoring: %d", ifindex
);
338 r
= link_get(m
, ifindex
, &link
);
339 if (r
< 0 || !link
) {
340 /* when enumerating we might be out of sync, but we will
341 * get the route again, so just ignore it */
343 log_warning("rtnl: received route for nonexistent link (%d), ignoring", ifindex
);
348 r
= sd_rtnl_message_route_get_family(message
, &family
);
349 if (r
< 0 || !IN_SET(family
, AF_INET
, AF_INET6
)) {
350 log_link_warning(link
, "rtnl: received address with invalid family, ignoring.");
354 r
= sd_rtnl_message_route_get_protocol(message
, &protocol
);
356 log_warning_errno(r
, "rtnl: could not get route protocol: %m");
362 r
= sd_netlink_message_read_in_addr(message
, RTA_DST
, &dst
.in
);
363 if (r
< 0 && r
!= -ENODATA
) {
364 log_link_warning_errno(link
, r
, "rtnl: received route without valid destination, ignoring: %m");
368 r
= sd_netlink_message_read_in_addr(message
, RTA_GATEWAY
, &gw
.in
);
369 if (r
< 0 && r
!= -ENODATA
) {
370 log_link_warning_errno(link
, r
, "rtnl: received route with invalid gateway, ignoring: %m");
374 r
= sd_netlink_message_read_in_addr(message
, RTA_SRC
, &src
.in
);
375 if (r
< 0 && r
!= -ENODATA
) {
376 log_link_warning_errno(link
, r
, "rtnl: received route with invalid source, ignoring: %m");
380 r
= sd_netlink_message_read_in_addr(message
, RTA_PREFSRC
, &prefsrc
.in
);
381 if (r
< 0 && r
!= -ENODATA
) {
382 log_link_warning_errno(link
, r
, "rtnl: received route with invalid preferred source, ignoring: %m");
389 r
= sd_netlink_message_read_in6_addr(message
, RTA_DST
, &dst
.in6
);
390 if (r
< 0 && r
!= -ENODATA
) {
391 log_link_warning_errno(link
, r
, "rtnl: received route without valid destination, ignoring: %m");
395 r
= sd_netlink_message_read_in6_addr(message
, RTA_GATEWAY
, &gw
.in6
);
396 if (r
< 0 && r
!= -ENODATA
) {
397 log_link_warning_errno(link
, r
, "rtnl: received route with invalid gateway, ignoring: %m");
401 r
= sd_netlink_message_read_in6_addr(message
, RTA_SRC
, &src
.in6
);
402 if (r
< 0 && r
!= -ENODATA
) {
403 log_link_warning_errno(link
, r
, "rtnl: received route with invalid source, ignoring: %m");
407 r
= sd_netlink_message_read_in6_addr(message
, RTA_PREFSRC
, &prefsrc
.in6
);
408 if (r
< 0 && r
!= -ENODATA
) {
409 log_link_warning_errno(link
, r
, "rtnl: received route with invalid preferred source, ignoring: %m");
416 assert_not_reached("Received unsupported address family");
420 r
= sd_rtnl_message_route_get_dst_prefixlen(message
, &dst_prefixlen
);
422 log_link_warning_errno(link
, r
, "rtnl: received route with invalid destination prefixlen, ignoring: %m");
426 r
= sd_rtnl_message_route_get_src_prefixlen(message
, &src_prefixlen
);
428 log_link_warning_errno(link
, r
, "rtnl: received route with invalid source prefixlen, ignoring: %m");
432 r
= sd_rtnl_message_route_get_scope(message
, &scope
);
434 log_link_warning_errno(link
, r
, "rtnl: received route with invalid scope, ignoring: %m");
438 r
= sd_rtnl_message_route_get_tos(message
, &tos
);
440 log_link_warning_errno(link
, r
, "rtnl: received route with invalid tos, ignoring: %m");
444 r
= sd_rtnl_message_route_get_type(message
, &rt_type
);
446 log_link_warning_errno(link
, r
, "rtnl: received route with invalid type, ignoring: %m");
450 r
= sd_rtnl_message_route_get_table(message
, &table
);
452 log_link_warning_errno(link
, r
, "rtnl: received route with invalid table, ignoring: %m");
456 r
= sd_netlink_message_read_u32(message
, RTA_PRIORITY
, &priority
);
457 if (r
< 0 && r
!= -ENODATA
) {
458 log_link_warning_errno(link
, r
, "rtnl: received route with invalid priority, ignoring: %m");
462 route_get(link
, family
, &dst
, dst_prefixlen
, tos
, priority
, table
, &route
);
467 /* A route appeared that we did not request */
468 r
= route_add_foreign(link
, family
, &dst
, dst_prefixlen
, tos
, priority
, table
, &route
);
473 route_update(route
, &src
, src_prefixlen
, &gw
, &prefsrc
, scope
, rt_type
, protocol
);
482 assert_not_reached("Received invalid RTNL message type");
488 int manager_rtnl_process_address(sd_netlink
*rtnl
, sd_netlink_message
*message
, void *userdata
) {
489 Manager
*m
= userdata
;
494 unsigned char prefixlen
;
496 union in_addr_union in_addr
;
497 struct ifa_cacheinfo cinfo
;
498 Address
*address
= NULL
;
499 char buf
[INET6_ADDRSTRLEN
], valid_buf
[FORMAT_TIMESPAN_MAX
];
500 const char *valid_str
= NULL
;
507 if (sd_netlink_message_is_error(message
)) {
508 r
= sd_netlink_message_get_errno(message
);
510 log_warning_errno(r
, "rtnl: failed to receive address: %m");
515 r
= sd_netlink_message_get_type(message
, &type
);
517 log_warning_errno(r
, "rtnl: could not get message type: %m");
519 } else if (!IN_SET(type
, RTM_NEWADDR
, RTM_DELADDR
)) {
520 log_warning("rtnl: received unexpected message type when processing address");
524 r
= sd_rtnl_message_addr_get_ifindex(message
, &ifindex
);
526 log_warning_errno(r
, "rtnl: could not get ifindex from address: %m");
528 } else if (ifindex
<= 0) {
529 log_warning("rtnl: received address message with invalid ifindex: %d", ifindex
);
532 r
= link_get(m
, ifindex
, &link
);
533 if (r
< 0 || !link
) {
534 /* when enumerating we might be out of sync, but we will
535 * get the address again, so just ignore it */
537 log_warning("rtnl: received address for nonexistent link (%d), ignoring", ifindex
);
542 r
= sd_rtnl_message_addr_get_family(message
, &family
);
543 if (r
< 0 || !IN_SET(family
, AF_INET
, AF_INET6
)) {
544 log_link_warning(link
, "rtnl: received address with invalid family, ignoring.");
548 r
= sd_rtnl_message_addr_get_prefixlen(message
, &prefixlen
);
550 log_link_warning_errno(link
, r
, "rtnl: received address with invalid prefixlen, ignoring: %m");
554 r
= sd_rtnl_message_addr_get_scope(message
, &scope
);
556 log_link_warning_errno(link
, r
, "rtnl: received address with invalid scope, ignoring: %m");
560 r
= sd_rtnl_message_addr_get_flags(message
, &flags
);
562 log_link_warning_errno(link
, r
, "rtnl: received address with invalid flags, ignoring: %m");
568 r
= sd_netlink_message_read_in_addr(message
, IFA_LOCAL
, &in_addr
.in
);
570 log_link_warning_errno(link
, r
, "rtnl: received address without valid address, ignoring: %m");
577 r
= sd_netlink_message_read_in6_addr(message
, IFA_ADDRESS
, &in_addr
.in6
);
579 log_link_warning_errno(link
, r
, "rtnl: received address without valid address, ignoring: %m");
586 log_link_debug(link
, "rtnl: ignoring unsupported address family: %d", family
);
589 if (!inet_ntop(family
, &in_addr
, buf
, INET6_ADDRSTRLEN
)) {
590 log_link_warning(link
, "Could not print address");
594 r
= sd_netlink_message_read_cache_info(message
, IFA_CACHEINFO
, &cinfo
);
596 if (cinfo
.ifa_valid
!= CACHE_INFO_INFINITY_LIFE_TIME
)
597 valid_str
= format_timespan(valid_buf
, FORMAT_TIMESPAN_MAX
,
598 cinfo
.ifa_valid
* USEC_PER_SEC
,
602 address_get(link
, family
, &in_addr
, prefixlen
, &address
);
607 log_link_debug(link
, "Updating address: %s/%u (valid %s%s)", buf
, prefixlen
,
608 valid_str
? "for " : "forever", valid_str
?: "");
610 /* An address appeared that we did not request */
611 r
= address_add_foreign(link
, family
, &in_addr
, prefixlen
, &address
);
613 log_link_warning_errno(link
, r
, "Failed to add address %s/%u: %m", buf
, prefixlen
);
616 log_link_debug(link
, "Adding address: %s/%u (valid %s%s)", buf
, prefixlen
,
617 valid_str
? "for " : "forever", valid_str
?: "");
620 address_update(address
, flags
, scope
, &cinfo
);
627 log_link_debug(link
, "Removing address: %s/%u (valid %s%s)", buf
, prefixlen
,
628 valid_str
? "for " : "forever", valid_str
?: "");
629 address_drop(address
);
631 log_link_warning(link
, "Removing non-existent address: %s/%u (valid %s%s)", buf
, prefixlen
,
632 valid_str
? "for " : "forever", valid_str
?: "");
636 assert_not_reached("Received invalid RTNL message type");
642 static int manager_rtnl_process_link(sd_netlink
*rtnl
, sd_netlink_message
*message
, void *userdata
) {
643 Manager
*m
= userdata
;
645 NetDev
*netdev
= NULL
;
654 if (sd_netlink_message_is_error(message
)) {
655 r
= sd_netlink_message_get_errno(message
);
657 log_warning_errno(r
, "rtnl: Could not receive link: %m");
662 r
= sd_netlink_message_get_type(message
, &type
);
664 log_warning_errno(r
, "rtnl: Could not get message type: %m");
666 } else if (!IN_SET(type
, RTM_NEWLINK
, RTM_DELLINK
)) {
667 log_warning("rtnl: Received unexpected message type when processing link");
671 r
= sd_rtnl_message_link_get_ifindex(message
, &ifindex
);
673 log_warning_errno(r
, "rtnl: Could not get ifindex from link: %m");
675 } else if (ifindex
<= 0) {
676 log_warning("rtnl: received link message with invalid ifindex: %d", ifindex
);
680 r
= sd_netlink_message_read_string(message
, IFLA_IFNAME
, &name
);
682 log_warning_errno(r
, "rtnl: Received link message without ifname: %m");
686 (void) link_get(m
, ifindex
, &link
);
687 (void) netdev_get(m
, name
, &netdev
);
692 /* link is new, so add it */
693 r
= link_add(m
, message
, &link
);
695 log_warning_errno(r
, "Could not add new link: %m");
701 /* netdev exists, so make sure the ifindex matches */
702 r
= netdev_set_ifindex(netdev
, message
);
704 log_warning_errno(r
, "Could not set ifindex on netdev: %m");
709 r
= link_update(link
, message
);
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;
730 RoutingPolicyRule
*rule
= NULL
;
731 union in_addr_union to
, from
;
732 uint32_t fwmark
= 0, table
= 0;
733 Manager
*m
= userdata
;
742 if (sd_netlink_message_is_error(message
)) {
743 r
= sd_netlink_message_get_errno(message
);
745 log_warning_errno(r
, "rtnl: failed to receive rule: %m");
750 r
= sd_netlink_message_get_type(message
, &type
);
752 log_warning_errno(r
, "rtnl: could not get message type: %m");
754 } else if (!IN_SET(type
, RTM_NEWRULE
, RTM_DELRULE
)) {
755 log_warning("rtnl: received unexpected message type '%u' when processing rule.", type
);
759 r
= sd_rtnl_message_get_family(message
, &family
);
761 log_warning_errno(r
, "rtnl: could not get rule family: %m");
763 } else if (!IN_SET(family
, AF_INET
, AF_INET6
)) {
764 log_debug("rtnl: received address with invalid family %u, ignoring.", family
);
770 r
= sd_netlink_message_read_in_addr(message
, FRA_SRC
, &from
.in
);
772 r
= sd_rtnl_message_routing_policy_rule_get_rtm_src_prefixlen(message
, &from_prefixlen
);
774 log_warning_errno(r
, "rtnl: failed to retrive rule from prefix length: %m");
777 r
= sd_netlink_message_read_in_addr(message
, FRA_DST
, &to
.in
);
779 r
= sd_rtnl_message_routing_policy_rule_get_rtm_dst_prefixlen(message
, &to_prefixlen
);
781 log_warning_errno(r
, "rtnl: failed to retrive rule to prefix length: %m");
787 r
= sd_netlink_message_read_in6_addr(message
, FRA_SRC
, &from
.in6
);
789 r
= sd_rtnl_message_routing_policy_rule_get_rtm_src_prefixlen(message
, &from_prefixlen
);
791 log_warning_errno(r
, "rtnl: failed to retrive rule from prefix length: %m");
794 r
= sd_netlink_message_read_in6_addr(message
, FRA_DST
, &to
.in6
);
796 r
= sd_rtnl_message_routing_policy_rule_get_rtm_dst_prefixlen(message
, &to_prefixlen
);
798 log_warning_errno(r
, "rtnl: failed to retrive rule to prefix length: %m");
804 assert_not_reached("Received unsupported address family");
807 if (from_prefixlen
== 0 && to_prefixlen
== 0)
810 (void) sd_netlink_message_read_u32(message
, FRA_FWMARK
, &fwmark
);
811 (void) sd_netlink_message_read_u32(message
, FRA_TABLE
, &table
);
812 (void) sd_rtnl_message_routing_policy_rule_get_tos(message
, &tos
);
814 (void) routing_policy_rule_get(m
, family
, &from
, from_prefixlen
, &to
, to_prefixlen
, tos
, fwmark
, table
, &rule
);
819 r
= routing_policy_rule_add_foreign(m
, family
, &from
, from_prefixlen
, &to
, to_prefixlen
, tos
, fwmark
, table
, &rule
);
821 log_warning_errno(r
, "Could not add rule: %m");
827 routing_policy_rule_free(rule
);
832 assert_not_reached("Received invalid RTNL message type");
838 static int systemd_netlink_fd(void) {
839 int n
, fd
, rtnl_fd
= -EINVAL
;
841 n
= sd_listen_fds(true);
845 for (fd
= SD_LISTEN_FDS_START
; fd
< SD_LISTEN_FDS_START
+ n
; fd
++) {
846 if (sd_is_socket(fd
, AF_NETLINK
, SOCK_RAW
, -1) > 0) {
857 static int manager_connect_rtnl(Manager
*m
) {
862 fd
= systemd_netlink_fd();
864 r
= sd_netlink_open(&m
->rtnl
);
866 r
= sd_netlink_open_fd(&m
->rtnl
, fd
);
870 r
= sd_netlink_inc_rcvbuf(m
->rtnl
, RCVBUF_SIZE
);
874 r
= sd_netlink_attach_event(m
->rtnl
, m
->event
, 0);
878 r
= sd_netlink_add_match(m
->rtnl
, RTM_NEWLINK
, &manager_rtnl_process_link
, m
);
882 r
= sd_netlink_add_match(m
->rtnl
, RTM_DELLINK
, &manager_rtnl_process_link
, m
);
886 r
= sd_netlink_add_match(m
->rtnl
, RTM_NEWADDR
, &manager_rtnl_process_address
, m
);
890 r
= sd_netlink_add_match(m
->rtnl
, RTM_DELADDR
, &manager_rtnl_process_address
, m
);
894 r
= sd_netlink_add_match(m
->rtnl
, RTM_NEWROUTE
, &manager_rtnl_process_route
, m
);
898 r
= sd_netlink_add_match(m
->rtnl
, RTM_DELROUTE
, &manager_rtnl_process_route
, m
);
902 r
= sd_netlink_add_match(m
->rtnl
, RTM_NEWRULE
, &manager_rtnl_process_rule
, m
);
906 r
= sd_netlink_add_match(m
->rtnl
, RTM_DELRULE
, &manager_rtnl_process_rule
, m
);
913 static int ordered_set_put_in_addr_data(OrderedSet
*s
, const struct in_addr_data
*address
) {
920 r
= in_addr_to_string(address
->family
, &address
->address
, &p
);
924 r
= ordered_set_consume(s
, p
);
931 static int ordered_set_put_in_addr_datav(OrderedSet
*s
, const struct in_addr_data
*addresses
, unsigned n
) {
936 assert(addresses
|| n
== 0);
938 for (i
= 0; i
< n
; i
++) {
939 r
= ordered_set_put_in_addr_data(s
, addresses
+i
);
949 static int ordered_set_put_in4_addr(OrderedSet
*s
, const struct in_addr
*address
) {
956 r
= in_addr_to_string(AF_INET
, (const union in_addr_union
*) address
, &p
);
960 r
= ordered_set_consume(s
, p
);
967 static int ordered_set_put_in4_addrv(OrderedSet
*s
, const struct in_addr
*addresses
, unsigned n
) {
972 assert(n
== 0 || addresses
);
974 for (i
= 0; i
< n
; i
++) {
975 r
= ordered_set_put_in4_addr(s
, addresses
+i
);
985 static void print_string_set(FILE *f
, const char *field
, OrderedSet
*s
) {
990 if (ordered_set_isempty(s
))
993 fputs_unlocked(field
, f
);
995 ORDERED_SET_FOREACH(p
, s
, i
)
996 fputs_with_space(f
, p
, NULL
, &space
);
998 fputc_unlocked('\n', f
);
1001 static int manager_save(Manager
*m
) {
1002 _cleanup_ordered_set_free_free_ OrderedSet
*dns
= NULL
, *ntp
= NULL
, *search_domains
= NULL
, *route_domains
= NULL
;
1003 RoutingPolicyRule
*rule
= NULL
;
1007 _cleanup_free_
char *temp_path
= NULL
;
1008 _cleanup_fclose_
FILE *f
= NULL
;
1009 LinkOperationalState operstate
= LINK_OPERSTATE_OFF
;
1010 const char *operstate_str
;
1014 assert(m
->state_file
);
1016 /* We add all NTP and DNS server to a set, to filter out duplicates */
1017 dns
= ordered_set_new(&string_hash_ops
);
1021 ntp
= ordered_set_new(&string_hash_ops
);
1025 search_domains
= ordered_set_new(&dns_name_hash_ops
);
1026 if (!search_domains
)
1029 route_domains
= ordered_set_new(&dns_name_hash_ops
);
1033 HASHMAP_FOREACH(link
, m
->links
, i
) {
1034 if (link
->flags
& IFF_LOOPBACK
)
1037 if (link
->operstate
> operstate
)
1038 operstate
= link
->operstate
;
1043 /* First add the static configured entries */
1044 r
= ordered_set_put_in_addr_datav(dns
, link
->network
->dns
, link
->network
->n_dns
);
1048 r
= ordered_set_put_strdupv(ntp
, link
->network
->ntp
);
1052 r
= ordered_set_put_strdupv(search_domains
, link
->network
->search_domains
);
1056 r
= ordered_set_put_strdupv(route_domains
, link
->network
->route_domains
);
1060 if (!link
->dhcp_lease
)
1063 /* Secondly, add the entries acquired via DHCP */
1064 if (link
->network
->dhcp_use_dns
) {
1065 const struct in_addr
*addresses
;
1067 r
= sd_dhcp_lease_get_dns(link
->dhcp_lease
, &addresses
);
1069 r
= ordered_set_put_in4_addrv(dns
, addresses
, r
);
1072 } else if (r
< 0 && r
!= -ENODATA
)
1076 if (link
->network
->dhcp_use_ntp
) {
1077 const struct in_addr
*addresses
;
1079 r
= sd_dhcp_lease_get_ntp(link
->dhcp_lease
, &addresses
);
1081 r
= ordered_set_put_in4_addrv(ntp
, addresses
, r
);
1084 } else if (r
< 0 && r
!= -ENODATA
)
1088 if (link
->network
->dhcp_use_domains
!= DHCP_USE_DOMAINS_NO
) {
1089 const char *domainname
;
1090 char **domains
= NULL
;
1092 OrderedSet
*target_domains
= (link
->network
->dhcp_use_domains
== DHCP_USE_DOMAINS_YES
) ? search_domains
: route_domains
;
1093 r
= sd_dhcp_lease_get_domainname(link
->dhcp_lease
, &domainname
);
1095 r
= ordered_set_put_strdup(target_domains
, domainname
);
1098 } else if (r
!= -ENODATA
)
1101 r
= sd_dhcp_lease_get_search_domains(link
->dhcp_lease
, &domains
);
1103 r
= ordered_set_put_strdupv(target_domains
, domains
);
1106 } else if (r
!= -ENODATA
)
1111 operstate_str
= link_operstate_to_string(operstate
);
1112 assert(operstate_str
);
1114 r
= fopen_temporary(m
->state_file
, &f
, &temp_path
);
1118 (void) fchmod(fileno(f
), 0644);
1121 "# This is private data. Do not parse.\n"
1122 "OPER_STATE=%s\n", operstate_str
);
1124 print_string_set(f
, "DNS=", dns
);
1125 print_string_set(f
, "NTP=", ntp
);
1126 print_string_set(f
, "DOMAINS=", search_domains
);
1127 print_string_set(f
, "ROUTE_DOMAINS=", route_domains
);
1129 SET_FOREACH(rule
, m
->rules
, i
) {
1130 _cleanup_free_
char *from_str
= NULL
, *to_str
= NULL
;
1133 if (!in_addr_is_null(rule
->family
, &rule
->from
)) {
1134 r
= in_addr_to_string(rule
->family
, &rule
->from
, &from_str
);
1139 if (!in_addr_is_null(rule
->family
, &rule
->to
)) {
1140 r
= in_addr_to_string(rule
->family
, &rule
->to
, &to_str
);
1145 fprintf(f
, "from=%s%s/%hhu to=%s%s/%hhu tos=%hhu fwmark=%"PRIu32
"/%"PRIu32
" table=%hhu", space
? " " : "", from_str
,
1146 rule
->from_prefixlen
, space
? " " : "", to_str
, rule
->to_prefixlen
, rule
->tos
, rule
->fwmark
, rule
->fwmask
, rule
->table
);
1151 r
= fflush_and_check(f
);
1155 if (rename(temp_path
, m
->state_file
) < 0) {
1160 if (m
->operational_state
!= operstate
) {
1161 m
->operational_state
= operstate
;
1162 r
= manager_send_changed(m
, "OperationalState", NULL
);
1164 log_error_errno(r
, "Could not emit changed OperationalState: %m");
1172 (void) unlink(m
->state_file
);
1173 (void) unlink(temp_path
);
1175 return log_error_errno(r
, "Failed to save network state to %s: %m", m
->state_file
);
1178 static int manager_dirty_handler(sd_event_source
*s
, void *userdata
) {
1179 Manager
*m
= userdata
;
1189 SET_FOREACH(link
, m
->dirty_links
, i
) {
1190 r
= link_save(link
);
1198 int manager_new(Manager
**ret
, sd_event
*event
) {
1199 _cleanup_manager_free_ Manager
*m
= NULL
;
1202 m
= new0(Manager
, 1);
1206 m
->state_file
= strdup("/run/systemd/netif/state");
1210 m
->event
= sd_event_ref(event
);
1212 r
= sd_event_add_post(m
->event
, NULL
, manager_dirty_handler
, m
);
1216 r
= manager_connect_rtnl(m
);
1220 r
= manager_connect_udev(m
);
1224 m
->netdevs
= hashmap_new(&string_hash_ops
);
1228 LIST_HEAD_INIT(m
->networks
);
1230 r
= setup_default_address_pool(m
);
1234 m
->duid
.type
= DUID_TYPE_EN
;
1236 (void) routing_policy_rule_load(m
);
1244 void manager_free(Manager
*m
) {
1245 RoutingPolicyRule
*rule
;
1254 free(m
->state_file
);
1256 while ((network
= m
->networks
))
1257 network_free(network
);
1259 while ((link
= hashmap_first(m
->links
)))
1261 hashmap_free(m
->links
);
1263 hashmap_free(m
->networks_by_name
);
1265 while ((netdev
= hashmap_first(m
->netdevs
)))
1266 netdev_unref(netdev
);
1267 hashmap_free(m
->netdevs
);
1269 while ((pool
= m
->address_pools
))
1270 address_pool_free(pool
);
1273 set_free(m
->rules_foreign
);
1275 while ((rule
= set_steal_first(m
->rules_saved
)))
1278 set_free(m
->rules_saved
);
1280 sd_netlink_unref(m
->rtnl
);
1281 sd_event_unref(m
->event
);
1283 sd_event_source_unref(m
->udev_event_source
);
1284 udev_monitor_unref(m
->udev_monitor
);
1285 udev_unref(m
->udev
);
1287 sd_bus_unref(m
->bus
);
1288 sd_bus_slot_unref(m
->prepare_for_sleep_slot
);
1289 sd_event_source_unref(m
->bus_retry_event_source
);
1291 free(m
->dynamic_timezone
);
1292 free(m
->dynamic_hostname
);
1297 int manager_start(Manager
*m
) {
1303 /* The dirty handler will deal with future serialization, but the first one
1304 must be done explicitly. */
1308 HASHMAP_FOREACH(link
, m
->links
, i
)
1314 int manager_load_config(Manager
*m
) {
1317 /* update timestamp */
1318 paths_check_timestamp(network_dirs
, &m
->network_dirs_ts_usec
, true);
1324 r
= network_load(m
);
1331 bool manager_should_reload(Manager
*m
) {
1332 return paths_check_timestamp(network_dirs
, &m
->network_dirs_ts_usec
, false);
1335 int manager_rtnl_enumerate_links(Manager
*m
) {
1336 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
, *reply
= NULL
;
1337 sd_netlink_message
*link
;
1343 r
= sd_rtnl_message_new_link(m
->rtnl
, &req
, RTM_GETLINK
, 0);
1347 r
= sd_netlink_message_request_dump(req
, true);
1351 r
= sd_netlink_call(m
->rtnl
, req
, 0, &reply
);
1355 for (link
= reply
; link
; link
= sd_netlink_message_next(link
)) {
1358 m
->enumerating
= true;
1360 k
= manager_rtnl_process_link(m
->rtnl
, link
, m
);
1364 m
->enumerating
= false;
1370 int manager_rtnl_enumerate_addresses(Manager
*m
) {
1371 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
, *reply
= NULL
;
1372 sd_netlink_message
*addr
;
1378 r
= sd_rtnl_message_new_addr(m
->rtnl
, &req
, RTM_GETADDR
, 0, 0);
1382 r
= sd_netlink_message_request_dump(req
, true);
1386 r
= sd_netlink_call(m
->rtnl
, req
, 0, &reply
);
1390 for (addr
= reply
; addr
; addr
= sd_netlink_message_next(addr
)) {
1393 m
->enumerating
= true;
1395 k
= manager_rtnl_process_address(m
->rtnl
, addr
, m
);
1399 m
->enumerating
= false;
1405 int manager_rtnl_enumerate_routes(Manager
*m
) {
1406 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
, *reply
= NULL
;
1407 sd_netlink_message
*route
;
1413 r
= sd_rtnl_message_new_route(m
->rtnl
, &req
, RTM_GETROUTE
, 0, 0);
1417 r
= sd_netlink_message_request_dump(req
, true);
1421 r
= sd_netlink_call(m
->rtnl
, req
, 0, &reply
);
1425 for (route
= reply
; route
; route
= sd_netlink_message_next(route
)) {
1428 m
->enumerating
= true;
1430 k
= manager_rtnl_process_route(m
->rtnl
, route
, m
);
1434 m
->enumerating
= false;
1440 int manager_rtnl_enumerate_rules(Manager
*m
) {
1441 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
, *reply
= NULL
;
1442 sd_netlink_message
*rule
;
1448 r
= sd_rtnl_message_new_routing_policy_rule(m
->rtnl
, &req
, RTM_GETRULE
, 0);
1452 r
= sd_netlink_message_request_dump(req
, true);
1456 r
= sd_netlink_call(m
->rtnl
, req
, 0, &reply
);
1460 for (rule
= reply
; rule
; rule
= sd_netlink_message_next(rule
)) {
1463 m
->enumerating
= true;
1465 k
= manager_rtnl_process_rule(m
->rtnl
, rule
, m
);
1469 m
->enumerating
= false;
1475 int manager_address_pool_acquire(Manager
*m
, int family
, unsigned prefixlen
, union in_addr_union
*found
) {
1480 assert(prefixlen
> 0);
1483 LIST_FOREACH(address_pools
, p
, m
->address_pools
) {
1484 if (p
->family
!= family
)
1487 r
= address_pool_acquire(p
, prefixlen
, found
);
1495 Link
* manager_find_uplink(Manager
*m
, Link
*exclude
) {
1496 _cleanup_free_
struct local_address
*gateways
= NULL
;
1501 /* Looks for a suitable "uplink", via black magic: an
1502 * interface that is up and where the default route with the
1503 * highest priority points to. */
1505 n
= local_gateways(m
->rtnl
, 0, AF_UNSPEC
, &gateways
);
1507 log_warning_errno(n
, "Failed to determine list of default gateways: %m");
1511 for (i
= 0; i
< n
; i
++) {
1514 link
= hashmap_get(m
->links
, INT_TO_PTR(gateways
[i
].ifindex
));
1516 log_debug("Weird, found a gateway for a link we don't know. Ignoring.");
1520 if (link
== exclude
)
1523 if (link
->operstate
< LINK_OPERSTATE_ROUTABLE
)
1532 void manager_dirty(Manager
*manager
) {
1535 /* the serialized state in /run is no longer up-to-date */
1536 manager
->dirty
= true;
1539 static int set_hostname_handler(sd_bus_message
*m
, void *userdata
, sd_bus_error
*ret_error
) {
1540 Manager
*manager
= userdata
;
1541 const sd_bus_error
*e
;
1546 e
= sd_bus_message_get_error(m
);
1548 log_warning_errno(sd_bus_error_get_errno(e
), "Could not set hostname: %s", e
->message
);
1553 int manager_set_hostname(Manager
*m
, const char *hostname
) {
1556 log_debug("Setting transient hostname: '%s'", strna(hostname
));
1557 if (free_and_strdup(&m
->dynamic_hostname
, hostname
) < 0)
1561 /* TODO: replace by assert when we can rely on kdbus */
1562 log_info("Not connected to system bus, ignoring transient hostname.");
1566 r
= sd_bus_call_method_async(
1569 "org.freedesktop.hostname1",
1570 "/org/freedesktop/hostname1",
1571 "org.freedesktop.hostname1",
1573 set_hostname_handler
,
1580 return log_error_errno(r
, "Could not set transient hostname: %m");
1585 static int set_timezone_handler(sd_bus_message
*m
, void *userdata
, sd_bus_error
*ret_error
) {
1586 Manager
*manager
= userdata
;
1587 const sd_bus_error
*e
;
1592 e
= sd_bus_message_get_error(m
);
1594 log_warning_errno(sd_bus_error_get_errno(e
), "Could not set timezone: %s", e
->message
);
1599 int manager_set_timezone(Manager
*m
, const char *tz
) {
1605 log_debug("Setting system timezone: '%s'", tz
);
1606 if (free_and_strdup(&m
->dynamic_timezone
, tz
) < 0)
1610 log_info("Not connected to system bus, ignoring timezone.");
1614 r
= sd_bus_call_method_async(
1617 "org.freedesktop.timedate1",
1618 "/org/freedesktop/timedate1",
1619 "org.freedesktop.timedate1",
1621 set_timezone_handler
,
1627 return log_error_errno(r
, "Could not set timezone: %m");