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
  10 #include "sd-daemon.h"
  11 #include "sd-netlink.h"
  12
  13 #include "alloc-util.h"
  14 #include "bus-log-control-api.h"
  15 #include "bus-polkit.h"
  16 #include "bus-util.h"
  17 #include "conf-parser.h"
  18 #include "def.h"
  19 #include "device-private.h"
  20 #include "device-util.h"
  21 #include "dns-domain.h"
  22 #include "fd-util.h"
  23 #include "fileio.h"
  24 #include "local-addresses.h"
  25 #include "netlink-util.h"
  26 #include "network-internal.h"
  27 #include "networkd-address-pool.h"
  28 #include "networkd-dhcp-server-bus.h"
  29 #include "networkd-dhcp6.h"
  30 #include "networkd-link-bus.h"
  31 #include "networkd-manager-bus.h"
  32 #include "networkd-manager.h"
  33 #include "networkd-neighbor.h"
  34 #include "networkd-network-bus.h"
  35 #include "networkd-nexthop.h"
  36 #include "networkd-routing-policy-rule.h"
  37 #include "networkd-speed-meter.h"
  38 #include "ordered-set.h"
  39 #include "path-lookup.h"
  40 #include "path-util.h"
  41 #include "selinux-util.h"
  42 #include "set.h"
  43 #include "signal-util.h"
  44 #include "stat-util.h"
  45 #include "strv.h"
  46 #include "sysctl-util.h"
  47 #include "tmpfile-util.h"
  48 #include "udev-util.h"
  49
  50 /* use 128 MB for receive socket kernel queue. */
  51 #define RCVBUF_SIZE    (128*1024*1024)
  52
  53 static int manager_reset_all(Manager *m) {
  54         Link *link;
  55         int r;
  56
  57         assert(m);
  58
  59         HASHMAP_FOREACH(link, m->links) {
  60                 r = link_carrier_reset(link);
  61                 if (r < 0)
  62                         log_link_warning_errno(link, r, "Could not reset carrier: %m");
  63         }
  64
  65         return 0;
  66 }
  67
  68 static int match_prepare_for_sleep(sd_bus_message *message, void *userdata, sd_bus_error *ret_error) {
  69         Manager *m = userdata;
  70         int b, r;
  71
  72         assert(message);
  73         assert(m);
  74
  75         r = sd_bus_message_read(message, "b", &b);
  76         if (r < 0) {
  77                 bus_log_parse_error(r);
  78                 return 0;
  79         }
  80
  81         if (b)
  82                 return 0;
  83
  84         log_debug("Coming back from suspend, resetting all connections...");
  85
  86         (void) manager_reset_all(m);
  87
  88         return 0;
  89 }
  90
  91 static int on_connected(sd_bus_message *message, void *userdata, sd_bus_error *ret_error) {
  92         Manager *m = userdata;
  93
  94         assert(message);
  95         assert(m);
  96
  97         /* Did we get a timezone or transient hostname from DHCP while D-Bus wasn't up yet? */
  98         if (m->dynamic_hostname)
  99                 (void) manager_set_hostname(m, m->dynamic_hostname);
 100         if (m->dynamic_timezone)
 101                 (void) manager_set_timezone(m, m->dynamic_timezone);
 102         if (m->links_requesting_uuid)
 103                 (void) manager_request_product_uuid(m, NULL);
 104
 105         return 0;
 106 }
 107
 108 int manager_connect_bus(Manager *m) {
 109         int r;
 110
 111         assert(m);
 112
 113         if (m->bus)
 114                 return 0;
 115
 116         r = bus_open_system_watch_bind_with_description(&m->bus, "bus-api-network");
 117         if (r < 0)
 118                 return log_error_errno(r, "Failed to connect to bus: %m");
 119
 120         r = sd_bus_add_object_vtable(m->bus, NULL, "/org/freedesktop/network1", "org.freedesktop.network1.Manager", manager_vtable, m);
 121         if (r < 0)
 122                 return log_error_errno(r, "Failed to add manager object vtable: %m");
 123
 124         r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/network1/link", "org.freedesktop.network1.Link", link_vtable, link_object_find, m);
 125         if (r < 0)
 126                return log_error_errno(r, "Failed to add link object vtable: %m");
 127
 128         r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/network1/link", "org.freedesktop.network1.DHCPServer", dhcp_server_vtable, link_object_find, m);
 129         if (r < 0)
 130                return log_error_errno(r, "Failed to add link object vtable: %m");
 131
 132         r = sd_bus_add_node_enumerator(m->bus, NULL, "/org/freedesktop/network1/link", link_node_enumerator, m);
 133         if (r < 0)
 134                 return log_error_errno(r, "Failed to add link enumerator: %m");
 135
 136         r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/network1/network", "org.freedesktop.network1.Network", network_vtable, network_object_find, m);
 137         if (r < 0)
 138                return log_error_errno(r, "Failed to add network object vtable: %m");
 139
 140         r = sd_bus_add_node_enumerator(m->bus, NULL, "/org/freedesktop/network1/network", network_node_enumerator, m);
 141         if (r < 0)
 142                 return log_error_errno(r, "Failed to add network enumerator: %m");
 143
 144         r = bus_log_control_api_register(m->bus);
 145         if (r < 0)
 146                 return r;
 147
 148         r = sd_bus_request_name_async(m->bus, NULL, "org.freedesktop.network1", 0, NULL, NULL);
 149         if (r < 0)
 150                 return log_error_errno(r, "Failed to request name: %m");
 151
 152         r = sd_bus_attach_event(m->bus, m->event, 0);
 153         if (r < 0)
 154                 return log_error_errno(r, "Failed to attach bus to event loop: %m");
 155
 156         r = sd_bus_match_signal_async(
 157                         m->bus,
 158                         NULL,
 159                         "org.freedesktop.DBus.Local",
 160                         NULL,
 161                         "org.freedesktop.DBus.Local",
 162                         "Connected",
 163                         on_connected, NULL, m);
 164         if (r < 0)
 165                 return log_error_errno(r, "Failed to request match on Connected signal: %m");
 166
 167         r = sd_bus_match_signal_async(
 168                         m->bus,
 169                         NULL,
 170                         "org.freedesktop.login1",
 171                         "/org/freedesktop/login1",
 172                         "org.freedesktop.login1.Manager",
 173                         "PrepareForSleep",
 174                         match_prepare_for_sleep, NULL, m);
 175         if (r < 0)
 176                 log_warning_errno(r, "Failed to request match for PrepareForSleep, ignoring: %m");
 177
 178         return 0;
 179 }
 180
 181 static int manager_udev_process_link(sd_device_monitor *monitor, sd_device *device, void *userdata) {
 182         Manager *m = userdata;
 183         DeviceAction action;
 184         Link *link = NULL;
 185         int r, ifindex;
 186
 187         assert(m);
 188         assert(device);
 189
 190         r = device_get_action(device, &action);
 191         if (r < 0) {
 192                 log_device_debug_errno(device, r, "Failed to get udev action, ignoring device: %m");
 193                 return 0;
 194         }
 195
 196         /* Ignore the "remove" uevent — let's remove a device only if rtnetlink says so. All other uevents
 197          * are "positive" events in some form, i.e. inform us about a changed or new network interface, that
 198          * still exists — and we are interested in that. */
 199         if (action == DEVICE_ACTION_REMOVE)
 200                 return 0;
 201
 202         r = sd_device_get_ifindex(device, &ifindex);
 203         if (r < 0) {
 204                 log_device_debug_errno(device, r, "Ignoring udev %s event for device without ifindex or with invalid ifindex: %m",
 205                                        device_action_to_string(action));
 206                 return 0;
 207         }
 208
 209         r = device_is_renaming(device);
 210         if (r < 0) {
 211                 log_device_error_errno(device, r, "Failed to determine the device is renamed or not, ignoring '%s' uevent: %m",
 212                                        device_action_to_string(action));
 213                 return 0;
 214         }
 215         if (r > 0) {
 216                 log_device_debug(device, "Interface is under renaming, wait for the interface to be renamed.");
 217                 return 0;
 218         }
 219
 220         r = link_get(m, ifindex, &link);
 221         if (r < 0) {
 222                 if (r != -ENODEV)
 223                         log_debug_errno(r, "Failed to get link from ifindex %i, ignoring: %m", ifindex);
 224                 return 0;
 225         }
 226
 227         (void) link_initialized(link, device);
 228
 229         return 0;
 230 }
 231
 232 static int manager_connect_udev(Manager *m) {
 233         int r;
 234
 235         /* udev does not initialize devices inside containers, so we rely on them being already
 236          * initialized before entering the container. */
 237         if (path_is_read_only_fs("/sys") > 0)
 238                 return 0;
 239
 240         r = sd_device_monitor_new(&m->device_monitor);
 241         if (r < 0)
 242                 return log_error_errno(r, "Failed to initialize device monitor: %m");
 243
 244         r = sd_device_monitor_set_receive_buffer_size(m->device_monitor, RCVBUF_SIZE);
 245         if (r < 0)
 246                 log_warning_errno(r, "Failed to increase buffer size for device monitor, ignoring: %m");
 247
 248         r = sd_device_monitor_filter_add_match_subsystem_devtype(m->device_monitor, "net", NULL);
 249         if (r < 0)
 250                 return log_error_errno(r, "Could not add device monitor filter: %m");
 251
 252         r = sd_device_monitor_attach_event(m->device_monitor, m->event);
 253         if (r < 0)
 254                 return log_error_errno(r, "Failed to attach event to device monitor: %m");
 255
 256         r = sd_device_monitor_start(m->device_monitor, manager_udev_process_link, m);
 257         if (r < 0)
 258                 return log_error_errno(r, "Failed to start device monitor: %m");
 259
 260         return 0;
 261 }
 262
 263 static int manager_rtnl_process_link(sd_netlink *rtnl, sd_netlink_message *message, Manager *m) {
 264         Link *link = NULL;
 265         NetDev *netdev = NULL;
 266         uint16_t type;
 267         const char *name;
 268         int r, ifindex;
 269
 270         assert(rtnl);
 271         assert(message);
 272         assert(m);
 273
 274         if (sd_netlink_message_is_error(message)) {
 275                 r = sd_netlink_message_get_errno(message);
 276                 if (r < 0)
 277                         log_message_warning_errno(message, r, "rtnl: Could not receive link message, ignoring");
 278
 279                 return 0;
 280         }
 281
 282         r = sd_netlink_message_get_type(message, &type);
 283         if (r < 0) {
 284                 log_warning_errno(r, "rtnl: Could not get message type, ignoring: %m");
 285                 return 0;
 286         } else if (!IN_SET(type, RTM_NEWLINK, RTM_DELLINK)) {
 287                 log_warning("rtnl: Received unexpected message type %u when processing link, ignoring.", type);
 288                 return 0;
 289         }
 290
 291         r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
 292         if (r < 0) {
 293                 log_warning_errno(r, "rtnl: Could not get ifindex from link message, ignoring: %m");
 294                 return 0;
 295         } else if (ifindex <= 0) {
 296                 log_warning("rtnl: received link message with invalid ifindex %d, ignoring.", ifindex);
 297                 return 0;
 298         }
 299
 300         r = sd_netlink_message_read_string(message, IFLA_IFNAME, &name);
 301         if (r < 0) {
 302                 log_warning_errno(r, "rtnl: Received link message without ifname, ignoring: %m");
 303                 return 0;
 304         }
 305
 306         (void) link_get(m, ifindex, &link);
 307         (void) netdev_get(m, name, &netdev);
 308
 309         switch (type) {
 310         case RTM_NEWLINK:
 311                 if (!link) {
 312                         /* link is new, so add it */
 313                         r = link_add(m, message, &link);
 314                         if (r < 0) {
 315                                 log_warning_errno(r, "Could not process new link message, ignoring: %m");
 316                                 return 0;
 317                         }
 318                 }
 319
 320                 if (netdev) {
 321                         /* netdev exists, so make sure the ifindex matches */
 322                         r = netdev_set_ifindex(netdev, message);
 323                         if (r < 0) {
 324                                 log_warning_errno(r, "Could not process new link message for netdev, ignoring: %m");
 325                                 return 0;
 326                         }
 327                 }
 328
 329                 r = link_update(link, message);
 330                 if (r < 0) {
 331                         log_warning_errno(r, "Could not process link message, ignoring: %m");
 332                         return 0;
 333                 }
 334
 335                 break;
 336
 337         case RTM_DELLINK:
 338                 link_drop(link);
 339                 netdev_drop(netdev);
 340
 341                 break;
 342
 343         default:
 344                 assert_not_reached("Received link message with invalid RTNL message type.");
 345         }
 346
 347         return 1;
 348 }
 349
 350 static int systemd_netlink_fd(void) {
 351         int n, fd, rtnl_fd = -EINVAL;
 352
 353         n = sd_listen_fds(true);
 354         if (n <= 0)
 355                 return -EINVAL;
 356
 357         for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++) {
 358                 if (sd_is_socket(fd, AF_NETLINK, SOCK_RAW, -1) > 0) {
 359                         if (rtnl_fd >= 0)
 360                                 return -EINVAL;
 361
 362                         rtnl_fd = fd;
 363                 }
 364         }
 365
 366         return rtnl_fd;
 367 }
 368
 369 static int manager_connect_genl(Manager *m) {
 370         int r;
 371
 372         assert(m);
 373
 374         r = sd_genl_socket_open(&m->genl);
 375         if (r < 0)
 376                 return r;
 377
 378         r = sd_netlink_inc_rcvbuf(m->genl, RCVBUF_SIZE);
 379         if (r < 0)
 380                 log_warning_errno(r, "Failed to increase receive buffer size for general netlink socket, ignoring: %m");
 381
 382         r = sd_netlink_attach_event(m->genl, m->event, 0);
 383         if (r < 0)
 384                 return r;
 385
 386         return 0;
 387 }
 388
 389 static int manager_connect_rtnl(Manager *m) {
 390         int fd, r;
 391
 392         assert(m);
 393
 394         fd = systemd_netlink_fd();
 395         if (fd < 0)
 396                 r = sd_netlink_open(&m->rtnl);
 397         else
 398                 r = sd_netlink_open_fd(&m->rtnl, fd);
 399         if (r < 0)
 400                 return r;
 401
 402         /* Bump receiver buffer, but only if we are not called via socket activation, as in that
 403          * case systemd sets the receive buffer size for us, and the value in the .socket unit
 404          * should take full effect. */
 405         if (fd < 0) {
 406                 r = sd_netlink_inc_rcvbuf(m->rtnl, RCVBUF_SIZE);
 407                 if (r < 0)
 408                         log_warning_errno(r, "Failed to increase receive buffer size for rtnl socket, ignoring: %m");
 409         }
 410
 411         r = sd_netlink_attach_event(m->rtnl, m->event, 0);
 412         if (r < 0)
 413                 return r;
 414
 415         r = netlink_add_match(m->rtnl, NULL, RTM_NEWLINK, &manager_rtnl_process_link, NULL, m, "network-rtnl_process_link");
 416         if (r < 0)
 417                 return r;
 418
 419         r = netlink_add_match(m->rtnl, NULL, RTM_DELLINK, &manager_rtnl_process_link, NULL, m, "network-rtnl_process_link");
 420         if (r < 0)
 421                 return r;
 422
 423         r = netlink_add_match(m->rtnl, NULL, RTM_NEWADDR, &manager_rtnl_process_address, NULL, m, "network-rtnl_process_address");
 424         if (r < 0)
 425                 return r;
 426
 427         r = netlink_add_match(m->rtnl, NULL, RTM_DELADDR, &manager_rtnl_process_address, NULL, m, "network-rtnl_process_address");
 428         if (r < 0)
 429                 return r;
 430
 431         r = netlink_add_match(m->rtnl, NULL, RTM_NEWNEIGH, &manager_rtnl_process_neighbor, NULL, m, "network-rtnl_process_neighbor");
 432         if (r < 0)
 433                 return r;
 434
 435         r = netlink_add_match(m->rtnl, NULL, RTM_DELNEIGH, &manager_rtnl_process_neighbor, NULL, m, "network-rtnl_process_neighbor");
 436         if (r < 0)
 437                 return r;
 438
 439         r = netlink_add_match(m->rtnl, NULL, RTM_NEWROUTE, &manager_rtnl_process_route, NULL, m, "network-rtnl_process_route");
 440         if (r < 0)
 441                 return r;
 442
 443         r = netlink_add_match(m->rtnl, NULL, RTM_DELROUTE, &manager_rtnl_process_route, NULL, m, "network-rtnl_process_route");
 444         if (r < 0)
 445                 return r;
 446
 447         r = netlink_add_match(m->rtnl, NULL, RTM_NEWRULE, &manager_rtnl_process_rule, NULL, m, "network-rtnl_process_rule");
 448         if (r < 0)
 449                 return r;
 450
 451         r = netlink_add_match(m->rtnl, NULL, RTM_DELRULE, &manager_rtnl_process_rule, NULL, m, "network-rtnl_process_rule");
 452         if (r < 0)
 453                 return r;
 454
 455         r = netlink_add_match(m->rtnl, NULL, RTM_NEWNEXTHOP, &manager_rtnl_process_nexthop, NULL, m, "network-rtnl_process_nexthop");
 456         if (r < 0)
 457                 return r;
 458
 459         r = netlink_add_match(m->rtnl, NULL, RTM_DELNEXTHOP, &manager_rtnl_process_nexthop, NULL, m, "network-rtnl_process_nexthop");
 460         if (r < 0)
 461                 return r;
 462
 463         return 0;
 464 }
 465
 466 static int ordered_set_put_dns_server(OrderedSet *s, int ifindex, struct in_addr_full *dns) {
 467         const char *p;
 468         int r;
 469
 470         assert(s);
 471         assert(dns);
 472
 473         if (dns->ifindex != 0 && dns->ifindex != ifindex)
 474                 return 0;
 475
 476         p = in_addr_full_to_string(dns);
 477         if (!p)
 478                 return 0;
 479
 480         r = ordered_set_put_strdup(s, p);
 481         if (r == -EEXIST)
 482                 return 0;
 483
 484         return r;
 485 }
 486
 487 static int ordered_set_put_dns_servers(OrderedSet *s, int ifindex, struct in_addr_full **dns, unsigned n) {
 488         int r, c = 0;
 489         unsigned i;
 490
 491         assert(s);
 492         assert(dns || n == 0);
 493
 494         for (i = 0; i < n; i++) {
 495                 r = ordered_set_put_dns_server(s, ifindex, dns[i]);
 496                 if (r < 0)
 497                         return r;
 498
 499                 c += r;
 500         }
 501
 502         return c;
 503 }
 504
 505 static int ordered_set_put_in4_addr(OrderedSet *s, const struct in_addr *address) {
 506         char *p;
 507         int r;
 508
 509         assert(s);
 510         assert(address);
 511
 512         r = in_addr_to_string(AF_INET, (const union in_addr_union*) address, &p);
 513         if (r < 0)
 514                 return r;
 515
 516         r = ordered_set_consume(s, p);
 517         if (r == -EEXIST)
 518                 return 0;
 519
 520         return r;
 521 }
 522
 523 static int ordered_set_put_in4_addrv(OrderedSet *s,
 524                                      const struct in_addr *addresses,
 525                                      size_t n,
 526                                      bool (*predicate)(const struct in_addr *addr)) {
 527         int r, c = 0;
 528         size_t i;
 529
 530         assert(s);
 531         assert(n == 0 || addresses);
 532
 533         for (i = 0; i < n; i++) {
 534                 if (predicate && !predicate(&addresses[i]))
 535                         continue;
 536                 r = ordered_set_put_in4_addr(s, addresses+i);
 537                 if (r < 0)
 538                         return r;
 539
 540                 c += r;
 541         }
 542
 543         return c;
 544 }
 545
 546 static int manager_save(Manager *m) {
 547         _cleanup_ordered_set_free_free_ OrderedSet *dns = NULL, *ntp = NULL, *sip = NULL, *search_domains = NULL, *route_domains = NULL;
 548         const char *operstate_str, *carrier_state_str, *address_state_str;
 549         LinkOperationalState operstate = LINK_OPERSTATE_OFF;
 550         LinkCarrierState carrier_state = LINK_CARRIER_STATE_OFF;
 551         LinkAddressState address_state = LINK_ADDRESS_STATE_OFF;
 552         _cleanup_free_ char *temp_path = NULL;
 553         _cleanup_strv_free_ char **p = NULL;
 554         _cleanup_fclose_ FILE *f = NULL;
 555         Link *link;
 556         int r;
 557
 558         assert(m);
 559         assert(m->state_file);
 560
 561         /* We add all NTP and DNS server to a set, to filter out duplicates */
 562         dns = ordered_set_new(&string_hash_ops);
 563         if (!dns)
 564                 return -ENOMEM;
 565
 566         ntp = ordered_set_new(&string_hash_ops);
 567         if (!ntp)
 568                 return -ENOMEM;
 569
 570         sip = ordered_set_new(&string_hash_ops);
 571         if (!sip)
 572                 return -ENOMEM;
 573
 574         search_domains = ordered_set_new(&dns_name_hash_ops);
 575         if (!search_domains)
 576                 return -ENOMEM;
 577
 578         route_domains = ordered_set_new(&dns_name_hash_ops);
 579         if (!route_domains)
 580                 return -ENOMEM;
 581
 582         HASHMAP_FOREACH(link, m->links) {
 583                 const struct in_addr *addresses;
 584
 585                 if (link->flags & IFF_LOOPBACK)
 586                         continue;
 587
 588                 if (link->operstate > operstate)
 589                         operstate = link->operstate;
 590
 591                 if (link->carrier_state > carrier_state)
 592                         carrier_state = link->carrier_state;
 593
 594                 if (link->address_state > address_state)
 595                         address_state = link->address_state;
 596
 597                 if (!link->network)
 598                         continue;
 599
 600                 /* First add the static configured entries */
 601                 if (link->n_dns != (unsigned) -1)
 602                         r = ordered_set_put_dns_servers(dns, link->ifindex, link->dns, link->n_dns);
 603                 else
 604                         r = ordered_set_put_dns_servers(dns, link->ifindex, link->network->dns, link->network->n_dns);
 605                 if (r < 0)
 606                         return r;
 607
 608                 r = ordered_set_put_strdupv(ntp, link->ntp ?: link->network->ntp);
 609                 if (r < 0)
 610                         return r;
 611
 612                 r = ordered_set_put_string_set(search_domains, link->search_domains ?: link->network->search_domains);
 613                 if (r < 0)
 614                         return r;
 615
 616                 r = ordered_set_put_string_set(route_domains, link->route_domains ?: link->network->route_domains);
 617                 if (r < 0)
 618                         return r;
 619
 620                 if (!link->dhcp_lease)
 621                         continue;
 622
 623                 /* Secondly, add the entries acquired via DHCP */
 624                 if (link->network->dhcp_use_dns) {
 625                         r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
 626                         if (r > 0) {
 627                                 r = ordered_set_put_in4_addrv(dns, addresses, r, in4_addr_is_non_local);
 628                                 if (r < 0)
 629                                         return r;
 630                         } else if (r < 0 && r != -ENODATA)
 631                                 return r;
 632                 }
 633
 634                 if (link->network->dhcp_use_ntp) {
 635                         r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
 636                         if (r > 0) {
 637                                 r = ordered_set_put_in4_addrv(ntp, addresses, r, in4_addr_is_non_local);
 638                                 if (r < 0)
 639                                         return r;
 640                         } else if (r < 0 && r != -ENODATA)
 641                                 return r;
 642                 }
 643
 644                 if (link->network->dhcp_use_sip) {
 645                         r = sd_dhcp_lease_get_sip(link->dhcp_lease, &addresses);
 646                         if (r > 0) {
 647                                 r = ordered_set_put_in4_addrv(sip, addresses, r, in4_addr_is_non_local);
 648                                 if (r < 0)
 649                                         return r;
 650                         } else if (r < 0 && r != -ENODATA)
 651                                 return r;
 652                 }
 653
 654                 if (link->network->dhcp_use_domains != DHCP_USE_DOMAINS_NO) {
 655                         const char *domainname;
 656                         char **domains = NULL;
 657
 658                         OrderedSet *target_domains = (link->network->dhcp_use_domains == DHCP_USE_DOMAINS_YES) ? search_domains : route_domains;
 659                         r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
 660                         if (r >= 0) {
 661                                 r = ordered_set_put_strdup(target_domains, domainname);
 662                                 if (r < 0)
 663                                         return r;
 664                         } else if (r != -ENODATA)
 665                                 return r;
 666
 667                         r = sd_dhcp_lease_get_search_domains(link->dhcp_lease, &domains);
 668                         if (r >= 0) {
 669                                 r = ordered_set_put_strdupv(target_domains, domains);
 670                                 if (r < 0)
 671                                         return r;
 672                         } else if (r != -ENODATA)
 673                                 return r;
 674                 }
 675         }
 676
 677         if (carrier_state >= LINK_CARRIER_STATE_ENSLAVED)
 678                 carrier_state = LINK_CARRIER_STATE_CARRIER;
 679
 680         operstate_str = link_operstate_to_string(operstate);
 681         assert(operstate_str);
 682
 683         carrier_state_str = link_carrier_state_to_string(carrier_state);
 684         assert(carrier_state_str);
 685
 686         address_state_str = link_address_state_to_string(address_state);
 687         assert(address_state_str);
 688
 689         r = fopen_temporary(m->state_file, &f, &temp_path);
 690         if (r < 0)
 691                 return r;
 692
 693         (void) fchmod(fileno(f), 0644);
 694
 695         fprintf(f,
 696                 "# This is private data. Do not parse.\n"
 697                 "OPER_STATE=%s\n"
 698                 "CARRIER_STATE=%s\n"
 699                 "ADDRESS_STATE=%s\n",
 700                 operstate_str, carrier_state_str, address_state_str);
 701
 702         ordered_set_print(f, "DNS=", dns);
 703         ordered_set_print(f, "NTP=", ntp);
 704         ordered_set_print(f, "SIP=", sip);
 705         ordered_set_print(f, "DOMAINS=", search_domains);
 706         ordered_set_print(f, "ROUTE_DOMAINS=", route_domains);
 707
 708         r = routing_policy_serialize_rules(m->rules, f);
 709         if (r < 0)
 710                 goto fail;
 711
 712         r = fflush_and_check(f);
 713         if (r < 0)
 714                 goto fail;
 715
 716         if (rename(temp_path, m->state_file) < 0) {
 717                 r = -errno;
 718                 goto fail;
 719         }
 720
 721         if (m->operational_state != operstate) {
 722                 m->operational_state = operstate;
 723                 if (strv_extend(&p, "OperationalState") < 0)
 724                         log_oom();
 725         }
 726
 727         if (m->carrier_state != carrier_state) {
 728                 m->carrier_state = carrier_state;
 729                 if (strv_extend(&p, "CarrierState") < 0)
 730                         log_oom();
 731         }
 732
 733         if (m->address_state != address_state) {
 734                 m->address_state = address_state;
 735                 if (strv_extend(&p, "AddressState") < 0)
 736                         log_oom();
 737         }
 738
 739         if (p) {
 740                 r = manager_send_changed_strv(m, p);
 741                 if (r < 0)
 742                         log_error_errno(r, "Could not emit changed properties: %m");
 743         }
 744
 745         m->dirty = false;
 746
 747         return 0;
 748
 749 fail:
 750         (void) unlink(m->state_file);
 751         (void) unlink(temp_path);
 752
 753         return log_error_errno(r, "Failed to save network state to %s: %m", m->state_file);
 754 }
 755
 756 static int manager_dirty_handler(sd_event_source *s, void *userdata) {
 757         Manager *m = userdata;
 758         Link *link;
 759
 760         assert(m);
 761
 762         if (m->dirty)
 763                 manager_save(m);
 764
 765         SET_FOREACH(link, m->dirty_links)
 766                 (void) link_save_and_clean(link);
 767
 768         return 1;
 769 }
 770
 771 static int signal_terminate_callback(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
 772         Manager *m = userdata;
 773
 774         assert(m);
 775         m->restarting = false;
 776
 777         log_debug("Terminate operation initiated.");
 778
 779         return sd_event_exit(sd_event_source_get_event(s), 0);
 780 }
 781
 782 static int signal_restart_callback(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
 783         Manager *m = userdata;
 784
 785         assert(m);
 786         m->restarting = true;
 787
 788         log_debug("Restart operation initiated.");
 789
 790         return sd_event_exit(sd_event_source_get_event(s), 0);
 791 }
 792
 793 int manager_new(Manager **ret) {
 794         _cleanup_(manager_freep) Manager *m = NULL;
 795         int r;
 796
 797         m = new(Manager, 1);
 798         if (!m)
 799                 return -ENOMEM;
 800
 801         *m = (Manager) {
 802                 .speed_meter_interval_usec = SPEED_METER_DEFAULT_TIME_INTERVAL,
 803                 .manage_foreign_routes = true,
 804                 .ethtool_fd = -1,
 805         };
 806
 807         m->state_file = strdup("/run/systemd/netif/state");
 808         if (!m->state_file)
 809                 return -ENOMEM;
 810
 811         r = sd_event_default(&m->event);
 812         if (r < 0)
 813                 return r;
 814
 815         assert_se(sigprocmask_many(SIG_SETMASK, NULL, SIGINT, SIGTERM, SIGUSR2, -1) >= 0);
 816
 817         (void) sd_event_set_watchdog(m->event, true);
 818         (void) sd_event_add_signal(m->event, NULL, SIGTERM, signal_terminate_callback, m);
 819         (void) sd_event_add_signal(m->event, NULL, SIGINT, signal_terminate_callback, m);
 820         (void) sd_event_add_signal(m->event, NULL, SIGUSR2, signal_restart_callback, m);
 821
 822         r = sd_event_add_post(m->event, NULL, manager_dirty_handler, m);
 823         if (r < 0)
 824                 return r;
 825
 826         r = manager_connect_rtnl(m);
 827         if (r < 0)
 828                 return r;
 829
 830         r = manager_connect_genl(m);
 831         if (r < 0)
 832                 return r;
 833
 834         r = manager_connect_udev(m);
 835         if (r < 0)
 836                 return r;
 837
 838         r = sd_resolve_default(&m->resolve);
 839         if (r < 0)
 840                 return r;
 841
 842         r = sd_resolve_attach_event(m->resolve, m->event, 0);
 843         if (r < 0)
 844                 return r;
 845
 846         r = address_pool_setup_default(m);
 847         if (r < 0)
 848                 return r;
 849
 850         m->duid.type = DUID_TYPE_EN;
 851
 852         (void) routing_policy_load_rules(m->state_file, &m->rules_saved);
 853
 854         *ret = TAKE_PTR(m);
 855
 856         return 0;
 857 }
 858
 859 void manager_free(Manager *m) {
 860         Link *link;
 861
 862         if (!m)
 863                 return;
 864
 865         free(m->state_file);
 866
 867         HASHMAP_FOREACH(link, m->links)
 868                 (void) link_stop_engines(link, true);
 869
 870         m->dhcp6_prefixes = hashmap_free_with_destructor(m->dhcp6_prefixes, dhcp6_pd_free);
 871         m->dhcp6_pd_prefixes = set_free_with_destructor(m->dhcp6_pd_prefixes, dhcp6_pd_free);
 872
 873         m->dirty_links = set_free_with_destructor(m->dirty_links, link_unref);
 874         m->links_requesting_uuid = set_free_with_destructor(m->links_requesting_uuid, link_unref);
 875         m->links = hashmap_free_with_destructor(m->links, link_unref);
 876
 877         m->duids_requesting_uuid = set_free(m->duids_requesting_uuid);
 878         m->networks = ordered_hashmap_free_with_destructor(m->networks, network_unref);
 879
 880         m->netdevs = hashmap_free_with_destructor(m->netdevs, netdev_unref);
 881
 882         ordered_set_free_free(m->address_pools);
 883
 884         /* routing_policy_rule_free() access m->rules and m->rules_foreign.
 885          * So, it is necessary to set NULL after the sets are freed. */
 886         m->rules = set_free(m->rules);
 887         m->rules_foreign = set_free(m->rules_foreign);
 888         set_free(m->rules_saved);
 889
 890         m->routes = set_free(m->routes);
 891         m->routes_foreign = set_free(m->routes_foreign);
 892
 893         sd_netlink_unref(m->rtnl);
 894         sd_netlink_unref(m->genl);
 895         sd_resolve_unref(m->resolve);
 896
 897         sd_event_source_unref(m->speed_meter_event_source);
 898         sd_event_unref(m->event);
 899
 900         sd_device_monitor_unref(m->device_monitor);
 901
 902         bus_verify_polkit_async_registry_free(m->polkit_registry);
 903         sd_bus_flush_close_unref(m->bus);
 904
 905         free(m->dynamic_timezone);
 906         free(m->dynamic_hostname);
 907
 908         safe_close(m->ethtool_fd);
 909
 910         free(m);
 911 }
 912
 913 int manager_start(Manager *m) {
 914         Link *link;
 915         int r;
 916
 917         assert(m);
 918
 919         r = manager_start_speed_meter(m);
 920         if (r < 0)
 921                 return log_error_errno(r, "Failed to initialize speed meter: %m");
 922
 923         /* The dirty handler will deal with future serialization, but the first one
 924            must be done explicitly. */
 925
 926         manager_save(m);
 927
 928         HASHMAP_FOREACH(link, m->links)
 929                 (void) link_save(link);
 930
 931         return 0;
 932 }
 933
 934 int manager_load_config(Manager *m) {
 935         int r;
 936
 937         /* update timestamp */
 938         paths_check_timestamp(NETWORK_DIRS, &m->network_dirs_ts_usec, true);
 939
 940         r = netdev_load(m, false);
 941         if (r < 0)
 942                 return r;
 943
 944         r = network_load(m, &m->networks);
 945         if (r < 0)
 946                 return r;
 947
 948         return 0;
 949 }
 950
 951 bool manager_should_reload(Manager *m) {
 952         return paths_check_timestamp(NETWORK_DIRS, &m->network_dirs_ts_usec, false);
 953 }
 954
 955 static int manager_enumerate_internal(
 956                 Manager *m,
 957                 sd_netlink_message *req,
 958                 int (*process)(sd_netlink *, sd_netlink_message *, Manager *),
 959                 const char *name) {
 960
 961         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *reply = NULL;
 962         int r;
 963
 964         assert(m);
 965         assert(m->rtnl);
 966         assert(req);
 967         assert(process);
 968
 969         r = sd_netlink_message_request_dump(req, true);
 970         if (r < 0)
 971                 return r;
 972
 973         r = sd_netlink_call(m->rtnl, req, 0, &reply);
 974         if (r < 0) {
 975                 if (name && (r == -EOPNOTSUPP || (r == -EINVAL && mac_selinux_enforcing()))) {
 976                         log_debug_errno(r, "%s are not supported by the kernel. Ignoring.", name);
 977                         return 0;
 978                 }
 979
 980                 return r;
 981         }
 982
 983         for (sd_netlink_message *reply_one = reply; reply_one; reply_one = sd_netlink_message_next(reply_one)) {
 984                 int k;
 985
 986                 m->enumerating = true;
 987
 988                 k = process(m->rtnl, reply_one, m);
 989                 if (k < 0 && r >= 0)
 990                         r = k;
 991
 992                 m->enumerating = false;
 993         }
 994
 995         return r;
 996 }
 997
 998 static int manager_enumerate_links(Manager *m) {
 999         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1000         int r;
1001
1002         assert(m);
1003         assert(m->rtnl);
1004
1005         r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
1006         if (r < 0)
1007                 return r;
1008
1009         return manager_enumerate_internal(m, req, manager_rtnl_process_link, NULL);
1010 }
1011
1012 static int manager_enumerate_addresses(Manager *m) {
1013         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1014         int r;
1015
1016         assert(m);
1017         assert(m->rtnl);
1018
1019         r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, 0, 0);
1020         if (r < 0)
1021                 return r;
1022
1023         return manager_enumerate_internal(m, req, manager_rtnl_process_address, NULL);
1024 }
1025
1026 static int manager_enumerate_neighbors(Manager *m) {
1027         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1028         int r;
1029
1030         assert(m);
1031         assert(m->rtnl);
1032
1033         r = sd_rtnl_message_new_neigh(m->rtnl, &req, RTM_GETNEIGH, 0, AF_UNSPEC);
1034         if (r < 0)
1035                 return r;
1036
1037         return manager_enumerate_internal(m, req, manager_rtnl_process_neighbor, NULL);
1038 }
1039
1040 static int manager_enumerate_routes(Manager *m) {
1041         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1042         int r;
1043
1044         assert(m);
1045         assert(m->rtnl);
1046
1047         if (!m->manage_foreign_routes)
1048                 return 0;
1049
1050         r = sd_rtnl_message_new_route(m->rtnl, &req, RTM_GETROUTE, 0, 0);
1051         if (r < 0)
1052                 return r;
1053
1054         return manager_enumerate_internal(m, req, manager_rtnl_process_route, NULL);
1055 }
1056
1057 static int manager_enumerate_rules(Manager *m) {
1058         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1059         int r;
1060
1061         assert(m);
1062         assert(m->rtnl);
1063
1064         r = sd_rtnl_message_new_routing_policy_rule(m->rtnl, &req, RTM_GETRULE, 0);
1065         if (r < 0)
1066                 return r;
1067
1068         return manager_enumerate_internal(m, req, manager_rtnl_process_rule, "Routing policy rules");
1069 }
1070
1071 static int manager_enumerate_nexthop(Manager *m) {
1072         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1073         int r;
1074
1075         assert(m);
1076         assert(m->rtnl);
1077
1078         r = sd_rtnl_message_new_nexthop(m->rtnl, &req, RTM_GETNEXTHOP, 0, 0);
1079         if (r < 0)
1080                 return r;
1081
1082         return manager_enumerate_internal(m, req, manager_rtnl_process_nexthop, "Nexthop rules");
1083 }
1084
1085 int manager_enumerate(Manager *m) {
1086         int r;
1087
1088         r = manager_enumerate_links(m);
1089         if (r < 0)
1090                 return log_error_errno(r, "Could not enumerate links: %m");
1091
1092         r = manager_enumerate_addresses(m);
1093         if (r < 0)
1094                 return log_error_errno(r, "Could not enumerate addresses: %m");
1095
1096         r = manager_enumerate_neighbors(m);
1097         if (r < 0)
1098                 return log_error_errno(r, "Could not enumerate neighbors: %m");
1099
1100         r = manager_enumerate_routes(m);
1101         if (r < 0)
1102                 return log_error_errno(r, "Could not enumerate routes: %m");
1103
1104         r = manager_enumerate_rules(m);
1105         if (r < 0)
1106                 return log_error_errno(r, "Could not enumerate routing policy rules: %m");
1107
1108         r = manager_enumerate_nexthop(m);
1109         if (r < 0)
1110                 return log_error_errno(r, "Could not enumerate nexthop rules: %m");
1111
1112         return 0;
1113 }
1114
1115 Link* manager_find_uplink(Manager *m, Link *exclude) {
1116         _cleanup_free_ struct local_address *gateways = NULL;
1117         int n, i;
1118
1119         assert(m);
1120
1121         /* Looks for a suitable "uplink", via black magic: an
1122          * interface that is up and where the default route with the
1123          * highest priority points to. */
1124
1125         n = local_gateways(m->rtnl, 0, AF_UNSPEC, &gateways);
1126         if (n < 0) {
1127                 log_warning_errno(n, "Failed to determine list of default gateways: %m");
1128                 return NULL;
1129         }
1130
1131         for (i = 0; i < n; i++) {
1132                 Link *link;
1133
1134                 link = hashmap_get(m->links, INT_TO_PTR(gateways[i].ifindex));
1135                 if (!link) {
1136                         log_debug("Weird, found a gateway for a link we don't know. Ignoring.");
1137                         continue;
1138                 }
1139
1140                 if (link == exclude)
1141                         continue;
1142
1143                 if (link->operstate < LINK_OPERSTATE_ROUTABLE)
1144                         continue;
1145
1146                 return link;
1147         }
1148
1149         return NULL;
1150 }
1151
1152 void manager_dirty(Manager *manager) {
1153         assert(manager);
1154
1155         /* the serialized state in /run is no longer up-to-date */
1156         manager->dirty = true;
1157 }
1158
1159 static int set_hostname_handler(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
1160         _unused_ Manager *manager = userdata;
1161         const sd_bus_error *e;
1162
1163         assert(m);
1164         assert(manager);
1165
1166         e = sd_bus_message_get_error(m);
1167         if (e)
1168                 log_warning_errno(sd_bus_error_get_errno(e), "Could not set hostname: %s", e->message);
1169
1170         return 1;
1171 }
1172
1173 int manager_set_hostname(Manager *m, const char *hostname) {
1174         int r;
1175
1176         log_debug("Setting transient hostname: '%s'", strna(hostname));
1177
1178         if (free_and_strdup(&m->dynamic_hostname, hostname) < 0)
1179                 return log_oom();
1180
1181         if (!m->bus || sd_bus_is_ready(m->bus) <= 0) {
1182                 log_debug("Not connected to system bus, setting hostname later.");
1183                 return 0;
1184         }
1185
1186         r = sd_bus_call_method_async(
1187                         m->bus,
1188                         NULL,
1189                         "org.freedesktop.hostname1",
1190                         "/org/freedesktop/hostname1",
1191                         "org.freedesktop.hostname1",
1192                         "SetHostname",
1193                         set_hostname_handler,
1194                         m,
1195                         "sb",
1196                         hostname,
1197                         false);
1198
1199         if (r < 0)
1200                 return log_error_errno(r, "Could not set transient hostname: %m");
1201
1202         return 0;
1203 }
1204
1205 static int set_timezone_handler(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
1206         _unused_ Manager *manager = userdata;
1207         const sd_bus_error *e;
1208
1209         assert(m);
1210         assert(manager);
1211
1212         e = sd_bus_message_get_error(m);
1213         if (e)
1214                 log_warning_errno(sd_bus_error_get_errno(e), "Could not set timezone: %s", e->message);
1215
1216         return 1;
1217 }
1218
1219 int manager_set_timezone(Manager *m, const char *tz) {
1220         int r;
1221
1222         assert(m);
1223         assert(tz);
1224
1225         log_debug("Setting system timezone: '%s'", tz);
1226         if (free_and_strdup(&m->dynamic_timezone, tz) < 0)
1227                 return log_oom();
1228
1229         if (!m->bus || sd_bus_is_ready(m->bus) <= 0) {
1230                 log_debug("Not connected to system bus, setting timezone later.");
1231                 return 0;
1232         }
1233
1234         r = sd_bus_call_method_async(
1235                         m->bus,
1236                         NULL,
1237                         "org.freedesktop.timedate1",
1238                         "/org/freedesktop/timedate1",
1239                         "org.freedesktop.timedate1",
1240                         "SetTimezone",
1241                         set_timezone_handler,
1242                         m,
1243                         "sb",
1244                         tz,
1245                         false);
1246         if (r < 0)
1247                 return log_error_errno(r, "Could not set timezone: %m");
1248
1249         return 0;
1250 }