src/network/networkd-dhcp4.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2013-2014 Tom Gundersen <teg@jklm.no>
   6 ***/
   7
   8 #include <netinet/ether.h>
   9 #include <linux/if.h>
  10
  11 #include "alloc-util.h"
  12 #include "dhcp-lease-internal.h"
  13 #include "hostname-util.h"
  14 #include "parse-util.h"
  15 #include "netdev/vrf.h"
  16 #include "network-internal.h"
  17 #include "networkd-link.h"
  18 #include "networkd-manager.h"
  19 #include "networkd-network.h"
  20 #include "string-util.h"
  21 #include "sysctl-util.h"
  22
  23 static int dhcp4_route_handler(sd_netlink *rtnl, sd_netlink_message *m,
  24                                void *userdata) {
  25         _cleanup_(link_unrefp) Link *link = userdata;
  26         int r;
  27
  28         assert(link);
  29         assert(link->dhcp4_messages > 0);
  30
  31         link->dhcp4_messages--;
  32
  33         r = sd_netlink_message_get_errno(m);
  34         if (r < 0 && r != -EEXIST) {
  35                 log_link_error_errno(link, r, "Could not set DHCPv4 route: %m");
  36                 link_enter_failed(link);
  37         }
  38
  39         if (link->dhcp4_messages == 0) {
  40                 link->dhcp4_configured = true;
  41                 link_check_ready(link);
  42         }
  43
  44         return 1;
  45 }
  46
  47 static int route_scope_from_address(const Route *route, const struct in_addr *self_addr) {
  48         assert(route);
  49         assert(self_addr);
  50
  51         if (in_addr_is_localhost(AF_INET, &route->dst) ||
  52             (self_addr->s_addr && route->dst.in.s_addr == self_addr->s_addr))
  53                 return RT_SCOPE_HOST;
  54         else if (in4_addr_is_null(&route->gw.in))
  55                 return RT_SCOPE_LINK;
  56         else
  57                 return RT_SCOPE_UNIVERSE;
  58 }
  59
  60 static int link_set_dhcp_routes(Link *link) {
  61         _cleanup_free_ sd_dhcp_route **static_routes = NULL;
  62         bool classless_route = false, static_route = false;
  63         struct in_addr gateway, address;
  64         int r, n, i;
  65         uint32_t table;
  66
  67         assert(link);
  68
  69         if (!link->dhcp_lease) /* link went down while we configured the IP addresses? */
  70                 return 0;
  71
  72         if (!link->network) /* link went down while we configured the IP addresses? */
  73                 return 0;
  74
  75         if (!link->network->dhcp_use_routes)
  76                 return 0;
  77
  78         /* When the interface is part of an VRF use the VRFs routing table, unless
  79          * there is a another table specified. */
  80         table = link->network->dhcp_route_table;
  81         if (!link->network->dhcp_route_table_set && link->network->vrf != NULL)
  82                 table = VRF(link->network->vrf)->table;
  83
  84         r = sd_dhcp_lease_get_address(link->dhcp_lease, &address);
  85         if (r < 0)
  86                 return log_link_warning_errno(link, r, "DHCP error: could not get address: %m");
  87
  88         n = sd_dhcp_lease_get_routes(link->dhcp_lease, &static_routes);
  89         if (n < 0)
  90                 log_link_debug_errno(link, n, "DHCP error: could not get routes: %m");
  91
  92         for (i = 0; i < n; i++) {
  93                 if (static_routes[i]->option == SD_DHCP_OPTION_CLASSLESS_STATIC_ROUTE)
  94                         classless_route = true;
  95
  96                 if (static_routes[i]->option == SD_DHCP_OPTION_STATIC_ROUTE)
  97                         static_route = true;
  98         }
  99
 100         for (i = 0; i < n; i++) {
 101                 _cleanup_(route_freep) Route *route = NULL;
 102
 103                 /* if the DHCP server returns both a Classless Static Routes option and a Static Routes option,
 104                    the DHCP client MUST ignore the Static Routes option. */
 105                 if (classless_route && static_routes[i]->option == SD_DHCP_OPTION_STATIC_ROUTE)
 106                         continue;
 107
 108                 r = route_new(&route);
 109                 if (r < 0)
 110                         return log_link_error_errno(link, r, "Could not allocate route: %m");
 111
 112                 route->family = AF_INET;
 113                 route->protocol = RTPROT_DHCP;
 114                 assert_se(sd_dhcp_route_get_gateway(static_routes[i], &route->gw.in) >= 0);
 115                 assert_se(sd_dhcp_route_get_destination(static_routes[i], &route->dst.in) >= 0);
 116                 assert_se(sd_dhcp_route_get_destination_prefix_length(static_routes[i], &route->dst_prefixlen) >= 0);
 117                 route->priority = link->network->dhcp_route_metric;
 118                 route->table = table;
 119                 route->scope = route_scope_from_address(route, &address);
 120
 121                 r = route_configure(route, link, dhcp4_route_handler);
 122                 if (r < 0)
 123                         return log_link_warning_errno(link, r, "Could not set host route: %m");
 124
 125                 link->dhcp4_messages++;
 126         }
 127
 128         r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
 129         if (r == -ENODATA)
 130                 log_link_info_errno(link, r, "DHCP: No routes received from DHCP server: %m");
 131         else if (r < 0)
 132                 log_link_warning_errno(link, r, "DHCP error: could not get gateway: %m");
 133
 134         /* According to RFC 3442: If the DHCP server returns both a Classless Static Routes option and
 135            a Router option, the DHCP client MUST ignore the Router option. */
 136         if (classless_route && static_route)
 137                 log_link_warning(link, "Classless static routes received from DHCP server: ignoring static-route option and router option");
 138
 139         if (r >= 0 && !classless_route) {
 140                 _cleanup_(route_freep) Route *route = NULL;
 141                 _cleanup_(route_freep) Route *route_gw = NULL;
 142
 143                 r = route_new(&route);
 144                 if (r < 0)
 145                         return log_link_error_errno(link, r, "Could not allocate route: %m");
 146
 147                 route->protocol = RTPROT_DHCP;
 148
 149                 r = route_new(&route_gw);
 150                 if (r < 0)
 151                         return log_link_error_errno(link, r,  "Could not allocate route: %m");
 152
 153                 /* The dhcp netmask may mask out the gateway. Add an explicit
 154                  * route for the gw host so that we can route no matter the
 155                  * netmask or existing kernel route tables. */
 156                 route_gw->family = AF_INET;
 157                 route_gw->dst.in = gateway;
 158                 route_gw->dst_prefixlen = 32;
 159                 route_gw->prefsrc.in = address;
 160                 route_gw->scope = RT_SCOPE_LINK;
 161                 route_gw->protocol = RTPROT_DHCP;
 162                 route_gw->priority = link->network->dhcp_route_metric;
 163                 route_gw->table = table;
 164
 165                 r = route_configure(route_gw, link, dhcp4_route_handler);
 166                 if (r < 0)
 167                         return log_link_warning_errno(link, r, "Could not set host route: %m");
 168
 169                 link->dhcp4_messages++;
 170
 171                 route->family = AF_INET;
 172                 route->gw.in = gateway;
 173                 route->prefsrc.in = address;
 174                 route->priority = link->network->dhcp_route_metric;
 175                 route->table = table;
 176
 177                 r = route_configure(route, link, dhcp4_route_handler);
 178                 if (r < 0) {
 179                         log_link_warning_errno(link, r, "Could not set routes: %m");
 180                         link_enter_failed(link);
 181                         return r;
 182                 }
 183
 184                 link->dhcp4_messages++;
 185         }
 186
 187         return 0;
 188 }
 189
 190 static int dhcp_lease_lost(Link *link) {
 191         _cleanup_(address_freep) Address *address = NULL;
 192         struct in_addr addr;
 193         struct in_addr netmask;
 194         struct in_addr gateway;
 195         unsigned prefixlen = 0;
 196         int r;
 197
 198         assert(link);
 199         assert(link->dhcp_lease);
 200
 201         log_link_warning(link, "DHCP lease lost");
 202
 203         if (link->network->dhcp_use_routes) {
 204                 _cleanup_free_ sd_dhcp_route **routes = NULL;
 205                 int n, i;
 206
 207                 n = sd_dhcp_lease_get_routes(link->dhcp_lease, &routes);
 208                 if (n >= 0) {
 209                         for (i = 0; i < n; i++) {
 210                                 _cleanup_(route_freep) Route *route = NULL;
 211
 212                                 r = route_new(&route);
 213                                 if (r >= 0) {
 214                                         route->family = AF_INET;
 215                                         assert_se(sd_dhcp_route_get_gateway(routes[i], &route->gw.in) >= 0);
 216                                         assert_se(sd_dhcp_route_get_destination(routes[i], &route->dst.in) >= 0);
 217                                         assert_se(sd_dhcp_route_get_destination_prefix_length(routes[i], &route->dst_prefixlen) >= 0);
 218
 219                                         route_remove(route, link,
 220                                                      link_route_remove_handler);
 221                                 }
 222                         }
 223                 }
 224         }
 225
 226         r = address_new(&address);
 227         if (r >= 0) {
 228                 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
 229                 if (r >= 0) {
 230                         _cleanup_(route_freep) Route *route_gw = NULL;
 231                         _cleanup_(route_freep) Route *route = NULL;
 232
 233                         r = route_new(&route_gw);
 234                         if (r >= 0) {
 235                                 route_gw->family = AF_INET;
 236                                 route_gw->dst.in = gateway;
 237                                 route_gw->dst_prefixlen = 32;
 238                                 route_gw->scope = RT_SCOPE_LINK;
 239
 240                                 route_remove(route_gw, link,
 241                                              link_route_remove_handler);
 242                         }
 243
 244                         r = route_new(&route);
 245                         if (r >= 0) {
 246                                 route->family = AF_INET;
 247                                 route->gw.in = gateway;
 248
 249                                 route_remove(route, link,
 250                                              link_route_remove_handler);
 251                         }
 252                 }
 253
 254                 r = sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
 255                 if (r >= 0) {
 256                         r = sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
 257                         if (r >= 0)
 258                                 prefixlen = in4_addr_netmask_to_prefixlen(&netmask);
 259
 260                         address->family = AF_INET;
 261                         address->in_addr.in = addr;
 262                         address->prefixlen = prefixlen;
 263
 264                         address_remove(address, link, link_address_remove_handler);
 265                 }
 266         }
 267
 268         if (link->network->dhcp_use_mtu) {
 269                 uint16_t mtu;
 270
 271                 r = sd_dhcp_lease_get_mtu(link->dhcp_lease, &mtu);
 272                 if (r >= 0 && link->original_mtu != mtu) {
 273                         r = link_set_mtu(link, link->original_mtu);
 274                         if (r < 0) {
 275                                 log_link_warning(link,
 276                                                  "DHCP error: could not reset MTU");
 277                                 link_enter_failed(link);
 278                                 return r;
 279                         }
 280                 }
 281         }
 282
 283         if (link->network->dhcp_use_hostname) {
 284                 const char *hostname = NULL;
 285
 286                 if (link->network->dhcp_hostname)
 287                         hostname = link->network->dhcp_hostname;
 288                 else
 289                         (void) sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
 290
 291                 if (hostname) {
 292                         /* If a hostname was set due to the lease, then unset it now. */
 293                         r = manager_set_hostname(link->manager, NULL);
 294                         if (r < 0)
 295                                 log_link_warning_errno(link, r, "Failed to reset transient hostname: %m");
 296                 }
 297         }
 298
 299         link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
 300         link_dirty(link);
 301         link->dhcp4_configured = false;
 302
 303         return 0;
 304 }
 305
 306 static int dhcp4_address_handler(sd_netlink *rtnl, sd_netlink_message *m,
 307                                  void *userdata) {
 308         _cleanup_(link_unrefp) Link *link = userdata;
 309         int r;
 310
 311         assert(link);
 312
 313         r = sd_netlink_message_get_errno(m);
 314         if (r < 0 && r != -EEXIST) {
 315                 log_link_error_errno(link, r, "Could not set DHCPv4 address: %m");
 316                 link_enter_failed(link);
 317         } else if (r >= 0)
 318                 manager_rtnl_process_address(rtnl, m, link->manager);
 319
 320         link_set_dhcp_routes(link);
 321
 322         if (link->dhcp4_messages == 0) {
 323                 link->dhcp4_configured = true;
 324                 link_check_ready(link);
 325         }
 326
 327         return 1;
 328 }
 329
 330 static int dhcp4_update_address(Link *link,
 331                                 struct in_addr *address,
 332                                 struct in_addr *netmask,
 333                                 uint32_t lifetime) {
 334         _cleanup_(address_freep) Address *addr = NULL;
 335         unsigned prefixlen;
 336         int r;
 337
 338         assert(address);
 339         assert(netmask);
 340         assert(lifetime);
 341
 342         prefixlen = in4_addr_netmask_to_prefixlen(netmask);
 343
 344         r = address_new(&addr);
 345         if (r < 0)
 346                 return r;
 347
 348         addr->family = AF_INET;
 349         addr->in_addr.in.s_addr = address->s_addr;
 350         addr->cinfo.ifa_prefered = lifetime;
 351         addr->cinfo.ifa_valid = lifetime;
 352         addr->prefixlen = prefixlen;
 353         addr->broadcast.s_addr = address->s_addr | ~netmask->s_addr;
 354
 355         /* allow reusing an existing address and simply update its lifetime
 356          * in case it already exists */
 357         r = address_configure(addr, link, dhcp4_address_handler, true);
 358         if (r < 0)
 359                 return r;
 360
 361         return 0;
 362 }
 363
 364 static int dhcp_lease_renew(sd_dhcp_client *client, Link *link) {
 365         sd_dhcp_lease *lease;
 366         struct in_addr address;
 367         struct in_addr netmask;
 368         uint32_t lifetime = CACHE_INFO_INFINITY_LIFE_TIME;
 369         int r;
 370
 371         assert(link);
 372         assert(client);
 373         assert(link->network);
 374
 375         r = sd_dhcp_client_get_lease(client, &lease);
 376         if (r < 0)
 377                 return log_link_warning_errno(link, r, "DHCP error: no lease: %m");
 378
 379         sd_dhcp_lease_unref(link->dhcp_lease);
 380         link->dhcp4_configured = false;
 381         link->dhcp_lease = sd_dhcp_lease_ref(lease);
 382         link_dirty(link);
 383
 384         r = sd_dhcp_lease_get_address(lease, &address);
 385         if (r < 0)
 386                 return log_link_warning_errno(link, r, "DHCP error: no address: %m");
 387
 388         r = sd_dhcp_lease_get_netmask(lease, &netmask);
 389         if (r < 0)
 390                 return log_link_warning_errno(link, r, "DHCP error: no netmask: %m");
 391
 392         if (!link->network->dhcp_critical) {
 393                 r = sd_dhcp_lease_get_lifetime(link->dhcp_lease, &lifetime);
 394                 if (r < 0)
 395                         return log_link_warning_errno(link, r, "DHCP error: no lifetime: %m");
 396         }
 397
 398         r = dhcp4_update_address(link, &address, &netmask, lifetime);
 399         if (r < 0) {
 400                 log_link_warning_errno(link, r, "Could not update IP address: %m");
 401                 link_enter_failed(link);
 402                 return r;
 403         }
 404
 405         return 0;
 406 }
 407
 408 static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
 409         sd_dhcp_lease *lease;
 410         struct in_addr address;
 411         struct in_addr netmask;
 412         struct in_addr gateway;
 413         unsigned prefixlen;
 414         uint32_t lifetime = CACHE_INFO_INFINITY_LIFE_TIME;
 415         int r;
 416
 417         assert(client);
 418         assert(link);
 419
 420         r = sd_dhcp_client_get_lease(client, &lease);
 421         if (r < 0)
 422                 return log_link_error_errno(link, r, "DHCP error: No lease: %m");
 423
 424         r = sd_dhcp_lease_get_address(lease, &address);
 425         if (r < 0)
 426                 return log_link_error_errno(link, r, "DHCP error: No address: %m");
 427
 428         r = sd_dhcp_lease_get_netmask(lease, &netmask);
 429         if (r < 0)
 430                 return log_link_error_errno(link, r, "DHCP error: No netmask: %m");
 431
 432         prefixlen = in4_addr_netmask_to_prefixlen(&netmask);
 433
 434         r = sd_dhcp_lease_get_router(lease, &gateway);
 435         if (r < 0 && r != -ENODATA)
 436                 return log_link_error_errno(link, r, "DHCP error: Could not get gateway: %m");
 437
 438         if (r >= 0)
 439                 log_struct(LOG_INFO,
 440                            LOG_LINK_INTERFACE(link),
 441                            LOG_LINK_MESSAGE(link, "DHCPv4 address %u.%u.%u.%u/%u via %u.%u.%u.%u",
 442                                             ADDRESS_FMT_VAL(address),
 443                                             prefixlen,
 444                                             ADDRESS_FMT_VAL(gateway)),
 445                            "ADDRESS=%u.%u.%u.%u", ADDRESS_FMT_VAL(address),
 446                            "PREFIXLEN=%u", prefixlen,
 447                            "GATEWAY=%u.%u.%u.%u", ADDRESS_FMT_VAL(gateway),
 448                            NULL);
 449         else
 450                 log_struct(LOG_INFO,
 451                            LOG_LINK_INTERFACE(link),
 452                            LOG_LINK_MESSAGE(link, "DHCPv4 address %u.%u.%u.%u/%u",
 453                                             ADDRESS_FMT_VAL(address),
 454                                             prefixlen),
 455                            "ADDRESS=%u.%u.%u.%u", ADDRESS_FMT_VAL(address),
 456                            "PREFIXLEN=%u", prefixlen,
 457                            NULL);
 458
 459         link->dhcp_lease = sd_dhcp_lease_ref(lease);
 460         link_dirty(link);
 461
 462         if (link->network->dhcp_use_mtu) {
 463                 uint16_t mtu;
 464
 465                 r = sd_dhcp_lease_get_mtu(lease, &mtu);
 466                 if (r >= 0) {
 467                         r = link_set_mtu(link, mtu);
 468                         if (r < 0)
 469                                 log_link_error_errno(link, r, "Failed to set MTU to %" PRIu16 ": %m", mtu);
 470                 }
 471         }
 472
 473         if (link->network->dhcp_use_hostname) {
 474                 const char *dhcpname = NULL;
 475                 _cleanup_free_ char *hostname = NULL;
 476
 477                 if (link->network->dhcp_hostname)
 478                         dhcpname = link->network->dhcp_hostname;
 479                 else
 480                         (void) sd_dhcp_lease_get_hostname(lease, &dhcpname);
 481
 482                 if (dhcpname) {
 483                         r = shorten_overlong(dhcpname, &hostname);
 484                         if (r < 0)
 485                                 log_link_warning_errno(link, r, "Unable to shorten overlong DHCP hostname '%s', ignoring: %m", dhcpname);
 486                         if (r == 1)
 487                                 log_link_notice(link, "Overlong DCHP hostname received, shortened from '%s' to '%s'", dhcpname, hostname);
 488                 }
 489
 490                 if (hostname) {
 491                         r = manager_set_hostname(link->manager, hostname);
 492                         if (r < 0)
 493                                 log_link_error_errno(link, r, "Failed to set transient hostname to '%s': %m", hostname);
 494                 }
 495         }
 496
 497         if (link->network->dhcp_use_timezone) {
 498                 const char *tz = NULL;
 499
 500                 (void) sd_dhcp_lease_get_timezone(link->dhcp_lease, &tz);
 501
 502                 if (tz) {
 503                         r = manager_set_timezone(link->manager, tz);
 504                         if (r < 0)
 505                                 log_link_error_errno(link, r, "Failed to set timezone to '%s': %m", tz);
 506                 }
 507         }
 508
 509         if (!link->network->dhcp_critical) {
 510                 r = sd_dhcp_lease_get_lifetime(link->dhcp_lease, &lifetime);
 511                 if (r < 0) {
 512                         log_link_warning_errno(link, r, "DHCP error: no lifetime: %m");
 513                         return r;
 514                 }
 515         }
 516
 517         r = dhcp4_update_address(link, &address, &netmask, lifetime);
 518         if (r < 0) {
 519                 log_link_warning_errno(link, r, "Could not update IP address: %m");
 520                 link_enter_failed(link);
 521                 return r;
 522         }
 523
 524         return 0;
 525 }
 526 static void dhcp4_handler(sd_dhcp_client *client, int event, void *userdata) {
 527         Link *link = userdata;
 528         int r = 0;
 529
 530         assert(link);
 531         assert(link->network);
 532         assert(link->manager);
 533
 534         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 535                 return;
 536
 537         switch (event) {
 538                 case SD_DHCP_CLIENT_EVENT_EXPIRED:
 539                 case SD_DHCP_CLIENT_EVENT_STOP:
 540                 case SD_DHCP_CLIENT_EVENT_IP_CHANGE:
 541                         if (link->network->dhcp_critical) {
 542                                 log_link_error(link, "DHCPv4 connection considered system critical, ignoring request to reconfigure it.");
 543                                 return;
 544                         }
 545
 546                         if (link->dhcp_lease) {
 547                                 r = dhcp_lease_lost(link);
 548                                 if (r < 0) {
 549                                         link_enter_failed(link);
 550                                         return;
 551                                 }
 552                         }
 553
 554                         if (event == SD_DHCP_CLIENT_EVENT_IP_CHANGE) {
 555                                 r = dhcp_lease_acquired(client, link);
 556                                 if (r < 0) {
 557                                         link_enter_failed(link);
 558                                         return;
 559                                 }
 560                         }
 561
 562                         break;
 563                 case SD_DHCP_CLIENT_EVENT_RENEW:
 564                         r = dhcp_lease_renew(client, link);
 565                         if (r < 0) {
 566                                 link_enter_failed(link);
 567                                 return;
 568                         }
 569                         break;
 570                 case SD_DHCP_CLIENT_EVENT_IP_ACQUIRE:
 571                         r = dhcp_lease_acquired(client, link);
 572                         if (r < 0) {
 573                                 link_enter_failed(link);
 574                                 return;
 575                         }
 576                         break;
 577                 default:
 578                         if (event < 0)
 579                                 log_link_warning_errno(link, event, "DHCP error: Client failed: %m");
 580                         else
 581                                 log_link_warning(link, "DHCP unknown event: %i", event);
 582                         break;
 583         }
 584
 585         return;
 586 }
 587
 588 static int dhcp4_set_hostname(Link *link) {
 589         _cleanup_free_ char *hostname = NULL;
 590         const char *hn;
 591         int r;
 592
 593         assert(link);
 594
 595         if (!link->network->dhcp_send_hostname)
 596                 hn = NULL;
 597         else if (link->network->dhcp_hostname)
 598                 hn = link->network->dhcp_hostname;
 599         else {
 600                 r = gethostname_strict(&hostname);
 601                 if (r < 0 && r != -ENXIO) /* ENXIO: no hostname set or hostname is "localhost" */
 602                         return r;
 603
 604                 hn = hostname;
 605         }
 606
 607         return sd_dhcp_client_set_hostname(link->dhcp_client, hn);
 608 }
 609
 610 static bool promote_secondaries_enabled(const char *ifname) {
 611         _cleanup_free_ char *promote_secondaries_sysctl = NULL;
 612         char *promote_secondaries_path;
 613         int r;
 614
 615         promote_secondaries_path = strjoina("net/ipv4/conf/", ifname, "/promote_secondaries");
 616         r = sysctl_read(promote_secondaries_path, &promote_secondaries_sysctl);
 617         if (r < 0) {
 618                 log_debug_errno(r, "Cannot read sysctl %s", promote_secondaries_path);
 619                 return false;
 620         }
 621
 622         truncate_nl(promote_secondaries_sysctl);
 623         r = parse_boolean(promote_secondaries_sysctl);
 624         if (r < 0)
 625                 log_warning_errno(r, "Cannot parse sysctl %s with content %s as boolean", promote_secondaries_path, promote_secondaries_sysctl);
 626         return r > 0;
 627 }
 628
 629 /* dhcp4_set_promote_secondaries will ensure this interface has
 630  * the "promote_secondaries" option in the kernel set. If this sysctl
 631  * is not set DHCP will work only as long as the IP address does not
 632  * changes between leases. The kernel will remove all secondary IP
 633  * addresses of an interface otherwise. The way systemd-network works
 634  * is that the new IP of a lease is added as a secondary IP and when
 635  * the primary one expires it relies on the kernel to promote the
 636  * secondary IP. See also https://github.com/systemd/systemd/issues/7163
 637  */
 638 int dhcp4_set_promote_secondaries(Link *link) {
 639         int r;
 640
 641         assert(link);
 642         assert(link->network);
 643         assert(link->network->dhcp & ADDRESS_FAMILY_IPV4);
 644
 645         /* check if the kernel has promote_secondaries enabled for our
 646          * interface. If it is not globally enabled or enabled for the
 647          * specific interface we must either enable it.
 648          */
 649         if (!(promote_secondaries_enabled("all") || promote_secondaries_enabled(link->ifname))) {
 650                 char *promote_secondaries_path = NULL;
 651
 652                 log_link_debug(link, "promote_secondaries is unset, setting it");
 653                 promote_secondaries_path = strjoina("net/ipv4/conf/", link->ifname, "/promote_secondaries");
 654                 r = sysctl_write(promote_secondaries_path, "1");
 655                 if (r < 0)
 656                         log_link_warning_errno(link, r, "cannot set sysctl %s to 1", promote_secondaries_path);
 657                 return r > 0;
 658         }
 659
 660         return 0;
 661 }
 662
 663 int dhcp4_configure(Link *link) {
 664         int r;
 665
 666         assert(link);
 667         assert(link->network);
 668         assert(link->network->dhcp & ADDRESS_FAMILY_IPV4);
 669
 670         if (!link->dhcp_client) {
 671                 r = sd_dhcp_client_new(&link->dhcp_client, link->network->dhcp_anonymize);
 672                 if (r < 0)
 673                         return r;
 674         }
 675
 676         r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
 677         if (r < 0)
 678                 return r;
 679
 680         r = sd_dhcp_client_set_mac(link->dhcp_client,
 681                                    (const uint8_t *) &link->mac,
 682                                    sizeof (link->mac), ARPHRD_ETHER);
 683         if (r < 0)
 684                 return r;
 685
 686         r = sd_dhcp_client_set_ifindex(link->dhcp_client, link->ifindex);
 687         if (r < 0)
 688                 return r;
 689
 690         r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp4_handler, link);
 691         if (r < 0)
 692                 return r;
 693
 694         r = sd_dhcp_client_set_request_broadcast(link->dhcp_client,
 695                                                  link->network->dhcp_broadcast);
 696         if (r < 0)
 697                 return r;
 698
 699         if (link->mtu) {
 700                 r = sd_dhcp_client_set_mtu(link->dhcp_client, link->mtu);
 701                 if (r < 0)
 702                         return r;
 703         }
 704
 705         if (link->network->dhcp_use_mtu) {
 706                 r = sd_dhcp_client_set_request_option(link->dhcp_client,
 707                                                       SD_DHCP_OPTION_INTERFACE_MTU);
 708                 if (r < 0)
 709                         return r;
 710         }
 711
 712         /* NOTE: even if this variable is called "use", it also "sends" PRL
 713          * options, maybe there should be a different configuration variable
 714          * to send or not route options?. */
 715         /* NOTE: when using Anonymize=yes, routes PRL options are sent
 716          * by default, so they don't need to be added here. */
 717         if (link->network->dhcp_use_routes && !link->network->dhcp_anonymize) {
 718                 r = sd_dhcp_client_set_request_option(link->dhcp_client,
 719                                                       SD_DHCP_OPTION_STATIC_ROUTE);
 720                 if (r < 0)
 721                         return r;
 722                 r = sd_dhcp_client_set_request_option(link->dhcp_client,
 723                                                       SD_DHCP_OPTION_CLASSLESS_STATIC_ROUTE);
 724                 if (r < 0)
 725                         return r;
 726         }
 727
 728         if (link->network->dhcp_use_ntp) {
 729                 r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_NTP_SERVER);
 730                 if (r < 0)
 731                         return r;
 732         }
 733
 734         if (link->network->dhcp_use_timezone) {
 735                 r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_NEW_TZDB_TIMEZONE);
 736                 if (r < 0)
 737                         return r;
 738         }
 739
 740         r = dhcp4_set_hostname(link);
 741         if (r < 0)
 742                 return r;
 743
 744         if (link->network->dhcp_vendor_class_identifier) {
 745                 r = sd_dhcp_client_set_vendor_class_identifier(link->dhcp_client,
 746                                                                link->network->dhcp_vendor_class_identifier);
 747                 if (r < 0)
 748                         return r;
 749         }
 750
 751         if (link->network->dhcp_user_class) {
 752                 r = sd_dhcp_client_set_user_class(link->dhcp_client, (const char **) link->network->dhcp_user_class);
 753                 if (r < 0)
 754                         return r;
 755         }
 756
 757         if (link->network->dhcp_client_port) {
 758                 r = sd_dhcp_client_set_client_port(link->dhcp_client, link->network->dhcp_client_port);
 759                 if (r < 0)
 760                         return r;
 761         }
 762
 763         switch (link->network->dhcp_client_identifier) {
 764         case DHCP_CLIENT_ID_DUID: {
 765                 /* If configured, apply user specified DUID and/or IAID */
 766                 const DUID *duid = link_duid(link);
 767
 768                 r = sd_dhcp_client_set_iaid_duid(link->dhcp_client,
 769                                                  link->network->iaid,
 770                                                  duid->type,
 771                                                  duid->raw_data_len > 0 ? duid->raw_data : NULL,
 772                                                  duid->raw_data_len);
 773                 if (r < 0)
 774                         return r;
 775                 break;
 776         }
 777         case DHCP_CLIENT_ID_DUID_ONLY: {
 778                 /* If configured, apply user specified DUID */
 779                 const DUID *duid = link_duid(link);
 780
 781                 r = sd_dhcp_client_set_duid(link->dhcp_client,
 782                                             duid->type,
 783                                             duid->raw_data_len > 0 ? duid->raw_data : NULL,
 784                                             duid->raw_data_len);
 785                 if (r < 0)
 786                         return r;
 787                 break;
 788         }
 789         case DHCP_CLIENT_ID_MAC:
 790                 r = sd_dhcp_client_set_client_id(link->dhcp_client,
 791                                                  ARPHRD_ETHER,
 792                                                  (const uint8_t *) &link->mac,
 793                                                  sizeof(link->mac));
 794                 if (r < 0)
 795                         return r;
 796                 break;
 797         default:
 798                 assert_not_reached("Unknown client identifier type.");
 799         }
 800
 801         return 0;
 802 }