]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/libsystemd-network/sd-dhcp-lease.c
projects / thirdparty / systemd.git / blob
? search:


9db0a9389817d603897452d080d6568f2b8169f9
[thirdparty/systemd.git] / src / libsystemd-network / sd-dhcp-lease.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
2 /***
3 This file is part of systemd.
4
5 Copyright (C) 2013 Intel Corporation. All rights reserved.
6 Copyright (C) 2014 Tom Gundersen
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <arpa/inet.h>
23 #include <errno.h>
24 #include <stdio.h>
25 #include <stdio_ext.h>
26 #include <stdlib.h>
27 #include <string.h>
28
29 #include "sd-dhcp-lease.h"
30
31 #include "alloc-util.h"
32 #include "dhcp-lease-internal.h"
33 #include "dhcp-protocol.h"
34 #include "dns-domain.h"
35 #include "fd-util.h"
36 #include "fileio.h"
37 #include "hexdecoct.h"
38 #include "hostname-util.h"
39 #include "in-addr-util.h"
40 #include "network-internal.h"
41 #include "parse-util.h"
42 #include "stdio-util.h"
43 #include "string-util.h"
44 #include "unaligned.h"
45
46 int sd_dhcp_lease_get_address(sd_dhcp_lease *lease, struct in_addr *addr) {
47 assert_return(lease, -EINVAL);
48 assert_return(addr, -EINVAL);
49
50 if (lease->address == 0)
51 return -ENODATA;
52
53 addr->s_addr = lease->address;
54 return 0;
55 }
56
57 int sd_dhcp_lease_get_broadcast(sd_dhcp_lease *lease, struct in_addr *addr) {
58 assert_return(lease, -EINVAL);
59 assert_return(addr, -EINVAL);
60
61 if (!lease->have_broadcast)
62 return -ENODATA;
63
64 addr->s_addr = lease->broadcast;
65 return 0;
66 }
67
68 int sd_dhcp_lease_get_lifetime(sd_dhcp_lease *lease, uint32_t *lifetime) {
69 assert_return(lease, -EINVAL);
70 assert_return(lifetime, -EINVAL);
71
72 if (lease->lifetime <= 0)
73 return -ENODATA;
74
75 *lifetime = lease->lifetime;
76 return 0;
77 }
78
79 int sd_dhcp_lease_get_t1(sd_dhcp_lease *lease, uint32_t *t1) {
80 assert_return(lease, -EINVAL);
81 assert_return(t1, -EINVAL);
82
83 if (lease->t1 <= 0)
84 return -ENODATA;
85
86 *t1 = lease->t1;
87 return 0;
88 }
89
90 int sd_dhcp_lease_get_t2(sd_dhcp_lease *lease, uint32_t *t2) {
91 assert_return(lease, -EINVAL);
92 assert_return(t2, -EINVAL);
93
94 if (lease->t2 <= 0)
95 return -ENODATA;
96
97 *t2 = lease->t2;
98 return 0;
99 }
100
101 int sd_dhcp_lease_get_mtu(sd_dhcp_lease *lease, uint16_t *mtu) {
102 assert_return(lease, -EINVAL);
103 assert_return(mtu, -EINVAL);
104
105 if (lease->mtu <= 0)
106 return -ENODATA;
107
108 *mtu = lease->mtu;
109 return 0;
110 }
111
112 int sd_dhcp_lease_get_dns(sd_dhcp_lease *lease, const struct in_addr **addr) {
113 assert_return(lease, -EINVAL);
114 assert_return(addr, -EINVAL);
115
116 if (lease->dns_size <= 0)
117 return -ENODATA;
118
119 *addr = lease->dns;
120 return (int) lease->dns_size;
121 }
122
123 int sd_dhcp_lease_get_ntp(sd_dhcp_lease *lease, const struct in_addr **addr) {
124 assert_return(lease, -EINVAL);
125 assert_return(addr, -EINVAL);
126
127 if (lease->ntp_size <= 0)
128 return -ENODATA;
129
130 *addr = lease->ntp;
131 return (int) lease->ntp_size;
132 }
133
134 int sd_dhcp_lease_get_domainname(sd_dhcp_lease *lease, const char **domainname) {
135 assert_return(lease, -EINVAL);
136 assert_return(domainname, -EINVAL);
137
138 if (!lease->domainname)
139 return -ENODATA;
140
141 *domainname = lease->domainname;
142 return 0;
143 }
144
145 int sd_dhcp_lease_get_hostname(sd_dhcp_lease *lease, const char **hostname) {
146 assert_return(lease, -EINVAL);
147 assert_return(hostname, -EINVAL);
148
149 if (!lease->hostname)
150 return -ENODATA;
151
152 *hostname = lease->hostname;
153 return 0;
154 }
155
156 int sd_dhcp_lease_get_root_path(sd_dhcp_lease *lease, const char **root_path) {
157 assert_return(lease, -EINVAL);
158 assert_return(root_path, -EINVAL);
159
160 if (!lease->root_path)
161 return -ENODATA;
162
163 *root_path = lease->root_path;
164 return 0;
165 }
166
167 int sd_dhcp_lease_get_router(sd_dhcp_lease *lease, struct in_addr *addr) {
168 assert_return(lease, -EINVAL);
169 assert_return(addr, -EINVAL);
170
171 if (lease->router == 0)
172 return -ENODATA;
173
174 addr->s_addr = lease->router;
175 return 0;
176 }
177
178 int sd_dhcp_lease_get_netmask(sd_dhcp_lease *lease, struct in_addr *addr) {
179 assert_return(lease, -EINVAL);
180 assert_return(addr, -EINVAL);
181
182 if (!lease->have_subnet_mask)
183 return -ENODATA;
184
185 addr->s_addr = lease->subnet_mask;
186 return 0;
187 }
188
189 int sd_dhcp_lease_get_server_identifier(sd_dhcp_lease *lease, struct in_addr *addr) {
190 assert_return(lease, -EINVAL);
191 assert_return(addr, -EINVAL);
192
193 if (lease->server_address == 0)
194 return -ENODATA;
195
196 addr->s_addr = lease->server_address;
197 return 0;
198 }
199
200 int sd_dhcp_lease_get_next_server(sd_dhcp_lease *lease, struct in_addr *addr) {
201 assert_return(lease, -EINVAL);
202 assert_return(addr, -EINVAL);
203
204 if (lease->next_server == 0)
205 return -ENODATA;
206
207 addr->s_addr = lease->next_server;
208 return 0;
209 }
210
211 /*
212 * The returned routes array must be freed by the caller.
213 * Route objects have the same lifetime of the lease and must not be freed.
214 */
215 int sd_dhcp_lease_get_routes(sd_dhcp_lease *lease, sd_dhcp_route ***routes) {
216 sd_dhcp_route **ret;
217 unsigned i;
218
219 assert_return(lease, -EINVAL);
220 assert_return(routes, -EINVAL);
221
222 if (lease->static_route_size <= 0)
223 return -ENODATA;
224
225 ret = new(sd_dhcp_route *, lease->static_route_size);
226 if (!ret)
227 return -ENOMEM;
228
229 for (i = 0; i < lease->static_route_size; i++)
230 ret[i] = &lease->static_route[i];
231
232 *routes = ret;
233 return (int) lease->static_route_size;
234 }
235
236 int sd_dhcp_lease_get_search_domains(sd_dhcp_lease *lease, char ***domains) {
237 unsigned r;
238
239 assert_return(lease, -EINVAL);
240 assert_return(domains, -EINVAL);
241
242 r = strv_length(lease->search_domains);
243 if (r > 0) {
244 *domains = lease->search_domains;
245 return (int) r;
246 }
247
248 return -ENODATA;
249 }
250
251 int sd_dhcp_lease_get_vendor_specific(sd_dhcp_lease *lease, const void **data, size_t *data_len) {
252 assert_return(lease, -EINVAL);
253 assert_return(data, -EINVAL);
254 assert_return(data_len, -EINVAL);
255
256 if (lease->vendor_specific_len <= 0)
257 return -ENODATA;
258
259 *data = lease->vendor_specific;
260 *data_len = lease->vendor_specific_len;
261 return 0;
262 }
263
264 sd_dhcp_lease *sd_dhcp_lease_ref(sd_dhcp_lease *lease) {
265
266 if (!lease)
267 return NULL;
268
269 assert(lease->n_ref >= 1);
270 lease->n_ref++;
271
272 return lease;
273 }
274
275 sd_dhcp_lease *sd_dhcp_lease_unref(sd_dhcp_lease *lease) {
276
277 if (!lease)
278 return NULL;
279
280 assert(lease->n_ref >= 1);
281 lease->n_ref--;
282
283 if (lease->n_ref > 0)
284 return NULL;
285
286 while (lease->private_options) {
287 struct sd_dhcp_raw_option *option = lease->private_options;
288
289 LIST_REMOVE(options, lease->private_options, option);
290
291 free(option->data);
292 free(option);
293 }
294
295 free(lease->hostname);
296 free(lease->domainname);
297 free(lease->dns);
298 free(lease->ntp);
299 free(lease->static_route);
300 free(lease->client_id);
301 free(lease->vendor_specific);
302 strv_free(lease->search_domains);
303 return mfree(lease);
304 }
305
306 static int lease_parse_u32(const uint8_t *option, size_t len, uint32_t *ret, uint32_t min) {
307 assert(option);
308 assert(ret);
309
310 if (len != 4)
311 return -EINVAL;
312
313 *ret = unaligned_read_be32((be32_t*) option);
314 if (*ret < min)
315 *ret = min;
316
317 return 0;
318 }
319
320 static int lease_parse_u16(const uint8_t *option, size_t len, uint16_t *ret, uint16_t min) {
321 assert(option);
322 assert(ret);
323
324 if (len != 2)
325 return -EINVAL;
326
327 *ret = unaligned_read_be16((be16_t*) option);
328 if (*ret < min)
329 *ret = min;
330
331 return 0;
332 }
333
334 static int lease_parse_be32(const uint8_t *option, size_t len, be32_t *ret) {
335 assert(option);
336 assert(ret);
337
338 if (len != 4)
339 return -EINVAL;
340
341 memcpy(ret, option, 4);
342 return 0;
343 }
344
345 static int lease_parse_string(const uint8_t *option, size_t len, char **ret) {
346 assert(option);
347 assert(ret);
348
349 if (len <= 0)
350 *ret = mfree(*ret);
351 else {
352 char *string;
353
354 /*
355 * One trailing NUL byte is OK, we don't mind. See:
356 * https://github.com/systemd/systemd/issues/1337
357 */
358 if (memchr(option, 0, len - 1))
359 return -EINVAL;
360
361 string = strndup((const char *) option, len);
362 if (!string)
363 return -ENOMEM;
364
365 free(*ret);
366 *ret = string;
367 }
368
369 return 0;
370 }
371
372 static int lease_parse_domain(const uint8_t *option, size_t len, char **ret) {
373 _cleanup_free_ char *name = NULL, *normalized = NULL;
374 int r;
375
376 assert(option);
377 assert(ret);
378
379 r = lease_parse_string(option, len, &name);
380 if (r < 0)
381 return r;
382 if (!name) {
383 *ret = mfree(*ret);
384 return 0;
385 }
386
387 r = dns_name_normalize(name, &normalized);
388 if (r < 0)
389 return r;
390
391 if (is_localhost(normalized))
392 return -EINVAL;
393
394 if (dns_name_is_root(normalized))
395 return -EINVAL;
396
397 free_and_replace(*ret, normalized);
398
399 return 0;
400 }
401
402 static void filter_bogus_addresses(struct in_addr *addresses, size_t *n) {
403 size_t i, j;
404
405 /* Silently filter DNS/NTP servers supplied to us that do not make outside of the local scope. */
406
407 for (i = 0, j = 0; i < *n; i ++) {
408
409 if (in4_addr_is_null(addresses+i) ||
410 in4_addr_is_localhost(addresses+i))
411 continue;
412
413 addresses[j++] = addresses[i];
414 }
415
416 *n = j;
417 }
418
419 static int lease_parse_in_addrs(const uint8_t *option, size_t len, struct in_addr **ret, size_t *n_ret) {
420 assert(option);
421 assert(ret);
422 assert(n_ret);
423
424 if (len <= 0) {
425 *ret = mfree(*ret);
426 *n_ret = 0;
427 } else {
428 size_t n_addresses;
429 struct in_addr *addresses;
430
431 if (len % 4 != 0)
432 return -EINVAL;
433
434 n_addresses = len / 4;
435
436 addresses = newdup(struct in_addr, option, n_addresses);
437 if (!addresses)
438 return -ENOMEM;
439
440 filter_bogus_addresses(addresses, &n_addresses);
441
442 free(*ret);
443 *ret = addresses;
444 *n_ret = n_addresses;
445 }
446
447 return 0;
448 }
449
450 static int lease_parse_routes(
451 const uint8_t *option, size_t len,
452 struct sd_dhcp_route **routes, size_t *routes_size, size_t *routes_allocated) {
453
454 struct in_addr addr;
455
456 assert(option || len <= 0);
457 assert(routes);
458 assert(routes_size);
459 assert(routes_allocated);
460
461 if (len <= 0)
462 return 0;
463
464 if (len % 8 != 0)
465 return -EINVAL;
466
467 if (!GREEDY_REALLOC(*routes, *routes_allocated, *routes_size + (len / 8)))
468 return -ENOMEM;
469
470 while (len >= 8) {
471 struct sd_dhcp_route *route = *routes + *routes_size;
472 int r;
473
474 route->option = SD_DHCP_OPTION_STATIC_ROUTE;
475 r = in4_addr_default_prefixlen((struct in_addr*) option, &route->dst_prefixlen);
476 if (r < 0) {
477 log_debug("Failed to determine destination prefix length from class based IP, ignoring");
478 continue;
479 }
480
481 assert_se(lease_parse_be32(option, 4, &addr.s_addr) >= 0);
482 route->dst_addr = inet_makeaddr(inet_netof(addr), 0);
483 option += 4;
484
485 assert_se(lease_parse_be32(option, 4, &route->gw_addr.s_addr) >= 0);
486 option += 4;
487
488 len -= 8;
489 (*routes_size)++;
490 }
491
492 return 0;
493 }
494
495 /* parses RFC3442 Classless Static Route Option */
496 static int lease_parse_classless_routes(
497 const uint8_t *option, size_t len,
498 struct sd_dhcp_route **routes, size_t *routes_size, size_t *routes_allocated) {
499
500 assert(option || len <= 0);
501 assert(routes);
502 assert(routes_size);
503 assert(routes_allocated);
504
505 if (len <= 0)
506 return 0;
507
508 /* option format: (subnet-mask-width significant-subnet-octets gateway-ip)* */
509
510 while (len > 0) {
511 uint8_t dst_octets;
512 struct sd_dhcp_route *route;
513
514 if (!GREEDY_REALLOC(*routes, *routes_allocated, *routes_size + 1))
515 return -ENOMEM;
516
517 route = *routes + *routes_size;
518 route->option = SD_DHCP_OPTION_CLASSLESS_STATIC_ROUTE;
519
520 dst_octets = (*option == 0 ? 0 : ((*option - 1) / 8) + 1);
521 route->dst_prefixlen = *option;
522 option++;
523 len--;
524
525 /* can't have more than 4 octets in IPv4 */
526 if (dst_octets > 4 || len < dst_octets)
527 return -EINVAL;
528
529 route->dst_addr.s_addr = 0;
530 memcpy(&route->dst_addr.s_addr, option, dst_octets);
531 option += dst_octets;
532 len -= dst_octets;
533
534 if (len < 4)
535 return -EINVAL;
536
537 assert_se(lease_parse_be32(option, 4, &route->gw_addr.s_addr) >= 0);
538 option += 4;
539 len -= 4;
540
541 (*routes_size)++;
542 }
543
544 return 0;
545 }
546
547 int dhcp_lease_parse_options(uint8_t code, uint8_t len, const void *option, void *userdata) {
548 sd_dhcp_lease *lease = userdata;
549 int r;
550
551 assert(lease);
552
553 switch(code) {
554
555 case SD_DHCP_OPTION_IP_ADDRESS_LEASE_TIME:
556 r = lease_parse_u32(option, len, &lease->lifetime, 1);
557 if (r < 0)
558 log_debug_errno(r, "Failed to parse lease time, ignoring: %m");
559
560 break;
561
562 case SD_DHCP_OPTION_SERVER_IDENTIFIER:
563 r = lease_parse_be32(option, len, &lease->server_address);
564 if (r < 0)
565 log_debug_errno(r, "Failed to parse server identifier, ignoring: %m");
566
567 break;
568
569 case SD_DHCP_OPTION_SUBNET_MASK:
570 r = lease_parse_be32(option, len, &lease->subnet_mask);
571 if (r < 0)
572 log_debug_errno(r, "Failed to parse subnet mask, ignoring: %m");
573 else
574 lease->have_subnet_mask = true;
575 break;
576
577 case SD_DHCP_OPTION_BROADCAST:
578 r = lease_parse_be32(option, len, &lease->broadcast);
579 if (r < 0)
580 log_debug_errno(r, "Failed to parse broadcast address, ignoring: %m");
581 else
582 lease->have_broadcast = true;
583 break;
584
585 case SD_DHCP_OPTION_ROUTER:
586 if (len >= 4) {
587 r = lease_parse_be32(option, 4, &lease->router);
588 if (r < 0)
589 log_debug_errno(r, "Failed to parse router address, ignoring: %m");
590 }
591 break;
592
593 case SD_DHCP_OPTION_DOMAIN_NAME_SERVER:
594 r = lease_parse_in_addrs(option, len, &lease->dns, &lease->dns_size);
595 if (r < 0)
596 log_debug_errno(r, "Failed to parse DNS server, ignoring: %m");
597 break;
598
599 case SD_DHCP_OPTION_NTP_SERVER:
600 r = lease_parse_in_addrs(option, len, &lease->ntp, &lease->ntp_size);
601 if (r < 0)
602 log_debug_errno(r, "Failed to parse NTP server, ignoring: %m");
603 break;
604
605 case SD_DHCP_OPTION_STATIC_ROUTE:
606 r = lease_parse_routes(option, len, &lease->static_route, &lease->static_route_size, &lease->static_route_allocated);
607 if (r < 0)
608 log_debug_errno(r, "Failed to parse static routes, ignoring: %m");
609 break;
610
611 case SD_DHCP_OPTION_INTERFACE_MTU:
612 r = lease_parse_u16(option, len, &lease->mtu, 68);
613 if (r < 0)
614 log_debug_errno(r, "Failed to parse MTU, ignoring: %m");
615 if (lease->mtu < DHCP_DEFAULT_MIN_SIZE) {
616 log_debug("MTU value of %" PRIu16 " too small. Using default MTU value of %d instead.", lease->mtu, DHCP_DEFAULT_MIN_SIZE);
617 lease->mtu = DHCP_DEFAULT_MIN_SIZE;
618 }
619
620 break;
621
622 case SD_DHCP_OPTION_DOMAIN_NAME:
623 r = lease_parse_domain(option, len, &lease->domainname);
624 if (r < 0) {
625 log_debug_errno(r, "Failed to parse domain name, ignoring: %m");
626 return 0;
627 }
628
629 break;
630
631 case SD_DHCP_OPTION_DOMAIN_SEARCH_LIST:
632 r = dhcp_lease_parse_search_domains(option, len, &lease->search_domains);
633 if (r < 0)
634 log_debug_errno(r, "Failed to parse Domain Search List, ignoring: %m");
635 break;
636
637 case SD_DHCP_OPTION_HOST_NAME:
638 r = lease_parse_domain(option, len, &lease->hostname);
639 if (r < 0) {
640 log_debug_errno(r, "Failed to parse host name, ignoring: %m");
641 return 0;
642 }
643
644 break;
645
646 case SD_DHCP_OPTION_ROOT_PATH:
647 r = lease_parse_string(option, len, &lease->root_path);
648 if (r < 0)
649 log_debug_errno(r, "Failed to parse root path, ignoring: %m");
650 break;
651
652 case SD_DHCP_OPTION_RENEWAL_T1_TIME:
653 r = lease_parse_u32(option, len, &lease->t1, 1);
654 if (r < 0)
655 log_debug_errno(r, "Failed to parse T1 time, ignoring: %m");
656 break;
657
658 case SD_DHCP_OPTION_REBINDING_T2_TIME:
659 r = lease_parse_u32(option, len, &lease->t2, 1);
660 if (r < 0)
661 log_debug_errno(r, "Failed to parse T2 time, ignoring: %m");
662 break;
663
664 case SD_DHCP_OPTION_CLASSLESS_STATIC_ROUTE:
665 r = lease_parse_classless_routes(
666 option, len,
667 &lease->static_route,
668 &lease->static_route_size,
669 &lease->static_route_allocated);
670 if (r < 0)
671 log_debug_errno(r, "Failed to parse classless routes, ignoring: %m");
672 break;
673
674 case SD_DHCP_OPTION_NEW_TZDB_TIMEZONE: {
675 _cleanup_free_ char *tz = NULL;
676
677 r = lease_parse_string(option, len, &tz);
678 if (r < 0) {
679 log_debug_errno(r, "Failed to parse timezone option, ignoring: %m");
680 return 0;
681 }
682
683 if (!timezone_is_valid(tz)) {
684 log_debug_errno(r, "Timezone is not valid, ignoring: %m");
685 return 0;
686 }
687
688 free_and_replace(lease->timezone, tz);
689
690 break;
691 }
692
693 case SD_DHCP_OPTION_VENDOR_SPECIFIC:
694
695 if (len <= 0)
696 lease->vendor_specific = mfree(lease->vendor_specific);
697 else {
698 void *p;
699
700 p = memdup(option, len);
701 if (!p)
702 return -ENOMEM;
703
704 free(lease->vendor_specific);
705 lease->vendor_specific = p;
706 }
707
708 lease->vendor_specific_len = len;
709 break;
710
711 case SD_DHCP_OPTION_PRIVATE_BASE ... SD_DHCP_OPTION_PRIVATE_LAST:
712 r = dhcp_lease_insert_private_option(lease, code, option, len);
713 if (r < 0)
714 return r;
715
716 break;
717
718 default:
719 log_debug("Ignoring option DHCP option %"PRIu8" while parsing.", code);
720 break;
721 }
722
723 return 0;
724 }
725
726 /* Parses compressed domain names. */
727 int dhcp_lease_parse_search_domains(const uint8_t *option, size_t len, char ***domains) {
728 _cleanup_strv_free_ char **names = NULL;
729 size_t pos = 0, cnt = 0;
730 int r;
731
732 assert(domains);
733 assert_return(option && len > 0, -ENODATA);
734
735 while (pos < len) {
736 _cleanup_free_ char *name = NULL;
737 size_t n = 0, allocated = 0;
738 size_t jump_barrier = pos, next_chunk = 0;
739 bool first = true;
740
741 for (;;) {
742 uint8_t c;
743 c = option[pos++];
744
745 if (c == 0) {
746 /* End of name */
747 break;
748 } else if (c <= 63) {
749 const char *label;
750
751 /* Literal label */
752 label = (const char*) (option + pos);
753 pos += c;
754 if (pos >= len)
755 return -EBADMSG;
756
757 if (!GREEDY_REALLOC(name, allocated, n + !first + DNS_LABEL_ESCAPED_MAX))
758 return -ENOMEM;
759
760 if (first)
761 first = false;
762 else
763 name[n++] = '.';
764
765 r = dns_label_escape(label, c, name + n, DNS_LABEL_ESCAPED_MAX);
766 if (r < 0)
767 return r;
768
769 n += r;
770 } else if ((c & 0xc0) == 0xc0) {
771 /* Pointer */
772
773 uint8_t d;
774 uint16_t ptr;
775
776 if (pos >= len)
777 return -EBADMSG;
778
779 d = option[pos++];
780 ptr = (uint16_t) (c & ~0xc0) << 8 | (uint16_t) d;
781
782 /* Jumps are limited to a "prior occurrence" (RFC-1035 4.1.4) */
783 if (ptr >= jump_barrier)
784 return -EBADMSG;
785 jump_barrier = ptr;
786
787 /* Save current location so we don't end up re-parsing what's parsed so far. */
788 if (next_chunk == 0)
789 next_chunk = pos;
790
791 pos = ptr;
792 } else
793 return -EBADMSG;
794 }
795
796 if (!GREEDY_REALLOC(name, allocated, n + 1))
797 return -ENOMEM;
798 name[n] = 0;
799
800 r = strv_extend(&names, name);
801 if (r < 0)
802 return r;
803
804 cnt++;
805
806 if (next_chunk != 0)
807 pos = next_chunk;
808 }
809
810 *domains = TAKE_PTR(names);
811
812 return cnt;
813 }
814
815 int dhcp_lease_insert_private_option(sd_dhcp_lease *lease, uint8_t tag, const void *data, uint8_t len) {
816 struct sd_dhcp_raw_option *cur, *option;
817
818 assert(lease);
819
820 LIST_FOREACH(options, cur, lease->private_options) {
821 if (tag < cur->tag)
822 break;
823 if (tag == cur->tag) {
824 log_debug("Ignoring duplicate option, tagged %i.", tag);
825 return 0;
826 }
827 }
828
829 option = new(struct sd_dhcp_raw_option, 1);
830 if (!option)
831 return -ENOMEM;
832
833 option->tag = tag;
834 option->length = len;
835 option->data = memdup(data, len);
836 if (!option->data) {
837 free(option);
838 return -ENOMEM;
839 }
840
841 LIST_INSERT_BEFORE(options, lease->private_options, cur, option);
842 return 0;
843 }
844
845 int dhcp_lease_new(sd_dhcp_lease **ret) {
846 sd_dhcp_lease *lease;
847
848 lease = new0(sd_dhcp_lease, 1);
849 if (!lease)
850 return -ENOMEM;
851
852 lease->router = INADDR_ANY;
853 lease->n_ref = 1;
854
855 *ret = lease;
856 return 0;
857 }
858
859 int dhcp_lease_save(sd_dhcp_lease *lease, const char *lease_file) {
860 _cleanup_free_ char *temp_path = NULL;
861 _cleanup_fclose_ FILE *f = NULL;
862 struct sd_dhcp_raw_option *option;
863 struct in_addr address;
864 const struct in_addr *addresses;
865 const void *client_id, *data;
866 size_t client_id_len, data_len;
867 const char *string;
868 uint16_t mtu;
869 _cleanup_free_ sd_dhcp_route **routes = NULL;
870 char **search_domains = NULL;
871 uint32_t t1, t2, lifetime;
872 int r;
873
874 assert(lease);
875 assert(lease_file);
876
877 r = fopen_temporary(lease_file, &f, &temp_path);
878 if (r < 0)
879 goto fail;
880
881 (void) __fsetlocking(f, FSETLOCKING_BYCALLER);
882 (void) fchmod(fileno(f), 0644);
883
884 fprintf(f,
885 "# This is private data. Do not parse.\n");
886
887 r = sd_dhcp_lease_get_address(lease, &address);
888 if (r >= 0)
889 fprintf(f, "ADDRESS=%s\n", inet_ntoa(address));
890
891 r = sd_dhcp_lease_get_netmask(lease, &address);
892 if (r >= 0)
893 fprintf(f, "NETMASK=%s\n", inet_ntoa(address));
894
895 r = sd_dhcp_lease_get_router(lease, &address);
896 if (r >= 0)
897 fprintf(f, "ROUTER=%s\n", inet_ntoa(address));
898
899 r = sd_dhcp_lease_get_server_identifier(lease, &address);
900 if (r >= 0)
901 fprintf(f, "SERVER_ADDRESS=%s\n", inet_ntoa(address));
902
903 r = sd_dhcp_lease_get_next_server(lease, &address);
904 if (r >= 0)
905 fprintf(f, "NEXT_SERVER=%s\n", inet_ntoa(address));
906
907 r = sd_dhcp_lease_get_broadcast(lease, &address);
908 if (r >= 0)
909 fprintf(f, "BROADCAST=%s\n", inet_ntoa(address));
910
911 r = sd_dhcp_lease_get_mtu(lease, &mtu);
912 if (r >= 0)
913 fprintf(f, "MTU=%" PRIu16 "\n", mtu);
914
915 r = sd_dhcp_lease_get_t1(lease, &t1);
916 if (r >= 0)
917 fprintf(f, "T1=%" PRIu32 "\n", t1);
918
919 r = sd_dhcp_lease_get_t2(lease, &t2);
920 if (r >= 0)
921 fprintf(f, "T2=%" PRIu32 "\n", t2);
922
923 r = sd_dhcp_lease_get_lifetime(lease, &lifetime);
924 if (r >= 0)
925 fprintf(f, "LIFETIME=%" PRIu32 "\n", lifetime);
926
927 r = sd_dhcp_lease_get_dns(lease, &addresses);
928 if (r > 0) {
929 fputs("DNS=", f);
930 serialize_in_addrs(f, addresses, r);
931 fputs("\n", f);
932 }
933
934 r = sd_dhcp_lease_get_ntp(lease, &addresses);
935 if (r > 0) {
936 fputs("NTP=", f);
937 serialize_in_addrs(f, addresses, r);
938 fputs("\n", f);
939 }
940
941 r = sd_dhcp_lease_get_domainname(lease, &string);
942 if (r >= 0)
943 fprintf(f, "DOMAINNAME=%s\n", string);
944
945 r = sd_dhcp_lease_get_search_domains(lease, &search_domains);
946 if (r > 0) {
947 fputs("DOMAIN_SEARCH_LIST=", f);
948 fputstrv(f, search_domains, NULL, NULL);
949 fputs("\n", f);
950 }
951
952 r = sd_dhcp_lease_get_hostname(lease, &string);
953 if (r >= 0)
954 fprintf(f, "HOSTNAME=%s\n", string);
955
956 r = sd_dhcp_lease_get_root_path(lease, &string);
957 if (r >= 0)
958 fprintf(f, "ROOT_PATH=%s\n", string);
959
960 r = sd_dhcp_lease_get_routes(lease, &routes);
961 if (r > 0)
962 serialize_dhcp_routes(f, "ROUTES", routes, r);
963
964 r = sd_dhcp_lease_get_timezone(lease, &string);
965 if (r >= 0)
966 fprintf(f, "TIMEZONE=%s\n", string);
967
968 r = sd_dhcp_lease_get_client_id(lease, &client_id, &client_id_len);
969 if (r >= 0) {
970 _cleanup_free_ char *client_id_hex = NULL;
971
972 client_id_hex = hexmem(client_id, client_id_len);
973 if (!client_id_hex) {
974 r = -ENOMEM;
975 goto fail;
976 }
977 fprintf(f, "CLIENTID=%s\n", client_id_hex);
978 }
979
980 r = sd_dhcp_lease_get_vendor_specific(lease, &data, &data_len);
981 if (r >= 0) {
982 _cleanup_free_ char *option_hex = NULL;
983
984 option_hex = hexmem(data, data_len);
985 if (!option_hex) {
986 r = -ENOMEM;
987 goto fail;
988 }
989 fprintf(f, "VENDOR_SPECIFIC=%s\n", option_hex);
990 }
991
992 LIST_FOREACH(options, option, lease->private_options) {
993 char key[STRLEN("OPTION_000")+1];
994
995 xsprintf(key, "OPTION_%" PRIu8, option->tag);
996 r = serialize_dhcp_option(f, key, option->data, option->length);
997 if (r < 0)
998 goto fail;
999 }
1000
1001 r = fflush_and_check(f);
1002 if (r < 0)
1003 goto fail;
1004
1005 if (rename(temp_path, lease_file) < 0) {
1006 r = -errno;
1007 goto fail;
1008 }
1009
1010 return 0;
1011
1012 fail:
1013 if (temp_path)
1014 (void) unlink(temp_path);
1015
1016 return log_error_errno(r, "Failed to save lease data %s: %m", lease_file);
1017 }
1018
1019 int dhcp_lease_load(sd_dhcp_lease **ret, const char *lease_file) {
1020
1021 _cleanup_(sd_dhcp_lease_unrefp) sd_dhcp_lease *lease = NULL;
1022 _cleanup_free_ char
1023 *address = NULL,
1024 *router = NULL,
1025 *netmask = NULL,
1026 *server_address = NULL,
1027 *next_server = NULL,
1028 *broadcast = NULL,
1029 *dns = NULL,
1030 *ntp = NULL,
1031 *mtu = NULL,
1032 *routes = NULL,
1033 *domains = NULL,
1034 *client_id_hex = NULL,
1035 *vendor_specific_hex = NULL,
1036 *lifetime = NULL,
1037 *t1 = NULL,
1038 *t2 = NULL,
1039 *options[SD_DHCP_OPTION_PRIVATE_LAST - SD_DHCP_OPTION_PRIVATE_BASE + 1] = {};
1040
1041 int r, i;
1042
1043 assert(lease_file);
1044 assert(ret);
1045
1046 r = dhcp_lease_new(&lease);
1047 if (r < 0)
1048 return r;
1049
1050 r = parse_env_file(lease_file, NEWLINE,
1051 "ADDRESS", &address,
1052 "ROUTER", &router,
1053 "NETMASK", &netmask,
1054 "SERVER_IDENTIFIER", &server_address,
1055 "NEXT_SERVER", &next_server,
1056 "BROADCAST", &broadcast,
1057 "DNS", &dns,
1058 "NTP", &ntp,
1059 "MTU", &mtu,
1060 "DOMAINNAME", &lease->domainname,
1061 "HOSTNAME", &lease->hostname,
1062 "DOMAIN_SEARCH_LIST", &domains,
1063 "ROOT_PATH", &lease->root_path,
1064 "ROUTES", &routes,
1065 "CLIENTID", &client_id_hex,
1066 "TIMEZONE", &lease->timezone,
1067 "VENDOR_SPECIFIC", &vendor_specific_hex,
1068 "LIFETIME", &lifetime,
1069 "T1", &t1,
1070 "T2", &t2,
1071 "OPTION_224", &options[0],
1072 "OPTION_225", &options[1],
1073 "OPTION_226", &options[2],
1074 "OPTION_227", &options[3],
1075 "OPTION_228", &options[4],
1076 "OPTION_229", &options[5],
1077 "OPTION_230", &options[6],
1078 "OPTION_231", &options[7],
1079 "OPTION_232", &options[8],
1080 "OPTION_233", &options[9],
1081 "OPTION_234", &options[10],
1082 "OPTION_235", &options[11],
1083 "OPTION_236", &options[12],
1084 "OPTION_237", &options[13],
1085 "OPTION_238", &options[14],
1086 "OPTION_239", &options[15],
1087 "OPTION_240", &options[16],
1088 "OPTION_241", &options[17],
1089 "OPTION_242", &options[18],
1090 "OPTION_243", &options[19],
1091 "OPTION_244", &options[20],
1092 "OPTION_245", &options[21],
1093 "OPTION_246", &options[22],
1094 "OPTION_247", &options[23],
1095 "OPTION_248", &options[24],
1096 "OPTION_249", &options[25],
1097 "OPTION_250", &options[26],
1098 "OPTION_251", &options[27],
1099 "OPTION_252", &options[28],
1100 "OPTION_253", &options[29],
1101 "OPTION_254", &options[30],
1102 NULL);
1103 if (r < 0)
1104 return r;
1105
1106 if (address) {
1107 r = inet_pton(AF_INET, address, &lease->address);
1108 if (r <= 0)
1109 log_debug("Failed to parse address %s, ignoring.", address);
1110 }
1111
1112 if (router) {
1113 r = inet_pton(AF_INET, router, &lease->router);
1114 if (r <= 0)
1115 log_debug("Failed to parse router %s, ignoring.", router);
1116 }
1117
1118 if (netmask) {
1119 r = inet_pton(AF_INET, netmask, &lease->subnet_mask);
1120 if (r <= 0)
1121 log_debug("Failed to parse netmask %s, ignoring.", netmask);
1122 else
1123 lease->have_subnet_mask = true;
1124 }
1125
1126 if (server_address) {
1127 r = inet_pton(AF_INET, server_address, &lease->server_address);
1128 if (r <= 0)
1129 log_debug("Failed to parse server address %s, ignoring.", server_address);
1130 }
1131
1132 if (next_server) {
1133 r = inet_pton(AF_INET, next_server, &lease->next_server);
1134 if (r <= 0)
1135 log_debug("Failed to parse next server %s, ignoring.", next_server);
1136 }
1137
1138 if (broadcast) {
1139 r = inet_pton(AF_INET, broadcast, &lease->broadcast);
1140 if (r <= 0)
1141 log_debug("Failed to parse broadcast address %s, ignoring.", broadcast);
1142 else
1143 lease->have_broadcast = true;
1144 }
1145
1146 if (dns) {
1147 r = deserialize_in_addrs(&lease->dns, dns);
1148 if (r < 0)
1149 log_debug_errno(r, "Failed to deserialize DNS servers %s, ignoring: %m", dns);
1150 else
1151 lease->dns_size = r;
1152 }
1153
1154 if (ntp) {
1155 r = deserialize_in_addrs(&lease->ntp, ntp);
1156 if (r < 0)
1157 log_debug_errno(r, "Failed to deserialize NTP servers %s, ignoring: %m", ntp);
1158 else
1159 lease->ntp_size = r;
1160 }
1161
1162 if (mtu) {
1163 r = safe_atou16(mtu, &lease->mtu);
1164 if (r < 0)
1165 log_debug_errno(r, "Failed to parse MTU %s, ignoring: %m", mtu);
1166 }
1167
1168 if (domains) {
1169 _cleanup_strv_free_ char **a = NULL;
1170 a = strv_split(domains, " ");
1171 if (!a)
1172 return -ENOMEM;
1173
1174 if (!strv_isempty(a)) {
1175 lease->search_domains = a;
1176 a = NULL;
1177 }
1178 }
1179
1180 if (routes) {
1181 r = deserialize_dhcp_routes(
1182 &lease->static_route,
1183 &lease->static_route_size,
1184 &lease->static_route_allocated,
1185 routes);
1186 if (r < 0)
1187 log_debug_errno(r, "Failed to parse DHCP routes %s, ignoring: %m", routes);
1188 }
1189
1190 if (lifetime) {
1191 r = safe_atou32(lifetime, &lease->lifetime);
1192 if (r < 0)
1193 log_debug_errno(r, "Failed to parse lifetime %s, ignoring: %m", lifetime);
1194 }
1195
1196 if (t1) {
1197 r = safe_atou32(t1, &lease->t1);
1198 if (r < 0)
1199 log_debug_errno(r, "Failed to parse T1 %s, ignoring: %m", t1);
1200 }
1201
1202 if (t2) {
1203 r = safe_atou32(t2, &lease->t2);
1204 if (r < 0)
1205 log_debug_errno(r, "Failed to parse T2 %s, ignoring: %m", t2);
1206 }
1207
1208 if (client_id_hex) {
1209 r = deserialize_dhcp_option(&lease->client_id, &lease->client_id_len, client_id_hex);
1210 if (r < 0)
1211 log_debug_errno(r, "Failed to parse client ID %s, ignoring: %m", client_id_hex);
1212 }
1213
1214 if (vendor_specific_hex) {
1215 r = deserialize_dhcp_option(&lease->vendor_specific, &lease->vendor_specific_len, vendor_specific_hex);
1216 if (r < 0)
1217 log_debug_errno(r, "Failed to parse vendor specific data %s, ignoring: %m", vendor_specific_hex);
1218 }
1219
1220 for (i = 0; i <= SD_DHCP_OPTION_PRIVATE_LAST - SD_DHCP_OPTION_PRIVATE_BASE; i++) {
1221 _cleanup_free_ void *data = NULL;
1222 size_t len;
1223
1224 if (!options[i])
1225 continue;
1226
1227 r = deserialize_dhcp_option(&data, &len, options[i]);
1228 if (r < 0) {
1229 log_debug_errno(r, "Failed to parse private DHCP option %s, ignoring: %m", options[i]);
1230 continue;
1231 }
1232
1233 r = dhcp_lease_insert_private_option(lease, SD_DHCP_OPTION_PRIVATE_BASE + i, data, len);
1234 if (r < 0)
1235 return r;
1236 }
1237
1238 *ret = lease;
1239 lease = NULL;
1240
1241 return 0;
1242 }
1243
1244 int dhcp_lease_set_default_subnet_mask(sd_dhcp_lease *lease) {
1245 struct in_addr address, mask;
1246 int r;
1247
1248 assert(lease);
1249
1250 if (lease->address == 0)
1251 return -ENODATA;
1252
1253 address.s_addr = lease->address;
1254
1255 /* fall back to the default subnet masks based on address class */
1256 r = in4_addr_default_subnet_mask(&address, &mask);
1257 if (r < 0)
1258 return r;
1259
1260 lease->subnet_mask = mask.s_addr;
1261 lease->have_subnet_mask = true;
1262
1263 return 0;
1264 }
1265
1266 int sd_dhcp_lease_get_client_id(sd_dhcp_lease *lease, const void **client_id, size_t *client_id_len) {
1267 assert_return(lease, -EINVAL);
1268 assert_return(client_id, -EINVAL);
1269 assert_return(client_id_len, -EINVAL);
1270
1271 if (!lease->client_id)
1272 return -ENODATA;
1273
1274 *client_id = lease->client_id;
1275 *client_id_len = lease->client_id_len;
1276
1277 return 0;
1278 }
1279
1280 int dhcp_lease_set_client_id(sd_dhcp_lease *lease, const void *client_id, size_t client_id_len) {
1281 assert_return(lease, -EINVAL);
1282 assert_return(client_id || client_id_len <= 0, -EINVAL);
1283
1284 if (client_id_len <= 0)
1285 lease->client_id = mfree(lease->client_id);
1286 else {
1287 void *p;
1288
1289 p = memdup(client_id, client_id_len);
1290 if (!p)
1291 return -ENOMEM;
1292
1293 free(lease->client_id);
1294 lease->client_id = p;
1295 lease->client_id_len = client_id_len;
1296 }
1297
1298 return 0;
1299 }
1300
1301 int sd_dhcp_lease_get_timezone(sd_dhcp_lease *lease, const char **tz) {
1302 assert_return(lease, -EINVAL);
1303 assert_return(tz, -EINVAL);
1304
1305 if (!lease->timezone)
1306 return -ENODATA;
1307
1308 *tz = lease->timezone;
1309 return 0;
1310 }
1311
1312 int sd_dhcp_route_get_destination(sd_dhcp_route *route, struct in_addr *destination) {
1313 assert_return(route, -EINVAL);
1314 assert_return(destination, -EINVAL);
1315
1316 *destination = route->dst_addr;
1317 return 0;
1318 }
1319
1320 int sd_dhcp_route_get_destination_prefix_length(sd_dhcp_route *route, uint8_t *length) {
1321 assert_return(route, -EINVAL);
1322 assert_return(length, -EINVAL);
1323
1324 *length = route->dst_prefixlen;
1325 return 0;
1326 }
1327
1328 int sd_dhcp_route_get_gateway(sd_dhcp_route *route, struct in_addr *gateway) {
1329 assert_return(route, -EINVAL);
1330 assert_return(gateway, -EINVAL);
1331
1332 *gateway = route->gw_addr;
1333 return 0;
1334 }
Unnamed repository; edit this file 'description' to name the repository.