src/network/networkd-manager.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2013 Tom Gundersen <teg@jklm.no>
   7
   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.
  12
  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.
  17
  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/>.
  20  ***/
  21
  22 #include <sys/socket.h>
  23 #include <linux/if.h>
  24
  25 #include "conf-parser.h"
  26 #include "path-util.h"
  27 #include "networkd.h"
  28 #include "network-internal.h"
  29 #include "libudev-private.h"
  30 #include "udev-util.h"
  31 #include "rtnl-util.h"
  32 #include "mkdir.h"
  33 #include "virt.h"
  34
  35 #include "sd-rtnl.h"
  36
  37 const char* const network_dirs[] = {
  38         "/etc/systemd/network",
  39         "/run/systemd/network",
  40         "/usr/lib/systemd/network",
  41 #ifdef HAVE_SPLIT_USR
  42         "/lib/systemd/network",
  43 #endif
  44         NULL};
  45
  46 static int dispatch_sigterm(sd_event_source *es, const struct signalfd_siginfo *si, void *userdata) {
  47         Manager *m = userdata;
  48
  49         assert(m);
  50
  51         log_received_signal(LOG_INFO, si);
  52
  53         sd_event_exit(m->event, 0);
  54         return 0;
  55 }
  56
  57 static int setup_signals(Manager *m) {
  58         sigset_t mask;
  59         int r;
  60
  61         assert(m);
  62
  63         assert_se(sigemptyset(&mask) == 0);
  64         sigset_add_many(&mask, SIGINT, SIGTERM, -1);
  65         assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
  66
  67         r = sd_event_add_signal(m->event, &m->sigterm_event_source, SIGTERM, dispatch_sigterm, m);
  68         if (r < 0)
  69                 return r;
  70
  71         r = sd_event_add_signal(m->event, &m->sigint_event_source, SIGINT, dispatch_sigterm, m);
  72         if (r < 0)
  73                 return r;
  74
  75         return 0;
  76 }
  77
  78 static int setup_default_address_pool(Manager *m) {
  79         AddressPool *p;
  80         int r;
  81
  82         assert(m);
  83
  84         /* Add in the well-known private address ranges. */
  85
  86         r = address_pool_new_from_string(m, &p, AF_INET6, "fc00::", 7);
  87         if (r < 0)
  88                 return r;
  89
  90         r = address_pool_new_from_string(m, &p, AF_INET, "192.168.0.0", 16);
  91         if (r < 0)
  92                 return r;
  93
  94         r = address_pool_new_from_string(m, &p, AF_INET, "172.16.0.0", 12);
  95         if (r < 0)
  96                 return r;
  97
  98         r = address_pool_new_from_string(m, &p, AF_INET, "10.0.0.0", 8);
  99         if (r < 0)
 100                 return r;
 101
 102         return 0;
 103 }
 104
 105 int manager_new(Manager **ret) {
 106         _cleanup_manager_free_ Manager *m = NULL;
 107         int r;
 108
 109         m = new0(Manager, 1);
 110         if (!m)
 111                 return -ENOMEM;
 112
 113         m->state_file = strdup("/run/systemd/netif/state");
 114         if (!m->state_file)
 115                 return -ENOMEM;
 116
 117         r = sd_event_default(&m->event);
 118         if (r < 0)
 119                 return r;
 120
 121         sd_event_set_watchdog(m->event, true);
 122
 123         r = sd_rtnl_open(&m->rtnl, 3, RTNLGRP_LINK, RTNLGRP_IPV4_IFADDR,
 124                          RTNLGRP_IPV6_IFADDR);
 125         if (r < 0)
 126                 return r;
 127
 128         r = sd_bus_default_system(&m->bus);
 129         if (r < 0 && r != -ENOENT) /* TODO: drop when we can rely on kdbus */
 130                 return r;
 131
 132         r = setup_signals(m);
 133         if (r < 0)
 134                 return r;
 135
 136         /* udev does not initialize devices inside containers,
 137          * so we rely on them being already initialized before
 138          * entering the container */
 139         if (detect_container(NULL) <= 0) {
 140                 m->udev = udev_new();
 141                 if (!m->udev)
 142                         return -ENOMEM;
 143
 144                 m->udev_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
 145                 if (!m->udev_monitor)
 146                         return -ENOMEM;
 147         }
 148
 149         m->links = hashmap_new(uint64_hash_func, uint64_compare_func);
 150         if (!m->links)
 151                 return -ENOMEM;
 152
 153         m->netdevs = hashmap_new(string_hash_func, string_compare_func);
 154         if (!m->netdevs)
 155                 return -ENOMEM;
 156
 157         LIST_HEAD_INIT(m->networks);
 158
 159         r = setup_default_address_pool(m);
 160         if (r < 0)
 161                 return r;
 162
 163         *ret = m;
 164         m = NULL;
 165
 166         return 0;
 167 }
 168
 169 void manager_free(Manager *m) {
 170         Network *network;
 171         NetDev *netdev;
 172         Link *link;
 173         AddressPool *pool;
 174
 175         if (!m)
 176                 return;
 177
 178         free(m->state_file);
 179
 180         udev_monitor_unref(m->udev_monitor);
 181         udev_unref(m->udev);
 182         sd_bus_unref(m->bus);
 183         sd_event_source_unref(m->udev_event_source);
 184         sd_event_source_unref(m->sigterm_event_source);
 185         sd_event_source_unref(m->sigint_event_source);
 186         sd_event_unref(m->event);
 187
 188         while ((link = hashmap_first(m->links)))
 189                 link_unref(link);
 190         hashmap_free(m->links);
 191
 192         while ((network = m->networks))
 193                 network_free(network);
 194
 195         while ((netdev = hashmap_first(m->netdevs)))
 196                 netdev_unref(netdev);
 197         hashmap_free(m->netdevs);
 198
 199         while ((pool = m->address_pools))
 200                 address_pool_free(pool);
 201
 202         sd_rtnl_unref(m->rtnl);
 203
 204         free(m);
 205 }
 206
 207 int manager_load_config(Manager *m) {
 208         int r;
 209
 210         /* update timestamp */
 211         paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, true);
 212
 213         r = netdev_load(m);
 214         if (r < 0)
 215                 return r;
 216
 217         r = network_load(m);
 218         if (r < 0)
 219                 return r;
 220
 221         return 0;
 222 }
 223
 224 bool manager_should_reload(Manager *m) {
 225         return paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, false);
 226 }
 227
 228 static int manager_udev_process_link(Manager *m, struct udev_device *device) {
 229         Link *link = NULL;
 230         int r, ifindex;
 231
 232         assert(m);
 233         assert(device);
 234
 235         if (!streq_ptr(udev_device_get_action(device), "add"))
 236                 return 0;
 237
 238         ifindex = udev_device_get_ifindex(device);
 239         if (ifindex <= 0) {
 240                 log_debug("ignoring udev ADD event for device with invalid ifindex");
 241                 return 0;
 242         }
 243
 244         r = link_get(m, ifindex, &link);
 245         if (r == -ENODEV)
 246                 return 0;
 247         else if (r < 0)
 248                 return r;
 249
 250         r = link_initialized(link, device);
 251         if (r < 0)
 252                 return r;
 253
 254         return 0;
 255 }
 256
 257 static int manager_rtnl_process_link(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
 258         Manager *m = userdata;
 259         Link *link = NULL;
 260         NetDev *netdev = NULL;
 261         uint16_t type;
 262         char *name;
 263         int r, ifindex;
 264
 265         assert(rtnl);
 266         assert(message);
 267         assert(m);
 268
 269         r = sd_rtnl_message_get_type(message, &type);
 270         if (r < 0) {
 271                 log_warning("rtnl: could not get message type");
 272                 return 0;
 273         }
 274
 275         r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
 276         if (r < 0 || ifindex <= 0) {
 277                 log_warning("rtnl: received link message without valid ifindex");
 278                 return 0;
 279         } else
 280                 link_get(m, ifindex, &link);
 281
 282         r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &name);
 283         if (r < 0 || !name) {
 284                 log_warning("rtnl: received link message without valid ifname");
 285                 return 0;
 286         } else
 287                 netdev_get(m, name, &netdev);
 288
 289         switch (type) {
 290         case RTM_NEWLINK:
 291                 if (!link) {
 292                         /* link is new, so add it */
 293                         r = link_add(m, message, &link);
 294                         if (r < 0) {
 295                                 log_debug("could not add new link: %s",
 296                                            strerror(-r));
 297                                 return 0;
 298                         }
 299                 }
 300
 301                 if (netdev) {
 302                         /* netdev exists, so make sure the ifindex matches */
 303                         r = netdev_set_ifindex(netdev, message);
 304                         if (r < 0) {
 305                                 log_debug("could not set ifindex on netdev");
 306                                 return 0;
 307                         }
 308                 }
 309
 310                 r = link_update(link, message);
 311                 if (r < 0)
 312                         return 0;
 313
 314                 break;
 315
 316         case RTM_DELLINK:
 317                 link_drop(link);
 318                 netdev_drop(netdev);
 319
 320                 break;
 321
 322         default:
 323                 assert_not_reached("Received invalid RTNL message type.");
 324         }
 325
 326         return 1;
 327 }
 328
 329 int manager_rtnl_enumerate_links(Manager *m) {
 330         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
 331         sd_rtnl_message *link;
 332         int r, k;
 333
 334         assert(m);
 335         assert(m->rtnl);
 336
 337         r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
 338         if (r < 0)
 339                 return r;
 340
 341         r = sd_rtnl_message_request_dump(req, true);
 342         if (r < 0)
 343                 return r;
 344
 345         r = sd_rtnl_call(m->rtnl, req, 0, &reply);
 346         if (r < 0)
 347                 return r;
 348
 349         for (link = reply; link; link = sd_rtnl_message_next(link)) {
 350                 uint16_t type;
 351
 352                 k = sd_rtnl_message_get_type(link, &type);
 353                 if (k < 0)
 354                         return k;
 355
 356                 if (type != RTM_NEWLINK)
 357                         continue;
 358
 359                 k = manager_rtnl_process_link(m->rtnl, link, m);
 360                 if (k < 0)
 361                         r = k;
 362         }
 363
 364         return r;
 365 }
 366
 367 static int manager_dispatch_link_udev(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
 368         Manager *m = userdata;
 369         struct udev_monitor *monitor = m->udev_monitor;
 370         _cleanup_udev_device_unref_ struct udev_device *device = NULL;
 371
 372         device = udev_monitor_receive_device(monitor);
 373         if (!device)
 374                 return -ENOMEM;
 375
 376         manager_udev_process_link(m, device);
 377         return 0;
 378 }
 379
 380 int manager_udev_listen(Manager *m) {
 381         int r;
 382
 383         if (detect_container(NULL) > 0)
 384                 return 0;
 385
 386         assert(m->udev_monitor);
 387
 388         r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_monitor, "net", NULL);
 389         if (r < 0) {
 390                 log_error("Could not add udev monitor filter: %s", strerror(-r));
 391                 return r;
 392         }
 393
 394         r = udev_monitor_enable_receiving(m->udev_monitor);
 395         if (r < 0) {
 396                 log_error("Could not enable udev monitor");
 397                 return r;
 398         }
 399
 400         r = sd_event_add_io(m->event,
 401                         &m->udev_event_source,
 402                         udev_monitor_get_fd(m->udev_monitor),
 403                         EPOLLIN, manager_dispatch_link_udev,
 404                         m);
 405         if (r < 0)
 406                 return r;
 407
 408         return 0;
 409 }
 410
 411 int manager_rtnl_listen(Manager *m) {
 412         int r;
 413
 414         assert(m);
 415
 416         r = sd_rtnl_attach_event(m->rtnl, m->event, 0);
 417         if (r < 0)
 418                 return r;
 419
 420         r = sd_rtnl_add_match(m->rtnl, RTM_NEWLINK, &manager_rtnl_process_link, m);
 421         if (r < 0)
 422                 return r;
 423
 424         r = sd_rtnl_add_match(m->rtnl, RTM_DELLINK, &manager_rtnl_process_link, m);
 425         if (r < 0)
 426                 return r;
 427
 428         r = sd_rtnl_add_match(m->rtnl, RTM_NEWADDR, &link_rtnl_process_address, m);
 429         if (r < 0)
 430                 return r;
 431
 432         r = sd_rtnl_add_match(m->rtnl, RTM_DELADDR, &link_rtnl_process_address, m);
 433         if (r < 0)
 434                 return r;
 435
 436         return 0;
 437 }
 438
 439 int manager_bus_listen(Manager *m) {
 440         int r;
 441
 442         assert(m->event);
 443
 444         if (!m->bus) /* TODO: drop when we can rely on kdbus */
 445                 return 0;
 446
 447         r = sd_bus_attach_event(m->bus, m->event, 0);
 448         if (r < 0)
 449                 return r;
 450
 451         return 0;
 452 }
 453
 454 int manager_save(Manager *m) {
 455         Link *link;
 456         Iterator i;
 457         _cleanup_free_ char *temp_path = NULL;
 458         _cleanup_fclose_ FILE *f = NULL;
 459         LinkOperationalState operstate = LINK_OPERSTATE_UNKNOWN;
 460         const char *operstate_str;
 461         int r;
 462
 463         assert(m);
 464         assert(m->state_file);
 465
 466         HASHMAP_FOREACH(link, m->links, i) {
 467                 if (link->flags & IFF_LOOPBACK)
 468                         continue;
 469
 470                 if (link->operstate > operstate)
 471                         operstate = link->operstate;
 472         }
 473
 474         operstate_str = link_operstate_to_string(operstate);
 475         assert(operstate_str);
 476
 477         r = fopen_temporary(m->state_file, &f, &temp_path);
 478         if (r < 0)
 479                 goto finish;
 480
 481         fchmod(fileno(f), 0644);
 482
 483         fprintf(f,
 484                 "# This is private data. Do not parse.\n"
 485                 "OPER_STATE=%s\n", operstate_str);
 486
 487         fflush(f);
 488
 489         if (ferror(f) || rename(temp_path, m->state_file) < 0) {
 490                 r = -errno;
 491                 unlink(m->state_file);
 492                 unlink(temp_path);
 493         }
 494
 495 finish:
 496         if (r < 0)
 497                 log_error("Failed to save network state to %s: %s", m->state_file, strerror(-r));
 498
 499         return r;
 500 }
 501
 502 int manager_address_pool_acquire(Manager *m, unsigned family, unsigned prefixlen, union in_addr_union *found) {
 503         AddressPool *p;
 504         int r;
 505
 506         assert(m);
 507         assert(prefixlen > 0);
 508         assert(found);
 509
 510         LIST_FOREACH(address_pools, p, m->address_pools) {
 511                 if (p->family != family)
 512                         continue;
 513
 514                 r = address_pool_acquire(p, prefixlen, found);
 515                 if (r != 0)
 516                         return r;
 517         }
 518
 519         return 0;
 520 }