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