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 setup_default_address_pool(Manager *m) {
  47         AddressPool *p;
  48         int r;
  49
  50         assert(m);
  51
  52         /* Add in the well-known private address ranges. */
  53
  54         r = address_pool_new_from_string(m, &p, AF_INET6, "fc00::", 7);
  55         if (r < 0)
  56                 return r;
  57
  58         r = address_pool_new_from_string(m, &p, AF_INET, "192.168.0.0", 16);
  59         if (r < 0)
  60                 return r;
  61
  62         r = address_pool_new_from_string(m, &p, AF_INET, "172.16.0.0", 12);
  63         if (r < 0)
  64                 return r;
  65
  66         r = address_pool_new_from_string(m, &p, AF_INET, "10.0.0.0", 8);
  67         if (r < 0)
  68                 return r;
  69
  70         return 0;
  71 }
  72
  73 int manager_new(Manager **ret) {
  74         _cleanup_manager_free_ Manager *m = NULL;
  75         int r;
  76
  77         m = new0(Manager, 1);
  78         if (!m)
  79                 return -ENOMEM;
  80
  81         m->state_file = strdup("/run/systemd/netif/state");
  82         if (!m->state_file)
  83                 return -ENOMEM;
  84
  85         r = sd_event_default(&m->event);
  86         if (r < 0)
  87                 return r;
  88
  89         sd_event_set_watchdog(m->event, true);
  90
  91         sd_event_add_signal(m->event, NULL, SIGTERM, NULL, NULL);
  92         sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
  93
  94         r = sd_rtnl_open(&m->rtnl, 3, RTNLGRP_LINK, RTNLGRP_IPV4_IFADDR,
  95                          RTNLGRP_IPV6_IFADDR);
  96         if (r < 0)
  97                 return r;
  98
  99         r = sd_bus_default_system(&m->bus);
 100         if (r < 0 && r != -ENOENT) /* TODO: drop when we can rely on kdbus */
 101                 return r;
 102
 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();
 108                 if (!m->udev)
 109                         return -ENOMEM;
 110
 111                 m->udev_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
 112                 if (!m->udev_monitor)
 113                         return -ENOMEM;
 114         }
 115
 116         m->links = hashmap_new(uint64_hash_func, uint64_compare_func);
 117         if (!m->links)
 118                 return -ENOMEM;
 119
 120         m->netdevs = hashmap_new(string_hash_func, string_compare_func);
 121         if (!m->netdevs)
 122                 return -ENOMEM;
 123
 124         LIST_HEAD_INIT(m->networks);
 125
 126         r = setup_default_address_pool(m);
 127         if (r < 0)
 128                 return r;
 129
 130         *ret = m;
 131         m = NULL;
 132
 133         return 0;
 134 }
 135
 136 void manager_free(Manager *m) {
 137         Network *network;
 138         NetDev *netdev;
 139         Link *link;
 140         AddressPool *pool;
 141
 142         if (!m)
 143                 return;
 144
 145         free(m->state_file);
 146
 147         udev_monitor_unref(m->udev_monitor);
 148         udev_unref(m->udev);
 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);
 154
 155         while ((link = hashmap_first(m->links)))
 156                 link_unref(link);
 157         hashmap_free(m->links);
 158
 159         while ((network = m->networks))
 160                 network_free(network);
 161
 162         while ((netdev = hashmap_first(m->netdevs)))
 163                 netdev_unref(netdev);
 164         hashmap_free(m->netdevs);
 165
 166         while ((pool = m->address_pools))
 167                 address_pool_free(pool);
 168
 169         sd_rtnl_unref(m->rtnl);
 170
 171         free(m);
 172 }
 173
 174 int manager_load_config(Manager *m) {
 175         int r;
 176
 177         /* update timestamp */
 178         paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, true);
 179
 180         r = netdev_load(m);
 181         if (r < 0)
 182                 return r;
 183
 184         r = network_load(m);
 185         if (r < 0)
 186                 return r;
 187
 188         return 0;
 189 }
 190
 191 bool manager_should_reload(Manager *m) {
 192         return paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, false);
 193 }
 194
 195 static int manager_udev_process_link(Manager *m, struct udev_device *device) {
 196         Link *link = NULL;
 197         int r, ifindex;
 198
 199         assert(m);
 200         assert(device);
 201
 202         if (!streq_ptr(udev_device_get_action(device), "add"))
 203                 return 0;
 204
 205         ifindex = udev_device_get_ifindex(device);
 206         if (ifindex <= 0) {
 207                 log_debug("ignoring udev ADD event for device with invalid ifindex");
 208                 return 0;
 209         }
 210
 211         r = link_get(m, ifindex, &link);
 212         if (r == -ENODEV)
 213                 return 0;
 214         else if (r < 0)
 215                 return r;
 216
 217         r = link_initialized(link, device);
 218         if (r < 0)
 219                 return r;
 220
 221         return 0;
 222 }
 223
 224 static int manager_rtnl_process_link(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
 225         Manager *m = userdata;
 226         Link *link = NULL;
 227         NetDev *netdev = NULL;
 228         uint16_t type;
 229         char *name;
 230         int r, ifindex;
 231
 232         assert(rtnl);
 233         assert(message);
 234         assert(m);
 235
 236         r = sd_rtnl_message_get_type(message, &type);
 237         if (r < 0) {
 238                 log_warning("rtnl: could not get message type");
 239                 return 0;
 240         }
 241
 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");
 245                 return 0;
 246         } else
 247                 link_get(m, ifindex, &link);
 248
 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");
 252                 return 0;
 253         } else
 254                 netdev_get(m, name, &netdev);
 255
 256         switch (type) {
 257         case RTM_NEWLINK:
 258                 if (!link) {
 259                         /* link is new, so add it */
 260                         r = link_add(m, message, &link);
 261                         if (r < 0) {
 262                                 log_debug("could not add new link: %s",
 263                                            strerror(-r));
 264                                 return 0;
 265                         }
 266                 }
 267
 268                 if (netdev) {
 269                         /* netdev exists, so make sure the ifindex matches */
 270                         r = netdev_set_ifindex(netdev, message);
 271                         if (r < 0) {
 272                                 log_debug("could not set ifindex on netdev");
 273                                 return 0;
 274                         }
 275                 }
 276
 277                 r = link_update(link, message);
 278                 if (r < 0)
 279                         return 0;
 280
 281                 break;
 282
 283         case RTM_DELLINK:
 284                 link_drop(link);
 285                 netdev_drop(netdev);
 286
 287                 break;
 288
 289         default:
 290                 assert_not_reached("Received invalid RTNL message type.");
 291         }
 292
 293         return 1;
 294 }
 295
 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;
 299         int r, k;
 300
 301         assert(m);
 302         assert(m->rtnl);
 303
 304         r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
 305         if (r < 0)
 306                 return r;
 307
 308         r = sd_rtnl_message_request_dump(req, true);
 309         if (r < 0)
 310                 return r;
 311
 312         r = sd_rtnl_call(m->rtnl, req, 0, &reply);
 313         if (r < 0)
 314                 return r;
 315
 316         for (link = reply; link; link = sd_rtnl_message_next(link)) {
 317                 uint16_t type;
 318
 319                 k = sd_rtnl_message_get_type(link, &type);
 320                 if (k < 0)
 321                         return k;
 322
 323                 if (type != RTM_NEWLINK)
 324                         continue;
 325
 326                 k = manager_rtnl_process_link(m->rtnl, link, m);
 327                 if (k < 0)
 328                         r = k;
 329         }
 330
 331         return r;
 332 }
 333
 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;
 338
 339         device = udev_monitor_receive_device(monitor);
 340         if (!device)
 341                 return -ENOMEM;
 342
 343         manager_udev_process_link(m, device);
 344         return 0;
 345 }
 346
 347 int manager_udev_listen(Manager *m) {
 348         int r;
 349
 350         if (detect_container(NULL) > 0)
 351                 return 0;
 352
 353         assert(m->udev_monitor);
 354
 355         r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_monitor, "net", NULL);
 356         if (r < 0) {
 357                 log_error("Could not add udev monitor filter: %s", strerror(-r));
 358                 return r;
 359         }
 360
 361         r = udev_monitor_enable_receiving(m->udev_monitor);
 362         if (r < 0) {
 363                 log_error("Could not enable udev monitor");
 364                 return r;
 365         }
 366
 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,
 371                         m);
 372         if (r < 0)
 373                 return r;
 374
 375         return 0;
 376 }
 377
 378 int manager_rtnl_listen(Manager *m) {
 379         int r;
 380
 381         assert(m);
 382
 383         r = sd_rtnl_attach_event(m->rtnl, m->event, 0);
 384         if (r < 0)
 385                 return r;
 386
 387         r = sd_rtnl_add_match(m->rtnl, RTM_NEWLINK, &manager_rtnl_process_link, m);
 388         if (r < 0)
 389                 return r;
 390
 391         r = sd_rtnl_add_match(m->rtnl, RTM_DELLINK, &manager_rtnl_process_link, m);
 392         if (r < 0)
 393                 return r;
 394
 395         r = sd_rtnl_add_match(m->rtnl, RTM_NEWADDR, &link_rtnl_process_address, m);
 396         if (r < 0)
 397                 return r;
 398
 399         r = sd_rtnl_add_match(m->rtnl, RTM_DELADDR, &link_rtnl_process_address, m);
 400         if (r < 0)
 401                 return r;
 402
 403         return 0;
 404 }
 405
 406 int manager_bus_listen(Manager *m) {
 407         int r;
 408
 409         assert(m->event);
 410
 411         if (!m->bus) /* TODO: drop when we can rely on kdbus */
 412                 return 0;
 413
 414         r = sd_bus_attach_event(m->bus, m->event, 0);
 415         if (r < 0)
 416                 return r;
 417
 418         return 0;
 419 }
 420
 421 int manager_save(Manager *m) {
 422         Link *link;
 423         Iterator i;
 424         _cleanup_free_ char *temp_path = NULL;
 425         _cleanup_fclose_ FILE *f = NULL;
 426         LinkOperationalState operstate = LINK_OPERSTATE_UNKNOWN;
 427         const char *operstate_str;
 428         int r;
 429
 430         assert(m);
 431         assert(m->state_file);
 432
 433         HASHMAP_FOREACH(link, m->links, i) {
 434                 if (link->flags & IFF_LOOPBACK)
 435                         continue;
 436
 437                 if (link->operstate > operstate)
 438                         operstate = link->operstate;
 439         }
 440
 441         operstate_str = link_operstate_to_string(operstate);
 442         assert(operstate_str);
 443
 444         r = fopen_temporary(m->state_file, &f, &temp_path);
 445         if (r < 0)
 446                 goto finish;
 447
 448         fchmod(fileno(f), 0644);
 449
 450         fprintf(f,
 451                 "# This is private data. Do not parse.\n"
 452                 "OPER_STATE=%s\n", operstate_str);
 453
 454         fflush(f);
 455
 456         if (ferror(f) || rename(temp_path, m->state_file) < 0) {
 457                 r = -errno;
 458                 unlink(m->state_file);
 459                 unlink(temp_path);
 460         }
 461
 462 finish:
 463         if (r < 0)
 464                 log_error("Failed to save network state to %s: %s", m->state_file, strerror(-r));
 465
 466         return r;
 467 }
 468
 469 int manager_address_pool_acquire(Manager *m, unsigned family, unsigned prefixlen, union in_addr_union *found) {
 470         AddressPool *p;
 471         int r;
 472
 473         assert(m);
 474         assert(prefixlen > 0);
 475         assert(found);
 476
 477         LIST_FOREACH(address_pools, p, m->address_pools) {
 478                 if (p->family != family)
 479                         continue;
 480
 481                 r = address_pool_acquire(p, prefixlen, found);
 482                 if (r != 0)
 483                         return r;
 484         }
 485
 486         return 0;
 487 }