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 static int on_bus_retry(sd_event_source *s, usec_t usec, void *userdata) {
82 Manager *m = userdata;
87 m->bus_retry_event_source = sd_event_source_unref(m->bus_retry_event_source);
89 manager_connect_bus(m);
94 static int manager_reset_all(Manager *m) {
101 HASHMAP_FOREACH(link, m->links, i) {
102 r = link_carrier_reset(link);
104 log_link_warning_errno(link, r, "could not reset carrier: %m");
110 static int match_prepare_for_sleep(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *ret_error) {
111 Manager *m = userdata;
117 r = sd_bus_message_read(message, "b", &b);
119 log_debug_errno(r, "Failed to parse PrepareForSleep signal: %m");
126 log_debug("Coming back from suspend, resetting all connections...");
128 manager_reset_all(m);
133 int manager_connect_bus(Manager *m) {
138 r = sd_bus_default_system(&m->bus);
140 /* We failed to connect? Yuck, we must be in early
141 * boot. Let's try in 5s again. As soon as we have
142 * kdbus we can stop doing this... */
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");
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_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
281 Manager *m = userdata;
283 NetDev *netdev = NULL;
292 if (sd_rtnl_message_is_error(message)) {
293 r = sd_rtnl_message_get_errno(message);
295 log_warning_errno(r, "rtnl: could not receive link: %m");
300 r = sd_rtnl_message_get_type(message, &type);
302 log_warning_errno(r, "rtnl: could not get message type: %m");
306 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
308 log_warning_errno(r, "rtnl: could not get ifindex: %m");
310 } else if (ifindex <= 0) {
311 log_warning("rtnl: received link message with invalid ifindex: %d", ifindex);
314 link_get(m, ifindex, &link);
316 r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &name);
318 log_warning_errno(r, "rtnl: received link message without ifname: %m");
321 netdev_get(m, name, &netdev);
326 /* link is new, so add it */
327 r = link_add(m, message, &link);
329 log_warning_errno(r, "could not add new link: %m");
335 /* netdev exists, so make sure the ifindex matches */
336 r = netdev_set_ifindex(netdev, message);
338 log_warning_errno(r, "could not set ifindex on netdev: %m");
343 r = link_update(link, message);
356 assert_not_reached("Received invalid RTNL message type.");
362 static int systemd_netlink_fd(void) {
363 int n, fd, rtnl_fd = -EINVAL;
365 n = sd_listen_fds(true);
369 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++) {
370 if (sd_is_socket(fd, AF_NETLINK, SOCK_RAW, -1) > 0) {
381 static int manager_connect_rtnl(Manager *m) {
386 fd = systemd_netlink_fd();
388 r = sd_rtnl_open(&m->rtnl, 3, RTNLGRP_LINK, RTNLGRP_IPV4_IFADDR, RTNLGRP_IPV6_IFADDR);
390 r = sd_rtnl_open_fd(&m->rtnl, fd, 0);
394 r = sd_rtnl_inc_rcvbuf(m->rtnl, RCVBUF_SIZE);
398 r = sd_rtnl_attach_event(m->rtnl, m->event, 0);
402 r = sd_rtnl_add_match(m->rtnl, RTM_NEWLINK, &manager_rtnl_process_link, m);
406 r = sd_rtnl_add_match(m->rtnl, RTM_DELLINK, &manager_rtnl_process_link, m);
410 r = sd_rtnl_add_match(m->rtnl, RTM_NEWADDR, &link_rtnl_process_address, m);
414 r = sd_rtnl_add_match(m->rtnl, RTM_DELADDR, &link_rtnl_process_address, m);
421 int manager_new(Manager **ret) {
422 _cleanup_manager_free_ Manager *m = NULL;
425 m = new0(Manager, 1);
429 m->state_file = strdup("/run/systemd/netif/state");
433 r = sd_event_default(&m->event);
437 sd_event_set_watchdog(m->event, true);
439 sd_event_add_signal(m->event, NULL, SIGTERM, NULL, NULL);
440 sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
442 r = manager_connect_rtnl(m);
446 r = manager_connect_udev(m);
450 m->netdevs = hashmap_new(&string_hash_ops);
454 LIST_HEAD_INIT(m->networks);
456 r = setup_default_address_pool(m);
466 void manager_free(Manager *m) {
477 udev_monitor_unref(m->udev_monitor);
479 sd_bus_unref(m->bus);
480 sd_bus_slot_unref(m->prepare_for_sleep_slot);
481 sd_event_source_unref(m->udev_event_source);
482 sd_event_source_unref(m->bus_retry_event_source);
483 sd_event_unref(m->event);
485 while ((link = hashmap_first(m->links)))
487 hashmap_free(m->links);
489 while ((network = m->networks))
490 network_free(network);
492 hashmap_free(m->networks_by_name);
494 while ((netdev = hashmap_first(m->netdevs)))
495 netdev_unref(netdev);
496 hashmap_free(m->netdevs);
498 while ((pool = m->address_pools))
499 address_pool_free(pool);
501 sd_rtnl_unref(m->rtnl);
506 static bool manager_check_idle(void *userdata) {
507 Manager *m = userdata;
513 HASHMAP_FOREACH(link, m->links, i) {
514 /* we are not woken on udev activity, so let's just wait for the
515 * pending udev event */
516 if (link->state == LINK_STATE_PENDING)
522 /* we are not woken on netork activity, so let's stay around */
523 if (link_lldp_enabled(link) ||
524 link_ipv4ll_enabled(link) ||
525 link_dhcp4_server_enabled(link) ||
526 link_dhcp4_enabled(link) ||
527 link_dhcp6_enabled(link))
534 int manager_run(Manager *m) {
538 return bus_event_loop_with_idle(
541 "org.freedesktop.network1",
546 /* failed to connect to the bus, so we lose exit-on-idle logic,
547 this should not happen except if dbus is not around at all */
548 return sd_event_loop(m->event);
551 int manager_load_config(Manager *m) {
554 /* update timestamp */
555 paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, true);
568 bool manager_should_reload(Manager *m) {
569 return paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, false);
572 int manager_rtnl_enumerate_links(Manager *m) {
573 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
574 sd_rtnl_message *link;
580 r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
584 r = sd_rtnl_message_request_dump(req, true);
588 r = sd_rtnl_call(m->rtnl, req, 0, &reply);
592 for (link = reply; link; link = sd_rtnl_message_next(link)) {
595 m->enumerating = true;
597 k = manager_rtnl_process_link(m->rtnl, link, m);
601 m->enumerating = false;
607 int manager_rtnl_enumerate_addresses(Manager *m) {
608 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
609 sd_rtnl_message *addr;
615 r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, 0, 0);
619 r = sd_rtnl_message_request_dump(req, true);
623 r = sd_rtnl_call(m->rtnl, req, 0, &reply);
627 for (addr = reply; addr; addr = sd_rtnl_message_next(addr)) {
630 m->enumerating = true;
632 k = link_rtnl_process_address(m->rtnl, addr, m);
636 m->enumerating = false;
642 static int set_put_in_addr(Set *s, const struct in_addr *address) {
648 r = in_addr_to_string(AF_INET, (const union in_addr_union*) address, &p);
652 r = set_consume(s, p);
659 static int set_put_in_addrv(Set *s, const struct in_addr *addresses, int n) {
663 assert(n <= 0 || addresses);
665 for (i = 0; i < n; i++) {
666 r = set_put_in_addr(s, addresses+i);
676 static void print_string_set(FILE *f, const char *field, Set *s) {
686 SET_FOREACH(p, s, i) {
695 int manager_save(Manager *m) {
696 _cleanup_set_free_free_ Set *dns = NULL, *ntp = NULL, *domains = NULL;
699 _cleanup_free_ char *temp_path = NULL;
700 _cleanup_fclose_ FILE *f = NULL;
701 LinkOperationalState operstate = LINK_OPERSTATE_OFF;
702 const char *operstate_str;
706 assert(m->state_file);
708 /* We add all NTP and DNS server to a set, to filter out duplicates */
709 dns = set_new(&string_hash_ops);
713 ntp = set_new(&string_hash_ops);
717 domains = set_new(&string_hash_ops);
721 HASHMAP_FOREACH(link, m->links, i) {
722 if (link->flags & IFF_LOOPBACK)
725 if (link->operstate > operstate)
726 operstate = link->operstate;
731 /* First add the static configured entries */
732 r = set_put_strdupv(dns, link->network->dns);
736 r = set_put_strdupv(ntp, link->network->ntp);
740 r = set_put_strdupv(domains, link->network->domains);
744 if (!link->dhcp_lease)
747 /* Secondly, add the entries acquired via DHCP */
748 if (link->network->dhcp_dns) {
749 const struct in_addr *addresses;
751 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
753 r = set_put_in_addrv(dns, addresses, r);
756 } else if (r < 0 && r != -ENOENT)
760 if (link->network->dhcp_ntp) {
761 const struct in_addr *addresses;
763 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
765 r = set_put_in_addrv(ntp, addresses, r);
768 } else if (r < 0 && r != -ENOENT)
772 if (link->network->dhcp_domains) {
773 const char *domainname;
775 r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
777 r = set_put_strdup(domains, domainname);
780 } else if (r != -ENOENT)
785 operstate_str = link_operstate_to_string(operstate);
786 assert(operstate_str);
788 r = fopen_temporary(m->state_file, &f, &temp_path);
792 fchmod(fileno(f), 0644);
795 "# This is private data. Do not parse.\n"
796 "OPER_STATE=%s\n", operstate_str);
798 print_string_set(f, "DNS=", dns);
799 print_string_set(f, "NTP=", ntp);
800 print_string_set(f, "DOMAINS=", domains);
802 r = fflush_and_check(f);
806 if (rename(temp_path, m->state_file) < 0) {
811 if (m->operational_state != operstate) {
812 m->operational_state = operstate;
813 r = manager_send_changed(m, "OperationalState", NULL);
815 log_error_errno(r, "Could not emit changed OperationalState: %m");
821 log_error_errno(r, "Failed to save network state to %s: %m", m->state_file);
822 unlink(m->state_file);
827 int manager_address_pool_acquire(Manager *m, int family, unsigned prefixlen, union in_addr_union *found) {
832 assert(prefixlen > 0);
835 LIST_FOREACH(address_pools, p, m->address_pools) {
836 if (p->family != family)
839 r = address_pool_acquire(p, prefixlen, found);
847 const char *address_family_boolean_to_string(AddressFamilyBoolean b) {
848 if (b == ADDRESS_FAMILY_YES ||
849 b == ADDRESS_FAMILY_NO)
850 return yes_no(b == ADDRESS_FAMILY_YES);
852 if (b == ADDRESS_FAMILY_IPV4)
854 if (b == ADDRESS_FAMILY_IPV6)
860 AddressFamilyBoolean address_family_boolean_from_string(const char *s) {
863 /* Make this a true superset of a boolean */
865 r = parse_boolean(s);
867 return ADDRESS_FAMILY_YES;
869 return ADDRESS_FAMILY_NO;
871 if (streq(s, "ipv4"))
872 return ADDRESS_FAMILY_IPV4;
873 if (streq(s, "ipv6"))
874 return ADDRESS_FAMILY_IPV6;
876 return _ADDRESS_FAMILY_BOOLEAN_INVALID;
879 DEFINE_CONFIG_PARSE_ENUM(config_parse_address_family_boolean, address_family_boolean, AddressFamilyBoolean, "Failed to parse option");