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 "conf-parser.h"
26 #include "path-util.h"
28 #include "networkd-netdev.h"
29 #include "networkd-link.h"
30 #include "network-internal.h"
31 #include "libudev-private.h"
32 #include "udev-util.h"
33 #include "rtnl-util.h"
40 #include "sd-daemon.h"
42 /* use 8 MB for receive socket kernel queue. */
43 #define RCVBUF_SIZE (8*1024*1024)
45 const char* const network_dirs[] = {
46 "/etc/systemd/network",
47 "/run/systemd/network",
48 "/usr/lib/systemd/network",
50 "/lib/systemd/network",
54 static int setup_default_address_pool(Manager *m) {
60 /* Add in the well-known private address ranges. */
62 r = address_pool_new_from_string(m, &p, AF_INET6, "fc00::", 7);
66 r = address_pool_new_from_string(m, &p, AF_INET, "192.168.0.0", 16);
70 r = address_pool_new_from_string(m, &p, AF_INET, "172.16.0.0", 12);
74 r = address_pool_new_from_string(m, &p, AF_INET, "10.0.0.0", 8);
81 int manager_connect_bus(Manager *m);
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 *bus, sd_bus_message *message, void *userdata, sd_bus_error *ret_error) {
113 Manager *m = userdata;
119 r = sd_bus_message_read(message, "b", &b);
121 log_debug_errno(r, "Failed to parse PrepareForSleep signal: %m");
128 log_debug("Coming back from suspend, resetting all connections...");
130 manager_reset_all(m);
135 int manager_connect_bus(Manager *m) {
140 r = sd_bus_default_system(&m->bus);
142 /* We failed to connect? Yuck, we must be in early
143 * boot. Let's try in 5s again. As soon as we have
144 * kdbus we can stop doing this... */
146 log_debug_errno(r, "Failed to connect to bus, trying again in 5s: %m");
148 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);
150 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_request_name(m->bus, "org.freedesktop.network1", 0);
181 return log_error_errno(r, "Failed to register name: %m");
183 r = sd_bus_attach_event(m->bus, m->event, 0);
185 return log_error_errno(r, "Failed to attach bus to event loop: %m");
190 static int manager_udev_process_link(Manager *m, struct udev_device *device) {
197 if (!streq_ptr(udev_device_get_action(device), "add"))
200 ifindex = udev_device_get_ifindex(device);
202 log_debug("ignoring udev ADD event for device with invalid ifindex");
206 r = link_get(m, ifindex, &link);
212 r = link_initialized(link, device);
219 static int manager_dispatch_link_udev(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
220 Manager *m = userdata;
221 struct udev_monitor *monitor = m->udev_monitor;
222 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
224 device = udev_monitor_receive_device(monitor);
228 manager_udev_process_link(m, device);
232 static int manager_connect_udev(Manager *m) {
235 /* udev does not initialize devices inside containers,
236 * so we rely on them being already initialized before
237 * entering the container */
238 if (detect_container(NULL) > 0)
241 m->udev = udev_new();
245 m->udev_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
246 if (!m->udev_monitor)
249 r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_monitor, "net", NULL);
251 return log_error_errno(r, "Could not add udev monitor filter: %m");
253 r = udev_monitor_enable_receiving(m->udev_monitor);
255 log_error("Could not enable udev monitor");
259 r = sd_event_add_io(m->event,
260 &m->udev_event_source,
261 udev_monitor_get_fd(m->udev_monitor),
262 EPOLLIN, manager_dispatch_link_udev,
267 r = sd_event_source_set_description(m->udev_event_source, "networkd-udev");
274 static int manager_rtnl_process_link(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
275 Manager *m = userdata;
277 NetDev *netdev = NULL;
286 if (sd_rtnl_message_is_error(message)) {
287 r = sd_rtnl_message_get_errno(message);
289 log_warning_errno(r, "rtnl: could not receive link: %m");
294 r = sd_rtnl_message_get_type(message, &type);
296 log_warning_errno(r, "rtnl: could not get message type: %m");
300 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
302 log_warning_errno(r, "rtnl: could not get ifindex: %m");
304 } else if (ifindex <= 0) {
305 log_warning("rtnl: received link message with invalid ifindex: %d", ifindex);
308 link_get(m, ifindex, &link);
310 r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &name);
312 log_warning_errno(r, "rtnl: received link message without ifname: %m");
315 netdev_get(m, name, &netdev);
320 /* link is new, so add it */
321 r = link_add(m, message, &link);
323 log_warning_errno(r, "could not add new link: %m");
329 /* netdev exists, so make sure the ifindex matches */
330 r = netdev_set_ifindex(netdev, message);
332 log_warning_errno(r, "could not set ifindex on netdev: %m");
337 r = link_update(link, message);
350 assert_not_reached("Received invalid RTNL message type.");
356 static int systemd_netlink_fd(void) {
357 int n, fd, rtnl_fd = -EINVAL;
359 n = sd_listen_fds(true);
363 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++) {
364 if (sd_is_socket(fd, AF_NETLINK, SOCK_RAW, -1) > 0) {
375 static int manager_connect_rtnl(Manager *m) {
380 fd = systemd_netlink_fd();
382 r = sd_rtnl_open(&m->rtnl, 3, RTNLGRP_LINK, RTNLGRP_IPV4_IFADDR, RTNLGRP_IPV6_IFADDR);
384 r = sd_rtnl_open_fd(&m->rtnl, fd, 0);
388 r = sd_rtnl_inc_rcvbuf(m->rtnl, RCVBUF_SIZE);
392 r = sd_rtnl_attach_event(m->rtnl, m->event, 0);
396 r = sd_rtnl_add_match(m->rtnl, RTM_NEWLINK, &manager_rtnl_process_link, m);
400 r = sd_rtnl_add_match(m->rtnl, RTM_DELLINK, &manager_rtnl_process_link, m);
404 r = sd_rtnl_add_match(m->rtnl, RTM_NEWADDR, &link_rtnl_process_address, m);
408 r = sd_rtnl_add_match(m->rtnl, RTM_DELADDR, &link_rtnl_process_address, m);
415 int manager_new(Manager **ret) {
416 _cleanup_manager_free_ Manager *m = NULL;
419 m = new0(Manager, 1);
423 m->state_file = strdup("/run/systemd/netif/state");
427 r = sd_event_default(&m->event);
431 sd_event_set_watchdog(m->event, true);
433 sd_event_add_signal(m->event, NULL, SIGTERM, NULL, NULL);
434 sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
436 r = manager_connect_rtnl(m);
440 r = manager_connect_bus(m);
444 r = manager_connect_udev(m);
448 m->netdevs = hashmap_new(&string_hash_ops);
452 LIST_HEAD_INIT(m->networks);
454 r = setup_default_address_pool(m);
464 void manager_free(Manager *m) {
475 udev_monitor_unref(m->udev_monitor);
477 sd_bus_unref(m->bus);
478 sd_bus_slot_unref(m->prepare_for_sleep_slot);
479 sd_event_source_unref(m->udev_event_source);
480 sd_event_source_unref(m->bus_retry_event_source);
481 sd_event_unref(m->event);
483 while ((link = hashmap_first(m->links)))
485 hashmap_free(m->links);
487 while ((network = m->networks))
488 network_free(network);
490 while ((netdev = hashmap_first(m->netdevs)))
491 netdev_unref(netdev);
492 hashmap_free(m->netdevs);
494 while ((pool = m->address_pools))
495 address_pool_free(pool);
497 sd_rtnl_unref(m->rtnl);
502 static bool manager_check_idle(void *userdata) {
503 Manager *m = userdata;
509 HASHMAP_FOREACH(link, m->links, i) {
510 /* we are not woken on udev activity, so let's just wait for the
511 * pending udev event */
512 if (link->state == LINK_STATE_PENDING)
518 /* we are not woken on netork activity, so let's stay around */
519 if (link_lldp_enabled(link) ||
520 link_ipv4ll_enabled(link) ||
521 link_dhcp4_server_enabled(link) ||
522 link_dhcp4_enabled(link) ||
523 link_dhcp6_enabled(link))
530 int manager_run(Manager *m) {
533 return bus_event_loop_with_idle(
536 "org.freedesktop.network1",
542 int manager_load_config(Manager *m) {
545 /* update timestamp */
546 paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, true);
559 bool manager_should_reload(Manager *m) {
560 return paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, false);
563 int manager_rtnl_enumerate_links(Manager *m) {
564 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
565 sd_rtnl_message *link;
571 r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
575 r = sd_rtnl_message_request_dump(req, true);
579 r = sd_rtnl_call(m->rtnl, req, 0, &reply);
583 for (link = reply; link; link = sd_rtnl_message_next(link)) {
586 m->enumerating = true;
588 k = manager_rtnl_process_link(m->rtnl, link, m);
592 m->enumerating = false;
598 int manager_rtnl_enumerate_addresses(Manager *m) {
599 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
600 sd_rtnl_message *addr;
606 r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, 0, 0);
610 r = sd_rtnl_message_request_dump(req, true);
614 r = sd_rtnl_call(m->rtnl, req, 0, &reply);
618 for (addr = reply; addr; addr = sd_rtnl_message_next(addr)) {
621 m->enumerating = true;
623 k = link_rtnl_process_address(m->rtnl, addr, m);
627 m->enumerating = false;
633 static int set_put_in_addr(Set *s, const struct in_addr *address) {
639 r = in_addr_to_string(AF_INET, (const union in_addr_union*) address, &p);
643 r = set_consume(s, p);
650 static int set_put_in_addrv(Set *s, const struct in_addr *addresses, int n) {
654 assert(n <= 0 || addresses);
656 for (i = 0; i < n; i++) {
657 r = set_put_in_addr(s, addresses+i);
667 static void print_string_set(FILE *f, const char *field, Set *s) {
677 SET_FOREACH(p, s, i) {
686 int manager_save(Manager *m) {
687 _cleanup_set_free_free_ Set *dns = NULL, *ntp = NULL, *domains = NULL;
690 _cleanup_free_ char *temp_path = NULL;
691 _cleanup_fclose_ FILE *f = NULL;
692 LinkOperationalState operstate = LINK_OPERSTATE_OFF;
693 const char *operstate_str;
697 assert(m->state_file);
699 /* We add all NTP and DNS server to a set, to filter out duplicates */
700 dns = set_new(&string_hash_ops);
704 ntp = set_new(&string_hash_ops);
708 domains = set_new(&string_hash_ops);
712 HASHMAP_FOREACH(link, m->links, i) {
713 if (link->flags & IFF_LOOPBACK)
716 if (link->operstate > operstate)
717 operstate = link->operstate;
722 /* First add the static configured entries */
723 r = set_put_strdupv(dns, link->network->dns);
727 r = set_put_strdupv(ntp, link->network->ntp);
731 r = set_put_strdupv(domains, link->network->domains);
735 if (!link->dhcp_lease)
738 /* Secondly, add the entries acquired via DHCP */
739 if (link->network->dhcp_dns) {
740 const struct in_addr *addresses;
742 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
744 r = set_put_in_addrv(dns, addresses, r);
747 } else if (r < 0 && r != -ENOENT)
751 if (link->network->dhcp_ntp) {
752 const struct in_addr *addresses;
754 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
756 r = set_put_in_addrv(ntp, addresses, r);
759 } else if (r < 0 && r != -ENOENT)
763 if (link->network->dhcp_domains) {
764 const char *domainname;
766 r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
768 r = set_put_strdup(domains, domainname);
771 } else if (r != -ENOENT)
776 operstate_str = link_operstate_to_string(operstate);
777 assert(operstate_str);
779 r = fopen_temporary(m->state_file, &f, &temp_path);
783 fchmod(fileno(f), 0644);
786 "# This is private data. Do not parse.\n"
787 "OPER_STATE=%s\n", operstate_str);
789 print_string_set(f, "DNS=", dns);
790 print_string_set(f, "NTP=", ntp);
791 print_string_set(f, "DOMAINS=", domains);
793 r = fflush_and_check(f);
797 if (rename(temp_path, m->state_file) < 0) {
802 if (m->operational_state != operstate) {
803 m->operational_state = operstate;
804 r = manager_send_changed(m, "OperationalState", NULL);
806 log_error_errno(r, "Could not emit changed OperationalState: %m");
812 log_error_errno(r, "Failed to save network state to %s: %m", m->state_file);
813 unlink(m->state_file);
818 int manager_address_pool_acquire(Manager *m, int family, unsigned prefixlen, union in_addr_union *found) {
823 assert(prefixlen > 0);
826 LIST_FOREACH(address_pools, p, m->address_pools) {
827 if (p->family != family)
830 r = address_pool_acquire(p, prefixlen, found);
838 const char *address_family_boolean_to_string(AddressFamilyBoolean b) {
839 if (b == ADDRESS_FAMILY_YES ||
840 b == ADDRESS_FAMILY_NO)
841 return yes_no(b == ADDRESS_FAMILY_YES);
843 if (b == ADDRESS_FAMILY_IPV4)
845 if (b == ADDRESS_FAMILY_IPV6)
851 AddressFamilyBoolean address_family_boolean_from_string(const char *s) {
854 /* Make this a true superset of a boolean */
856 r = parse_boolean(s);
858 return ADDRESS_FAMILY_YES;
860 return ADDRESS_FAMILY_NO;
862 if (streq(s, "ipv4"))
863 return ADDRESS_FAMILY_IPV4;
864 if (streq(s, "ipv6"))
865 return ADDRESS_FAMILY_IPV6;
867 return _ADDRESS_FAMILY_BOOLEAN_INVALID;
870 DEFINE_CONFIG_PARSE_ENUM(config_parse_address_family_boolean, address_family_boolean, AddressFamilyBoolean, "Failed to parse option");