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_ops);
 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_unref(m->event);
 150
 151         while ((link = hashmap_first(m->links)))
 152                 link_unref(link);
 153         hashmap_free(m->links);
 154
 155         while ((network = m->networks))
 156                 network_free(network);
 157
 158         while ((netdev = hashmap_first(m->netdevs)))
 159                 netdev_unref(netdev);
 160         hashmap_free(m->netdevs);
 161
 162         while ((pool = m->address_pools))
 163                 address_pool_free(pool);
 164
 165         sd_rtnl_unref(m->rtnl);
 166
 167         free(m);
 168 }
 169
 170 int manager_load_config(Manager *m) {
 171         int r;
 172
 173         /* update timestamp */
 174         paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, true);
 175
 176         r = netdev_load(m);
 177         if (r < 0)
 178                 return r;
 179
 180         r = network_load(m);
 181         if (r < 0)
 182                 return r;
 183
 184         return 0;
 185 }
 186
 187 bool manager_should_reload(Manager *m) {
 188         return paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, false);
 189 }
 190
 191 static int manager_udev_process_link(Manager *m, struct udev_device *device) {
 192         Link *link = NULL;
 193         int r, ifindex;
 194
 195         assert(m);
 196         assert(device);
 197
 198         if (!streq_ptr(udev_device_get_action(device), "add"))
 199                 return 0;
 200
 201         ifindex = udev_device_get_ifindex(device);
 202         if (ifindex <= 0) {
 203                 log_debug("ignoring udev ADD event for device with invalid ifindex");
 204                 return 0;
 205         }
 206
 207         r = link_get(m, ifindex, &link);
 208         if (r == -ENODEV)
 209                 return 0;
 210         else if (r < 0)
 211                 return r;
 212
 213         r = link_initialized(link, device);
 214         if (r < 0)
 215                 return r;
 216
 217         return 0;
 218 }
 219
 220 static int manager_rtnl_process_link(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
 221         Manager *m = userdata;
 222         Link *link = NULL;
 223         NetDev *netdev = NULL;
 224         uint16_t type;
 225         const char *name;
 226         int r, ifindex;
 227
 228         assert(rtnl);
 229         assert(message);
 230         assert(m);
 231
 232         r = sd_rtnl_message_get_type(message, &type);
 233         if (r < 0) {
 234                 log_warning("rtnl: could not get message type");
 235                 return 0;
 236         }
 237
 238         r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
 239         if (r < 0 || ifindex <= 0) {
 240                 log_warning("rtnl: received link message without valid ifindex");
 241                 return 0;
 242         } else
 243                 link_get(m, ifindex, &link);
 244
 245         r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &name);
 246         if (r < 0 || !name) {
 247                 log_warning("rtnl: received link message without valid ifname");
 248                 return 0;
 249         } else
 250                 netdev_get(m, name, &netdev);
 251
 252         switch (type) {
 253         case RTM_NEWLINK:
 254                 if (!link) {
 255                         /* link is new, so add it */
 256                         r = link_add(m, message, &link);
 257                         if (r < 0) {
 258                                 log_debug("could not add new link: %s",
 259                                            strerror(-r));
 260                                 return 0;
 261                         }
 262                 }
 263
 264                 if (netdev) {
 265                         /* netdev exists, so make sure the ifindex matches */
 266                         r = netdev_set_ifindex(netdev, message);
 267                         if (r < 0) {
 268                                 log_debug("could not set ifindex on netdev");
 269                                 return 0;
 270                         }
 271                 }
 272
 273                 r = link_update(link, message);
 274                 if (r < 0)
 275                         return 0;
 276
 277                 break;
 278
 279         case RTM_DELLINK:
 280                 link_drop(link);
 281                 netdev_drop(netdev);
 282
 283                 break;
 284
 285         default:
 286                 assert_not_reached("Received invalid RTNL message type.");
 287         }
 288
 289         return 1;
 290 }
 291
 292 int manager_rtnl_enumerate_links(Manager *m) {
 293         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
 294         sd_rtnl_message *link;
 295         int r, k;
 296
 297         assert(m);
 298         assert(m->rtnl);
 299
 300         r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
 301         if (r < 0)
 302                 return r;
 303
 304         r = sd_rtnl_message_request_dump(req, true);
 305         if (r < 0)
 306                 return r;
 307
 308         r = sd_rtnl_call(m->rtnl, req, 0, &reply);
 309         if (r < 0)
 310                 return r;
 311
 312         for (link = reply; link; link = sd_rtnl_message_next(link)) {
 313                 uint16_t type;
 314
 315                 k = sd_rtnl_message_get_type(link, &type);
 316                 if (k < 0)
 317                         return k;
 318
 319                 if (type != RTM_NEWLINK)
 320                         continue;
 321
 322                 k = manager_rtnl_process_link(m->rtnl, link, m);
 323                 if (k < 0)
 324                         r = k;
 325         }
 326
 327         return r;
 328 }
 329
 330 static int manager_dispatch_link_udev(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
 331         Manager *m = userdata;
 332         struct udev_monitor *monitor = m->udev_monitor;
 333         _cleanup_udev_device_unref_ struct udev_device *device = NULL;
 334
 335         device = udev_monitor_receive_device(monitor);
 336         if (!device)
 337                 return -ENOMEM;
 338
 339         manager_udev_process_link(m, device);
 340         return 0;
 341 }
 342
 343 int manager_udev_listen(Manager *m) {
 344         int r;
 345
 346         if (detect_container(NULL) > 0)
 347                 return 0;
 348
 349         assert(m->udev_monitor);
 350
 351         r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_monitor, "net", NULL);
 352         if (r < 0) {
 353                 log_error("Could not add udev monitor filter: %s", strerror(-r));
 354                 return r;
 355         }
 356
 357         r = udev_monitor_enable_receiving(m->udev_monitor);
 358         if (r < 0) {
 359                 log_error("Could not enable udev monitor");
 360                 return r;
 361         }
 362
 363         r = sd_event_add_io(m->event,
 364                         &m->udev_event_source,
 365                         udev_monitor_get_fd(m->udev_monitor),
 366                         EPOLLIN, manager_dispatch_link_udev,
 367                         m);
 368         if (r < 0)
 369                 return r;
 370
 371         r = sd_event_source_set_name(m->udev_event_source, "networkd-udev");
 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 static int set_put_in_addr(Set *s, const struct in_addr *address) {
 422         char *p;
 423         int r;
 424
 425         assert(s);
 426
 427         r = in_addr_to_string(AF_INET, (const union in_addr_union*) address, &p);
 428         if (r < 0)
 429                 return r;
 430
 431         r = set_consume(s, p);
 432         if (r == -EEXIST)
 433                 return 0;
 434
 435         return r;
 436 }
 437
 438 static int set_put_in_addrv(Set *s, const struct in_addr *addresses, int n) {
 439         int r, i, c = 0;
 440
 441         assert(s);
 442         assert(n <= 0 || addresses);
 443
 444         for (i = 0; i < n; i++) {
 445                 r = set_put_in_addr(s, addresses+i);
 446                 if (r < 0)
 447                         return r;
 448
 449                 c += r;
 450         }
 451
 452         return c;
 453 }
 454
 455 static void print_string_set(FILE *f, const char *field, Set *s) {
 456         bool space = false;
 457         Iterator i;
 458         char *p;
 459
 460         if (set_isempty(s))
 461                 return;
 462
 463         fputs(field, f);
 464
 465         SET_FOREACH(p, s, i) {
 466                 if (space)
 467                         fputc(' ', f);
 468                 fputs(p, f);
 469                 space = true;
 470         }
 471         fputc('\n', f);
 472 }
 473
 474 int manager_save(Manager *m) {
 475         _cleanup_set_free_free_ Set *dns = NULL, *ntp = NULL, *domains = NULL;
 476         Link *link;
 477         Iterator i;
 478         _cleanup_free_ char *temp_path = NULL;
 479         _cleanup_fclose_ FILE *f = NULL;
 480         LinkOperationalState operstate = LINK_OPERSTATE_OFF;
 481         const char *operstate_str;
 482         int r;
 483
 484         assert(m);
 485         assert(m->state_file);
 486
 487         /* We add all NTP and DNS server to a set, to filter out duplicates */
 488         dns = set_new(&string_hash_ops);
 489         if (!dns)
 490                 return -ENOMEM;
 491
 492         ntp = set_new(&string_hash_ops);
 493         if (!ntp)
 494                 return -ENOMEM;
 495
 496         domains = set_new(&string_hash_ops);
 497         if (!domains)
 498                 return -ENOMEM;
 499
 500         HASHMAP_FOREACH(link, m->links, i) {
 501                 if (link->flags & IFF_LOOPBACK)
 502                         continue;
 503
 504                 if (link->operstate > operstate)
 505                         operstate = link->operstate;
 506
 507                 if (!link->network)
 508                         continue;
 509
 510                 /* First add the static configured entries */
 511                 r = set_put_strdupv(dns, link->network->dns);
 512                 if (r < 0)
 513                         return r;
 514
 515                 r = set_put_strdupv(ntp, link->network->ntp);
 516                 if (r < 0)
 517                         return r;
 518
 519                 r = set_put_strdupv(domains, link->network->domains);
 520                 if (r < 0)
 521                         return r;
 522
 523                 if (!link->dhcp_lease)
 524                         continue;
 525
 526                 /* Secondly, add the entries acquired via DHCP */
 527                 if (link->network->dhcp_dns) {
 528                         const struct in_addr *addresses;
 529
 530                         r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
 531                         if (r > 0) {
 532                                 r = set_put_in_addrv(dns, addresses, r);
 533                                 if (r < 0)
 534                                         return r;
 535                         } else if (r < 0 && r != -ENOENT)
 536                                 return r;
 537                 }
 538
 539                 if (link->network->dhcp_ntp) {
 540                         const struct in_addr *addresses;
 541
 542                         r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
 543                         if (r > 0) {
 544                                 r = set_put_in_addrv(ntp, addresses, r);
 545                                 if (r < 0)
 546                                         return r;
 547                         } else if (r < 0 && r != -ENOENT)
 548                                 return r;
 549                 }
 550
 551                 if (link->network->dhcp_domains) {
 552                         const char *domainname;
 553
 554                         r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
 555                         if (r >= 0) {
 556                                 r = set_put_strdup(domains, domainname);
 557                                 if (r < 0)
 558                                         return r;
 559                         } else if (r != -ENOENT)
 560                                 return r;
 561                 }
 562         }
 563
 564         operstate_str = link_operstate_to_string(operstate);
 565         assert(operstate_str);
 566
 567         r = fopen_temporary(m->state_file, &f, &temp_path);
 568         if (r < 0)
 569                 return r;
 570
 571         fchmod(fileno(f), 0644);
 572
 573         fprintf(f,
 574                 "# This is private data. Do not parse.\n"
 575                 "OPER_STATE=%s\n", operstate_str);
 576
 577         print_string_set(f, "DNS=", dns);
 578         print_string_set(f, "NTP=", ntp);
 579         print_string_set(f, "DOMAINS=", domains);
 580
 581         r = fflush_and_check(f);
 582         if (r < 0)
 583                 goto fail;
 584
 585         if (rename(temp_path, m->state_file) < 0) {
 586                 r = -errno;
 587                 goto fail;
 588         }
 589
 590         return 0;
 591
 592 fail:
 593         log_error("Failed to save network state to %s: %s", m->state_file, strerror(-r));
 594         unlink(m->state_file);
 595         unlink(temp_path);
 596         return r;
 597 }
 598
 599 int manager_address_pool_acquire(Manager *m, int family, unsigned prefixlen, union in_addr_union *found) {
 600         AddressPool *p;
 601         int r;
 602
 603         assert(m);
 604         assert(prefixlen > 0);
 605         assert(found);
 606
 607         LIST_FOREACH(address_pools, p, m->address_pools) {
 608                 if (p->family != family)
 609                         continue;
 610
 611                 r = address_pool_acquire(p, prefixlen, found);
 612                 if (r != 0)
 613                         return r;
 614         }
 615
 616         return 0;
 617 }