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->netdevs = hashmap_new(string_hash_func, string_compare_func);
121 LIST_HEAD_INIT(m->networks);
123 r = setup_default_address_pool(m);
133 void manager_free(Manager *m) {
144 udev_monitor_unref(m->udev_monitor);
146 sd_bus_unref(m->bus);
147 sd_event_source_unref(m->udev_event_source);
148 sd_event_source_unref(m->sigterm_event_source);
149 sd_event_source_unref(m->sigint_event_source);
150 sd_event_unref(m->event);
152 while ((link = hashmap_first(m->links)))
154 hashmap_free(m->links);
156 while ((network = m->networks))
157 network_free(network);
159 while ((netdev = hashmap_first(m->netdevs)))
160 netdev_unref(netdev);
161 hashmap_free(m->netdevs);
163 while ((pool = m->address_pools))
164 address_pool_free(pool);
166 sd_rtnl_unref(m->rtnl);
171 int manager_load_config(Manager *m) {
174 /* update timestamp */
175 paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, true);
188 bool manager_should_reload(Manager *m) {
189 return paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, false);
192 static int manager_udev_process_link(Manager *m, struct udev_device *device) {
199 if (!streq_ptr(udev_device_get_action(device), "add"))
202 ifindex = udev_device_get_ifindex(device);
204 log_debug("ignoring udev ADD event for device with invalid ifindex");
208 r = link_get(m, ifindex, &link);
214 r = link_initialized(link, device);
221 static int manager_rtnl_process_link(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
222 Manager *m = userdata;
224 NetDev *netdev = NULL;
233 r = sd_rtnl_message_get_type(message, &type);
235 log_warning("rtnl: could not get message type");
239 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
240 if (r < 0 || ifindex <= 0) {
241 log_warning("rtnl: received link message without valid ifindex");
244 link_get(m, ifindex, &link);
246 r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &name);
247 if (r < 0 || !name) {
248 log_warning("rtnl: received link message without valid ifname");
251 netdev_get(m, name, &netdev);
256 /* link is new, so add it */
257 r = link_add(m, message, &link);
259 log_debug("could not add new link: %s",
266 /* netdev exists, so make sure the ifindex matches */
267 r = netdev_set_ifindex(netdev, message);
269 log_debug("could not set ifindex on netdev");
274 r = link_update(link, message);
287 assert_not_reached("Received invalid RTNL message type.");
293 int manager_rtnl_enumerate_links(Manager *m) {
294 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
295 sd_rtnl_message *link;
301 r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
305 r = sd_rtnl_message_request_dump(req, true);
309 r = sd_rtnl_call(m->rtnl, req, 0, &reply);
313 for (link = reply; link; link = sd_rtnl_message_next(link)) {
316 k = sd_rtnl_message_get_type(link, &type);
320 if (type != RTM_NEWLINK)
323 k = manager_rtnl_process_link(m->rtnl, link, m);
331 static int manager_dispatch_link_udev(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
332 Manager *m = userdata;
333 struct udev_monitor *monitor = m->udev_monitor;
334 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
336 device = udev_monitor_receive_device(monitor);
340 manager_udev_process_link(m, device);
344 int manager_udev_listen(Manager *m) {
347 if (detect_container(NULL) > 0)
350 assert(m->udev_monitor);
352 r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_monitor, "net", NULL);
354 log_error("Could not add udev monitor filter: %s", strerror(-r));
358 r = udev_monitor_enable_receiving(m->udev_monitor);
360 log_error("Could not enable udev monitor");
364 r = sd_event_add_io(m->event,
365 &m->udev_event_source,
366 udev_monitor_get_fd(m->udev_monitor),
367 EPOLLIN, manager_dispatch_link_udev,
375 int manager_rtnl_listen(Manager *m) {
380 r = sd_rtnl_attach_event(m->rtnl, m->event, 0);
384 r = sd_rtnl_add_match(m->rtnl, RTM_NEWLINK, &manager_rtnl_process_link, m);
388 r = sd_rtnl_add_match(m->rtnl, RTM_DELLINK, &manager_rtnl_process_link, m);
392 r = sd_rtnl_add_match(m->rtnl, RTM_NEWADDR, &link_rtnl_process_address, m);
396 r = sd_rtnl_add_match(m->rtnl, RTM_DELADDR, &link_rtnl_process_address, m);
403 int manager_bus_listen(Manager *m) {
408 if (!m->bus) /* TODO: drop when we can rely on kdbus */
411 r = sd_bus_attach_event(m->bus, m->event, 0);
418 int manager_save(Manager *m) {
421 _cleanup_free_ char *temp_path = NULL;
422 _cleanup_fclose_ FILE *f = NULL;
423 LinkOperationalState operstate = LINK_OPERSTATE_UNKNOWN;
424 const char *operstate_str;
428 assert(m->state_file);
430 HASHMAP_FOREACH(link, m->links, i) {
431 if (link->flags & IFF_LOOPBACK)
434 if (link->operstate > operstate)
435 operstate = link->operstate;
438 operstate_str = link_operstate_to_string(operstate);
439 assert(operstate_str);
441 r = fopen_temporary(m->state_file, &f, &temp_path);
445 fchmod(fileno(f), 0644);
448 "# This is private data. Do not parse.\n"
449 "OPER_STATE=%s\n", operstate_str);
453 if (ferror(f) || rename(temp_path, m->state_file) < 0) {
455 unlink(m->state_file);
461 log_error("Failed to save network state to %s: %s", m->state_file, strerror(-r));
466 int manager_address_pool_acquire(Manager *m, int family, unsigned prefixlen, union in_addr_union *found) {
471 assert(prefixlen > 0);
474 LIST_FOREACH(address_pools, p, m->address_pools) {
475 if (p->family != family)
478 r = address_pool_acquire(p, prefixlen, found);