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_errno(r, "could not add new link: %m");
 266                                 return 0;
 267                         }
 268                 }
 269
 270                 if (netdev) {
 271                         /* netdev exists, so make sure the ifindex matches */
 272                         r = netdev_set_ifindex(netdev, message);
 273                         if (r < 0) {
 274                                 log_debug("could not set ifindex on netdev");
 275                                 return 0;
 276                         }
 277                 }
 278
 279                 r = link_update(link, message);
 280                 if (r < 0)
 281                         return 0;
 282
 283                 break;
 284
 285         case RTM_DELLINK:
 286                 link_drop(link);
 287                 netdev_drop(netdev);
 288
 289                 break;
 290
 291         default:
 292                 assert_not_reached("Received invalid RTNL message type.");
 293         }
 294
 295         return 1;
 296 }
 297
 298 int manager_rtnl_enumerate_links(Manager *m) {
 299         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
 300         sd_rtnl_message *link;
 301         int r, k;
 302
 303         assert(m);
 304         assert(m->rtnl);
 305
 306         r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
 307         if (r < 0)
 308                 return r;
 309
 310         r = sd_rtnl_message_request_dump(req, true);
 311         if (r < 0)
 312                 return r;
 313
 314         r = sd_rtnl_call(m->rtnl, req, 0, &reply);
 315         if (r < 0)
 316                 return r;
 317
 318         for (link = reply; link; link = sd_rtnl_message_next(link)) {
 319                 uint16_t type;
 320
 321                 k = sd_rtnl_message_get_type(link, &type);
 322                 if (k < 0)
 323                         return k;
 324
 325                 if (type != RTM_NEWLINK)
 326                         continue;
 327
 328                 k = manager_rtnl_process_link(m->rtnl, link, m);
 329                 if (k < 0)
 330                         r = k;
 331         }
 332
 333         return r;
 334 }
 335
 336 static int manager_dispatch_link_udev(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
 337         Manager *m = userdata;
 338         struct udev_monitor *monitor = m->udev_monitor;
 339         _cleanup_udev_device_unref_ struct udev_device *device = NULL;
 340
 341         device = udev_monitor_receive_device(monitor);
 342         if (!device)
 343                 return -ENOMEM;
 344
 345         manager_udev_process_link(m, device);
 346         return 0;
 347 }
 348
 349 int manager_udev_listen(Manager *m) {
 350         int r;
 351
 352         if (detect_container(NULL) > 0)
 353                 return 0;
 354
 355         assert(m->udev_monitor);
 356
 357         r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_monitor, "net", NULL);
 358         if (r < 0)
 359                 return log_error_errno(r, "Could not add udev monitor filter: %m");
 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         r = sd_event_source_set_description(m->udev_event_source, "networkd-udev");
 376         if (r < 0)
 377                 return r;
 378
 379         return 0;
 380 }
 381
 382 int manager_rtnl_listen(Manager *m) {
 383         int r;
 384
 385         assert(m);
 386
 387         r = sd_rtnl_attach_event(m->rtnl, m->event, 0);
 388         if (r < 0)
 389                 return r;
 390
 391         r = sd_rtnl_add_match(m->rtnl, RTM_NEWLINK, &manager_rtnl_process_link, m);
 392         if (r < 0)
 393                 return r;
 394
 395         r = sd_rtnl_add_match(m->rtnl, RTM_DELLINK, &manager_rtnl_process_link, m);
 396         if (r < 0)
 397                 return r;
 398
 399         r = sd_rtnl_add_match(m->rtnl, RTM_NEWADDR, &link_rtnl_process_address, m);
 400         if (r < 0)
 401                 return r;
 402
 403         r = sd_rtnl_add_match(m->rtnl, RTM_DELADDR, &link_rtnl_process_address, m);
 404         if (r < 0)
 405                 return r;
 406
 407         return 0;
 408 }
 409
 410 int manager_bus_listen(Manager *m) {
 411         int r;
 412
 413         assert(m->event);
 414
 415         if (!m->bus) /* TODO: drop when we can rely on kdbus */
 416                 return 0;
 417
 418         r = sd_bus_attach_event(m->bus, m->event, 0);
 419         if (r < 0)
 420                 return r;
 421
 422         return 0;
 423 }
 424
 425 static int set_put_in_addr(Set *s, const struct in_addr *address) {
 426         char *p;
 427         int r;
 428
 429         assert(s);
 430
 431         r = in_addr_to_string(AF_INET, (const union in_addr_union*) address, &p);
 432         if (r < 0)
 433                 return r;
 434
 435         r = set_consume(s, p);
 436         if (r == -EEXIST)
 437                 return 0;
 438
 439         return r;
 440 }
 441
 442 static int set_put_in_addrv(Set *s, const struct in_addr *addresses, int n) {
 443         int r, i, c = 0;
 444
 445         assert(s);
 446         assert(n <= 0 || addresses);
 447
 448         for (i = 0; i < n; i++) {
 449                 r = set_put_in_addr(s, addresses+i);
 450                 if (r < 0)
 451                         return r;
 452
 453                 c += r;
 454         }
 455
 456         return c;
 457 }
 458
 459 static void print_string_set(FILE *f, const char *field, Set *s) {
 460         bool space = false;
 461         Iterator i;
 462         char *p;
 463
 464         if (set_isempty(s))
 465                 return;
 466
 467         fputs(field, f);
 468
 469         SET_FOREACH(p, s, i) {
 470                 if (space)
 471                         fputc(' ', f);
 472                 fputs(p, f);
 473                 space = true;
 474         }
 475         fputc('\n', f);
 476 }
 477
 478 int manager_save(Manager *m) {
 479         _cleanup_set_free_free_ Set *dns = NULL, *ntp = NULL, *domains = NULL;
 480         Link *link;
 481         Iterator i;
 482         _cleanup_free_ char *temp_path = NULL;
 483         _cleanup_fclose_ FILE *f = NULL;
 484         LinkOperationalState operstate = LINK_OPERSTATE_OFF;
 485         const char *operstate_str;
 486         int r;
 487
 488         assert(m);
 489         assert(m->state_file);
 490
 491         /* We add all NTP and DNS server to a set, to filter out duplicates */
 492         dns = set_new(&string_hash_ops);
 493         if (!dns)
 494                 return -ENOMEM;
 495
 496         ntp = set_new(&string_hash_ops);
 497         if (!ntp)
 498                 return -ENOMEM;
 499
 500         domains = set_new(&string_hash_ops);
 501         if (!domains)
 502                 return -ENOMEM;
 503
 504         HASHMAP_FOREACH(link, m->links, i) {
 505                 if (link->flags & IFF_LOOPBACK)
 506                         continue;
 507
 508                 if (link->operstate > operstate)
 509                         operstate = link->operstate;
 510
 511                 if (!link->network)
 512                         continue;
 513
 514                 /* First add the static configured entries */
 515                 r = set_put_strdupv(dns, link->network->dns);
 516                 if (r < 0)
 517                         return r;
 518
 519                 r = set_put_strdupv(ntp, link->network->ntp);
 520                 if (r < 0)
 521                         return r;
 522
 523                 r = set_put_strdupv(domains, link->network->domains);
 524                 if (r < 0)
 525                         return r;
 526
 527                 if (!link->dhcp_lease)
 528                         continue;
 529
 530                 /* Secondly, add the entries acquired via DHCP */
 531                 if (link->network->dhcp_dns) {
 532                         const struct in_addr *addresses;
 533
 534                         r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
 535                         if (r > 0) {
 536                                 r = set_put_in_addrv(dns, addresses, r);
 537                                 if (r < 0)
 538                                         return r;
 539                         } else if (r < 0 && r != -ENOENT)
 540                                 return r;
 541                 }
 542
 543                 if (link->network->dhcp_ntp) {
 544                         const struct in_addr *addresses;
 545
 546                         r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
 547                         if (r > 0) {
 548                                 r = set_put_in_addrv(ntp, addresses, r);
 549                                 if (r < 0)
 550                                         return r;
 551                         } else if (r < 0 && r != -ENOENT)
 552                                 return r;
 553                 }
 554
 555                 if (link->network->dhcp_domains) {
 556                         const char *domainname;
 557
 558                         r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
 559                         if (r >= 0) {
 560                                 r = set_put_strdup(domains, domainname);
 561                                 if (r < 0)
 562                                         return r;
 563                         } else if (r != -ENOENT)
 564                                 return r;
 565                 }
 566         }
 567
 568         operstate_str = link_operstate_to_string(operstate);
 569         assert(operstate_str);
 570
 571         r = fopen_temporary(m->state_file, &f, &temp_path);
 572         if (r < 0)
 573                 return r;
 574
 575         fchmod(fileno(f), 0644);
 576
 577         fprintf(f,
 578                 "# This is private data. Do not parse.\n"
 579                 "OPER_STATE=%s\n", operstate_str);
 580
 581         print_string_set(f, "DNS=", dns);
 582         print_string_set(f, "NTP=", ntp);
 583         print_string_set(f, "DOMAINS=", domains);
 584
 585         r = fflush_and_check(f);
 586         if (r < 0)
 587                 goto fail;
 588
 589         if (rename(temp_path, m->state_file) < 0) {
 590                 r = -errno;
 591                 goto fail;
 592         }
 593
 594         return 0;
 595
 596 fail:
 597         log_error_errno(r, "Failed to save network state to %s: %m", m->state_file);
 598         unlink(m->state_file);
 599         unlink(temp_path);
 600         return r;
 601 }
 602
 603 int manager_address_pool_acquire(Manager *m, int family, unsigned prefixlen, union in_addr_union *found) {
 604         AddressPool *p;
 605         int r;
 606
 607         assert(m);
 608         assert(prefixlen > 0);
 609         assert(found);
 610
 611         LIST_FOREACH(address_pools, p, m->address_pools) {
 612                 if (p->family != family)
 613                         continue;
 614
 615                 r = address_pool_acquire(p, prefixlen, found);
 616                 if (r != 0)
 617                         return r;
 618         }
 619
 620         return 0;
 621 }