1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2013 Tom Gundersen <teg@jklm.no>
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 #include <sys/socket.h>
25 #include "sd-netlink.h"
26 #include "sd-daemon.h"
28 #include "conf-parser.h"
29 #include "path-util.h"
30 #include "libudev-private.h"
31 #include "udev-util.h"
32 #include "netlink-util.h"
37 #include "local-addresses.h"
41 /* use 8 MB for receive socket kernel queue. */
42 #define RCVBUF_SIZE (8*1024*1024)
44 const char* const network_dirs
[] = {
45 "/etc/systemd/network",
46 "/run/systemd/network",
47 "/usr/lib/systemd/network",
49 "/lib/systemd/network",
53 static int setup_default_address_pool(Manager
*m
) {
59 /* Add in the well-known private address ranges. */
61 r
= address_pool_new_from_string(m
, &p
, AF_INET6
, "fc00::", 7);
65 r
= address_pool_new_from_string(m
, &p
, AF_INET
, "192.168.0.0", 16);
69 r
= address_pool_new_from_string(m
, &p
, AF_INET
, "172.16.0.0", 12);
73 r
= address_pool_new_from_string(m
, &p
, AF_INET
, "10.0.0.0", 8);
80 static int on_bus_retry(sd_event_source
*s
, usec_t usec
, void *userdata
) {
81 Manager
*m
= userdata
;
86 m
->bus_retry_event_source
= sd_event_source_unref(m
->bus_retry_event_source
);
88 manager_connect_bus(m
);
93 static int manager_reset_all(Manager
*m
) {
100 HASHMAP_FOREACH(link
, m
->links
, i
) {
101 r
= link_carrier_reset(link
);
103 log_link_warning_errno(link
, r
, "Could not reset carrier: %m");
109 static int match_prepare_for_sleep(sd_bus_message
*message
, void *userdata
, sd_bus_error
*ret_error
) {
110 Manager
*m
= userdata
;
115 r
= sd_bus_message_read(message
, "b", &b
);
117 log_debug_errno(r
, "Failed to parse PrepareForSleep signal: %m");
124 log_debug("Coming back from suspend, resetting all connections...");
126 manager_reset_all(m
);
131 int manager_connect_bus(Manager
*m
) {
136 r
= sd_bus_default_system(&m
->bus
);
138 /* We failed to connect? Yuck, we must be in early
139 * boot. Let's try in 5s again. As soon as we have
140 * kdbus we can stop doing this... */
142 log_debug_errno(r
, "Failed to connect to bus, trying again in 5s: %m");
144 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
);
146 return log_error_errno(r
, "Failed to install bus reconnect time event: %m");
154 r
= sd_bus_add_match(m
->bus
, &m
->prepare_for_sleep_slot
,
156 "sender='org.freedesktop.login1',"
157 "interface='org.freedesktop.login1.Manager',"
158 "member='PrepareForSleep',"
159 "path='/org/freedesktop/login1'",
160 match_prepare_for_sleep
,
163 return log_error_errno(r
, "Failed to add match for PrepareForSleep: %m");
165 r
= sd_bus_add_object_vtable(m
->bus
, NULL
, "/org/freedesktop/network1", "org.freedesktop.network1.Manager", manager_vtable
, m
);
167 return log_error_errno(r
, "Failed to add manager object vtable: %m");
169 r
= sd_bus_add_fallback_vtable(m
->bus
, NULL
, "/org/freedesktop/network1/link", "org.freedesktop.network1.Link", link_vtable
, link_object_find
, m
);
171 return log_error_errno(r
, "Failed to add link object vtable: %m");
173 r
= sd_bus_add_node_enumerator(m
->bus
, NULL
, "/org/freedesktop/network1/link", link_node_enumerator
, m
);
175 return log_error_errno(r
, "Failed to add link enumerator: %m");
177 r
= sd_bus_add_fallback_vtable(m
->bus
, NULL
, "/org/freedesktop/network1/network", "org.freedesktop.network1.Network", network_vtable
, network_object_find
, m
);
179 return log_error_errno(r
, "Failed to add network object vtable: %m");
181 r
= sd_bus_add_node_enumerator(m
->bus
, NULL
, "/org/freedesktop/network1/network", network_node_enumerator
, m
);
183 return log_error_errno(r
, "Failed to add network enumerator: %m");
185 r
= sd_bus_request_name(m
->bus
, "org.freedesktop.network1", 0);
187 return log_error_errno(r
, "Failed to register name: %m");
189 r
= sd_bus_attach_event(m
->bus
, m
->event
, 0);
191 return log_error_errno(r
, "Failed to attach bus to event loop: %m");
196 static int manager_udev_process_link(Manager
*m
, struct udev_device
*device
) {
203 if (!streq_ptr(udev_device_get_action(device
), "add"))
206 ifindex
= udev_device_get_ifindex(device
);
208 log_debug("Ignoring udev ADD event for device with invalid ifindex");
212 r
= link_get(m
, ifindex
, &link
);
218 r
= link_initialized(link
, device
);
225 static int manager_dispatch_link_udev(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
) {
226 Manager
*m
= userdata
;
227 struct udev_monitor
*monitor
= m
->udev_monitor
;
228 _cleanup_udev_device_unref_
struct udev_device
*device
= NULL
;
230 device
= udev_monitor_receive_device(monitor
);
234 manager_udev_process_link(m
, device
);
238 static int manager_connect_udev(Manager
*m
) {
241 /* udev does not initialize devices inside containers,
242 * so we rely on them being already initialized before
243 * entering the container */
244 if (detect_container(NULL
) > 0)
247 m
->udev
= udev_new();
251 m
->udev_monitor
= udev_monitor_new_from_netlink(m
->udev
, "udev");
252 if (!m
->udev_monitor
)
255 r
= udev_monitor_filter_add_match_subsystem_devtype(m
->udev_monitor
, "net", NULL
);
257 return log_error_errno(r
, "Could not add udev monitor filter: %m");
259 r
= udev_monitor_enable_receiving(m
->udev_monitor
);
261 log_error("Could not enable udev monitor");
265 r
= sd_event_add_io(m
->event
,
266 &m
->udev_event_source
,
267 udev_monitor_get_fd(m
->udev_monitor
),
268 EPOLLIN
, manager_dispatch_link_udev
,
273 r
= sd_event_source_set_description(m
->udev_event_source
, "networkd-udev");
280 static int manager_rtnl_process_link(sd_netlink
*rtnl
, sd_netlink_message
*message
, void *userdata
) {
281 Manager
*m
= userdata
;
283 NetDev
*netdev
= NULL
;
292 if (sd_netlink_message_is_error(message
)) {
293 r
= sd_netlink_message_get_errno(message
);
295 log_warning_errno(r
, "rtnl: Could not receive link: %m");
300 r
= sd_netlink_message_get_type(message
, &type
);
302 log_warning_errno(r
, "rtnl: Could not get message type: %m");
304 } else if (type
!= RTM_NEWLINK
&& type
!= RTM_DELLINK
) {
305 log_warning("rtnl: Received unexpected message type when processing link");
309 r
= sd_rtnl_message_link_get_ifindex(message
, &ifindex
);
311 log_warning_errno(r
, "rtnl: Could not get ifindex from link: %m");
313 } else if (ifindex
<= 0) {
314 log_warning("rtnl: received link message with invalid ifindex: %d", ifindex
);
317 link_get(m
, ifindex
, &link
);
319 r
= sd_netlink_message_read_string(message
, IFLA_IFNAME
, &name
);
321 log_warning_errno(r
, "rtnl: Received link message without ifname: %m");
324 netdev_get(m
, name
, &netdev
);
329 /* link is new, so add it */
330 r
= link_add(m
, message
, &link
);
332 log_warning_errno(r
, "Could not add new link: %m");
338 /* netdev exists, so make sure the ifindex matches */
339 r
= netdev_set_ifindex(netdev
, message
);
341 log_warning_errno(r
, "Could not set ifindex on netdev: %m");
346 r
= link_update(link
, message
);
359 assert_not_reached("Received invalid RTNL message type.");
365 static int systemd_netlink_fd(void) {
366 int n
, fd
, rtnl_fd
= -EINVAL
;
368 n
= sd_listen_fds(true);
372 for (fd
= SD_LISTEN_FDS_START
; fd
< SD_LISTEN_FDS_START
+ n
; fd
++) {
373 if (sd_is_socket(fd
, AF_NETLINK
, SOCK_RAW
, -1) > 0) {
384 static int manager_connect_rtnl(Manager
*m
) {
389 fd
= systemd_netlink_fd();
391 r
= sd_netlink_open(&m
->rtnl
);
393 r
= sd_netlink_open_fd(&m
->rtnl
, fd
);
397 r
= sd_netlink_inc_rcvbuf(m
->rtnl
, RCVBUF_SIZE
);
401 r
= sd_netlink_attach_event(m
->rtnl
, m
->event
, 0);
405 r
= sd_netlink_add_match(m
->rtnl
, RTM_NEWLINK
, &manager_rtnl_process_link
, m
);
409 r
= sd_netlink_add_match(m
->rtnl
, RTM_DELLINK
, &manager_rtnl_process_link
, m
);
413 r
= sd_netlink_add_match(m
->rtnl
, RTM_NEWADDR
, &link_rtnl_process_address
, m
);
417 r
= sd_netlink_add_match(m
->rtnl
, RTM_DELADDR
, &link_rtnl_process_address
, m
);
424 int manager_new(Manager
**ret
) {
425 _cleanup_manager_free_ Manager
*m
= NULL
;
428 m
= new0(Manager
, 1);
432 m
->state_file
= strdup("/run/systemd/netif/state");
436 r
= sd_event_default(&m
->event
);
440 sd_event_set_watchdog(m
->event
, true);
442 sd_event_add_signal(m
->event
, NULL
, SIGTERM
, NULL
, NULL
);
443 sd_event_add_signal(m
->event
, NULL
, SIGINT
, NULL
, NULL
);
445 r
= manager_connect_rtnl(m
);
449 r
= manager_connect_udev(m
);
453 m
->netdevs
= hashmap_new(&string_hash_ops
);
457 LIST_HEAD_INIT(m
->networks
);
459 r
= setup_default_address_pool(m
);
469 void manager_free(Manager
*m
) {
480 udev_monitor_unref(m
->udev_monitor
);
482 sd_bus_unref(m
->bus
);
483 sd_bus_slot_unref(m
->prepare_for_sleep_slot
);
484 sd_event_source_unref(m
->udev_event_source
);
485 sd_event_source_unref(m
->bus_retry_event_source
);
486 sd_event_unref(m
->event
);
488 while ((link
= hashmap_first(m
->links
)))
490 hashmap_free(m
->links
);
492 while ((network
= m
->networks
))
493 network_free(network
);
495 hashmap_free(m
->networks_by_name
);
497 while ((netdev
= hashmap_first(m
->netdevs
)))
498 netdev_unref(netdev
);
499 hashmap_free(m
->netdevs
);
501 while ((pool
= m
->address_pools
))
502 address_pool_free(pool
);
504 sd_netlink_unref(m
->rtnl
);
509 static bool manager_check_idle(void *userdata
) {
510 Manager
*m
= userdata
;
516 HASHMAP_FOREACH(link
, m
->links
, i
) {
517 /* we are not woken on udev activity, so let's just wait for the
518 * pending udev event */
519 if (link
->state
== LINK_STATE_PENDING
)
525 /* we are not woken on netork activity, so let's stay around */
526 if (link_lldp_enabled(link
) ||
527 link_ipv4ll_enabled(link
) ||
528 link_dhcp4_server_enabled(link
) ||
529 link_dhcp4_enabled(link
) ||
530 link_dhcp6_enabled(link
))
537 int manager_run(Manager
*m
) {
541 return bus_event_loop_with_idle(
544 "org.freedesktop.network1",
549 /* failed to connect to the bus, so we lose exit-on-idle logic,
550 this should not happen except if dbus is not around at all */
551 return sd_event_loop(m
->event
);
554 int manager_load_config(Manager
*m
) {
557 /* update timestamp */
558 paths_check_timestamp(network_dirs
, &m
->network_dirs_ts_usec
, true);
571 bool manager_should_reload(Manager
*m
) {
572 return paths_check_timestamp(network_dirs
, &m
->network_dirs_ts_usec
, false);
575 int manager_rtnl_enumerate_links(Manager
*m
) {
576 _cleanup_netlink_message_unref_ sd_netlink_message
*req
= NULL
, *reply
= NULL
;
577 sd_netlink_message
*link
;
583 r
= sd_rtnl_message_new_link(m
->rtnl
, &req
, RTM_GETLINK
, 0);
587 r
= sd_netlink_message_request_dump(req
, true);
591 r
= sd_netlink_call(m
->rtnl
, req
, 0, &reply
);
595 for (link
= reply
; link
; link
= sd_netlink_message_next(link
)) {
598 m
->enumerating
= true;
600 k
= manager_rtnl_process_link(m
->rtnl
, link
, m
);
604 m
->enumerating
= false;
610 int manager_rtnl_enumerate_addresses(Manager
*m
) {
611 _cleanup_netlink_message_unref_ sd_netlink_message
*req
= NULL
, *reply
= NULL
;
612 sd_netlink_message
*addr
;
618 r
= sd_rtnl_message_new_addr(m
->rtnl
, &req
, RTM_GETADDR
, 0, 0);
622 r
= sd_netlink_message_request_dump(req
, true);
626 r
= sd_netlink_call(m
->rtnl
, req
, 0, &reply
);
630 for (addr
= reply
; addr
; addr
= sd_netlink_message_next(addr
)) {
633 m
->enumerating
= true;
635 k
= link_rtnl_process_address(m
->rtnl
, addr
, m
);
639 m
->enumerating
= false;
645 static int set_put_in_addr(Set
*s
, const struct in_addr
*address
) {
651 r
= in_addr_to_string(AF_INET
, (const union in_addr_union
*) address
, &p
);
655 r
= set_consume(s
, p
);
662 static int set_put_in_addrv(Set
*s
, const struct in_addr
*addresses
, int n
) {
666 assert(n
<= 0 || addresses
);
668 for (i
= 0; i
< n
; i
++) {
669 r
= set_put_in_addr(s
, addresses
+i
);
679 static void print_string_set(FILE *f
, const char *field
, Set
*s
) {
689 SET_FOREACH(p
, s
, i
) {
698 int manager_save(Manager
*m
) {
699 _cleanup_set_free_free_ Set
*dns
= NULL
, *ntp
= NULL
, *domains
= NULL
;
702 _cleanup_free_
char *temp_path
= NULL
;
703 _cleanup_fclose_
FILE *f
= NULL
;
704 LinkOperationalState operstate
= LINK_OPERSTATE_OFF
;
705 const char *operstate_str
;
709 assert(m
->state_file
);
711 /* We add all NTP and DNS server to a set, to filter out duplicates */
712 dns
= set_new(&string_hash_ops
);
716 ntp
= set_new(&string_hash_ops
);
720 domains
= set_new(&string_hash_ops
);
724 HASHMAP_FOREACH(link
, m
->links
, i
) {
725 if (link
->flags
& IFF_LOOPBACK
)
728 if (link
->operstate
> operstate
)
729 operstate
= link
->operstate
;
734 /* First add the static configured entries */
735 r
= set_put_strdupv(dns
, link
->network
->dns
);
739 r
= set_put_strdupv(ntp
, link
->network
->ntp
);
743 r
= set_put_strdupv(domains
, link
->network
->domains
);
747 if (!link
->dhcp_lease
)
750 /* Secondly, add the entries acquired via DHCP */
751 if (link
->network
->dhcp_dns
) {
752 const struct in_addr
*addresses
;
754 r
= sd_dhcp_lease_get_dns(link
->dhcp_lease
, &addresses
);
756 r
= set_put_in_addrv(dns
, addresses
, r
);
759 } else if (r
< 0 && r
!= -ENOENT
)
763 if (link
->network
->dhcp_ntp
) {
764 const struct in_addr
*addresses
;
766 r
= sd_dhcp_lease_get_ntp(link
->dhcp_lease
, &addresses
);
768 r
= set_put_in_addrv(ntp
, addresses
, r
);
771 } else if (r
< 0 && r
!= -ENOENT
)
775 if (link
->network
->dhcp_domains
) {
776 const char *domainname
;
778 r
= sd_dhcp_lease_get_domainname(link
->dhcp_lease
, &domainname
);
780 r
= set_put_strdup(domains
, domainname
);
783 } else if (r
!= -ENOENT
)
788 operstate_str
= link_operstate_to_string(operstate
);
789 assert(operstate_str
);
791 r
= fopen_temporary(m
->state_file
, &f
, &temp_path
);
795 fchmod(fileno(f
), 0644);
798 "# This is private data. Do not parse.\n"
799 "OPER_STATE=%s\n", operstate_str
);
801 print_string_set(f
, "DNS=", dns
);
802 print_string_set(f
, "NTP=", ntp
);
803 print_string_set(f
, "DOMAINS=", domains
);
805 r
= fflush_and_check(f
);
809 if (rename(temp_path
, m
->state_file
) < 0) {
814 if (m
->operational_state
!= operstate
) {
815 m
->operational_state
= operstate
;
816 r
= manager_send_changed(m
, "OperationalState", NULL
);
818 log_error_errno(r
, "Could not emit changed OperationalState: %m");
824 (void) unlink(m
->state_file
);
825 (void) unlink(temp_path
);
827 return log_error_errno(r
, "Failed to save network state to %s: %m", m
->state_file
);
830 int manager_address_pool_acquire(Manager
*m
, int family
, unsigned prefixlen
, union in_addr_union
*found
) {
835 assert(prefixlen
> 0);
838 LIST_FOREACH(address_pools
, p
, m
->address_pools
) {
839 if (p
->family
!= family
)
842 r
= address_pool_acquire(p
, prefixlen
, found
);
850 Link
* manager_find_uplink(Manager
*m
, Link
*exclude
) {
851 _cleanup_free_
struct local_address
*gateways
= NULL
;
856 /* Looks for a suitable "uplink", via black magic: an
857 * interface that is up and where the default route with the
858 * highest priority points to. */
860 n
= local_gateways(m
->rtnl
, 0, AF_UNSPEC
, &gateways
);
862 log_warning_errno(n
, "Failed to determine list of default gateways: %m");
866 for (i
= 0; i
< n
; i
++) {
869 link
= hashmap_get(m
->links
, INT_TO_PTR(gateways
[i
].ifindex
));
871 log_debug("Weird, found a gateway for a link we don't now. Ignoring.");
878 if (link
->operstate
< LINK_OPERSTATE_ROUTABLE
)