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