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