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