src/network/networkd-manager.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <netinet/in.h>
   4 #include <sys/socket.h>
   5 #include <unistd.h>
   6 #include <linux/if.h>
   7 #include <linux/fib_rules.h>
   8 #include <linux/nexthop.h>
   9 #include <linux/nl80211.h>
  10
  11 #include "sd-daemon.h"
  12 #include "sd-netlink.h"
  13
  14 #include "alloc-util.h"
  15 #include "bus-error.h"
  16 #include "bus-log-control-api.h"
  17 #include "bus-polkit.h"
  18 #include "bus-util.h"
  19 #include "conf-parser.h"
  20 #include "def.h"
  21 #include "dns-domain.h"
  22 #include "fd-util.h"
  23 #include "fileio.h"
  24 #include "firewall-util.h"
  25 #include "fs-util.h"
  26 #include "local-addresses.h"
  27 #include "netlink-util.h"
  28 #include "network-internal.h"
  29 #include "networkd-address-pool.h"
  30 #include "networkd-address.h"
  31 #include "networkd-dhcp-server-bus.h"
  32 #include "networkd-dhcp6.h"
  33 #include "networkd-link-bus.h"
  34 #include "networkd-manager-bus.h"
  35 #include "networkd-manager.h"
  36 #include "networkd-neighbor.h"
  37 #include "networkd-network-bus.h"
  38 #include "networkd-nexthop.h"
  39 #include "networkd-queue.h"
  40 #include "networkd-route.h"
  41 #include "networkd-routing-policy-rule.h"
  42 #include "networkd-speed-meter.h"
  43 #include "networkd-state-file.h"
  44 #include "networkd-wifi.h"
  45 #include "ordered-set.h"
  46 #include "path-lookup.h"
  47 #include "path-util.h"
  48 #include "selinux-util.h"
  49 #include "set.h"
  50 #include "signal-util.h"
  51 #include "stat-util.h"
  52 #include "strv.h"
  53 #include "sysctl-util.h"
  54 #include "tmpfile-util.h"
  55
  56 /* use 128 MB for receive socket kernel queue. */
  57 #define RCVBUF_SIZE    (128*1024*1024)
  58
  59 static int manager_reset_all(Manager *m) {
  60         Link *link;
  61         int r;
  62
  63         assert(m);
  64
  65         HASHMAP_FOREACH(link, m->links_by_index) {
  66                 r = link_reconfigure_after_sleep(link);
  67                 if (r < 0) {
  68                         log_link_warning_errno(link, r, "Failed to reconfigure interface: %m");
  69                         link_enter_failed(link);
  70                 }
  71         }
  72
  73         return 0;
  74 }
  75
  76 static int match_prepare_for_sleep(sd_bus_message *message, void *userdata, sd_bus_error *ret_error) {
  77         Manager *m = userdata;
  78         int b, r;
  79
  80         assert(message);
  81         assert(m);
  82
  83         r = sd_bus_message_read(message, "b", &b);
  84         if (r < 0) {
  85                 bus_log_parse_error(r);
  86                 return 0;
  87         }
  88
  89         if (b)
  90                 return 0;
  91
  92         log_debug("Coming back from suspend, resetting all connections...");
  93
  94         (void) manager_reset_all(m);
  95
  96         return 0;
  97 }
  98
  99 static int on_connected(sd_bus_message *message, void *userdata, sd_bus_error *ret_error) {
 100         Manager *m = userdata;
 101
 102         assert(message);
 103         assert(m);
 104
 105         /* Did we get a timezone or transient hostname from DHCP while D-Bus wasn't up yet? */
 106         if (m->dynamic_hostname)
 107                 (void) manager_set_hostname(m, m->dynamic_hostname);
 108         if (m->dynamic_timezone)
 109                 (void) manager_set_timezone(m, m->dynamic_timezone);
 110         if (m->product_uuid_requested)
 111                 (void) manager_request_product_uuid(m);
 112
 113         return 0;
 114 }
 115
 116 static int manager_connect_bus(Manager *m) {
 117         int r;
 118
 119         assert(m);
 120         assert(!m->bus);
 121
 122         r = bus_open_system_watch_bind_with_description(&m->bus, "bus-api-network");
 123         if (r < 0)
 124                 return log_error_errno(r, "Failed to connect to bus: %m");
 125
 126         r = sd_bus_add_object_vtable(m->bus, NULL, "/org/freedesktop/network1", "org.freedesktop.network1.Manager", manager_vtable, m);
 127         if (r < 0)
 128                 return log_error_errno(r, "Failed to add manager object vtable: %m");
 129
 130         r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/network1/link", "org.freedesktop.network1.Link", link_vtable, link_object_find, m);
 131         if (r < 0)
 132                return log_error_errno(r, "Failed to add link object vtable: %m");
 133
 134         r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/network1/link", "org.freedesktop.network1.DHCPServer", dhcp_server_vtable, link_object_find, m);
 135         if (r < 0)
 136                return log_error_errno(r, "Failed to add link object vtable: %m");
 137
 138         r = sd_bus_add_node_enumerator(m->bus, NULL, "/org/freedesktop/network1/link", link_node_enumerator, m);
 139         if (r < 0)
 140                 return log_error_errno(r, "Failed to add link enumerator: %m");
 141
 142         r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/network1/network", "org.freedesktop.network1.Network", network_vtable, network_object_find, m);
 143         if (r < 0)
 144                return log_error_errno(r, "Failed to add network object vtable: %m");
 145
 146         r = sd_bus_add_node_enumerator(m->bus, NULL, "/org/freedesktop/network1/network", network_node_enumerator, m);
 147         if (r < 0)
 148                 return log_error_errno(r, "Failed to add network enumerator: %m");
 149
 150         r = bus_log_control_api_register(m->bus);
 151         if (r < 0)
 152                 return r;
 153
 154         r = sd_bus_request_name_async(m->bus, NULL, "org.freedesktop.network1", 0, NULL, NULL);
 155         if (r < 0)
 156                 return log_error_errno(r, "Failed to request name: %m");
 157
 158         r = sd_bus_attach_event(m->bus, m->event, 0);
 159         if (r < 0)
 160                 return log_error_errno(r, "Failed to attach bus to event loop: %m");
 161
 162         r = sd_bus_match_signal_async(
 163                         m->bus,
 164                         NULL,
 165                         "org.freedesktop.DBus.Local",
 166                         NULL,
 167                         "org.freedesktop.DBus.Local",
 168                         "Connected",
 169                         on_connected, NULL, m);
 170         if (r < 0)
 171                 return log_error_errno(r, "Failed to request match on Connected signal: %m");
 172
 173         r = sd_bus_match_signal_async(
 174                         m->bus,
 175                         NULL,
 176                         "org.freedesktop.login1",
 177                         "/org/freedesktop/login1",
 178                         "org.freedesktop.login1.Manager",
 179                         "PrepareForSleep",
 180                         match_prepare_for_sleep, NULL, m);
 181         if (r < 0)
 182                 log_warning_errno(r, "Failed to request match for PrepareForSleep, ignoring: %m");
 183
 184         return 0;
 185 }
 186
 187 static int manager_connect_udev(Manager *m) {
 188         int r;
 189
 190         /* udev does not initialize devices inside containers, so we rely on them being already
 191          * initialized before entering the container. */
 192         if (path_is_read_only_fs("/sys") > 0)
 193                 return 0;
 194
 195         r = sd_device_monitor_new(&m->device_monitor);
 196         if (r < 0)
 197                 return log_error_errno(r, "Failed to initialize device monitor: %m");
 198
 199         r = sd_device_monitor_set_receive_buffer_size(m->device_monitor, RCVBUF_SIZE);
 200         if (r < 0)
 201                 log_warning_errno(r, "Failed to increase buffer size for device monitor, ignoring: %m");
 202
 203         r = sd_device_monitor_filter_add_match_subsystem_devtype(m->device_monitor, "net", NULL);
 204         if (r < 0)
 205                 return log_error_errno(r, "Could not add device monitor filter: %m");
 206
 207         r = sd_device_monitor_attach_event(m->device_monitor, m->event);
 208         if (r < 0)
 209                 return log_error_errno(r, "Failed to attach event to device monitor: %m");
 210
 211         r = sd_device_monitor_start(m->device_monitor, manager_udev_process_link, m);
 212         if (r < 0)
 213                 return log_error_errno(r, "Failed to start device monitor: %m");
 214
 215         return 0;
 216 }
 217
 218 static int systemd_netlink_fd(void) {
 219         int n, fd, rtnl_fd = -EINVAL;
 220
 221         n = sd_listen_fds(true);
 222         if (n <= 0)
 223                 return -EINVAL;
 224
 225         for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
 226                 if (sd_is_socket(fd, AF_NETLINK, SOCK_RAW, -1) > 0) {
 227                         if (rtnl_fd >= 0)
 228                                 return -EINVAL;
 229
 230                         rtnl_fd = fd;
 231                 }
 232
 233         return rtnl_fd;
 234 }
 235
 236 static int manager_connect_genl(Manager *m) {
 237         int r;
 238
 239         assert(m);
 240
 241         r = sd_genl_socket_open(&m->genl);
 242         if (r < 0)
 243                 return r;
 244
 245         r = sd_netlink_inc_rcvbuf(m->genl, RCVBUF_SIZE);
 246         if (r < 0)
 247                 log_warning_errno(r, "Failed to increase receive buffer size for general netlink socket, ignoring: %m");
 248
 249         r = sd_netlink_attach_event(m->genl, m->event, 0);
 250         if (r < 0)
 251                 return r;
 252
 253         r = genl_add_match(m->genl, NULL, NL80211_GENL_NAME, NL80211_MULTICAST_GROUP_CONFIG, 0,
 254                            &manager_genl_process_nl80211_config, NULL, m, "network-genl_process_nl80211_config");
 255         if (r < 0 && r != -EOPNOTSUPP)
 256                 return r;
 257
 258         r = genl_add_match(m->genl, NULL, NL80211_GENL_NAME, NL80211_MULTICAST_GROUP_MLME, 0,
 259                            &manager_genl_process_nl80211_mlme, NULL, m, "network-genl_process_nl80211_mlme");
 260         if (r < 0 && r != -EOPNOTSUPP)
 261                 return r;
 262
 263         return 0;
 264 }
 265
 266 static int manager_connect_rtnl(Manager *m) {
 267         int fd, r;
 268
 269         assert(m);
 270
 271         fd = systemd_netlink_fd();
 272         if (fd < 0)
 273                 r = sd_netlink_open(&m->rtnl);
 274         else
 275                 r = sd_netlink_open_fd(&m->rtnl, fd);
 276         if (r < 0)
 277                 return r;
 278
 279         /* Bump receiver buffer, but only if we are not called via socket activation, as in that
 280          * case systemd sets the receive buffer size for us, and the value in the .socket unit
 281          * should take full effect. */
 282         if (fd < 0) {
 283                 r = sd_netlink_inc_rcvbuf(m->rtnl, RCVBUF_SIZE);
 284                 if (r < 0)
 285                         log_warning_errno(r, "Failed to increase receive buffer size for rtnl socket, ignoring: %m");
 286         }
 287
 288         r = sd_netlink_attach_event(m->rtnl, m->event, 0);
 289         if (r < 0)
 290                 return r;
 291
 292         r = netlink_add_match(m->rtnl, NULL, RTM_NEWLINK, &manager_rtnl_process_link, NULL, m, "network-rtnl_process_link");
 293         if (r < 0)
 294                 return r;
 295
 296         r = netlink_add_match(m->rtnl, NULL, RTM_DELLINK, &manager_rtnl_process_link, NULL, m, "network-rtnl_process_link");
 297         if (r < 0)
 298                 return r;
 299
 300         r = netlink_add_match(m->rtnl, NULL, RTM_NEWADDR, &manager_rtnl_process_address, NULL, m, "network-rtnl_process_address");
 301         if (r < 0)
 302                 return r;
 303
 304         r = netlink_add_match(m->rtnl, NULL, RTM_DELADDR, &manager_rtnl_process_address, NULL, m, "network-rtnl_process_address");
 305         if (r < 0)
 306                 return r;
 307
 308         r = netlink_add_match(m->rtnl, NULL, RTM_NEWNEIGH, &manager_rtnl_process_neighbor, NULL, m, "network-rtnl_process_neighbor");
 309         if (r < 0)
 310                 return r;
 311
 312         r = netlink_add_match(m->rtnl, NULL, RTM_DELNEIGH, &manager_rtnl_process_neighbor, NULL, m, "network-rtnl_process_neighbor");
 313         if (r < 0)
 314                 return r;
 315
 316         r = netlink_add_match(m->rtnl, NULL, RTM_NEWROUTE, &manager_rtnl_process_route, NULL, m, "network-rtnl_process_route");
 317         if (r < 0)
 318                 return r;
 319
 320         r = netlink_add_match(m->rtnl, NULL, RTM_DELROUTE, &manager_rtnl_process_route, NULL, m, "network-rtnl_process_route");
 321         if (r < 0)
 322                 return r;
 323
 324         r = netlink_add_match(m->rtnl, NULL, RTM_NEWRULE, &manager_rtnl_process_rule, NULL, m, "network-rtnl_process_rule");
 325         if (r < 0)
 326                 return r;
 327
 328         r = netlink_add_match(m->rtnl, NULL, RTM_DELRULE, &manager_rtnl_process_rule, NULL, m, "network-rtnl_process_rule");
 329         if (r < 0)
 330                 return r;
 331
 332         r = netlink_add_match(m->rtnl, NULL, RTM_NEWNEXTHOP, &manager_rtnl_process_nexthop, NULL, m, "network-rtnl_process_nexthop");
 333         if (r < 0)
 334                 return r;
 335
 336         r = netlink_add_match(m->rtnl, NULL, RTM_DELNEXTHOP, &manager_rtnl_process_nexthop, NULL, m, "network-rtnl_process_nexthop");
 337         if (r < 0)
 338                 return r;
 339
 340         return 0;
 341 }
 342
 343 static int manager_dirty_handler(sd_event_source *s, void *userdata) {
 344         Manager *m = userdata;
 345         Link *link;
 346         int r;
 347
 348         assert(m);
 349
 350         if (m->dirty) {
 351                 r = manager_save(m);
 352                 if (r < 0)
 353                         log_warning_errno(r, "Failed to update state file %s, ignoring: %m", m->state_file);
 354         }
 355
 356         SET_FOREACH(link, m->dirty_links) {
 357                 r = link_save_and_clean(link);
 358                 if (r < 0)
 359                         log_link_warning_errno(link, r, "Failed to update link state file %s, ignoring: %m", link->state_file);
 360         }
 361
 362         return 1;
 363 }
 364
 365 static int signal_terminate_callback(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
 366         Manager *m = userdata;
 367
 368         assert(m);
 369         m->restarting = false;
 370
 371         log_debug("Terminate operation initiated.");
 372
 373         return sd_event_exit(sd_event_source_get_event(s), 0);
 374 }
 375
 376 static int signal_restart_callback(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
 377         Manager *m = userdata;
 378
 379         assert(m);
 380         m->restarting = true;
 381
 382         log_debug("Restart operation initiated.");
 383
 384         return sd_event_exit(sd_event_source_get_event(s), 0);
 385 }
 386
 387 int manager_setup(Manager *m) {
 388         int r;
 389
 390         assert(m);
 391
 392         r = sd_event_default(&m->event);
 393         if (r < 0)
 394                 return r;
 395
 396         assert_se(sigprocmask_many(SIG_SETMASK, NULL, SIGINT, SIGTERM, SIGUSR2, -1) >= 0);
 397
 398         (void) sd_event_set_watchdog(m->event, true);
 399         (void) sd_event_add_signal(m->event, NULL, SIGTERM, signal_terminate_callback, m);
 400         (void) sd_event_add_signal(m->event, NULL, SIGINT, signal_terminate_callback, m);
 401         (void) sd_event_add_signal(m->event, NULL, SIGUSR2, signal_restart_callback, m);
 402
 403         r = sd_event_add_post(m->event, NULL, manager_dirty_handler, m);
 404         if (r < 0)
 405                 return r;
 406
 407         r = sd_event_add_post(m->event, NULL, manager_process_requests, m);
 408         if (r < 0)
 409                 return r;
 410
 411         r = manager_connect_rtnl(m);
 412         if (r < 0)
 413                 return r;
 414
 415         r = manager_connect_genl(m);
 416         if (r < 0)
 417                 return r;
 418
 419         if (m->test_mode)
 420                 return 0;
 421
 422         r = manager_connect_bus(m);
 423         if (r < 0)
 424                 return r;
 425
 426         r = manager_connect_udev(m);
 427         if (r < 0)
 428                 return r;
 429
 430         r = sd_resolve_default(&m->resolve);
 431         if (r < 0)
 432                 return r;
 433
 434         r = sd_resolve_attach_event(m->resolve, m->event, 0);
 435         if (r < 0)
 436                 return r;
 437
 438         r = address_pool_setup_default(m);
 439         if (r < 0)
 440                 return r;
 441
 442         m->state_file = strdup("/run/systemd/netif/state");
 443         if (!m->state_file)
 444                 return -ENOMEM;
 445
 446         return 0;
 447 }
 448
 449 int manager_new(Manager **ret, bool test_mode) {
 450         _cleanup_(manager_freep) Manager *m = NULL;
 451
 452         m = new(Manager, 1);
 453         if (!m)
 454                 return -ENOMEM;
 455
 456         *m = (Manager) {
 457                 .test_mode = test_mode,
 458                 .speed_meter_interval_usec = SPEED_METER_DEFAULT_TIME_INTERVAL,
 459                 .online_state = _LINK_ONLINE_STATE_INVALID,
 460                 .manage_foreign_routes = true,
 461                 .manage_foreign_rules = true,
 462                 .ethtool_fd = -1,
 463                 .dhcp_duid.type = DUID_TYPE_EN,
 464                 .dhcp6_duid.type = DUID_TYPE_EN,
 465                 .duid_product_uuid.type = DUID_TYPE_UUID,
 466         };
 467
 468         *ret = TAKE_PTR(m);
 469         return 0;
 470 }
 471
 472 Manager* manager_free(Manager *m) {
 473         Link *link;
 474
 475         if (!m)
 476                 return NULL;
 477
 478         free(m->state_file);
 479
 480         HASHMAP_FOREACH(link, m->links_by_index)
 481                 (void) link_stop_engines(link, true);
 482
 483         m->request_queue = ordered_set_free(m->request_queue);
 484
 485         m->dirty_links = set_free_with_destructor(m->dirty_links, link_unref);
 486         m->links_by_name = hashmap_free(m->links_by_name);
 487         m->links_by_hw_addr = hashmap_free(m->links_by_hw_addr);
 488         m->links_by_index = hashmap_free_with_destructor(m->links_by_index, link_unref);
 489
 490         m->networks = ordered_hashmap_free_with_destructor(m->networks, network_unref);
 491
 492         m->netdevs = hashmap_free_with_destructor(m->netdevs, netdev_unref);
 493
 494         ordered_set_free_free(m->address_pools);
 495
 496         hashmap_free(m->route_table_names_by_number);
 497         hashmap_free(m->route_table_numbers_by_name);
 498
 499         set_free(m->rules);
 500
 501         sd_netlink_unref(m->rtnl);
 502         sd_netlink_unref(m->genl);
 503         sd_resolve_unref(m->resolve);
 504
 505         /* reject (e.g. unreachable) type routes are managed by Manager, but may be referenced by a
 506          * link. E.g., DHCP6 with prefix delegation creates unreachable routes, and they are referenced
 507          * by the upstream link. And the links may be referenced by netlink slots. Hence, two
 508          * set_free() must be called after the above sd_netlink_unref(). */
 509         m->routes = set_free(m->routes);
 510         m->routes_foreign = set_free(m->routes_foreign);
 511
 512         m->nexthops = set_free(m->nexthops);
 513         m->nexthops_by_id = hashmap_free(m->nexthops_by_id);
 514
 515         sd_event_source_unref(m->speed_meter_event_source);
 516         sd_event_unref(m->event);
 517
 518         sd_device_monitor_unref(m->device_monitor);
 519
 520         bus_verify_polkit_async_registry_free(m->polkit_registry);
 521         sd_bus_flush_close_unref(m->bus);
 522
 523         free(m->dynamic_timezone);
 524         free(m->dynamic_hostname);
 525
 526         safe_close(m->ethtool_fd);
 527
 528         m->fw_ctx = fw_ctx_free(m->fw_ctx);
 529
 530         return mfree(m);
 531 }
 532
 533 int manager_start(Manager *m) {
 534         Link *link;
 535         int r;
 536
 537         assert(m);
 538
 539         r = manager_start_speed_meter(m);
 540         if (r < 0)
 541                 return log_error_errno(r, "Failed to initialize speed meter: %m");
 542
 543         /* The dirty handler will deal with future serialization, but the first one
 544            must be done explicitly. */
 545
 546         r = manager_save(m);
 547         if (r < 0)
 548                 log_warning_errno(r, "Failed to update state file %s, ignoring: %m", m->state_file);
 549
 550         HASHMAP_FOREACH(link, m->links_by_index) {
 551                 r = link_save(link);
 552                 if (r < 0)
 553                         log_link_warning_errno(link, r, "Failed to update link state file %s, ignoring: %m", link->state_file);
 554         }
 555
 556         return 0;
 557 }
 558
 559 int manager_load_config(Manager *m) {
 560         int r;
 561
 562         /* update timestamp */
 563         paths_check_timestamp(NETWORK_DIRS, &m->network_dirs_ts_usec, true);
 564
 565         r = netdev_load(m, false);
 566         if (r < 0)
 567                 return r;
 568
 569         r = network_load(m, &m->networks);
 570         if (r < 0)
 571                 return r;
 572
 573         return 0;
 574 }
 575
 576 bool manager_should_reload(Manager *m) {
 577         return paths_check_timestamp(NETWORK_DIRS, &m->network_dirs_ts_usec, false);
 578 }
 579
 580 static int manager_enumerate_internal(
 581                 Manager *m,
 582                 sd_netlink *nl,
 583                 sd_netlink_message *req,
 584                 int (*process)(sd_netlink *, sd_netlink_message *, Manager *)) {
 585
 586         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *reply = NULL;
 587         int k, r;
 588
 589         assert(m);
 590         assert(nl);
 591         assert(req);
 592         assert(process);
 593
 594         r = sd_netlink_message_request_dump(req, true);
 595         if (r < 0)
 596                 return r;
 597
 598         r = sd_netlink_call(nl, req, 0, &reply);
 599         if (r < 0)
 600                 return r;
 601
 602         for (sd_netlink_message *reply_one = reply; reply_one; reply_one = sd_netlink_message_next(reply_one)) {
 603                 m->enumerating = true;
 604
 605                 k = process(nl, reply_one, m);
 606                 if (k < 0 && r >= 0)
 607                         r = k;
 608
 609                 m->enumerating = false;
 610         }
 611
 612         return r;
 613 }
 614
 615 static int manager_enumerate_links(Manager *m) {
 616         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
 617         int r;
 618
 619         assert(m);
 620         assert(m->rtnl);
 621
 622         r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
 623         if (r < 0)
 624                 return r;
 625
 626         return manager_enumerate_internal(m, m->rtnl, req, manager_rtnl_process_link);
 627 }
 628
 629 static int manager_enumerate_addresses(Manager *m) {
 630         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
 631         int r;
 632
 633         assert(m);
 634         assert(m->rtnl);
 635
 636         r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, 0, 0);
 637         if (r < 0)
 638                 return r;
 639
 640         return manager_enumerate_internal(m, m->rtnl, req, manager_rtnl_process_address);
 641 }
 642
 643 static int manager_enumerate_neighbors(Manager *m) {
 644         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
 645         int r;
 646
 647         assert(m);
 648         assert(m->rtnl);
 649
 650         r = sd_rtnl_message_new_neigh(m->rtnl, &req, RTM_GETNEIGH, 0, AF_UNSPEC);
 651         if (r < 0)
 652                 return r;
 653
 654         return manager_enumerate_internal(m, m->rtnl, req, manager_rtnl_process_neighbor);
 655 }
 656
 657 static int manager_enumerate_routes(Manager *m) {
 658         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
 659         int r;
 660
 661         assert(m);
 662         assert(m->rtnl);
 663
 664         if (!m->manage_foreign_routes)
 665                 return 0;
 666
 667         r = sd_rtnl_message_new_route(m->rtnl, &req, RTM_GETROUTE, 0, 0);
 668         if (r < 0)
 669                 return r;
 670
 671         return manager_enumerate_internal(m, m->rtnl, req, manager_rtnl_process_route);
 672 }
 673
 674 static int manager_enumerate_rules(Manager *m) {
 675         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
 676         int r;
 677
 678         assert(m);
 679         assert(m->rtnl);
 680
 681         if (!m->manage_foreign_rules)
 682                 return 0;
 683
 684         r = sd_rtnl_message_new_routing_policy_rule(m->rtnl, &req, RTM_GETRULE, 0);
 685         if (r < 0)
 686                 return r;
 687
 688         return manager_enumerate_internal(m, m->rtnl, req, manager_rtnl_process_rule);
 689 }
 690
 691 static int manager_enumerate_nexthop(Manager *m) {
 692         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
 693         int r;
 694
 695         assert(m);
 696         assert(m->rtnl);
 697
 698         r = sd_rtnl_message_new_nexthop(m->rtnl, &req, RTM_GETNEXTHOP, 0, 0);
 699         if (r < 0)
 700                 return r;
 701
 702         return manager_enumerate_internal(m, m->rtnl, req, manager_rtnl_process_nexthop);
 703 }
 704
 705 static int manager_enumerate_nl80211_config(Manager *m) {
 706         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
 707         int r;
 708
 709         assert(m);
 710         assert(m->genl);
 711
 712         r = sd_genl_message_new(m->genl, NL80211_GENL_NAME, NL80211_CMD_GET_INTERFACE, &req);
 713         if (r < 0)
 714                 return r;
 715
 716         return manager_enumerate_internal(m, m->genl, req, manager_genl_process_nl80211_config);
 717 }
 718
 719 static int manager_enumerate_nl80211_mlme(Manager *m) {
 720         Link *link;
 721         int r;
 722
 723         assert(m);
 724         assert(m->genl);
 725
 726         HASHMAP_FOREACH(link, m->links_by_index) {
 727                 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
 728
 729                 if (link->wlan_iftype != NL80211_IFTYPE_STATION)
 730                         continue;
 731
 732                 r = sd_genl_message_new(m->genl, NL80211_GENL_NAME, NL80211_CMD_GET_STATION, &req);
 733                 if (r < 0)
 734                         return r;
 735
 736                 r = sd_netlink_message_append_u32(req, NL80211_ATTR_IFINDEX, link->ifindex);
 737                 if (r < 0)
 738                         return r;
 739
 740                 r = manager_enumerate_internal(m, m->genl, req, manager_genl_process_nl80211_mlme);
 741                 if (r < 0)
 742                         return r;
 743         }
 744
 745         return 0;
 746 }
 747
 748 int manager_enumerate(Manager *m) {
 749         int r;
 750
 751         r = manager_enumerate_links(m);
 752         if (r < 0)
 753                 return log_error_errno(r, "Could not enumerate links: %m");
 754
 755         r = manager_enumerate_addresses(m);
 756         if (r < 0)
 757                 return log_error_errno(r, "Could not enumerate addresses: %m");
 758
 759         r = manager_enumerate_neighbors(m);
 760         if (r < 0)
 761                 return log_error_errno(r, "Could not enumerate neighbors: %m");
 762
 763         /* NextHop support is added in kernel v5.3 (65ee00a9409f751188a8cdc0988167858eb4a536),
 764          * and older kernels return -EOPNOTSUPP, or -EINVAL if SELinux is enabled. */
 765         r = manager_enumerate_nexthop(m);
 766         if (r == -EOPNOTSUPP || (r == -EINVAL && mac_selinux_enforcing()))
 767                 log_debug_errno(r, "Could not enumerate nexthops, ignoring: %m");
 768         else if (r < 0)
 769                 return log_error_errno(r, "Could not enumerate nexthops: %m");
 770
 771         r = manager_enumerate_routes(m);
 772         if (r < 0)
 773                 return log_error_errno(r, "Could not enumerate routes: %m");
 774
 775         /* If kernel is built with CONFIG_FIB_RULES=n, it returns -EOPNOTSUPP. */
 776         r = manager_enumerate_rules(m);
 777         if (r == -EOPNOTSUPP)
 778                 log_debug_errno(r, "Could not enumerate routing policy rules, ignoring: %m");
 779         else if (r < 0)
 780                 return log_error_errno(r, "Could not enumerate routing policy rules: %m");
 781
 782         r = manager_enumerate_nl80211_config(m);
 783         if (r == -EOPNOTSUPP)
 784                 log_debug_errno(r, "Could not enumerate wireless LAN interfaces, ignoring: %m");
 785         else if (r < 0)
 786                 return log_error_errno(r, "Could not enumerate wireless LAN interfaces: %m");
 787
 788         r = manager_enumerate_nl80211_mlme(m);
 789         if (r == -EOPNOTSUPP)
 790                 log_debug_errno(r, "Could not enumerate wireless LAN stations, ignoring: %m");
 791         else if (r < 0)
 792                 return log_error_errno(r, "Could not enumerate wireless LAN stations: %m");
 793
 794         return 0;
 795 }
 796
 797 static int set_hostname_handler(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
 798         const sd_bus_error *e;
 799         int r;
 800
 801         assert(m);
 802
 803         e = sd_bus_message_get_error(m);
 804         if (e) {
 805                 r = sd_bus_error_get_errno(e);
 806                 log_warning_errno(r, "Could not set hostname: %s", bus_error_message(e, r));
 807         }
 808
 809         return 1;
 810 }
 811
 812 int manager_set_hostname(Manager *m, const char *hostname) {
 813         int r;
 814
 815         log_debug("Setting transient hostname: '%s'", strna(hostname));
 816
 817         r = free_and_strdup_warn(&m->dynamic_hostname, hostname);
 818         if (r < 0)
 819                 return r;
 820
 821         if (sd_bus_is_ready(m->bus) <= 0) {
 822                 log_debug("Not connected to system bus, setting system hostname later.");
 823                 return 0;
 824         }
 825
 826         r = sd_bus_call_method_async(
 827                         m->bus,
 828                         NULL,
 829                         "org.freedesktop.hostname1",
 830                         "/org/freedesktop/hostname1",
 831                         "org.freedesktop.hostname1",
 832                         "SetHostname",
 833                         set_hostname_handler,
 834                         m,
 835                         "sb",
 836                         hostname,
 837                         false);
 838         if (r < 0)
 839                 return log_error_errno(r, "Could not set transient hostname: %m");
 840
 841         return 0;
 842 }
 843
 844 static int set_timezone_handler(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
 845         const sd_bus_error *e;
 846         int r;
 847
 848         assert(m);
 849
 850         e = sd_bus_message_get_error(m);
 851         if (e) {
 852                 r = sd_bus_error_get_errno(e);
 853                 log_warning_errno(r, "Could not set timezone: %s", bus_error_message(e, r));
 854         }
 855
 856         return 1;
 857 }
 858
 859 int manager_set_timezone(Manager *m, const char *tz) {
 860         int r;
 861
 862         assert(m);
 863         assert(tz);
 864
 865         log_debug("Setting system timezone: '%s'", tz);
 866         r = free_and_strdup_warn(&m->dynamic_timezone, tz);
 867         if (r < 0)
 868                 return r;
 869
 870         if (sd_bus_is_ready(m->bus) <= 0) {
 871                 log_debug("Not connected to system bus, setting system timezone later.");
 872                 return 0;
 873         }
 874
 875         r = sd_bus_call_method_async(
 876                         m->bus,
 877                         NULL,
 878                         "org.freedesktop.timedate1",
 879                         "/org/freedesktop/timedate1",
 880                         "org.freedesktop.timedate1",
 881                         "SetTimezone",
 882                         set_timezone_handler,
 883                         m,
 884                         "sb",
 885                         tz,
 886                         false);
 887         if (r < 0)
 888                 return log_error_errno(r, "Could not set timezone: %m");
 889
 890         return 0;
 891 }