src/network/networkd-dhcp4.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <netinet/in.h>
   4 #include <netinet/ip.h>
   5 #include <linux/if.h>
   6 #include <linux/if_arp.h>
   7
   8 #include "escape.h"
   9 #include "alloc-util.h"
  10 #include "dhcp-client-internal.h"
  11 #include "hostname-setup.h"
  12 #include "hostname-util.h"
  13 #include "parse-util.h"
  14 #include "network-internal.h"
  15 #include "networkd-address.h"
  16 #include "networkd-dhcp4.h"
  17 #include "networkd-link.h"
  18 #include "networkd-manager.h"
  19 #include "networkd-network.h"
  20 #include "networkd-state-file.h"
  21 #include "string-table.h"
  22 #include "strv.h"
  23 #include "sysctl-util.h"
  24 #include "web-util.h"
  25
  26 static int dhcp4_update_address(Link *link, bool announce);
  27 static int dhcp4_remove_all(Link *link);
  28
  29 void network_adjust_dhcp4(Network *network) {
  30         assert(network);
  31
  32         if (!FLAGS_SET(network->dhcp, ADDRESS_FAMILY_IPV4))
  33                 return;
  34
  35         if (network->dhcp_use_gateway < 0)
  36                 network->dhcp_use_gateway = network->dhcp_use_routes;
  37
  38         /* RFC7844 section 3.: MAY contain the Client Identifier option
  39          * Section 3.5: clients MUST use client identifiers based solely on the link-layer address
  40          * NOTE: Using MAC, as it does not reveal extra information, and some servers might not answer
  41          * if this option is not sent */
  42         if (network->dhcp_anonymize &&
  43             network->dhcp_client_identifier >= 0 &&
  44             network->dhcp_client_identifier != DHCP_CLIENT_ID_MAC) {
  45                 log_warning("%s: ClientIdentifier= is set, although Anonymize=yes. Using ClientIdentifier=mac.",
  46                             network->filename);
  47                 network->dhcp_client_identifier = DHCP_CLIENT_ID_MAC;
  48         }
  49
  50         if (network->dhcp_client_identifier < 0)
  51                 network->dhcp_client_identifier = network->dhcp_anonymize ? DHCP_CLIENT_ID_MAC : DHCP_CLIENT_ID_DUID;
  52 }
  53
  54 static int dhcp4_release_old_lease(Link *link) {
  55         Route *route;
  56         int k, r = 0;
  57
  58         assert(link);
  59
  60         if (!link->dhcp_address_old && set_isempty(link->dhcp_routes_old))
  61                 return 0;
  62
  63         log_link_debug(link, "Removing old DHCPv4 address and routes.");
  64
  65         SET_FOREACH(route, link->dhcp_routes_old) {
  66                 k = route_remove(route, NULL, link, NULL);
  67                 if (k < 0)
  68                         r = k;
  69         }
  70
  71         if (link->dhcp_address_old) {
  72                 k = address_remove(link->dhcp_address_old, link, NULL);
  73                 if (k < 0)
  74                         r = k;
  75         }
  76
  77         return r;
  78 }
  79
  80 static void dhcp4_check_ready(Link *link) {
  81         int r;
  82
  83         if (link->network->dhcp_send_decline && !link->dhcp4_address_bind)
  84                 return;
  85
  86         if (link->dhcp4_messages > 0)
  87                 return;
  88
  89         link->dhcp4_configured = true;
  90
  91         /* New address and routes are configured now. Let's release old lease. */
  92         r = dhcp4_release_old_lease(link);
  93         if (r < 0) {
  94                 link_enter_failed(link);
  95                 return;
  96         }
  97
  98         r = sd_ipv4ll_stop(link->ipv4ll);
  99         if (r < 0)
 100                 log_link_warning_errno(link, r, "Failed to drop IPv4 link-local address, ignoring: %m");
 101
 102         link_check_ready(link);
 103 }
 104
 105 static int dhcp4_route_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
 106         int r;
 107
 108         assert(link);
 109         assert(link->dhcp4_messages > 0);
 110
 111         link->dhcp4_messages--;
 112
 113         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 114                 return 1;
 115
 116         r = sd_netlink_message_get_errno(m);
 117         if (r == -ENETUNREACH && !link->dhcp4_route_retrying) {
 118
 119                 /* It seems kernel does not support that the prefix route cannot be configured with
 120                  * route table. Let's once drop the config and reconfigure them later. */
 121
 122                 log_link_message_debug_errno(link, m, r, "Could not set DHCPv4 route, retrying later");
 123                 link->dhcp4_route_failed = true;
 124                 link->manager->dhcp4_prefix_root_cannot_set_table = true;
 125         } else if (r < 0 && r != -EEXIST) {
 126                 log_link_message_warning_errno(link, m, r, "Could not set DHCPv4 route");
 127                 link_enter_failed(link);
 128                 return 1;
 129         }
 130
 131         if (link->dhcp4_messages == 0 && link->dhcp4_route_failed) {
 132                 link->dhcp4_route_failed = false;
 133                 link->dhcp4_route_retrying = true;
 134
 135                 r = dhcp4_remove_all(link);
 136                 if (r < 0)
 137                         link_enter_failed(link);
 138                 return 1;
 139         }
 140
 141         dhcp4_check_ready(link);
 142
 143         return 1;
 144 }
 145
 146 static int route_scope_from_address(const Route *route, const struct in_addr *self_addr) {
 147         assert(route);
 148         assert(self_addr);
 149
 150         if (in4_addr_is_localhost(&route->dst.in) ||
 151             (in4_addr_is_set(self_addr) && in4_addr_equal(&route->dst.in, self_addr)))
 152                 return RT_SCOPE_HOST;
 153         else if (in4_addr_is_null(&route->gw.in))
 154                 return RT_SCOPE_LINK;
 155         else
 156                 return RT_SCOPE_UNIVERSE;
 157 }
 158
 159 static bool link_prefixroute(Link *link) {
 160         return !link->network->dhcp_route_table_set ||
 161                 link->network->dhcp_route_table == RT_TABLE_MAIN ||
 162                 link->manager->dhcp4_prefix_root_cannot_set_table;
 163 }
 164
 165 static int dhcp_route_configure(Route *route, Link *link) {
 166         Route *ret;
 167         int r;
 168
 169         assert(route);
 170         assert(link);
 171
 172         r = route_configure(route, link, dhcp4_route_handler, &ret);
 173         if (r < 0)
 174                 return log_link_error_errno(link, r, "Failed to set DHCPv4 route: %m");
 175
 176         link->dhcp4_messages++;
 177
 178         r = set_ensure_put(&link->dhcp_routes, &route_hash_ops, ret);
 179         if (r < 0)
 180                 return log_link_error_errno(link, r, "Failed to store DHCPv4 route: %m");
 181
 182         (void) set_remove(link->dhcp_routes_old, ret);
 183
 184         return 0;
 185 }
 186
 187 static int link_set_dns_routes(Link *link, const struct in_addr *address) {
 188         const struct in_addr *dns;
 189         uint32_t table;
 190         int n, r;
 191
 192         assert(link);
 193         assert(link->dhcp_lease);
 194         assert(link->network);
 195
 196         if (!link->network->dhcp_use_dns ||
 197             !link->network->dhcp_routes_to_dns)
 198                 return 0;
 199
 200         n = sd_dhcp_lease_get_dns(link->dhcp_lease, &dns);
 201         if (IN_SET(n, 0, -ENODATA))
 202                 return 0;
 203         if (n < 0)
 204                 return log_link_warning_errno(link, n, "DHCP error: could not get DNS servers: %m");
 205
 206         table = link_get_dhcp_route_table(link);
 207
 208         for (int i = 0; i < n; i ++) {
 209                 _cleanup_(route_freep) Route *route = NULL;
 210
 211                 r = route_new(&route);
 212                 if (r < 0)
 213                         return log_link_error_errno(link, r, "Could not allocate route: %m");
 214
 215                 /* Set routes to DNS servers. */
 216
 217                 route->family = AF_INET;
 218                 route->dst.in = dns[i];
 219                 route->dst_prefixlen = 32;
 220                 route->prefsrc.in = *address;
 221                 route->scope = RT_SCOPE_LINK;
 222                 route->protocol = RTPROT_DHCP;
 223                 route->priority = link->network->dhcp_route_metric;
 224                 route->table = table;
 225
 226                 r = dhcp_route_configure(route, link);
 227                 if (r < 0)
 228                         return log_link_error_errno(link, r, "Could not set route to DNS server: %m");
 229         }
 230
 231         return 0;
 232 }
 233
 234 static int dhcp_prefix_route_from_lease(
 235                 const sd_dhcp_lease *lease,
 236                 uint32_t table,
 237                 const struct in_addr *address,
 238                 Route **ret_route) {
 239
 240         Route *route;
 241         struct in_addr netmask;
 242         int r;
 243
 244         r = sd_dhcp_lease_get_netmask((sd_dhcp_lease*) lease, &netmask);
 245         if (r < 0)
 246                 return r;
 247
 248         r = route_new(&route);
 249         if (r < 0)
 250                 return r;
 251
 252         route->family = AF_INET;
 253         route->dst.in.s_addr = address->s_addr & netmask.s_addr;
 254         route->dst_prefixlen = in4_addr_netmask_to_prefixlen(&netmask);
 255         route->prefsrc.in = *address;
 256         route->scope = RT_SCOPE_LINK;
 257         route->protocol = RTPROT_DHCP;
 258         route->table = table;
 259         *ret_route = route;
 260         return 0;
 261 }
 262
 263 static int link_set_dhcp_routes(Link *link) {
 264         _cleanup_free_ sd_dhcp_route **static_routes = NULL;
 265         bool classless_route = false, static_route = false;
 266         struct in_addr address;
 267         uint32_t table;
 268         Route *rt;
 269         int r, n;
 270
 271         assert(link);
 272
 273         if (!link->dhcp_lease) /* link went down while we configured the IP addresses? */
 274                 return 0;
 275
 276         if (!link->network) /* link went down while we configured the IP addresses? */
 277                 return 0;
 278
 279         if (!link_has_carrier(link) && !link->network->configure_without_carrier)
 280                 /* During configuring addresses, the link lost its carrier. As networkd is dropping
 281                  * the addresses now, let's not configure the routes either. */
 282                 return 0;
 283
 284         while ((rt = set_steal_first(link->dhcp_routes))) {
 285                 r = set_ensure_put(&link->dhcp_routes_old, &route_hash_ops, rt);
 286                 if (r < 0)
 287                         return log_link_error_errno(link, r, "Failed to store old DHCPv4 route: %m");
 288         }
 289
 290         table = link_get_dhcp_route_table(link);
 291
 292         r = sd_dhcp_lease_get_address(link->dhcp_lease, &address);
 293         if (r < 0)
 294                 return log_link_warning_errno(link, r, "DHCP error: could not get address: %m");
 295
 296         if (!link_prefixroute(link)) {
 297                 _cleanup_(route_freep) Route *prefix_route = NULL;
 298
 299                 r = dhcp_prefix_route_from_lease(link->dhcp_lease, table, &address, &prefix_route);
 300                 if (r < 0)
 301                         return log_link_error_errno(link, r, "Could not create prefix route: %m");
 302
 303                 r = dhcp_route_configure(prefix_route, link);
 304                 if (r < 0)
 305                         return log_link_error_errno(link, r, "Could not set prefix route: %m");
 306         }
 307
 308         n = sd_dhcp_lease_get_routes(link->dhcp_lease, &static_routes);
 309         if (n == -ENODATA)
 310                 log_link_debug_errno(link, n, "DHCP: No routes received from DHCP server: %m");
 311         else if (n < 0)
 312                 return log_link_error_errno(link, n, "DHCP: could not get routes: %m");
 313
 314         for (int i = 0; i < n; i++) {
 315                 switch (sd_dhcp_route_get_option(static_routes[i])) {
 316                 case SD_DHCP_OPTION_CLASSLESS_STATIC_ROUTE:
 317                         classless_route = true;
 318                         break;
 319                 case SD_DHCP_OPTION_STATIC_ROUTE:
 320                         static_route = true;
 321                         break;
 322                 }
 323         }
 324
 325         if (link->network->dhcp_use_routes) {
 326                 /* if the DHCP server returns both a Classless Static Routes option and a Static Routes option,
 327                  * the DHCP client MUST ignore the Static Routes option. */
 328                 if (classless_route && static_route)
 329                         log_link_warning(link, "Classless static routes received from DHCP server: ignoring static-route option");
 330
 331                 for (int i = 0; i < n; i++) {
 332                         _cleanup_(route_freep) Route *route = NULL;
 333
 334                         if (classless_route &&
 335                             sd_dhcp_route_get_option(static_routes[i]) != SD_DHCP_OPTION_CLASSLESS_STATIC_ROUTE)
 336                                 continue;
 337
 338                         r = route_new(&route);
 339                         if (r < 0)
 340                                 return log_link_error_errno(link, r, "Could not allocate route: %m");
 341
 342                         route->family = AF_INET;
 343                         route->protocol = RTPROT_DHCP;
 344                         route->gw_family = AF_INET;
 345                         assert_se(sd_dhcp_route_get_gateway(static_routes[i], &route->gw.in) >= 0);
 346                         assert_se(sd_dhcp_route_get_destination(static_routes[i], &route->dst.in) >= 0);
 347                         assert_se(sd_dhcp_route_get_destination_prefix_length(static_routes[i], &route->dst_prefixlen) >= 0);
 348                         route->priority = link->network->dhcp_route_metric;
 349                         route->table = table;
 350                         route->mtu = link->network->dhcp_route_mtu;
 351                         route->scope = route_scope_from_address(route, &address);
 352                         if (IN_SET(route->scope, RT_SCOPE_LINK, RT_SCOPE_UNIVERSE))
 353                                 route->prefsrc.in = address;
 354
 355                         if (set_contains(link->dhcp_routes, route))
 356                                 continue;
 357
 358                         r = dhcp_route_configure(route, link);
 359                         if (r < 0)
 360                                 return log_link_error_errno(link, r, "Could not set route: %m");
 361                 }
 362         }
 363
 364         if (link->network->dhcp_use_gateway) {
 365                 const struct in_addr *router;
 366
 367                 r = sd_dhcp_lease_get_router(link->dhcp_lease, &router);
 368                 if (IN_SET(r, 0, -ENODATA))
 369                         log_link_info(link, "DHCP: No gateway received from DHCP server.");
 370                 else if (r < 0)
 371                         return log_link_error_errno(link, r, "DHCP error: could not get gateway: %m");
 372                 else if (in4_addr_is_null(&router[0]))
 373                         log_link_info(link, "DHCP: Received gateway is null.");
 374                 else if (classless_route)
 375                         /* According to RFC 3442: If the DHCP server returns both a Classless Static Routes option and
 376                          * a Router option, the DHCP client MUST ignore the Router option. */
 377                         log_link_warning(link, "Classless static routes received from DHCP server: ignoring router option");
 378                 else {
 379                         _cleanup_(route_freep) Route *route = NULL, *route_gw = NULL;
 380
 381                         r = route_new(&route_gw);
 382                         if (r < 0)
 383                                 return log_link_error_errno(link, r, "Could not allocate route: %m");
 384
 385                         /* The dhcp netmask may mask out the gateway. Add an explicit
 386                          * route for the gw host so that we can route no matter the
 387                          * netmask or existing kernel route tables. */
 388                         route_gw->family = AF_INET;
 389                         route_gw->dst.in = router[0];
 390                         route_gw->dst_prefixlen = 32;
 391                         route_gw->prefsrc.in = address;
 392                         route_gw->scope = RT_SCOPE_LINK;
 393                         route_gw->protocol = RTPROT_DHCP;
 394                         route_gw->priority = link->network->dhcp_route_metric;
 395                         route_gw->table = table;
 396                         route_gw->mtu = link->network->dhcp_route_mtu;
 397
 398                         r = dhcp_route_configure(route_gw, link);
 399                         if (r < 0)
 400                                 return log_link_error_errno(link, r, "Could not set host route: %m");
 401
 402                         r = route_new(&route);
 403                         if (r < 0)
 404                                 return log_link_error_errno(link, r, "Could not allocate route: %m");
 405
 406                         route->family = AF_INET;
 407                         route->gw_family = AF_INET;
 408                         route->gw.in = router[0];
 409                         route->prefsrc.in = address;
 410                         route->protocol = RTPROT_DHCP;
 411                         route->priority = link->network->dhcp_route_metric;
 412                         route->table = table;
 413                         route->mtu = link->network->dhcp_route_mtu;
 414
 415                         r = dhcp_route_configure(route, link);
 416                         if (r < 0)
 417                                 return log_link_error_errno(link, r, "Could not set router: %m");
 418
 419                         HASHMAP_FOREACH(rt, link->network->routes_by_section) {
 420                                 if (!rt->gateway_from_dhcp_or_ra)
 421                                         continue;
 422
 423                                 if (rt->gw_family != AF_INET)
 424                                         continue;
 425
 426                                 rt->gw.in = router[0];
 427                                 if (!rt->protocol_set)
 428                                         rt->protocol = RTPROT_DHCP;
 429                                 if (!rt->priority_set)
 430                                         rt->priority = link->network->dhcp_route_metric;
 431                                 if (!rt->table_set)
 432                                         rt->table = table;
 433                                 if (rt->mtu == 0)
 434                                         rt->mtu = link->network->dhcp_route_mtu;
 435
 436                                 r = dhcp_route_configure(rt, link);
 437                                 if (r < 0)
 438                                         return log_link_error_errno(link, r, "Could not set gateway: %m");
 439                         }
 440                 }
 441         }
 442
 443         return link_set_dns_routes(link, &address);
 444 }
 445
 446 static int dhcp_reset_mtu(Link *link) {
 447         uint16_t mtu;
 448         int r;
 449
 450         assert(link);
 451
 452         if (!link->network->dhcp_use_mtu)
 453                 return 0;
 454
 455         r = sd_dhcp_lease_get_mtu(link->dhcp_lease, &mtu);
 456         if (r == -ENODATA)
 457                 return 0;
 458         if (r < 0)
 459                 return log_link_error_errno(link, r, "DHCP error: failed to get MTU from lease: %m");
 460
 461         if (link->original_mtu == mtu)
 462                 return 0;
 463
 464         r = link_set_mtu(link, link->original_mtu);
 465         if (r < 0)
 466                 return log_link_error_errno(link, r, "DHCP error: could not reset MTU: %m");
 467
 468         return 0;
 469 }
 470
 471 static int dhcp_reset_hostname(Link *link) {
 472         const char *hostname;
 473         int r;
 474
 475         assert(link);
 476
 477         if (!link->network->dhcp_use_hostname)
 478                 return 0;
 479
 480         hostname = link->network->dhcp_hostname;
 481         if (!hostname)
 482                 (void) sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
 483
 484         if (!hostname)
 485                 return 0;
 486
 487         /* If a hostname was set due to the lease, then unset it now. */
 488         r = manager_set_hostname(link->manager, NULL);
 489         if (r < 0)
 490                 return log_link_error_errno(link, r, "DHCP error: Failed to reset transient hostname: %m");
 491
 492         return 0;
 493 }
 494
 495 static int dhcp4_remove_route_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
 496         int r;
 497
 498         assert(m);
 499         assert(link);
 500         assert(link->dhcp4_remove_messages > 0);
 501
 502         link->dhcp4_remove_messages--;
 503
 504         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 505                 return 1;
 506
 507         r = sd_netlink_message_get_errno(m);
 508         if (r < 0 && r != -ESRCH)
 509                 log_link_message_warning_errno(link, m, r, "Failed to remove DHCPv4 route, ignoring");
 510
 511         if (link->dhcp4_remove_messages == 0) {
 512                 r = dhcp4_update_address(link, false);
 513                 if (r < 0)
 514                         link_enter_failed(link);
 515         }
 516
 517         return 1;
 518 }
 519
 520 static int dhcp4_remove_address_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
 521         int r;
 522
 523         assert(m);
 524         assert(link);
 525         assert(link->dhcp4_remove_messages > 0);
 526
 527         link->dhcp4_remove_messages--;
 528
 529         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 530                 return 1;
 531
 532         r = sd_netlink_message_get_errno(m);
 533         if (r < 0 && r != -EADDRNOTAVAIL)
 534                 log_link_message_warning_errno(link, m, r, "Failed to remove DHCPv4 address, ignoring");
 535         else
 536                 (void) manager_rtnl_process_address(rtnl, m, link->manager);
 537
 538         if (link->dhcp4_remove_messages == 0) {
 539                 r = dhcp4_update_address(link, false);
 540                 if (r < 0)
 541                         link_enter_failed(link);
 542         }
 543
 544         return 1;
 545 }
 546
 547 static int dhcp4_remove_all(Link *link) {
 548         Route *route;
 549         int k, r = 0;
 550
 551         assert(link);
 552
 553         SET_FOREACH(route, link->dhcp_routes) {
 554                 k = route_remove(route, NULL, link, dhcp4_remove_route_handler);
 555                 if (k < 0)
 556                         r = k;
 557                 else
 558                         link->dhcp4_remove_messages++;
 559         }
 560
 561         if (link->dhcp_address) {
 562                 k = address_remove(link->dhcp_address, link, dhcp4_remove_address_handler);
 563                 if (k < 0)
 564                         r = k;
 565                 else
 566                         link->dhcp4_remove_messages++;
 567         }
 568
 569         return r;
 570 }
 571
 572 static int dhcp_lease_lost(Link *link) {
 573         int k, r = 0;
 574
 575         assert(link);
 576         assert(link->dhcp_lease);
 577
 578         log_link_info(link, "DHCP lease lost");
 579
 580         link->dhcp4_configured = false;
 581
 582         /* dhcp_lease_lost() may be called during renewing IP address. */
 583         k = dhcp4_release_old_lease(link);
 584         if (k < 0)
 585                 r = k;
 586
 587         k = dhcp4_remove_all(link);
 588         if (k < 0)
 589                 r = k;
 590
 591         k = dhcp_reset_mtu(link);
 592         if (k < 0)
 593                 r = k;
 594
 595         k = dhcp_reset_hostname(link);
 596         if (k < 0)
 597                 r = k;
 598
 599         link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
 600         link_dirty(link);
 601
 602         (void) sd_ipv4acd_stop(link->dhcp_acd);
 603
 604         return r;
 605 }
 606
 607 static void dhcp_address_on_acd(sd_ipv4acd *acd, int event, void *userdata) {
 608         _cleanup_free_ char *pretty = NULL;
 609         union in_addr_union address = {};
 610         Link *link;
 611         int r;
 612
 613         assert(acd);
 614         assert(userdata);
 615
 616         link = userdata;
 617
 618         switch (event) {
 619         case SD_IPV4ACD_EVENT_STOP:
 620                 log_link_debug(link, "Stopping ACD client for DHCP4...");
 621                 return;
 622
 623         case SD_IPV4ACD_EVENT_BIND:
 624                 if (DEBUG_LOGGING) {
 625                         (void) sd_dhcp_lease_get_address(link->dhcp_lease, &address.in);
 626                         (void) in_addr_to_string(AF_INET, &address, &pretty);
 627                         log_link_debug(link, "Successfully claimed DHCP4 address %s", strna(pretty));
 628                 }
 629                 link->dhcp4_address_bind = true;
 630                 dhcp4_check_ready(link);
 631                 break;
 632
 633         case SD_IPV4ACD_EVENT_CONFLICT:
 634                 (void) sd_dhcp_lease_get_address(link->dhcp_lease, &address.in);
 635                 (void) in_addr_to_string(AF_INET, &address, &pretty);
 636                 log_link_warning(link, "DAD conflict. Dropping DHCP4 address %s", strna(pretty));
 637
 638                 r = sd_dhcp_client_send_decline(link->dhcp_client);
 639                 if (r < 0)
 640                         log_link_warning_errno(link, r, "Failed to send DHCP DECLINE, ignoring: %m");
 641
 642                 if (link->dhcp_lease) {
 643                         r = dhcp_lease_lost(link);
 644                         if (r < 0)
 645                                 link_enter_failed(link);
 646                 }
 647                 break;
 648
 649         default:
 650                 assert_not_reached("Invalid IPv4ACD event.");
 651         }
 652
 653         (void) sd_ipv4acd_stop(acd);
 654
 655         return;
 656 }
 657
 658 static int dhcp4_configure_dad(Link *link) {
 659         int r;
 660
 661         assert(link);
 662         assert(link->manager);
 663         assert(link->network);
 664
 665         if (!link->network->dhcp_send_decline)
 666                 return 0;
 667
 668         if (!link->dhcp_acd) {
 669                 r = sd_ipv4acd_new(&link->dhcp_acd);
 670                 if (r < 0)
 671                         return r;
 672
 673                 r = sd_ipv4acd_attach_event(link->dhcp_acd, link->manager->event, 0);
 674                 if (r < 0)
 675                         return r;
 676         }
 677
 678         r = sd_ipv4acd_set_ifindex(link->dhcp_acd, link->ifindex);
 679         if (r < 0)
 680                 return r;
 681
 682         r = sd_ipv4acd_set_mac(link->dhcp_acd, &link->hw_addr.addr.ether);
 683         if (r < 0)
 684                 return r;
 685
 686         return 0;
 687 }
 688
 689 static int dhcp4_dad_update_mac(Link *link) {
 690         bool running;
 691         int r;
 692
 693         assert(link);
 694
 695         if (!link->dhcp_acd)
 696                 return 0;
 697
 698         running = sd_ipv4acd_is_running(link->dhcp_acd);
 699
 700         r = sd_ipv4acd_stop(link->dhcp_acd);
 701         if (r < 0)
 702                 return r;
 703
 704         r = sd_ipv4acd_set_mac(link->dhcp_acd, &link->hw_addr.addr.ether);
 705         if (r < 0)
 706                 return r;
 707
 708         if (running) {
 709                 r = sd_ipv4acd_start(link->dhcp_acd, true);
 710                 if (r < 0)
 711                         return r;
 712         }
 713
 714         return 0;
 715 }
 716
 717 static int dhcp4_start_acd(Link *link) {
 718         union in_addr_union addr;
 719         struct in_addr old;
 720         int r;
 721
 722         if (!link->network->dhcp_send_decline)
 723                 return 0;
 724
 725         if (!link->dhcp_lease)
 726                 return 0;
 727
 728         (void) sd_ipv4acd_stop(link->dhcp_acd);
 729
 730         link->dhcp4_address_bind = false;
 731
 732         r = sd_dhcp_lease_get_address(link->dhcp_lease, &addr.in);
 733         if (r < 0)
 734                 return r;
 735
 736         r = sd_ipv4acd_get_address(link->dhcp_acd, &old);
 737         if (r < 0)
 738                 return r;
 739
 740         r = sd_ipv4acd_set_address(link->dhcp_acd, &addr.in);
 741         if (r < 0)
 742                 return r;
 743
 744         r = sd_ipv4acd_set_callback(link->dhcp_acd, dhcp_address_on_acd, link);
 745         if (r < 0)
 746                 return r;
 747
 748         if (DEBUG_LOGGING) {
 749                 _cleanup_free_ char *pretty = NULL;
 750
 751                 (void) in_addr_to_string(AF_INET, &addr, &pretty);
 752                 log_link_debug(link, "Starting IPv4ACD client. Probing DHCPv4 address %s", strna(pretty));
 753         }
 754
 755         r = sd_ipv4acd_start(link->dhcp_acd, !in4_addr_equal(&addr.in, &old));
 756         if (r < 0)
 757                 return r;
 758
 759         return 1;
 760 }
 761
 762 static int dhcp4_address_ready_callback(Address *address) {
 763         Link *link;
 764         int r;
 765
 766         assert(address);
 767
 768         link = address->link;
 769
 770         /* Do not call this again. */
 771         address->callback = NULL;
 772
 773         r = link_set_dhcp_routes(link);
 774         if (r < 0)
 775                 return r;
 776
 777         /* Reconfigure static routes as kernel may remove some routes when lease expires. */
 778         r = link_set_routes(link);
 779         if (r < 0)
 780                 return r;
 781
 782         r = dhcp4_start_acd(link);
 783         if (r < 0)
 784                 return log_link_error_errno(link, r, "Failed to start IPv4ACD for DHCP4 address: %m");
 785
 786         dhcp4_check_ready(link);
 787         return 0;
 788 }
 789
 790 static int dhcp4_address_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
 791         int r;
 792
 793         assert(link);
 794
 795         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 796                 return 1;
 797
 798         r = sd_netlink_message_get_errno(m);
 799         if (r < 0 && r != -EEXIST) {
 800                 log_link_message_warning_errno(link, m, r, "Could not set DHCPv4 address");
 801                 link_enter_failed(link);
 802                 return 1;
 803         } else if (r >= 0)
 804                 (void) manager_rtnl_process_address(rtnl, m, link->manager);
 805
 806         if (address_is_ready(link->dhcp_address)) {
 807                 r = dhcp4_address_ready_callback(link->dhcp_address);
 808                 if (r < 0) {
 809                         link_enter_failed(link);
 810                         return 1;
 811                 }
 812         } else
 813                 link->dhcp_address->callback = dhcp4_address_ready_callback;
 814
 815         return 1;
 816 }
 817
 818 static int dhcp4_update_address(Link *link, bool announce) {
 819         _cleanup_(address_freep) Address *addr = NULL;
 820         uint32_t lifetime = CACHE_INFO_INFINITY_LIFE_TIME;
 821         struct in_addr address, netmask;
 822         unsigned prefixlen;
 823         Address *ret;
 824         int r;
 825
 826         assert(link);
 827         assert(link->network);
 828
 829         if (!link->dhcp_lease)
 830                 return 0;
 831
 832         link_set_state(link, LINK_STATE_CONFIGURING);
 833         link->dhcp4_configured = false;
 834
 835         /* address_handler calls link_set_routes() and link_set_nexthop(). Before they are called, the
 836          * related flags must be cleared. Otherwise, the link becomes configured state before routes
 837          * are configured. */
 838         link->static_routes_configured = false;
 839         link->static_nexthops_configured = false;
 840
 841         r = sd_dhcp_lease_get_address(link->dhcp_lease, &address);
 842         if (r < 0)
 843                 return log_link_warning_errno(link, r, "DHCP error: no address: %m");
 844
 845         r = sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
 846         if (r < 0)
 847                 return log_link_warning_errno(link, r, "DHCP error: no netmask: %m");
 848
 849         if (!FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DHCP)) {
 850                 r = sd_dhcp_lease_get_lifetime(link->dhcp_lease, &lifetime);
 851                 if (r < 0)
 852                         return log_link_warning_errno(link, r, "DHCP error: no lifetime: %m");
 853         }
 854
 855         prefixlen = in4_addr_netmask_to_prefixlen(&netmask);
 856
 857         if (announce) {
 858                 const struct in_addr *router;
 859
 860                 r = sd_dhcp_lease_get_router(link->dhcp_lease, &router);
 861                 if (r < 0 && r != -ENODATA)
 862                         return log_link_error_errno(link, r, "DHCP error: Could not get gateway: %m");
 863
 864                 if (r > 0 && in4_addr_is_set(&router[0]))
 865                         log_struct(LOG_INFO,
 866                                    LOG_LINK_INTERFACE(link),
 867                                    LOG_LINK_MESSAGE(link, "DHCPv4 address "IPV4_ADDRESS_FMT_STR"/%u via "IPV4_ADDRESS_FMT_STR,
 868                                                     IPV4_ADDRESS_FMT_VAL(address),
 869                                                     prefixlen,
 870                                                     IPV4_ADDRESS_FMT_VAL(router[0])),
 871                                    "ADDRESS="IPV4_ADDRESS_FMT_STR, IPV4_ADDRESS_FMT_VAL(address),
 872                                    "PREFIXLEN=%u", prefixlen,
 873                                    "GATEWAY="IPV4_ADDRESS_FMT_STR, IPV4_ADDRESS_FMT_VAL(router[0]));
 874                 else
 875                         log_struct(LOG_INFO,
 876                                    LOG_LINK_INTERFACE(link),
 877                                    LOG_LINK_MESSAGE(link, "DHCPv4 address "IPV4_ADDRESS_FMT_STR"/%u",
 878                                                     IPV4_ADDRESS_FMT_VAL(address),
 879                                                     prefixlen),
 880                                    "ADDRESS="IPV4_ADDRESS_FMT_STR, IPV4_ADDRESS_FMT_VAL(address),
 881                                    "PREFIXLEN=%u", prefixlen);
 882         }
 883
 884         r = address_new(&addr);
 885         if (r < 0)
 886                 return log_oom();
 887
 888         addr->family = AF_INET;
 889         addr->in_addr.in.s_addr = address.s_addr;
 890         addr->cinfo.ifa_prefered = lifetime;
 891         addr->cinfo.ifa_valid = lifetime;
 892         addr->prefixlen = prefixlen;
 893         if (prefixlen <= 30)
 894                 addr->broadcast.s_addr = address.s_addr | ~netmask.s_addr;
 895         SET_FLAG(addr->flags, IFA_F_NOPREFIXROUTE, !link_prefixroute(link));
 896         addr->route_metric = link->network->dhcp_route_metric;
 897
 898         /* allow reusing an existing address and simply update its lifetime
 899          * in case it already exists */
 900         r = address_configure(addr, link, dhcp4_address_handler, &ret);
 901         if (r < 0)
 902                 return log_link_error_errno(link, r, "Failed to set DHCPv4 address: %m");
 903
 904         if (!address_equal(link->dhcp_address, ret))
 905                 link->dhcp_address_old = link->dhcp_address;
 906         link->dhcp_address = ret;
 907
 908         return 0;
 909 }
 910
 911 static int dhcp_lease_renew(sd_dhcp_client *client, Link *link) {
 912         sd_dhcp_lease *lease;
 913         int r;
 914
 915         assert(link);
 916         assert(client);
 917
 918         r = sd_dhcp_client_get_lease(client, &lease);
 919         if (r < 0)
 920                 return log_link_warning_errno(link, r, "DHCP error: no lease: %m");
 921
 922         sd_dhcp_lease_unref(link->dhcp_lease);
 923         link->dhcp_lease = sd_dhcp_lease_ref(lease);
 924         link_dirty(link);
 925
 926         return dhcp4_update_address(link, false);
 927 }
 928
 929 static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
 930         sd_dhcp_lease *lease;
 931         int r;
 932
 933         assert(client);
 934         assert(link);
 935
 936         r = sd_dhcp_client_get_lease(client, &lease);
 937         if (r < 0)
 938                 return log_link_error_errno(link, r, "DHCP error: No lease: %m");
 939
 940         sd_dhcp_lease_unref(link->dhcp_lease);
 941         link->dhcp_lease = sd_dhcp_lease_ref(lease);
 942         link_dirty(link);
 943
 944         if (link->network->dhcp_use_mtu) {
 945                 uint16_t mtu;
 946
 947                 r = sd_dhcp_lease_get_mtu(lease, &mtu);
 948                 if (r >= 0) {
 949                         r = link_set_mtu(link, mtu);
 950                         if (r < 0)
 951                                 log_link_error_errno(link, r, "Failed to set MTU to %" PRIu16 ": %m", mtu);
 952                 }
 953         }
 954
 955         if (link->network->dhcp_use_hostname) {
 956                 const char *dhcpname = NULL;
 957                 _cleanup_free_ char *hostname = NULL;
 958
 959                 if (link->network->dhcp_hostname)
 960                         dhcpname = link->network->dhcp_hostname;
 961                 else
 962                         (void) sd_dhcp_lease_get_hostname(lease, &dhcpname);
 963
 964                 if (dhcpname) {
 965                         r = shorten_overlong(dhcpname, &hostname);
 966                         if (r < 0)
 967                                 log_link_warning_errno(link, r, "Unable to shorten overlong DHCP hostname '%s', ignoring: %m", dhcpname);
 968                         if (r == 1)
 969                                 log_link_notice(link, "Overlong DHCP hostname received, shortened from '%s' to '%s'", dhcpname, hostname);
 970                 }
 971
 972                 if (hostname) {
 973                         r = manager_set_hostname(link->manager, hostname);
 974                         if (r < 0)
 975                                 log_link_error_errno(link, r, "Failed to set transient hostname to '%s': %m", hostname);
 976                 }
 977         }
 978
 979         if (link->network->dhcp_use_timezone) {
 980                 const char *tz = NULL;
 981
 982                 (void) sd_dhcp_lease_get_timezone(link->dhcp_lease, &tz);
 983
 984                 if (tz) {
 985                         r = manager_set_timezone(link->manager, tz);
 986                         if (r < 0)
 987                                 log_link_error_errno(link, r, "Failed to set timezone to '%s': %m", tz);
 988                 }
 989         }
 990
 991         if (link->dhcp4_remove_messages == 0) {
 992                 r = dhcp4_update_address(link, true);
 993                 if (r < 0)
 994                         return r;
 995         } else
 996                 log_link_debug(link,
 997                                "The link has previously assigned DHCPv4 address or routes. "
 998                                "The newly assigned address and routes will set up after old ones are removed.");
 999
1000         return 0;
1001 }
1002
1003 static int dhcp_lease_ip_change(sd_dhcp_client *client, Link *link) {
1004         int r;
1005
1006         r = dhcp_lease_acquired(client, link);
1007         if (r < 0)
1008                 (void) dhcp_lease_lost(link);
1009
1010         return r;
1011 }
1012
1013 static int dhcp_server_is_deny_listed(Link *link, sd_dhcp_client *client) {
1014         sd_dhcp_lease *lease;
1015         struct in_addr addr;
1016         int r;
1017
1018         assert(link);
1019         assert(link->network);
1020         assert(client);
1021
1022         r = sd_dhcp_client_get_lease(client, &lease);
1023         if (r < 0)
1024                 return log_link_error_errno(link, r, "Failed to get DHCP lease: %m");
1025
1026         r = sd_dhcp_lease_get_server_identifier(lease, &addr);
1027         if (r < 0)
1028                 return log_link_debug_errno(link, r, "Failed to get DHCP server IP address: %m");
1029
1030         if (set_contains(link->network->dhcp_deny_listed_ip, UINT32_TO_PTR(addr.s_addr))) {
1031                 log_struct(LOG_DEBUG,
1032                            LOG_LINK_INTERFACE(link),
1033                            LOG_LINK_MESSAGE(link, "DHCPv4 server IP address "IPV4_ADDRESS_FMT_STR" found in deny-list, ignoring offer",
1034                                             IPV4_ADDRESS_FMT_VAL(addr)));
1035                 return true;
1036         }
1037
1038         return false;
1039 }
1040
1041 static int dhcp_server_is_allow_listed(Link *link, sd_dhcp_client *client) {
1042         sd_dhcp_lease *lease;
1043         struct in_addr addr;
1044         int r;
1045
1046         assert(link);
1047         assert(link->network);
1048         assert(client);
1049
1050         r = sd_dhcp_client_get_lease(client, &lease);
1051         if (r < 0)
1052                 return log_link_error_errno(link, r, "Failed to get DHCP lease: %m");
1053
1054         r = sd_dhcp_lease_get_server_identifier(lease, &addr);
1055         if (r < 0)
1056                 return log_link_debug_errno(link, r, "Failed to get DHCP server IP address: %m");
1057
1058         if (set_contains(link->network->dhcp_allow_listed_ip, UINT32_TO_PTR(addr.s_addr))) {
1059                 log_struct(LOG_DEBUG,
1060                            LOG_LINK_INTERFACE(link),
1061                            LOG_LINK_MESSAGE(link, "DHCPv4 server IP address "IPV4_ADDRESS_FMT_STR" found in allow-list, accepting offer",
1062                                             IPV4_ADDRESS_FMT_VAL(addr)));
1063                 return true;
1064         }
1065
1066         return false;
1067 }
1068
1069 static int dhcp4_handler(sd_dhcp_client *client, int event, void *userdata) {
1070         Link *link = userdata;
1071         int r;
1072
1073         assert(link);
1074         assert(link->network);
1075         assert(link->manager);
1076
1077         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1078                 return 0;
1079
1080         switch (event) {
1081                 case SD_DHCP_CLIENT_EVENT_STOP:
1082                         if (link->ipv4ll) {
1083                                 log_link_debug(link, "DHCP client is stopped. Acquiring IPv4 link-local address");
1084
1085                                 r = sd_ipv4ll_start(link->ipv4ll);
1086                                 if (r < 0)
1087                                         return log_link_warning_errno(link, r, "Could not acquire IPv4 link-local address: %m");
1088                         }
1089
1090                         if (FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DHCP)) {
1091                                 log_link_notice(link, "DHCPv4 connection considered critical, ignoring request to reconfigure it.");
1092                                 return 0;
1093                         }
1094
1095                         if (link->dhcp_lease) {
1096                                 if (link->network->dhcp_send_release) {
1097                                         r = sd_dhcp_client_send_release(client);
1098                                         if (r < 0)
1099                                                 log_link_warning_errno(link, r, "Failed to send DHCP RELEASE, ignoring: %m");
1100                                 }
1101
1102                                 r = dhcp_lease_lost(link);
1103                                 if (r < 0) {
1104                                         link_enter_failed(link);
1105                                         return r;
1106                                 }
1107                         }
1108
1109                         break;
1110                 case SD_DHCP_CLIENT_EVENT_EXPIRED:
1111                         if (FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DHCP)) {
1112                                 log_link_notice(link, "DHCPv4 connection considered critical, ignoring request to reconfigure it.");
1113                                 return 0;
1114                         }
1115
1116                         if (link->dhcp_lease) {
1117                                 r = dhcp_lease_lost(link);
1118                                 if (r < 0) {
1119                                         link_enter_failed(link);
1120                                         return r;
1121                                 }
1122                         }
1123
1124                         break;
1125                 case SD_DHCP_CLIENT_EVENT_IP_CHANGE:
1126                         if (FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DHCP)) {
1127                                 log_link_notice(link, "DHCPv4 connection considered critical, ignoring request to reconfigure it.");
1128                                 return 0;
1129                         }
1130
1131                         r = dhcp_lease_ip_change(client, link);
1132                         if (r < 0) {
1133                                 link_enter_failed(link);
1134                                 return r;
1135                         }
1136
1137                         break;
1138                 case SD_DHCP_CLIENT_EVENT_RENEW:
1139                         r = dhcp_lease_renew(client, link);
1140                         if (r < 0) {
1141                                 link_enter_failed(link);
1142                                 return r;
1143                         }
1144                         break;
1145                 case SD_DHCP_CLIENT_EVENT_IP_ACQUIRE:
1146                         r = dhcp_lease_acquired(client, link);
1147                         if (r < 0) {
1148                                 link_enter_failed(link);
1149                                 return r;
1150                         }
1151                         break;
1152                 case SD_DHCP_CLIENT_EVENT_SELECTING:
1153                         if (!set_isempty(link->network->dhcp_allow_listed_ip)) {
1154                                 r = dhcp_server_is_allow_listed(link, client);
1155                                 if (r < 0)
1156                                         return r;
1157                                 if (r == 0)
1158                                         return -ENOMSG;
1159                         } else {
1160                                 r = dhcp_server_is_deny_listed(link, client);
1161                                 if (r < 0)
1162                                         return r;
1163                                 if (r != 0)
1164                                         return -ENOMSG;
1165                         }
1166                         break;
1167
1168                 case SD_DHCP_CLIENT_EVENT_TRANSIENT_FAILURE:
1169                         if (link->ipv4ll && !sd_ipv4ll_is_running(link->ipv4ll)) {
1170                                 log_link_debug(link, "Problems acquiring DHCP lease, acquiring IPv4 link-local address");
1171
1172                                 r = sd_ipv4ll_start(link->ipv4ll);
1173                                 if (r < 0)
1174                                         return log_link_warning_errno(link, r, "Could not acquire IPv4 link-local address: %m");
1175                         }
1176                         break;
1177
1178                 default:
1179                         if (event < 0)
1180                                 log_link_warning_errno(link, event, "DHCP error: Client failed: %m");
1181                         else
1182                                 log_link_warning(link, "DHCP unknown event: %i", event);
1183                         break;
1184         }
1185
1186         return 0;
1187 }
1188
1189 static int dhcp4_set_hostname(Link *link) {
1190         _cleanup_free_ char *hostname = NULL;
1191         const char *hn;
1192         int r;
1193
1194         assert(link);
1195
1196         if (!link->network->dhcp_send_hostname)
1197                 hn = NULL;
1198         else if (link->network->dhcp_hostname)
1199                 hn = link->network->dhcp_hostname;
1200         else {
1201                 r = gethostname_strict(&hostname);
1202                 if (r < 0 && r != -ENXIO) /* ENXIO: no hostname set or hostname is "localhost" */
1203                         return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to get hostname: %m");
1204
1205                 hn = hostname;
1206         }
1207
1208         r = sd_dhcp_client_set_hostname(link->dhcp_client, hn);
1209         if (r == -EINVAL && hostname)
1210                 /* Ignore error when the machine's hostname is not suitable to send in DHCP packet. */
1211                 log_link_debug_errno(link, r, "DHCP4 CLIENT: Failed to set hostname from kernel hostname, ignoring: %m");
1212         else if (r < 0)
1213                 return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to set hostname: %m");
1214
1215         return 0;
1216 }
1217
1218 static int dhcp4_set_client_identifier(Link *link) {
1219         int r;
1220
1221         assert(link);
1222         assert(link->network);
1223         assert(link->dhcp_client);
1224
1225         switch (link->network->dhcp_client_identifier) {
1226         case DHCP_CLIENT_ID_DUID: {
1227                 /* If configured, apply user specified DUID and IAID */
1228                 const DUID *duid = link_get_dhcp4_duid(link);
1229
1230                 if (duid->type == DUID_TYPE_LLT && duid->raw_data_len == 0)
1231                         r = sd_dhcp_client_set_iaid_duid_llt(link->dhcp_client,
1232                                                              link->network->dhcp_iaid_set,
1233                                                              link->network->dhcp_iaid,
1234                                                              duid->llt_time);
1235                 else
1236                         r = sd_dhcp_client_set_iaid_duid(link->dhcp_client,
1237                                                          link->network->dhcp_iaid_set,
1238                                                          link->network->dhcp_iaid,
1239                                                          duid->type,
1240                                                          duid->raw_data_len > 0 ? duid->raw_data : NULL,
1241                                                          duid->raw_data_len);
1242                 if (r < 0)
1243                         return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to set IAID+DUID: %m");
1244                 break;
1245         }
1246         case DHCP_CLIENT_ID_DUID_ONLY: {
1247                 /* If configured, apply user specified DUID */
1248                 const DUID *duid = link_get_dhcp4_duid(link);
1249
1250                 if (duid->type == DUID_TYPE_LLT && duid->raw_data_len == 0)
1251                         r = sd_dhcp_client_set_duid_llt(link->dhcp_client,
1252                                                         duid->llt_time);
1253                 else
1254                         r = sd_dhcp_client_set_duid(link->dhcp_client,
1255                                                     duid->type,
1256                                                     duid->raw_data_len > 0 ? duid->raw_data : NULL,
1257                                                     duid->raw_data_len);
1258                 if (r < 0)
1259                         return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to set DUID: %m");
1260                 break;
1261         }
1262         case DHCP_CLIENT_ID_MAC: {
1263                 const uint8_t *hw_addr = link->hw_addr.addr.bytes;
1264                 size_t hw_addr_len = link->hw_addr.length;
1265
1266                 if (link->iftype == ARPHRD_INFINIBAND && hw_addr_len == INFINIBAND_ALEN) {
1267                         /* set_client_id expects only last 8 bytes of an IB address */
1268                         hw_addr += INFINIBAND_ALEN - 8;
1269                         hw_addr_len -= INFINIBAND_ALEN - 8;
1270                 }
1271
1272                 r = sd_dhcp_client_set_client_id(link->dhcp_client,
1273                                                  link->iftype,
1274                                                  hw_addr,
1275                                                  hw_addr_len);
1276                 if (r < 0)
1277                         return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to set client ID: %m");
1278                 break;
1279         }
1280         default:
1281                 assert_not_reached("Unknown client identifier type.");
1282         }
1283
1284         return 0;
1285 }
1286
1287 static int dhcp4_configure_duid(Link *link) {
1288         assert(link);
1289
1290         if (!IN_SET(link->network->dhcp_client_identifier, DHCP_CLIENT_ID_DUID, DHCP_CLIENT_ID_DUID_ONLY))
1291                 return 1;
1292
1293         return dhcp_configure_duid(link, link_get_dhcp4_duid(link));
1294 }
1295
1296 static int dhcp4_set_request_address(Link *link) {
1297         Address *a;
1298
1299         assert(link);
1300         assert(link->network);
1301         assert(link->dhcp_client);
1302
1303         if (!FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DHCP))
1304                 return 0;
1305
1306         SET_FOREACH(a, link->addresses_foreign) {
1307                 if (a->family != AF_INET)
1308                         continue;
1309                 if (link_address_is_dynamic(link, a))
1310                         break;
1311         }
1312
1313         if (!a)
1314                 return 0;
1315
1316         log_link_debug(link, "DHCP4 CLIENT: requesting " IPV4_ADDRESS_FMT_STR, IPV4_ADDRESS_FMT_VAL(a->in_addr.in));
1317
1318         return sd_dhcp_client_set_request_address(link->dhcp_client, &a->in_addr.in);
1319 }
1320
1321 static bool link_needs_dhcp_broadcast(Link *link) {
1322         const char *val;
1323         int r;
1324
1325         assert(link);
1326         assert(link->network);
1327
1328         /* Return the setting in DHCP[4].RequestBroadcast if specified. Otherwise return the device property
1329          * ID_NET_DHCP_BROADCAST setting, which may be set for interfaces requiring that the DHCPOFFER message
1330          * is being broadcast because they can't  handle unicast messages while not fully configured.
1331          * If neither is set or a failure occurs, return false, which is the default for this flag.
1332          */
1333         r = link->network->dhcp_broadcast;
1334         if (r < 0 && link->sd_device && sd_device_get_property_value(link->sd_device, "ID_NET_DHCP_BROADCAST", &val) >= 0) {
1335                 r = parse_boolean(val);
1336                 if (r < 0)
1337                         log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to parse ID_NET_DHCP_BROADCAST, ignoring: %m");
1338                 else
1339                         log_link_debug(link, "DHCP4 CLIENT: Detected ID_NET_DHCP_BROADCAST='%d'.", r);
1340
1341         }
1342         return r == true;
1343 }
1344
1345 int dhcp4_configure(Link *link) {
1346         sd_dhcp_option *send_option;
1347         void *request_options;
1348         int r;
1349
1350         assert(link);
1351         assert(link->network);
1352
1353         if (!link_dhcp4_enabled(link))
1354                 return 0;
1355
1356         if (link->dhcp_client)
1357                 return -EBUSY; /* Already configured. */
1358
1359         r = dhcp4_configure_duid(link);
1360         if (r <= 0)
1361                 return r;
1362
1363         r = sd_dhcp_client_new(&link->dhcp_client, link->network->dhcp_anonymize);
1364         if (r < 0)
1365                 return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to allocate DHCP4 client: %m");
1366
1367         r = sd_dhcp_client_attach_event(link->dhcp_client, link->manager->event, 0);
1368         if (r < 0)
1369                 return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to attach event to DHCP4 client: %m");
1370
1371         r = sd_dhcp_client_set_mac(link->dhcp_client,
1372                                    link->hw_addr.addr.bytes,
1373                                    link->bcast_addr.length > 0 ? link->bcast_addr.addr.bytes : NULL,
1374                                    link->hw_addr.length, link->iftype);
1375         if (r < 0)
1376                 return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to set MAC address: %m");
1377
1378         r = sd_dhcp_client_set_ifindex(link->dhcp_client, link->ifindex);
1379         if (r < 0)
1380                 return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to set ifindex: %m");
1381
1382         r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp4_handler, link);
1383         if (r < 0)
1384                 return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to set callback: %m");
1385
1386         r = sd_dhcp_client_set_request_broadcast(link->dhcp_client, link_needs_dhcp_broadcast(link));
1387         if (r < 0)
1388                 return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to set request flag for broadcast: %m");
1389
1390         if (link->mtu > 0) {
1391                 r = sd_dhcp_client_set_mtu(link->dhcp_client, link->mtu);
1392                 if (r < 0)
1393                         return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to set MTU: %m");
1394         }
1395
1396         if (!link->network->dhcp_anonymize) {
1397                 if (link->network->dhcp_use_mtu) {
1398                         r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_INTERFACE_MTU);
1399                         if (r < 0)
1400                                 return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to set request flag for MTU: %m");
1401                 }
1402
1403                 if (link->network->dhcp_use_routes) {
1404                         r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_STATIC_ROUTE);
1405                         if (r < 0)
1406                                 return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to set request flag for static route: %m");
1407
1408                         r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_CLASSLESS_STATIC_ROUTE);
1409                         if (r < 0)
1410                                 return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to set request flag for classless static route: %m");
1411                 }
1412
1413                 if (link->network->dhcp_use_domains != DHCP_USE_DOMAINS_NO) {
1414                         r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_DOMAIN_SEARCH_LIST);
1415                         if (r < 0)
1416                                 return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to set request flag for domain search list: %m");
1417                 }
1418
1419                 if (link->network->dhcp_use_ntp) {
1420                         r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_NTP_SERVER);
1421                         if (r < 0)
1422                                 return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to set request flag for NTP server: %m");
1423                 }
1424
1425                 if (link->network->dhcp_use_sip) {
1426                         r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_SIP_SERVER);
1427                         if (r < 0)
1428                                 return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to set request flag for SIP server: %m");
1429                 }
1430
1431                 if (link->network->dhcp_use_timezone) {
1432                         r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_NEW_TZDB_TIMEZONE);
1433                         if (r < 0)
1434                                 return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to set request flag for timezone: %m");
1435                 }
1436
1437                 SET_FOREACH(request_options, link->network->dhcp_request_options) {
1438                         uint32_t option = PTR_TO_UINT32(request_options);
1439
1440                         r = sd_dhcp_client_set_request_option(link->dhcp_client, option);
1441                         if (r < 0)
1442                                 return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to set request flag for '%u': %m", option);
1443                 }
1444
1445                 ORDERED_HASHMAP_FOREACH(send_option, link->network->dhcp_client_send_options) {
1446                         r = sd_dhcp_client_add_option(link->dhcp_client, send_option);
1447                         if (r == -EEXIST)
1448                                 continue;
1449                         if (r < 0)
1450                                 return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to set send option: %m");
1451                 }
1452
1453                 ORDERED_HASHMAP_FOREACH(send_option, link->network->dhcp_client_send_vendor_options) {
1454                         r = sd_dhcp_client_add_vendor_option(link->dhcp_client, send_option);
1455                         if (r == -EEXIST)
1456                                 continue;
1457                         if (r < 0)
1458                                 return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to set send option: %m");
1459                 }
1460
1461                 r = dhcp4_set_hostname(link);
1462                 if (r < 0)
1463                         return r;
1464
1465                 if (link->network->dhcp_vendor_class_identifier) {
1466                         r = sd_dhcp_client_set_vendor_class_identifier(link->dhcp_client,
1467                                                                        link->network->dhcp_vendor_class_identifier);
1468                         if (r < 0)
1469                                 return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to set vendor class identifier: %m");
1470                 }
1471
1472                 if (link->network->dhcp_mudurl) {
1473                         r = sd_dhcp_client_set_mud_url(link->dhcp_client, link->network->dhcp_mudurl);
1474                         if (r < 0)
1475                                 return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to set MUD URL: %m");
1476                 }
1477
1478                 if (link->network->dhcp_user_class) {
1479                         r = sd_dhcp_client_set_user_class(link->dhcp_client, link->network->dhcp_user_class);
1480                         if (r < 0)
1481                                 return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to set user class: %m");
1482                 }
1483         }
1484
1485         if (link->network->dhcp_client_port > 0) {
1486                 r = sd_dhcp_client_set_client_port(link->dhcp_client, link->network->dhcp_client_port);
1487                 if (r < 0)
1488                         return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to set listen port: %m");
1489         }
1490
1491         if (link->network->dhcp_max_attempts > 0) {
1492                 r = sd_dhcp_client_set_max_attempts(link->dhcp_client, link->network->dhcp_max_attempts);
1493                 if (r < 0)
1494                         return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to set max attempts: %m");
1495         }
1496
1497         if (link->network->dhcp_ip_service_type > 0) {
1498                 r = sd_dhcp_client_set_service_type(link->dhcp_client, link->network->dhcp_ip_service_type);
1499                 if (r < 0)
1500                         return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to set IP service type: %m");
1501         }
1502
1503         if (link->network->dhcp_fallback_lease_lifetime > 0) {
1504                 r = sd_dhcp_client_set_fallback_lease_lifetime(link->dhcp_client, link->network->dhcp_fallback_lease_lifetime);
1505                 if (r < 0)
1506                         return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed set to lease lifetime: %m");
1507         }
1508
1509         r = dhcp4_set_request_address(link);
1510         if (r < 0)
1511                 return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to set initial DHCPv4 address: %m");
1512
1513         r = dhcp4_configure_dad(link);
1514         if (r < 0)
1515                 return log_link_warning_errno(link, r, "DHCP4 CLIENT: Failed to configure service type: %m");
1516
1517         return dhcp4_set_client_identifier(link);
1518 }
1519
1520 int dhcp4_update_mac(Link *link) {
1521         int r;
1522
1523         assert(link);
1524
1525         if (!link->dhcp_client)
1526                 return 0;
1527
1528         r = sd_dhcp_client_set_mac(link->dhcp_client, link->hw_addr.addr.bytes,
1529                                    link->bcast_addr.length > 0 ? link->bcast_addr.addr.bytes : NULL,
1530                                    link->hw_addr.length, link->iftype);
1531         if (r < 0)
1532                 return r;
1533
1534         r = dhcp4_set_client_identifier(link);
1535         if (r < 0)
1536                 return r;
1537
1538         r = dhcp4_dad_update_mac(link);
1539         if (r < 0)
1540                 return r;
1541
1542         return 0;
1543 }
1544
1545 int dhcp4_start(Link *link) {
1546         assert(link);
1547
1548         if (!link->dhcp_client)
1549                 return 0;
1550
1551         if (sd_dhcp_client_is_running(link->dhcp_client) > 0)
1552                 return 0;
1553
1554         log_link_debug(link, "Acquiring DHCPv4 lease");
1555
1556         return sd_dhcp_client_start(link->dhcp_client);
1557 }
1558
1559 int config_parse_dhcp_max_attempts(
1560                 const char *unit,
1561                 const char *filename,
1562                 unsigned line,
1563                 const char *section,
1564                 unsigned section_line,
1565                 const char *lvalue,
1566                 int ltype,
1567                 const char *rvalue,
1568                 void *data,
1569                 void *userdata) {
1570
1571         Network *network = data;
1572         uint64_t a;
1573         int r;
1574
1575         assert(network);
1576         assert(lvalue);
1577         assert(rvalue);
1578
1579         if (isempty(rvalue)) {
1580                 network->dhcp_max_attempts = 0;
1581                 return 0;
1582         }
1583
1584         if (streq(rvalue, "infinity")) {
1585                 network->dhcp_max_attempts = UINT64_MAX;
1586                 return 0;
1587         }
1588
1589         r = safe_atou64(rvalue, &a);
1590         if (r < 0) {
1591                 log_syntax(unit, LOG_WARNING, filename, line, r,
1592                            "Failed to parse DHCP maximum attempts, ignoring: %s", rvalue);
1593                 return 0;
1594         }
1595
1596         if (a == 0) {
1597                 log_syntax(unit, LOG_WARNING, filename, line, 0,
1598                            "%s= must be positive integer or 'infinity', ignoring: %s", lvalue, rvalue);
1599                 return 0;
1600         }
1601
1602         network->dhcp_max_attempts = a;
1603
1604         return 0;
1605 }
1606
1607 int config_parse_dhcp_acl_ip_address(
1608                 const char *unit,
1609                 const char *filename,
1610                 unsigned line,
1611                 const char *section,
1612                 unsigned section_line,
1613                 const char *lvalue,
1614                 int ltype,
1615                 const char *rvalue,
1616                 void *data,
1617                 void *userdata) {
1618
1619         Network *network = data;
1620         Set **acl;
1621         int r;
1622
1623         assert(filename);
1624         assert(lvalue);
1625         assert(rvalue);
1626         assert(data);
1627
1628         acl = STR_IN_SET(lvalue, "DenyList", "BlackList") ? &network->dhcp_deny_listed_ip : &network->dhcp_allow_listed_ip;
1629
1630         if (isempty(rvalue)) {
1631                 *acl = set_free(*acl);
1632                 return 0;
1633         }
1634
1635         for (const char *p = rvalue;;) {
1636                 _cleanup_free_ char *n = NULL;
1637                 union in_addr_union ip;
1638
1639                 r = extract_first_word(&p, &n, NULL, 0);
1640                 if (r == -ENOMEM)
1641                         return log_oom();
1642                 if (r < 0) {
1643                         log_syntax(unit, LOG_WARNING, filename, line, r,
1644                                    "Failed to parse DHCP '%s=' IP address, ignoring assignment: %s",
1645                                    lvalue, rvalue);
1646                         return 0;
1647                 }
1648                 if (r == 0)
1649                         return 0;
1650
1651                 r = in_addr_from_string(AF_INET, n, &ip);
1652                 if (r < 0) {
1653                         log_syntax(unit, LOG_WARNING, filename, line, r,
1654                                    "DHCP '%s=' IP address is invalid, ignoring assignment: %s", lvalue, n);
1655                         continue;
1656                 }
1657
1658                 r = set_ensure_put(acl, NULL, UINT32_TO_PTR(ip.in.s_addr));
1659                 if (r < 0)
1660                         log_syntax(unit, LOG_WARNING, filename, line, r,
1661                                    "Failed to store DHCP '%s=' IP address '%s', ignoring assignment: %m", lvalue, n);
1662         }
1663 }
1664
1665 int config_parse_dhcp_ip_service_type(
1666                 const char *unit,
1667                 const char *filename,
1668                 unsigned line,
1669                 const char *section,
1670                 unsigned section_line,
1671                 const char *lvalue,
1672                 int ltype,
1673                 const char *rvalue,
1674                 void *data,
1675                 void *userdata) {
1676
1677         assert(filename);
1678         assert(lvalue);
1679         assert(rvalue);
1680
1681         if (streq(rvalue, "CS4"))
1682                 *((int *)data) = IPTOS_CLASS_CS4;
1683         else if (streq(rvalue, "CS6"))
1684                 *((int *)data) = IPTOS_CLASS_CS6;
1685         else
1686                 log_syntax(unit, LOG_WARNING, filename, line, 0,
1687                            "Failed to parse IPServiceType type '%s', ignoring.", rvalue);
1688
1689         return 0;
1690 }
1691
1692 int config_parse_dhcp_mud_url(
1693                 const char *unit,
1694                 const char *filename,
1695                 unsigned line,
1696                 const char *section,
1697                 unsigned section_line,
1698                 const char *lvalue,
1699                 int ltype,
1700                 const char *rvalue,
1701                 void *data,
1702                 void *userdata) {
1703
1704         _cleanup_free_ char *unescaped = NULL;
1705         Network *network = data;
1706         int r;
1707
1708         assert(filename);
1709         assert(lvalue);
1710         assert(rvalue);
1711
1712         if (isempty(rvalue)) {
1713                 network->dhcp_mudurl = mfree(network->dhcp_mudurl);
1714                 return 0;
1715         }
1716
1717         r = cunescape(rvalue, 0, &unescaped);
1718         if (r < 0) {
1719                 log_syntax(unit, LOG_WARNING, filename, line, r,
1720                            "Failed to Failed to unescape MUD URL, ignoring: %s", rvalue);
1721                 return 0;
1722         }
1723
1724         if (!http_url_is_valid(unescaped) || strlen(unescaped) > 255) {
1725                 log_syntax(unit, LOG_WARNING, filename, line, 0,
1726                            "Failed to parse MUD URL '%s', ignoring: %m", rvalue);
1727
1728                 return 0;
1729         }
1730
1731         return free_and_strdup_warn(&network->dhcp_mudurl, unescaped);
1732 }
1733
1734 int config_parse_dhcp_fallback_lease_lifetime(const char *unit,
1735                 const char *filename,
1736                 unsigned line,
1737                 const char *section,
1738                 unsigned section_line,
1739                 const char *lvalue,
1740                 int ltype,
1741                 const char *rvalue,
1742                 void *data,
1743                 void *userdata) {
1744         Network *network = userdata;
1745         uint32_t k;
1746
1747         assert(filename);
1748         assert(section);
1749         assert(lvalue);
1750         assert(rvalue);
1751         assert(data);
1752
1753         if (isempty(rvalue)) {
1754                 network->dhcp_fallback_lease_lifetime = 0;
1755                 return 0;
1756         }
1757
1758         /* We accept only "forever" or "infinity". */
1759         if (STR_IN_SET(rvalue, "forever", "infinity"))
1760                 k = CACHE_INFO_INFINITY_LIFE_TIME;
1761         else {
1762                 log_syntax(unit, LOG_WARNING, filename, line, 0,
1763                            "Invalid LeaseLifetime= value, ignoring: %s", rvalue);
1764                 return 0;
1765         }
1766
1767         network->dhcp_fallback_lease_lifetime = k;
1768
1769         return 0;
1770 }
1771
1772 static const char* const dhcp_client_identifier_table[_DHCP_CLIENT_ID_MAX] = {
1773         [DHCP_CLIENT_ID_MAC] = "mac",
1774         [DHCP_CLIENT_ID_DUID] = "duid",
1775         [DHCP_CLIENT_ID_DUID_ONLY] = "duid-only",
1776 };
1777
1778 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING(dhcp_client_identifier, DHCPClientIdentifier);
1779 DEFINE_CONFIG_PARSE_ENUM(config_parse_dhcp_client_identifier, dhcp_client_identifier, DHCPClientIdentifier,
1780                          "Failed to parse client identifier type");