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