src/network/networkd-manager.c

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