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                 log_error_errno(r, "Could not add udev monitor filter: %m");
 360                 return r;
 361         }
 362
 363         r = udev_monitor_enable_receiving(m->udev_monitor);
 364         if (r < 0) {
 365                 log_error("Could not enable udev monitor");
 366                 return r;
 367         }
 368
 369         r = sd_event_add_io(m->event,
 370                         &m->udev_event_source,
 371                         udev_monitor_get_fd(m->udev_monitor),
 372                         EPOLLIN, manager_dispatch_link_udev,
 373                         m);
 374         if (r < 0)
 375                 return r;
 376
 377         r = sd_event_source_set_description(m->udev_event_source, "networkd-udev");
 378         if (r < 0)
 379                 return r;
 380
 381         return 0;
 382 }
 383
 384 int manager_rtnl_listen(Manager *m) {
 385         int r;
 386
 387         assert(m);
 388
 389         r = sd_rtnl_attach_event(m->rtnl, m->event, 0);
 390         if (r < 0)
 391                 return r;
 392
 393         r = sd_rtnl_add_match(m->rtnl, RTM_NEWLINK, &manager_rtnl_process_link, m);
 394         if (r < 0)
 395                 return r;
 396
 397         r = sd_rtnl_add_match(m->rtnl, RTM_DELLINK, &manager_rtnl_process_link, m);
 398         if (r < 0)
 399                 return r;
 400
 401         r = sd_rtnl_add_match(m->rtnl, RTM_NEWADDR, &link_rtnl_process_address, m);
 402         if (r < 0)
 403                 return r;
 404
 405         r = sd_rtnl_add_match(m->rtnl, RTM_DELADDR, &link_rtnl_process_address, m);
 406         if (r < 0)
 407                 return r;
 408
 409         return 0;
 410 }
 411
 412 int manager_bus_listen(Manager *m) {
 413         int r;
 414
 415         assert(m->event);
 416
 417         if (!m->bus) /* TODO: drop when we can rely on kdbus */
 418                 return 0;
 419
 420         r = sd_bus_attach_event(m->bus, m->event, 0);
 421         if (r < 0)
 422                 return r;
 423
 424         return 0;
 425 }
 426
 427 static int set_put_in_addr(Set *s, const struct in_addr *address) {
 428         char *p;
 429         int r;
 430
 431         assert(s);
 432
 433         r = in_addr_to_string(AF_INET, (const union in_addr_union*) address, &p);
 434         if (r < 0)
 435                 return r;
 436
 437         r = set_consume(s, p);
 438         if (r == -EEXIST)
 439                 return 0;
 440
 441         return r;
 442 }
 443
 444 static int set_put_in_addrv(Set *s, const struct in_addr *addresses, int n) {
 445         int r, i, c = 0;
 446
 447         assert(s);
 448         assert(n <= 0 || addresses);
 449
 450         for (i = 0; i < n; i++) {
 451                 r = set_put_in_addr(s, addresses+i);
 452                 if (r < 0)
 453                         return r;
 454
 455                 c += r;
 456         }
 457
 458         return c;
 459 }
 460
 461 static void print_string_set(FILE *f, const char *field, Set *s) {
 462         bool space = false;
 463         Iterator i;
 464         char *p;
 465
 466         if (set_isempty(s))
 467                 return;
 468
 469         fputs(field, f);
 470
 471         SET_FOREACH(p, s, i) {
 472                 if (space)
 473                         fputc(' ', f);
 474                 fputs(p, f);
 475                 space = true;
 476         }
 477         fputc('\n', f);
 478 }
 479
 480 int manager_save(Manager *m) {
 481         _cleanup_set_free_free_ Set *dns = NULL, *ntp = NULL, *domains = NULL;
 482         Link *link;
 483         Iterator i;
 484         _cleanup_free_ char *temp_path = NULL;
 485         _cleanup_fclose_ FILE *f = NULL;
 486         LinkOperationalState operstate = LINK_OPERSTATE_OFF;
 487         const char *operstate_str;
 488         int r;
 489
 490         assert(m);
 491         assert(m->state_file);
 492
 493         /* We add all NTP and DNS server to a set, to filter out duplicates */
 494         dns = set_new(&string_hash_ops);
 495         if (!dns)
 496                 return -ENOMEM;
 497
 498         ntp = set_new(&string_hash_ops);
 499         if (!ntp)
 500                 return -ENOMEM;
 501
 502         domains = set_new(&string_hash_ops);
 503         if (!domains)
 504                 return -ENOMEM;
 505
 506         HASHMAP_FOREACH(link, m->links, i) {
 507                 if (link->flags & IFF_LOOPBACK)
 508                         continue;
 509
 510                 if (link->operstate > operstate)
 511                         operstate = link->operstate;
 512
 513                 if (!link->network)
 514                         continue;
 515
 516                 /* First add the static configured entries */
 517                 r = set_put_strdupv(dns, link->network->dns);
 518                 if (r < 0)
 519                         return r;
 520
 521                 r = set_put_strdupv(ntp, link->network->ntp);
 522                 if (r < 0)
 523                         return r;
 524
 525                 r = set_put_strdupv(domains, link->network->domains);
 526                 if (r < 0)
 527                         return r;
 528
 529                 if (!link->dhcp_lease)
 530                         continue;
 531
 532                 /* Secondly, add the entries acquired via DHCP */
 533                 if (link->network->dhcp_dns) {
 534                         const struct in_addr *addresses;
 535
 536                         r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
 537                         if (r > 0) {
 538                                 r = set_put_in_addrv(dns, addresses, r);
 539                                 if (r < 0)
 540                                         return r;
 541                         } else if (r < 0 && r != -ENOENT)
 542                                 return r;
 543                 }
 544
 545                 if (link->network->dhcp_ntp) {
 546                         const struct in_addr *addresses;
 547
 548                         r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
 549                         if (r > 0) {
 550                                 r = set_put_in_addrv(ntp, addresses, r);
 551                                 if (r < 0)
 552                                         return r;
 553                         } else if (r < 0 && r != -ENOENT)
 554                                 return r;
 555                 }
 556
 557                 if (link->network->dhcp_domains) {
 558                         const char *domainname;
 559
 560                         r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
 561                         if (r >= 0) {
 562                                 r = set_put_strdup(domains, domainname);
 563                                 if (r < 0)
 564                                         return r;
 565                         } else if (r != -ENOENT)
 566                                 return r;
 567                 }
 568         }
 569
 570         operstate_str = link_operstate_to_string(operstate);
 571         assert(operstate_str);
 572
 573         r = fopen_temporary(m->state_file, &f, &temp_path);
 574         if (r < 0)
 575                 return r;
 576
 577         fchmod(fileno(f), 0644);
 578
 579         fprintf(f,
 580                 "# This is private data. Do not parse.\n"
 581                 "OPER_STATE=%s\n", operstate_str);
 582
 583         print_string_set(f, "DNS=", dns);
 584         print_string_set(f, "NTP=", ntp);
 585         print_string_set(f, "DOMAINS=", domains);
 586
 587         r = fflush_and_check(f);
 588         if (r < 0)
 589                 goto fail;
 590
 591         if (rename(temp_path, m->state_file) < 0) {
 592                 r = -errno;
 593                 goto fail;
 594         }
 595
 596         return 0;
 597
 598 fail:
 599         log_error_errno(r, "Failed to save network state to %s: %m", m->state_file);
 600         unlink(m->state_file);
 601         unlink(temp_path);
 602         return r;
 603 }
 604
 605 int manager_address_pool_acquire(Manager *m, int family, unsigned prefixlen, union in_addr_union *found) {
 606         AddressPool *p;
 607         int r;
 608
 609         assert(m);
 610         assert(prefixlen > 0);
 611         assert(found);
 612
 613         LIST_FOREACH(address_pools, p, m->address_pools) {
 614                 if (p->family != family)
 615                         continue;
 616
 617                 r = address_pool_acquire(p, prefixlen, found);
 618                 if (r != 0)
 619                         return r;
 620         }
 621
 622         return 0;
 623 }