Debian Codegraph @

src/libsystemd-network/sd-dhcp-lease.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2 /***
3 Copyright © 2013 Intel Corporation. All rights reserved.
4 ***/
5
6 #include <sys/stat.h>
7
8 #include "sd-dhcp-lease.h"
9
10 #include "alloc-util.h"
11 #include "dhcp-client-internal.h"
12 #include "dhcp-lease-internal.h"
13 #include "dhcp-route.h"
14 #include "dns-resolver-internal.h"
15 #include "in-addr-util.h"
16 #include "ip-util.h"
17 #include "set.h"
18 #include "string-util.h"
19 #include "strv.h"
20 #include "time-util.h"
21
22 void dhcp_lease_set_timestamp(sd_dhcp_lease *lease, const triple_timestamp *timestamp) {
23 assert(lease);
24
25 if (timestamp && triple_timestamp_is_set(timestamp))
26 lease->timestamp = *timestamp;
27 else
28 triple_timestamp_now(&lease->timestamp);
29 }
30
31 int sd_dhcp_lease_get_timestamp(sd_dhcp_lease *lease, clockid_t clock, uint64_t *ret) {
32 assert_return(lease, -EINVAL);
33 assert_return(TRIPLE_TIMESTAMP_HAS_CLOCK(clock), -EOPNOTSUPP);
34 assert_return(clock_supported(clock), -EOPNOTSUPP);
35
36 if (!triple_timestamp_is_set(&lease->timestamp))
37 return -ENODATA;
38
39 if (ret)
40 *ret = triple_timestamp_by_clock(&lease->timestamp, clock);
41 return 0;
42 }
43
44 int sd_dhcp_lease_get_address(sd_dhcp_lease *lease, struct in_addr *ret) {
45 assert_return(lease, -EINVAL);
46
47 if (lease->address == INADDR_ANY)
48 return -ENODATA;
49
50 if (ret)
51 ret->s_addr = lease->address;
52 return 0;
53 }
54
55 int sd_dhcp_lease_get_broadcast(sd_dhcp_lease *lease, struct in_addr *ret) {
56 assert_return(lease, -EINVAL);
57
58 if (lease->broadcast == INADDR_ANY)
59 return -ENODATA;
60
61 if (ret)
62 ret->s_addr = lease->broadcast;
63 return 0;
64 }
65
66 int sd_dhcp_lease_get_lifetime(sd_dhcp_lease *lease, uint64_t *ret) {
67 assert_return(lease, -EINVAL);
68
69 if (lease->lifetime <= 0)
70 return -ENODATA;
71
72 if (ret)
73 *ret = lease->lifetime;
74 return 0;
75 }
76
77 int sd_dhcp_lease_get_t1(sd_dhcp_lease *lease, uint64_t *ret) {
78 assert_return(lease, -EINVAL);
79
80 if (lease->t1 <= 0)
81 return -ENODATA;
82
83 if (ret)
84 *ret = lease->t1;
85 return 0;
86 }
87
88 int sd_dhcp_lease_get_t2(sd_dhcp_lease *lease, uint64_t *ret) {
89 assert_return(lease, -EINVAL);
90
91 if (lease->t2 <= 0)
92 return -ENODATA;
93
94 if (ret)
95 *ret = lease->t2;
96 return 0;
97 }
98
99 #define DEFINE_GET_TIMESTAMP(name) \
100 int sd_dhcp_lease_get_##name##_timestamp( \
101 sd_dhcp_lease *lease, \
102 clockid_t clock, \
103 uint64_t *ret) { \
104 \
105 usec_t t, timestamp; \
106 int r; \
107 \
108 assert_return(lease, -EINVAL); \
109 \
110 r = sd_dhcp_lease_get_##name(lease, &t); \
111 if (r < 0) \
112 return r; \
113 \
114 r = sd_dhcp_lease_get_timestamp(lease, clock, &timestamp); \
115 if (r < 0) \
116 return r; \
117 \
118 if (ret) \
119 *ret = usec_add(t, timestamp); \
120 return 0; \
121 }
122
123 DEFINE_GET_TIMESTAMP(lifetime);
124 DEFINE_GET_TIMESTAMP(t1);
125 DEFINE_GET_TIMESTAMP(t2);
126
127 int sd_dhcp_lease_get_mtu(sd_dhcp_lease *lease, uint16_t *ret) {
128 assert_return(lease, -EINVAL);
129
130 if (lease->mtu <= 0)
131 return -ENODATA;
132
133 if (ret)
134 *ret = lease->mtu;
135 return 0;
136 }
137
138 int sd_dhcp_lease_get_servers(
139 sd_dhcp_lease *lease,
140 sd_dhcp_lease_server_type_t what,
141 const struct in_addr **ret) {
142
143 assert_return(lease, -EINVAL);
144 assert_return(what >= 0, -EINVAL);
145 assert_return(what < _SD_DHCP_LEASE_SERVER_TYPE_MAX, -EINVAL);
146
147 if (lease->servers[what].size <= 0)
148 return -ENODATA;
149
150 if (ret)
151 *ret = lease->servers[what].addr;
152
153 return (int) lease->servers[what].size;
154 }
155
156 int sd_dhcp_lease_get_dns(sd_dhcp_lease *lease, const struct in_addr **ret) {
157 return sd_dhcp_lease_get_servers(lease, SD_DHCP_LEASE_DNS, ret);
158 }
159 int sd_dhcp_lease_get_ntp(sd_dhcp_lease *lease, const struct in_addr **ret) {
160 return sd_dhcp_lease_get_servers(lease, SD_DHCP_LEASE_NTP, ret);
161 }
162 int sd_dhcp_lease_get_sip(sd_dhcp_lease *lease, const struct in_addr **ret) {
163 return sd_dhcp_lease_get_servers(lease, SD_DHCP_LEASE_SIP, ret);
164 }
165
166 int sd_dhcp_lease_get_domainname(sd_dhcp_lease *lease, const char **ret) {
167 assert_return(lease, -EINVAL);
168
169 if (!lease->domainname)
170 return -ENODATA;
171
172 if (ret)
173 *ret = lease->domainname;
174 return 0;
175 }
176
177 int sd_dhcp_lease_get_hostname(sd_dhcp_lease *lease, const char **ret) {
178 assert_return(lease, -EINVAL);
179
180 if (!lease->hostname)
181 return -ENODATA;
182
183 if (ret)
184 *ret = lease->hostname;
185 return 0;
186 }
187
188 int sd_dhcp_lease_get_captive_portal(sd_dhcp_lease *lease, const char **ret) {
189 assert_return(lease, -EINVAL);
190
191 if (!lease->captive_portal)
192 return -ENODATA;
193
194 if (ret)
195 *ret = lease->captive_portal;
196 return 0;
197 }
198
199 int sd_dhcp_lease_get_dnr(sd_dhcp_lease *lease, sd_dns_resolver **ret) {
200 assert_return(lease, -EINVAL);
201
202 if (!lease->dnr)
203 return -ENODATA;
204
205 if (ret)
206 *ret = lease->dnr;
207 return lease->n_dnr;
208 }
209
210 int sd_dhcp_lease_get_router(sd_dhcp_lease *lease, const struct in_addr **ret) {
211 assert_return(lease, -EINVAL);
212
213 if (lease->router_size <= 0)
214 return -ENODATA;
215
216 if (ret)
217 *ret = lease->router;
218 return (int) lease->router_size;
219 }
220
221 int sd_dhcp_lease_get_netmask(sd_dhcp_lease *lease, struct in_addr *ret) {
222 assert_return(lease, -EINVAL);
223
224 if (lease->subnet_mask == INADDR_ANY)
225 return -ENODATA;
226
227 if (ret)
228 ret->s_addr = lease->subnet_mask;
229 return 0;
230 }
231
232 int sd_dhcp_lease_get_prefix(sd_dhcp_lease *lease, struct in_addr *ret_prefix, uint8_t *ret_prefixlen) {
233 struct in_addr address, netmask;
234 uint8_t prefixlen;
235 int r;
236
237 assert_return(lease, -EINVAL);
238
239 r = sd_dhcp_lease_get_address(lease, &address);
240 if (r < 0)
241 return r;
242
243 r = sd_dhcp_lease_get_netmask(lease, &netmask);
244 if (r < 0)
245 return r;
246
247 prefixlen = in4_addr_netmask_to_prefixlen(&netmask);
248
249 r = in4_addr_mask(&address, prefixlen);
250 if (r < 0)
251 return r;
252
253 if (ret_prefix)
254 *ret_prefix = address;
255 if (ret_prefixlen)
256 *ret_prefixlen = prefixlen;
257 return 0;
258 }
259
260 int sd_dhcp_lease_get_server_identifier(sd_dhcp_lease *lease, struct in_addr *ret) {
261 assert_return(lease, -EINVAL);
262
263 if (lease->server_address == INADDR_ANY)
264 return -ENODATA;
265
266 if (ret)
267 ret->s_addr = lease->server_address;
268 return 0;
269 }
270
271 /*
272 * The returned routes array must be freed by the caller.
273 * Route objects have the same lifetime of the lease and must not be freed.
274 */
275 static int dhcp_lease_get_routes(sd_dhcp_route *routes, size_t n_routes, sd_dhcp_route ***ret) {
276 assert(routes || n_routes == 0);
277
278 if (n_routes <= 0)
279 return -ENODATA;
280
281 if (ret) {
282 sd_dhcp_route **buf;
283
284 buf = new(sd_dhcp_route*, n_routes);
285 if (!buf)
286 return -ENOMEM;
287
288 for (size_t i = 0; i < n_routes; i++)
289 buf[i] = &routes[i];
290
291 *ret = buf;
292 }
293
294 return (int) n_routes;
295 }
296
297 int sd_dhcp_lease_get_static_routes(sd_dhcp_lease *lease, sd_dhcp_route ***ret) {
298 assert_return(lease, -EINVAL);
299
300 return dhcp_lease_get_routes(lease->static_routes, lease->n_static_routes, ret);
301 }
302
303 int sd_dhcp_lease_get_classless_routes(sd_dhcp_lease *lease, sd_dhcp_route ***ret) {
304 assert_return(lease, -EINVAL);
305
306 return dhcp_lease_get_routes(lease->classless_routes, lease->n_classless_routes, ret);
307 }
308
309 int sd_dhcp_lease_get_search_domains(sd_dhcp_lease *lease, char ***ret) {
310 assert_return(lease, -EINVAL);
311
312 size_t n = strv_length(lease->search_domains);
313 if (n == 0)
314 return -ENODATA;
315
316 if (ret)
317 *ret = lease->search_domains;
318 return (int) n;
319 }
320
321 int sd_dhcp_lease_get_6rd(
322 sd_dhcp_lease *lease,
323 uint8_t *ret_ipv4masklen,
324 uint8_t *ret_prefixlen,
325 struct in6_addr *ret_prefix,
326 const struct in_addr **ret_br_addresses,
327 size_t *ret_n_br_addresses) {
328
329 assert_return(lease, -EINVAL);
330
331 if (lease->sixrd_n_br_addresses <= 0)
332 return -ENODATA;
333
334 if (ret_ipv4masklen)
335 *ret_ipv4masklen = lease->sixrd_ipv4masklen;
336 if (ret_prefixlen)
337 *ret_prefixlen = lease->sixrd_prefixlen;
338 if (ret_prefix)
339 *ret_prefix = lease->sixrd_prefix;
340 if (ret_br_addresses)
341 *ret_br_addresses = lease->sixrd_br_addresses;
342 if (ret_n_br_addresses)
343 *ret_n_br_addresses = lease->sixrd_n_br_addresses;
344
345 return 0;
346 }
347
348 int sd_dhcp_lease_has_6rd(sd_dhcp_lease *lease) {
349 return lease && lease->sixrd_n_br_addresses > 0;
350 }
351
352 static sd_dhcp_lease* dhcp_lease_free(sd_dhcp_lease *lease) {
353 assert(lease);
354
355 sd_dhcp_message_unref(lease->message);
356
357 free(lease->router);
358 free(lease->timezone);
359 free(lease->hostname);
360 free(lease->domainname);
361 free(lease->captive_portal);
362
363 for (sd_dhcp_lease_server_type_t i = 0; i < _SD_DHCP_LEASE_SERVER_TYPE_MAX; i++)
364 free(lease->servers[i].addr);
365
366 dns_resolver_free_array(lease->dnr, lease->n_dnr);
367 free(lease->static_routes);
368 free(lease->classless_routes);
369 strv_free(lease->search_domains);
370 free(lease->sixrd_br_addresses);
371 return mfree(lease);
372 }
373
374 DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_dhcp_lease, sd_dhcp_lease, dhcp_lease_free);
375
376 int dhcp_lease_new(sd_dhcp_lease **ret) {
377 sd_dhcp_lease *lease;
378
379 assert(ret);
380
381 lease = new0(sd_dhcp_lease, 1);
382 if (!lease)
383 return -ENOMEM;
384
385 lease->n_ref = 1;
386
387 *ret = lease;
388 return 0;
389 }
390
391 int sd_dhcp_lease_get_timezone(sd_dhcp_lease *lease, const char **ret) {
392 assert_return(lease, -EINVAL);
393
394 if (!lease->timezone)
395 return -ENODATA;
396
397 if (ret)
398 *ret = lease->timezone;
399 return 0;
400 }
401
402 static int dhcp_lease_new_from_message(sd_dhcp_client *client, sd_dhcp_message *message, sd_dhcp_lease **ret) {
403 int r;
404
405 assert(client);
406 assert(message);
407 assert(ret);
408
409 _cleanup_(sd_dhcp_lease_unrefp) sd_dhcp_lease *lease = NULL;
410 r = dhcp_lease_new(&lease);
411 if (r < 0)
412 return r;
413
414 /* acquired address: mandatory */
415 if (message->header.yiaddr == INADDR_ANY)
416 return -EBADMSG;
417 lease->address = message->header.yiaddr;
418
419 /* subnet mask: mandatory */
420 if (dhcp_message_get_option_be32(message, SD_DHCP_OPTION_SUBNET_MASK, &lease->subnet_mask) < 0) {
421 /* fall back to the default subnet masks based on address class */
422 struct in_addr mask;
423 r = in4_addr_default_subnet_mask(
424 &(struct in_addr) {
425 .s_addr = message->header.yiaddr,
426 },
427 &mask);
428 if (r < 0)
429 return r;
430
431 lease->subnet_mask = mask.s_addr;
432 }
433
434 /* DHCP server address: mandatory */
435 r = dhcp_message_get_option_be32(message, SD_DHCP_OPTION_SERVER_IDENTIFIER, &lease->server_address);
436 if (r < 0) {
437 if (!client->bootp)
438 return log_dhcp_client_errno(client, r, "Failed to read %s option: %m",
439 dhcp_option_code_to_string(SD_DHCP_OPTION_SERVER_IDENTIFIER));
440
441 /* BOOTP typically does not use Server Identifier option, but uses the siaddr field. */
442 lease->server_address = message->header.siaddr;
443 }
444
445 /* lifetime: mandatory */
446 if (client->bootp)
447 lease->lifetime = USEC_INFINITY; /* BOOTP does not support lifetime. */
448 else {
449 r = dhcp_message_get_option_sec(message, SD_DHCP_OPTION_IP_ADDRESS_LEASE_TIME, /* max_as_infinity= */ true, &lease->lifetime);
450 if (r < 0 || lease->lifetime == 0) {
451 if (client->fallback_lease_lifetime == 0) {
452 if (r < 0)
453 return log_dhcp_client_errno(client, r, "Failed to read %s option: %m",
454 dhcp_option_code_to_string(SD_DHCP_OPTION_IP_ADDRESS_LEASE_TIME));
455
456 return log_dhcp_client_errno(client, SYNTHETIC_ERRNO(EBADMSG),
457 "The %s option set to 0 second.",
458 dhcp_option_code_to_string(SD_DHCP_OPTION_IP_ADDRESS_LEASE_TIME));
459 }
460
461 lease->lifetime = client->fallback_lease_lifetime;
462 }
463
464 /* There is nothing mentioned about the valid range of the lifetime in RFC, but if it is too
465 * short, then the network connection easily become unstable. Let's bump to 30 seconds in
466 * that case.
467 * TODO: filter short lifetime in selecting state. */
468 if (lease->lifetime <= 30 * USEC_PER_SEC) {
469 log_dhcp_client(client, "The %s option is too short (%s), bumping lease lifetime to 30 seconds.",
470 dhcp_option_code_to_string(SD_DHCP_OPTION_IP_ADDRESS_LEASE_TIME),
471 FORMAT_TIMESPAN(lease->lifetime, USEC_PER_SEC));
472 lease->lifetime = 30 * USEC_PER_SEC;
473 }
474
475 if (lease->lifetime != USEC_INFINITY) {
476 /* T2 */
477 r = dhcp_message_get_option_sec(message, SD_DHCP_OPTION_REBINDING_TIME, /* max_as_infinity= */ true, &lease->t2);
478 if (r < 0 && r != -ENODATA)
479 log_dhcp_client_errno(client, r, "Failed to read %s option, ignoring: %m",
480 dhcp_option_code_to_string(SD_DHCP_OPTION_REBINDING_TIME));
481
482 /* verify that 0 < t2 < lifetime */
483 if (lease->t2 <= 0 || lease->t2 >= lease->lifetime)
484 /* RFC2131 section 4.4.5: T2 defaults to (0.875 * duration_of_lease). */
485 lease->t2 = lease->lifetime * 7 / 8;
486
487 /* T1 */
488 r = dhcp_message_get_option_sec(message, SD_DHCP_OPTION_RENEWAL_TIME, /* max_as_infinity= */ true, &lease->t1);
489 if (r < 0 && r != -ENODATA)
490 log_dhcp_client_errno(client, r, "Failed to read %s option, ignoring: %m",
491 dhcp_option_code_to_string(SD_DHCP_OPTION_RENEWAL_TIME));
492
493 /* verify that 0 < t1 < t2 */
494 if (lease->t1 <= 0 || lease->t1 >= lease->t2)
495 /* RFC2131 section 4.4.5: T1 defaults to (0.5 * duration_of_lease). */
496 lease->t1 = lease->lifetime / 2;
497
498 /* For the case when T2 is too small compared with lifetime. */
499 if (lease->t1 >= lease->t2)
500 /* RFC2131 section 4.4.5: T2 defaults to (0.875 * duration_of_lease). */
501 lease->t2 = lease->lifetime * 7 / 8;
502
503 assert(lease->t1 > 0);
504 assert(lease->t1 < lease->t2);
505 assert(lease->t2 < lease->lifetime);
506 }
507 }
508
509 r = dhcp_message_get_option_be32(message, SD_DHCP_OPTION_BROADCAST, &lease->broadcast);
510 if (r < 0 && r != -ENODATA)
511 log_dhcp_client_errno(client, r, "Failed to parse %s option, ignoring: %m",
512 dhcp_option_code_to_string(SD_DHCP_OPTION_BROADCAST));
513
514 r = dhcp_message_get_option_addresses(
515 message,
516 SD_DHCP_OPTION_ROUTER,
517 &lease->router_size,
518 &lease->router);
519 if (r < 0 && r != -ENODATA)
520 log_dhcp_client_errno(client, r, "Failed to parse %s option, ignoring: %m",
521 dhcp_option_code_to_string(SD_DHCP_OPTION_ROUTER));
522
523 r = dhcp_message_get_option_addresses(
524 message,
525 SD_DHCP_OPTION_DOMAIN_NAME_SERVER,
526 &lease->servers[SD_DHCP_LEASE_DNS].size,
527 &lease->servers[SD_DHCP_LEASE_DNS].addr);
528 if (r < 0 && r != -ENODATA)
529 log_dhcp_client_errno(client, r, "Failed to parse %s option, ignoring: %m",
530 dhcp_option_code_to_string(SD_DHCP_OPTION_DOMAIN_NAME_SERVER));
531
532 r = dhcp_message_get_option_addresses(
533 message,
534 SD_DHCP_OPTION_NTP_SERVER,
535 &lease->servers[SD_DHCP_LEASE_NTP].size,
536 &lease->servers[SD_DHCP_LEASE_NTP].addr);
537 if (r < 0 && r != -ENODATA)
538 log_dhcp_client_errno(client, r, "Failed to parse %s option, ignoring: %m",
539 dhcp_option_code_to_string(SD_DHCP_OPTION_NTP_SERVER));
540
541 r = dhcp_message_get_option_addresses(
542 message,
543 SD_DHCP_OPTION_SIP_SERVER,
544 &lease->servers[SD_DHCP_LEASE_SIP].size,
545 &lease->servers[SD_DHCP_LEASE_SIP].addr);
546 if (r < 0 && r != -ENODATA)
547 log_dhcp_client_errno(client, r, "Failed to parse %s option, ignoring: %m",
548 dhcp_option_code_to_string(SD_DHCP_OPTION_SIP_SERVER));
549
550 r = dhcp_message_get_option_routes(
551 message,
552 SD_DHCP_OPTION_STATIC_ROUTE,
553 &lease->n_static_routes,
554 &lease->static_routes);
555 if (r < 0 && r != -ENODATA)
556 log_dhcp_client_errno(client, r, "Failed to parse %s option, ignoring: %m",
557 dhcp_option_code_to_string(SD_DHCP_OPTION_STATIC_ROUTE));
558
559 r = dhcp_message_get_option_routes(
560 message,
561 SD_DHCP_OPTION_CLASSLESS_STATIC_ROUTE,
562 &lease->n_classless_routes,
563 &lease->classless_routes);
564 if (r < 0) {
565 if (r != -ENODATA)
566 log_dhcp_client_errno(client, r, "Failed to parse %s option, ignoring: %m",
567 dhcp_option_code_to_string(SD_DHCP_OPTION_CLASSLESS_STATIC_ROUTE));
568
569 r = dhcp_message_get_option_routes(
570 message,
571 SD_DHCP_OPTION_PRIVATE_CLASSLESS_STATIC_ROUTE,
572 &lease->n_classless_routes,
573 &lease->classless_routes);
574 if (r < 0 && r != -ENODATA)
575 log_dhcp_client_errno(client, r, "Failed to parse %s option, ignoring: %m",
576 dhcp_option_code_to_string(SD_DHCP_OPTION_PRIVATE_CLASSLESS_STATIC_ROUTE));
577 }
578
579 r = dhcp_message_get_option_6rd(
580 message,
581 &lease->sixrd_ipv4masklen,
582 &lease->sixrd_prefixlen,
583 &lease->sixrd_prefix,
584 &lease->sixrd_n_br_addresses,
585 &lease->sixrd_br_addresses);
586 if (r < 0 && r != -ENODATA)
587 log_dhcp_client_errno(client, r, "Failed to parse %s option, ignoring: %m",
588 dhcp_option_code_to_string(SD_DHCP_OPTION_6RD));
589
590 r = dhcp_message_get_option_dns_name(message, SD_DHCP_OPTION_DOMAIN_NAME, &lease->domainname);
591 if (r < 0 && r != -ENODATA)
592 log_dhcp_client_errno(client, r, "Failed to parse %s option, ignoring: %m",
593 dhcp_option_code_to_string(SD_DHCP_OPTION_DOMAIN_NAME));
594
595 r = dhcp_message_get_option_hostname(message, &lease->hostname);
596 if (r < 0 && r != -ENODATA)
597 log_dhcp_client_errno(client, r, "Failed to parse %s and/or %s option, ignoring: %m",
598 dhcp_option_code_to_string(SD_DHCP_OPTION_FQDN),
599 dhcp_option_code_to_string(SD_DHCP_OPTION_HOST_NAME));
600
601 r = dhcp_message_get_option_domains(message, SD_DHCP_OPTION_DOMAIN_SEARCH, &lease->search_domains);
602 if (r < 0 && r != -ENODATA)
603 log_dhcp_client_errno(client, r, "Failed to parse %s option, ignoring: %m",
604 dhcp_option_code_to_string(SD_DHCP_OPTION_DOMAIN_SEARCH));
605
606 r = dhcp_message_get_option_dnr(message, &lease->n_dnr, &lease->dnr);
607 if (r < 0 && r != -ENODATA)
608 log_dhcp_client_errno(client, r, "Failed to parse %s option, ignoring: %m",
609 dhcp_option_code_to_string(SD_DHCP_OPTION_V4_DNR));
610
611 _cleanup_free_ char *captive_portal = NULL;
612 r = dhcp_message_get_option_string(message, SD_DHCP_OPTION_DHCP_CAPTIVE_PORTAL, &captive_portal);
613 if (r >= 0) {
614 if (!in_charset(captive_portal, URI_VALID))
615 log_dhcp_client(client, "Received invalid %s, ignoring: %s",
616 dhcp_option_code_to_string(SD_DHCP_OPTION_DHCP_CAPTIVE_PORTAL),
617 captive_portal);
618 else
619 lease->captive_portal = TAKE_PTR(captive_portal);
620 } else if (r != -ENODATA)
621 log_dhcp_client_errno(client, r, "Failed to parse %s option, ignoring: %m",
622 dhcp_option_code_to_string(SD_DHCP_OPTION_DHCP_CAPTIVE_PORTAL));
623
624 _cleanup_free_ char *tz = NULL;
625 r = dhcp_message_get_option_string(message, SD_DHCP_OPTION_TZDB_TIMEZONE, &tz);
626 if (r >= 0) {
627 if (!timezone_is_valid(tz, LOG_DEBUG))
628 log_dhcp_client(client, "Received invalid %s, ignoring: %s",
629 dhcp_option_code_to_string(SD_DHCP_OPTION_TZDB_TIMEZONE), tz);
630 else
631 lease->timezone = TAKE_PTR(tz);
632 } else if (r != -ENODATA)
633 log_dhcp_client_errno(client, r, "Failed to parse %s option, ignoring: %m",
634 dhcp_option_code_to_string(SD_DHCP_OPTION_TZDB_TIMEZONE));
635
636 uint16_t mtu;
637 r = dhcp_message_get_option_u16(message, SD_DHCP_OPTION_MTU_INTERFACE, &mtu);
638 if (r >= 0) {
639 /* RFC 2132 section 5.1 permits MTU values down to 68 bytes, which corresponds to the minimum
640 * IPv4 datagram size defined in RFC 791.
641 *
642 * Such a small MTU is not generally usable for normal IP communication. RFC 791 and RFC 1122
643 * require hosts to be able to reassemble datagrams of at least 576 bytes, which is treated
644 * as the minimum safe size for IPv4 interoperability.
645 *
646 * Ignore MTU values smaller than 576 bytes. */
647 if (mtu < IPV4_MIN_REASSEMBLY_SIZE)
648 log_dhcp_client(client, "Received too small %s, ignoring: %u",
649 dhcp_option_code_to_string(SD_DHCP_OPTION_MTU_INTERFACE), mtu);
650 else
651 lease->mtu = mtu;
652 } else if (r != -ENODATA)
653 log_dhcp_client_errno(client, r, "Failed to parse %s option, ignoring: %m",
654 dhcp_option_code_to_string(SD_DHCP_OPTION_MTU_INTERFACE));
655
656 /* RFC 8925 section 3.2
657 * If the client did not include the IPv6-Only Preferred option code in the Parameter Request List in
658 * the DHCPDISCOVER or DHCPREQUEST message, it MUST ignore the IPv6-Only Preferred option in any
659 * messages received from the server. */
660 if (!client->anonymize &&
661 set_contains(client->req_opts, UINT_TO_PTR(SD_DHCP_OPTION_IPV6_ONLY_PREFERRED))) {
662 usec_t t;
663 r = dhcp_message_get_option_sec(
664 message,
665 SD_DHCP_OPTION_IPV6_ONLY_PREFERRED,
666 /* max_as_infinity= */ false,
667 &t);
668 if (r >= 0) {
669 /* RFC 8925 section 3.4
670 * MIN_V6ONLY_WAIT: The lower boundary for V6ONLY_WAIT. */
671 if (t < MIN_V6ONLY_WAIT_USEC && !network_test_mode_enabled())
672 lease->ipv6_only_preferred_usec = MIN_V6ONLY_WAIT_USEC;
673 else
674 lease->ipv6_only_preferred_usec = t;
675 } else if (r != -ENODATA)
676 log_dhcp_client_errno(client, r, "Failed to parse %s option, ignoring: %m",
677 dhcp_option_code_to_string(SD_DHCP_OPTION_IPV6_ONLY_PREFERRED));
678 }
679
680 lease->message = sd_dhcp_message_ref(message);
681 *ret = TAKE_PTR(lease);
682 return 0;
683 }
684
685 static int client_parse_bootreply(sd_dhcp_client *client, sd_dhcp_message *message, sd_dhcp_lease **ret) {
686 int r;
687
688 assert(client);
689 assert(message);
690 assert(ret);
691
692 if (client->state != DHCP_STATE_SELECTING)
693 return log_dhcp_client_errno(client, SYNTHETIC_ERRNO(EBADMSG), "Received unexpected BOOTREPLY.");
694
695 _cleanup_(sd_dhcp_lease_unrefp) sd_dhcp_lease *lease = NULL;
696 r = dhcp_lease_new_from_message(client, message, &lease);
697 if (r < 0)
698 return log_dhcp_client_errno(client, r, "Failed to create BOOTP lease: %m");
699
700 log_dhcp_client(client, "Received BOOTREPLY from %s", IN4_ADDR_TO_STRING(&(struct in_addr) { .s_addr = lease->server_address }));
701
702 *ret = TAKE_PTR(lease);
703 return DHCP_ACK;
704 }
705
706 static int client_parse_ack(sd_dhcp_client *client, sd_dhcp_message *message, sd_dhcp_lease **ret) {
707 int r;
708
709 assert(client);
710 assert(message);
711 assert(ret);
712
713 switch (client->state) {
714 case DHCP_STATE_SELECTING:
715 if (!client->rapid_commit)
716 return log_dhcp_client_errno(client, SYNTHETIC_ERRNO(EBADMSG), "Received unexpected DHCPACK.");
717
718 r = dhcp_message_get_option_flag(message, SD_DHCP_OPTION_RAPID_COMMIT);
719 if (r < 0)
720 return log_dhcp_client_errno(client, r, "Failed to get Rapid Commit option: %m");
721
722 break;
723 case DHCP_STATE_REBOOTING:
724 case DHCP_STATE_REQUESTING:
725 case DHCP_STATE_RENEWING:
726 case DHCP_STATE_REBINDING:
727 break;
728 default:
729 return log_dhcp_client_errno(client, SYNTHETIC_ERRNO(EBADMSG), "Received unexpected DHCPACK.");
730 }
731
732 _cleanup_(sd_dhcp_lease_unrefp) sd_dhcp_lease *lease = NULL;
733 r = dhcp_lease_new_from_message(client, message, &lease);
734 if (r < 0)
735 return log_dhcp_client_errno(client, r, "Failed to create DHCP lease: %m");
736
737 log_dhcp_client(client, "Received DHCPACK from %s", IN4_ADDR_TO_STRING(&(struct in_addr) { .s_addr = lease->server_address }));
738
739 *ret = TAKE_PTR(lease);
740 return DHCP_ACK;
741 }
742
743 static int client_parse_offer(sd_dhcp_client *client, sd_dhcp_message *message, sd_dhcp_lease **ret) {
744 int r;
745
746 assert(client);
747 assert(message);
748 assert(ret);
749
750 if (client->state != DHCP_STATE_SELECTING)
751 return log_dhcp_client_errno(client, SYNTHETIC_ERRNO(EBADMSG), "Received unexpected DHCPOFFER.");
752
753 _cleanup_(sd_dhcp_lease_unrefp) sd_dhcp_lease *lease = NULL;
754 r = dhcp_lease_new_from_message(client, message, &lease);
755 if (r < 0)
756 return log_dhcp_client_errno(client, r, "Failed to create DHCP lease: %m");
757
758 log_dhcp_client(client, "Received DHCPOFFER from %s", IN4_ADDR_TO_STRING(&(struct in_addr) { .s_addr = lease->server_address }));
759
760 *ret = TAKE_PTR(lease);
761 return DHCP_OFFER;
762 }
763
764 static int client_parse_nak(sd_dhcp_client *client, sd_dhcp_message *message, sd_dhcp_lease **ret) {
765 int r;
766
767 assert(client);
768 assert(message);
769 assert(ret);
770
771 /* DHCPNAK is a valid reply when we sent DHCPREQUEST. When we receive it after sending
772 * DHCPDISCOVER (or even we sent nothing), we should ignore the message. */
773 if (!IN_SET(client->state, DHCP_STATE_REBOOTING, DHCP_STATE_REQUESTING, DHCP_STATE_RENEWING, DHCP_STATE_REBINDING))
774 return log_dhcp_client_errno(client, SYNTHETIC_ERRNO(EBADMSG), "Received unexpected DHCPNAK.");
775
776 /* Always ignore DHCPNAK without Server Identifier option. */
777 struct in_addr a;
778 r = dhcp_message_get_option_address(message, SD_DHCP_OPTION_SERVER_IDENTIFIER, &a);
779 if (r < 0)
780 return log_dhcp_client_errno(client, r, "Failed to read Server Identifier option in DHCPNAK: %m");
781
782 if (client->lease && client->lease->server_address != a.s_addr)
783 return log_dhcp_client_errno(client, SYNTHETIC_ERRNO(EBADMSG),
784 "Received DHCPNAK from unexpected server (%s).",
785 IN4_ADDR_TO_STRING(&a));
786
787 _cleanup_free_ char *e = NULL;
788 (void) dhcp_message_get_option_string(message, SD_DHCP_OPTION_ERROR_MESSAGE, &e);
789 log_dhcp_client(client, "Received DHCPNAK: %s", strna(e));
790
791 *ret = NULL;
792 return DHCP_NAK;
793 }
794
795 int dhcp_client_parse_message(sd_dhcp_client *client, const struct iovec *iov, sd_dhcp_lease **ret) {
796 int r;
797
798 assert(client);
799 assert(iov);
800 assert(ret);
801
802 _cleanup_(sd_dhcp_message_unrefp) sd_dhcp_message *message = NULL;
803 r = dhcp_message_parse(
804 iov,
805 BOOTREPLY,
806 &client->xid,
807 client->arp_type,
808 &client->hw_addr,
809 &message);
810 if (r < 0)
811 return r;
812
813 if (client->bootp)
814 return client_parse_bootreply(client, message, ret);
815
816 uint8_t type;
817 r = dhcp_message_get_option_u8(message, SD_DHCP_OPTION_MESSAGE_TYPE, &type);
818 if (r < 0)
819 return log_dhcp_client_errno(client, r, "Failed to read Message Type option: %m");
820
821 switch (type) {
822 case DHCP_OFFER:
823 return client_parse_offer(client, message, ret);
824 case DHCP_ACK:
825 return client_parse_ack(client, message, ret);
826 case DHCP_NAK:
827 return client_parse_nak(client, message, ret);
828 default:
829 return log_dhcp_client_errno(client, SYNTHETIC_ERRNO(EBADMSG), "Received message with unexpected type (%u).", type);
830 }
831 }