]>
Commit | Line | Data |
---|---|---|
53e1b683 | 1 | /* SPDX-License-Identifier: LGPL-2.1+ */ |
f12ed3bf | 2 | /*** |
810adae9 | 3 | Copyright © 2014-2015 Intel Corporation. All rights reserved. |
f12ed3bf PF |
4 | ***/ |
5 | ||
f12ed3bf | 6 | #include <errno.h> |
cf0fbc49 | 7 | #include <netinet/in.h> |
f12ed3bf PF |
8 | #include <string.h> |
9 | ||
2c1ab8ca BG |
10 | #include "sd-dhcp6-client.h" |
11 | ||
b5efdb8a | 12 | #include "alloc-util.h" |
f12ed3bf | 13 | #include "dhcp6-internal.h" |
c6b4f32a | 14 | #include "dhcp6-lease-internal.h" |
f12ed3bf | 15 | #include "dhcp6-protocol.h" |
f96ccab7 | 16 | #include "dns-domain.h" |
b5efdb8a LP |
17 | #include "sparse-endian.h" |
18 | #include "strv.h" | |
19 | #include "unaligned.h" | |
20 | #include "util.h" | |
f12ed3bf | 21 | |
c6b4f32a PF |
22 | typedef struct DHCP6StatusOption { |
23 | struct DHCP6Option option; | |
24 | be16_t status; | |
25 | char msg[]; | |
26 | } _packed_ DHCP6StatusOption; | |
27 | ||
0dfe2a4b PF |
28 | typedef struct DHCP6AddressOption { |
29 | struct DHCP6Option option; | |
30 | struct iaaddr iaaddr; | |
31 | uint8_t options[]; | |
32 | } _packed_ DHCP6AddressOption; | |
33 | ||
f8ad4dd4 PF |
34 | typedef struct DHCP6PDPrefixOption { |
35 | struct DHCP6Option option; | |
36 | struct iapdprefix iapdprefix; | |
37 | uint8_t options[]; | |
38 | } _packed_ DHCP6PDPrefixOption; | |
39 | ||
40 | #define DHCP6_OPTION_IA_NA_LEN (sizeof(struct ia_na)) | |
41 | #define DHCP6_OPTION_IA_PD_LEN (sizeof(struct ia_pd)) | |
42 | #define DHCP6_OPTION_IA_TA_LEN (sizeof(struct ia_ta)) | |
f12ed3bf PF |
43 | |
44 | static int option_append_hdr(uint8_t **buf, size_t *buflen, uint16_t optcode, | |
45 | size_t optlen) { | |
c962cb68 | 46 | DHCP6Option *option = (DHCP6Option*) *buf; |
4903a73c | 47 | |
f12ed3bf PF |
48 | assert_return(buf, -EINVAL); |
49 | assert_return(*buf, -EINVAL); | |
50 | assert_return(buflen, -EINVAL); | |
51 | ||
4903a73c | 52 | if (optlen > 0xffff || *buflen < optlen + sizeof(DHCP6Option)) |
f12ed3bf PF |
53 | return -ENOBUFS; |
54 | ||
c962cb68 TG |
55 | option->code = htobe16(optcode); |
56 | option->len = htobe16(optlen); | |
f12ed3bf | 57 | |
4903a73c TG |
58 | *buf += sizeof(DHCP6Option); |
59 | *buflen -= sizeof(DHCP6Option); | |
f12ed3bf PF |
60 | |
61 | return 0; | |
62 | } | |
63 | ||
64 | int dhcp6_option_append(uint8_t **buf, size_t *buflen, uint16_t code, | |
65 | size_t optlen, const void *optval) { | |
66 | int r; | |
67 | ||
ed6ee219 | 68 | assert_return(optval || optlen == 0, -EINVAL); |
f12ed3bf PF |
69 | |
70 | r = option_append_hdr(buf, buflen, code, optlen); | |
71 | if (r < 0) | |
72 | return r; | |
73 | ||
75f32f04 | 74 | memcpy_safe(*buf, optval, optlen); |
f12ed3bf PF |
75 | |
76 | *buf += optlen; | |
77 | *buflen -= optlen; | |
78 | ||
79 | return 0; | |
80 | } | |
81 | ||
82 | int dhcp6_option_append_ia(uint8_t **buf, size_t *buflen, DHCP6IA *ia) { | |
83 | uint16_t len; | |
84 | uint8_t *ia_hdr; | |
976fade6 | 85 | size_t iaid_offset, ia_buflen, ia_addrlen = 0; |
f12ed3bf PF |
86 | DHCP6Address *addr; |
87 | int r; | |
88 | ||
89 | assert_return(buf && *buf && buflen && ia, -EINVAL); | |
90 | ||
91 | switch (ia->type) { | |
2c1ab8ca | 92 | case SD_DHCP6_OPTION_IA_NA: |
f12ed3bf | 93 | len = DHCP6_OPTION_IA_NA_LEN; |
976fade6 | 94 | iaid_offset = offsetof(DHCP6IA, ia_na); |
f12ed3bf PF |
95 | break; |
96 | ||
2c1ab8ca | 97 | case SD_DHCP6_OPTION_IA_TA: |
f12ed3bf | 98 | len = DHCP6_OPTION_IA_TA_LEN; |
976fade6 | 99 | iaid_offset = offsetof(DHCP6IA, ia_ta); |
f12ed3bf PF |
100 | break; |
101 | ||
102 | default: | |
103 | return -EINVAL; | |
104 | } | |
105 | ||
106 | if (*buflen < len) | |
107 | return -ENOBUFS; | |
108 | ||
109 | ia_hdr = *buf; | |
110 | ia_buflen = *buflen; | |
111 | ||
4903a73c TG |
112 | *buf += sizeof(DHCP6Option); |
113 | *buflen -= sizeof(DHCP6Option); | |
f12ed3bf | 114 | |
976fade6 | 115 | memcpy(*buf, (char*) ia + iaid_offset, len); |
f12ed3bf PF |
116 | |
117 | *buf += len; | |
118 | *buflen -= len; | |
119 | ||
120 | LIST_FOREACH(addresses, addr, ia->addresses) { | |
2c1ab8ca | 121 | r = option_append_hdr(buf, buflen, SD_DHCP6_OPTION_IAADDR, |
ee3a5027 | 122 | sizeof(addr->iaaddr)); |
f12ed3bf PF |
123 | if (r < 0) |
124 | return r; | |
125 | ||
ee3a5027 | 126 | memcpy(*buf, &addr->iaaddr, sizeof(addr->iaaddr)); |
f12ed3bf | 127 | |
ee3a5027 PF |
128 | *buf += sizeof(addr->iaaddr); |
129 | *buflen -= sizeof(addr->iaaddr); | |
f12ed3bf | 130 | |
4903a73c | 131 | ia_addrlen += sizeof(DHCP6Option) + sizeof(addr->iaaddr); |
f12ed3bf PF |
132 | } |
133 | ||
134 | r = option_append_hdr(&ia_hdr, &ia_buflen, ia->type, len + ia_addrlen); | |
135 | if (r < 0) | |
136 | return r; | |
137 | ||
138 | return 0; | |
139 | } | |
140 | ||
8006aa32 | 141 | int dhcp6_option_append_fqdn(uint8_t **buf, size_t *buflen, const char *fqdn) { |
5e55cde9 | 142 | uint8_t buffer[1 + DNS_WIRE_FORMAT_HOSTNAME_MAX]; |
8006aa32 SA |
143 | int r; |
144 | ||
145 | assert_return(buf && *buf && buflen && fqdn, -EINVAL); | |
146 | ||
147 | buffer[0] = DHCP6_FQDN_FLAG_S; /* Request server to perform AAAA RR DNS updates */ | |
148 | ||
149 | /* Store domain name after flags field */ | |
150 | r = dns_name_to_wire_format(fqdn, buffer + 1, sizeof(buffer) - 1, false); | |
151 | if (r <= 0) | |
152 | return r; | |
153 | ||
154 | /* | |
155 | * According to RFC 4704, chapter 4.2 only add terminating zero-length | |
156 | * label in case a FQDN is provided. Since dns_name_to_wire_format | |
157 | * always adds terminating zero-length label remove if only a hostname | |
158 | * is provided. | |
159 | */ | |
160 | if (dns_name_is_single_label(fqdn)) | |
161 | r--; | |
162 | ||
163 | r = dhcp6_option_append(buf, buflen, SD_DHCP6_OPTION_FQDN, 1 + r, buffer); | |
164 | ||
165 | return r; | |
166 | } | |
167 | ||
c77e3db1 PF |
168 | int dhcp6_option_append_pd(uint8_t *buf, size_t len, DHCP6IA *pd) { |
169 | DHCP6Option *option = (DHCP6Option *)buf; | |
170 | size_t i = sizeof(*option) + sizeof(pd->ia_pd); | |
171 | DHCP6Address *prefix; | |
172 | ||
173 | assert_return(buf, -EINVAL); | |
174 | assert_return(pd, -EINVAL); | |
175 | assert_return(pd->type == SD_DHCP6_OPTION_IA_PD, -EINVAL); | |
176 | ||
177 | if (len < i) | |
178 | return -ENOBUFS; | |
179 | ||
180 | option->code = htobe16(SD_DHCP6_OPTION_IA_PD); | |
181 | ||
182 | memcpy(&option->data, &pd->ia_pd, sizeof(pd->ia_pd)); | |
183 | ||
184 | LIST_FOREACH(addresses, prefix, pd->addresses) { | |
185 | DHCP6PDPrefixOption *prefix_opt; | |
186 | ||
187 | if (len < i + sizeof(*prefix_opt)) | |
188 | return -ENOBUFS; | |
189 | ||
190 | prefix_opt = (DHCP6PDPrefixOption *)&buf[i]; | |
191 | prefix_opt->option.code = htobe16(SD_DHCP6_OPTION_IA_PD_PREFIX); | |
192 | prefix_opt->option.len = htobe16(sizeof(prefix_opt->iapdprefix)); | |
193 | ||
194 | memcpy(&prefix_opt->iapdprefix, &prefix->iapdprefix, | |
195 | sizeof(struct iapdprefix)); | |
196 | ||
197 | i += sizeof(*prefix_opt); | |
198 | } | |
199 | ||
200 | option->len = htobe16(i - sizeof(*option)); | |
201 | ||
202 | return i; | |
203 | } | |
c6affce8 | 204 | |
c962cb68 TG |
205 | static int option_parse_hdr(uint8_t **buf, size_t *buflen, uint16_t *optcode, size_t *optlen) { |
206 | DHCP6Option *option = (DHCP6Option*) *buf; | |
c6affce8 PF |
207 | uint16_t len; |
208 | ||
209 | assert_return(buf, -EINVAL); | |
4903a73c | 210 | assert_return(optcode, -EINVAL); |
c6affce8 PF |
211 | assert_return(optlen, -EINVAL); |
212 | ||
4903a73c | 213 | if (*buflen < sizeof(DHCP6Option)) |
c6affce8 PF |
214 | return -ENOMSG; |
215 | ||
c962cb68 | 216 | len = be16toh(option->len); |
c6affce8 PF |
217 | |
218 | if (len > *buflen) | |
219 | return -ENOMSG; | |
220 | ||
c962cb68 | 221 | *optcode = be16toh(option->code); |
c6affce8 PF |
222 | *optlen = len; |
223 | ||
224 | *buf += 4; | |
225 | *buflen -= 4; | |
226 | ||
227 | return 0; | |
228 | } | |
229 | ||
f12ed3bf PF |
230 | int dhcp6_option_parse(uint8_t **buf, size_t *buflen, uint16_t *optcode, |
231 | size_t *optlen, uint8_t **optvalue) { | |
c6affce8 | 232 | int r; |
f12ed3bf | 233 | |
c6affce8 | 234 | assert_return(buf && buflen && optcode && optlen && optvalue, -EINVAL); |
f12ed3bf | 235 | |
c6affce8 PF |
236 | r = option_parse_hdr(buf, buflen, optcode, optlen); |
237 | if (r < 0) | |
238 | return r; | |
f12ed3bf | 239 | |
c6affce8 | 240 | if (*optlen > *buflen) |
f12ed3bf PF |
241 | return -ENOBUFS; |
242 | ||
c6affce8 PF |
243 | *optvalue = *buf; |
244 | *buflen -= *optlen; | |
245 | *buf += *optlen; | |
f12ed3bf PF |
246 | |
247 | return 0; | |
248 | } | |
c6affce8 | 249 | |
84452783 | 250 | int dhcp6_option_parse_status(DHCP6Option *option, size_t len) { |
c6b4f32a PF |
251 | DHCP6StatusOption *statusopt = (DHCP6StatusOption *)option; |
252 | ||
84452783 YW |
253 | if (len < sizeof(DHCP6StatusOption) || |
254 | be16toh(option->len) + sizeof(DHCP6Option) < sizeof(DHCP6StatusOption)) | |
c6b4f32a PF |
255 | return -ENOBUFS; |
256 | ||
257 | return be16toh(statusopt->status); | |
258 | } | |
259 | ||
0dfe2a4b PF |
260 | static int dhcp6_option_parse_address(DHCP6Option *option, DHCP6IA *ia, |
261 | uint32_t *lifetime_valid) { | |
262 | DHCP6AddressOption *addr_option = (DHCP6AddressOption *)option; | |
263 | DHCP6Address *addr; | |
264 | uint32_t lt_valid, lt_pref; | |
265 | int r; | |
266 | ||
267 | if (be16toh(option->len) + sizeof(DHCP6Option) < sizeof(*addr_option)) | |
268 | return -ENOBUFS; | |
269 | ||
270 | lt_valid = be32toh(addr_option->iaaddr.lifetime_valid); | |
271 | lt_pref = be32toh(addr_option->iaaddr.lifetime_preferred); | |
272 | ||
273 | if (lt_valid == 0 || lt_pref > lt_valid) { | |
274 | log_dhcp6_client(client, "Valid lifetime of an IA address is zero or preferred lifetime %d > valid lifetime %d", | |
275 | lt_pref, lt_valid); | |
276 | ||
277 | return 0; | |
278 | } | |
279 | ||
280 | if (be16toh(option->len) + sizeof(DHCP6Option) > sizeof(*addr_option)) { | |
84452783 | 281 | r = dhcp6_option_parse_status((DHCP6Option *)addr_option->options, be16toh(option->len) + sizeof(DHCP6Option) - sizeof(*addr_option)); |
0dfe2a4b PF |
282 | if (r != 0) |
283 | return r < 0 ? r: 0; | |
284 | } | |
285 | ||
286 | addr = new0(DHCP6Address, 1); | |
287 | if (!addr) | |
288 | return -ENOMEM; | |
289 | ||
290 | LIST_INIT(addresses, addr); | |
291 | memcpy(&addr->iaaddr, option->data, sizeof(addr->iaaddr)); | |
292 | ||
293 | LIST_PREPEND(addresses, ia->addresses, addr); | |
294 | ||
295 | *lifetime_valid = be32toh(addr->iaaddr.lifetime_valid); | |
296 | ||
297 | return 0; | |
298 | } | |
299 | ||
f8ad4dd4 PF |
300 | static int dhcp6_option_parse_pdprefix(DHCP6Option *option, DHCP6IA *ia, |
301 | uint32_t *lifetime_valid) { | |
302 | DHCP6PDPrefixOption *pdprefix_option = (DHCP6PDPrefixOption *)option; | |
303 | DHCP6Address *prefix; | |
304 | uint32_t lt_valid, lt_pref; | |
305 | int r; | |
306 | ||
307 | if (be16toh(option->len) + sizeof(DHCP6Option) < sizeof(*pdprefix_option)) | |
308 | return -ENOBUFS; | |
309 | ||
310 | lt_valid = be32toh(pdprefix_option->iapdprefix.lifetime_valid); | |
311 | lt_pref = be32toh(pdprefix_option->iapdprefix.lifetime_preferred); | |
312 | ||
313 | if (lt_valid == 0 || lt_pref > lt_valid) { | |
314 | log_dhcp6_client(client, "Valid lifetieme of a PD prefix is zero or preferred lifetime %d > valid lifetime %d", | |
315 | lt_pref, lt_valid); | |
316 | ||
317 | return 0; | |
318 | } | |
319 | ||
320 | if (be16toh(option->len) + sizeof(DHCP6Option) > sizeof(*pdprefix_option)) { | |
84452783 | 321 | r = dhcp6_option_parse_status((DHCP6Option *)pdprefix_option->options, be16toh(option->len) + sizeof(DHCP6Option) - sizeof(*pdprefix_option)); |
f8ad4dd4 PF |
322 | if (r != 0) |
323 | return r < 0 ? r: 0; | |
324 | } | |
325 | ||
326 | prefix = new0(DHCP6Address, 1); | |
327 | if (!prefix) | |
328 | return -ENOMEM; | |
329 | ||
330 | LIST_INIT(addresses, prefix); | |
331 | memcpy(&prefix->iapdprefix, option->data, sizeof(prefix->iapdprefix)); | |
332 | ||
333 | LIST_PREPEND(addresses, ia->addresses, prefix); | |
334 | ||
335 | *lifetime_valid = be32toh(prefix->iapdprefix.lifetime_valid); | |
336 | ||
337 | return 0; | |
338 | } | |
339 | ||
3bc424a3 PF |
340 | int dhcp6_option_parse_ia(DHCP6Option *iaoption, DHCP6IA *ia) { |
341 | uint16_t iatype, optlen; | |
342 | size_t i, len; | |
343 | int r = 0, status; | |
344 | uint16_t opt; | |
c6affce8 | 345 | size_t iaaddr_offset; |
3c035649 | 346 | uint32_t lt_t1, lt_t2, lt_valid = 0, lt_min = UINT32_MAX; |
c6affce8 PF |
347 | |
348 | assert_return(ia, -EINVAL); | |
349 | assert_return(!ia->addresses, -EINVAL); | |
350 | ||
3bc424a3 PF |
351 | iatype = be16toh(iaoption->code); |
352 | len = be16toh(iaoption->len); | |
353 | ||
c6affce8 | 354 | switch (iatype) { |
2c1ab8ca | 355 | case SD_DHCP6_OPTION_IA_NA: |
c6affce8 | 356 | |
aae1fa5c YW |
357 | if (len < DHCP6_OPTION_IA_NA_LEN) |
358 | return -ENOBUFS; | |
c6affce8 PF |
359 | |
360 | iaaddr_offset = DHCP6_OPTION_IA_NA_LEN; | |
3bc424a3 | 361 | memcpy(&ia->ia_na, iaoption->data, sizeof(ia->ia_na)); |
c6affce8 | 362 | |
e0026dcb PF |
363 | lt_t1 = be32toh(ia->ia_na.lifetime_t1); |
364 | lt_t2 = be32toh(ia->ia_na.lifetime_t2); | |
c6affce8 PF |
365 | |
366 | if (lt_t1 && lt_t2 && lt_t1 > lt_t2) { | |
f8ad4dd4 PF |
367 | log_dhcp6_client(client, "IA NA T1 %ds > T2 %ds", |
368 | lt_t1, lt_t2); | |
aae1fa5c | 369 | return -EINVAL; |
f8ad4dd4 PF |
370 | } |
371 | ||
372 | break; | |
373 | ||
374 | case SD_DHCP6_OPTION_IA_PD: | |
375 | ||
aae1fa5c YW |
376 | if (len < sizeof(ia->ia_pd)) |
377 | return -ENOBUFS; | |
f8ad4dd4 PF |
378 | |
379 | iaaddr_offset = sizeof(ia->ia_pd); | |
380 | memcpy(&ia->ia_pd, iaoption->data, sizeof(ia->ia_pd)); | |
381 | ||
382 | lt_t1 = be32toh(ia->ia_pd.lifetime_t1); | |
383 | lt_t2 = be32toh(ia->ia_pd.lifetime_t2); | |
384 | ||
385 | if (lt_t1 && lt_t2 && lt_t1 > lt_t2) { | |
386 | log_dhcp6_client(client, "IA PD T1 %ds > T2 %ds", | |
c6affce8 | 387 | lt_t1, lt_t2); |
aae1fa5c | 388 | return -EINVAL; |
c6affce8 PF |
389 | } |
390 | ||
391 | break; | |
392 | ||
2c1ab8ca | 393 | case SD_DHCP6_OPTION_IA_TA: |
aae1fa5c YW |
394 | if (len < DHCP6_OPTION_IA_TA_LEN) |
395 | return -ENOBUFS; | |
c6affce8 PF |
396 | |
397 | iaaddr_offset = DHCP6_OPTION_IA_TA_LEN; | |
3bc424a3 | 398 | memcpy(&ia->ia_ta.id, iaoption->data, sizeof(ia->ia_ta)); |
c6affce8 PF |
399 | |
400 | break; | |
401 | ||
402 | default: | |
aae1fa5c | 403 | return -ENOMSG; |
c6affce8 PF |
404 | } |
405 | ||
406 | ia->type = iatype; | |
3bc424a3 PF |
407 | i = iaaddr_offset; |
408 | ||
409 | while (i < len) { | |
410 | DHCP6Option *option = (DHCP6Option *)&iaoption->data[i]; | |
c6affce8 | 411 | |
aae1fa5c YW |
412 | if (len < i + sizeof(*option) || len < i + sizeof(*option) + be16toh(option->len)) |
413 | return -ENOBUFS; | |
c6affce8 | 414 | |
3bc424a3 PF |
415 | opt = be16toh(option->code); |
416 | optlen = be16toh(option->len); | |
c6affce8 PF |
417 | |
418 | switch (opt) { | |
2c1ab8ca | 419 | case SD_DHCP6_OPTION_IAADDR: |
0dfe2a4b | 420 | |
f8ad4dd4 PF |
421 | if (!IN_SET(ia->type, SD_DHCP6_OPTION_IA_NA, SD_DHCP6_OPTION_IA_TA)) { |
422 | log_dhcp6_client(client, "IA Address option not in IA NA or TA option"); | |
aae1fa5c | 423 | return -EINVAL; |
f8ad4dd4 PF |
424 | } |
425 | ||
0dfe2a4b PF |
426 | r = dhcp6_option_parse_address(option, ia, <_valid); |
427 | if (r < 0) | |
aae1fa5c | 428 | return r; |
0dfe2a4b PF |
429 | |
430 | if (lt_valid < lt_min) | |
431 | lt_min = lt_valid; | |
c6affce8 PF |
432 | |
433 | break; | |
434 | ||
f8ad4dd4 PF |
435 | case SD_DHCP6_OPTION_IA_PD_PREFIX: |
436 | ||
437 | if (!IN_SET(ia->type, SD_DHCP6_OPTION_IA_PD)) { | |
438 | log_dhcp6_client(client, "IA PD Prefix option not in IA PD option"); | |
aae1fa5c | 439 | return -EINVAL; |
f8ad4dd4 PF |
440 | } |
441 | ||
442 | r = dhcp6_option_parse_pdprefix(option, ia, <_valid); | |
443 | if (r < 0) | |
aae1fa5c | 444 | return r; |
f8ad4dd4 PF |
445 | |
446 | if (lt_valid < lt_min) | |
447 | lt_min = lt_valid; | |
448 | ||
449 | break; | |
450 | ||
2c1ab8ca | 451 | case SD_DHCP6_OPTION_STATUS_CODE: |
c6affce8 | 452 | |
91c43f39 | 453 | status = dhcp6_option_parse_status(option, optlen + sizeof(DHCP6Option)); |
aae1fa5c YW |
454 | if (status < 0) |
455 | return status; | |
91c43f39 | 456 | if (status > 0) { |
c6affce8 PF |
457 | log_dhcp6_client(client, "IA status %d", |
458 | status); | |
c6b4f32a | 459 | |
aae1fa5c | 460 | return -EINVAL; |
c6affce8 PF |
461 | } |
462 | ||
463 | break; | |
464 | ||
465 | default: | |
466 | log_dhcp6_client(client, "Unknown IA option %d", opt); | |
467 | break; | |
468 | } | |
469 | ||
3bc424a3 | 470 | i += sizeof(*option) + optlen; |
c6affce8 PF |
471 | } |
472 | ||
f8ad4dd4 PF |
473 | switch(iatype) { |
474 | case SD_DHCP6_OPTION_IA_NA: | |
475 | if (!ia->ia_na.lifetime_t1 && !ia->ia_na.lifetime_t2) { | |
476 | lt_t1 = lt_min / 2; | |
477 | lt_t2 = lt_min / 10 * 8; | |
478 | ia->ia_na.lifetime_t1 = htobe32(lt_t1); | |
479 | ia->ia_na.lifetime_t2 = htobe32(lt_t2); | |
480 | ||
481 | log_dhcp6_client(client, "Computed IA NA T1 %ds and T2 %ds as both were zero", | |
482 | lt_t1, lt_t2); | |
483 | } | |
484 | ||
485 | break; | |
486 | ||
487 | case SD_DHCP6_OPTION_IA_PD: | |
488 | if (!ia->ia_pd.lifetime_t1 && !ia->ia_pd.lifetime_t2) { | |
489 | lt_t1 = lt_min / 2; | |
490 | lt_t2 = lt_min / 10 * 8; | |
491 | ia->ia_pd.lifetime_t1 = htobe32(lt_t1); | |
492 | ia->ia_pd.lifetime_t2 = htobe32(lt_t2); | |
493 | ||
494 | log_dhcp6_client(client, "Computed IA PD T1 %ds and T2 %ds as both were zero", | |
495 | lt_t1, lt_t2); | |
496 | } | |
c6affce8 | 497 | |
f8ad4dd4 PF |
498 | break; |
499 | ||
500 | default: | |
501 | break; | |
c6affce8 PF |
502 | } |
503 | ||
aae1fa5c | 504 | return 0; |
c6affce8 | 505 | } |
b553817c PF |
506 | |
507 | int dhcp6_option_parse_ip6addrs(uint8_t *optval, uint16_t optlen, | |
508 | struct in6_addr **addrs, size_t count, | |
509 | size_t *allocated) { | |
510 | ||
511 | if (optlen == 0 || optlen % sizeof(struct in6_addr) != 0) | |
512 | return -EINVAL; | |
513 | ||
514 | if (!GREEDY_REALLOC(*addrs, *allocated, | |
515 | count * sizeof(struct in6_addr) + optlen)) | |
516 | return -ENOMEM; | |
517 | ||
518 | memcpy(*addrs + count, optval, optlen); | |
519 | ||
520 | count += optlen / sizeof(struct in6_addr); | |
521 | ||
522 | return count; | |
523 | } | |
f96ccab7 | 524 | |
52efd56a | 525 | int dhcp6_option_parse_domainname(const uint8_t *optval, uint16_t optlen, char ***str_arr) { |
f96ccab7 | 526 | size_t pos = 0, idx = 0; |
419eaa8f | 527 | _cleanup_strv_free_ char **names = NULL; |
f96ccab7 PF |
528 | int r; |
529 | ||
530 | assert_return(optlen > 1, -ENODATA); | |
93f660da | 531 | assert_return(optval[optlen - 1] == '\0', -EINVAL); |
f96ccab7 PF |
532 | |
533 | while (pos < optlen) { | |
534 | _cleanup_free_ char *ret = NULL; | |
535 | size_t n = 0, allocated = 0; | |
536 | bool first = true; | |
537 | ||
538 | for (;;) { | |
3c72b6ed | 539 | const char *label; |
f96ccab7 PF |
540 | uint8_t c; |
541 | ||
542 | c = optval[pos++]; | |
543 | ||
544 | if (c == 0) | |
545 | /* End of name */ | |
546 | break; | |
3c72b6ed YW |
547 | if (c > 63) |
548 | return -EBADMSG; | |
549 | ||
550 | /* Literal label */ | |
551 | label = (const char *)&optval[pos]; | |
552 | pos += c; | |
553 | if (pos >= optlen) | |
554 | return -EMSGSIZE; | |
555 | ||
556 | if (!GREEDY_REALLOC(ret, allocated, n + !first + DNS_LABEL_ESCAPED_MAX)) | |
557 | return -ENOMEM; | |
558 | ||
559 | if (first) | |
560 | first = false; | |
561 | else | |
562 | ret[n++] = '.'; | |
563 | ||
564 | r = dns_label_escape(label, c, ret + n, DNS_LABEL_ESCAPED_MAX); | |
565 | if (r < 0) | |
566 | return r; | |
f96ccab7 | 567 | |
3c72b6ed | 568 | n += r; |
f96ccab7 PF |
569 | } |
570 | ||
3c72b6ed YW |
571 | if (n == 0) |
572 | continue; | |
573 | ||
574 | if (!GREEDY_REALLOC(ret, allocated, n + 1)) | |
575 | return -ENOMEM; | |
576 | ||
f96ccab7 PF |
577 | ret[n] = 0; |
578 | ||
579 | r = strv_extend(&names, ret); | |
580 | if (r < 0) | |
3c72b6ed | 581 | return r; |
f96ccab7 | 582 | |
f96ccab7 PF |
583 | idx++; |
584 | } | |
585 | ||
ae2a15bc | 586 | *str_arr = TAKE_PTR(names); |
f96ccab7 PF |
587 | |
588 | return idx; | |
f96ccab7 | 589 | } |