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 "network-internal.h"
29 #include "libudev-private.h"
30 #include "udev-util.h"
31 #include "rtnl-util.h"
37 const char* const network_dirs[] = {
38 "/etc/systemd/network",
39 "/run/systemd/network",
40 "/usr/lib/systemd/network",
42 "/lib/systemd/network",
46 static int setup_default_address_pool(Manager *m) {
52 /* Add in the well-known private address ranges. */
54 r = address_pool_new_from_string(m, &p, AF_INET6, "fc00::", 7);
58 r = address_pool_new_from_string(m, &p, AF_INET, "192.168.0.0", 16);
62 r = address_pool_new_from_string(m, &p, AF_INET, "172.16.0.0", 12);
66 r = address_pool_new_from_string(m, &p, AF_INET, "10.0.0.0", 8);
73 int manager_new(Manager **ret) {
74 _cleanup_manager_free_ Manager *m = NULL;
81 m->state_file = strdup("/run/systemd/netif/state");
85 r = sd_event_default(&m->event);
89 sd_event_set_watchdog(m->event, true);
91 sd_event_add_signal(m->event, NULL, SIGTERM, NULL, NULL);
92 sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
94 r = sd_rtnl_open(&m->rtnl, 3, RTNLGRP_LINK, RTNLGRP_IPV4_IFADDR,
99 r = sd_bus_default_system(&m->bus);
100 if (r < 0 && r != -ENOENT) /* TODO: drop when we can rely on kdbus */
103 /* udev does not initialize devices inside containers,
104 * so we rely on them being already initialized before
105 * entering the container */
106 if (detect_container(NULL) <= 0) {
107 m->udev = udev_new();
111 m->udev_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
112 if (!m->udev_monitor)
116 m->links = hashmap_new(uint64_hash_func, uint64_compare_func);
120 m->netdevs = hashmap_new(string_hash_func, string_compare_func);
124 LIST_HEAD_INIT(m->networks);
126 r = setup_default_address_pool(m);
136 void manager_free(Manager *m) {
147 udev_monitor_unref(m->udev_monitor);
149 sd_bus_unref(m->bus);
150 sd_event_source_unref(m->udev_event_source);
151 sd_event_source_unref(m->sigterm_event_source);
152 sd_event_source_unref(m->sigint_event_source);
153 sd_event_unref(m->event);
155 while ((link = hashmap_first(m->links)))
157 hashmap_free(m->links);
159 while ((network = m->networks))
160 network_free(network);
162 while ((netdev = hashmap_first(m->netdevs)))
163 netdev_unref(netdev);
164 hashmap_free(m->netdevs);
166 while ((pool = m->address_pools))
167 address_pool_free(pool);
169 sd_rtnl_unref(m->rtnl);
174 int manager_load_config(Manager *m) {
177 /* update timestamp */
178 paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, true);
191 bool manager_should_reload(Manager *m) {
192 return paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, false);
195 static int manager_udev_process_link(Manager *m, struct udev_device *device) {
202 if (!streq_ptr(udev_device_get_action(device), "add"))
205 ifindex = udev_device_get_ifindex(device);
207 log_debug("ignoring udev ADD event for device with invalid ifindex");
211 r = link_get(m, ifindex, &link);
217 r = link_initialized(link, device);
224 static int manager_rtnl_process_link(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
225 Manager *m = userdata;
227 NetDev *netdev = NULL;
236 r = sd_rtnl_message_get_type(message, &type);
238 log_warning("rtnl: could not get message type");
242 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
243 if (r < 0 || ifindex <= 0) {
244 log_warning("rtnl: received link message without valid ifindex");
247 link_get(m, ifindex, &link);
249 r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &name);
250 if (r < 0 || !name) {
251 log_warning("rtnl: received link message without valid ifname");
254 netdev_get(m, name, &netdev);
259 /* link is new, so add it */
260 r = link_add(m, message, &link);
262 log_debug("could not add new link: %s",
269 /* netdev exists, so make sure the ifindex matches */
270 r = netdev_set_ifindex(netdev, message);
272 log_debug("could not set ifindex on netdev");
277 r = link_update(link, message);
290 assert_not_reached("Received invalid RTNL message type.");
296 int manager_rtnl_enumerate_links(Manager *m) {
297 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
298 sd_rtnl_message *link;
304 r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
308 r = sd_rtnl_message_request_dump(req, true);
312 r = sd_rtnl_call(m->rtnl, req, 0, &reply);
316 for (link = reply; link; link = sd_rtnl_message_next(link)) {
319 k = sd_rtnl_message_get_type(link, &type);
323 if (type != RTM_NEWLINK)
326 k = manager_rtnl_process_link(m->rtnl, link, m);
334 static int manager_dispatch_link_udev(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
335 Manager *m = userdata;
336 struct udev_monitor *monitor = m->udev_monitor;
337 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
339 device = udev_monitor_receive_device(monitor);
343 manager_udev_process_link(m, device);
347 int manager_udev_listen(Manager *m) {
350 if (detect_container(NULL) > 0)
353 assert(m->udev_monitor);
355 r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_monitor, "net", NULL);
357 log_error("Could not add udev monitor filter: %s", strerror(-r));
361 r = udev_monitor_enable_receiving(m->udev_monitor);
363 log_error("Could not enable udev monitor");
367 r = sd_event_add_io(m->event,
368 &m->udev_event_source,
369 udev_monitor_get_fd(m->udev_monitor),
370 EPOLLIN, manager_dispatch_link_udev,
378 int manager_rtnl_listen(Manager *m) {
383 r = sd_rtnl_attach_event(m->rtnl, m->event, 0);
387 r = sd_rtnl_add_match(m->rtnl, RTM_NEWLINK, &manager_rtnl_process_link, m);
391 r = sd_rtnl_add_match(m->rtnl, RTM_DELLINK, &manager_rtnl_process_link, m);
395 r = sd_rtnl_add_match(m->rtnl, RTM_NEWADDR, &link_rtnl_process_address, m);
399 r = sd_rtnl_add_match(m->rtnl, RTM_DELADDR, &link_rtnl_process_address, m);
406 int manager_bus_listen(Manager *m) {
411 if (!m->bus) /* TODO: drop when we can rely on kdbus */
414 r = sd_bus_attach_event(m->bus, m->event, 0);
421 int manager_save(Manager *m) {
424 _cleanup_free_ char *temp_path = NULL;
425 _cleanup_fclose_ FILE *f = NULL;
426 LinkOperationalState operstate = LINK_OPERSTATE_UNKNOWN;
427 const char *operstate_str;
431 assert(m->state_file);
433 HASHMAP_FOREACH(link, m->links, i) {
434 if (link->flags & IFF_LOOPBACK)
437 if (link->operstate > operstate)
438 operstate = link->operstate;
441 operstate_str = link_operstate_to_string(operstate);
442 assert(operstate_str);
444 r = fopen_temporary(m->state_file, &f, &temp_path);
448 fchmod(fileno(f), 0644);
451 "# This is private data. Do not parse.\n"
452 "OPER_STATE=%s\n", operstate_str);
456 if (ferror(f) || rename(temp_path, m->state_file) < 0) {
458 unlink(m->state_file);
464 log_error("Failed to save network state to %s: %s", m->state_file, strerror(-r));
469 int manager_address_pool_acquire(Manager *m, unsigned family, unsigned prefixlen, union in_addr_union *found) {
474 assert(prefixlen > 0);
477 LIST_FOREACH(address_pools, p, m->address_pools) {
478 if (p->family != family)
481 r = address_pool_acquire(p, prefixlen, found);