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