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