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"
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 systemd_netlink_fd(int *ret) {
80 int n, fd, rtnl_fd = -1;
82 n = sd_listen_fds(true);
86 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++) {
87 if (sd_is_socket(fd, AF_NETLINK, SOCK_RAW, -1) > 0) {
103 int manager_new(Manager **ret) {
104 _cleanup_manager_free_ Manager *m = NULL;
107 m = new0(Manager, 1);
111 m->state_file = strdup("/run/systemd/netif/state");
115 r = sd_event_default(&m->event);
119 sd_event_set_watchdog(m->event, true);
121 sd_event_add_signal(m->event, NULL, SIGTERM, NULL, NULL);
122 sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
124 if (systemd_netlink_fd(&fd) < 0) {
125 r = sd_rtnl_open(&m->rtnl, 3, RTNLGRP_LINK, RTNLGRP_IPV4_IFADDR,
126 RTNLGRP_IPV6_IFADDR);
130 r = sd_rtnl_inc_rcvbuf(m->rtnl, RCVBUF_SIZE);
134 r = sd_rtnl_new_from_netlink(&m->rtnl, fd);
139 r = sd_bus_default_system(&m->bus);
140 if (r < 0 && r != -ENOENT) /* TODO: drop when we can rely on kdbus */
143 /* udev does not initialize devices inside containers,
144 * so we rely on them being already initialized before
145 * entering the container */
146 if (detect_container(NULL) <= 0) {
147 m->udev = udev_new();
151 m->udev_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
152 if (!m->udev_monitor)
156 m->netdevs = hashmap_new(&string_hash_ops);
160 LIST_HEAD_INIT(m->networks);
162 r = setup_default_address_pool(m);
172 void manager_free(Manager *m) {
183 udev_monitor_unref(m->udev_monitor);
185 sd_bus_unref(m->bus);
186 sd_event_source_unref(m->udev_event_source);
187 sd_event_unref(m->event);
189 while ((link = hashmap_first(m->links)))
191 hashmap_free(m->links);
193 while ((network = m->networks))
194 network_free(network);
196 while ((netdev = hashmap_first(m->netdevs)))
197 netdev_unref(netdev);
198 hashmap_free(m->netdevs);
200 while ((pool = m->address_pools))
201 address_pool_free(pool);
203 sd_rtnl_unref(m->rtnl);
208 int manager_load_config(Manager *m) {
211 /* update timestamp */
212 paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, true);
225 bool manager_should_reload(Manager *m) {
226 return paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, false);
229 static int manager_udev_process_link(Manager *m, struct udev_device *device) {
236 if (!streq_ptr(udev_device_get_action(device), "add"))
239 ifindex = udev_device_get_ifindex(device);
241 log_debug("ignoring udev ADD event for device with invalid ifindex");
245 r = link_get(m, ifindex, &link);
251 r = link_initialized(link, device);
258 static int manager_rtnl_process_link(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
259 Manager *m = userdata;
261 NetDev *netdev = NULL;
270 if (sd_rtnl_message_is_error(message)) {
271 r = sd_rtnl_message_get_errno(message);
273 log_warning_errno(r, "rtnl: could not receive link: %m");
278 r = sd_rtnl_message_get_type(message, &type);
280 log_warning_errno(r, "rtnl: could not get message type: %m");
284 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
286 log_warning_errno(r, "rtnl: could not get ifindex: %m");
288 } else if (ifindex <= 0) {
289 log_warning("rtnl: received link message with invalid ifindex: %d", ifindex);
292 link_get(m, ifindex, &link);
294 r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &name);
296 log_warning_errno(r, "rtnl: received link message without ifname: %m");
299 netdev_get(m, name, &netdev);
304 /* link is new, so add it */
305 r = link_add(m, message, &link);
307 log_warning_errno(r, "could not add new link: %m");
313 /* netdev exists, so make sure the ifindex matches */
314 r = netdev_set_ifindex(netdev, message);
316 log_warning_errno(r, "could not set ifindex on netdev: %m");
321 r = link_update(link, message);
334 assert_not_reached("Received invalid RTNL message type.");
340 int manager_rtnl_enumerate_links(Manager *m) {
341 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
342 sd_rtnl_message *link;
348 r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
352 r = sd_rtnl_message_request_dump(req, true);
356 r = sd_rtnl_call(m->rtnl, req, 0, &reply);
360 for (link = reply; link; link = sd_rtnl_message_next(link)) {
363 k = manager_rtnl_process_link(m->rtnl, link, m);
371 int manager_rtnl_enumerate_addresses(Manager *m) {
372 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
373 sd_rtnl_message *addr;
379 r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, 0, 0);
383 r = sd_rtnl_message_request_dump(req, true);
387 r = sd_rtnl_call(m->rtnl, req, 0, &reply);
391 for (addr = reply; addr; addr = sd_rtnl_message_next(addr)) {
394 k = link_rtnl_process_address(m->rtnl, addr, m);
402 static int manager_dispatch_link_udev(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
403 Manager *m = userdata;
404 struct udev_monitor *monitor = m->udev_monitor;
405 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
407 device = udev_monitor_receive_device(monitor);
411 manager_udev_process_link(m, device);
415 int manager_udev_listen(Manager *m) {
418 if (detect_container(NULL) > 0)
421 assert(m->udev_monitor);
423 r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_monitor, "net", NULL);
425 return log_error_errno(r, "Could not add udev monitor filter: %m");
427 r = udev_monitor_enable_receiving(m->udev_monitor);
429 log_error("Could not enable udev monitor");
433 r = sd_event_add_io(m->event,
434 &m->udev_event_source,
435 udev_monitor_get_fd(m->udev_monitor),
436 EPOLLIN, manager_dispatch_link_udev,
441 r = sd_event_source_set_description(m->udev_event_source, "networkd-udev");
448 int manager_rtnl_listen(Manager *m) {
453 r = sd_rtnl_attach_event(m->rtnl, m->event, 0);
457 r = sd_rtnl_add_match(m->rtnl, RTM_NEWLINK, &manager_rtnl_process_link, m);
461 r = sd_rtnl_add_match(m->rtnl, RTM_DELLINK, &manager_rtnl_process_link, m);
465 r = sd_rtnl_add_match(m->rtnl, RTM_NEWADDR, &link_rtnl_process_address, m);
469 r = sd_rtnl_add_match(m->rtnl, RTM_DELADDR, &link_rtnl_process_address, m);
476 int manager_bus_listen(Manager *m) {
481 if (!m->bus) /* TODO: drop when we can rely on kdbus */
484 r = sd_bus_attach_event(m->bus, m->event, 0);
491 static int set_put_in_addr(Set *s, const struct in_addr *address) {
497 r = in_addr_to_string(AF_INET, (const union in_addr_union*) address, &p);
501 r = set_consume(s, p);
508 static int set_put_in_addrv(Set *s, const struct in_addr *addresses, int n) {
512 assert(n <= 0 || addresses);
514 for (i = 0; i < n; i++) {
515 r = set_put_in_addr(s, addresses+i);
525 static void print_string_set(FILE *f, const char *field, Set *s) {
535 SET_FOREACH(p, s, i) {
544 int manager_save(Manager *m) {
545 _cleanup_set_free_free_ Set *dns = NULL, *ntp = NULL, *domains = NULL;
548 _cleanup_free_ char *temp_path = NULL;
549 _cleanup_fclose_ FILE *f = NULL;
550 LinkOperationalState operstate = LINK_OPERSTATE_OFF;
551 const char *operstate_str;
555 assert(m->state_file);
557 /* We add all NTP and DNS server to a set, to filter out duplicates */
558 dns = set_new(&string_hash_ops);
562 ntp = set_new(&string_hash_ops);
566 domains = set_new(&string_hash_ops);
570 HASHMAP_FOREACH(link, m->links, i) {
571 if (link->flags & IFF_LOOPBACK)
574 if (link->operstate > operstate)
575 operstate = link->operstate;
580 /* First add the static configured entries */
581 r = set_put_strdupv(dns, link->network->dns);
585 r = set_put_strdupv(ntp, link->network->ntp);
589 r = set_put_strdupv(domains, link->network->domains);
593 if (!link->dhcp_lease)
596 /* Secondly, add the entries acquired via DHCP */
597 if (link->network->dhcp_dns) {
598 const struct in_addr *addresses;
600 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
602 r = set_put_in_addrv(dns, addresses, r);
605 } else if (r < 0 && r != -ENOENT)
609 if (link->network->dhcp_ntp) {
610 const struct in_addr *addresses;
612 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
614 r = set_put_in_addrv(ntp, addresses, r);
617 } else if (r < 0 && r != -ENOENT)
621 if (link->network->dhcp_domains) {
622 const char *domainname;
624 r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
626 r = set_put_strdup(domains, domainname);
629 } else if (r != -ENOENT)
634 operstate_str = link_operstate_to_string(operstate);
635 assert(operstate_str);
637 r = fopen_temporary(m->state_file, &f, &temp_path);
641 fchmod(fileno(f), 0644);
644 "# This is private data. Do not parse.\n"
645 "OPER_STATE=%s\n", operstate_str);
647 print_string_set(f, "DNS=", dns);
648 print_string_set(f, "NTP=", ntp);
649 print_string_set(f, "DOMAINS=", domains);
651 r = fflush_and_check(f);
655 if (rename(temp_path, m->state_file) < 0) {
663 log_error_errno(r, "Failed to save network state to %s: %m", m->state_file);
664 unlink(m->state_file);
669 int manager_address_pool_acquire(Manager *m, int family, unsigned prefixlen, union in_addr_union *found) {
674 assert(prefixlen > 0);
677 LIST_FOREACH(address_pools, p, m->address_pools) {
678 if (p->family != family)
681 r = address_pool_acquire(p, prefixlen, found);
689 const char *address_family_boolean_to_string(AddressFamilyBoolean b) {
690 if (b == ADDRESS_FAMILY_YES ||
691 b == ADDRESS_FAMILY_NO)
692 return yes_no(b == ADDRESS_FAMILY_YES);
694 if (b == ADDRESS_FAMILY_IPV4)
696 if (b == ADDRESS_FAMILY_IPV6)
702 AddressFamilyBoolean address_family_boolean_from_string(const char *s) {
705 /* Make this a true superset of a boolean */
707 r = parse_boolean(s);
709 return ADDRESS_FAMILY_YES;
711 return ADDRESS_FAMILY_NO;
713 if (streq(s, "ipv4"))
714 return ADDRESS_FAMILY_IPV4;
715 if (streq(s, "ipv6"))
716 return ADDRESS_FAMILY_IPV6;
718 return _ADDRESS_FAMILY_BOOLEAN_INVALID;
721 DEFINE_CONFIG_PARSE_ENUM(config_parse_address_family_boolean, address_family_boolean, AddressFamilyBoolean, "Failed to parse option");