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 "network-internal.h"
30 #include "libudev-private.h"
31 #include "udev-util.h"
32 #include "rtnl-util.h"
38 const char* const network_dirs[] = {
39 "/etc/systemd/network",
40 "/run/systemd/network",
41 "/usr/lib/systemd/network",
43 "/lib/systemd/network",
47 static int setup_default_address_pool(Manager *m) {
53 /* Add in the well-known private address ranges. */
55 r = address_pool_new_from_string(m, &p, AF_INET6, "fc00::", 7);
59 r = address_pool_new_from_string(m, &p, AF_INET, "192.168.0.0", 16);
63 r = address_pool_new_from_string(m, &p, AF_INET, "172.16.0.0", 12);
67 r = address_pool_new_from_string(m, &p, AF_INET, "10.0.0.0", 8);
74 int manager_new(Manager **ret) {
75 _cleanup_manager_free_ Manager *m = NULL;
82 m->state_file = strdup("/run/systemd/netif/state");
86 r = sd_event_default(&m->event);
90 sd_event_set_watchdog(m->event, true);
92 sd_event_add_signal(m->event, NULL, SIGTERM, NULL, NULL);
93 sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
95 r = sd_rtnl_open(&m->rtnl, 3, RTNLGRP_LINK, RTNLGRP_IPV4_IFADDR,
100 r = sd_bus_default_system(&m->bus);
101 if (r < 0 && r != -ENOENT) /* TODO: drop when we can rely on kdbus */
104 /* udev does not initialize devices inside containers,
105 * so we rely on them being already initialized before
106 * entering the container */
107 if (detect_container(NULL) <= 0) {
108 m->udev = udev_new();
112 m->udev_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
113 if (!m->udev_monitor)
117 m->links = hashmap_new(uint64_hash_func, uint64_compare_func);
121 m->netdevs = hashmap_new(string_hash_func, string_compare_func);
125 LIST_HEAD_INIT(m->networks);
127 r = setup_default_address_pool(m);
137 void manager_free(Manager *m) {
148 udev_monitor_unref(m->udev_monitor);
150 sd_bus_unref(m->bus);
151 sd_event_source_unref(m->udev_event_source);
152 sd_event_source_unref(m->sigterm_event_source);
153 sd_event_source_unref(m->sigint_event_source);
154 sd_event_unref(m->event);
156 while ((link = hashmap_first(m->links)))
158 hashmap_free(m->links);
160 while ((network = m->networks))
161 network_free(network);
163 while ((netdev = hashmap_first(m->netdevs)))
164 netdev_unref(netdev);
165 hashmap_free(m->netdevs);
167 while ((pool = m->address_pools))
168 address_pool_free(pool);
170 sd_rtnl_unref(m->rtnl);
175 int manager_load_config(Manager *m) {
178 /* update timestamp */
179 paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, true);
192 bool manager_should_reload(Manager *m) {
193 return paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, false);
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_rtnl_process_link(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
226 Manager *m = userdata;
228 NetDev *netdev = NULL;
237 r = sd_rtnl_message_get_type(message, &type);
239 log_warning("rtnl: could not get message type");
243 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
244 if (r < 0 || ifindex <= 0) {
245 log_warning("rtnl: received link message without valid ifindex");
248 link_get(m, ifindex, &link);
250 r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &name);
251 if (r < 0 || !name) {
252 log_warning("rtnl: received link message without valid ifname");
255 netdev_get(m, name, &netdev);
260 /* link is new, so add it */
261 r = link_add(m, message, &link);
263 log_debug("could not add new link: %s",
270 /* netdev exists, so make sure the ifindex matches */
271 r = netdev_set_ifindex(netdev, message);
273 log_debug("could not set ifindex on netdev");
278 r = link_update(link, message);
291 assert_not_reached("Received invalid RTNL message type.");
297 int manager_rtnl_enumerate_links(Manager *m) {
298 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
299 sd_rtnl_message *link;
305 r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
309 r = sd_rtnl_message_request_dump(req, true);
313 r = sd_rtnl_call(m->rtnl, req, 0, &reply);
317 for (link = reply; link; link = sd_rtnl_message_next(link)) {
320 k = sd_rtnl_message_get_type(link, &type);
324 if (type != RTM_NEWLINK)
327 k = manager_rtnl_process_link(m->rtnl, link, m);
335 static int manager_dispatch_link_udev(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
336 Manager *m = userdata;
337 struct udev_monitor *monitor = m->udev_monitor;
338 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
340 device = udev_monitor_receive_device(monitor);
344 manager_udev_process_link(m, device);
348 int manager_udev_listen(Manager *m) {
351 if (detect_container(NULL) > 0)
354 assert(m->udev_monitor);
356 r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_monitor, "net", NULL);
358 log_error("Could not add udev monitor filter: %s", strerror(-r));
362 r = udev_monitor_enable_receiving(m->udev_monitor);
364 log_error("Could not enable udev monitor");
368 r = sd_event_add_io(m->event,
369 &m->udev_event_source,
370 udev_monitor_get_fd(m->udev_monitor),
371 EPOLLIN, manager_dispatch_link_udev,
379 int manager_rtnl_listen(Manager *m) {
384 r = sd_rtnl_attach_event(m->rtnl, m->event, 0);
388 r = sd_rtnl_add_match(m->rtnl, RTM_NEWLINK, &manager_rtnl_process_link, m);
392 r = sd_rtnl_add_match(m->rtnl, RTM_DELLINK, &manager_rtnl_process_link, m);
396 r = sd_rtnl_add_match(m->rtnl, RTM_NEWADDR, &link_rtnl_process_address, m);
400 r = sd_rtnl_add_match(m->rtnl, RTM_DELADDR, &link_rtnl_process_address, m);
407 int manager_bus_listen(Manager *m) {
412 if (!m->bus) /* TODO: drop when we can rely on kdbus */
415 r = sd_bus_attach_event(m->bus, m->event, 0);
422 int manager_save(Manager *m) {
425 _cleanup_free_ char *temp_path = NULL;
426 _cleanup_fclose_ FILE *f = NULL;
427 LinkOperationalState operstate = LINK_OPERSTATE_UNKNOWN;
428 const char *operstate_str;
432 assert(m->state_file);
434 HASHMAP_FOREACH(link, m->links, i) {
435 if (link->flags & IFF_LOOPBACK)
438 if (link->operstate > operstate)
439 operstate = link->operstate;
442 operstate_str = link_operstate_to_string(operstate);
443 assert(operstate_str);
445 r = fopen_temporary(m->state_file, &f, &temp_path);
449 fchmod(fileno(f), 0644);
452 "# This is private data. Do not parse.\n"
453 "OPER_STATE=%s\n", operstate_str);
457 if (ferror(f) || rename(temp_path, m->state_file) < 0) {
459 unlink(m->state_file);
465 log_error("Failed to save network state to %s: %s", m->state_file, strerror(-r));
470 int manager_address_pool_acquire(Manager *m, unsigned family, unsigned prefixlen, union in_addr_union *found) {
475 assert(prefixlen > 0);
478 LIST_FOREACH(address_pools, p, m->address_pools) {
479 if (p->family != family)
482 r = address_pool_acquire(p, prefixlen, found);