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