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 "alloc-util.h"
   9 #include "dhcp-client-internal.h"
  10 #include "hostname-setup.h"
  11 #include "hostname-util.h"
  12 #include "parse-util.h"
  13 #include "network-internal.h"
  14 #include "networkd-address.h"
  15 #include "networkd-dhcp-prefix-delegation.h"
  16 #include "networkd-dhcp4-bus.h"
  17 #include "networkd-dhcp4.h"
  18 #include "networkd-ipv4acd.h"
  19 #include "networkd-link.h"
  20 #include "networkd-manager.h"
  21 #include "networkd-network.h"
  22 #include "networkd-nexthop.h"
  23 #include "networkd-queue.h"
  24 #include "networkd-route.h"
  25 #include "networkd-setlink.h"
  26 #include "networkd-state-file.h"
  27 #include "string-table.h"
  28 #include "strv.h"
  29 #include "sysctl-util.h"
  30
  31 void network_adjust_dhcp4(Network *network) {
  32         assert(network);
  33
  34         if (!FLAGS_SET(network->dhcp, ADDRESS_FAMILY_IPV4))
  35                 return;
  36
  37         if (network->dhcp_use_gateway < 0)
  38                 network->dhcp_use_gateway = network->dhcp_use_routes;
  39
  40         /* RFC7844 section 3.: MAY contain the Client Identifier option
  41          * Section 3.5: clients MUST use client identifiers based solely on the link-layer address
  42          * NOTE: Using MAC, as it does not reveal extra information, and some servers might not answer
  43          * if this option is not sent */
  44         if (network->dhcp_anonymize &&
  45             network->dhcp_client_identifier >= 0 &&
  46             network->dhcp_client_identifier != DHCP_CLIENT_ID_MAC) {
  47                 log_warning("%s: ClientIdentifier= is set, although Anonymize=yes. Using ClientIdentifier=mac.",
  48                             network->filename);
  49                 network->dhcp_client_identifier = DHCP_CLIENT_ID_MAC;
  50         }
  51
  52         if (network->dhcp_client_identifier < 0)
  53                 network->dhcp_client_identifier = network->dhcp_anonymize ? DHCP_CLIENT_ID_MAC : DHCP_CLIENT_ID_DUID;
  54
  55         /* By default, RapidCommit= is enabled when Anonymize=no and neither AllowList= nor DenyList= is specified. */
  56         if (network->dhcp_use_rapid_commit < 0)
  57                 network->dhcp_use_rapid_commit =
  58                         !network->dhcp_anonymize &&
  59                         set_isempty(network->dhcp_allow_listed_ip) &&
  60                         set_isempty(network->dhcp_deny_listed_ip);
  61 }
  62
  63 static int dhcp4_prefix_covers(
  64                 Link *link,
  65                 const struct in_addr *in_prefix,
  66                 uint8_t in_prefixlen) {
  67
  68         struct in_addr prefix;
  69         uint8_t prefixlen;
  70         int r;
  71
  72         assert(link);
  73         assert(link->dhcp_lease);
  74         assert(in_prefix);
  75
  76         /* Return true if the input address or address range is in the assigned network.
  77          * E.g. if the DHCP server provides 192.168.0.100/24, then this returns true for the address or
  78          * address range in 192.168.0.0/24, and returns false otherwise. */
  79
  80         r = sd_dhcp_lease_get_prefix(link->dhcp_lease, &prefix, &prefixlen);
  81         if (r < 0)
  82                 return r;
  83
  84         return in4_addr_prefix_covers_full(&prefix, prefixlen, in_prefix, in_prefixlen);
  85 }
  86
  87 static int dhcp4_get_router(Link *link, struct in_addr *ret) {
  88         const struct in_addr *routers;
  89         int r;
  90
  91         assert(link);
  92         assert(link->dhcp_lease);
  93         assert(ret);
  94
  95         r = sd_dhcp_lease_get_router(link->dhcp_lease, &routers);
  96         if (r < 0)
  97                 return r;
  98
  99         /* The router option may provide multiple routers, We only use the first non-null address. */
 100
 101         FOREACH_ARRAY(router, routers, r) {
 102                 if (in4_addr_is_null(router))
 103                         continue;
 104
 105                 *ret = *router;
 106                 return 0;
 107         }
 108
 109         return -ENODATA;
 110 }
 111
 112 static int dhcp4_get_classless_static_or_static_routes(Link *link, sd_dhcp_route ***ret_routes, size_t *ret_num) {
 113         _cleanup_free_ sd_dhcp_route **routes = NULL;
 114         int r;
 115
 116         assert(link);
 117         assert(link->dhcp_lease);
 118
 119         /* If the DHCP server returns both a Classless Static Routes option and a Static Routes option,
 120          * the DHCP client MUST ignore the Static Routes option. */
 121
 122         r = sd_dhcp_lease_get_classless_routes(link->dhcp_lease, &routes);
 123         if (r >= 0) {
 124                 assert(r > 0);
 125                 if (ret_routes)
 126                         *ret_routes = TAKE_PTR(routes);
 127                 if (ret_num)
 128                         *ret_num = r;
 129                 return 1; /* classless */
 130         } else if (r != -ENODATA)
 131                 return r;
 132
 133         r = sd_dhcp_lease_get_static_routes(link->dhcp_lease, &routes);
 134         if (r < 0)
 135                 return r;
 136
 137         assert(r > 0);
 138         if (ret_routes)
 139                 *ret_routes = TAKE_PTR(routes);
 140         if (ret_num)
 141                 *ret_num = r;
 142         return 0; /* static */
 143 }
 144
 145 static int dhcp4_find_gateway_for_destination(
 146                 Link *link,
 147                 const struct in_addr *destination,
 148                 uint8_t prefixlength,
 149                 bool allow_null,
 150                 struct in_addr *ret) {
 151
 152         _cleanup_free_ sd_dhcp_route **routes = NULL;
 153         size_t n_routes = 0;
 154         bool is_classless, reachable;
 155         uint8_t max_prefixlen = UINT8_MAX;
 156         struct in_addr gw;
 157         int r;
 158
 159         assert(link);
 160         assert(link->dhcp_lease);
 161         assert(destination);
 162         assert(ret);
 163
 164         /* This tries to find the most suitable gateway for an address or address range.
 165          * E.g. if the server provides the default gateway 192.168.0.1 and a classless static route for
 166          * 8.0.0.0/8 with gateway 192.168.0.2, then this returns 192.168.0.2 for 8.8.8.8/32, and 192.168.0.1
 167          * for 9.9.9.9/32. If 'allow_null' flag is set, and the input address or address range is in the
 168          * assigned network, then the default gateway will be ignored and the null address will be returned
 169          * unless a matching non-default gateway found. */
 170
 171         r = dhcp4_prefix_covers(link, destination, prefixlength);
 172         if (r < 0)
 173                 return r;
 174         reachable = r > 0;
 175
 176         r = dhcp4_get_classless_static_or_static_routes(link, &routes, &n_routes);
 177         if (r < 0 && r != -ENODATA)
 178                 return r;
 179         is_classless = r > 0;
 180
 181         /* First, find most suitable gateway. */
 182         FOREACH_ARRAY(e, routes, n_routes) {
 183                 struct in_addr dst;
 184                 uint8_t len;
 185
 186                 r = sd_dhcp_route_get_destination(*e, &dst);
 187                 if (r < 0)
 188                         return r;
 189
 190                 r = sd_dhcp_route_get_destination_prefix_length(*e, &len);
 191                 if (r < 0)
 192                         return r;
 193
 194                 r = in4_addr_prefix_covers_full(&dst, len, destination, prefixlength);
 195                 if (r < 0)
 196                         return r;
 197                 if (r == 0)
 198                         continue;
 199
 200                 if (max_prefixlen != UINT8_MAX && max_prefixlen > len)
 201                         continue;
 202
 203                 r = sd_dhcp_route_get_gateway(*e, &gw);
 204                 if (r < 0)
 205                         return r;
 206
 207                 max_prefixlen = len;
 208         }
 209
 210         /* Found a suitable gateway in classless static routes or static routes. */
 211         if (max_prefixlen != UINT8_MAX) {
 212                 if (max_prefixlen == 0 && reachable && allow_null)
 213                         /* Do not return the default gateway, if the destination is in the assigned network. */
 214                         *ret = (struct in_addr) {};
 215                 else
 216                         *ret = gw;
 217                 return 0;
 218         }
 219
 220         /* When the destination is in the assigned network, return the null address if allowed. */
 221         if (reachable && allow_null) {
 222                 *ret = (struct in_addr) {};
 223                 return 0;
 224         }
 225
 226         /* According to RFC 3442: If the DHCP server returns both a Classless Static Routes option and
 227          * a Router option, the DHCP client MUST ignore the Router option. */
 228         if (!is_classless) {
 229                 r = dhcp4_get_router(link, ret);
 230                 if (r >= 0)
 231                         return 0;
 232                 if (r != -ENODATA)
 233                         return r;
 234         }
 235
 236         if (!reachable)
 237                 return -EHOSTUNREACH; /* Not in the same network, cannot reach the destination. */
 238
 239         assert(!allow_null);
 240         return -ENODATA; /* No matching gateway found. */
 241 }
 242
 243 static int dhcp4_remove_address_and_routes(Link *link, bool only_marked) {
 244         Address *address;
 245         Route *route;
 246         int ret = 0;
 247
 248         assert(link);
 249
 250         SET_FOREACH(route, link->routes) {
 251                 if (route->source != NETWORK_CONFIG_SOURCE_DHCP4)
 252                         continue;
 253                 if (only_marked && !route_is_marked(route))
 254                         continue;
 255
 256                 RET_GATHER(ret, route_remove(route));
 257                 route_cancel_request(route, link);
 258         }
 259
 260         SET_FOREACH(address, link->addresses) {
 261                 if (address->source != NETWORK_CONFIG_SOURCE_DHCP4)
 262                         continue;
 263                 if (only_marked && !address_is_marked(address))
 264                         continue;
 265
 266                 RET_GATHER(ret, address_remove_and_cancel(address, link));
 267         }
 268
 269         return ret;
 270 }
 271
 272 static int dhcp4_address_get(Link *link, Address **ret) {
 273         Address *address;
 274
 275         assert(link);
 276
 277         SET_FOREACH(address, link->addresses) {
 278                 if (address->source != NETWORK_CONFIG_SOURCE_DHCP4)
 279                         continue;
 280                 if (address_is_marked(address))
 281                         continue;
 282
 283                 if (ret)
 284                         *ret = address;
 285                 return 0;
 286         }
 287
 288         return -ENOENT;
 289 }
 290
 291 static int dhcp4_address_ready_callback(Address *address) {
 292         assert(address);
 293         assert(address->link);
 294
 295         /* Do not call this again. */
 296         address->callback = NULL;
 297
 298         return dhcp4_check_ready(address->link);
 299 }
 300
 301 int dhcp4_check_ready(Link *link) {
 302         Address *address;
 303         int r;
 304
 305         assert(link);
 306
 307         if (link->dhcp4_messages > 0) {
 308                 log_link_debug(link, "%s(): DHCPv4 address and routes are not set.", __func__);
 309                 return 0;
 310         }
 311
 312         if (dhcp4_address_get(link, &address) < 0) {
 313                 log_link_debug(link, "%s(): DHCPv4 address is not set.", __func__);
 314                 return 0;
 315         }
 316
 317         if (!address_is_ready(address)) {
 318                 log_link_debug(link, "%s(): DHCPv4 address is not ready.", __func__);
 319                 address->callback = dhcp4_address_ready_callback;
 320                 return 0;
 321         }
 322
 323         link->dhcp4_configured = true;
 324         log_link_debug(link, "DHCPv4 address and routes set.");
 325
 326         /* New address and routes are configured now. Let's release old lease. */
 327         r = dhcp4_remove_address_and_routes(link, /* only_marked = */ true);
 328         if (r < 0)
 329                 return r;
 330
 331         r = sd_ipv4ll_stop(link->ipv4ll);
 332         if (r < 0)
 333                 return log_link_warning_errno(link, r, "Failed to drop IPv4 link-local address: %m");
 334
 335         link_check_ready(link);
 336         return 0;
 337 }
 338
 339 static int dhcp4_route_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, Route *route) {
 340         int r;
 341
 342         assert(m);
 343         assert(link);
 344
 345         r = route_configure_handler_internal(rtnl, m, link, route, "Could not set DHCPv4 route");
 346         if (r <= 0)
 347                 return r;
 348
 349         r = dhcp4_check_ready(link);
 350         if (r < 0)
 351                 link_enter_failed(link);
 352
 353         return 1;
 354 }
 355
 356 static int dhcp4_request_route(Route *route, Link *link) {
 357         struct in_addr server;
 358         Route *existing;
 359         int r;
 360
 361         assert(route);
 362         assert(link);
 363         assert(link->network);
 364         assert(link->dhcp_lease);
 365
 366         r = sd_dhcp_lease_get_server_identifier(link->dhcp_lease, &server);
 367         if (r < 0)
 368                 return log_link_debug_errno(link, r, "Failed to get DHCP server IP address: %m");
 369
 370         route->source = NETWORK_CONFIG_SOURCE_DHCP4;
 371         route->provider.in = server;
 372         route->family = AF_INET;
 373         if (!route->protocol_set)
 374                 route->protocol = RTPROT_DHCP;
 375         if (!route->priority_set)
 376                 route->priority = link->network->dhcp_route_metric;
 377         if (!route->table_set)
 378                 route->table = link_get_dhcp4_route_table(link);
 379         r = route_metric_set(&route->metric, RTAX_MTU, link->network->dhcp_route_mtu);
 380         if (r < 0)
 381                 return r;
 382         r = route_metric_set(&route->metric, RTAX_INITCWND, link->network->dhcp_initial_congestion_window);
 383         if (r < 0)
 384                 return r;
 385         r = route_metric_set(&route->metric, RTAX_INITRWND, link->network->dhcp_advertised_receive_window);
 386         if (r < 0)
 387                 return r;
 388         r = route_metric_set(&route->metric, RTAX_QUICKACK, link->network->dhcp_quickack);
 389         if (r < 0)
 390                 return r;
 391
 392         r = route_adjust_nexthops(route, link);
 393         if (r < 0)
 394                 return r;
 395
 396         if (route_get(NULL, link, route, &existing) < 0) /* This is a new route. */
 397                 link->dhcp4_configured = false;
 398         else
 399                 route_unmark(existing);
 400
 401         return link_request_route(link, route, &link->dhcp4_messages, dhcp4_route_handler);
 402 }
 403
 404 static bool link_prefixroute(Link *link) {
 405         return !link->network->dhcp_route_table_set ||
 406                 link->network->dhcp_route_table == RT_TABLE_MAIN;
 407 }
 408
 409 static int dhcp4_request_prefix_route(Link *link) {
 410         _cleanup_(route_freep) Route *route = NULL;
 411         int r;
 412
 413         assert(link);
 414         assert(link->dhcp_lease);
 415
 416         if (link_prefixroute(link))
 417                 /* When true, the route will be created by kernel. See dhcp4_update_address(). */
 418                 return 0;
 419
 420         r = route_new(&route);
 421         if (r < 0)
 422                 return r;
 423
 424         route->scope = RT_SCOPE_LINK;
 425
 426         r = sd_dhcp_lease_get_prefix(link->dhcp_lease, &route->dst.in, &route->dst_prefixlen);
 427         if (r < 0)
 428                 return r;
 429
 430         r = sd_dhcp_lease_get_address(link->dhcp_lease, &route->prefsrc.in);
 431         if (r < 0)
 432                 return r;
 433
 434         return dhcp4_request_route(route, link);
 435 }
 436
 437 static int dhcp4_request_route_to_gateway(Link *link, const struct in_addr *gw) {
 438         _cleanup_(route_freep) Route *route = NULL;
 439         struct in_addr address;
 440         int r;
 441
 442         assert(link);
 443         assert(link->dhcp_lease);
 444         assert(gw);
 445
 446         r = sd_dhcp_lease_get_address(link->dhcp_lease, &address);
 447         if (r < 0)
 448                 return r;
 449
 450         r = route_new(&route);
 451         if (r < 0)
 452                 return r;
 453
 454         route->dst.in = *gw;
 455         route->dst_prefixlen = 32;
 456         route->prefsrc.in = address;
 457         route->scope = RT_SCOPE_LINK;
 458
 459         return dhcp4_request_route(route, link);
 460 }
 461
 462 static int dhcp4_request_route_auto(
 463                 Route *route,
 464                 Link *link,
 465                 const struct in_addr *gw) {
 466
 467         struct in_addr address;
 468         int r;
 469
 470         assert(route);
 471         assert(link);
 472         assert(link->dhcp_lease);
 473         assert(gw);
 474
 475         r = sd_dhcp_lease_get_address(link->dhcp_lease, &address);
 476         if (r < 0)
 477                 return r;
 478
 479         if (in4_addr_is_localhost(&route->dst.in)) {
 480                 if (in4_addr_is_set(gw))
 481                         log_link_debug(link, "DHCP: requested route destination "IPV4_ADDRESS_FMT_STR"/%u is localhost, "
 482                                        "ignoring gateway address "IPV4_ADDRESS_FMT_STR,
 483                                        IPV4_ADDRESS_FMT_VAL(route->dst.in), route->dst_prefixlen, IPV4_ADDRESS_FMT_VAL(*gw));
 484
 485                 route->scope = RT_SCOPE_HOST;
 486                 route->nexthop.family = AF_UNSPEC;
 487                 route->nexthop.gw = IN_ADDR_NULL;
 488                 route->prefsrc = IN_ADDR_NULL;
 489
 490         } else if (in4_addr_equal(&route->dst.in, &address)) {
 491                 if (in4_addr_is_set(gw))
 492                         log_link_debug(link, "DHCP: requested route destination "IPV4_ADDRESS_FMT_STR"/%u is equivalent to the acquired address, "
 493                                        "ignoring gateway address "IPV4_ADDRESS_FMT_STR,
 494                                        IPV4_ADDRESS_FMT_VAL(route->dst.in), route->dst_prefixlen, IPV4_ADDRESS_FMT_VAL(*gw));
 495
 496                 route->scope = RT_SCOPE_HOST;
 497                 route->nexthop.family = AF_UNSPEC;
 498                 route->nexthop.gw = IN_ADDR_NULL;
 499                 route->prefsrc.in = address;
 500
 501         } else if (in4_addr_is_null(gw)) {
 502                 r = dhcp4_prefix_covers(link, &route->dst.in, route->dst_prefixlen);
 503                 if (r < 0)
 504                         return r;
 505                 if (r == 0 && DEBUG_LOGGING) {
 506                         struct in_addr prefix;
 507                         uint8_t prefixlen;
 508
 509                         r = sd_dhcp_lease_get_prefix(link->dhcp_lease, &prefix, &prefixlen);
 510                         if (r < 0)
 511                                 return r;
 512
 513                         log_link_debug(link, "DHCP: requested route destination "IPV4_ADDRESS_FMT_STR"/%u is not in the assigned network "
 514                                        IPV4_ADDRESS_FMT_STR"/%u, but no gateway is specified, using 'link' scope.",
 515                                        IPV4_ADDRESS_FMT_VAL(route->dst.in), route->dst_prefixlen,
 516                                        IPV4_ADDRESS_FMT_VAL(prefix), prefixlen);
 517                 }
 518
 519                 route->scope = RT_SCOPE_LINK;
 520                 route->nexthop.family = AF_UNSPEC;
 521                 route->nexthop.gw = IN_ADDR_NULL;
 522                 route->prefsrc.in = address;
 523
 524         } else {
 525                 r = dhcp4_request_route_to_gateway(link, gw);
 526                 if (r < 0)
 527                         return r;
 528
 529                 route->scope = RT_SCOPE_UNIVERSE;
 530                 route->nexthop.family = AF_INET;
 531                 route->nexthop.gw.in = *gw;
 532                 route->prefsrc.in = address;
 533         }
 534
 535         return dhcp4_request_route(route, link);
 536 }
 537
 538 static int dhcp4_request_classless_static_or_static_routes(Link *link) {
 539         _cleanup_free_ sd_dhcp_route **routes = NULL;
 540         size_t n_routes;
 541         int r;
 542
 543         assert(link);
 544         assert(link->dhcp_lease);
 545
 546         if (!link->network->dhcp_use_routes)
 547                 return 0;
 548
 549         r = dhcp4_get_classless_static_or_static_routes(link, &routes, &n_routes);
 550         if (r == -ENODATA)
 551                 return 0;
 552         if (r < 0)
 553                 return r;
 554
 555         FOREACH_ARRAY(e, routes, n_routes) {
 556                 _cleanup_(route_freep) Route *route = NULL;
 557                 struct in_addr gw;
 558
 559                 r = route_new(&route);
 560                 if (r < 0)
 561                         return r;
 562
 563                 r = sd_dhcp_route_get_gateway(*e, &gw);
 564                 if (r < 0)
 565                         return r;
 566
 567                 r = sd_dhcp_route_get_destination(*e, &route->dst.in);
 568                 if (r < 0)
 569                         return r;
 570
 571                 r = sd_dhcp_route_get_destination_prefix_length(*e, &route->dst_prefixlen);
 572                 if (r < 0)
 573                         return r;
 574
 575                 r = dhcp4_request_route_auto(route, link, &gw);
 576                 if (r < 0)
 577                         return r;
 578         }
 579
 580         return 0;
 581 }
 582
 583 static int dhcp4_request_default_gateway(Link *link) {
 584         _cleanup_(route_freep) Route *route = NULL;
 585         struct in_addr address, router;
 586         int r;
 587
 588         assert(link);
 589         assert(link->dhcp_lease);
 590
 591         if (!link->network->dhcp_use_gateway)
 592                 return 0;
 593
 594         /* According to RFC 3442: If the DHCP server returns both a Classless Static Routes option and
 595          * a Router option, the DHCP client MUST ignore the Router option. */
 596         if (link->network->dhcp_use_routes &&
 597             dhcp4_get_classless_static_or_static_routes(link, NULL, NULL) > 0)
 598                 return 0;
 599
 600         r = sd_dhcp_lease_get_address(link->dhcp_lease, &address);
 601         if (r < 0)
 602                 return r;
 603
 604         r = dhcp4_get_router(link, &router);
 605         if (r == -ENODATA) {
 606                 log_link_debug(link, "DHCP: No valid router address received from DHCP server.");
 607                 return 0;
 608         }
 609         if (r < 0)
 610                 return r;
 611
 612         /* The dhcp netmask may mask out the gateway. First, add an explicit route for the gateway host
 613          * so that we can route no matter the netmask or existing kernel route tables. */
 614         r = dhcp4_request_route_to_gateway(link, &router);
 615         if (r < 0)
 616                 return r;
 617
 618         r = route_new(&route);
 619         if (r < 0)
 620                 return r;
 621
 622         /* Next, add a default gateway. */
 623         route->nexthop.family = AF_INET;
 624         route->nexthop.gw.in = router;
 625         route->prefsrc.in = address;
 626
 627         return dhcp4_request_route(route, link);
 628 }
 629
 630 static int dhcp4_request_semi_static_routes(Link *link) {
 631         Route *rt;
 632         int r;
 633
 634         assert(link);
 635         assert(link->dhcp_lease);
 636         assert(link->network);
 637
 638         HASHMAP_FOREACH(rt, link->network->routes_by_section) {
 639                 _cleanup_(route_freep) Route *route = NULL;
 640                 struct in_addr gw;
 641
 642                 if (!rt->gateway_from_dhcp_or_ra)
 643                         continue;
 644
 645                 if (rt->nexthop.family != AF_INET)
 646                         continue;
 647
 648                 assert(rt->family == AF_INET);
 649
 650                 r = dhcp4_find_gateway_for_destination(link, &rt->dst.in, rt->dst_prefixlen, /* allow_null = */ false, &gw);
 651                 if (IN_SET(r, -EHOSTUNREACH, -ENODATA)) {
 652                         log_link_debug_errno(link, r, "DHCP: Cannot find suitable gateway for destination %s of semi-static route, ignoring: %m",
 653                                              IN4_ADDR_PREFIX_TO_STRING(&rt->dst.in, rt->dst_prefixlen));
 654                         continue;
 655                 }
 656                 if (r < 0)
 657                         return r;
 658
 659                 r = dhcp4_request_route_to_gateway(link, &gw);
 660                 if (r < 0)
 661                         return r;
 662
 663                 r = route_dup(rt, NULL, &route);
 664                 if (r < 0)
 665                         return r;
 666
 667                 route->nexthop.gw.in = gw;
 668
 669                 r = dhcp4_request_route(route, link);
 670                 if (r < 0)
 671                         return r;
 672         }
 673
 674         return 0;
 675 }
 676
 677 static int dhcp4_request_routes_to_servers(
 678                 Link *link,
 679                 const struct in_addr *servers,
 680                 size_t n_servers) {
 681
 682         int r;
 683
 684         assert(link);
 685         assert(link->dhcp_lease);
 686         assert(link->network);
 687         assert(servers || n_servers == 0);
 688
 689         FOREACH_ARRAY(dst, servers, n_servers) {
 690                 _cleanup_(route_freep) Route *route = NULL;
 691                 struct in_addr gw;
 692
 693                 if (in4_addr_is_null(dst))
 694                         continue;
 695
 696                 r = dhcp4_find_gateway_for_destination(link, dst, 32, /* allow_null = */ true, &gw);
 697                 if (r == -EHOSTUNREACH) {
 698                         log_link_debug_errno(link, r, "DHCP: Cannot find suitable gateway for destination %s, ignoring: %m",
 699                                              IN4_ADDR_PREFIX_TO_STRING(dst, 32));
 700                         continue;
 701                 }
 702                 if (r < 0)
 703                         return r;
 704
 705                 r = route_new(&route);
 706                 if (r < 0)
 707                         return r;
 708
 709                 route->dst.in = *dst;
 710                 route->dst_prefixlen = 32;
 711
 712                 r = dhcp4_request_route_auto(route, link, &gw);
 713                 if (r < 0)
 714                         return r;
 715         }
 716
 717         return 0;
 718 }
 719
 720 static int dhcp4_request_routes_to_dns(Link *link) {
 721         const struct in_addr *dns;
 722         int r;
 723
 724         assert(link);
 725         assert(link->dhcp_lease);
 726         assert(link->network);
 727
 728         if (!link->network->dhcp_use_dns ||
 729             !link->network->dhcp_routes_to_dns)
 730                 return 0;
 731
 732         r = sd_dhcp_lease_get_dns(link->dhcp_lease, &dns);
 733         if (IN_SET(r, 0, -ENODATA))
 734                 return 0;
 735         if (r < 0)
 736                 return r;
 737
 738         return dhcp4_request_routes_to_servers(link, dns, r);
 739 }
 740
 741 static int dhcp4_request_routes_to_ntp(Link *link) {
 742         const struct in_addr *ntp;
 743         int r;
 744
 745         assert(link);
 746         assert(link->dhcp_lease);
 747         assert(link->network);
 748
 749         if (!link->network->dhcp_use_ntp ||
 750             !link->network->dhcp_routes_to_ntp)
 751                 return 0;
 752
 753         r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &ntp);
 754         if (IN_SET(r, 0, -ENODATA))
 755                 return 0;
 756         if (r < 0)
 757                 return r;
 758
 759         return dhcp4_request_routes_to_servers(link, ntp, r);
 760 }
 761
 762 static int dhcp4_request_routes(Link *link) {
 763         int r;
 764
 765         assert(link);
 766         assert(link->dhcp_lease);
 767
 768         r = dhcp4_request_prefix_route(link);
 769         if (r < 0)
 770                 return log_link_error_errno(link, r, "DHCP error: Could not request prefix route: %m");
 771
 772         r = dhcp4_request_default_gateway(link);
 773         if (r < 0)
 774                 return log_link_error_errno(link, r, "DHCP error: Could not request default gateway: %m");
 775
 776         r = dhcp4_request_classless_static_or_static_routes(link);
 777         if (r < 0)
 778                 return log_link_error_errno(link, r, "DHCP error: Could not request static routes: %m");
 779
 780         r = dhcp4_request_semi_static_routes(link);
 781         if (r < 0)
 782                 return log_link_error_errno(link, r, "DHCP error: Could not request routes with Gateway=_dhcp4 setting: %m");
 783
 784         r = dhcp4_request_routes_to_dns(link);
 785         if (r < 0)
 786                 return log_link_error_errno(link, r, "DHCP error: Could not request routes to DNS servers: %m");
 787
 788         r = dhcp4_request_routes_to_ntp(link);
 789         if (r < 0)
 790                 return log_link_error_errno(link, r, "DHCP error: Could not request routes to NTP servers: %m");
 791
 792         return 0;
 793 }
 794
 795 static int dhcp_reset_mtu(Link *link) {
 796         int r;
 797
 798         assert(link);
 799
 800         if (!link->network->dhcp_use_mtu)
 801                 return 0;
 802
 803         r = link_request_to_set_mtu(link, link->original_mtu);
 804         if (r < 0)
 805                 return log_link_error_errno(link, r, "DHCP error: Could not queue request to reset MTU: %m");
 806
 807         return 0;
 808 }
 809
 810 static int dhcp_reset_hostname(Link *link) {
 811         const char *hostname;
 812         int r;
 813
 814         assert(link);
 815
 816         if (!link->network->dhcp_use_hostname)
 817                 return 0;
 818
 819         hostname = link->network->dhcp_hostname;
 820         if (!hostname)
 821                 (void) sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
 822
 823         if (!hostname)
 824                 return 0;
 825
 826         /* If a hostname was set due to the lease, then unset it now. */
 827         r = manager_set_hostname(link->manager, NULL);
 828         if (r < 0)
 829                 return log_link_error_errno(link, r, "DHCP error: Failed to reset transient hostname: %m");
 830
 831         return 0;
 832 }
 833
 834 int dhcp4_lease_lost(Link *link) {
 835         int r = 0;
 836
 837         assert(link);
 838         assert(link->dhcp_lease);
 839         assert(link->network);
 840
 841         log_link_info(link, "DHCP lease lost");
 842
 843         link->dhcp4_configured = false;
 844
 845         if (link->network->dhcp_use_6rd &&
 846             sd_dhcp_lease_has_6rd(link->dhcp_lease))
 847                 dhcp4_pd_prefix_lost(link);
 848
 849         RET_GATHER(r, dhcp4_remove_address_and_routes(link, /* only_marked = */ false));
 850         RET_GATHER(r, dhcp_reset_mtu(link));
 851         RET_GATHER(r, dhcp_reset_hostname(link));
 852
 853         link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
 854         link_dirty(link);
 855
 856         /* If one of the above failed. Do not request nexthops and routes. */
 857         if (r < 0)
 858                 return r;
 859
 860         r = link_request_static_nexthops(link, true);
 861         if (r < 0)
 862                 return r;
 863
 864         return link_request_static_routes(link, true);
 865 }
 866
 867 static int dhcp4_address_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, Address *address) {
 868         int r;
 869
 870         assert(link);
 871
 872         r = address_configure_handler_internal(rtnl, m, link, "Could not set DHCPv4 address");
 873         if (r <= 0)
 874                 return r;
 875
 876         r = dhcp4_check_ready(link);
 877         if (r < 0)
 878                 link_enter_failed(link);
 879
 880         return 1;
 881 }
 882
 883 static int dhcp4_request_address(Link *link, bool announce) {
 884         _cleanup_(address_unrefp) Address *addr = NULL;
 885         struct in_addr address, server;
 886         uint8_t prefixlen;
 887         Address *existing;
 888         usec_t lifetime_usec;
 889         int r;
 890
 891         assert(link);
 892         assert(link->manager);
 893         assert(link->network);
 894         assert(link->dhcp_lease);
 895
 896         r = sd_dhcp_lease_get_address(link->dhcp_lease, &address);
 897         if (r < 0)
 898                 return log_link_warning_errno(link, r, "DHCP error: no address: %m");
 899
 900         r = sd_dhcp_lease_get_prefix(link->dhcp_lease, NULL, &prefixlen);
 901         if (r < 0)
 902                 return log_link_warning_errno(link, r, "DHCP error: no netmask: %m");
 903
 904         r = sd_dhcp_lease_get_server_identifier(link->dhcp_lease, &server);
 905         if (r < 0)
 906                 return log_link_debug_errno(link, r, "DHCP error: failed to get DHCP server IP address: %m");
 907
 908         if (!FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DHCP)) {
 909                 r = sd_dhcp_lease_get_lifetime_timestamp(link->dhcp_lease, CLOCK_BOOTTIME, &lifetime_usec);
 910                 if (r < 0)
 911                         return log_link_warning_errno(link, r, "DHCP error: failed to get lifetime: %m");
 912         } else
 913                 lifetime_usec = USEC_INFINITY;
 914
 915         if (announce) {
 916                 const struct in_addr *router;
 917
 918                 r = sd_dhcp_lease_get_router(link->dhcp_lease, &router);
 919                 if (r < 0 && r != -ENODATA)
 920                         return log_link_error_errno(link, r, "DHCP error: Could not get gateway: %m");
 921
 922                 if (r > 0 && in4_addr_is_set(&router[0]))
 923                         log_struct(LOG_INFO,
 924                                    LOG_LINK_INTERFACE(link),
 925                                    LOG_LINK_MESSAGE(link, "DHCPv4 address "IPV4_ADDRESS_FMT_STR"/%u, gateway "IPV4_ADDRESS_FMT_STR" acquired from "IPV4_ADDRESS_FMT_STR,
 926                                                     IPV4_ADDRESS_FMT_VAL(address),
 927                                                     prefixlen,
 928                                                     IPV4_ADDRESS_FMT_VAL(router[0]),
 929                                                     IPV4_ADDRESS_FMT_VAL(server)),
 930                                    "ADDRESS="IPV4_ADDRESS_FMT_STR, IPV4_ADDRESS_FMT_VAL(address),
 931                                    "PREFIXLEN=%u", prefixlen,
 932                                    "GATEWAY="IPV4_ADDRESS_FMT_STR, IPV4_ADDRESS_FMT_VAL(router[0]));
 933                 else
 934                         log_struct(LOG_INFO,
 935                                    LOG_LINK_INTERFACE(link),
 936                                    LOG_LINK_MESSAGE(link, "DHCPv4 address "IPV4_ADDRESS_FMT_STR"/%u acquired from "IPV4_ADDRESS_FMT_STR,
 937                                                     IPV4_ADDRESS_FMT_VAL(address),
 938                                                     prefixlen,
 939                                                     IPV4_ADDRESS_FMT_VAL(server)),
 940                                    "ADDRESS="IPV4_ADDRESS_FMT_STR, IPV4_ADDRESS_FMT_VAL(address),
 941                                    "PREFIXLEN=%u", prefixlen);
 942         }
 943
 944         r = address_new(&addr);
 945         if (r < 0)
 946                 return log_oom();
 947
 948         addr->source = NETWORK_CONFIG_SOURCE_DHCP4;
 949         addr->provider.in = server;
 950         addr->family = AF_INET;
 951         addr->in_addr.in.s_addr = address.s_addr;
 952         addr->lifetime_preferred_usec = lifetime_usec;
 953         addr->lifetime_valid_usec = lifetime_usec;
 954         addr->prefixlen = prefixlen;
 955         r = sd_dhcp_lease_get_broadcast(link->dhcp_lease, &addr->broadcast);
 956         if (r < 0 && r != -ENODATA)
 957                 return log_link_warning_errno(link, r, "DHCP: failed to get broadcast address: %m");
 958         SET_FLAG(addr->flags, IFA_F_NOPREFIXROUTE, !link_prefixroute(link));
 959         addr->route_metric = link->network->dhcp_route_metric;
 960         addr->duplicate_address_detection = link->network->dhcp_send_decline ? ADDRESS_FAMILY_IPV4 : ADDRESS_FAMILY_NO;
 961
 962         r = free_and_strdup_warn(&addr->label, link->network->dhcp_label);
 963         if (r < 0)
 964                 return r;
 965
 966         r = free_and_strdup_warn(&addr->netlabel, link->network->dhcp_netlabel);
 967         if (r < 0)
 968                 return r;
 969
 970         if (address_get(link, addr, &existing) < 0) /* The address is new. */
 971                 link->dhcp4_configured = false;
 972         else
 973                 address_unmark(existing);
 974
 975         r = link_request_address(link, addr, &link->dhcp4_messages,
 976                                  dhcp4_address_handler, NULL);
 977         if (r < 0)
 978                 return log_link_error_errno(link, r, "Failed to request DHCPv4 address: %m");
 979
 980         return 0;
 981 }
 982
 983 static int dhcp4_request_address_and_routes(Link *link, bool announce) {
 984         int r;
 985
 986         assert(link);
 987
 988         link_mark_addresses(link, NETWORK_CONFIG_SOURCE_DHCP4);
 989         link_mark_routes(link, NETWORK_CONFIG_SOURCE_DHCP4);
 990
 991         r = dhcp4_request_address(link, announce);
 992         if (r < 0)
 993                 return r;
 994
 995         r = dhcp4_request_routes(link);
 996         if (r < 0)
 997                 return r;
 998
 999         if (!link->dhcp4_configured) {
1000                 link_set_state(link, LINK_STATE_CONFIGURING);
1001                 link_check_ready(link);
1002         }
1003
1004         return 0;
1005 }
1006
1007 static int dhcp_lease_renew(sd_dhcp_client *client, Link *link) {
1008         _cleanup_(sd_dhcp_lease_unrefp) sd_dhcp_lease *old_lease = NULL;
1009         sd_dhcp_lease *lease;
1010         int r;
1011
1012         assert(link);
1013         assert(link->network);
1014         assert(client);
1015
1016         r = sd_dhcp_client_get_lease(client, &lease);
1017         if (r < 0)
1018                 return log_link_warning_errno(link, r, "DHCP error: no lease: %m");
1019
1020         old_lease = TAKE_PTR(link->dhcp_lease);
1021         link->dhcp_lease = sd_dhcp_lease_ref(lease);
1022         link_dirty(link);
1023
1024         if (link->network->dhcp_use_6rd) {
1025                 if (sd_dhcp_lease_has_6rd(link->dhcp_lease)) {
1026                         r = dhcp4_pd_prefix_acquired(link);
1027                         if (r < 0)
1028                                 return log_link_warning_errno(link, r, "Failed to process 6rd option: %m");
1029                 } else if (sd_dhcp_lease_has_6rd(old_lease))
1030                         dhcp4_pd_prefix_lost(link);
1031         }
1032
1033         return dhcp4_request_address_and_routes(link, false);
1034 }
1035
1036 static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
1037         sd_dhcp_lease *lease;
1038         int r;
1039
1040         assert(client);
1041         assert(link);
1042
1043         r = sd_dhcp_client_get_lease(client, &lease);
1044         if (r < 0)
1045                 return log_link_error_errno(link, r, "DHCP error: No lease: %m");
1046
1047         sd_dhcp_lease_unref(link->dhcp_lease);
1048         link->dhcp_lease = sd_dhcp_lease_ref(lease);
1049         link_dirty(link);
1050
1051         if (link->network->dhcp_use_mtu) {
1052                 uint16_t mtu;
1053
1054                 r = sd_dhcp_lease_get_mtu(lease, &mtu);
1055                 if (r >= 0) {
1056                         r = link_request_to_set_mtu(link, mtu);
1057                         if (r < 0)
1058                                 log_link_error_errno(link, r, "Failed to set MTU to %" PRIu16 ": %m", mtu);
1059                 }
1060         }
1061
1062         if (link->network->dhcp_use_hostname) {
1063                 const char *dhcpname = NULL;
1064                 _cleanup_free_ char *hostname = NULL;
1065
1066                 if (link->network->dhcp_hostname)
1067                         dhcpname = link->network->dhcp_hostname;
1068                 else
1069                         (void) sd_dhcp_lease_get_hostname(lease, &dhcpname);
1070
1071                 if (dhcpname) {
1072                         r = shorten_overlong(dhcpname, &hostname);
1073                         if (r < 0)
1074                                 log_link_warning_errno(link, r, "Unable to shorten overlong DHCP hostname '%s', ignoring: %m", dhcpname);
1075                         if (r == 1)
1076                                 log_link_notice(link, "Overlong DHCP hostname received, shortened from '%s' to '%s'", dhcpname, hostname);
1077                 }
1078
1079                 if (hostname) {
1080                         r = manager_set_hostname(link->manager, hostname);
1081                         if (r < 0)
1082                                 log_link_error_errno(link, r, "Failed to set transient hostname to '%s': %m", hostname);
1083                 }
1084         }
1085
1086         if (link->network->dhcp_use_timezone) {
1087                 const char *tz = NULL;
1088
1089                 (void) sd_dhcp_lease_get_timezone(link->dhcp_lease, &tz);
1090
1091                 if (tz) {
1092                         r = manager_set_timezone(link->manager, tz);
1093                         if (r < 0)
1094                                 log_link_error_errno(link, r, "Failed to set timezone to '%s': %m", tz);
1095                 }
1096         }
1097
1098         if (link->network->dhcp_use_6rd &&
1099             sd_dhcp_lease_has_6rd(link->dhcp_lease)) {
1100                 r = dhcp4_pd_prefix_acquired(link);
1101                 if (r < 0)
1102                         return log_link_warning_errno(link, r, "Failed to process 6rd option: %m");
1103         }
1104
1105         return dhcp4_request_address_and_routes(link, true);
1106 }
1107
1108 static int dhcp_lease_ip_change(sd_dhcp_client *client, Link *link) {
1109         int r;
1110
1111         r = dhcp_lease_acquired(client, link);
1112         if (r < 0)
1113                 (void) dhcp4_lease_lost(link);
1114
1115         return r;
1116 }
1117
1118 static int dhcp_server_is_filtered(Link *link, sd_dhcp_client *client) {
1119         sd_dhcp_lease *lease;
1120         struct in_addr addr;
1121         int r;
1122
1123         assert(link);
1124         assert(link->network);
1125         assert(client);
1126
1127         r = sd_dhcp_client_get_lease(client, &lease);
1128         if (r < 0)
1129                 return log_link_error_errno(link, r, "Failed to get DHCP lease: %m");
1130
1131         r = sd_dhcp_lease_get_server_identifier(lease, &addr);
1132         if (r < 0)
1133                 return log_link_debug_errno(link, r, "Failed to get DHCP server IP address: %m");
1134
1135         if (in4_address_is_filtered(&addr, link->network->dhcp_allow_listed_ip, link->network->dhcp_deny_listed_ip)) {
1136                 if (DEBUG_LOGGING) {
1137                         if (link->network->dhcp_allow_listed_ip)
1138                                 log_link_debug(link, "DHCPv4 server IP address "IPV4_ADDRESS_FMT_STR" not found in allow-list, ignoring offer.",
1139                                                IPV4_ADDRESS_FMT_VAL(addr));
1140                         else
1141                                 log_link_debug(link, "DHCPv4 server IP address "IPV4_ADDRESS_FMT_STR" found in deny-list, ignoring offer.",
1142                                                IPV4_ADDRESS_FMT_VAL(addr));
1143                 }
1144
1145                 return true;
1146         }
1147
1148         return false;
1149 }
1150
1151 static int dhcp4_handler(sd_dhcp_client *client, int event, void *userdata) {
1152         Link *link = ASSERT_PTR(userdata);
1153         int r;
1154
1155         assert(link->network);
1156         assert(link->manager);
1157
1158         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1159                 return 0;
1160
1161         switch (event) {
1162                 case SD_DHCP_CLIENT_EVENT_STOP:
1163                         if (link->ipv4ll) {
1164                                 log_link_debug(link, "DHCP client is stopped. Acquiring IPv4 link-local address");
1165
1166                                 if (in4_addr_is_set(&link->network->ipv4ll_start_address)) {
1167                                         r = sd_ipv4ll_set_address(link->ipv4ll, &link->network->ipv4ll_start_address);
1168                                         if (r < 0)
1169                                                 return log_link_warning_errno(link, r, "Could not set IPv4 link-local start address: %m");
1170                                 }
1171
1172                                 r = sd_ipv4ll_start(link->ipv4ll);
1173                                 if (r < 0 && r != -ESTALE) /* On exit, we cannot and should not start sd-ipv4ll. */
1174                                         return log_link_warning_errno(link, r, "Could not acquire IPv4 link-local address: %m");
1175                         }
1176
1177                         if (FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DHCP)) {
1178                                 log_link_notice(link, "DHCPv4 connection considered critical, ignoring request to reconfigure it.");
1179                                 return 0;
1180                         }
1181
1182                         if (link->dhcp_lease) {
1183                                 if (link->network->dhcp_send_release) {
1184                                         r = sd_dhcp_client_send_release(client);
1185                                         if (r < 0)
1186                                                 log_link_full_errno(link,
1187                                                                     ERRNO_IS_DISCONNECT(r) ? LOG_DEBUG : LOG_WARNING,
1188                                                                     r, "Failed to send DHCP RELEASE, ignoring: %m");
1189                                 }
1190
1191                                 r = dhcp4_lease_lost(link);
1192                                 if (r < 0) {
1193                                         link_enter_failed(link);
1194                                         return r;
1195                                 }
1196                         }
1197
1198                         break;
1199                 case SD_DHCP_CLIENT_EVENT_EXPIRED:
1200                         if (FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DHCP)) {
1201                                 log_link_notice(link, "DHCPv4 connection considered critical, ignoring request to reconfigure it.");
1202                                 return 0;
1203                         }
1204
1205                         if (link->dhcp_lease) {
1206                                 r = dhcp4_lease_lost(link);
1207                                 if (r < 0) {
1208                                         link_enter_failed(link);
1209                                         return r;
1210                                 }
1211                         }
1212
1213                         break;
1214                 case SD_DHCP_CLIENT_EVENT_IP_CHANGE:
1215                         if (FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DHCP)) {
1216                                 log_link_notice(link, "DHCPv4 connection considered critical, ignoring request to reconfigure it.");
1217                                 return 0;
1218                         }
1219
1220                         r = dhcp_lease_ip_change(client, link);
1221                         if (r < 0) {
1222                                 link_enter_failed(link);
1223                                 return r;
1224                         }
1225
1226                         break;
1227                 case SD_DHCP_CLIENT_EVENT_RENEW:
1228                         r = dhcp_lease_renew(client, link);
1229                         if (r < 0) {
1230                                 link_enter_failed(link);
1231                                 return r;
1232                         }
1233                         break;
1234                 case SD_DHCP_CLIENT_EVENT_IP_ACQUIRE:
1235                         r = dhcp_lease_acquired(client, link);
1236                         if (r < 0) {
1237                                 link_enter_failed(link);
1238                                 return r;
1239                         }
1240                         break;
1241                 case SD_DHCP_CLIENT_EVENT_SELECTING:
1242                         r = dhcp_server_is_filtered(link, client);
1243                         if (r < 0) {
1244                                 link_enter_failed(link);
1245                                 return r;
1246                         }
1247                         if (r > 0)
1248                                 return -ENOMSG;
1249                         break;
1250
1251                 case SD_DHCP_CLIENT_EVENT_TRANSIENT_FAILURE:
1252                         if (link->ipv4ll && !sd_ipv4ll_is_running(link->ipv4ll)) {
1253                                 log_link_debug(link, "Problems acquiring DHCP lease, acquiring IPv4 link-local address");
1254
1255                                 if (in4_addr_is_set(&link->network->ipv4ll_start_address)) {
1256                                         r = sd_ipv4ll_set_address(link->ipv4ll, &link->network->ipv4ll_start_address);
1257                                         if (r < 0)
1258                                                 return log_link_warning_errno(link, r, "Could not set IPv4 link-local start address: %m");
1259                                 }
1260
1261                                 r = sd_ipv4ll_start(link->ipv4ll);
1262                                 if (r < 0)
1263                                         return log_link_warning_errno(link, r, "Could not acquire IPv4 link-local address: %m");
1264                         }
1265                         break;
1266
1267                 default:
1268                         if (event < 0)
1269                                 log_link_warning_errno(link, event, "DHCP error: Client failed: %m");
1270                         else
1271                                 log_link_warning(link, "DHCP unknown event: %i", event);
1272                         break;
1273         }
1274
1275         return 0;
1276 }
1277
1278 static int dhcp4_set_hostname(Link *link) {
1279         _cleanup_free_ char *hostname = NULL;
1280         const char *hn;
1281         int r;
1282
1283         assert(link);
1284
1285         if (!link->network->dhcp_send_hostname)
1286                 hn = NULL;
1287         else if (link->network->dhcp_hostname)
1288                 hn = link->network->dhcp_hostname;
1289         else {
1290                 r = gethostname_strict(&hostname);
1291                 if (r < 0 && r != -ENXIO) /* ENXIO: no hostname set or hostname is "localhost" */
1292                         return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to get hostname: %m");
1293
1294                 hn = hostname;
1295         }
1296
1297         r = sd_dhcp_client_set_hostname(link->dhcp_client, hn);
1298         if (r == -EINVAL && hostname)
1299                 /* Ignore error when the machine's hostname is not suitable to send in DHCP packet. */
1300                 log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set hostname from kernel hostname, ignoring: %m");
1301         else if (r < 0)
1302                 return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set hostname: %m");
1303
1304         return 0;
1305 }
1306
1307 static int dhcp4_set_client_identifier(Link *link) {
1308         int r;
1309
1310         assert(link);
1311         assert(link->network);
1312         assert(link->dhcp_client);
1313
1314         switch (link->network->dhcp_client_identifier) {
1315         case DHCP_CLIENT_ID_DUID: {
1316                 /* If configured, apply user specified DUID and IAID */
1317                 const DUID *duid = link_get_dhcp4_duid(link);
1318
1319                 if (duid->raw_data_len == 0)
1320                         switch (duid->type) {
1321                         case DUID_TYPE_LLT:
1322                                 r = sd_dhcp_client_set_iaid_duid_llt(link->dhcp_client,
1323                                                                      link->network->dhcp_iaid_set,
1324                                                                      link->network->dhcp_iaid,
1325                                                                      duid->llt_time);
1326                                 break;
1327                         case DUID_TYPE_LL:
1328                                 r = sd_dhcp_client_set_iaid_duid_ll(link->dhcp_client,
1329                                                                     link->network->dhcp_iaid_set,
1330                                                                     link->network->dhcp_iaid);
1331                                 break;
1332                         case DUID_TYPE_EN:
1333                                 r = sd_dhcp_client_set_iaid_duid_en(link->dhcp_client,
1334                                                                     link->network->dhcp_iaid_set,
1335                                                                     link->network->dhcp_iaid);
1336                                 break;
1337                         case DUID_TYPE_UUID:
1338                                 r = sd_dhcp_client_set_iaid_duid_uuid(link->dhcp_client,
1339                                                                       link->network->dhcp_iaid_set,
1340                                                                       link->network->dhcp_iaid);
1341                                 break;
1342                         default:
1343                                 r = sd_dhcp_client_set_iaid_duid_raw(link->dhcp_client,
1344                                                                      link->network->dhcp_iaid_set,
1345                                                                      link->network->dhcp_iaid,
1346                                                                      duid->type, NULL, 0);
1347                         }
1348                 else
1349                         r = sd_dhcp_client_set_iaid_duid_raw(link->dhcp_client,
1350                                                              link->network->dhcp_iaid_set,
1351                                                              link->network->dhcp_iaid,
1352                                                              duid->type, duid->raw_data, duid->raw_data_len);
1353                 if (r < 0)
1354                         return r;
1355                 break;
1356         }
1357         case DHCP_CLIENT_ID_MAC: {
1358                 const uint8_t *hw_addr = link->hw_addr.bytes;
1359                 size_t hw_addr_len = link->hw_addr.length;
1360
1361                 if (link->iftype == ARPHRD_INFINIBAND && hw_addr_len == INFINIBAND_ALEN) {
1362                         /* set_client_id expects only last 8 bytes of an IB address */
1363                         hw_addr += INFINIBAND_ALEN - 8;
1364                         hw_addr_len -= INFINIBAND_ALEN - 8;
1365                 }
1366
1367                 r = sd_dhcp_client_set_client_id(link->dhcp_client,
1368                                                  link->iftype,
1369                                                  hw_addr,
1370                                                  hw_addr_len);
1371                 if (r < 0)
1372                         return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set client ID: %m");
1373                 break;
1374         }
1375         default:
1376                 assert_not_reached();
1377         }
1378
1379         return 0;
1380 }
1381
1382 static int dhcp4_find_dynamic_address(Link *link, struct in_addr *ret) {
1383         Address *a;
1384
1385         assert(link);
1386         assert(link->network);
1387         assert(ret);
1388
1389         if (!FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DHCP))
1390                 return false;
1391
1392         SET_FOREACH(a, link->addresses) {
1393                 if (a->source != NETWORK_CONFIG_SOURCE_FOREIGN)
1394                         continue;
1395                 if (a->family != AF_INET)
1396                         continue;
1397                 if (link_address_is_dynamic(link, a))
1398                         break;
1399         }
1400
1401         if (!a)
1402                 return false;
1403
1404         *ret = a->in_addr.in;
1405         return true;
1406 }
1407
1408 static int dhcp4_set_request_address(Link *link) {
1409         struct in_addr a;
1410
1411         assert(link);
1412         assert(link->network);
1413         assert(link->dhcp_client);
1414
1415         a = link->network->dhcp_request_address;
1416
1417         if (in4_addr_is_null(&a))
1418                 (void) dhcp4_find_dynamic_address(link, &a);
1419
1420         if (in4_addr_is_null(&a))
1421                 return 0;
1422
1423         log_link_debug(link, "DHCPv4 CLIENT: requesting %s.", IN4_ADDR_TO_STRING(&a));
1424         return sd_dhcp_client_set_request_address(link->dhcp_client, &a);
1425 }
1426
1427 static bool link_needs_dhcp_broadcast(Link *link) {
1428         const char *val;
1429         int r;
1430
1431         assert(link);
1432         assert(link->network);
1433
1434         /* Return the setting in DHCP[4].RequestBroadcast if specified. Otherwise return the device property
1435          * ID_NET_DHCP_BROADCAST setting, which may be set for interfaces requiring that the DHCPOFFER message
1436          * is being broadcast because they can't  handle unicast messages while not fully configured.
1437          * If neither is set or a failure occurs, return false, which is the default for this flag.
1438          */
1439         r = link->network->dhcp_broadcast;
1440         if (r < 0 && link->dev && sd_device_get_property_value(link->dev, "ID_NET_DHCP_BROADCAST", &val) >= 0) {
1441                 r = parse_boolean(val);
1442                 if (r < 0)
1443                         log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to parse ID_NET_DHCP_BROADCAST, ignoring: %m");
1444                 else
1445                         log_link_debug(link, "DHCPv4 CLIENT: Detected ID_NET_DHCP_BROADCAST='%d'.", r);
1446
1447         }
1448         return r == true;
1449 }
1450
1451 static bool link_dhcp4_ipv6_only_mode(Link *link) {
1452         assert(link);
1453         assert(link->network);
1454
1455         if (link->network->dhcp_ipv6_only_mode >= 0)
1456                 return link->network->dhcp_ipv6_only_mode;
1457
1458         return link_dhcp6_enabled(link) || link_ipv6_accept_ra_enabled(link);
1459 }
1460
1461 static int dhcp4_configure(Link *link) {
1462         sd_dhcp_option *send_option;
1463         void *request_options;
1464         int r;
1465
1466         assert(link);
1467         assert(link->network);
1468
1469         if (link->dhcp_client)
1470                 return log_link_debug_errno(link, SYNTHETIC_ERRNO(EBUSY), "DHCPv4 client is already configured.");
1471
1472         r = sd_dhcp_client_new(&link->dhcp_client, link->network->dhcp_anonymize);
1473         if (r < 0)
1474                 return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to allocate DHCPv4 client: %m");
1475
1476         r = sd_dhcp_client_attach_event(link->dhcp_client, link->manager->event, 0);
1477         if (r < 0)
1478                 return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to attach event to DHCPv4 client: %m");
1479
1480         r = sd_dhcp_client_attach_device(link->dhcp_client, link->dev);
1481         if (r < 0)
1482                 return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to attach device: %m");
1483
1484         r = sd_dhcp_client_set_rapid_commit(link->dhcp_client, link->network->dhcp_use_rapid_commit);
1485         if (r < 0)
1486                 return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set rapid commit: %m");
1487
1488         r = sd_dhcp_client_set_mac(link->dhcp_client,
1489                                    link->hw_addr.bytes,
1490                                    link->bcast_addr.length > 0 ? link->bcast_addr.bytes : NULL,
1491                                    link->hw_addr.length, link->iftype);
1492         if (r < 0)
1493                 return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set MAC address: %m");
1494
1495         r = sd_dhcp_client_set_ifindex(link->dhcp_client, link->ifindex);
1496         if (r < 0)
1497                 return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set ifindex: %m");
1498
1499         r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp4_handler, link);
1500         if (r < 0)
1501                 return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set callback: %m");
1502
1503         r = sd_dhcp_client_set_request_broadcast(link->dhcp_client, link_needs_dhcp_broadcast(link));
1504         if (r < 0)
1505                 return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set request flag for broadcast: %m");
1506
1507         r = dhcp_client_set_state_callback(link->dhcp_client, dhcp_client_callback_bus, link);
1508         if (r < 0)
1509                 return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set state change callback: %m");
1510
1511         if (link->mtu > 0) {
1512                 r = sd_dhcp_client_set_mtu(link->dhcp_client, link->mtu);
1513                 if (r < 0)
1514                         return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set MTU: %m");
1515         }
1516
1517         if (!link->network->dhcp_anonymize) {
1518                 r = dhcp4_set_request_address(link);
1519                 if (r < 0)
1520                         return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set initial DHCPv4 address: %m");
1521
1522                 if (link->network->dhcp_use_mtu) {
1523                         r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_MTU_INTERFACE);
1524                         if (r < 0)
1525                                 return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set request flag for MTU: %m");
1526                 }
1527
1528                 if (link->network->dhcp_use_routes) {
1529                         r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_STATIC_ROUTE);
1530                         if (r < 0)
1531                                 return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set request flag for static route: %m");
1532
1533                         r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_CLASSLESS_STATIC_ROUTE);
1534                         if (r < 0)
1535                                 return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set request flag for classless static route: %m");
1536                 }
1537
1538                 if (link->network->dhcp_use_domains != DHCP_USE_DOMAINS_NO) {
1539                         r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_DOMAIN_SEARCH);
1540                         if (r < 0)
1541                                 return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set request flag for domain search list: %m");
1542                 }
1543
1544                 if (link->network->dhcp_use_ntp) {
1545                         r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_NTP_SERVER);
1546                         if (r < 0)
1547                                 return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set request flag for NTP server: %m");
1548                 }
1549
1550                 if (link->network->dhcp_use_sip) {
1551                         r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_SIP_SERVER);
1552                         if (r < 0)
1553                                 return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set request flag for SIP server: %m");
1554                 }
1555                 if (link->network->dhcp_use_captive_portal) {
1556                         r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_DHCP_CAPTIVE_PORTAL);
1557                         if (r < 0)
1558                                 return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set request flag for captive portal: %m");
1559                 }
1560
1561                 if (link->network->dhcp_use_timezone) {
1562                         r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_TZDB_TIMEZONE);
1563                         if (r < 0)
1564                                 return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set request flag for timezone: %m");
1565                 }
1566
1567                 if (link->network->dhcp_use_6rd) {
1568                         r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_6RD);
1569                         if (r < 0)
1570                                 return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set request flag for 6rd: %m");
1571                 }
1572
1573                 if (link_dhcp4_ipv6_only_mode(link)) {
1574                         r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_IPV6_ONLY_PREFERRED);
1575                         if (r < 0)
1576                                 return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set request flag for IPv6-only preferred option: %m");
1577                 }
1578
1579                 SET_FOREACH(request_options, link->network->dhcp_request_options) {
1580                         uint32_t option = PTR_TO_UINT32(request_options);
1581
1582                         r = sd_dhcp_client_set_request_option(link->dhcp_client, option);
1583                         if (r < 0)
1584                                 return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set request flag for '%u': %m", option);
1585                 }
1586
1587                 ORDERED_HASHMAP_FOREACH(send_option, link->network->dhcp_client_send_options) {
1588                         r = sd_dhcp_client_add_option(link->dhcp_client, send_option);
1589                         if (r == -EEXIST)
1590                                 continue;
1591                         if (r < 0)
1592                                 return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set send option: %m");
1593                 }
1594
1595                 ORDERED_HASHMAP_FOREACH(send_option, link->network->dhcp_client_send_vendor_options) {
1596                         r = sd_dhcp_client_add_vendor_option(link->dhcp_client, send_option);
1597                         if (r == -EEXIST)
1598                                 continue;
1599                         if (r < 0)
1600                                 return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set send option: %m");
1601                 }
1602
1603                 r = dhcp4_set_hostname(link);
1604                 if (r < 0)
1605                         return r;
1606
1607                 if (link->network->dhcp_vendor_class_identifier) {
1608                         r = sd_dhcp_client_set_vendor_class_identifier(link->dhcp_client,
1609                                                                        link->network->dhcp_vendor_class_identifier);
1610                         if (r < 0)
1611                                 return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set vendor class identifier: %m");
1612                 }
1613
1614                 if (link->network->dhcp_mudurl) {
1615                         r = sd_dhcp_client_set_mud_url(link->dhcp_client, link->network->dhcp_mudurl);
1616                         if (r < 0)
1617                                 return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set MUD URL: %m");
1618                 }
1619
1620                 if (link->network->dhcp_user_class) {
1621                         r = sd_dhcp_client_set_user_class(link->dhcp_client, link->network->dhcp_user_class);
1622                         if (r < 0)
1623                                 return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set user class: %m");
1624                 }
1625         }
1626
1627         if (link->network->dhcp_client_port > 0) {
1628                 r = sd_dhcp_client_set_client_port(link->dhcp_client, link->network->dhcp_client_port);
1629                 if (r < 0)
1630                         return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set listen port: %m");
1631         }
1632
1633         if (link->network->dhcp_max_attempts > 0) {
1634                 r = sd_dhcp_client_set_max_attempts(link->dhcp_client, link->network->dhcp_max_attempts);
1635                 if (r < 0)
1636                         return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set max attempts: %m");
1637         }
1638
1639         if (link->network->dhcp_ip_service_type >= 0) {
1640                 r = sd_dhcp_client_set_service_type(link->dhcp_client, link->network->dhcp_ip_service_type);
1641                 if (r < 0)
1642                         return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set IP service type: %m");
1643         }
1644
1645         if (link->network->dhcp_socket_priority_set) {
1646                 r = sd_dhcp_client_set_socket_priority(link->dhcp_client, link->network->dhcp_socket_priority);
1647                 if (r < 0)
1648                         return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set socket priority: %m");
1649         }
1650
1651         if (link->network->dhcp_fallback_lease_lifetime_usec > 0) {
1652                 r = sd_dhcp_client_set_fallback_lease_lifetime(link->dhcp_client, link->network->dhcp_fallback_lease_lifetime_usec);
1653                 if (r < 0)
1654                         return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed set to lease lifetime: %m");
1655         }
1656
1657         return dhcp4_set_client_identifier(link);
1658 }
1659
1660 int dhcp4_update_mac(Link *link) {
1661         bool restart;
1662         int r;
1663
1664         assert(link);
1665
1666         if (!link->dhcp_client)
1667                 return 0;
1668
1669         restart = sd_dhcp_client_is_running(link->dhcp_client);
1670
1671         r = sd_dhcp_client_stop(link->dhcp_client);
1672         if (r < 0)
1673                 return r;
1674
1675         r = sd_dhcp_client_set_mac(link->dhcp_client,
1676                                    link->hw_addr.bytes,
1677                                    link->bcast_addr.length > 0 ? link->bcast_addr.bytes : NULL,
1678                                    link->hw_addr.length, link->iftype);
1679         if (r < 0)
1680                 return r;
1681
1682         r = dhcp4_set_client_identifier(link);
1683         if (r < 0)
1684                 return r;
1685
1686         if (restart) {
1687                 r = dhcp4_start(link);
1688                 if (r < 0)
1689                         return r;
1690         }
1691
1692         return 0;
1693 }
1694
1695 int dhcp4_update_ipv6_connectivity(Link *link) {
1696         assert(link);
1697
1698         if (!link->network)
1699                 return 0;
1700
1701         if (!link->network->dhcp_ipv6_only_mode)
1702                 return 0;
1703
1704         if (!link->dhcp_client)
1705                 return 0;
1706
1707         /* If the client is running, set the current connectivity. */
1708         if (sd_dhcp_client_is_running(link->dhcp_client))
1709                 return sd_dhcp_client_set_ipv6_connectivity(link->dhcp_client, link_has_ipv6_connectivity(link));
1710
1711         /* If the client has been already stopped or not started yet, let's check the current connectivity
1712          * and start the client if necessary. */
1713         if (link_has_ipv6_connectivity(link))
1714                 return 0;
1715
1716         return dhcp4_start_full(link, /* set_ipv6_connectivity = */ false);
1717 }
1718
1719 int dhcp4_start_full(Link *link, bool set_ipv6_connectivity) {
1720         int r;
1721
1722         assert(link);
1723         assert(link->network);
1724
1725         if (!link->dhcp_client)
1726                 return 0;
1727
1728         if (!link_has_carrier(link))
1729                 return 0;
1730
1731         if (sd_dhcp_client_is_running(link->dhcp_client) > 0)
1732                 return 0;
1733
1734         r = sd_dhcp_client_start(link->dhcp_client);
1735         if (r < 0)
1736                 return r;
1737
1738         if (set_ipv6_connectivity) {
1739                 r = dhcp4_update_ipv6_connectivity(link);
1740                 if (r < 0)
1741                         return r;
1742         }
1743
1744         return 1;
1745 }
1746
1747 int dhcp4_renew(Link *link) {
1748         assert(link);
1749
1750         if (!link->dhcp_client)
1751                 return 0;
1752
1753         /* The DHCPv4 client may have been stopped by the IPv6 only mode. Let's unconditionally restart the
1754          * client if it is not running. */
1755         if (!sd_dhcp_client_is_running(link->dhcp_client))
1756                 return dhcp4_start(link);
1757
1758         /* The client may be waiting for IPv6 connectivity. Let's restart the client in that case. */
1759         if (dhcp_client_get_state(link->dhcp_client) != DHCP_STATE_BOUND)
1760                 return sd_dhcp_client_interrupt_ipv6_only_mode(link->dhcp_client);
1761
1762         /* Otherwise, send a RENEW command. */
1763         return sd_dhcp_client_send_renew(link->dhcp_client);
1764 }
1765
1766 static int dhcp4_configure_duid(Link *link) {
1767         assert(link);
1768         assert(link->network);
1769
1770         if (link->network->dhcp_client_identifier != DHCP_CLIENT_ID_DUID)
1771                 return 1;
1772
1773         return dhcp_configure_duid(link, link_get_dhcp4_duid(link));
1774 }
1775
1776 static int dhcp4_process_request(Request *req, Link *link, void *userdata) {
1777         int r;
1778
1779         assert(link);
1780
1781         if (!link_is_ready_to_configure(link, /* allow_unmanaged = */ false))
1782                 return 0;
1783
1784         r = dhcp4_configure_duid(link);
1785         if (r <= 0)
1786                 return r;
1787
1788         r = dhcp4_configure(link);
1789         if (r < 0)
1790                 return log_link_warning_errno(link, r, "Failed to configure DHCPv4 client: %m");
1791
1792         r = dhcp4_start(link);
1793         if (r < 0)
1794                 return log_link_warning_errno(link, r, "Failed to start DHCPv4 client: %m");
1795
1796         log_link_debug(link, "DHCPv4 client is configured%s.",
1797                        r > 0 ? ", acquiring DHCPv4 lease" : "");
1798         return 1;
1799 }
1800
1801 int link_request_dhcp4_client(Link *link) {
1802         int r;
1803
1804         assert(link);
1805
1806         if (!link_dhcp4_enabled(link))
1807                 return 0;
1808
1809         if (link->dhcp_client)
1810                 return 0;
1811
1812         r = link_queue_request(link, REQUEST_TYPE_DHCP4_CLIENT, dhcp4_process_request, NULL);
1813         if (r < 0)
1814                 return log_link_warning_errno(link, r, "Failed to request configuring of the DHCPv4 client: %m");
1815
1816         log_link_debug(link, "Requested configuring of the DHCPv4 client.");
1817         return 0;
1818 }
1819
1820 int config_parse_dhcp_max_attempts(
1821                 const char *unit,
1822                 const char *filename,
1823                 unsigned line,
1824                 const char *section,
1825                 unsigned section_line,
1826                 const char *lvalue,
1827                 int ltype,
1828                 const char *rvalue,
1829                 void *data,
1830                 void *userdata) {
1831
1832         Network *network = ASSERT_PTR(data);
1833         uint64_t a;
1834         int r;
1835
1836         assert(lvalue);
1837         assert(rvalue);
1838
1839         if (isempty(rvalue)) {
1840                 network->dhcp_max_attempts = 0;
1841                 return 0;
1842         }
1843
1844         if (streq(rvalue, "infinity")) {
1845                 network->dhcp_max_attempts = UINT64_MAX;
1846                 return 0;
1847         }
1848
1849         r = safe_atou64(rvalue, &a);
1850         if (r < 0) {
1851                 log_syntax(unit, LOG_WARNING, filename, line, r,
1852                            "Failed to parse DHCP maximum attempts, ignoring: %s", rvalue);
1853                 return 0;
1854         }
1855
1856         if (a == 0) {
1857                 log_syntax(unit, LOG_WARNING, filename, line, 0,
1858                            "%s= must be positive integer or 'infinity', ignoring: %s", lvalue, rvalue);
1859                 return 0;
1860         }
1861
1862         network->dhcp_max_attempts = a;
1863
1864         return 0;
1865 }
1866
1867 int config_parse_dhcp_ip_service_type(
1868                 const char *unit,
1869                 const char *filename,
1870                 unsigned line,
1871                 const char *section,
1872                 unsigned section_line,
1873                 const char *lvalue,
1874                 int ltype,
1875                 const char *rvalue,
1876                 void *data,
1877                 void *userdata) {
1878
1879         int *tos = ASSERT_PTR(data);
1880
1881         assert(filename);
1882         assert(lvalue);
1883         assert(rvalue);
1884
1885         if (isempty(rvalue))
1886                 *tos = -1; /* use sd_dhcp_client's default (currently, CS6). */
1887         else if (streq(rvalue, "none"))
1888                 *tos = 0;
1889         else if (streq(rvalue, "CS4"))
1890                 *tos = IPTOS_CLASS_CS4;
1891         else if (streq(rvalue, "CS6"))
1892                 *tos = IPTOS_CLASS_CS6;
1893         else
1894                 log_syntax(unit, LOG_WARNING, filename, line, 0,
1895                            "Failed to parse %s=, ignoring assignment: %s", lvalue, rvalue);
1896
1897         return 0;
1898 }
1899
1900 int config_parse_dhcp_socket_priority(
1901                 const char *unit,
1902                 const char *filename,
1903                 unsigned line,
1904                 const char *section,
1905                 unsigned section_line,
1906                 const char *lvalue,
1907                 int ltype,
1908                 const char *rvalue,
1909                 void *data,
1910                 void *userdata) {
1911
1912         Network *network = ASSERT_PTR(data);
1913         int a, r;
1914
1915         assert(lvalue);
1916         assert(rvalue);
1917
1918         if (isempty(rvalue)) {
1919                 network->dhcp_socket_priority_set = false;
1920                 return 0;
1921         }
1922
1923         r = safe_atoi(rvalue, &a);
1924         if (r < 0) {
1925                 log_syntax(unit, LOG_WARNING, filename, line, r,
1926                            "Failed to parse socket priority, ignoring: %s", rvalue);
1927                 return 0;
1928         }
1929
1930         network->dhcp_socket_priority_set = true;
1931         network->dhcp_socket_priority = a;
1932
1933         return 0;
1934 }
1935
1936 int config_parse_dhcp_fallback_lease_lifetime(
1937                 const char *unit,
1938                 const char *filename,
1939                 unsigned line,
1940                 const char *section,
1941                 unsigned section_line,
1942                 const char *lvalue,
1943                 int ltype,
1944                 const char *rvalue,
1945                 void *data,
1946                 void *userdata) {
1947
1948         Network *network = userdata;
1949
1950         assert(filename);
1951         assert(section);
1952         assert(lvalue);
1953         assert(rvalue);
1954         assert(data);
1955
1956         if (isempty(rvalue)) {
1957                 network->dhcp_fallback_lease_lifetime_usec = 0;
1958                 return 0;
1959         }
1960
1961         /* We accept only "forever" or "infinity". */
1962         if (!STR_IN_SET(rvalue, "forever", "infinity")) {
1963                 log_syntax(unit, LOG_WARNING, filename, line, 0,
1964                            "Invalid LeaseLifetime= value, ignoring: %s", rvalue);
1965                 return 0;
1966         }
1967
1968         network->dhcp_fallback_lease_lifetime_usec = USEC_INFINITY;
1969
1970         return 0;
1971 }
1972
1973 int config_parse_dhcp_label(
1974                 const char *unit,
1975                 const char *filename,
1976                 unsigned line,
1977                 const char *section,
1978                 unsigned section_line,
1979                 const char *lvalue,
1980                 int ltype,
1981                 const char *rvalue,
1982                 void *data,
1983                 void *userdata) {
1984
1985         char **label = ASSERT_PTR(data);
1986
1987         assert(filename);
1988         assert(lvalue);
1989         assert(rvalue);
1990
1991         if (isempty(rvalue)) {
1992                 *label = mfree(*label);
1993                 return 0;
1994         }
1995
1996         if (!address_label_valid(rvalue)) {
1997                 log_syntax(unit, LOG_WARNING, filename, line, 0,
1998                            "Address label is too long or invalid, ignoring assignment: %s", rvalue);
1999                 return 0;
2000         }
2001
2002         return free_and_strdup_warn(label, rvalue);
2003 }
2004
2005 static const char* const dhcp_client_identifier_table[_DHCP_CLIENT_ID_MAX] = {
2006         [DHCP_CLIENT_ID_MAC]  = "mac",
2007         [DHCP_CLIENT_ID_DUID] = "duid",
2008 };
2009
2010 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING(dhcp_client_identifier, DHCPClientIdentifier);
2011 DEFINE_CONFIG_PARSE_ENUM(config_parse_dhcp_client_identifier, dhcp_client_identifier, DHCPClientIdentifier,
2012                          "Failed to parse client identifier type");