src/network/networkd-manager.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2013 Tom Gundersen <teg@jklm.no>
   6
   7   systemd is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as published by
   9   the Free Software Foundation; either version 2.1 of the License, or
  10   (at your option) any later version.
  11
  12   systemd is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  19  ***/
  20
  21 #include <sys/socket.h>
  22 #include <linux/if.h>
  23 #include <linux/fib_rules.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-manager.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 #if 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 < 0) {
 142                 /* We failed to connect? Yuck, we must be in early
 143                  * boot. Let's try in 5s again. */
 144
 145                 log_debug_errno(r, "Failed to connect to bus, trying again in 5s: %m");
 146
 147                 r = sd_event_add_time(m->event, &m->bus_retry_event_source, CLOCK_MONOTONIC, now(CLOCK_MONOTONIC) + 5*USEC_PER_SEC, 0, on_bus_retry, m);
 148                 if (r < 0)
 149                         return log_error_errno(r, "Failed to install bus reconnect time event: %m");
 150
 151                 return 0;
 152         }
 153
 154         r = sd_bus_add_match(m->bus, &m->prepare_for_sleep_slot,
 155                              "type='signal',"
 156                              "sender='org.freedesktop.login1',"
 157                              "interface='org.freedesktop.login1.Manager',"
 158                              "member='PrepareForSleep',"
 159                              "path='/org/freedesktop/login1'",
 160                              match_prepare_for_sleep,
 161                              m);
 162         if (r < 0)
 163                 return log_error_errno(r, "Failed to add match for PrepareForSleep: %m");
 164
 165         r = sd_bus_add_object_vtable(m->bus, NULL, "/org/freedesktop/network1", "org.freedesktop.network1.Manager", manager_vtable, m);
 166         if (r < 0)
 167                 return log_error_errno(r, "Failed to add manager object vtable: %m");
 168
 169         r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/network1/link", "org.freedesktop.network1.Link", link_vtable, link_object_find, m);
 170         if (r < 0)
 171                return log_error_errno(r, "Failed to add link object vtable: %m");
 172
 173         r = sd_bus_add_node_enumerator(m->bus, NULL, "/org/freedesktop/network1/link", link_node_enumerator, m);
 174         if (r < 0)
 175                 return log_error_errno(r, "Failed to add link enumerator: %m");
 176
 177         r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/network1/network", "org.freedesktop.network1.Network", network_vtable, network_object_find, m);
 178         if (r < 0)
 179                return log_error_errno(r, "Failed to add network object vtable: %m");
 180
 181         r = sd_bus_add_node_enumerator(m->bus, NULL, "/org/freedesktop/network1/network", network_node_enumerator, m);
 182         if (r < 0)
 183                 return log_error_errno(r, "Failed to add network enumerator: %m");
 184
 185         r = sd_bus_request_name(m->bus, "org.freedesktop.network1", 0);
 186         if (r < 0)
 187                 return log_error_errno(r, "Failed to register name: %m");
 188
 189         r = sd_bus_attach_event(m->bus, m->event, 0);
 190         if (r < 0)
 191                 return log_error_errno(r, "Failed to attach bus to event loop: %m");
 192
 193        /* Did we get a timezone or transient hostname from DHCP while D-Bus wasn't up yet? */
 194         if (m->dynamic_hostname) {
 195                 r = manager_set_hostname(m, m->dynamic_hostname);
 196                 if (r < 0)
 197                         return r;
 198         }
 199         if (m->dynamic_timezone) {
 200                 r = manager_set_timezone(m, m->dynamic_timezone);
 201                 if (r < 0)
 202                         return r;
 203         }
 204
 205         return 0;
 206 }
 207
 208 static int manager_udev_process_link(Manager *m, struct udev_device *device) {
 209         Link *link = NULL;
 210         int r, ifindex;
 211
 212         assert(m);
 213         assert(device);
 214
 215         if (!streq_ptr(udev_device_get_action(device), "add"))
 216                 return 0;
 217
 218         ifindex = udev_device_get_ifindex(device);
 219         if (ifindex <= 0) {
 220                 log_debug("Ignoring udev ADD event for device with invalid ifindex");
 221                 return 0;
 222         }
 223
 224         r = link_get(m, ifindex, &link);
 225         if (r == -ENODEV)
 226                 return 0;
 227         else if (r < 0)
 228                 return r;
 229
 230         r = link_initialized(link, device);
 231         if (r < 0)
 232                 return r;
 233
 234         return 0;
 235 }
 236
 237 static int manager_dispatch_link_udev(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
 238         Manager *m = userdata;
 239         struct udev_monitor *monitor = m->udev_monitor;
 240         _cleanup_udev_device_unref_ struct udev_device *device = NULL;
 241
 242         device = udev_monitor_receive_device(monitor);
 243         if (!device)
 244                 return -ENOMEM;
 245
 246         manager_udev_process_link(m, device);
 247         return 0;
 248 }
 249
 250 static int manager_connect_udev(Manager *m) {
 251         int r;
 252
 253         /* udev does not initialize devices inside containers,
 254          * so we rely on them being already initialized before
 255          * entering the container */
 256         if (detect_container() > 0)
 257                 return 0;
 258
 259         m->udev = udev_new();
 260         if (!m->udev)
 261                 return -ENOMEM;
 262
 263         m->udev_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
 264         if (!m->udev_monitor)
 265                 return -ENOMEM;
 266
 267         r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_monitor, "net", NULL);
 268         if (r < 0)
 269                 return log_error_errno(r, "Could not add udev monitor filter: %m");
 270
 271         r = udev_monitor_enable_receiving(m->udev_monitor);
 272         if (r < 0) {
 273                 log_error("Could not enable udev monitor");
 274                 return r;
 275         }
 276
 277         r = sd_event_add_io(m->event,
 278                         &m->udev_event_source,
 279                         udev_monitor_get_fd(m->udev_monitor),
 280                         EPOLLIN, manager_dispatch_link_udev,
 281                         m);
 282         if (r < 0)
 283                 return r;
 284
 285         r = sd_event_source_set_description(m->udev_event_source, "networkd-udev");
 286         if (r < 0)
 287                 return r;
 288
 289         return 0;
 290 }
 291
 292 int manager_rtnl_process_route(sd_netlink *rtnl, sd_netlink_message *message, void *userdata) {
 293         Manager *m = userdata;
 294         Link *link = NULL;
 295         uint16_t type;
 296         uint32_t ifindex, priority = 0;
 297         unsigned char protocol, scope, tos, table, rt_type;
 298         int family;
 299         unsigned char dst_prefixlen, src_prefixlen;
 300         union in_addr_union dst = {}, gw = {}, src = {}, prefsrc = {};
 301         Route *route = NULL;
 302         int r;
 303
 304         assert(rtnl);
 305         assert(message);
 306         assert(m);
 307
 308         if (sd_netlink_message_is_error(message)) {
 309                 r = sd_netlink_message_get_errno(message);
 310                 if (r < 0)
 311                         log_warning_errno(r, "rtnl: failed to receive route: %m");
 312
 313                 return 0;
 314         }
 315
 316         r = sd_netlink_message_get_type(message, &type);
 317         if (r < 0) {
 318                 log_warning_errno(r, "rtnl: could not get message type: %m");
 319                 return 0;
 320         } else if (!IN_SET(type, RTM_NEWROUTE, RTM_DELROUTE)) {
 321                 log_warning("rtnl: received unexpected message type when processing route");
 322                 return 0;
 323         }
 324
 325         r = sd_netlink_message_read_u32(message, RTA_OIF, &ifindex);
 326         if (r == -ENODATA) {
 327                 log_debug("rtnl: received route without ifindex, ignoring");
 328                 return 0;
 329         } else if (r < 0) {
 330                 log_warning_errno(r, "rtnl: could not get ifindex from route, ignoring: %m");
 331                 return 0;
 332         } else if (ifindex <= 0) {
 333                 log_warning("rtnl: received route message with invalid ifindex, ignoring: %d", ifindex);
 334                 return 0;
 335         } else {
 336                 r = link_get(m, ifindex, &link);
 337                 if (r < 0 || !link) {
 338                         /* when enumerating we might be out of sync, but we will
 339                          * get the route again, so just ignore it */
 340                         if (!m->enumerating)
 341                                 log_warning("rtnl: received route for nonexistent link (%d), ignoring", ifindex);
 342                         return 0;
 343                 }
 344         }
 345
 346         r = sd_rtnl_message_route_get_family(message, &family);
 347         if (r < 0 || !IN_SET(family, AF_INET, AF_INET6)) {
 348                 log_link_warning(link, "rtnl: received address with invalid family, ignoring.");
 349                 return 0;
 350         }
 351
 352         r = sd_rtnl_message_route_get_protocol(message, &protocol);
 353         if (r < 0) {
 354                 log_warning_errno(r, "rtnl: could not get route protocol: %m");
 355                 return 0;
 356         }
 357
 358         switch (family) {
 359         case AF_INET:
 360                 r = sd_netlink_message_read_in_addr(message, RTA_DST, &dst.in);
 361                 if (r < 0 && r != -ENODATA) {
 362                         log_link_warning_errno(link, r, "rtnl: received route without valid destination, ignoring: %m");
 363                         return 0;
 364                 }
 365
 366                 r = sd_netlink_message_read_in_addr(message, RTA_GATEWAY, &gw.in);
 367                 if (r < 0 && r != -ENODATA) {
 368                         log_link_warning_errno(link, r, "rtnl: received route with invalid gateway, ignoring: %m");
 369                         return 0;
 370                 }
 371
 372                 r = sd_netlink_message_read_in_addr(message, RTA_SRC, &src.in);
 373                 if (r < 0 && r != -ENODATA) {
 374                         log_link_warning_errno(link, r, "rtnl: received route with invalid source, ignoring: %m");
 375                         return 0;
 376                 }
 377
 378                 r = sd_netlink_message_read_in_addr(message, RTA_PREFSRC, &prefsrc.in);
 379                 if (r < 0 && r != -ENODATA) {
 380                         log_link_warning_errno(link, r, "rtnl: received route with invalid preferred source, ignoring: %m");
 381                         return 0;
 382                 }
 383
 384                 break;
 385
 386         case AF_INET6:
 387                 r = sd_netlink_message_read_in6_addr(message, RTA_DST, &dst.in6);
 388                 if (r < 0 && r != -ENODATA) {
 389                         log_link_warning_errno(link, r, "rtnl: received route without valid destination, ignoring: %m");
 390                         return 0;
 391                 }
 392
 393                 r = sd_netlink_message_read_in6_addr(message, RTA_GATEWAY, &gw.in6);
 394                 if (r < 0 && r != -ENODATA) {
 395                         log_link_warning_errno(link, r, "rtnl: received route with invalid gateway, ignoring: %m");
 396                         return 0;
 397                 }
 398
 399                 r = sd_netlink_message_read_in6_addr(message, RTA_SRC, &src.in6);
 400                 if (r < 0 && r != -ENODATA) {
 401                         log_link_warning_errno(link, r, "rtnl: received route with invalid source, ignoring: %m");
 402                         return 0;
 403                 }
 404
 405                 r = sd_netlink_message_read_in6_addr(message, RTA_PREFSRC, &prefsrc.in6);
 406                 if (r < 0 && r != -ENODATA) {
 407                         log_link_warning_errno(link, r, "rtnl: received route with invalid preferred source, ignoring: %m");
 408                         return 0;
 409                 }
 410
 411                 break;
 412
 413         default:
 414                 assert_not_reached("Received unsupported address family");
 415                 return 0;
 416         }
 417
 418         r = sd_rtnl_message_route_get_dst_prefixlen(message, &dst_prefixlen);
 419         if (r < 0) {
 420                 log_link_warning_errno(link, r, "rtnl: received route with invalid destination prefixlen, ignoring: %m");
 421                 return 0;
 422         }
 423
 424         r = sd_rtnl_message_route_get_src_prefixlen(message, &src_prefixlen);
 425         if (r < 0) {
 426                 log_link_warning_errno(link, r, "rtnl: received route with invalid source prefixlen, ignoring: %m");
 427                 return 0;
 428         }
 429
 430         r = sd_rtnl_message_route_get_scope(message, &scope);
 431         if (r < 0) {
 432                 log_link_warning_errno(link, r, "rtnl: received route with invalid scope, ignoring: %m");
 433                 return 0;
 434         }
 435
 436         r = sd_rtnl_message_route_get_tos(message, &tos);
 437         if (r < 0) {
 438                 log_link_warning_errno(link, r, "rtnl: received route with invalid tos, ignoring: %m");
 439                 return 0;
 440         }
 441
 442         r = sd_rtnl_message_route_get_type(message, &rt_type);
 443         if (r < 0) {
 444                 log_link_warning_errno(link, r, "rtnl: received route with invalid type, ignoring: %m");
 445                 return 0;
 446         }
 447
 448         r = sd_rtnl_message_route_get_table(message, &table);
 449         if (r < 0) {
 450                 log_link_warning_errno(link, r, "rtnl: received route with invalid table, ignoring: %m");
 451                 return 0;
 452         }
 453
 454         r = sd_netlink_message_read_u32(message, RTA_PRIORITY, &priority);
 455         if (r < 0 && r != -ENODATA) {
 456                 log_link_warning_errno(link, r, "rtnl: received route with invalid priority, ignoring: %m");
 457                 return 0;
 458         }
 459
 460         route_get(link, family, &dst, dst_prefixlen, tos, priority, table, &route);
 461
 462         switch (type) {
 463         case RTM_NEWROUTE:
 464                 if (!route) {
 465                         /* A route appeared that we did not request */
 466                         r = route_add_foreign(link, family, &dst, dst_prefixlen, tos, priority, table, &route);
 467                         if (r < 0)
 468                                 return 0;
 469                 }
 470
 471                 route_update(route, &src, src_prefixlen, &gw, &prefsrc, scope, protocol, rt_type);
 472
 473                 break;
 474
 475         case RTM_DELROUTE:
 476                 route_free(route);
 477                 break;
 478
 479         default:
 480                 assert_not_reached("Received invalid RTNL message type");
 481         }
 482
 483         return 1;
 484 }
 485
 486 int manager_rtnl_process_address(sd_netlink *rtnl, sd_netlink_message *message, void *userdata) {
 487         Manager *m = userdata;
 488         Link *link = NULL;
 489         uint16_t type;
 490         unsigned char flags;
 491         int family;
 492         unsigned char prefixlen;
 493         unsigned char scope;
 494         union in_addr_union in_addr;
 495         struct ifa_cacheinfo cinfo;
 496         Address *address = NULL;
 497         char buf[INET6_ADDRSTRLEN], valid_buf[FORMAT_TIMESPAN_MAX];
 498         const char *valid_str = NULL;
 499         int r, ifindex;
 500
 501         assert(rtnl);
 502         assert(message);
 503         assert(m);
 504
 505         if (sd_netlink_message_is_error(message)) {
 506                 r = sd_netlink_message_get_errno(message);
 507                 if (r < 0)
 508                         log_warning_errno(r, "rtnl: failed to receive address: %m");
 509
 510                 return 0;
 511         }
 512
 513         r = sd_netlink_message_get_type(message, &type);
 514         if (r < 0) {
 515                 log_warning_errno(r, "rtnl: could not get message type: %m");
 516                 return 0;
 517         } else if (!IN_SET(type, RTM_NEWADDR, RTM_DELADDR)) {
 518                 log_warning("rtnl: received unexpected message type when processing address");
 519                 return 0;
 520         }
 521
 522         r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
 523         if (r < 0) {
 524                 log_warning_errno(r, "rtnl: could not get ifindex from address: %m");
 525                 return 0;
 526         } else if (ifindex <= 0) {
 527                 log_warning("rtnl: received address message with invalid ifindex: %d", ifindex);
 528                 return 0;
 529         } else {
 530                 r = link_get(m, ifindex, &link);
 531                 if (r < 0 || !link) {
 532                         /* when enumerating we might be out of sync, but we will
 533                          * get the address again, so just ignore it */
 534                         if (!m->enumerating)
 535                                 log_warning("rtnl: received address for nonexistent link (%d), ignoring", ifindex);
 536                         return 0;
 537                 }
 538         }
 539
 540         r = sd_rtnl_message_addr_get_family(message, &family);
 541         if (r < 0 || !IN_SET(family, AF_INET, AF_INET6)) {
 542                 log_link_warning(link, "rtnl: received address with invalid family, ignoring.");
 543                 return 0;
 544         }
 545
 546         r = sd_rtnl_message_addr_get_prefixlen(message, &prefixlen);
 547         if (r < 0) {
 548                 log_link_warning_errno(link, r, "rtnl: received address with invalid prefixlen, ignoring: %m");
 549                 return 0;
 550         }
 551
 552         r = sd_rtnl_message_addr_get_scope(message, &scope);
 553         if (r < 0) {
 554                 log_link_warning_errno(link, r, "rtnl: received address with invalid scope, ignoring: %m");
 555                 return 0;
 556         }
 557
 558         r = sd_rtnl_message_addr_get_flags(message, &flags);
 559         if (r < 0) {
 560                 log_link_warning_errno(link, r, "rtnl: received address with invalid flags, ignoring: %m");
 561                 return 0;
 562         }
 563
 564         switch (family) {
 565         case AF_INET:
 566                 r = sd_netlink_message_read_in_addr(message, IFA_LOCAL, &in_addr.in);
 567                 if (r < 0) {
 568                         log_link_warning_errno(link, r, "rtnl: received address without valid address, ignoring: %m");
 569                         return 0;
 570                 }
 571
 572                 break;
 573
 574         case AF_INET6:
 575                 r = sd_netlink_message_read_in6_addr(message, IFA_ADDRESS, &in_addr.in6);
 576                 if (r < 0) {
 577                         log_link_warning_errno(link, r, "rtnl: received address without valid address, ignoring: %m");
 578                         return 0;
 579                 }
 580
 581                 break;
 582
 583         default:
 584                 log_link_debug(link, "rtnl: ignoring unsupported address family: %d", family);
 585         }
 586
 587         if (!inet_ntop(family, &in_addr, buf, INET6_ADDRSTRLEN)) {
 588                 log_link_warning(link, "Could not print address");
 589                 return 0;
 590         }
 591
 592         r = sd_netlink_message_read_cache_info(message, IFA_CACHEINFO, &cinfo);
 593         if (r >= 0) {
 594                 if (cinfo.ifa_valid != CACHE_INFO_INFINITY_LIFE_TIME)
 595                         valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
 596                                                     cinfo.ifa_valid * USEC_PER_SEC,
 597                                                     USEC_PER_SEC);
 598         }
 599
 600         address_get(link, family, &in_addr, prefixlen, &address);
 601
 602         switch (type) {
 603         case RTM_NEWADDR:
 604                 if (address)
 605                         log_link_debug(link, "Updating address: %s/%u (valid %s%s)", buf, prefixlen,
 606                                        valid_str ? "for " : "forever", strempty(valid_str));
 607                 else {
 608                         /* An address appeared that we did not request */
 609                         r = address_add_foreign(link, family, &in_addr, prefixlen, &address);
 610                         if (r < 0) {
 611                                 log_link_warning_errno(link, r, "Failed to add address %s/%u: %m", buf, prefixlen);
 612                                 return 0;
 613                         } else
 614                                 log_link_debug(link, "Adding address: %s/%u (valid %s%s)", buf, prefixlen,
 615                                                valid_str ? "for " : "forever", strempty(valid_str));
 616                 }
 617
 618                 address_update(address, flags, scope, &cinfo);
 619
 620                 break;
 621
 622         case RTM_DELADDR:
 623
 624                 if (address) {
 625                         log_link_debug(link, "Removing address: %s/%u (valid %s%s)", buf, prefixlen,
 626                                        valid_str ? "for " : "forever", strempty(valid_str));
 627                         address_drop(address);
 628                 } else
 629                         log_link_warning(link, "Removing non-existent address: %s/%u (valid %s%s)", buf, prefixlen,
 630                                          valid_str ? "for " : "forever", strempty(valid_str));
 631
 632                 break;
 633         default:
 634                 assert_not_reached("Received invalid RTNL message type");
 635         }
 636
 637         return 1;
 638 }
 639
 640 static int manager_rtnl_process_link(sd_netlink *rtnl, sd_netlink_message *message, void *userdata) {
 641         Manager *m = userdata;
 642         Link *link = NULL;
 643         NetDev *netdev = NULL;
 644         uint16_t type;
 645         const char *name;
 646         int r, ifindex;
 647
 648         assert(rtnl);
 649         assert(message);
 650         assert(m);
 651
 652         if (sd_netlink_message_is_error(message)) {
 653                 r = sd_netlink_message_get_errno(message);
 654                 if (r < 0)
 655                         log_warning_errno(r, "rtnl: Could not receive link: %m");
 656
 657                 return 0;
 658         }
 659
 660         r = sd_netlink_message_get_type(message, &type);
 661         if (r < 0) {
 662                 log_warning_errno(r, "rtnl: Could not get message type: %m");
 663                 return 0;
 664         } else if (!IN_SET(type, RTM_NEWLINK, RTM_DELLINK)) {
 665                 log_warning("rtnl: Received unexpected message type when processing link");
 666                 return 0;
 667         }
 668
 669         r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
 670         if (r < 0) {
 671                 log_warning_errno(r, "rtnl: Could not get ifindex from link: %m");
 672                 return 0;
 673         } else if (ifindex <= 0) {
 674                 log_warning("rtnl: received link message with invalid ifindex: %d", ifindex);
 675                 return 0;
 676         }
 677
 678         r = sd_netlink_message_read_string(message, IFLA_IFNAME, &name);
 679         if (r < 0) {
 680                 log_warning_errno(r, "rtnl: Received link message without ifname: %m");
 681                 return 0;
 682         }
 683
 684         (void) link_get(m, ifindex, &link);
 685         (void) netdev_get(m, name, &netdev);
 686
 687         switch (type) {
 688         case RTM_NEWLINK:
 689                 if (!link) {
 690                         /* link is new, so add it */
 691                         r = link_add(m, message, &link);
 692                         if (r < 0) {
 693                                 log_warning_errno(r, "Could not add new link: %m");
 694                                 return 0;
 695                         }
 696                 }
 697
 698                 if (netdev) {
 699                         /* netdev exists, so make sure the ifindex matches */
 700                         r = netdev_set_ifindex(netdev, message);
 701                         if (r < 0) {
 702                                 log_warning_errno(r, "Could not set ifindex on netdev: %m");
 703                                 return 0;
 704                         }
 705                 }
 706
 707                 r = link_update(link, message);
 708                 if (r < 0)
 709                         return 0;
 710
 711                 break;
 712
 713         case RTM_DELLINK:
 714                 link_drop(link);
 715                 netdev_drop(netdev);
 716
 717                 break;
 718
 719         default:
 720                 assert_not_reached("Received invalid RTNL message type.");
 721         }
 722
 723         return 1;
 724 }
 725
 726 int manager_rtnl_process_rule(sd_netlink *rtnl, sd_netlink_message *message, void *userdata) {
 727         uint8_t tos = 0, to_prefixlen = 0, from_prefixlen = 0;
 728         RoutingPolicyRule *rule = NULL;
 729         union in_addr_union to, from;
 730         uint32_t fwmark = 0, table = 0;
 731         Manager *m = userdata;
 732         char *iif, *oif;
 733         uint16_t type;
 734         int family;
 735         int r;
 736
 737         assert(rtnl);
 738         assert(message);
 739         assert(m);
 740
 741         if (sd_netlink_message_is_error(message)) {
 742                 r = sd_netlink_message_get_errno(message);
 743                 if (r < 0)
 744                         log_warning_errno(r, "rtnl: failed to receive rule: %m");
 745
 746                 return 0;
 747         }
 748
 749         r = sd_netlink_message_get_type(message, &type);
 750         if (r < 0) {
 751                 log_warning_errno(r, "rtnl: could not get message type: %m");
 752                 return 0;
 753         } else if (!IN_SET(type, RTM_NEWRULE, RTM_DELRULE)) {
 754                 log_warning("rtnl: received unexpected message type '%u' when processing rule.", type);
 755                 return 0;
 756         }
 757
 758         r = sd_rtnl_message_get_family(message, &family);
 759         if (r < 0) {
 760                 log_warning_errno(r, "rtnl: could not get rule family: %m");
 761                 return 0;
 762         } else if (!IN_SET(family, AF_INET, AF_INET6)) {
 763                 log_debug("rtnl: received address with invalid family %u, ignoring.", family);
 764                 return 0;
 765         }
 766
 767         switch (family) {
 768         case AF_INET:
 769                 r = sd_netlink_message_read_in_addr(message, FRA_SRC, &from.in);
 770                 if (r >= 0) {
 771                         r = sd_rtnl_message_routing_policy_rule_get_rtm_src_prefixlen(message, &from_prefixlen);
 772                         if (r < 0)
 773                                 log_warning_errno(r, "rtnl: failed to retrive rule from prefix length: %m");
 774                 }
 775
 776                 r = sd_netlink_message_read_in_addr(message, FRA_DST, &to.in);
 777                 if (r >= 0) {
 778                         r = sd_rtnl_message_routing_policy_rule_get_rtm_dst_prefixlen(message, &to_prefixlen);
 779                         if (r < 0)
 780                                 log_warning_errno(r, "rtnl: failed to retrive rule to prefix length: %m");
 781                 }
 782
 783                 break;
 784
 785         case AF_INET6:
 786                 r = sd_netlink_message_read_in6_addr(message, FRA_SRC, &from.in6);
 787                 if (r >= 0) {
 788                         r = sd_rtnl_message_routing_policy_rule_get_rtm_src_prefixlen(message, &from_prefixlen);
 789                         if (r < 0)
 790                                 log_warning_errno(r, "rtnl: failed to retrive rule from prefix length: %m");
 791                 }
 792
 793                 r = sd_netlink_message_read_in6_addr(message, FRA_DST, &to.in6);
 794                 if (r >= 0) {
 795                         r = sd_rtnl_message_routing_policy_rule_get_rtm_dst_prefixlen(message, &to_prefixlen);
 796                         if (r < 0)
 797                                 log_warning_errno(r, "rtnl: failed to retrive rule to prefix length: %m");
 798                 }
 799
 800                 break;
 801
 802         default:
 803                 assert_not_reached("Received unsupported address family");
 804         }
 805
 806         if (from_prefixlen == 0 && to_prefixlen == 0)
 807                 return 0;
 808
 809         (void) sd_netlink_message_read_u32(message, FRA_FWMARK, &fwmark);
 810         (void) sd_netlink_message_read_u32(message, FRA_TABLE, &table);
 811         (void) sd_rtnl_message_routing_policy_rule_get_tos(message, &tos);
 812         (void) sd_netlink_message_read_string(message, FRA_IIFNAME, (const char **) &iif);
 813         (void) sd_netlink_message_read_string(message, FRA_OIFNAME, (const char **) &oif);
 814
 815         (void) routing_policy_rule_get(m, family, &from, from_prefixlen, &to, to_prefixlen, tos, fwmark, table, iif, oif, &rule);
 816
 817         switch (type) {
 818         case RTM_NEWRULE:
 819                 if(!rule) {
 820                         r = routing_policy_rule_add_foreign(m, family, &from, from_prefixlen, &to, to_prefixlen, tos, fwmark, table, iif, oif, &rule);
 821                         if (r < 0) {
 822                                 log_warning_errno(r, "Could not add rule: %m");
 823                                 return 0;
 824                         }
 825                 }
 826                 break;
 827         case RTM_DELRULE:
 828                 routing_policy_rule_free(rule);
 829
 830                 break;
 831
 832         default:
 833                 assert_not_reached("Received invalid RTNL message type");
 834         }
 835
 836         return 1;
 837 }
 838
 839 static int systemd_netlink_fd(void) {
 840         int n, fd, rtnl_fd = -EINVAL;
 841
 842         n = sd_listen_fds(true);
 843         if (n <= 0)
 844                 return -EINVAL;
 845
 846         for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++) {
 847                 if (sd_is_socket(fd, AF_NETLINK, SOCK_RAW, -1) > 0) {
 848                         if (rtnl_fd >= 0)
 849                                 return -EINVAL;
 850
 851                         rtnl_fd = fd;
 852                 }
 853         }
 854
 855         return rtnl_fd;
 856 }
 857
 858 static int manager_connect_rtnl(Manager *m) {
 859         int fd, r;
 860
 861         assert(m);
 862
 863         fd = systemd_netlink_fd();
 864         if (fd < 0)
 865                 r = sd_netlink_open(&m->rtnl);
 866         else
 867                 r = sd_netlink_open_fd(&m->rtnl, fd);
 868         if (r < 0)
 869                 return r;
 870
 871         r = sd_netlink_inc_rcvbuf(m->rtnl, RCVBUF_SIZE);
 872         if (r < 0)
 873                 return r;
 874
 875         r = sd_netlink_attach_event(m->rtnl, m->event, 0);
 876         if (r < 0)
 877                 return r;
 878
 879         r = sd_netlink_add_match(m->rtnl, RTM_NEWLINK, &manager_rtnl_process_link, m);
 880         if (r < 0)
 881                 return r;
 882
 883         r = sd_netlink_add_match(m->rtnl, RTM_DELLINK, &manager_rtnl_process_link, m);
 884         if (r < 0)
 885                 return r;
 886
 887         r = sd_netlink_add_match(m->rtnl, RTM_NEWADDR, &manager_rtnl_process_address, m);
 888         if (r < 0)
 889                 return r;
 890
 891         r = sd_netlink_add_match(m->rtnl, RTM_DELADDR, &manager_rtnl_process_address, m);
 892         if (r < 0)
 893                 return r;
 894
 895         r = sd_netlink_add_match(m->rtnl, RTM_NEWROUTE, &manager_rtnl_process_route, m);
 896         if (r < 0)
 897                 return r;
 898
 899         r = sd_netlink_add_match(m->rtnl, RTM_DELROUTE, &manager_rtnl_process_route, m);
 900         if (r < 0)
 901                 return r;
 902
 903         r = sd_netlink_add_match(m->rtnl, RTM_NEWRULE, &manager_rtnl_process_rule, m);
 904         if (r < 0)
 905                 return r;
 906
 907         r = sd_netlink_add_match(m->rtnl, RTM_DELRULE, &manager_rtnl_process_rule, m);
 908         if (r < 0)
 909                 return r;
 910
 911         return 0;
 912 }
 913
 914 static int ordered_set_put_in_addr_data(OrderedSet *s, const struct in_addr_data *address) {
 915         char *p;
 916         int r;
 917
 918         assert(s);
 919         assert(address);
 920
 921         r = in_addr_to_string(address->family, &address->address, &p);
 922         if (r < 0)
 923                 return r;
 924
 925         r = ordered_set_consume(s, p);
 926         if (r == -EEXIST)
 927                 return 0;
 928
 929         return r;
 930 }
 931
 932 static int ordered_set_put_in_addr_datav(OrderedSet *s, const struct in_addr_data *addresses, unsigned n) {
 933         int r, c = 0;
 934         unsigned i;
 935
 936         assert(s);
 937         assert(addresses || n == 0);
 938
 939         for (i = 0; i < n; i++) {
 940                 r = ordered_set_put_in_addr_data(s, addresses+i);
 941                 if (r < 0)
 942                         return r;
 943
 944                 c += r;
 945         }
 946
 947         return c;
 948 }
 949
 950 static int ordered_set_put_in4_addr(OrderedSet *s, const struct in_addr *address) {
 951         char *p;
 952         int r;
 953
 954         assert(s);
 955         assert(address);
 956
 957         r = in_addr_to_string(AF_INET, (const union in_addr_union*) address, &p);
 958         if (r < 0)
 959                 return r;
 960
 961         r = ordered_set_consume(s, p);
 962         if (r == -EEXIST)
 963                 return 0;
 964
 965         return r;
 966 }
 967
 968 static int ordered_set_put_in4_addrv(OrderedSet *s, const struct in_addr *addresses, unsigned n) {
 969         int r, c = 0;
 970         unsigned i;
 971
 972         assert(s);
 973         assert(n == 0 || addresses);
 974
 975         for (i = 0; i < n; i++) {
 976                 r = ordered_set_put_in4_addr(s, addresses+i);
 977                 if (r < 0)
 978                         return r;
 979
 980                 c += r;
 981         }
 982
 983         return c;
 984 }
 985
 986 static void print_string_set(FILE *f, const char *field, OrderedSet *s) {
 987         bool space = false;
 988         Iterator i;
 989         char *p;
 990
 991         if (ordered_set_isempty(s))
 992                 return;
 993
 994         fputs_unlocked(field, f);
 995
 996         ORDERED_SET_FOREACH(p, s, i)
 997                 fputs_with_space(f, p, NULL, &space);
 998
 999         fputc_unlocked('\n', f);
1000 }
1001
1002 static int manager_save(Manager *m) {
1003         _cleanup_ordered_set_free_free_ OrderedSet *dns = NULL, *ntp = NULL, *search_domains = NULL, *route_domains = NULL;
1004         Link *link;
1005         Iterator i;
1006         _cleanup_free_ char *temp_path = NULL;
1007         _cleanup_fclose_ FILE *f = NULL;
1008         LinkOperationalState operstate = LINK_OPERSTATE_OFF;
1009         const char *operstate_str;
1010         int r;
1011
1012         assert(m);
1013         assert(m->state_file);
1014
1015         /* We add all NTP and DNS server to a set, to filter out duplicates */
1016         dns = ordered_set_new(&string_hash_ops);
1017         if (!dns)
1018                 return -ENOMEM;
1019
1020         ntp = ordered_set_new(&string_hash_ops);
1021         if (!ntp)
1022                 return -ENOMEM;
1023
1024         search_domains = ordered_set_new(&dns_name_hash_ops);
1025         if (!search_domains)
1026                 return -ENOMEM;
1027
1028         route_domains = ordered_set_new(&dns_name_hash_ops);
1029         if (!route_domains)
1030                 return -ENOMEM;
1031
1032         HASHMAP_FOREACH(link, m->links, i) {
1033                 if (link->flags & IFF_LOOPBACK)
1034                         continue;
1035
1036                 if (link->operstate > operstate)
1037                         operstate = link->operstate;
1038
1039                 if (!link->network)
1040                         continue;
1041
1042                 /* First add the static configured entries */
1043                 r = ordered_set_put_in_addr_datav(dns, link->network->dns, link->network->n_dns);
1044                 if (r < 0)
1045                         return r;
1046
1047                 r = ordered_set_put_strdupv(ntp, link->network->ntp);
1048                 if (r < 0)
1049                         return r;
1050
1051                 r = ordered_set_put_strdupv(search_domains, link->network->search_domains);
1052                 if (r < 0)
1053                         return r;
1054
1055                 r = ordered_set_put_strdupv(route_domains, link->network->route_domains);
1056                 if (r < 0)
1057                         return r;
1058
1059                 if (!link->dhcp_lease)
1060                         continue;
1061
1062                 /* Secondly, add the entries acquired via DHCP */
1063                 if (link->network->dhcp_use_dns) {
1064                         const struct in_addr *addresses;
1065
1066                         r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
1067                         if (r > 0) {
1068                                 r = ordered_set_put_in4_addrv(dns, addresses, r);
1069                                 if (r < 0)
1070                                         return r;
1071                         } else if (r < 0 && r != -ENODATA)
1072                                 return r;
1073                 }
1074
1075                 if (link->network->dhcp_use_ntp) {
1076                         const struct in_addr *addresses;
1077
1078                         r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
1079                         if (r > 0) {
1080                                 r = ordered_set_put_in4_addrv(ntp, addresses, r);
1081                                 if (r < 0)
1082                                         return r;
1083                         } else if (r < 0 && r != -ENODATA)
1084                                 return r;
1085                 }
1086
1087                 if (link->network->dhcp_use_domains != DHCP_USE_DOMAINS_NO) {
1088                         const char *domainname;
1089                         char **domains = NULL;
1090
1091                         OrderedSet *target_domains = (link->network->dhcp_use_domains == DHCP_USE_DOMAINS_YES) ? search_domains : route_domains;
1092                         r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
1093                         if (r >= 0) {
1094                                 r = ordered_set_put_strdup(target_domains, domainname);
1095                                 if (r < 0)
1096                                         return r;
1097                         } else if (r != -ENODATA)
1098                                 return r;
1099
1100                         r = sd_dhcp_lease_get_search_domains(link->dhcp_lease, &domains);
1101                         if (r >= 0) {
1102                                 r = ordered_set_put_strdupv(target_domains, domains);
1103                                 if (r < 0)
1104                                         return r;
1105                         } else if (r != -ENODATA)
1106                                 return r;
1107                 }
1108         }
1109
1110         operstate_str = link_operstate_to_string(operstate);
1111         assert(operstate_str);
1112
1113         r = fopen_temporary(m->state_file, &f, &temp_path);
1114         if (r < 0)
1115                 return r;
1116
1117         (void) fchmod(fileno(f), 0644);
1118
1119         fprintf(f,
1120                 "# This is private data. Do not parse.\n"
1121                 "OPER_STATE=%s\n", operstate_str);
1122
1123         print_string_set(f, "DNS=", dns);
1124         print_string_set(f, "NTP=", ntp);
1125         print_string_set(f, "DOMAINS=", search_domains);
1126         print_string_set(f, "ROUTE_DOMAINS=", route_domains);
1127
1128         r = routing_policy_serialize_rules(m->rules, f);
1129         if (r < 0)
1130                 goto fail;
1131
1132         r = fflush_and_check(f);
1133         if (r < 0)
1134                 goto fail;
1135
1136         if (rename(temp_path, m->state_file) < 0) {
1137                 r = -errno;
1138                 goto fail;
1139         }
1140
1141         if (m->operational_state != operstate) {
1142                 m->operational_state = operstate;
1143                 r = manager_send_changed(m, "OperationalState", NULL);
1144                 if (r < 0)
1145                         log_error_errno(r, "Could not emit changed OperationalState: %m");
1146         }
1147
1148         m->dirty = false;
1149
1150         return 0;
1151
1152 fail:
1153         (void) unlink(m->state_file);
1154         (void) unlink(temp_path);
1155
1156         return log_error_errno(r, "Failed to save network state to %s: %m", m->state_file);
1157 }
1158
1159 static int manager_dirty_handler(sd_event_source *s, void *userdata) {
1160         Manager *m = userdata;
1161         Link *link;
1162         Iterator i;
1163         int r;
1164
1165         assert(m);
1166
1167         if (m->dirty)
1168                 manager_save(m);
1169
1170         SET_FOREACH(link, m->dirty_links, i) {
1171                 r = link_save(link);
1172                 if (r >= 0)
1173                         link_clean(link);
1174         }
1175
1176         return 1;
1177 }
1178
1179 int manager_new(Manager **ret, sd_event *event) {
1180         _cleanup_manager_free_ Manager *m = NULL;
1181         int r;
1182
1183         m = new0(Manager, 1);
1184         if (!m)
1185                 return -ENOMEM;
1186
1187         m->state_file = strdup("/run/systemd/netif/state");
1188         if (!m->state_file)
1189                 return -ENOMEM;
1190
1191         m->event = sd_event_ref(event);
1192
1193         r = sd_event_add_post(m->event, NULL, manager_dirty_handler, m);
1194         if (r < 0)
1195                 return r;
1196
1197         r = manager_connect_rtnl(m);
1198         if (r < 0)
1199                 return r;
1200
1201         r = manager_connect_udev(m);
1202         if (r < 0)
1203                 return r;
1204
1205         m->netdevs = hashmap_new(&string_hash_ops);
1206         if (!m->netdevs)
1207                 return -ENOMEM;
1208
1209         LIST_HEAD_INIT(m->networks);
1210
1211         r = setup_default_address_pool(m);
1212         if (r < 0)
1213                 return r;
1214
1215         m->duid.type = DUID_TYPE_EN;
1216
1217         (void) routing_policy_load_rules(m->state_file, &m->rules_saved);
1218
1219         *ret = m;
1220         m = NULL;
1221
1222         return 0;
1223 }
1224
1225 void manager_free(Manager *m) {
1226         RoutingPolicyRule *rule;
1227         Network *network;
1228         NetDev *netdev;
1229         Link *link;
1230         AddressPool *pool;
1231
1232         if (!m)
1233                 return;
1234
1235         free(m->state_file);
1236
1237         while ((network = m->networks))
1238                 network_free(network);
1239
1240         while ((link = hashmap_first(m->links)))
1241                 link_unref(link);
1242         hashmap_free(m->links);
1243
1244         hashmap_free(m->networks_by_name);
1245
1246         while ((netdev = hashmap_first(m->netdevs)))
1247                 netdev_unref(netdev);
1248         hashmap_free(m->netdevs);
1249
1250         while ((pool = m->address_pools))
1251                 address_pool_free(pool);
1252
1253         set_free(m->rules);
1254         set_free(m->rules_foreign);
1255
1256         while ((rule = set_steal_first(m->rules_saved)))
1257                 free(rule);
1258
1259         set_free(m->rules_saved);
1260
1261         sd_netlink_unref(m->rtnl);
1262         sd_event_unref(m->event);
1263
1264         sd_event_source_unref(m->udev_event_source);
1265         udev_monitor_unref(m->udev_monitor);
1266         udev_unref(m->udev);
1267
1268         sd_bus_unref(m->bus);
1269         sd_bus_slot_unref(m->prepare_for_sleep_slot);
1270         sd_event_source_unref(m->bus_retry_event_source);
1271
1272         free(m->dynamic_timezone);
1273         free(m->dynamic_hostname);
1274
1275         free(m);
1276 }
1277
1278 int manager_start(Manager *m) {
1279         Link *link;
1280         Iterator i;
1281
1282         assert(m);
1283
1284         /* The dirty handler will deal with future serialization, but the first one
1285            must be done explicitly. */
1286
1287         manager_save(m);
1288
1289         HASHMAP_FOREACH(link, m->links, i)
1290                 link_save(link);
1291
1292         return 0;
1293 }
1294
1295 int manager_load_config(Manager *m) {
1296         int r;
1297
1298         /* update timestamp */
1299         paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, true);
1300
1301         r = netdev_load(m);
1302         if (r < 0)
1303                 return r;
1304
1305         r = network_load(m);
1306         if (r < 0)
1307                 return r;
1308
1309         return 0;
1310 }
1311
1312 bool manager_should_reload(Manager *m) {
1313         return paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, false);
1314 }
1315
1316 int manager_rtnl_enumerate_links(Manager *m) {
1317         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL;
1318         sd_netlink_message *link;
1319         int r;
1320
1321         assert(m);
1322         assert(m->rtnl);
1323
1324         r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
1325         if (r < 0)
1326                 return r;
1327
1328         r = sd_netlink_message_request_dump(req, true);
1329         if (r < 0)
1330                 return r;
1331
1332         r = sd_netlink_call(m->rtnl, req, 0, &reply);
1333         if (r < 0)
1334                 return r;
1335
1336         for (link = reply; link; link = sd_netlink_message_next(link)) {
1337                 int k;
1338
1339                 m->enumerating = true;
1340
1341                 k = manager_rtnl_process_link(m->rtnl, link, m);
1342                 if (k < 0)
1343                         r = k;
1344
1345                 m->enumerating = false;
1346         }
1347
1348         return r;
1349 }
1350
1351 int manager_rtnl_enumerate_addresses(Manager *m) {
1352         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL;
1353         sd_netlink_message *addr;
1354         int r;
1355
1356         assert(m);
1357         assert(m->rtnl);
1358
1359         r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, 0, 0);
1360         if (r < 0)
1361                 return r;
1362
1363         r = sd_netlink_message_request_dump(req, true);
1364         if (r < 0)
1365                 return r;
1366
1367         r = sd_netlink_call(m->rtnl, req, 0, &reply);
1368         if (r < 0)
1369                 return r;
1370
1371         for (addr = reply; addr; addr = sd_netlink_message_next(addr)) {
1372                 int k;
1373
1374                 m->enumerating = true;
1375
1376                 k = manager_rtnl_process_address(m->rtnl, addr, m);
1377                 if (k < 0)
1378                         r = k;
1379
1380                 m->enumerating = false;
1381         }
1382
1383         return r;
1384 }
1385
1386 int manager_rtnl_enumerate_routes(Manager *m) {
1387         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL;
1388         sd_netlink_message *route;
1389         int r;
1390
1391         assert(m);
1392         assert(m->rtnl);
1393
1394         r = sd_rtnl_message_new_route(m->rtnl, &req, RTM_GETROUTE, 0, 0);
1395         if (r < 0)
1396                 return r;
1397
1398         r = sd_netlink_message_request_dump(req, true);
1399         if (r < 0)
1400                 return r;
1401
1402         r = sd_netlink_call(m->rtnl, req, 0, &reply);
1403         if (r < 0)
1404                 return r;
1405
1406         for (route = reply; route; route = sd_netlink_message_next(route)) {
1407                 int k;
1408
1409                 m->enumerating = true;
1410
1411                 k = manager_rtnl_process_route(m->rtnl, route, m);
1412                 if (k < 0)
1413                         r = k;
1414
1415                 m->enumerating = false;
1416         }
1417
1418         return r;
1419 }
1420
1421 int manager_rtnl_enumerate_rules(Manager *m) {
1422         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL;
1423         sd_netlink_message *rule;
1424         int r;
1425
1426         assert(m);
1427         assert(m->rtnl);
1428
1429         r = sd_rtnl_message_new_routing_policy_rule(m->rtnl, &req, RTM_GETRULE, 0);
1430         if (r < 0)
1431                 return r;
1432
1433         r = sd_netlink_message_request_dump(req, true);
1434         if (r < 0)
1435                 return r;
1436
1437         r = sd_netlink_call(m->rtnl, req, 0, &reply);
1438         if (r < 0) {
1439                 if (r == -EOPNOTSUPP) {
1440                         log_debug("FIB Rules are not supported by the kernel. Ignoring.");
1441                         return 0;
1442                 }
1443
1444                 return r;
1445         }
1446
1447         for (rule = reply; rule; rule = sd_netlink_message_next(rule)) {
1448                 int k;
1449
1450                 m->enumerating = true;
1451
1452                 k = manager_rtnl_process_rule(m->rtnl, rule, m);
1453                 if (k < 0)
1454                         r = k;
1455
1456                 m->enumerating = false;
1457         }
1458
1459         return r;
1460 }
1461
1462 int manager_address_pool_acquire(Manager *m, int family, unsigned prefixlen, union in_addr_union *found) {
1463         AddressPool *p;
1464         int r;
1465
1466         assert(m);
1467         assert(prefixlen > 0);
1468         assert(found);
1469
1470         LIST_FOREACH(address_pools, p, m->address_pools) {
1471                 if (p->family != family)
1472                         continue;
1473
1474                 r = address_pool_acquire(p, prefixlen, found);
1475                 if (r != 0)
1476                         return r;
1477         }
1478
1479         return 0;
1480 }
1481
1482 Link* manager_find_uplink(Manager *m, Link *exclude) {
1483         _cleanup_free_ struct local_address *gateways = NULL;
1484         int n, i;
1485
1486         assert(m);
1487
1488         /* Looks for a suitable "uplink", via black magic: an
1489          * interface that is up and where the default route with the
1490          * highest priority points to. */
1491
1492         n = local_gateways(m->rtnl, 0, AF_UNSPEC, &gateways);
1493         if (n < 0) {
1494                 log_warning_errno(n, "Failed to determine list of default gateways: %m");
1495                 return NULL;
1496         }
1497
1498         for (i = 0; i < n; i++) {
1499                 Link *link;
1500
1501                 link = hashmap_get(m->links, INT_TO_PTR(gateways[i].ifindex));
1502                 if (!link) {
1503                         log_debug("Weird, found a gateway for a link we don't know. Ignoring.");
1504                         continue;
1505                 }
1506
1507                 if (link == exclude)
1508                         continue;
1509
1510                 if (link->operstate < LINK_OPERSTATE_ROUTABLE)
1511                         continue;
1512
1513                 return link;
1514         }
1515
1516         return NULL;
1517 }
1518
1519 void manager_dirty(Manager *manager) {
1520         assert(manager);
1521
1522         /* the serialized state in /run is no longer up-to-date */
1523         manager->dirty = true;
1524 }
1525
1526 static int set_hostname_handler(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
1527         Manager *manager = userdata;
1528         const sd_bus_error *e;
1529
1530         assert(m);
1531         assert(manager);
1532
1533         e = sd_bus_message_get_error(m);
1534         if (e)
1535                 log_warning_errno(sd_bus_error_get_errno(e), "Could not set hostname: %s", e->message);
1536
1537         return 1;
1538 }
1539
1540 int manager_set_hostname(Manager *m, const char *hostname) {
1541         int r;
1542
1543         log_debug("Setting transient hostname: '%s'", strna(hostname));
1544         if (free_and_strdup(&m->dynamic_hostname, hostname) < 0)
1545                 return log_oom();
1546
1547         if (!m->bus) {
1548                 /* TODO: replace by assert when we can rely on kdbus */
1549                 log_info("Not connected to system bus, ignoring transient hostname.");
1550                 return 0;
1551         }
1552
1553         r = sd_bus_call_method_async(
1554                         m->bus,
1555                         NULL,
1556                         "org.freedesktop.hostname1",
1557                         "/org/freedesktop/hostname1",
1558                         "org.freedesktop.hostname1",
1559                         "SetHostname",
1560                         set_hostname_handler,
1561                         m,
1562                         "sb",
1563                         hostname,
1564                         false);
1565
1566         if (r < 0)
1567                 return log_error_errno(r, "Could not set transient hostname: %m");
1568
1569         return 0;
1570 }
1571
1572 static int set_timezone_handler(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
1573         Manager *manager = userdata;
1574         const sd_bus_error *e;
1575
1576         assert(m);
1577         assert(manager);
1578
1579         e = sd_bus_message_get_error(m);
1580         if (e)
1581                 log_warning_errno(sd_bus_error_get_errno(e), "Could not set timezone: %s", e->message);
1582
1583         return 1;
1584 }
1585
1586 int manager_set_timezone(Manager *m, const char *tz) {
1587         int r;
1588
1589         assert(m);
1590         assert(tz);
1591
1592         log_debug("Setting system timezone: '%s'", tz);
1593         if (free_and_strdup(&m->dynamic_timezone, tz) < 0)
1594                 return log_oom();
1595
1596         if (!m->bus) {
1597                 log_info("Not connected to system bus, ignoring timezone.");
1598                 return 0;
1599         }
1600
1601         r = sd_bus_call_method_async(
1602                         m->bus,
1603                         NULL,
1604                         "org.freedesktop.timedate1",
1605                         "/org/freedesktop/timedate1",
1606                         "org.freedesktop.timedate1",
1607                         "SetTimezone",
1608                         set_timezone_handler,
1609                         m,
1610                         "sb",
1611                         tz,
1612                         false);
1613         if (r < 0)
1614                 return log_error_errno(r, "Could not set timezone: %m");
1615
1616         return 0;
1617 }