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         else
 449                 log_struct(LOG_INFO,
 450                            LOG_LINK_INTERFACE(link),
 451                            LOG_LINK_MESSAGE(link, "DHCPv4 address %u.%u.%u.%u/%u",
 452                                             ADDRESS_FMT_VAL(address),
 453                                             prefixlen),
 454                            "ADDRESS=%u.%u.%u.%u", ADDRESS_FMT_VAL(address),
 455                            "PREFIXLEN=%u", prefixlen);
 456
 457         link->dhcp_lease = sd_dhcp_lease_ref(lease);
 458         link_dirty(link);
 459
 460         if (link->network->dhcp_use_mtu) {
 461                 uint16_t mtu;
 462
 463                 r = sd_dhcp_lease_get_mtu(lease, &mtu);
 464                 if (r >= 0) {
 465                         r = link_set_mtu(link, mtu);
 466                         if (r < 0)
 467                                 log_link_error_errno(link, r, "Failed to set MTU to %" PRIu16 ": %m", mtu);
 468                 }
 469         }
 470
 471         if (link->network->dhcp_use_hostname) {
 472                 const char *dhcpname = NULL;
 473                 _cleanup_free_ char *hostname = NULL;
 474
 475                 if (link->network->dhcp_hostname)
 476                         dhcpname = link->network->dhcp_hostname;
 477                 else
 478                         (void) sd_dhcp_lease_get_hostname(lease, &dhcpname);
 479
 480                 if (dhcpname) {
 481                         r = shorten_overlong(dhcpname, &hostname);
 482                         if (r < 0)
 483                                 log_link_warning_errno(link, r, "Unable to shorten overlong DHCP hostname '%s', ignoring: %m", dhcpname);
 484                         if (r == 1)
 485                                 log_link_notice(link, "Overlong DCHP hostname received, shortened from '%s' to '%s'", dhcpname, hostname);
 486                 }
 487
 488                 if (hostname) {
 489                         r = manager_set_hostname(link->manager, hostname);
 490                         if (r < 0)
 491                                 log_link_error_errno(link, r, "Failed to set transient hostname to '%s': %m", hostname);
 492                 }
 493         }
 494
 495         if (link->network->dhcp_use_timezone) {
 496                 const char *tz = NULL;
 497
 498                 (void) sd_dhcp_lease_get_timezone(link->dhcp_lease, &tz);
 499
 500                 if (tz) {
 501                         r = manager_set_timezone(link->manager, tz);
 502                         if (r < 0)
 503                                 log_link_error_errno(link, r, "Failed to set timezone to '%s': %m", tz);
 504                 }
 505         }
 506
 507         if (!link->network->dhcp_critical) {
 508                 r = sd_dhcp_lease_get_lifetime(link->dhcp_lease, &lifetime);
 509                 if (r < 0) {
 510                         log_link_warning_errno(link, r, "DHCP error: no lifetime: %m");
 511                         return r;
 512                 }
 513         }
 514
 515         r = dhcp4_update_address(link, &address, &netmask, lifetime);
 516         if (r < 0) {
 517                 log_link_warning_errno(link, r, "Could not update IP address: %m");
 518                 link_enter_failed(link);
 519                 return r;
 520         }
 521
 522         return 0;
 523 }
 524 static void dhcp4_handler(sd_dhcp_client *client, int event, void *userdata) {
 525         Link *link = userdata;
 526         int r = 0;
 527
 528         assert(link);
 529         assert(link->network);
 530         assert(link->manager);
 531
 532         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 533                 return;
 534
 535         switch (event) {
 536                 case SD_DHCP_CLIENT_EVENT_EXPIRED:
 537                 case SD_DHCP_CLIENT_EVENT_STOP:
 538                 case SD_DHCP_CLIENT_EVENT_IP_CHANGE:
 539                         if (link->network->dhcp_critical) {
 540                                 log_link_error(link, "DHCPv4 connection considered system critical, ignoring request to reconfigure it.");
 541                                 return;
 542                         }
 543
 544                         if (link->dhcp_lease) {
 545                                 r = dhcp_lease_lost(link);
 546                                 if (r < 0) {
 547                                         link_enter_failed(link);
 548                                         return;
 549                                 }
 550                         }
 551
 552                         if (event == SD_DHCP_CLIENT_EVENT_IP_CHANGE) {
 553                                 r = dhcp_lease_acquired(client, link);
 554                                 if (r < 0) {
 555                                         link_enter_failed(link);
 556                                         return;
 557                                 }
 558                         }
 559
 560                         break;
 561                 case SD_DHCP_CLIENT_EVENT_RENEW:
 562                         r = dhcp_lease_renew(client, link);
 563                         if (r < 0) {
 564                                 link_enter_failed(link);
 565                                 return;
 566                         }
 567                         break;
 568                 case SD_DHCP_CLIENT_EVENT_IP_ACQUIRE:
 569                         r = dhcp_lease_acquired(client, link);
 570                         if (r < 0) {
 571                                 link_enter_failed(link);
 572                                 return;
 573                         }
 574                         break;
 575                 default:
 576                         if (event < 0)
 577                                 log_link_warning_errno(link, event, "DHCP error: Client failed: %m");
 578                         else
 579                                 log_link_warning(link, "DHCP unknown event: %i", event);
 580                         break;
 581         }
 582
 583         return;
 584 }
 585
 586 static int dhcp4_set_hostname(Link *link) {
 587         _cleanup_free_ char *hostname = NULL;
 588         const char *hn;
 589         int r;
 590
 591         assert(link);
 592
 593         if (!link->network->dhcp_send_hostname)
 594                 hn = NULL;
 595         else if (link->network->dhcp_hostname)
 596                 hn = link->network->dhcp_hostname;
 597         else {
 598                 r = gethostname_strict(&hostname);
 599                 if (r < 0 && r != -ENXIO) /* ENXIO: no hostname set or hostname is "localhost" */
 600                         return r;
 601
 602                 hn = hostname;
 603         }
 604
 605         return sd_dhcp_client_set_hostname(link->dhcp_client, hn);
 606 }
 607
 608 static bool promote_secondaries_enabled(const char *ifname) {
 609         _cleanup_free_ char *promote_secondaries_sysctl = NULL;
 610         char *promote_secondaries_path;
 611         int r;
 612
 613         promote_secondaries_path = strjoina("net/ipv4/conf/", ifname, "/promote_secondaries");
 614         r = sysctl_read(promote_secondaries_path, &promote_secondaries_sysctl);
 615         if (r < 0) {
 616                 log_debug_errno(r, "Cannot read sysctl %s", promote_secondaries_path);
 617                 return false;
 618         }
 619
 620         truncate_nl(promote_secondaries_sysctl);
 621         r = parse_boolean(promote_secondaries_sysctl);
 622         if (r < 0)
 623                 log_warning_errno(r, "Cannot parse sysctl %s with content %s as boolean", promote_secondaries_path, promote_secondaries_sysctl);
 624         return r > 0;
 625 }
 626
 627 /* dhcp4_set_promote_secondaries will ensure this interface has
 628  * the "promote_secondaries" option in the kernel set. If this sysctl
 629  * is not set DHCP will work only as long as the IP address does not
 630  * changes between leases. The kernel will remove all secondary IP
 631  * addresses of an interface otherwise. The way systemd-network works
 632  * is that the new IP of a lease is added as a secondary IP and when
 633  * the primary one expires it relies on the kernel to promote the
 634  * secondary IP. See also https://github.com/systemd/systemd/issues/7163
 635  */
 636 int dhcp4_set_promote_secondaries(Link *link) {
 637         int r;
 638
 639         assert(link);
 640         assert(link->network);
 641         assert(link->network->dhcp & ADDRESS_FAMILY_IPV4);
 642
 643         /* check if the kernel has promote_secondaries enabled for our
 644          * interface. If it is not globally enabled or enabled for the
 645          * specific interface we must either enable it.
 646          */
 647         if (!(promote_secondaries_enabled("all") || promote_secondaries_enabled(link->ifname))) {
 648                 char *promote_secondaries_path = NULL;
 649
 650                 log_link_debug(link, "promote_secondaries is unset, setting it");
 651                 promote_secondaries_path = strjoina("net/ipv4/conf/", link->ifname, "/promote_secondaries");
 652                 r = sysctl_write(promote_secondaries_path, "1");
 653                 if (r < 0)
 654                         log_link_warning_errno(link, r, "cannot set sysctl %s to 1", promote_secondaries_path);
 655                 return r > 0;
 656         }
 657
 658         return 0;
 659 }
 660
 661 int dhcp4_configure(Link *link) {
 662         int r;
 663
 664         assert(link);
 665         assert(link->network);
 666         assert(link->network->dhcp & ADDRESS_FAMILY_IPV4);
 667
 668         if (!link->dhcp_client) {
 669                 r = sd_dhcp_client_new(&link->dhcp_client, link->network->dhcp_anonymize);
 670                 if (r < 0)
 671                         return r;
 672         }
 673
 674         r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
 675         if (r < 0)
 676                 return r;
 677
 678         r = sd_dhcp_client_set_mac(link->dhcp_client,
 679                                    (const uint8_t *) &link->mac,
 680                                    sizeof (link->mac), ARPHRD_ETHER);
 681         if (r < 0)
 682                 return r;
 683
 684         r = sd_dhcp_client_set_ifindex(link->dhcp_client, link->ifindex);
 685         if (r < 0)
 686                 return r;
 687
 688         r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp4_handler, link);
 689         if (r < 0)
 690                 return r;
 691
 692         r = sd_dhcp_client_set_request_broadcast(link->dhcp_client,
 693                                                  link->network->dhcp_broadcast);
 694         if (r < 0)
 695                 return r;
 696
 697         if (link->mtu) {
 698                 r = sd_dhcp_client_set_mtu(link->dhcp_client, link->mtu);
 699                 if (r < 0)
 700                         return r;
 701         }
 702
 703         if (link->network->dhcp_use_mtu) {
 704                 r = sd_dhcp_client_set_request_option(link->dhcp_client,
 705                                                       SD_DHCP_OPTION_INTERFACE_MTU);
 706                 if (r < 0)
 707                         return r;
 708         }
 709
 710         /* NOTE: even if this variable is called "use", it also "sends" PRL
 711          * options, maybe there should be a different configuration variable
 712          * to send or not route options?. */
 713         /* NOTE: when using Anonymize=yes, routes PRL options are sent
 714          * by default, so they don't need to be added here. */
 715         if (link->network->dhcp_use_routes && !link->network->dhcp_anonymize) {
 716                 r = sd_dhcp_client_set_request_option(link->dhcp_client,
 717                                                       SD_DHCP_OPTION_STATIC_ROUTE);
 718                 if (r < 0)
 719                         return r;
 720                 r = sd_dhcp_client_set_request_option(link->dhcp_client,
 721                                                       SD_DHCP_OPTION_CLASSLESS_STATIC_ROUTE);
 722                 if (r < 0)
 723                         return r;
 724         }
 725
 726         if (link->network->dhcp_use_ntp) {
 727                 r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_NTP_SERVER);
 728                 if (r < 0)
 729                         return r;
 730         }
 731
 732         if (link->network->dhcp_use_timezone) {
 733                 r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_NEW_TZDB_TIMEZONE);
 734                 if (r < 0)
 735                         return r;
 736         }
 737
 738         r = dhcp4_set_hostname(link);
 739         if (r < 0)
 740                 return r;
 741
 742         if (link->network->dhcp_vendor_class_identifier) {
 743                 r = sd_dhcp_client_set_vendor_class_identifier(link->dhcp_client,
 744                                                                link->network->dhcp_vendor_class_identifier);
 745                 if (r < 0)
 746                         return r;
 747         }
 748
 749         if (link->network->dhcp_user_class) {
 750                 r = sd_dhcp_client_set_user_class(link->dhcp_client, (const char **) link->network->dhcp_user_class);
 751                 if (r < 0)
 752                         return r;
 753         }
 754
 755         if (link->network->dhcp_client_port) {
 756                 r = sd_dhcp_client_set_client_port(link->dhcp_client, link->network->dhcp_client_port);
 757                 if (r < 0)
 758                         return r;
 759         }
 760
 761         switch (link->network->dhcp_client_identifier) {
 762         case DHCP_CLIENT_ID_DUID: {
 763                 /* If configured, apply user specified DUID and/or IAID */
 764                 const DUID *duid = link_duid(link);
 765
 766                 r = sd_dhcp_client_set_iaid_duid(link->dhcp_client,
 767                                                  link->network->iaid,
 768                                                  duid->type,
 769                                                  duid->raw_data_len > 0 ? duid->raw_data : NULL,
 770                                                  duid->raw_data_len);
 771                 if (r < 0)
 772                         return r;
 773                 break;
 774         }
 775         case DHCP_CLIENT_ID_DUID_ONLY: {
 776                 /* If configured, apply user specified DUID */
 777                 const DUID *duid = link_duid(link);
 778
 779                 r = sd_dhcp_client_set_duid(link->dhcp_client,
 780                                             duid->type,
 781                                             duid->raw_data_len > 0 ? duid->raw_data : NULL,
 782                                             duid->raw_data_len);
 783                 if (r < 0)
 784                         return r;
 785                 break;
 786         }
 787         case DHCP_CLIENT_ID_MAC:
 788                 r = sd_dhcp_client_set_client_id(link->dhcp_client,
 789                                                  ARPHRD_ETHER,
 790                                                  (const uint8_t *) &link->mac,
 791                                                  sizeof(link->mac));
 792                 if (r < 0)
 793                         return r;
 794                 break;
 795         default:
 796                 assert_not_reached("Unknown client identifier type.");
 797         }
 798
 799         return 0;
 800 }