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