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 "libudev-private.h"
31 #include "udev-util.h"
32 #include "rtnl-util.h"
38 #include "sd-daemon.h"
40 /* use 8 MB for receive socket kernel queue. */
41 #define RCVBUF_SIZE (8*1024*1024)
43 const char* const network_dirs[] = {
44 "/etc/systemd/network",
45 "/run/systemd/network",
46 "/usr/lib/systemd/network",
48 "/lib/systemd/network",
52 static int setup_default_address_pool(Manager *m) {
58 /* Add in the well-known private address ranges. */
60 r = address_pool_new_from_string(m, &p, AF_INET6, "fc00::", 7);
64 r = address_pool_new_from_string(m, &p, AF_INET, "192.168.0.0", 16);
68 r = address_pool_new_from_string(m, &p, AF_INET, "172.16.0.0", 12);
72 r = address_pool_new_from_string(m, &p, AF_INET, "10.0.0.0", 8);
79 static int on_bus_retry(sd_event_source *s, usec_t usec, void *userdata) {
80 Manager *m = userdata;
85 m->bus_retry_event_source = sd_event_source_unref(m->bus_retry_event_source);
87 manager_connect_bus(m);
92 static int manager_reset_all(Manager *m) {
99 HASHMAP_FOREACH(link, m->links, i) {
100 r = link_carrier_reset(link);
102 log_link_warning_errno(link, r, "could not reset carrier: %m");
108 static int match_prepare_for_sleep(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *ret_error) {
109 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");
152 r = sd_bus_add_match(m->bus, &m->prepare_for_sleep_slot,
154 "sender='org.freedesktop.login1',"
155 "interface='org.freedesktop.login1.Manager',"
156 "member='PrepareForSleep',"
157 "path='/org/freedesktop/login1'",
158 match_prepare_for_sleep,
161 return log_error_errno(r, "Failed to add match for PrepareForSleep: %m");
163 r = sd_bus_add_object_vtable(m->bus, NULL, "/org/freedesktop/network1", "org.freedesktop.network1.Manager", manager_vtable, m);
165 return log_error_errno(r, "Failed to add manager object vtable: %m");
167 r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/network1/link", "org.freedesktop.network1.Link", link_vtable, link_object_find, m);
169 return log_error_errno(r, "Failed to add link object vtable: %m");
171 r = sd_bus_add_node_enumerator(m->bus, NULL, "/org/freedesktop/network1/link", link_node_enumerator, m);
173 return log_error_errno(r, "Failed to add link enumerator: %m");
175 r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/network1/network", "org.freedesktop.network1.Network", network_vtable, network_object_find, m);
177 return log_error_errno(r, "Failed to add network object vtable: %m");
179 r = sd_bus_add_node_enumerator(m->bus, NULL, "/org/freedesktop/network1/network", network_node_enumerator, m);
181 return log_error_errno(r, "Failed to add network enumerator: %m");
183 r = sd_bus_request_name(m->bus, "org.freedesktop.network1", 0);
185 return log_error_errno(r, "Failed to register name: %m");
187 r = sd_bus_attach_event(m->bus, m->event, 0);
189 return log_error_errno(r, "Failed to attach bus to event loop: %m");
194 static int manager_udev_process_link(Manager *m, struct udev_device *device) {
201 if (!streq_ptr(udev_device_get_action(device), "add"))
204 ifindex = udev_device_get_ifindex(device);
206 log_debug("ignoring udev ADD event for device with invalid ifindex");
210 r = link_get(m, ifindex, &link);
216 r = link_initialized(link, device);
223 static int manager_dispatch_link_udev(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
224 Manager *m = userdata;
225 struct udev_monitor *monitor = m->udev_monitor;
226 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
228 device = udev_monitor_receive_device(monitor);
232 manager_udev_process_link(m, device);
236 static int manager_connect_udev(Manager *m) {
239 /* udev does not initialize devices inside containers,
240 * so we rely on them being already initialized before
241 * entering the container */
242 if (detect_container(NULL) > 0)
245 m->udev = udev_new();
249 m->udev_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
250 if (!m->udev_monitor)
253 r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_monitor, "net", NULL);
255 return log_error_errno(r, "Could not add udev monitor filter: %m");
257 r = udev_monitor_enable_receiving(m->udev_monitor);
259 log_error("Could not enable udev monitor");
263 r = sd_event_add_io(m->event,
264 &m->udev_event_source,
265 udev_monitor_get_fd(m->udev_monitor),
266 EPOLLIN, manager_dispatch_link_udev,
271 r = sd_event_source_set_description(m->udev_event_source, "networkd-udev");
278 static int manager_rtnl_process_link(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
279 Manager *m = userdata;
281 NetDev *netdev = NULL;
290 if (sd_rtnl_message_is_error(message)) {
291 r = sd_rtnl_message_get_errno(message);
293 log_warning_errno(r, "rtnl: could not receive link: %m");
298 r = sd_rtnl_message_get_type(message, &type);
300 log_warning_errno(r, "rtnl: could not get message type: %m");
302 } else if (type != RTM_NEWLINK && type != RTM_DELLINK) {
303 log_warning("rtnl: received unexpected message type when processing link");
307 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
309 log_warning_errno(r, "rtnl: could not get ifindex from link: %m");
311 } else if (ifindex <= 0) {
312 log_warning("rtnl: received link message with invalid ifindex: %d", ifindex);
315 link_get(m, ifindex, &link);
317 r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &name);
319 log_warning_errno(r, "rtnl: received link message without ifname: %m");
322 netdev_get(m, name, &netdev);
327 /* link is new, so add it */
328 r = link_add(m, message, &link);
330 log_warning_errno(r, "could not add new link: %m");
336 /* netdev exists, so make sure the ifindex matches */
337 r = netdev_set_ifindex(netdev, message);
339 log_warning_errno(r, "could not set ifindex on netdev: %m");
344 r = link_update(link, message);
357 assert_not_reached("Received invalid RTNL message type.");
363 static int systemd_netlink_fd(void) {
364 int n, fd, rtnl_fd = -EINVAL;
366 n = sd_listen_fds(true);
370 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++) {
371 if (sd_is_socket(fd, AF_NETLINK, SOCK_RAW, -1) > 0) {
382 static int manager_connect_rtnl(Manager *m) {
387 fd = systemd_netlink_fd();
389 r = sd_rtnl_open(&m->rtnl, 3, RTNLGRP_LINK, RTNLGRP_IPV4_IFADDR, RTNLGRP_IPV6_IFADDR);
391 r = sd_rtnl_open_fd(&m->rtnl, fd, 0);
395 r = sd_rtnl_inc_rcvbuf(m->rtnl, RCVBUF_SIZE);
399 r = sd_rtnl_attach_event(m->rtnl, m->event, 0);
403 r = sd_rtnl_add_match(m->rtnl, RTM_NEWLINK, &manager_rtnl_process_link, m);
407 r = sd_rtnl_add_match(m->rtnl, RTM_DELLINK, &manager_rtnl_process_link, m);
411 r = sd_rtnl_add_match(m->rtnl, RTM_NEWADDR, &link_rtnl_process_address, m);
415 r = sd_rtnl_add_match(m->rtnl, RTM_DELADDR, &link_rtnl_process_address, m);
422 int manager_new(Manager **ret) {
423 _cleanup_manager_free_ Manager *m = NULL;
426 m = new0(Manager, 1);
430 m->state_file = strdup("/run/systemd/netif/state");
434 r = sd_event_default(&m->event);
438 sd_event_set_watchdog(m->event, true);
440 sd_event_add_signal(m->event, NULL, SIGTERM, NULL, NULL);
441 sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
443 r = manager_connect_rtnl(m);
447 r = manager_connect_udev(m);
451 m->netdevs = hashmap_new(&string_hash_ops);
455 LIST_HEAD_INIT(m->networks);
457 r = setup_default_address_pool(m);
467 void manager_free(Manager *m) {
478 udev_monitor_unref(m->udev_monitor);
480 sd_bus_unref(m->bus);
481 sd_bus_slot_unref(m->prepare_for_sleep_slot);
482 sd_event_source_unref(m->udev_event_source);
483 sd_event_source_unref(m->bus_retry_event_source);
484 sd_event_unref(m->event);
486 while ((link = hashmap_first(m->links)))
488 hashmap_free(m->links);
490 while ((network = m->networks))
491 network_free(network);
493 hashmap_free(m->networks_by_name);
495 while ((netdev = hashmap_first(m->netdevs)))
496 netdev_unref(netdev);
497 hashmap_free(m->netdevs);
499 while ((pool = m->address_pools))
500 address_pool_free(pool);
502 sd_rtnl_unref(m->rtnl);
507 static bool manager_check_idle(void *userdata) {
508 Manager *m = userdata;
514 HASHMAP_FOREACH(link, m->links, i) {
515 /* we are not woken on udev activity, so let's just wait for the
516 * pending udev event */
517 if (link->state == LINK_STATE_PENDING)
523 /* we are not woken on netork activity, so let's stay around */
524 if (link_lldp_enabled(link) ||
525 link_ipv4ll_enabled(link) ||
526 link_dhcp4_server_enabled(link) ||
527 link_dhcp4_enabled(link) ||
528 link_dhcp6_enabled(link))
535 int manager_run(Manager *m) {
539 return bus_event_loop_with_idle(
542 "org.freedesktop.network1",
547 /* failed to connect to the bus, so we lose exit-on-idle logic,
548 this should not happen except if dbus is not around at all */
549 return sd_event_loop(m->event);
552 int manager_load_config(Manager *m) {
555 /* update timestamp */
556 paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, true);
569 bool manager_should_reload(Manager *m) {
570 return paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, false);
573 int manager_rtnl_enumerate_links(Manager *m) {
574 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
575 sd_rtnl_message *link;
581 r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
585 r = sd_rtnl_message_request_dump(req, true);
589 r = sd_rtnl_call(m->rtnl, req, 0, &reply);
593 for (link = reply; link; link = sd_rtnl_message_next(link)) {
596 m->enumerating = true;
598 k = manager_rtnl_process_link(m->rtnl, link, m);
602 m->enumerating = false;
608 int manager_rtnl_enumerate_addresses(Manager *m) {
609 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
610 sd_rtnl_message *addr;
616 r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, 0, 0);
620 r = sd_rtnl_message_request_dump(req, true);
624 r = sd_rtnl_call(m->rtnl, req, 0, &reply);
628 for (addr = reply; addr; addr = sd_rtnl_message_next(addr)) {
631 m->enumerating = true;
633 k = link_rtnl_process_address(m->rtnl, addr, m);
637 m->enumerating = false;
643 static int set_put_in_addr(Set *s, const struct in_addr *address) {
649 r = in_addr_to_string(AF_INET, (const union in_addr_union*) address, &p);
653 r = set_consume(s, p);
660 static int set_put_in_addrv(Set *s, const struct in_addr *addresses, int n) {
664 assert(n <= 0 || addresses);
666 for (i = 0; i < n; i++) {
667 r = set_put_in_addr(s, addresses+i);
677 static void print_string_set(FILE *f, const char *field, Set *s) {
687 SET_FOREACH(p, s, i) {
696 int manager_save(Manager *m) {
697 _cleanup_set_free_free_ Set *dns = NULL, *ntp = NULL, *domains = NULL;
700 _cleanup_free_ char *temp_path = NULL;
701 _cleanup_fclose_ FILE *f = NULL;
702 LinkOperationalState operstate = LINK_OPERSTATE_OFF;
703 const char *operstate_str;
707 assert(m->state_file);
709 /* We add all NTP and DNS server to a set, to filter out duplicates */
710 dns = set_new(&string_hash_ops);
714 ntp = set_new(&string_hash_ops);
718 domains = set_new(&string_hash_ops);
722 HASHMAP_FOREACH(link, m->links, i) {
723 if (link->flags & IFF_LOOPBACK)
726 if (link->operstate > operstate)
727 operstate = link->operstate;
732 /* First add the static configured entries */
733 r = set_put_strdupv(dns, link->network->dns);
737 r = set_put_strdupv(ntp, link->network->ntp);
741 r = set_put_strdupv(domains, link->network->domains);
745 if (!link->dhcp_lease)
748 /* Secondly, add the entries acquired via DHCP */
749 if (link->network->dhcp_dns) {
750 const struct in_addr *addresses;
752 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
754 r = set_put_in_addrv(dns, addresses, r);
757 } else if (r < 0 && r != -ENOENT)
761 if (link->network->dhcp_ntp) {
762 const struct in_addr *addresses;
764 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
766 r = set_put_in_addrv(ntp, addresses, r);
769 } else if (r < 0 && r != -ENOENT)
773 if (link->network->dhcp_domains) {
774 const char *domainname;
776 r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
778 r = set_put_strdup(domains, domainname);
781 } else if (r != -ENOENT)
786 operstate_str = link_operstate_to_string(operstate);
787 assert(operstate_str);
789 r = fopen_temporary(m->state_file, &f, &temp_path);
793 fchmod(fileno(f), 0644);
796 "# This is private data. Do not parse.\n"
797 "OPER_STATE=%s\n", operstate_str);
799 print_string_set(f, "DNS=", dns);
800 print_string_set(f, "NTP=", ntp);
801 print_string_set(f, "DOMAINS=", domains);
803 r = fflush_and_check(f);
807 if (rename(temp_path, m->state_file) < 0) {
812 if (m->operational_state != operstate) {
813 m->operational_state = operstate;
814 r = manager_send_changed(m, "OperationalState", NULL);
816 log_error_errno(r, "Could not emit changed OperationalState: %m");
822 log_error_errno(r, "Failed to save network state to %s: %m", m->state_file);
823 unlink(m->state_file);
828 int manager_address_pool_acquire(Manager *m, int family, unsigned prefixlen, union in_addr_union *found) {
833 assert(prefixlen > 0);
836 LIST_FOREACH(address_pools, p, m->address_pools) {
837 if (p->family != family)
840 r = address_pool_acquire(p, prefixlen, found);
848 const char *address_family_boolean_to_string(AddressFamilyBoolean b) {
849 if (b == ADDRESS_FAMILY_YES ||
850 b == ADDRESS_FAMILY_NO)
851 return yes_no(b == ADDRESS_FAMILY_YES);
853 if (b == ADDRESS_FAMILY_IPV4)
855 if (b == ADDRESS_FAMILY_IPV6)
861 AddressFamilyBoolean address_family_boolean_from_string(const char *s) {
864 /* Make this a true superset of a boolean */
866 r = parse_boolean(s);
868 return ADDRESS_FAMILY_YES;
870 return ADDRESS_FAMILY_NO;
872 if (streq(s, "ipv4"))
873 return ADDRESS_FAMILY_IPV4;
874 if (streq(s, "ipv6"))
875 return ADDRESS_FAMILY_IPV6;
877 return _ADDRESS_FAMILY_BOOLEAN_INVALID;
880 DEFINE_CONFIG_PARSE_ENUM(config_parse_address_family_boolean, address_family_boolean, AddressFamilyBoolean, "Failed to parse option");