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 "sd-daemon.h"
  26 #include "sd-netlink.h"
  27
  28 #include "alloc-util.h"
  29 #include "bus-util.h"
  30 #include "conf-parser.h"
  31 #include "def.h"
  32 #include "fd-util.h"
  33 #include "fileio.h"
  34 #include "libudev-private.h"
  35 #include "local-addresses.h"
  36 #include "netlink-util.h"
  37 #include "networkd.h"
  38 #include "ordered-set.h"
  39 #include "path-util.h"
  40 #include "set.h"
  41 #include "udev-util.h"
  42 #include "virt.h"
  43
  44 /* use 8 MB for receive socket kernel queue. */
  45 #define RCVBUF_SIZE    (8*1024*1024)
  46
  47 const char* const network_dirs[] = {
  48         "/etc/systemd/network",
  49         "/run/systemd/network",
  50         "/usr/lib/systemd/network",
  51 #ifdef HAVE_SPLIT_USR
  52         "/lib/systemd/network",
  53 #endif
  54         NULL};
  55
  56 static int setup_default_address_pool(Manager *m) {
  57         AddressPool *p;
  58         int r;
  59
  60         assert(m);
  61
  62         /* Add in the well-known private address ranges. */
  63
  64         r = address_pool_new_from_string(m, &p, AF_INET6, "fc00::", 7);
  65         if (r < 0)
  66                 return r;
  67
  68         r = address_pool_new_from_string(m, &p, AF_INET, "192.168.0.0", 16);
  69         if (r < 0)
  70                 return r;
  71
  72         r = address_pool_new_from_string(m, &p, AF_INET, "172.16.0.0", 12);
  73         if (r < 0)
  74                 return r;
  75
  76         r = address_pool_new_from_string(m, &p, AF_INET, "10.0.0.0", 8);
  77         if (r < 0)
  78                 return r;
  79
  80         return 0;
  81 }
  82
  83 static int on_bus_retry(sd_event_source *s, usec_t usec, void *userdata) {
  84         Manager *m = userdata;
  85
  86         assert(s);
  87         assert(m);
  88
  89         m->bus_retry_event_source = sd_event_source_unref(m->bus_retry_event_source);
  90
  91         manager_connect_bus(m);
  92
  93         return 0;
  94 }
  95
  96 static int manager_reset_all(Manager *m) {
  97         Link *link;
  98         Iterator i;
  99         int r;
 100
 101         assert(m);
 102
 103         HASHMAP_FOREACH(link, m->links, i) {
 104                 r = link_carrier_reset(link);
 105                 if (r < 0)
 106                         log_link_warning_errno(link, r, "Could not reset carrier: %m");
 107         }
 108
 109         return 0;
 110 }
 111
 112 static int match_prepare_for_sleep(sd_bus_message *message, void *userdata, sd_bus_error *ret_error) {
 113         Manager *m = userdata;
 114         int b, r;
 115
 116         assert(message);
 117
 118         r = sd_bus_message_read(message, "b", &b);
 119         if (r < 0) {
 120                 log_debug_errno(r, "Failed to parse PrepareForSleep signal: %m");
 121                 return 0;
 122         }
 123
 124         if (b)
 125                 return 0;
 126
 127         log_debug("Coming back from suspend, resetting all connections...");
 128
 129         manager_reset_all(m);
 130
 131         return 0;
 132 }
 133
 134 int manager_connect_bus(Manager *m) {
 135         int r;
 136
 137         assert(m);
 138
 139         r = sd_bus_default_system(&m->bus);
 140         if (r == -ENOENT) {
 141                 /* We failed to connect? Yuck, we must be in early
 142                  * boot. Let's try in 5s again. As soon as we have
 143                  * kdbus we can stop doing this... */
 144
 145                 log_debug_errno(r, "Failed to connect to bus, trying again in 5s: %m");
 146
 147                 r = sd_event_add_time(m->event, &m->bus_retry_event_source, CLOCK_MONOTONIC, now(CLOCK_MONOTONIC) + 5*USEC_PER_SEC, 0, on_bus_retry, m);
 148                 if (r < 0)
 149                         return log_error_errno(r, "Failed to install bus reconnect time event: %m");
 150
 151                 return 0;
 152         }
 153
 154         if (r < 0)
 155                 return r;
 156
 157         r = sd_bus_add_match(m->bus, &m->prepare_for_sleep_slot,
 158                              "type='signal',"
 159                              "sender='org.freedesktop.login1',"
 160                              "interface='org.freedesktop.login1.Manager',"
 161                              "member='PrepareForSleep',"
 162                              "path='/org/freedesktop/login1'",
 163                              match_prepare_for_sleep,
 164                              m);
 165         if (r < 0)
 166                 return log_error_errno(r, "Failed to add match for PrepareForSleep: %m");
 167
 168         r = sd_bus_add_object_vtable(m->bus, NULL, "/org/freedesktop/network1", "org.freedesktop.network1.Manager", manager_vtable, m);
 169         if (r < 0)
 170                 return log_error_errno(r, "Failed to add manager object vtable: %m");
 171
 172         r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/network1/link", "org.freedesktop.network1.Link", link_vtable, link_object_find, m);
 173         if (r < 0)
 174                return log_error_errno(r, "Failed to add link object vtable: %m");
 175
 176         r = sd_bus_add_node_enumerator(m->bus, NULL, "/org/freedesktop/network1/link", link_node_enumerator, m);
 177         if (r < 0)
 178                 return log_error_errno(r, "Failed to add link enumerator: %m");
 179
 180         r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/network1/network", "org.freedesktop.network1.Network", network_vtable, network_object_find, m);
 181         if (r < 0)
 182                return log_error_errno(r, "Failed to add network object vtable: %m");
 183
 184         r = sd_bus_add_node_enumerator(m->bus, NULL, "/org/freedesktop/network1/network", network_node_enumerator, m);
 185         if (r < 0)
 186                 return log_error_errno(r, "Failed to add network enumerator: %m");
 187
 188         r = sd_bus_request_name(m->bus, "org.freedesktop.network1", 0);
 189         if (r < 0)
 190                 return log_error_errno(r, "Failed to register name: %m");
 191
 192         r = sd_bus_attach_event(m->bus, m->event, 0);
 193         if (r < 0)
 194                 return log_error_errno(r, "Failed to attach bus to event loop: %m");
 195
 196         return 0;
 197 }
 198
 199 static int manager_udev_process_link(Manager *m, struct udev_device *device) {
 200         Link *link = NULL;
 201         int r, ifindex;
 202
 203         assert(m);
 204         assert(device);
 205
 206         if (!streq_ptr(udev_device_get_action(device), "add"))
 207                 return 0;
 208
 209         ifindex = udev_device_get_ifindex(device);
 210         if (ifindex <= 0) {
 211                 log_debug("Ignoring udev ADD event for device with invalid ifindex");
 212                 return 0;
 213         }
 214
 215         r = link_get(m, ifindex, &link);
 216         if (r == -ENODEV)
 217                 return 0;
 218         else if (r < 0)
 219                 return r;
 220
 221         r = link_initialized(link, device);
 222         if (r < 0)
 223                 return r;
 224
 225         return 0;
 226 }
 227
 228 static int manager_dispatch_link_udev(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
 229         Manager *m = userdata;
 230         struct udev_monitor *monitor = m->udev_monitor;
 231         _cleanup_udev_device_unref_ struct udev_device *device = NULL;
 232
 233         device = udev_monitor_receive_device(monitor);
 234         if (!device)
 235                 return -ENOMEM;
 236
 237         manager_udev_process_link(m, device);
 238         return 0;
 239 }
 240
 241 static int manager_connect_udev(Manager *m) {
 242         int r;
 243
 244         /* udev does not initialize devices inside containers,
 245          * so we rely on them being already initialized before
 246          * entering the container */
 247         if (detect_container() > 0)
 248                 return 0;
 249
 250         m->udev = udev_new();
 251         if (!m->udev)
 252                 return -ENOMEM;
 253
 254         m->udev_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
 255         if (!m->udev_monitor)
 256                 return -ENOMEM;
 257
 258         r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_monitor, "net", NULL);
 259         if (r < 0)
 260                 return log_error_errno(r, "Could not add udev monitor filter: %m");
 261
 262         r = udev_monitor_enable_receiving(m->udev_monitor);
 263         if (r < 0) {
 264                 log_error("Could not enable udev monitor");
 265                 return r;
 266         }
 267
 268         r = sd_event_add_io(m->event,
 269                         &m->udev_event_source,
 270                         udev_monitor_get_fd(m->udev_monitor),
 271                         EPOLLIN, manager_dispatch_link_udev,
 272                         m);
 273         if (r < 0)
 274                 return r;
 275
 276         r = sd_event_source_set_description(m->udev_event_source, "networkd-udev");
 277         if (r < 0)
 278                 return r;
 279
 280         return 0;
 281 }
 282
 283 int manager_rtnl_process_route(sd_netlink *rtnl, sd_netlink_message *message, void *userdata) {
 284         Manager *m = userdata;
 285         Link *link = NULL;
 286         uint16_t type;
 287         uint32_t ifindex, priority = 0;
 288         unsigned char protocol, scope, tos, table;
 289         int family;
 290         unsigned char dst_prefixlen, src_prefixlen;
 291         union in_addr_union dst = {}, gw = {}, src = {}, prefsrc = {};
 292         Route *route = NULL;
 293         int r;
 294
 295         assert(rtnl);
 296         assert(message);
 297         assert(m);
 298
 299         if (sd_netlink_message_is_error(message)) {
 300                 r = sd_netlink_message_get_errno(message);
 301                 if (r < 0)
 302                         log_warning_errno(r, "rtnl: failed to receive route: %m");
 303
 304                 return 0;
 305         }
 306
 307         r = sd_netlink_message_get_type(message, &type);
 308         if (r < 0) {
 309                 log_warning_errno(r, "rtnl: could not get message type: %m");
 310                 return 0;
 311         } else if (type != RTM_NEWROUTE && type != RTM_DELROUTE) {
 312                 log_warning("rtnl: received unexpected message type when processing route");
 313                 return 0;
 314         }
 315
 316         r = sd_netlink_message_read_u32(message, RTA_OIF, &ifindex);
 317         if (r == -ENODATA) {
 318                 log_debug("rtnl: received route without ifindex, ignoring");
 319                 return 0;
 320         } else if (r < 0) {
 321                 log_warning_errno(r, "rtnl: could not get ifindex from route, ignoring: %m");
 322                 return 0;
 323         } else if (ifindex <= 0) {
 324                 log_warning("rtnl: received route message with invalid ifindex, ignoring: %d", ifindex);
 325                 return 0;
 326         } else {
 327                 r = link_get(m, ifindex, &link);
 328                 if (r < 0 || !link) {
 329                         /* when enumerating we might be out of sync, but we will
 330                          * get the route again, so just ignore it */
 331                         if (!m->enumerating)
 332                                 log_warning("rtnl: received route for nonexistent link (%d), ignoring", ifindex);
 333                         return 0;
 334                 }
 335         }
 336
 337         r = sd_rtnl_message_route_get_family(message, &family);
 338         if (r < 0 || !IN_SET(family, AF_INET, AF_INET6)) {
 339                 log_link_warning(link, "rtnl: received address with invalid family, ignoring.");
 340                 return 0;
 341         }
 342
 343         r = sd_rtnl_message_route_get_protocol(message, &protocol);
 344         if (r < 0) {
 345                 log_warning_errno(r, "rtnl: could not get route protocol: %m");
 346                 return 0;
 347         }
 348
 349         switch (family) {
 350         case AF_INET:
 351                 r = sd_netlink_message_read_in_addr(message, RTA_DST, &dst.in);
 352                 if (r < 0 && r != -ENODATA) {
 353                         log_link_warning_errno(link, r, "rtnl: received route without valid destination, ignoring: %m");
 354                         return 0;
 355                 }
 356
 357                 r = sd_netlink_message_read_in_addr(message, RTA_GATEWAY, &gw.in);
 358                 if (r < 0 && r != -ENODATA) {
 359                         log_link_warning_errno(link, r, "rtnl: received route with invalid gateway, ignoring: %m");
 360                         return 0;
 361                 }
 362
 363                 r = sd_netlink_message_read_in_addr(message, RTA_SRC, &src.in);
 364                 if (r < 0 && r != -ENODATA) {
 365                         log_link_warning_errno(link, r, "rtnl: received route with invalid source, ignoring: %m");
 366                         return 0;
 367                 }
 368
 369                 r = sd_netlink_message_read_in_addr(message, RTA_PREFSRC, &prefsrc.in);
 370                 if (r < 0 && r != -ENODATA) {
 371                         log_link_warning_errno(link, r, "rtnl: received route with invalid preferred source, ignoring: %m");
 372                         return 0;
 373                 }
 374
 375                 break;
 376
 377         case AF_INET6:
 378                 r = sd_netlink_message_read_in6_addr(message, RTA_DST, &dst.in6);
 379                 if (r < 0 && r != -ENODATA) {
 380                         log_link_warning_errno(link, r, "rtnl: received route without valid destination, ignoring: %m");
 381                         return 0;
 382                 }
 383
 384                 r = sd_netlink_message_read_in6_addr(message, RTA_GATEWAY, &gw.in6);
 385                 if (r < 0 && r != -ENODATA) {
 386                         log_link_warning_errno(link, r, "rtnl: received route with invalid gateway, ignoring: %m");
 387                         return 0;
 388                 }
 389
 390                 r = sd_netlink_message_read_in6_addr(message, RTA_SRC, &src.in6);
 391                 if (r < 0 && r != -ENODATA) {
 392                         log_link_warning_errno(link, r, "rtnl: received route with invalid source, ignoring: %m");
 393                         return 0;
 394                 }
 395
 396                 r = sd_netlink_message_read_in6_addr(message, RTA_PREFSRC, &prefsrc.in6);
 397                 if (r < 0 && r != -ENODATA) {
 398                         log_link_warning_errno(link, r, "rtnl: received route with invalid preferred source, ignoring: %m");
 399                         return 0;
 400                 }
 401
 402                 break;
 403
 404         default:
 405                 log_link_debug(link, "rtnl: ignoring unsupported address family: %d", family);
 406                 return 0;
 407         }
 408
 409         r = sd_rtnl_message_route_get_dst_prefixlen(message, &dst_prefixlen);
 410         if (r < 0) {
 411                 log_link_warning_errno(link, r, "rtnl: received route with invalid destination prefixlen, ignoring: %m");
 412                 return 0;
 413         }
 414
 415         r = sd_rtnl_message_route_get_src_prefixlen(message, &src_prefixlen);
 416         if (r < 0) {
 417                 log_link_warning_errno(link, r, "rtnl: received route with invalid source prefixlen, ignoring: %m");
 418                 return 0;
 419         }
 420
 421         r = sd_rtnl_message_route_get_scope(message, &scope);
 422         if (r < 0) {
 423                 log_link_warning_errno(link, r, "rtnl: received route with invalid scope, ignoring: %m");
 424                 return 0;
 425         }
 426
 427         r = sd_rtnl_message_route_get_tos(message, &tos);
 428         if (r < 0) {
 429                 log_link_warning_errno(link, r, "rtnl: received route with invalid tos, ignoring: %m");
 430                 return 0;
 431         }
 432
 433         r = sd_rtnl_message_route_get_table(message, &table);
 434         if (r < 0) {
 435                 log_link_warning_errno(link, r, "rtnl: received route with invalid table, ignoring: %m");
 436                 return 0;
 437         }
 438
 439         r = sd_netlink_message_read_u32(message, RTA_PRIORITY, &priority);
 440         if (r < 0 && r != -ENODATA) {
 441                 log_link_warning_errno(link, r, "rtnl: received route with invalid priority, ignoring: %m");
 442                 return 0;
 443         }
 444
 445         route_get(link, family, &dst, dst_prefixlen, tos, priority, table, &route);
 446
 447         switch (type) {
 448         case RTM_NEWROUTE:
 449                 if (!route) {
 450                         /* A route appeared that we did not request */
 451                         r = route_add_foreign(link, family, &dst, dst_prefixlen, tos, priority, table, &route);
 452                         if (r < 0)
 453                                 return 0;
 454                 }
 455
 456                 route_update(route, &src, src_prefixlen, &gw, &prefsrc, scope, protocol);
 457
 458                 break;
 459
 460         case RTM_DELROUTE:
 461
 462                 if (route)
 463                         route_drop(route);
 464
 465                 break;
 466         default:
 467                 assert_not_reached("Received invalid RTNL message type");
 468         }
 469
 470         return 1;
 471 }
 472
 473 int manager_rtnl_process_address(sd_netlink *rtnl, sd_netlink_message *message, void *userdata) {
 474         Manager *m = userdata;
 475         Link *link = NULL;
 476         uint16_t type;
 477         unsigned char flags;
 478         int family;
 479         unsigned char prefixlen;
 480         unsigned char scope;
 481         union in_addr_union in_addr;
 482         struct ifa_cacheinfo cinfo;
 483         Address *address = NULL;
 484         char buf[INET6_ADDRSTRLEN], valid_buf[FORMAT_TIMESPAN_MAX];
 485         const char *valid_str = NULL;
 486         int r, ifindex;
 487
 488         assert(rtnl);
 489         assert(message);
 490         assert(m);
 491
 492         if (sd_netlink_message_is_error(message)) {
 493                 r = sd_netlink_message_get_errno(message);
 494                 if (r < 0)
 495                         log_warning_errno(r, "rtnl: failed to receive address: %m");
 496
 497                 return 0;
 498         }
 499
 500         r = sd_netlink_message_get_type(message, &type);
 501         if (r < 0) {
 502                 log_warning_errno(r, "rtnl: could not get message type: %m");
 503                 return 0;
 504         } else if (type != RTM_NEWADDR && type != RTM_DELADDR) {
 505                 log_warning("rtnl: received unexpected message type when processing address");
 506                 return 0;
 507         }
 508
 509         r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
 510         if (r < 0) {
 511                 log_warning_errno(r, "rtnl: could not get ifindex from address: %m");
 512                 return 0;
 513         } else if (ifindex <= 0) {
 514                 log_warning("rtnl: received address message with invalid ifindex: %d", ifindex);
 515                 return 0;
 516         } else {
 517                 r = link_get(m, ifindex, &link);
 518                 if (r < 0 || !link) {
 519                         /* when enumerating we might be out of sync, but we will
 520                          * get the address again, so just ignore it */
 521                         if (!m->enumerating)
 522                                 log_warning("rtnl: received address for nonexistent link (%d), ignoring", ifindex);
 523                         return 0;
 524                 }
 525         }
 526
 527         r = sd_rtnl_message_addr_get_family(message, &family);
 528         if (r < 0 || !IN_SET(family, AF_INET, AF_INET6)) {
 529                 log_link_warning(link, "rtnl: received address with invalid family, ignoring.");
 530                 return 0;
 531         }
 532
 533         r = sd_rtnl_message_addr_get_prefixlen(message, &prefixlen);
 534         if (r < 0) {
 535                 log_link_warning_errno(link, r, "rtnl: received address with invalid prefixlen, ignoring: %m");
 536                 return 0;
 537         }
 538
 539         r = sd_rtnl_message_addr_get_scope(message, &scope);
 540         if (r < 0) {
 541                 log_link_warning_errno(link, r, "rtnl: received address with invalid scope, ignoring: %m");
 542                 return 0;
 543         }
 544
 545         r = sd_rtnl_message_addr_get_flags(message, &flags);
 546         if (r < 0) {
 547                 log_link_warning_errno(link, r, "rtnl: received address with invalid flags, ignoring: %m");
 548                 return 0;
 549         }
 550
 551         switch (family) {
 552         case AF_INET:
 553                 r = sd_netlink_message_read_in_addr(message, IFA_LOCAL, &in_addr.in);
 554                 if (r < 0) {
 555                         log_link_warning_errno(link, r, "rtnl: received address without valid address, ignoring: %m");
 556                         return 0;
 557                 }
 558
 559                 break;
 560
 561         case AF_INET6:
 562                 r = sd_netlink_message_read_in6_addr(message, IFA_ADDRESS, &in_addr.in6);
 563                 if (r < 0) {
 564                         log_link_warning_errno(link, r, "rtnl: received address without valid address, ignoring: %m");
 565                         return 0;
 566                 }
 567
 568                 break;
 569
 570         default:
 571                 log_link_debug(link, "rtnl: ignoring unsupported address family: %d", family);
 572         }
 573
 574         if (!inet_ntop(family, &in_addr, buf, INET6_ADDRSTRLEN)) {
 575                 log_link_warning(link, "Could not print address");
 576                 return 0;
 577         }
 578
 579         r = sd_netlink_message_read_cache_info(message, IFA_CACHEINFO, &cinfo);
 580         if (r >= 0) {
 581                 if (cinfo.ifa_valid != CACHE_INFO_INFINITY_LIFE_TIME)
 582                         valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
 583                                                     cinfo.ifa_valid * USEC_PER_SEC,
 584                                                     USEC_PER_SEC);
 585         }
 586
 587         address_get(link, family, &in_addr, prefixlen, &address);
 588
 589         switch (type) {
 590         case RTM_NEWADDR:
 591                 if (address)
 592                         log_link_debug(link, "Updating address: %s/%u (valid %s%s)", buf, prefixlen,
 593                                        valid_str ? "for " : "forever", valid_str ?: "");
 594                 else {
 595                         /* An address appeared that we did not request */
 596                         r = address_add_foreign(link, family, &in_addr, prefixlen, &address);
 597                         if (r < 0) {
 598                                 log_link_warning_errno(link, r, "Failed to add address %s/%u: %m", buf, prefixlen);
 599                                 return 0;
 600                         } else
 601                                 log_link_debug(link, "Adding address: %s/%u (valid %s%s)", buf, prefixlen,
 602                                                valid_str ? "for " : "forever", valid_str ?: "");
 603                 }
 604
 605                 address_update(address, flags, scope, &cinfo);
 606
 607                 break;
 608
 609         case RTM_DELADDR:
 610
 611                 if (address) {
 612                         log_link_debug(link, "Removing address: %s/%u (valid %s%s)", buf, prefixlen,
 613                                        valid_str ? "for " : "forever", valid_str ?: "");
 614                         address_drop(address);
 615                 } else
 616                         log_link_warning(link, "Removing non-existent address: %s/%u (valid %s%s)", buf, prefixlen,
 617                                          valid_str ? "for " : "forever", valid_str ?: "");
 618
 619                 break;
 620         default:
 621                 assert_not_reached("Received invalid RTNL message type");
 622         }
 623
 624         return 1;
 625 }
 626
 627 static int manager_rtnl_process_link(sd_netlink *rtnl, sd_netlink_message *message, void *userdata) {
 628         Manager *m = userdata;
 629         Link *link = NULL;
 630         NetDev *netdev = NULL;
 631         uint16_t type;
 632         const char *name;
 633         int r, ifindex;
 634
 635         assert(rtnl);
 636         assert(message);
 637         assert(m);
 638
 639         if (sd_netlink_message_is_error(message)) {
 640                 r = sd_netlink_message_get_errno(message);
 641                 if (r < 0)
 642                         log_warning_errno(r, "rtnl: Could not receive link: %m");
 643
 644                 return 0;
 645         }
 646
 647         r = sd_netlink_message_get_type(message, &type);
 648         if (r < 0) {
 649                 log_warning_errno(r, "rtnl: Could not get message type: %m");
 650                 return 0;
 651         } else if (type != RTM_NEWLINK && type != RTM_DELLINK) {
 652                 log_warning("rtnl: Received unexpected message type when processing link");
 653                 return 0;
 654         }
 655
 656         r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
 657         if (r < 0) {
 658                 log_warning_errno(r, "rtnl: Could not get ifindex from link: %m");
 659                 return 0;
 660         } else if (ifindex <= 0) {
 661                 log_warning("rtnl: received link message with invalid ifindex: %d", ifindex);
 662                 return 0;
 663         }
 664
 665         r = sd_netlink_message_read_string(message, IFLA_IFNAME, &name);
 666         if (r < 0) {
 667                 log_warning_errno(r, "rtnl: Received link message without ifname: %m");
 668                 return 0;
 669         }
 670
 671         (void) link_get(m, ifindex, &link);
 672         (void) netdev_get(m, name, &netdev);
 673
 674         switch (type) {
 675         case RTM_NEWLINK:
 676                 if (!link) {
 677                         /* link is new, so add it */
 678                         r = link_add(m, message, &link);
 679                         if (r < 0) {
 680                                 log_warning_errno(r, "Could not add new link: %m");
 681                                 return 0;
 682                         }
 683                 }
 684
 685                 if (netdev) {
 686                         /* netdev exists, so make sure the ifindex matches */
 687                         r = netdev_set_ifindex(netdev, message);
 688                         if (r < 0) {
 689                                 log_warning_errno(r, "Could not set ifindex on netdev: %m");
 690                                 return 0;
 691                         }
 692                 }
 693
 694                 r = link_update(link, message);
 695                 if (r < 0)
 696                         return 0;
 697
 698                 break;
 699
 700         case RTM_DELLINK:
 701                 link_drop(link);
 702                 netdev_drop(netdev);
 703
 704                 break;
 705
 706         default:
 707                 assert_not_reached("Received invalid RTNL message type.");
 708         }
 709
 710         return 1;
 711 }
 712
 713 static int systemd_netlink_fd(void) {
 714         int n, fd, rtnl_fd = -EINVAL;
 715
 716         n = sd_listen_fds(true);
 717         if (n <= 0)
 718                 return -EINVAL;
 719
 720         for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++) {
 721                 if (sd_is_socket(fd, AF_NETLINK, SOCK_RAW, -1) > 0) {
 722                         if (rtnl_fd >= 0)
 723                                 return -EINVAL;
 724
 725                         rtnl_fd = fd;
 726                 }
 727         }
 728
 729         return rtnl_fd;
 730 }
 731
 732 static int manager_connect_rtnl(Manager *m) {
 733         int fd, r;
 734
 735         assert(m);
 736
 737         fd = systemd_netlink_fd();
 738         if (fd < 0)
 739                 r = sd_netlink_open(&m->rtnl);
 740         else
 741                 r = sd_netlink_open_fd(&m->rtnl, fd);
 742         if (r < 0)
 743                 return r;
 744
 745         r = sd_netlink_inc_rcvbuf(m->rtnl, RCVBUF_SIZE);
 746         if (r < 0)
 747                 return r;
 748
 749         r = sd_netlink_attach_event(m->rtnl, m->event, 0);
 750         if (r < 0)
 751                 return r;
 752
 753         r = sd_netlink_add_match(m->rtnl, RTM_NEWLINK, &manager_rtnl_process_link, m);
 754         if (r < 0)
 755                 return r;
 756
 757         r = sd_netlink_add_match(m->rtnl, RTM_DELLINK, &manager_rtnl_process_link, m);
 758         if (r < 0)
 759                 return r;
 760
 761         r = sd_netlink_add_match(m->rtnl, RTM_NEWADDR, &manager_rtnl_process_address, m);
 762         if (r < 0)
 763                 return r;
 764
 765         r = sd_netlink_add_match(m->rtnl, RTM_DELADDR, &manager_rtnl_process_address, m);
 766         if (r < 0)
 767                 return r;
 768
 769         r = sd_netlink_add_match(m->rtnl, RTM_NEWROUTE, &manager_rtnl_process_route, m);
 770         if (r < 0)
 771                 return r;
 772
 773         r = sd_netlink_add_match(m->rtnl, RTM_DELROUTE, &manager_rtnl_process_route, m);
 774         if (r < 0)
 775                 return r;
 776
 777         return 0;
 778 }
 779
 780 static int ordered_set_put_in_addr(OrderedSet *s, const struct in_addr *address) {
 781         char *p;
 782         int r;
 783
 784         assert(s);
 785
 786         r = in_addr_to_string(AF_INET, (const union in_addr_union*) address, &p);
 787         if (r < 0)
 788                 return r;
 789
 790         r = ordered_set_consume(s, p);
 791         if (r == -EEXIST)
 792                 return 0;
 793
 794         return r;
 795 }
 796
 797 static int ordered_set_put_in_addrv(OrderedSet *s, const struct in_addr *addresses, int n) {
 798         int r, i, c = 0;
 799
 800         assert(s);
 801         assert(n <= 0 || addresses);
 802
 803         for (i = 0; i < n; i++) {
 804                 r = ordered_set_put_in_addr(s, addresses+i);
 805                 if (r < 0)
 806                         return r;
 807
 808                 c += r;
 809         }
 810
 811         return c;
 812 }
 813
 814 static void print_string_set(FILE *f, const char *field, OrderedSet *s) {
 815         bool space = false;
 816         Iterator i;
 817         char *p;
 818
 819         if (ordered_set_isempty(s))
 820                 return;
 821
 822         fputs(field, f);
 823
 824         ORDERED_SET_FOREACH(p, s, i) {
 825                 if (space)
 826                         fputc(' ', f);
 827                 fputs(p, f);
 828                 space = true;
 829         }
 830         fputc('\n', f);
 831 }
 832
 833 static int manager_save(Manager *m) {
 834         _cleanup_ordered_set_free_free_ OrderedSet *dns = NULL, *ntp = NULL, *search_domains = NULL, *route_domains = NULL;
 835         Link *link;
 836         Iterator i;
 837         _cleanup_free_ char *temp_path = NULL;
 838         _cleanup_fclose_ FILE *f = NULL;
 839         LinkOperationalState operstate = LINK_OPERSTATE_OFF;
 840         const char *operstate_str;
 841         int r;
 842
 843         assert(m);
 844         assert(m->state_file);
 845
 846         /* We add all NTP and DNS server to a set, to filter out duplicates */
 847         dns = ordered_set_new(&string_hash_ops);
 848         if (!dns)
 849                 return -ENOMEM;
 850
 851         ntp = ordered_set_new(&string_hash_ops);
 852         if (!ntp)
 853                 return -ENOMEM;
 854
 855         search_domains = ordered_set_new(&string_hash_ops);
 856         if (!search_domains)
 857                 return -ENOMEM;
 858
 859         route_domains = ordered_set_new(&string_hash_ops);
 860         if (!route_domains)
 861                 return -ENOMEM;
 862
 863         HASHMAP_FOREACH(link, m->links, i) {
 864                 if (link->flags & IFF_LOOPBACK)
 865                         continue;
 866
 867                 if (link->operstate > operstate)
 868                         operstate = link->operstate;
 869
 870                 if (!link->network)
 871                         continue;
 872
 873                 /* First add the static configured entries */
 874                 r = ordered_set_put_strdupv(dns, link->network->dns);
 875                 if (r < 0)
 876                         return r;
 877
 878                 r = ordered_set_put_strdupv(ntp, link->network->ntp);
 879                 if (r < 0)
 880                         return r;
 881
 882                 r = ordered_set_put_strdupv(search_domains, link->network->search_domains);
 883                 if (r < 0)
 884                         return r;
 885
 886                 r = ordered_set_put_strdupv(route_domains, link->network->route_domains);
 887                 if (r < 0)
 888                         return r;
 889
 890                 if (!link->dhcp_lease)
 891                         continue;
 892
 893                 /* Secondly, add the entries acquired via DHCP */
 894                 if (link->network->dhcp_dns) {
 895                         const struct in_addr *addresses;
 896
 897                         r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
 898                         if (r > 0) {
 899                                 r = ordered_set_put_in_addrv(dns, addresses, r);
 900                                 if (r < 0)
 901                                         return r;
 902                         } else if (r < 0 && r != -ENODATA)
 903                                 return r;
 904                 }
 905
 906                 if (link->network->dhcp_ntp) {
 907                         const struct in_addr *addresses;
 908
 909                         r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
 910                         if (r > 0) {
 911                                 r = ordered_set_put_in_addrv(ntp, addresses, r);
 912                                 if (r < 0)
 913                                         return r;
 914                         } else if (r < 0 && r != -ENODATA)
 915                                 return r;
 916                 }
 917
 918                 if (link->network->dhcp_domains) {
 919                         const char *domainname;
 920
 921                         r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
 922                         if (r >= 0) {
 923                                 r = ordered_set_put_strdup(search_domains, domainname);
 924                                 if (r < 0)
 925                                         return r;
 926                         } else if (r != -ENODATA)
 927                                 return r;
 928                 }
 929         }
 930
 931         operstate_str = link_operstate_to_string(operstate);
 932         assert(operstate_str);
 933
 934         r = fopen_temporary(m->state_file, &f, &temp_path);
 935         if (r < 0)
 936                 return r;
 937
 938         fchmod(fileno(f), 0644);
 939
 940         fprintf(f,
 941                 "# This is private data. Do not parse.\n"
 942                 "OPER_STATE=%s\n", operstate_str);
 943
 944         print_string_set(f, "DNS=", dns);
 945         print_string_set(f, "NTP=", ntp);
 946         print_string_set(f, "DOMAINS=", search_domains);
 947         print_string_set(f, "ROUTE_DOMAINS=", route_domains);
 948
 949         r = fflush_and_check(f);
 950         if (r < 0)
 951                 goto fail;
 952
 953         if (rename(temp_path, m->state_file) < 0) {
 954                 r = -errno;
 955                 goto fail;
 956         }
 957
 958         if (m->operational_state != operstate) {
 959                 m->operational_state = operstate;
 960                 r = manager_send_changed(m, "OperationalState", NULL);
 961                 if (r < 0)
 962                         log_error_errno(r, "Could not emit changed OperationalState: %m");
 963         }
 964
 965         m->dirty = false;
 966
 967         return 0;
 968
 969 fail:
 970         (void) unlink(m->state_file);
 971         (void) unlink(temp_path);
 972
 973         return log_error_errno(r, "Failed to save network state to %s: %m", m->state_file);
 974 }
 975
 976 static int manager_dirty_handler(sd_event_source *s, void *userdata) {
 977         Manager *m = userdata;
 978         Link *link;
 979         Iterator i;
 980         int r;
 981
 982         assert(m);
 983
 984         if (m->dirty)
 985                 manager_save(m);
 986
 987         SET_FOREACH(link, m->dirty_links, i) {
 988                 r = link_save(link);
 989                 if (r >= 0)
 990                         link_clean(link);
 991         }
 992
 993         return 1;
 994 }
 995
 996 int manager_new(Manager **ret) {
 997         _cleanup_manager_free_ Manager *m = NULL;
 998         int r;
 999
1000         m = new0(Manager, 1);
1001         if (!m)
1002                 return -ENOMEM;
1003
1004         m->state_file = strdup("/run/systemd/netif/state");
1005         if (!m->state_file)
1006                 return -ENOMEM;
1007
1008         r = sd_event_default(&m->event);
1009         if (r < 0)
1010                 return r;
1011
1012         sd_event_set_watchdog(m->event, true);
1013
1014         sd_event_add_signal(m->event, NULL, SIGTERM, NULL, NULL);
1015         sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
1016
1017         r = sd_event_add_post(m->event, NULL, manager_dirty_handler, m);
1018         if (r < 0)
1019                 return r;
1020
1021         r = manager_connect_rtnl(m);
1022         if (r < 0)
1023                 return r;
1024
1025         r = manager_connect_udev(m);
1026         if (r < 0)
1027                 return r;
1028
1029         m->netdevs = hashmap_new(&string_hash_ops);
1030         if (!m->netdevs)
1031                 return -ENOMEM;
1032
1033         LIST_HEAD_INIT(m->networks);
1034
1035         r = setup_default_address_pool(m);
1036         if (r < 0)
1037                 return r;
1038
1039         *ret = m;
1040         m = NULL;
1041
1042         return 0;
1043 }
1044
1045 void manager_free(Manager *m) {
1046         Network *network;
1047         NetDev *netdev;
1048         Link *link;
1049         AddressPool *pool;
1050
1051         if (!m)
1052                 return;
1053
1054         free(m->state_file);
1055
1056         while ((link = hashmap_first(m->links)))
1057                 link_unref(link);
1058         hashmap_free(m->links);
1059
1060         while ((network = m->networks))
1061                 network_free(network);
1062
1063         hashmap_free(m->networks_by_name);
1064
1065         while ((netdev = hashmap_first(m->netdevs)))
1066                 netdev_unref(netdev);
1067         hashmap_free(m->netdevs);
1068
1069         while ((pool = m->address_pools))
1070                 address_pool_free(pool);
1071
1072         sd_netlink_unref(m->rtnl);
1073         sd_event_unref(m->event);
1074
1075         sd_event_source_unref(m->udev_event_source);
1076         udev_monitor_unref(m->udev_monitor);
1077         udev_unref(m->udev);
1078
1079         sd_bus_unref(m->bus);
1080         sd_bus_slot_unref(m->prepare_for_sleep_slot);
1081         sd_event_source_unref(m->bus_retry_event_source);
1082
1083         free(m);
1084 }
1085
1086 static bool manager_check_idle(void *userdata) {
1087         Manager *m = userdata;
1088         Link *link;
1089         Iterator i;
1090
1091         assert(m);
1092
1093         HASHMAP_FOREACH(link, m->links, i) {
1094                 /* we are not woken on udev activity, so let's just wait for the
1095                  * pending udev event */
1096                 if (link->state == LINK_STATE_PENDING)
1097                         return false;
1098
1099                 if (!link->network)
1100                         continue;
1101
1102                 /* we are not woken on netork activity, so let's stay around */
1103                 if (link_lldp_enabled(link) ||
1104                     link_ipv4ll_enabled(link) ||
1105                     link_dhcp4_server_enabled(link) ||
1106                     link_dhcp4_enabled(link) ||
1107                     link_dhcp6_enabled(link) ||
1108                     link_ipv6_accept_ra_enabled(link))
1109                         return false;
1110         }
1111
1112         return true;
1113 }
1114
1115 int manager_run(Manager *m) {
1116         Link *link;
1117         Iterator i;
1118
1119         assert(m);
1120
1121         /* The dirty handler will deal with future serialization, but the first one
1122            must be done explicitly. */
1123
1124         manager_save(m);
1125
1126         HASHMAP_FOREACH(link, m->links, i)
1127                 link_save(link);
1128
1129         if (m->bus)
1130                 return bus_event_loop_with_idle(
1131                                 m->event,
1132                                 m->bus,
1133                                 "org.freedesktop.network1",
1134                                 DEFAULT_EXIT_USEC,
1135                                 manager_check_idle,
1136                                 m);
1137         else
1138                 /* failed to connect to the bus, so we lose exit-on-idle logic,
1139                    this should not happen except if dbus is not around at all */
1140                 return sd_event_loop(m->event);
1141 }
1142
1143 int manager_load_config(Manager *m) {
1144         int r;
1145
1146         /* update timestamp */
1147         paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, true);
1148
1149         r = netdev_load(m);
1150         if (r < 0)
1151                 return r;
1152
1153         r = network_load(m);
1154         if (r < 0)
1155                 return r;
1156
1157         return 0;
1158 }
1159
1160 bool manager_should_reload(Manager *m) {
1161         return paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, false);
1162 }
1163
1164 int manager_rtnl_enumerate_links(Manager *m) {
1165         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL;
1166         sd_netlink_message *link;
1167         int r;
1168
1169         assert(m);
1170         assert(m->rtnl);
1171
1172         r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
1173         if (r < 0)
1174                 return r;
1175
1176         r = sd_netlink_message_request_dump(req, true);
1177         if (r < 0)
1178                 return r;
1179
1180         r = sd_netlink_call(m->rtnl, req, 0, &reply);
1181         if (r < 0)
1182                 return r;
1183
1184         for (link = reply; link; link = sd_netlink_message_next(link)) {
1185                 int k;
1186
1187                 m->enumerating = true;
1188
1189                 k = manager_rtnl_process_link(m->rtnl, link, m);
1190                 if (k < 0)
1191                         r = k;
1192
1193                 m->enumerating = false;
1194         }
1195
1196         return r;
1197 }
1198
1199 int manager_rtnl_enumerate_addresses(Manager *m) {
1200         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL;
1201         sd_netlink_message *addr;
1202         int r;
1203
1204         assert(m);
1205         assert(m->rtnl);
1206
1207         r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, 0, 0);
1208         if (r < 0)
1209                 return r;
1210
1211         r = sd_netlink_message_request_dump(req, true);
1212         if (r < 0)
1213                 return r;
1214
1215         r = sd_netlink_call(m->rtnl, req, 0, &reply);
1216         if (r < 0)
1217                 return r;
1218
1219         for (addr = reply; addr; addr = sd_netlink_message_next(addr)) {
1220                 int k;
1221
1222                 m->enumerating = true;
1223
1224                 k = manager_rtnl_process_address(m->rtnl, addr, m);
1225                 if (k < 0)
1226                         r = k;
1227
1228                 m->enumerating = false;
1229         }
1230
1231         return r;
1232 }
1233
1234 int manager_rtnl_enumerate_routes(Manager *m) {
1235         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL;
1236         sd_netlink_message *route;
1237         int r;
1238
1239         assert(m);
1240         assert(m->rtnl);
1241
1242         r = sd_rtnl_message_new_route(m->rtnl, &req, RTM_GETROUTE, 0, 0);
1243         if (r < 0)
1244                 return r;
1245
1246         r = sd_netlink_message_request_dump(req, true);
1247         if (r < 0)
1248                 return r;
1249
1250         r = sd_netlink_call(m->rtnl, req, 0, &reply);
1251         if (r < 0)
1252                 return r;
1253
1254         for (route = reply; route; route = sd_netlink_message_next(route)) {
1255                 int k;
1256
1257                 m->enumerating = true;
1258
1259                 k = manager_rtnl_process_route(m->rtnl, route, m);
1260                 if (k < 0)
1261                         r = k;
1262
1263                 m->enumerating = false;
1264         }
1265
1266         return r;
1267 }
1268
1269 int manager_address_pool_acquire(Manager *m, int family, unsigned prefixlen, union in_addr_union *found) {
1270         AddressPool *p;
1271         int r;
1272
1273         assert(m);
1274         assert(prefixlen > 0);
1275         assert(found);
1276
1277         LIST_FOREACH(address_pools, p, m->address_pools) {
1278                 if (p->family != family)
1279                         continue;
1280
1281                 r = address_pool_acquire(p, prefixlen, found);
1282                 if (r != 0)
1283                         return r;
1284         }
1285
1286         return 0;
1287 }
1288
1289 Link* manager_find_uplink(Manager *m, Link *exclude) {
1290         _cleanup_free_ struct local_address *gateways = NULL;
1291         int n, i;
1292
1293         assert(m);
1294
1295         /* Looks for a suitable "uplink", via black magic: an
1296          * interface that is up and where the default route with the
1297          * highest priority points to. */
1298
1299         n = local_gateways(m->rtnl, 0, AF_UNSPEC, &gateways);
1300         if (n < 0) {
1301                 log_warning_errno(n, "Failed to determine list of default gateways: %m");
1302                 return NULL;
1303         }
1304
1305         for (i = 0; i < n; i++) {
1306                 Link *link;
1307
1308                 link = hashmap_get(m->links, INT_TO_PTR(gateways[i].ifindex));
1309                 if (!link) {
1310                         log_debug("Weird, found a gateway for a link we don't know. Ignoring.");
1311                         continue;
1312                 }
1313
1314                 if (link == exclude)
1315                         continue;
1316
1317                 if (link->operstate < LINK_OPERSTATE_ROUTABLE)
1318                         continue;
1319
1320                 return link;
1321         }
1322
1323         return NULL;
1324 }
1325
1326 void manager_dirty(Manager *manager) {
1327         assert(manager);
1328
1329         /* the serialized state in /run is no longer up-to-date */
1330         manager->dirty = true;
1331 }