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                 fputs_with_space(f, p, NULL, &space);
 827
 828         fputc('\n', f);
 829 }
 830
 831 static int manager_save(Manager *m) {
 832         _cleanup_ordered_set_free_free_ OrderedSet *dns = NULL, *ntp = NULL, *search_domains = NULL, *route_domains = NULL;
 833         Link *link;
 834         Iterator i;
 835         _cleanup_free_ char *temp_path = NULL;
 836         _cleanup_fclose_ FILE *f = NULL;
 837         LinkOperationalState operstate = LINK_OPERSTATE_OFF;
 838         const char *operstate_str;
 839         int r;
 840
 841         assert(m);
 842         assert(m->state_file);
 843
 844         /* We add all NTP and DNS server to a set, to filter out duplicates */
 845         dns = ordered_set_new(&string_hash_ops);
 846         if (!dns)
 847                 return -ENOMEM;
 848
 849         ntp = ordered_set_new(&string_hash_ops);
 850         if (!ntp)
 851                 return -ENOMEM;
 852
 853         search_domains = ordered_set_new(&dns_name_hash_ops);
 854         if (!search_domains)
 855                 return -ENOMEM;
 856
 857         route_domains = ordered_set_new(&dns_name_hash_ops);
 858         if (!route_domains)
 859                 return -ENOMEM;
 860
 861         HASHMAP_FOREACH(link, m->links, i) {
 862                 if (link->flags & IFF_LOOPBACK)
 863                         continue;
 864
 865                 if (link->operstate > operstate)
 866                         operstate = link->operstate;
 867
 868                 if (!link->network)
 869                         continue;
 870
 871                 /* First add the static configured entries */
 872                 r = ordered_set_put_strdupv(dns, link->network->dns);
 873                 if (r < 0)
 874                         return r;
 875
 876                 r = ordered_set_put_strdupv(ntp, link->network->ntp);
 877                 if (r < 0)
 878                         return r;
 879
 880                 r = ordered_set_put_strdupv(search_domains, link->network->search_domains);
 881                 if (r < 0)
 882                         return r;
 883
 884                 r = ordered_set_put_strdupv(route_domains, link->network->route_domains);
 885                 if (r < 0)
 886                         return r;
 887
 888                 if (!link->dhcp_lease)
 889                         continue;
 890
 891                 /* Secondly, add the entries acquired via DHCP */
 892                 if (link->network->dhcp_use_dns) {
 893                         const struct in_addr *addresses;
 894
 895                         r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
 896                         if (r > 0) {
 897                                 r = ordered_set_put_in_addrv(dns, addresses, r);
 898                                 if (r < 0)
 899                                         return r;
 900                         } else if (r < 0 && r != -ENODATA)
 901                                 return r;
 902                 }
 903
 904                 if (link->network->dhcp_use_ntp) {
 905                         const struct in_addr *addresses;
 906
 907                         r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
 908                         if (r > 0) {
 909                                 r = ordered_set_put_in_addrv(ntp, addresses, r);
 910                                 if (r < 0)
 911                                         return r;
 912                         } else if (r < 0 && r != -ENODATA)
 913                                 return r;
 914                 }
 915
 916                 if (link->network->dhcp_use_domains != DHCP_USE_DOMAINS_NO) {
 917                         const char *domainname;
 918
 919                         r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
 920                         if (r >= 0) {
 921
 922                                 if (link->network->dhcp_use_domains == DHCP_USE_DOMAINS_YES)
 923                                         r = ordered_set_put_strdup(search_domains, domainname);
 924                                 else
 925                                         r = ordered_set_put_strdup(route_domains, domainname);
 926
 927                                 if (r < 0)
 928                                         return r;
 929                         } else if (r != -ENODATA)
 930                                 return r;
 931                 }
 932         }
 933
 934         operstate_str = link_operstate_to_string(operstate);
 935         assert(operstate_str);
 936
 937         r = fopen_temporary(m->state_file, &f, &temp_path);
 938         if (r < 0)
 939                 return r;
 940
 941         fchmod(fileno(f), 0644);
 942
 943         fprintf(f,
 944                 "# This is private data. Do not parse.\n"
 945                 "OPER_STATE=%s\n", operstate_str);
 946
 947         print_string_set(f, "DNS=", dns);
 948         print_string_set(f, "NTP=", ntp);
 949         print_string_set(f, "DOMAINS=", search_domains);
 950         print_string_set(f, "ROUTE_DOMAINS=", route_domains);
 951
 952         r = fflush_and_check(f);
 953         if (r < 0)
 954                 goto fail;
 955
 956         if (rename(temp_path, m->state_file) < 0) {
 957                 r = -errno;
 958                 goto fail;
 959         }
 960
 961         if (m->operational_state != operstate) {
 962                 m->operational_state = operstate;
 963                 r = manager_send_changed(m, "OperationalState", NULL);
 964                 if (r < 0)
 965                         log_error_errno(r, "Could not emit changed OperationalState: %m");
 966         }
 967
 968         m->dirty = false;
 969
 970         return 0;
 971
 972 fail:
 973         (void) unlink(m->state_file);
 974         (void) unlink(temp_path);
 975
 976         return log_error_errno(r, "Failed to save network state to %s: %m", m->state_file);
 977 }
 978
 979 static int manager_dirty_handler(sd_event_source *s, void *userdata) {
 980         Manager *m = userdata;
 981         Link *link;
 982         Iterator i;
 983         int r;
 984
 985         assert(m);
 986
 987         if (m->dirty)
 988                 manager_save(m);
 989
 990         SET_FOREACH(link, m->dirty_links, i) {
 991                 r = link_save(link);
 992                 if (r >= 0)
 993                         link_clean(link);
 994         }
 995
 996         return 1;
 997 }
 998
 999 int manager_new(Manager **ret) {
1000         _cleanup_manager_free_ Manager *m = NULL;
1001         int r;
1002
1003         m = new0(Manager, 1);
1004         if (!m)
1005                 return -ENOMEM;
1006
1007         m->state_file = strdup("/run/systemd/netif/state");
1008         if (!m->state_file)
1009                 return -ENOMEM;
1010
1011         r = sd_event_default(&m->event);
1012         if (r < 0)
1013                 return r;
1014
1015         sd_event_set_watchdog(m->event, true);
1016
1017         sd_event_add_signal(m->event, NULL, SIGTERM, NULL, NULL);
1018         sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
1019
1020         r = sd_event_add_post(m->event, NULL, manager_dirty_handler, m);
1021         if (r < 0)
1022                 return r;
1023
1024         r = manager_connect_rtnl(m);
1025         if (r < 0)
1026                 return r;
1027
1028         r = manager_connect_udev(m);
1029         if (r < 0)
1030                 return r;
1031
1032         m->netdevs = hashmap_new(&string_hash_ops);
1033         if (!m->netdevs)
1034                 return -ENOMEM;
1035
1036         LIST_HEAD_INIT(m->networks);
1037
1038         r = setup_default_address_pool(m);
1039         if (r < 0)
1040                 return r;
1041
1042         *ret = m;
1043         m = NULL;
1044
1045         return 0;
1046 }
1047
1048 void manager_free(Manager *m) {
1049         Network *network;
1050         NetDev *netdev;
1051         Link *link;
1052         AddressPool *pool;
1053
1054         if (!m)
1055                 return;
1056
1057         free(m->state_file);
1058
1059         while ((link = hashmap_first(m->links)))
1060                 link_unref(link);
1061         hashmap_free(m->links);
1062
1063         while ((network = m->networks))
1064                 network_free(network);
1065
1066         hashmap_free(m->networks_by_name);
1067
1068         while ((netdev = hashmap_first(m->netdevs)))
1069                 netdev_unref(netdev);
1070         hashmap_free(m->netdevs);
1071
1072         while ((pool = m->address_pools))
1073                 address_pool_free(pool);
1074
1075         sd_netlink_unref(m->rtnl);
1076         sd_event_unref(m->event);
1077
1078         sd_event_source_unref(m->udev_event_source);
1079         udev_monitor_unref(m->udev_monitor);
1080         udev_unref(m->udev);
1081
1082         sd_bus_unref(m->bus);
1083         sd_bus_slot_unref(m->prepare_for_sleep_slot);
1084         sd_event_source_unref(m->bus_retry_event_source);
1085
1086         free(m);
1087 }
1088
1089 static bool manager_check_idle(void *userdata) {
1090         Manager *m = userdata;
1091         Link *link;
1092         Iterator i;
1093
1094         assert(m);
1095
1096         HASHMAP_FOREACH(link, m->links, i) {
1097                 /* we are not woken on udev activity, so let's just wait for the
1098                  * pending udev event */
1099                 if (link->state == LINK_STATE_PENDING)
1100                         return false;
1101
1102                 if (!link->network)
1103                         continue;
1104
1105                 /* we are not woken on netork activity, so let's stay around */
1106                 if (link_lldp_enabled(link) ||
1107                     link_ipv4ll_enabled(link) ||
1108                     link_dhcp4_server_enabled(link) ||
1109                     link_dhcp4_enabled(link) ||
1110                     link_dhcp6_enabled(link) ||
1111                     link_ipv6_accept_ra_enabled(link))
1112                         return false;
1113         }
1114
1115         return true;
1116 }
1117
1118 int manager_run(Manager *m) {
1119         Link *link;
1120         Iterator i;
1121
1122         assert(m);
1123
1124         /* The dirty handler will deal with future serialization, but the first one
1125            must be done explicitly. */
1126
1127         manager_save(m);
1128
1129         HASHMAP_FOREACH(link, m->links, i)
1130                 link_save(link);
1131
1132         if (m->bus)
1133                 return bus_event_loop_with_idle(
1134                                 m->event,
1135                                 m->bus,
1136                                 "org.freedesktop.network1",
1137                                 DEFAULT_EXIT_USEC,
1138                                 manager_check_idle,
1139                                 m);
1140         else
1141                 /* failed to connect to the bus, so we lose exit-on-idle logic,
1142                    this should not happen except if dbus is not around at all */
1143                 return sd_event_loop(m->event);
1144 }
1145
1146 int manager_load_config(Manager *m) {
1147         int r;
1148
1149         /* update timestamp */
1150         paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, true);
1151
1152         r = netdev_load(m);
1153         if (r < 0)
1154                 return r;
1155
1156         r = network_load(m);
1157         if (r < 0)
1158                 return r;
1159
1160         return 0;
1161 }
1162
1163 bool manager_should_reload(Manager *m) {
1164         return paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, false);
1165 }
1166
1167 int manager_rtnl_enumerate_links(Manager *m) {
1168         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL;
1169         sd_netlink_message *link;
1170         int r;
1171
1172         assert(m);
1173         assert(m->rtnl);
1174
1175         r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
1176         if (r < 0)
1177                 return r;
1178
1179         r = sd_netlink_message_request_dump(req, true);
1180         if (r < 0)
1181                 return r;
1182
1183         r = sd_netlink_call(m->rtnl, req, 0, &reply);
1184         if (r < 0)
1185                 return r;
1186
1187         for (link = reply; link; link = sd_netlink_message_next(link)) {
1188                 int k;
1189
1190                 m->enumerating = true;
1191
1192                 k = manager_rtnl_process_link(m->rtnl, link, m);
1193                 if (k < 0)
1194                         r = k;
1195
1196                 m->enumerating = false;
1197         }
1198
1199         return r;
1200 }
1201
1202 int manager_rtnl_enumerate_addresses(Manager *m) {
1203         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL;
1204         sd_netlink_message *addr;
1205         int r;
1206
1207         assert(m);
1208         assert(m->rtnl);
1209
1210         r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, 0, 0);
1211         if (r < 0)
1212                 return r;
1213
1214         r = sd_netlink_message_request_dump(req, true);
1215         if (r < 0)
1216                 return r;
1217
1218         r = sd_netlink_call(m->rtnl, req, 0, &reply);
1219         if (r < 0)
1220                 return r;
1221
1222         for (addr = reply; addr; addr = sd_netlink_message_next(addr)) {
1223                 int k;
1224
1225                 m->enumerating = true;
1226
1227                 k = manager_rtnl_process_address(m->rtnl, addr, m);
1228                 if (k < 0)
1229                         r = k;
1230
1231                 m->enumerating = false;
1232         }
1233
1234         return r;
1235 }
1236
1237 int manager_rtnl_enumerate_routes(Manager *m) {
1238         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL;
1239         sd_netlink_message *route;
1240         int r;
1241
1242         assert(m);
1243         assert(m->rtnl);
1244
1245         r = sd_rtnl_message_new_route(m->rtnl, &req, RTM_GETROUTE, 0, 0);
1246         if (r < 0)
1247                 return r;
1248
1249         r = sd_netlink_message_request_dump(req, true);
1250         if (r < 0)
1251                 return r;
1252
1253         r = sd_netlink_call(m->rtnl, req, 0, &reply);
1254         if (r < 0)
1255                 return r;
1256
1257         for (route = reply; route; route = sd_netlink_message_next(route)) {
1258                 int k;
1259
1260                 m->enumerating = true;
1261
1262                 k = manager_rtnl_process_route(m->rtnl, route, m);
1263                 if (k < 0)
1264                         r = k;
1265
1266                 m->enumerating = false;
1267         }
1268
1269         return r;
1270 }
1271
1272 int manager_address_pool_acquire(Manager *m, int family, unsigned prefixlen, union in_addr_union *found) {
1273         AddressPool *p;
1274         int r;
1275
1276         assert(m);
1277         assert(prefixlen > 0);
1278         assert(found);
1279
1280         LIST_FOREACH(address_pools, p, m->address_pools) {
1281                 if (p->family != family)
1282                         continue;
1283
1284                 r = address_pool_acquire(p, prefixlen, found);
1285                 if (r != 0)
1286                         return r;
1287         }
1288
1289         return 0;
1290 }
1291
1292 Link* manager_find_uplink(Manager *m, Link *exclude) {
1293         _cleanup_free_ struct local_address *gateways = NULL;
1294         int n, i;
1295
1296         assert(m);
1297
1298         /* Looks for a suitable "uplink", via black magic: an
1299          * interface that is up and where the default route with the
1300          * highest priority points to. */
1301
1302         n = local_gateways(m->rtnl, 0, AF_UNSPEC, &gateways);
1303         if (n < 0) {
1304                 log_warning_errno(n, "Failed to determine list of default gateways: %m");
1305                 return NULL;
1306         }
1307
1308         for (i = 0; i < n; i++) {
1309                 Link *link;
1310
1311                 link = hashmap_get(m->links, INT_TO_PTR(gateways[i].ifindex));
1312                 if (!link) {
1313                         log_debug("Weird, found a gateway for a link we don't know. Ignoring.");
1314                         continue;
1315                 }
1316
1317                 if (link == exclude)
1318                         continue;
1319
1320                 if (link->operstate < LINK_OPERSTATE_ROUTABLE)
1321                         continue;
1322
1323                 return link;
1324         }
1325
1326         return NULL;
1327 }
1328
1329 void manager_dirty(Manager *manager) {
1330         assert(manager);
1331
1332         /* the serialized state in /run is no longer up-to-date */
1333         manager->dirty = true;
1334 }