]>
Commit | Line | Data |
---|---|---|
a032b68d | 1 | /* SPDX-License-Identifier: LGPL-2.1-or-later */ |
e842803a | 2 | /*** |
b012e921 | 3 | Copyright © 2014-2015 Intel Corporation. All rights reserved. |
e842803a MB |
4 | ***/ |
5 | ||
6 | #include <errno.h> | |
7 | ||
db2df898 | 8 | #include "alloc-util.h" |
f5caa8fa | 9 | #include "dhcp6-internal.h" |
e842803a | 10 | #include "dhcp6-lease-internal.h" |
db2df898 | 11 | #include "strv.h" |
f5caa8fa MB |
12 | |
13 | #define IRT_DEFAULT (1 * USEC_PER_DAY) | |
14 | #define IRT_MINIMUM (600 * USEC_PER_SEC) | |
15 | ||
16 | static void dhcp6_lease_set_timestamp(sd_dhcp6_lease *lease, const triple_timestamp *timestamp) { | |
17 | assert(lease); | |
18 | ||
19 | if (timestamp && triple_timestamp_is_set(timestamp)) | |
20 | lease->timestamp = *timestamp; | |
21 | else | |
22 | triple_timestamp_get(&lease->timestamp); | |
23 | } | |
e842803a | 24 | |
ea0999c9 MB |
25 | int sd_dhcp6_lease_get_timestamp(sd_dhcp6_lease *lease, clockid_t clock, uint64_t *ret) { |
26 | assert_return(lease, -EINVAL); | |
27 | assert_return(TRIPLE_TIMESTAMP_HAS_CLOCK(clock), -EOPNOTSUPP); | |
28 | assert_return(clock_supported(clock), -EOPNOTSUPP); | |
29 | assert_return(ret, -EINVAL); | |
30 | ||
31 | if (!triple_timestamp_is_set(&lease->timestamp)) | |
32 | return -ENODATA; | |
33 | ||
34 | *ret = triple_timestamp_by_clock(&lease->timestamp, clock); | |
35 | return 0; | |
36 | } | |
37 | ||
f5caa8fa MB |
38 | static usec_t sec2usec(uint32_t sec) { |
39 | return sec == UINT32_MAX ? USEC_INFINITY : sec * USEC_PER_SEC; | |
ea0999c9 MB |
40 | } |
41 | ||
f5caa8fa MB |
42 | static void dhcp6_lease_set_lifetime(sd_dhcp6_lease *lease) { |
43 | uint32_t t1 = UINT32_MAX, t2 = UINT32_MAX, min_valid_lt = UINT32_MAX; | |
44 | ||
45 | assert(lease); | |
46 | assert(lease->ia_na || lease->ia_pd); | |
e842803a | 47 | |
f5caa8fa MB |
48 | if (lease->ia_na) { |
49 | t1 = MIN(t1, be32toh(lease->ia_na->header.lifetime_t1)); | |
50 | t2 = MIN(t2, be32toh(lease->ia_na->header.lifetime_t2)); | |
e842803a | 51 | |
f5caa8fa MB |
52 | LIST_FOREACH(addresses, a, lease->ia_na->addresses) |
53 | min_valid_lt = MIN(min_valid_lt, be32toh(a->iaaddr.lifetime_valid)); | |
e842803a MB |
54 | } |
55 | ||
f5caa8fa MB |
56 | if (lease->ia_pd) { |
57 | t1 = MIN(t1, be32toh(lease->ia_pd->header.lifetime_t1)); | |
58 | t2 = MIN(t2, be32toh(lease->ia_pd->header.lifetime_t2)); | |
e842803a | 59 | |
f5caa8fa MB |
60 | LIST_FOREACH(addresses, a, lease->ia_pd->addresses) |
61 | min_valid_lt = MIN(min_valid_lt, be32toh(a->iapdprefix.lifetime_valid)); | |
62 | } | |
e842803a | 63 | |
f5caa8fa MB |
64 | if (t2 == 0 || t2 > min_valid_lt) { |
65 | /* If T2 is zero or longer than the minimum valid lifetime of the addresses or prefixes, | |
66 | * then adjust lifetime with it. */ | |
67 | t1 = min_valid_lt / 2; | |
68 | t2 = min_valid_lt / 10 * 8; | |
69 | } | |
70 | ||
71 | lease->lifetime_valid = sec2usec(min_valid_lt); | |
72 | lease->lifetime_t1 = sec2usec(t1); | |
73 | lease->lifetime_t2 = sec2usec(t2); | |
74 | } | |
75 | ||
76 | int dhcp6_lease_get_lifetime(sd_dhcp6_lease *lease, usec_t *ret_t1, usec_t *ret_t2, usec_t *ret_valid) { | |
77 | assert(lease); | |
78 | ||
79 | if (!lease->ia_na && !lease->ia_pd) | |
80 | return -ENODATA; | |
81 | ||
82 | if (ret_t1) | |
83 | *ret_t1 = lease->lifetime_t1; | |
84 | if (ret_t2) | |
85 | *ret_t2 = lease->lifetime_t2; | |
86 | if (ret_valid) | |
87 | *ret_valid = lease->lifetime_valid; | |
e842803a MB |
88 | return 0; |
89 | } | |
90 | ||
f5caa8fa MB |
91 | static void dhcp6_lease_set_server_address(sd_dhcp6_lease *lease, const struct in6_addr *server_address) { |
92 | assert(lease); | |
e842803a | 93 | |
f5caa8fa MB |
94 | if (server_address) |
95 | lease->server_address = *server_address; | |
96 | else | |
97 | lease->server_address = (struct in6_addr) {}; | |
98 | } | |
e842803a | 99 | |
f5caa8fa MB |
100 | int sd_dhcp6_lease_get_server_address(sd_dhcp6_lease *lease, struct in6_addr *ret) { |
101 | assert_return(lease, -EINVAL); | |
102 | assert_return(ret, -EINVAL); | |
e842803a | 103 | |
f5caa8fa MB |
104 | *ret = lease->server_address; |
105 | return 0; | |
106 | } | |
e842803a | 107 | |
f5caa8fa MB |
108 | void dhcp6_ia_clear_addresses(DHCP6IA *ia) { |
109 | assert(ia); | |
110 | ||
111 | LIST_FOREACH(addresses, a, ia->addresses) | |
112 | free(a); | |
113 | ||
114 | ia->addresses = NULL; | |
115 | } | |
116 | ||
117 | DHCP6IA *dhcp6_ia_free(DHCP6IA *ia) { | |
118 | if (!ia) | |
119 | return NULL; | |
120 | ||
121 | dhcp6_ia_clear_addresses(ia); | |
e842803a | 122 | |
f5caa8fa | 123 | return mfree(ia); |
e842803a MB |
124 | } |
125 | ||
ea0999c9 | 126 | int dhcp6_lease_set_clientid(sd_dhcp6_lease *lease, const uint8_t *id, size_t len) { |
f5caa8fa | 127 | uint8_t *clientid = NULL; |
ea0999c9 | 128 | |
f5caa8fa MB |
129 | assert(lease); |
130 | assert(id || len == 0); | |
ea0999c9 | 131 | |
f5caa8fa MB |
132 | if (len > 0) { |
133 | clientid = memdup(id, len); | |
134 | if (!clientid) | |
135 | return -ENOMEM; | |
136 | } | |
ea0999c9 MB |
137 | |
138 | free_and_replace(lease->clientid, clientid); | |
139 | lease->clientid_len = len; | |
140 | ||
141 | return 0; | |
142 | } | |
143 | ||
144 | int dhcp6_lease_get_clientid(sd_dhcp6_lease *lease, uint8_t **ret_id, size_t *ret_len) { | |
f5caa8fa | 145 | assert(lease); |
ea0999c9 MB |
146 | |
147 | if (!lease->clientid) | |
148 | return -ENODATA; | |
149 | ||
150 | if (ret_id) | |
151 | *ret_id = lease->clientid; | |
152 | if (ret_len) | |
153 | *ret_len = lease->clientid_len; | |
154 | ||
155 | return 0; | |
156 | } | |
157 | ||
158 | int dhcp6_lease_set_serverid(sd_dhcp6_lease *lease, const uint8_t *id, size_t len) { | |
f5caa8fa | 159 | uint8_t *serverid = NULL; |
6e866b33 | 160 | |
f5caa8fa MB |
161 | assert(lease); |
162 | assert(id || len == 0); | |
e842803a | 163 | |
f5caa8fa MB |
164 | if (len > 0) { |
165 | serverid = memdup(id, len); | |
166 | if (!serverid) | |
167 | return -ENOMEM; | |
168 | } | |
e842803a | 169 | |
6e866b33 | 170 | free_and_replace(lease->serverid, serverid); |
e842803a MB |
171 | lease->serverid_len = len; |
172 | ||
173 | return 0; | |
174 | } | |
175 | ||
ea0999c9 | 176 | int dhcp6_lease_get_serverid(sd_dhcp6_lease *lease, uint8_t **ret_id, size_t *ret_len) { |
f5caa8fa | 177 | assert(lease); |
e842803a | 178 | |
98393f85 | 179 | if (!lease->serverid) |
ea0999c9 | 180 | return -ENODATA; |
98393f85 | 181 | |
ea0999c9 MB |
182 | if (ret_id) |
183 | *ret_id = lease->serverid; | |
184 | if (ret_len) | |
185 | *ret_len = lease->serverid_len; | |
e842803a MB |
186 | return 0; |
187 | } | |
188 | ||
189 | int dhcp6_lease_set_preference(sd_dhcp6_lease *lease, uint8_t preference) { | |
f5caa8fa | 190 | assert(lease); |
e842803a MB |
191 | |
192 | lease->preference = preference; | |
e842803a MB |
193 | return 0; |
194 | } | |
195 | ||
f5caa8fa MB |
196 | int dhcp6_lease_get_preference(sd_dhcp6_lease *lease, uint8_t *ret) { |
197 | assert(lease); | |
198 | assert(ret); | |
e842803a | 199 | |
f5caa8fa | 200 | *ret = lease->preference; |
e842803a MB |
201 | return 0; |
202 | } | |
203 | ||
204 | int dhcp6_lease_set_rapid_commit(sd_dhcp6_lease *lease) { | |
f5caa8fa | 205 | assert(lease); |
e842803a MB |
206 | |
207 | lease->rapid_commit = true; | |
e842803a MB |
208 | return 0; |
209 | } | |
210 | ||
f5caa8fa MB |
211 | int dhcp6_lease_get_rapid_commit(sd_dhcp6_lease *lease, bool *ret) { |
212 | assert(lease); | |
213 | assert(ret); | |
e842803a | 214 | |
f5caa8fa | 215 | *ret = lease->rapid_commit; |
e842803a MB |
216 | return 0; |
217 | } | |
218 | ||
f5caa8fa MB |
219 | int sd_dhcp6_lease_get_address( |
220 | sd_dhcp6_lease *lease, | |
221 | struct in6_addr *ret_addr, | |
222 | uint32_t *ret_lifetime_preferred, | |
223 | uint32_t *ret_lifetime_valid) { | |
224 | ||
e842803a | 225 | assert_return(lease, -EINVAL); |
e842803a MB |
226 | |
227 | if (!lease->addr_iter) | |
f5caa8fa | 228 | return -ENODATA; |
e842803a | 229 | |
f5caa8fa MB |
230 | if (ret_addr) |
231 | *ret_addr = lease->addr_iter->iaaddr.address; | |
232 | if (ret_lifetime_preferred) | |
233 | *ret_lifetime_preferred = be32toh(lease->addr_iter->iaaddr.lifetime_preferred); | |
234 | if (ret_lifetime_valid) | |
235 | *ret_lifetime_valid = be32toh(lease->addr_iter->iaaddr.lifetime_valid); | |
e842803a MB |
236 | |
237 | lease->addr_iter = lease->addr_iter->addresses_next; | |
e842803a MB |
238 | return 0; |
239 | } | |
240 | ||
e735f4d4 MP |
241 | void sd_dhcp6_lease_reset_address_iter(sd_dhcp6_lease *lease) { |
242 | if (lease) | |
f5caa8fa | 243 | lease->addr_iter = lease->ia_na ? lease->ia_na->addresses : NULL; |
e842803a MB |
244 | } |
245 | ||
f5caa8fa MB |
246 | int sd_dhcp6_lease_get_pd( |
247 | sd_dhcp6_lease *lease, | |
248 | struct in6_addr *ret_prefix, | |
249 | uint8_t *ret_prefix_len, | |
250 | uint32_t *ret_lifetime_preferred, | |
251 | uint32_t *ret_lifetime_valid) { | |
252 | ||
1d42b86d | 253 | assert_return(lease, -EINVAL); |
1d42b86d MB |
254 | |
255 | if (!lease->prefix_iter) | |
f5caa8fa | 256 | return -ENODATA; |
1d42b86d | 257 | |
f5caa8fa MB |
258 | if (ret_prefix) |
259 | *ret_prefix = lease->prefix_iter->iapdprefix.address; | |
260 | if (ret_prefix_len) | |
261 | *ret_prefix_len = lease->prefix_iter->iapdprefix.prefixlen; | |
262 | if (ret_lifetime_preferred) | |
263 | *ret_lifetime_preferred = be32toh(lease->prefix_iter->iapdprefix.lifetime_preferred); | |
264 | if (ret_lifetime_valid) | |
265 | *ret_lifetime_valid = be32toh(lease->prefix_iter->iapdprefix.lifetime_valid); | |
1d42b86d MB |
266 | |
267 | lease->prefix_iter = lease->prefix_iter->addresses_next; | |
1d42b86d MB |
268 | return 0; |
269 | } | |
270 | ||
271 | void sd_dhcp6_lease_reset_pd_prefix_iter(sd_dhcp6_lease *lease) { | |
272 | if (lease) | |
f5caa8fa | 273 | lease->prefix_iter = lease->ia_pd ? lease->ia_pd->addresses : NULL; |
1d42b86d MB |
274 | } |
275 | ||
ea0999c9 | 276 | int dhcp6_lease_add_dns(sd_dhcp6_lease *lease, const uint8_t *optval, size_t optlen) { |
f5caa8fa MB |
277 | assert(lease); |
278 | assert(optval || optlen == 0); | |
13d276d0 | 279 | |
ea0999c9 | 280 | if (optlen == 0) |
13d276d0 MP |
281 | return 0; |
282 | ||
ea0999c9 | 283 | return dhcp6_option_parse_addresses(optval, optlen, &lease->dns, &lease->dns_count); |
13d276d0 MP |
284 | } |
285 | ||
ea0999c9 | 286 | int sd_dhcp6_lease_get_dns(sd_dhcp6_lease *lease, const struct in6_addr **ret) { |
13d276d0 | 287 | assert_return(lease, -EINVAL); |
13d276d0 | 288 | |
ea0999c9 | 289 | if (!lease->dns) |
f5caa8fa | 290 | return -ENODATA; |
13d276d0 | 291 | |
ea0999c9 MB |
292 | if (ret) |
293 | *ret = lease->dns; | |
294 | ||
295 | return lease->dns_count; | |
13d276d0 MP |
296 | } |
297 | ||
ea0999c9 MB |
298 | int dhcp6_lease_add_domains(sd_dhcp6_lease *lease, const uint8_t *optval, size_t optlen) { |
299 | _cleanup_strv_free_ char **domains = NULL; | |
13d276d0 | 300 | int r; |
13d276d0 | 301 | |
f5caa8fa MB |
302 | assert(lease); |
303 | assert(optval || optlen == 0); | |
13d276d0 | 304 | |
ea0999c9 | 305 | if (optlen == 0) |
13d276d0 MP |
306 | return 0; |
307 | ||
a032b68d | 308 | r = dhcp6_option_parse_domainname_list(optval, optlen, &domains); |
13d276d0 | 309 | if (r < 0) |
ea0999c9 | 310 | return r; |
13d276d0 | 311 | |
ea0999c9 | 312 | return strv_extend_strv(&lease->domains, domains, true); |
13d276d0 MP |
313 | } |
314 | ||
ea0999c9 | 315 | int sd_dhcp6_lease_get_domains(sd_dhcp6_lease *lease, char ***ret) { |
13d276d0 | 316 | assert_return(lease, -EINVAL); |
ea0999c9 | 317 | assert_return(ret, -EINVAL); |
13d276d0 | 318 | |
ea0999c9 | 319 | if (!lease->domains) |
f5caa8fa | 320 | return -ENODATA; |
13d276d0 | 321 | |
ea0999c9 MB |
322 | *ret = lease->domains; |
323 | return strv_length(lease->domains); | |
13d276d0 MP |
324 | } |
325 | ||
ea0999c9 | 326 | int dhcp6_lease_add_ntp(sd_dhcp6_lease *lease, const uint8_t *optval, size_t optlen) { |
13d276d0 | 327 | int r; |
13d276d0 | 328 | |
f5caa8fa MB |
329 | assert(lease); |
330 | assert(optval || optlen == 0); | |
13d276d0 | 331 | |
ea0999c9 MB |
332 | for (size_t offset = 0; offset < optlen;) { |
333 | const uint8_t *subval; | |
334 | size_t sublen; | |
335 | uint16_t subopt; | |
13d276d0 | 336 | |
ea0999c9 MB |
337 | r = dhcp6_option_parse(optval, optlen, &offset, &subopt, &sublen, &subval); |
338 | if (r < 0) | |
339 | return r; | |
13d276d0 | 340 | |
8f232108 | 341 | switch (subopt) { |
13d276d0 MP |
342 | case DHCP6_NTP_SUBOPTION_SRV_ADDR: |
343 | case DHCP6_NTP_SUBOPTION_MC_ADDR: | |
344 | if (sublen != 16) | |
f5caa8fa | 345 | return -EINVAL; |
13d276d0 | 346 | |
ea0999c9 MB |
347 | r = dhcp6_option_parse_addresses(subval, sublen, &lease->ntp, &lease->ntp_count); |
348 | if (r < 0) | |
349 | return r; | |
13d276d0 MP |
350 | |
351 | break; | |
352 | ||
ea0999c9 MB |
353 | case DHCP6_NTP_SUBOPTION_SRV_FQDN: { |
354 | _cleanup_free_ char *server = NULL; | |
355 | ||
356 | r = dhcp6_option_parse_domainname(subval, sublen, &server); | |
13d276d0 | 357 | if (r < 0) |
ea0999c9 MB |
358 | return r; |
359 | ||
360 | if (strv_contains(lease->ntp_fqdn, server)) | |
361 | continue; | |
13d276d0 | 362 | |
ea0999c9 MB |
363 | r = strv_consume(&lease->ntp_fqdn, TAKE_PTR(server)); |
364 | if (r < 0) | |
365 | return r; | |
13d276d0 MP |
366 | |
367 | break; | |
ea0999c9 | 368 | }} |
13d276d0 MP |
369 | } |
370 | ||
13d276d0 MP |
371 | return 0; |
372 | } | |
373 | ||
ea0999c9 | 374 | int dhcp6_lease_add_sntp(sd_dhcp6_lease *lease, const uint8_t *optval, size_t optlen) { |
f5caa8fa MB |
375 | assert(lease); |
376 | assert(optval || optlen == 0); | |
13d276d0 | 377 | |
ea0999c9 | 378 | if (optlen == 0) |
13d276d0 MP |
379 | return 0; |
380 | ||
ea0999c9 MB |
381 | /* SNTP option is defined in RFC4075, and deprecated by RFC5908. */ |
382 | return dhcp6_option_parse_addresses(optval, optlen, &lease->sntp, &lease->sntp_count); | |
13d276d0 MP |
383 | } |
384 | ||
ea0999c9 | 385 | int sd_dhcp6_lease_get_ntp_addrs(sd_dhcp6_lease *lease, const struct in6_addr **ret) { |
13d276d0 | 386 | assert_return(lease, -EINVAL); |
13d276d0 | 387 | |
ea0999c9 MB |
388 | if (lease->ntp) { |
389 | if (ret) | |
390 | *ret = lease->ntp; | |
13d276d0 MP |
391 | return lease->ntp_count; |
392 | } | |
393 | ||
ea0999c9 MB |
394 | if (lease->sntp && !lease->ntp_fqdn) { |
395 | /* Fallback to the deprecated SNTP option. */ | |
396 | if (ret) | |
397 | *ret = lease->sntp; | |
398 | return lease->sntp_count; | |
399 | } | |
400 | ||
f5caa8fa | 401 | return -ENODATA; |
13d276d0 MP |
402 | } |
403 | ||
ea0999c9 | 404 | int sd_dhcp6_lease_get_ntp_fqdn(sd_dhcp6_lease *lease, char ***ret) { |
13d276d0 | 405 | assert_return(lease, -EINVAL); |
13d276d0 | 406 | |
ea0999c9 | 407 | if (!lease->ntp_fqdn) |
f5caa8fa | 408 | return -ENODATA; |
13d276d0 | 409 | |
ea0999c9 MB |
410 | if (ret) |
411 | *ret = lease->ntp_fqdn; | |
412 | return strv_length(lease->ntp_fqdn); | |
13d276d0 MP |
413 | } |
414 | ||
ea0999c9 | 415 | int dhcp6_lease_set_fqdn(sd_dhcp6_lease *lease, const uint8_t *optval, size_t optlen) { |
a032b68d | 416 | char *fqdn; |
f5caa8fa | 417 | int r; |
a032b68d | 418 | |
f5caa8fa MB |
419 | assert(lease); |
420 | assert(optval || optlen == 0); | |
421 | ||
422 | if (optlen == 0) | |
423 | return 0; | |
a032b68d MB |
424 | |
425 | if (optlen < 2) | |
426 | return -ENODATA; | |
427 | ||
428 | /* Ignore the flags field, it doesn't carry any useful | |
429 | information for clients. */ | |
430 | r = dhcp6_option_parse_domainname(optval + 1, optlen - 1, &fqdn); | |
431 | if (r < 0) | |
432 | return r; | |
433 | ||
434 | return free_and_replace(lease->fqdn, fqdn); | |
435 | } | |
436 | ||
ea0999c9 | 437 | int sd_dhcp6_lease_get_fqdn(sd_dhcp6_lease *lease, const char **ret) { |
a032b68d | 438 | assert_return(lease, -EINVAL); |
ea0999c9 | 439 | assert_return(ret, -EINVAL); |
a032b68d | 440 | |
ea0999c9 | 441 | if (!lease->fqdn) |
f5caa8fa | 442 | return -ENODATA; |
a032b68d | 443 | |
ea0999c9 MB |
444 | *ret = lease->fqdn; |
445 | return 0; | |
a032b68d MB |
446 | } |
447 | ||
f5caa8fa MB |
448 | static int dhcp6_lease_parse_message( |
449 | sd_dhcp6_client *client, | |
450 | sd_dhcp6_lease *lease, | |
451 | const DHCP6Message *message, | |
452 | size_t len) { | |
453 | ||
454 | usec_t irt = IRT_DEFAULT; | |
455 | int r; | |
456 | ||
457 | assert(client); | |
458 | assert(lease); | |
459 | assert(message); | |
460 | assert(len >= sizeof(DHCP6Message)); | |
461 | ||
462 | len -= sizeof(DHCP6Message); | |
463 | for (size_t offset = 0; offset < len;) { | |
464 | uint16_t optcode; | |
465 | size_t optlen; | |
466 | const uint8_t *optval; | |
467 | ||
468 | r = dhcp6_option_parse(message->options, len, &offset, &optcode, &optlen, &optval); | |
469 | if (r < 0) | |
9a96df7a MB |
470 | return log_dhcp6_client_errno(client, r, |
471 | "Failed to parse option header at offset %zu of total length %zu: %m", | |
472 | offset, len); | |
f5caa8fa MB |
473 | |
474 | switch (optcode) { | |
475 | case SD_DHCP6_OPTION_CLIENTID: | |
476 | if (dhcp6_lease_get_clientid(lease, NULL, NULL) >= 0) | |
477 | return log_dhcp6_client_errno(client, SYNTHETIC_ERRNO(EINVAL), "%s contains multiple client IDs", | |
478 | dhcp6_message_type_to_string(message->type)); | |
479 | ||
480 | r = dhcp6_lease_set_clientid(lease, optval, optlen); | |
481 | if (r < 0) | |
9a96df7a | 482 | return log_dhcp6_client_errno(client, r, "Failed to set client ID: %m"); |
f5caa8fa MB |
483 | |
484 | break; | |
485 | ||
486 | case SD_DHCP6_OPTION_SERVERID: | |
487 | if (dhcp6_lease_get_serverid(lease, NULL, NULL) >= 0) | |
488 | return log_dhcp6_client_errno(client, SYNTHETIC_ERRNO(EINVAL), "%s contains multiple server IDs", | |
489 | dhcp6_message_type_to_string(message->type)); | |
490 | ||
491 | r = dhcp6_lease_set_serverid(lease, optval, optlen); | |
492 | if (r < 0) | |
9a96df7a | 493 | return log_dhcp6_client_errno(client, r, "Failed to set server ID: %m"); |
f5caa8fa MB |
494 | |
495 | break; | |
496 | ||
497 | case SD_DHCP6_OPTION_PREFERENCE: | |
498 | if (optlen != 1) | |
9a96df7a | 499 | return log_dhcp6_client_errno(client, SYNTHETIC_ERRNO(EINVAL), "Received invalid length for preference."); |
f5caa8fa MB |
500 | |
501 | r = dhcp6_lease_set_preference(lease, optval[0]); | |
502 | if (r < 0) | |
9a96df7a | 503 | return log_dhcp6_client_errno(client, r, "Failed to set preference: %m"); |
f5caa8fa MB |
504 | |
505 | break; | |
506 | ||
507 | case SD_DHCP6_OPTION_STATUS_CODE: { | |
508 | _cleanup_free_ char *msg = NULL; | |
509 | ||
510 | r = dhcp6_option_parse_status(optval, optlen, &msg); | |
511 | if (r < 0) | |
9a96df7a | 512 | return log_dhcp6_client_errno(client, r, "Failed to parse status code: %m"); |
f5caa8fa MB |
513 | |
514 | if (r > 0) | |
d9f5095a | 515 | return log_dhcp6_client_errno(client, dhcp6_message_status_to_errno(r), |
f5caa8fa MB |
516 | "Received %s message with non-zero status: %s%s%s", |
517 | dhcp6_message_type_to_string(message->type), | |
518 | strempty(msg), isempty(msg) ? "" : ": ", | |
519 | dhcp6_message_status_to_string(r)); | |
520 | break; | |
521 | } | |
522 | case SD_DHCP6_OPTION_IA_NA: { | |
523 | _cleanup_(dhcp6_ia_freep) DHCP6IA *ia = NULL; | |
524 | ||
525 | if (client->state == DHCP6_STATE_INFORMATION_REQUEST) { | |
526 | log_dhcp6_client(client, "Ignoring IA NA option in information requesting mode."); | |
527 | break; | |
528 | } | |
529 | ||
530 | r = dhcp6_option_parse_ia(client, client->ia_na.header.id, optcode, optlen, optval, &ia); | |
531 | if (r == -ENOMEM) | |
9a96df7a MB |
532 | return log_oom_debug(); |
533 | if (r < 0) { | |
534 | log_dhcp6_client_errno(client, r, "Failed to parse IA_NA option, ignoring: %m"); | |
f5caa8fa | 535 | continue; |
9a96df7a | 536 | } |
f5caa8fa MB |
537 | |
538 | if (lease->ia_na) { | |
539 | log_dhcp6_client(client, "Received duplicate matching IA_NA option, ignoring."); | |
540 | continue; | |
541 | } | |
542 | ||
543 | dhcp6_ia_free(lease->ia_na); | |
544 | lease->ia_na = TAKE_PTR(ia); | |
545 | break; | |
546 | } | |
547 | case SD_DHCP6_OPTION_IA_PD: { | |
548 | _cleanup_(dhcp6_ia_freep) DHCP6IA *ia = NULL; | |
549 | ||
550 | if (client->state == DHCP6_STATE_INFORMATION_REQUEST) { | |
551 | log_dhcp6_client(client, "Ignoring IA PD option in information requesting mode."); | |
552 | break; | |
553 | } | |
554 | ||
555 | r = dhcp6_option_parse_ia(client, client->ia_pd.header.id, optcode, optlen, optval, &ia); | |
556 | if (r == -ENOMEM) | |
9a96df7a MB |
557 | return log_oom_debug(); |
558 | if (r < 0) { | |
559 | log_dhcp6_client_errno(client, r, "Failed to parse IA_PD option, ignoring: %m"); | |
f5caa8fa | 560 | continue; |
9a96df7a | 561 | } |
f5caa8fa MB |
562 | |
563 | if (lease->ia_pd) { | |
564 | log_dhcp6_client(client, "Received duplicate matching IA_PD option, ignoring."); | |
565 | continue; | |
566 | } | |
567 | ||
568 | dhcp6_ia_free(lease->ia_pd); | |
569 | lease->ia_pd = TAKE_PTR(ia); | |
570 | break; | |
571 | } | |
572 | case SD_DHCP6_OPTION_RAPID_COMMIT: | |
9a96df7a MB |
573 | if (optlen != 0) |
574 | log_dhcp6_client(client, "Received rapid commit option with an invalid length (%zu), ignoring.", optlen); | |
575 | ||
f5caa8fa MB |
576 | r = dhcp6_lease_set_rapid_commit(lease); |
577 | if (r < 0) | |
9a96df7a | 578 | return log_dhcp6_client_errno(client, r, "Failed to set rapid commit flag: %m"); |
f5caa8fa MB |
579 | |
580 | break; | |
581 | ||
8f232108 | 582 | case SD_DHCP6_OPTION_DNS_SERVER: |
f5caa8fa MB |
583 | r = dhcp6_lease_add_dns(lease, optval, optlen); |
584 | if (r < 0) | |
585 | log_dhcp6_client_errno(client, r, "Failed to parse DNS server option, ignoring: %m"); | |
586 | ||
587 | break; | |
588 | ||
8f232108 | 589 | case SD_DHCP6_OPTION_DOMAIN: |
f5caa8fa MB |
590 | r = dhcp6_lease_add_domains(lease, optval, optlen); |
591 | if (r < 0) | |
592 | log_dhcp6_client_errno(client, r, "Failed to parse domain list option, ignoring: %m"); | |
593 | ||
594 | break; | |
595 | ||
596 | case SD_DHCP6_OPTION_NTP_SERVER: | |
597 | r = dhcp6_lease_add_ntp(lease, optval, optlen); | |
598 | if (r < 0) | |
599 | log_dhcp6_client_errno(client, r, "Failed to parse NTP server option, ignoring: %m"); | |
600 | ||
601 | break; | |
602 | ||
8f232108 | 603 | case SD_DHCP6_OPTION_SNTP_SERVER: |
f5caa8fa MB |
604 | r = dhcp6_lease_add_sntp(lease, optval, optlen); |
605 | if (r < 0) | |
606 | log_dhcp6_client_errno(client, r, "Failed to parse SNTP server option, ignoring: %m"); | |
607 | ||
608 | break; | |
609 | ||
610 | case SD_DHCP6_OPTION_CLIENT_FQDN: | |
611 | r = dhcp6_lease_set_fqdn(lease, optval, optlen); | |
612 | if (r < 0) | |
613 | log_dhcp6_client_errno(client, r, "Failed to parse FQDN option, ignoring: %m"); | |
614 | ||
615 | break; | |
616 | ||
617 | case SD_DHCP6_OPTION_INFORMATION_REFRESH_TIME: | |
618 | if (optlen != 4) | |
9a96df7a MB |
619 | return log_dhcp6_client_errno(client, SYNTHETIC_ERRNO(EINVAL), |
620 | "Received information refresh time option with an invalid length (%zu).", optlen); | |
f5caa8fa MB |
621 | |
622 | irt = unaligned_read_be32((be32_t *) optval) * USEC_PER_SEC; | |
623 | break; | |
624 | } | |
625 | } | |
626 | ||
627 | uint8_t *clientid; | |
628 | size_t clientid_len; | |
629 | if (dhcp6_lease_get_clientid(lease, &clientid, &clientid_len) < 0) | |
630 | return log_dhcp6_client_errno(client, SYNTHETIC_ERRNO(EINVAL), | |
631 | "%s message does not contain client ID. Ignoring.", | |
632 | dhcp6_message_type_to_string(message->type)); | |
633 | ||
634 | if (memcmp_nn(clientid, clientid_len, &client->duid, client->duid_len) != 0) | |
635 | return log_dhcp6_client_errno(client, SYNTHETIC_ERRNO(EINVAL), | |
636 | "The client ID in %s message does not match. Ignoring.", | |
637 | dhcp6_message_type_to_string(message->type)); | |
638 | ||
639 | if (client->state == DHCP6_STATE_INFORMATION_REQUEST) { | |
640 | client->information_refresh_time_usec = MAX(irt, IRT_MINIMUM); | |
641 | log_dhcp6_client(client, "New information request will be refused in %s.", | |
642 | FORMAT_TIMESPAN(client->information_refresh_time_usec, USEC_PER_SEC)); | |
643 | ||
644 | } else { | |
645 | r = dhcp6_lease_get_serverid(lease, NULL, NULL); | |
646 | if (r < 0) | |
647 | return log_dhcp6_client_errno(client, r, "%s has no server id", | |
648 | dhcp6_message_type_to_string(message->type)); | |
649 | ||
650 | if (!lease->ia_na && !lease->ia_pd) | |
651 | return log_dhcp6_client_errno(client, SYNTHETIC_ERRNO(EINVAL), | |
652 | "No IA_PD prefix or IA_NA address received. Ignoring."); | |
653 | ||
654 | dhcp6_lease_set_lifetime(lease); | |
655 | } | |
656 | ||
657 | return 0; | |
658 | } | |
659 | ||
6e866b33 | 660 | static sd_dhcp6_lease *dhcp6_lease_free(sd_dhcp6_lease *lease) { |
ea0999c9 MB |
661 | if (!lease) |
662 | return NULL; | |
13d276d0 | 663 | |
ea0999c9 | 664 | free(lease->clientid); |
d9dfd233 | 665 | free(lease->serverid); |
f5caa8fa MB |
666 | dhcp6_ia_free(lease->ia_na); |
667 | dhcp6_ia_free(lease->ia_pd); | |
d9dfd233 | 668 | free(lease->dns); |
a032b68d | 669 | free(lease->fqdn); |
ea0999c9 | 670 | strv_free(lease->domains); |
d9dfd233 | 671 | free(lease->ntp); |
ea0999c9 MB |
672 | strv_free(lease->ntp_fqdn); |
673 | free(lease->sntp); | |
d9dfd233 | 674 | |
8a584da2 | 675 | return mfree(lease); |
e842803a MB |
676 | } |
677 | ||
6e866b33 MB |
678 | DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_dhcp6_lease, sd_dhcp6_lease, dhcp6_lease_free); |
679 | ||
e842803a MB |
680 | int dhcp6_lease_new(sd_dhcp6_lease **ret) { |
681 | sd_dhcp6_lease *lease; | |
682 | ||
f5caa8fa MB |
683 | assert(ret); |
684 | ||
685 | lease = new(sd_dhcp6_lease, 1); | |
e842803a MB |
686 | if (!lease) |
687 | return -ENOMEM; | |
688 | ||
f5caa8fa MB |
689 | *lease = (sd_dhcp6_lease) { |
690 | .n_ref = 1, | |
691 | }; | |
e842803a MB |
692 | |
693 | *ret = lease; | |
694 | return 0; | |
695 | } | |
f5caa8fa MB |
696 | |
697 | int dhcp6_lease_new_from_message( | |
698 | sd_dhcp6_client *client, | |
699 | const DHCP6Message *message, | |
700 | size_t len, | |
701 | const triple_timestamp *timestamp, | |
702 | const struct in6_addr *server_address, | |
703 | sd_dhcp6_lease **ret) { | |
704 | ||
705 | _cleanup_(sd_dhcp6_lease_unrefp) sd_dhcp6_lease *lease = NULL; | |
706 | int r; | |
707 | ||
708 | assert(client); | |
709 | assert(message); | |
710 | assert(len >= sizeof(DHCP6Message)); | |
711 | assert(ret); | |
712 | ||
713 | r = dhcp6_lease_new(&lease); | |
714 | if (r < 0) | |
715 | return r; | |
716 | ||
717 | dhcp6_lease_set_timestamp(lease, timestamp); | |
718 | dhcp6_lease_set_server_address(lease, server_address); | |
719 | ||
720 | r = dhcp6_lease_parse_message(client, lease, message, len); | |
721 | if (r < 0) | |
722 | return r; | |
723 | ||
724 | *ret = TAKE_PTR(lease); | |
725 | return 0; | |
726 | } |