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 Link *manager_dhcp6_prefix_get(Manager *m, struct in6_addr *addr) {
1238         assert_return(m, NULL);
1239         assert_return(m->dhcp6_prefixes, NULL);
1240         assert_return(addr, NULL);
1241
1242         return hashmap_get(m->dhcp6_prefixes, addr);
1243 }
1244
1245 int manager_dhcp6_prefix_add(Manager *m, struct in6_addr *addr, Link *link) {
1246         assert_return(m, -EINVAL);
1247         assert_return(m->dhcp6_prefixes, -ENODATA);
1248         assert_return(addr, -EINVAL);
1249
1250         return hashmap_put(m->dhcp6_prefixes, addr, link);
1251 }
1252
1253 int manager_dhcp6_prefix_remove(Manager *m, struct in6_addr *addr) {
1254         Link *l;
1255
1256         assert_return(m, -EINVAL);
1257         assert_return(m->dhcp6_prefixes, -ENODATA);
1258         assert_return(addr, -EINVAL);
1259
1260         l = hashmap_remove(m->dhcp6_prefixes, addr);
1261         if (!l)
1262                 return -EINVAL;
1263
1264         (void) sd_radv_remove_prefix(l->radv, addr, 64);
1265
1266         return 0;
1267 }
1268
1269 int manager_dhcp6_prefix_remove_all(Manager *m, Link *link) {
1270         Iterator i;
1271         Link *l;
1272         struct in6_addr *addr;
1273
1274         assert_return(m, -EINVAL);
1275         assert_return(l, -EINVAL);
1276
1277         HASHMAP_FOREACH_KEY(l, addr, m->dhcp6_prefixes, i) {
1278                 if (l != link)
1279                         continue;
1280
1281                 (void) sd_radv_remove_prefix(l->radv, addr, 64);
1282
1283                 hashmap_remove(m->dhcp6_prefixes, addr);
1284         }
1285
1286         return 0;
1287 }
1288
1289 static void dhcp6_prefixes_hash_func(const void *p, struct siphash *state) {
1290         const struct in6_addr *addr = p;
1291
1292         assert(p);
1293
1294         siphash24_compress(addr, sizeof(*addr), state);
1295 }
1296
1297 static int dhcp6_prefixes_compare_func(const void *_a, const void *_b) {
1298         const struct in6_addr *a = _a, *b = _b;
1299
1300         return memcmp(&a, &b, sizeof(*a));
1301 }
1302
1303 static const struct hash_ops dhcp6_prefixes_hash_ops = {
1304         .hash = dhcp6_prefixes_hash_func,
1305         .compare = dhcp6_prefixes_compare_func,
1306 };
1307
1308 int manager_new(Manager **ret, sd_event *event) {
1309         _cleanup_manager_free_ Manager *m = NULL;
1310         int r;
1311
1312         m = new0(Manager, 1);
1313         if (!m)
1314                 return -ENOMEM;
1315
1316         m->state_file = strdup("/run/systemd/netif/state");
1317         if (!m->state_file)
1318                 return -ENOMEM;
1319
1320         m->event = sd_event_ref(event);
1321
1322         r = sd_event_add_post(m->event, NULL, manager_dirty_handler, m);
1323         if (r < 0)
1324                 return r;
1325
1326         r = manager_connect_rtnl(m);
1327         if (r < 0)
1328                 return r;
1329
1330         r = manager_connect_udev(m);
1331         if (r < 0)
1332                 return r;
1333
1334         m->netdevs = hashmap_new(&string_hash_ops);
1335         if (!m->netdevs)
1336                 return -ENOMEM;
1337
1338         LIST_HEAD_INIT(m->networks);
1339
1340         r = setup_default_address_pool(m);
1341         if (r < 0)
1342                 return r;
1343
1344         m->dhcp6_prefixes = hashmap_new(&dhcp6_prefixes_hash_ops);
1345         if (!m->dhcp6_prefixes)
1346                 return -ENOMEM;
1347
1348         m->duid.type = DUID_TYPE_EN;
1349
1350         (void) routing_policy_load_rules(m->state_file, &m->rules_saved);
1351
1352         *ret = m;
1353         m = NULL;
1354
1355         return 0;
1356 }
1357
1358 void manager_free(Manager *m) {
1359         Network *network;
1360         NetDev *netdev;
1361         Link *link;
1362         AddressPool *pool;
1363
1364         if (!m)
1365                 return;
1366
1367         free(m->state_file);
1368
1369         while ((network = m->networks))
1370                 network_free(network);
1371
1372         while ((link = hashmap_first(m->dhcp6_prefixes)))
1373                 link_unref(link);
1374         hashmap_free(m->dhcp6_prefixes);
1375
1376         while ((link = hashmap_first(m->links)))
1377                 link_unref(link);
1378         hashmap_free(m->links);
1379
1380         hashmap_free(m->networks_by_name);
1381
1382         while ((netdev = hashmap_first(m->netdevs)))
1383                 netdev_unref(netdev);
1384         hashmap_free(m->netdevs);
1385
1386         while ((pool = m->address_pools))
1387                 address_pool_free(pool);
1388
1389         set_free(m->rules);
1390         set_free(m->rules_foreign);
1391
1392         set_free_with_destructor(m->rules_saved, routing_policy_rule_free);
1393
1394         sd_netlink_unref(m->rtnl);
1395         sd_event_unref(m->event);
1396
1397         sd_event_source_unref(m->udev_event_source);
1398         udev_monitor_unref(m->udev_monitor);
1399         udev_unref(m->udev);
1400
1401         sd_bus_unref(m->bus);
1402         sd_bus_slot_unref(m->prepare_for_sleep_slot);
1403         sd_event_source_unref(m->bus_retry_event_source);
1404
1405         free(m->dynamic_timezone);
1406         free(m->dynamic_hostname);
1407
1408         free(m);
1409 }
1410
1411 int manager_start(Manager *m) {
1412         Link *link;
1413         Iterator i;
1414
1415         assert(m);
1416
1417         /* The dirty handler will deal with future serialization, but the first one
1418            must be done explicitly. */
1419
1420         manager_save(m);
1421
1422         HASHMAP_FOREACH(link, m->links, i)
1423                 link_save(link);
1424
1425         return 0;
1426 }
1427
1428 int manager_load_config(Manager *m) {
1429         int r;
1430
1431         /* update timestamp */
1432         paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, true);
1433
1434         r = netdev_load(m);
1435         if (r < 0)
1436                 return r;
1437
1438         r = network_load(m);
1439         if (r < 0)
1440                 return r;
1441
1442         return 0;
1443 }
1444
1445 bool manager_should_reload(Manager *m) {
1446         return paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, false);
1447 }
1448
1449 int manager_rtnl_enumerate_links(Manager *m) {
1450         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL;
1451         sd_netlink_message *link;
1452         int r;
1453
1454         assert(m);
1455         assert(m->rtnl);
1456
1457         r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
1458         if (r < 0)
1459                 return r;
1460
1461         r = sd_netlink_message_request_dump(req, true);
1462         if (r < 0)
1463                 return r;
1464
1465         r = sd_netlink_call(m->rtnl, req, 0, &reply);
1466         if (r < 0)
1467                 return r;
1468
1469         for (link = reply; link; link = sd_netlink_message_next(link)) {
1470                 int k;
1471
1472                 m->enumerating = true;
1473
1474                 k = manager_rtnl_process_link(m->rtnl, link, m);
1475                 if (k < 0)
1476                         r = k;
1477
1478                 m->enumerating = false;
1479         }
1480
1481         return r;
1482 }
1483
1484 int manager_rtnl_enumerate_addresses(Manager *m) {
1485         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL;
1486         sd_netlink_message *addr;
1487         int r;
1488
1489         assert(m);
1490         assert(m->rtnl);
1491
1492         r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, 0, 0);
1493         if (r < 0)
1494                 return r;
1495
1496         r = sd_netlink_message_request_dump(req, true);
1497         if (r < 0)
1498                 return r;
1499
1500         r = sd_netlink_call(m->rtnl, req, 0, &reply);
1501         if (r < 0)
1502                 return r;
1503
1504         for (addr = reply; addr; addr = sd_netlink_message_next(addr)) {
1505                 int k;
1506
1507                 m->enumerating = true;
1508
1509                 k = manager_rtnl_process_address(m->rtnl, addr, m);
1510                 if (k < 0)
1511                         r = k;
1512
1513                 m->enumerating = false;
1514         }
1515
1516         return r;
1517 }
1518
1519 int manager_rtnl_enumerate_routes(Manager *m) {
1520         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL;
1521         sd_netlink_message *route;
1522         int r;
1523
1524         assert(m);
1525         assert(m->rtnl);
1526
1527         r = sd_rtnl_message_new_route(m->rtnl, &req, RTM_GETROUTE, 0, 0);
1528         if (r < 0)
1529                 return r;
1530
1531         r = sd_netlink_message_request_dump(req, true);
1532         if (r < 0)
1533                 return r;
1534
1535         r = sd_netlink_call(m->rtnl, req, 0, &reply);
1536         if (r < 0)
1537                 return r;
1538
1539         for (route = reply; route; route = sd_netlink_message_next(route)) {
1540                 int k;
1541
1542                 m->enumerating = true;
1543
1544                 k = manager_rtnl_process_route(m->rtnl, route, m);
1545                 if (k < 0)
1546                         r = k;
1547
1548                 m->enumerating = false;
1549         }
1550
1551         return r;
1552 }
1553
1554 int manager_rtnl_enumerate_rules(Manager *m) {
1555         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL;
1556         sd_netlink_message *rule;
1557         int r;
1558
1559         assert(m);
1560         assert(m->rtnl);
1561
1562         r = sd_rtnl_message_new_routing_policy_rule(m->rtnl, &req, RTM_GETRULE, 0);
1563         if (r < 0)
1564                 return r;
1565
1566         r = sd_netlink_message_request_dump(req, true);
1567         if (r < 0)
1568                 return r;
1569
1570         r = sd_netlink_call(m->rtnl, req, 0, &reply);
1571         if (r < 0) {
1572                 if (r == -EOPNOTSUPP) {
1573                         log_debug("FIB Rules are not supported by the kernel. Ignoring.");
1574                         return 0;
1575                 }
1576
1577                 return r;
1578         }
1579
1580         for (rule = reply; rule; rule = sd_netlink_message_next(rule)) {
1581                 int k;
1582
1583                 m->enumerating = true;
1584
1585                 k = manager_rtnl_process_rule(m->rtnl, rule, m);
1586                 if (k < 0)
1587                         r = k;
1588
1589                 m->enumerating = false;
1590         }
1591
1592         return r;
1593 }
1594
1595 int manager_address_pool_acquire(Manager *m, int family, unsigned prefixlen, union in_addr_union *found) {
1596         AddressPool *p;
1597         int r;
1598
1599         assert(m);
1600         assert(prefixlen > 0);
1601         assert(found);
1602
1603         LIST_FOREACH(address_pools, p, m->address_pools) {
1604                 if (p->family != family)
1605                         continue;
1606
1607                 r = address_pool_acquire(p, prefixlen, found);
1608                 if (r != 0)
1609                         return r;
1610         }
1611
1612         return 0;
1613 }
1614
1615 Link* manager_find_uplink(Manager *m, Link *exclude) {
1616         _cleanup_free_ struct local_address *gateways = NULL;
1617         int n, i;
1618
1619         assert(m);
1620
1621         /* Looks for a suitable "uplink", via black magic: an
1622          * interface that is up and where the default route with the
1623          * highest priority points to. */
1624
1625         n = local_gateways(m->rtnl, 0, AF_UNSPEC, &gateways);
1626         if (n < 0) {
1627                 log_warning_errno(n, "Failed to determine list of default gateways: %m");
1628                 return NULL;
1629         }
1630
1631         for (i = 0; i < n; i++) {
1632                 Link *link;
1633
1634                 link = hashmap_get(m->links, INT_TO_PTR(gateways[i].ifindex));
1635                 if (!link) {
1636                         log_debug("Weird, found a gateway for a link we don't know. Ignoring.");
1637                         continue;
1638                 }
1639
1640                 if (link == exclude)
1641                         continue;
1642
1643                 if (link->operstate < LINK_OPERSTATE_ROUTABLE)
1644                         continue;
1645
1646                 return link;
1647         }
1648
1649         return NULL;
1650 }
1651
1652 void manager_dirty(Manager *manager) {
1653         assert(manager);
1654
1655         /* the serialized state in /run is no longer up-to-date */
1656         manager->dirty = true;
1657 }
1658
1659 static int set_hostname_handler(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
1660         Manager *manager = userdata;
1661         const sd_bus_error *e;
1662
1663         assert(m);
1664         assert(manager);
1665
1666         e = sd_bus_message_get_error(m);
1667         if (e)
1668                 log_warning_errno(sd_bus_error_get_errno(e), "Could not set hostname: %s", e->message);
1669
1670         return 1;
1671 }
1672
1673 int manager_set_hostname(Manager *m, const char *hostname) {
1674         int r;
1675
1676         log_debug("Setting transient hostname: '%s'", strna(hostname));
1677         if (free_and_strdup(&m->dynamic_hostname, hostname) < 0)
1678                 return log_oom();
1679
1680         if (!m->bus) {
1681                 /* TODO: replace by assert when we can rely on kdbus */
1682                 log_info("Not connected to system bus, ignoring transient hostname.");
1683                 return 0;
1684         }
1685
1686         r = sd_bus_call_method_async(
1687                         m->bus,
1688                         NULL,
1689                         "org.freedesktop.hostname1",
1690                         "/org/freedesktop/hostname1",
1691                         "org.freedesktop.hostname1",
1692                         "SetHostname",
1693                         set_hostname_handler,
1694                         m,
1695                         "sb",
1696                         hostname,
1697                         false);
1698
1699         if (r < 0)
1700                 return log_error_errno(r, "Could not set transient hostname: %m");
1701
1702         return 0;
1703 }
1704
1705 static int set_timezone_handler(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
1706         Manager *manager = userdata;
1707         const sd_bus_error *e;
1708
1709         assert(m);
1710         assert(manager);
1711
1712         e = sd_bus_message_get_error(m);
1713         if (e)
1714                 log_warning_errno(sd_bus_error_get_errno(e), "Could not set timezone: %s", e->message);
1715
1716         return 1;
1717 }
1718
1719 int manager_set_timezone(Manager *m, const char *tz) {
1720         int r;
1721
1722         assert(m);
1723         assert(tz);
1724
1725         log_debug("Setting system timezone: '%s'", tz);
1726         if (free_and_strdup(&m->dynamic_timezone, tz) < 0)
1727                 return log_oom();
1728
1729         if (!m->bus) {
1730                 log_info("Not connected to system bus, ignoring timezone.");
1731                 return 0;
1732         }
1733
1734         r = sd_bus_call_method_async(
1735                         m->bus,
1736                         NULL,
1737                         "org.freedesktop.timedate1",
1738                         "/org/freedesktop/timedate1",
1739                         "org.freedesktop.timedate1",
1740                         "SetTimezone",
1741                         set_timezone_handler,
1742                         m,
1743                         "sb",
1744                         tz,
1745                         false);
1746         if (r < 0)
1747                 return log_error_errno(r, "Could not set timezone: %m");
1748
1749         return 0;
1750 }