?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update to dhcpcd-9.3.0 with the following changes:
[dragonfly.git] / contrib / dhcpcd / src / dhcp6.c
blob0dbf83332a428880bb73525be8431c2a82225d84
1 /* SPDX-License-Identifier: BSD-2-Clause */
2 /*
3 * dhcpcd - DHCP client daemon
4 * Copyright (c) 2006-2020 Roy Marples <roy@marples.name>
5 * All rights reserved
6
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29 #include <sys/utsname.h>
30 #include <sys/types.h>
31
32 #include <netinet/in.h>
33 #include <netinet/ip6.h>
34
35 #include <assert.h>
36 #include <ctype.h>
37 #include <errno.h>
38 #include <fcntl.h>
39 #include <inttypes.h>
40 #include <stdbool.h>
41 #include <stddef.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #include <unistd.h>
45 #include <fcntl.h>
46 #include <syslog.h>
47
48 #define ELOOP_QUEUE ELOOP_DHCP6
49 #include "config.h"
50 #include "common.h"
51 #include "dhcp.h"
52 #include "dhcp6.h"
53 #include "duid.h"
54 #include "eloop.h"
55 #include "if.h"
56 #include "if-options.h"
57 #include "ipv6nd.h"
58 #include "logerr.h"
59 #include "privsep.h"
60 #include "script.h"
61
62 #ifdef HAVE_SYS_BITOPS_H
63 #include <sys/bitops.h>
64 #else
65 #include "compat/bitops.h"
66 #endif
67
68 /* DHCPCD Project has been assigned an IANA PEN of 40712 */
69 #define DHCPCD_IANA_PEN 40712
70
71 /* Unsure if I want this */
72 //#define VENDOR_SPLIT
73
74 /* Support older systems with different defines */
75 #if !defined(IPV6_RECVPKTINFO) && defined(IPV6_PKTINFO)
76 #define IPV6_RECVPKTINFO IPV6_PKTINFO
77 #endif
78
79 #ifdef DHCP6
80
81 /* Assert the correct structure size for on wire */
82 struct dhcp6_message {
83 uint8_t type;
84 uint8_t xid[3];
85 /* followed by options */
86 };
87 __CTASSERT(sizeof(struct dhcp6_message) == 4);
88
89 struct dhcp6_option {
90 uint16_t code;
91 uint16_t len;
92 /* followed by data */
93 };
94 __CTASSERT(sizeof(struct dhcp6_option) == 4);
95
96 struct dhcp6_ia_na {
97 uint8_t iaid[4];
98 uint32_t t1;
99 uint32_t t2;
100 };
101 __CTASSERT(sizeof(struct dhcp6_ia_na) == 12);
102
103 struct dhcp6_ia_ta {
104 uint8_t iaid[4];
105 };
106 __CTASSERT(sizeof(struct dhcp6_ia_ta) == 4);
107
108 struct dhcp6_ia_addr {
109 struct in6_addr addr;
110 uint32_t pltime;
111 uint32_t vltime;
112 };
113 __CTASSERT(sizeof(struct dhcp6_ia_addr) == 16 + 8);
114
115 /* XXX FIXME: This is the only packed structure and it does not align.
116 * Maybe manually decode it? */
117 struct dhcp6_pd_addr {
118 uint32_t pltime;
119 uint32_t vltime;
120 uint8_t prefix_len;
121 struct in6_addr prefix;
122 } __packed;
123 __CTASSERT(sizeof(struct dhcp6_pd_addr) == 8 + 1 + 16);
124
125 struct dhcp6_op {
126 uint16_t type;
127 const char *name;
128 };
129
130 static const struct dhcp6_op dhcp6_ops[] = {
131 { DHCP6_SOLICIT, "SOLICIT6" },
132 { DHCP6_ADVERTISE, "ADVERTISE6" },
133 { DHCP6_REQUEST, "REQUEST6" },
134 { DHCP6_REPLY, "REPLY6" },
135 { DHCP6_RENEW, "RENEW6" },
136 { DHCP6_REBIND, "REBIND6" },
137 { DHCP6_CONFIRM, "CONFIRM6" },
138 { DHCP6_INFORMATION_REQ, "INFORM6" },
139 { DHCP6_RELEASE, "RELEASE6" },
140 { DHCP6_RECONFIGURE, "RECONFIGURE6" },
141 { DHCP6_DECLINE, "DECLINE6" },
142 { 0, NULL }
143 };
144
145 struct dhcp_compat {
146 uint8_t dhcp_opt;
147 uint16_t dhcp6_opt;
148 };
149
150 static const struct dhcp_compat dhcp_compats[] = {
151 { DHO_DNSSERVER, D6_OPTION_DNS_SERVERS },
152 { DHO_HOSTNAME, D6_OPTION_FQDN },
153 { DHO_DNSDOMAIN, D6_OPTION_FQDN },
154 { DHO_NISSERVER, D6_OPTION_NIS_SERVERS },
155 { DHO_NTPSERVER, D6_OPTION_SNTP_SERVERS },
156 { DHO_RAPIDCOMMIT, D6_OPTION_RAPID_COMMIT },
157 { DHO_FQDN, D6_OPTION_FQDN },
158 { DHO_VIVCO, D6_OPTION_VENDOR_CLASS },
159 { DHO_VIVSO, D6_OPTION_VENDOR_OPTS },
160 { DHO_DNSSEARCH, D6_OPTION_DOMAIN_LIST },
161 { 0, 0 }
162 };
163
164 static const char * const dhcp6_statuses[] = {
165 "Success",
166 "Unspecified Failure",
167 "No Addresses Available",
168 "No Binding",
169 "Not On Link",
170 "Use Multicast",
171 "No Prefix Available"
172 };
173
174 static void dhcp6_bind(struct interface *, const char *, const char *);
175 static void dhcp6_failinform(void *);
176 static void dhcp6_recvaddr(void *);
177 static void dhcp6_startdecline(struct interface *);
178
179 #ifdef SMALL
180 #define dhcp6_hasprefixdelegation(a) (0)
181 #else
182 static int dhcp6_hasprefixdelegation(struct interface *);
183 #endif
184
185 #define DECLINE_IA(ia) \
186 ((ia)->addr_flags & IN6_IFF_DUPLICATED && \
187 (ia)->ia_type != 0 && (ia)->ia_type != D6_OPTION_IA_PD && \
188 !((ia)->flags & IPV6_AF_STALE) && \
189 (ia)->prefix_vltime != 0)
190
191 void
192 dhcp6_printoptions(const struct dhcpcd_ctx *ctx,
193 const struct dhcp_opt *opts, size_t opts_len)
194 {
195 size_t i, j;
196 const struct dhcp_opt *opt, *opt2;
197 int cols;
198
199 for (i = 0, opt = ctx->dhcp6_opts;
200 i < ctx->dhcp6_opts_len; i++, opt++)
201 {
202 for (j = 0, opt2 = opts; j < opts_len; j++, opt2++)
203 if (opt2->option == opt->option)
204 break;
205 if (j == opts_len) {
206 cols = printf("%05d %s", opt->option, opt->var);
207 dhcp_print_option_encoding(opt, cols);
208 }
209 }
210 for (i = 0, opt = opts; i < opts_len; i++, opt++) {
211 cols = printf("%05d %s", opt->option, opt->var);
212 dhcp_print_option_encoding(opt, cols);
213 }
214 }
215
216 static size_t
217 dhcp6_makeuser(void *data, const struct interface *ifp)
218 {
219 const struct if_options *ifo = ifp->options;
220 struct dhcp6_option o;
221 uint8_t *p;
222 const uint8_t *up, *ue;
223 uint16_t ulen, unlen;
224 size_t olen;
225
226 /* Convert the DHCPv4 user class option to DHCPv6 */
227 up = ifo->userclass;
228 ulen = *up++;
229 if (ulen == 0)
230 return 0;
231
232 p = data;
233 olen = 0;
234 if (p != NULL)
235 p += sizeof(o);
236
237 ue = up + ulen;
238 for (; up < ue; up += ulen) {
239 ulen = *up++;
240 olen += sizeof(ulen) + ulen;
241 if (data == NULL)
242 continue;
243 unlen = htons(ulen);
244 memcpy(p, &unlen, sizeof(unlen));
245 p += sizeof(unlen);
246 memcpy(p, up, ulen);
247 p += ulen;
248 }
249 if (data != NULL) {
250 o.code = htons(D6_OPTION_USER_CLASS);
251 o.len = htons((uint16_t)olen);
252 memcpy(data, &o, sizeof(o));
253 }
254
255 return sizeof(o) + olen;
256 }
257
258 static size_t
259 dhcp6_makevendor(void *data, const struct interface *ifp)
260 {
261 const struct if_options *ifo;
262 size_t len, vlen, i;
263 uint8_t *p;
264 const struct vivco *vivco;
265 struct dhcp6_option o;
266
267 ifo = ifp->options;
268 len = sizeof(uint32_t); /* IANA PEN */
269 if (ifo->vivco_en) {
270 vlen = 0;
271 for (i = 0, vivco = ifo->vivco;
272 i < ifo->vivco_len;
273 i++, vivco++)
274 vlen += sizeof(uint16_t) + vivco->len;
275 len += vlen;
276 } else if (ifo->vendorclassid[0] != '\0') {
277 /* dhcpcd owns DHCPCD_IANA_PEN.
278 * If you need your own string, get your own IANA PEN. */
279 vlen = strlen(ifp->ctx->vendor);
280 len += sizeof(uint16_t) + vlen;
281 } else
282 return 0;
283
284 if (len > UINT16_MAX) {
285 logerrx("%s: DHCPv6 Vendor Class too big", ifp->name);
286 return 0;
287 }
288
289 if (data != NULL) {
290 uint32_t pen;
291 uint16_t hvlen;
292
293 p = data;
294 o.code = htons(D6_OPTION_VENDOR_CLASS);
295 o.len = htons((uint16_t)len);
296 memcpy(p, &o, sizeof(o));
297 p += sizeof(o);
298 pen = htonl(ifo->vivco_en ? ifo->vivco_en : DHCPCD_IANA_PEN);
299 memcpy(p, &pen, sizeof(pen));
300 p += sizeof(pen);
301
302 if (ifo->vivco_en) {
303 for (i = 0, vivco = ifo->vivco;
304 i < ifo->vivco_len;
305 i++, vivco++)
306 {
307 hvlen = htons((uint16_t)vivco->len);
308 memcpy(p, &hvlen, sizeof(hvlen));
309 p += sizeof(hvlen);
310 memcpy(p, vivco->data, vivco->len);
311 p += vivco->len;
312 }
313 } else if (ifo->vendorclassid[0] != '\0') {
314 hvlen = htons((uint16_t)vlen);
315 memcpy(p, &hvlen, sizeof(hvlen));
316 p += sizeof(hvlen);
317 memcpy(p, ifp->ctx->vendor, vlen);
318 }
319 }
320
321 return sizeof(o) + len;
322 }
323
324 static void *
325 dhcp6_findoption(void *data, size_t data_len, uint16_t code, uint16_t *len)
326 {
327 uint8_t *d;
328 struct dhcp6_option o;
329
330 code = htons(code);
331 for (d = data; data_len != 0; d += o.len, data_len -= o.len) {
332 if (data_len < sizeof(o)) {
333 errno = EINVAL;
334 return NULL;
335 }
336 memcpy(&o, d, sizeof(o));
337 d += sizeof(o);
338 data_len -= sizeof(o);
339 o.len = htons(o.len);
340 if (data_len < o.len) {
341 errno = EINVAL;
342 return NULL;
343 }
344 if (o.code == code) {
345 if (len != NULL)
346 *len = o.len;
347 return d;
348 }
349 }
350
351 errno = ENOENT;
352 return NULL;
353 }
354
355 static void *
356 dhcp6_findmoption(void *data, size_t data_len, uint16_t code,
357 uint16_t *len)
358 {
359 uint8_t *d;
360
361 if (data_len < sizeof(struct dhcp6_message)) {
362 errno = EINVAL;
363 return false;
364 }
365 d = data;
366 d += sizeof(struct dhcp6_message);
367 data_len -= sizeof(struct dhcp6_message);
368 return dhcp6_findoption(d, data_len, code, len);
369 }
370
371 static const uint8_t *
372 dhcp6_getoption(struct dhcpcd_ctx *ctx,
373 size_t *os, unsigned int *code, size_t *len,
374 const uint8_t *od, size_t ol, struct dhcp_opt **oopt)
375 {
376 struct dhcp6_option o;
377 size_t i;
378 struct dhcp_opt *opt;
379
380 if (od != NULL) {
381 *os = sizeof(o);
382 if (ol < *os) {
383 errno = EINVAL;
384 return NULL;
385 }
386 memcpy(&o, od, sizeof(o));
387 *len = ntohs(o.len);
388 if (*len > ol - *os) {
389 errno = ERANGE;
390 return NULL;
391 }
392 *code = ntohs(o.code);
393 }
394
395 *oopt = NULL;
396 for (i = 0, opt = ctx->dhcp6_opts;
397 i < ctx->dhcp6_opts_len; i++, opt++)
398 {
399 if (opt->option == *code) {
400 *oopt = opt;
401 break;
402 }
403 }
404
405 if (od != NULL)
406 return od + sizeof(o);
407 return NULL;
408 }
409
410 static bool
411 dhcp6_updateelapsed(struct interface *ifp, struct dhcp6_message *m, size_t len)
412 {
413 uint8_t *opt;
414 uint16_t opt_len;
415 struct dhcp6_state *state;
416 struct timespec tv;
417 unsigned long long hsec;
418 uint16_t sec;
419
420 opt = dhcp6_findmoption(m, len, D6_OPTION_ELAPSED, &opt_len);
421 if (opt == NULL)
422 return false;
423 if (opt_len != sizeof(sec)) {
424 errno = EINVAL;
425 return false;
426 }
427
428 state = D6_STATE(ifp);
429 clock_gettime(CLOCK_MONOTONIC, &tv);
430 if (state->RTC == 0) {
431 /* An RTC of zero means we're the first message
432 * out of the door, so the elapsed time is zero. */
433 state->started = tv;
434 hsec = 0;
435 } else {
436 unsigned long long secs;
437 unsigned int nsecs;
438
439 secs = eloop_timespec_diff(&tv, &state->started, &nsecs);
440 /* Elapsed time is measured in centiseconds.
441 * We need to be sure it will not potentially overflow. */
442 if (secs >= (UINT16_MAX / CSEC_PER_SEC) + 1)
443 hsec = UINT16_MAX;
444 else {
445 hsec = (secs * CSEC_PER_SEC) +
446 (nsecs / NSEC_PER_CSEC);
447 if (hsec > UINT16_MAX)
448 hsec = UINT16_MAX;
449 }
450 }
451 sec = htons((uint16_t)hsec);
452 memcpy(opt, &sec, sizeof(sec));
453 return true;
454 }
455
456 static void
457 dhcp6_newxid(const struct interface *ifp, struct dhcp6_message *m)
458 {
459 const struct interface *ifp1;
460 const struct dhcp6_state *state1;
461 uint32_t xid;
462
463 if (ifp->options->options & DHCPCD_XID_HWADDR &&
464 ifp->hwlen >= sizeof(xid))
465 /* The lower bits are probably more unique on the network */
466 memcpy(&xid, (ifp->hwaddr + ifp->hwlen) - sizeof(xid),
467 sizeof(xid));
468 else {
469 again:
470 xid = arc4random();
471 }
472
473 m->xid[0] = (xid >> 16) & 0xff;
474 m->xid[1] = (xid >> 8) & 0xff;
475 m->xid[2] = xid & 0xff;
476
477 /* Ensure it's unique */
478 TAILQ_FOREACH(ifp1, ifp->ctx->ifaces, next) {
479 if (ifp == ifp1)
480 continue;
481 if ((state1 = D6_CSTATE(ifp1)) == NULL)
482 continue;
483 if (state1->send != NULL &&
484 state1->send->xid[0] == m->xid[0] &&
485 state1->send->xid[1] == m->xid[1] &&
486 state1->send->xid[2] == m->xid[2])
487 break;
488 }
489
490 if (ifp1 != NULL) {
491 if (ifp->options->options & DHCPCD_XID_HWADDR &&
492 ifp->hwlen >= sizeof(xid))
493 {
494 logerrx("%s: duplicate xid on %s",
495 ifp->name, ifp1->name);
496 return;
497 }
498 goto again;
499 }
500 }
501
502 #ifndef SMALL
503 static const struct if_sla *
504 dhcp6_findselfsla(struct interface *ifp)
505 {
506 size_t i, j;
507 struct if_ia *ia;
508
509 for (i = 0; i < ifp->options->ia_len; i++) {
510 ia = &ifp->options->ia[i];
511 if (ia->ia_type != D6_OPTION_IA_PD)
512 continue;
513 for (j = 0; j < ia->sla_len; j++) {
514 if (strcmp(ia->sla[j].ifname, ifp->name) == 0)
515 return &ia->sla[j];
516 }
517 }
518 return NULL;
519 }
520
521 static int
522 dhcp6_delegateaddr(struct in6_addr *addr, struct interface *ifp,
523 const struct ipv6_addr *prefix, const struct if_sla *sla, struct if_ia *ia)
524 {
525 struct dhcp6_state *state;
526 struct if_sla asla;
527 char sabuf[INET6_ADDRSTRLEN];
528 const char *sa;
529
530 state = D6_STATE(ifp);
531 if (state == NULL) {
532 ifp->if_data[IF_DATA_DHCP6] = calloc(1, sizeof(*state));
533 state = D6_STATE(ifp);
534 if (state == NULL) {
535 logerr(__func__);
536 return -1;
537 }
538
539 TAILQ_INIT(&state->addrs);
540 state->state = DH6S_DELEGATED;
541 state->reason = "DELEGATED6";
542 }
543
544 if (sla == NULL || !sla->sla_set) {
545 /* No SLA set, so make an assumption of
546 * desired SLA and prefix length. */
547 asla.sla = ifp->index;
548 asla.prefix_len = 0;
549 asla.sla_set = false;
550 sla = &asla;
551 } else if (sla->prefix_len == 0) {
552 /* An SLA was given, but prefix length was not.
553 * We need to work out a suitable prefix length for
554 * potentially more than one interface. */
555 asla.sla = sla->sla;
556 asla.prefix_len = 0;
557 asla.sla_set = sla->sla_set;
558 sla = &asla;
559 }
560
561 if (sla->prefix_len == 0) {
562 uint32_t sla_max;
563 int bits;
564
565 sla_max = ia->sla_max;
566 if (sla_max == 0 && (sla == NULL || !sla->sla_set)) {
567 const struct interface *ifi;
568
569 TAILQ_FOREACH(ifi, ifp->ctx->ifaces, next) {
570 if (ifi->index > sla_max)
571 sla_max = ifi->index;
572 }
573 }
574
575 bits = fls32(sla_max);
576
577 if (prefix->prefix_len + bits > (int)UINT8_MAX)
578 asla.prefix_len = UINT8_MAX;
579 else {
580 asla.prefix_len = (uint8_t)(prefix->prefix_len + bits);
581
582 /* Make a 64 prefix by default, as this makes SLAAC
583 * possible.
584 * Otherwise round up to the nearest 4 bits. */
585 if (asla.prefix_len <= 64)
586 asla.prefix_len = 64;
587 else
588 asla.prefix_len =
589 (uint8_t)ROUNDUP4(asla.prefix_len);
590 }
591
592 #define BIT(n) (1UL << (n))
593 #define BIT_MASK(len) (BIT(len) - 1)
594 if (ia->sla_max == 0) {
595 /* Work out the real sla_max from our bits used */
596 bits = asla.prefix_len - prefix->prefix_len;
597 /* Make static analysis happy.
598 * Bits cannot be bigger than 32 thanks to fls32. */
599 assert(bits <= 32);
600 ia->sla_max = (uint32_t)BIT_MASK(bits);
601 }
602 }
603
604 if (ipv6_userprefix(&prefix->prefix, prefix->prefix_len,
605 sla->sla, addr, sla->prefix_len) == -1)
606 {
607 sa = inet_ntop(AF_INET6, &prefix->prefix,
608 sabuf, sizeof(sabuf));
609 logerr("%s: invalid prefix %s/%d + %d/%d",
610 ifp->name, sa, prefix->prefix_len,
611 sla->sla, sla->prefix_len);
612 return -1;
613 }
614
615 if (prefix->prefix_exclude_len &&
616 IN6_ARE_ADDR_EQUAL(addr, &prefix->prefix_exclude))
617 {
618 sa = inet_ntop(AF_INET6, &prefix->prefix_exclude,
619 sabuf, sizeof(sabuf));
620 logerrx("%s: cannot delegate excluded prefix %s/%d",
621 ifp->name, sa, prefix->prefix_exclude_len);
622 return -1;
623 }
624
625 return sla->prefix_len;
626 }
627 #endif
628
629 static int
630 dhcp6_makemessage(struct interface *ifp)
631 {
632 struct dhcp6_state *state;
633 struct dhcp6_message *m;
634 struct dhcp6_option o;
635 uint8_t *p, *si, *unicast, IA;
636 size_t n, l, len, ml, hl;
637 uint8_t type;
638 uint16_t si_len, uni_len, n_options;
639 uint8_t *o_lenp;
640 struct if_options *ifo;
641 const struct dhcp_opt *opt, *opt2;
642 const struct ipv6_addr *ap;
643 char hbuf[HOSTNAME_MAX_LEN + 1];
644 const char *hostname;
645 int fqdn;
646 struct dhcp6_ia_na ia_na;
647 uint16_t ia_na_len;
648 struct if_ia *ifia;
649 #ifdef AUTH
650 uint16_t auth_len;
651 #endif
652 uint8_t duid[DUID_LEN];
653 size_t duid_len = 0;
654
655 state = D6_STATE(ifp);
656 if (state->send) {
657 free(state->send);
658 state->send = NULL;
659 }
660
661 ifo = ifp->options;
662 fqdn = ifo->fqdn;
663
664 if (fqdn == FQDN_DISABLE && ifo->options & DHCPCD_HOSTNAME) {
665 /* We're sending the DHCPv4 hostname option, so send FQDN as
666 * DHCPv6 has no FQDN option and DHCPv4 must not send
667 * hostname and FQDN according to RFC4702 */
668 fqdn = FQDN_BOTH;
669 }
670 if (fqdn != FQDN_DISABLE)
671 hostname = dhcp_get_hostname(hbuf, sizeof(hbuf), ifo);
672 else
673 hostname = NULL; /* appearse gcc */
674
675 /* Work out option size first */
676 n_options = 0;
677 len = 0;
678 si = NULL;
679 hl = 0; /* Appease gcc */
680 if (state->state != DH6S_RELEASE && state->state != DH6S_DECLINE) {
681 for (l = 0, opt = ifp->ctx->dhcp6_opts;
682 l < ifp->ctx->dhcp6_opts_len;
683 l++, opt++)
684 {
685 for (n = 0, opt2 = ifo->dhcp6_override;
686 n < ifo->dhcp6_override_len;
687 n++, opt2++)
688 {
689 if (opt->option == opt2->option)
690 break;
691 }
692 if (n < ifo->dhcp6_override_len)
693 continue;
694 if (!DHC_REQOPT(opt, ifo->requestmask6, ifo->nomask6))
695 continue;
696 n_options++;
697 len += sizeof(o.len);
698 }
699 #ifndef SMALL
700 for (l = 0, opt = ifo->dhcp6_override;
701 l < ifo->dhcp6_override_len;
702 l++, opt++)
703 {
704 if (!DHC_REQOPT(opt, ifo->requestmask6, ifo->nomask6))
705 continue;
706 n_options++;
707 len += sizeof(o.len);
708 }
709 if (dhcp6_findselfsla(ifp)) {
710 n_options++;
711 len += sizeof(o.len);
712 }
713 #endif
714 if (len)
715 len += sizeof(o);
716
717 if (fqdn != FQDN_DISABLE) {
718 hl = encode_rfc1035(hostname, NULL);
719 len += sizeof(o) + 1 + hl;
720 }
721
722 if (!has_option_mask(ifo->nomask6, D6_OPTION_MUDURL) &&
723 ifo->mudurl[0])
724 len += sizeof(o) + ifo->mudurl[0];
725
726 #ifdef AUTH
727 if ((ifo->auth.options & DHCPCD_AUTH_SENDREQUIRE) !=
728 DHCPCD_AUTH_SENDREQUIRE &&
729 DHC_REQ(ifo->requestmask6, ifo->nomask6,
730 D6_OPTION_RECONF_ACCEPT))
731 len += sizeof(o); /* Reconfigure Accept */
732 #endif
733 }
734
735 len += sizeof(*state->send);
736 len += sizeof(o) + sizeof(uint16_t); /* elapsed */
737
738 if (ifo->options & DHCPCD_ANONYMOUS) {
739 duid_len = duid_make(duid, ifp, DUID_LL);
740 len += sizeof(o) + duid_len;
741 } else {
742 len += sizeof(o) + ifp->ctx->duid_len;
743 }
744
745 if (!has_option_mask(ifo->nomask6, D6_OPTION_USER_CLASS))
746 len += dhcp6_makeuser(NULL, ifp);
747 if (!has_option_mask(ifo->nomask6, D6_OPTION_VENDOR_CLASS))
748 len += dhcp6_makevendor(NULL, ifp);
749
750 /* IA */
751 m = NULL;
752 ml = 0;
753 switch(state->state) {
754 case DH6S_REQUEST:
755 m = state->recv;
756 ml = state->recv_len;
757 /* FALLTHROUGH */
758 case DH6S_DECLINE:
759 /* FALLTHROUGH */
760 case DH6S_RELEASE:
761 /* FALLTHROUGH */
762 case DH6S_RENEW:
763 if (m == NULL) {
764 m = state->new;
765 ml = state->new_len;
766 }
767 si = dhcp6_findmoption(m, ml, D6_OPTION_SERVERID, &si_len);
768 if (si == NULL)
769 return -1;
770 len += sizeof(o) + si_len;
771 /* FALLTHROUGH */
772 case DH6S_REBIND:
773 /* FALLTHROUGH */
774 case DH6S_CONFIRM:
775 /* FALLTHROUGH */
776 case DH6S_DISCOVER:
777 if (m == NULL) {
778 m = state->new;
779 ml = state->new_len;
780 }
781 TAILQ_FOREACH(ap, &state->addrs, next) {
782 if (ap->flags & IPV6_AF_STALE)
783 continue;
784 if (!(ap->flags & IPV6_AF_REQUEST) &&
785 (ap->prefix_vltime == 0 ||
786 state->state == DH6S_DISCOVER))
787 continue;
788 if (DECLINE_IA(ap) && state->state != DH6S_DECLINE)
789 continue;
790 if (ap->ia_type == D6_OPTION_IA_PD) {
791 #ifndef SMALL
792 len += sizeof(o) + sizeof(struct dhcp6_pd_addr);
793 if (ap->prefix_exclude_len)
794 len += sizeof(o) + 1 +
795 (uint8_t)((ap->prefix_exclude_len -
796 ap->prefix_len - 1) / NBBY) + 1;
797 #endif
798 } else
799 len += sizeof(o) + sizeof(struct dhcp6_ia_addr);
800 }
801 /* FALLTHROUGH */
802 case DH6S_INIT:
803 for (l = 0; l < ifo->ia_len; l++) {
804 len += sizeof(o) + sizeof(uint32_t); /* IAID */
805 /* IA_TA does not have T1 or T2 timers */
806 if (ifo->ia[l].ia_type != D6_OPTION_IA_TA)
807 len += sizeof(uint32_t) + sizeof(uint32_t);
808 }
809 IA = 1;
810 break;
811 default:
812 IA = 0;
813 }
814
815 if (state->state == DH6S_DISCOVER &&
816 !(ifp->ctx->options & DHCPCD_TEST) &&
817 DHC_REQ(ifo->requestmask6, ifo->nomask6, D6_OPTION_RAPID_COMMIT))
818 len += sizeof(o);
819
820 if (m == NULL) {
821 m = state->new;
822 ml = state->new_len;
823 }
824
825 switch(state->state) {
826 case DH6S_INIT: /* FALLTHROUGH */
827 case DH6S_DISCOVER:
828 type = DHCP6_SOLICIT;
829 break;
830 case DH6S_REQUEST:
831 type = DHCP6_REQUEST;
832 break;
833 case DH6S_CONFIRM:
834 type = DHCP6_CONFIRM;
835 break;
836 case DH6S_REBIND:
837 type = DHCP6_REBIND;
838 break;
839 case DH6S_RENEW:
840 type = DHCP6_RENEW;
841 break;
842 case DH6S_INFORM:
843 type = DHCP6_INFORMATION_REQ;
844 break;
845 case DH6S_RELEASE:
846 type = DHCP6_RELEASE;
847 break;
848 case DH6S_DECLINE:
849 type = DHCP6_DECLINE;
850 break;
851 default:
852 errno = EINVAL;
853 return -1;
854 }
855
856 switch(state->state) {
857 case DH6S_REQUEST: /* FALLTHROUGH */
858 case DH6S_RENEW: /* FALLTHROUGH */
859 case DH6S_RELEASE:
860 if (has_option_mask(ifo->nomask6, D6_OPTION_UNICAST)) {
861 unicast = NULL;
862 break;
863 }
864 unicast = dhcp6_findmoption(m, ml, D6_OPTION_UNICAST, &uni_len);
865 break;
866 default:
867 unicast = NULL;
868 break;
869 }
870
871 /* In non master mode we listen and send from fixed addresses.
872 * We should try and match an address we have to unicast to,
873 * but for now this is the safest policy. */
874 if (unicast != NULL && !(ifp->ctx->options & DHCPCD_MASTER)) {
875 logdebugx("%s: ignoring unicast option as not master",
876 ifp->name);
877 unicast = NULL;
878 }
879
880 #ifdef AUTH
881 auth_len = 0;
882 if (ifo->auth.options & DHCPCD_AUTH_SEND) {
883 ssize_t alen = dhcp_auth_encode(ifp->ctx, &ifo->auth,
884 state->auth.token, NULL, 0, 6, type, NULL, 0);
885 if (alen != -1 && alen > UINT16_MAX) {
886 errno = ERANGE;
887 alen = -1;
888 }
889 if (alen == -1)
890 logerr("%s: %s: dhcp_auth_encode", __func__, ifp->name);
891 else if (alen != 0) {
892 auth_len = (uint16_t)alen;
893 len += sizeof(o) + auth_len;
894 }
895 }
896 #endif
897
898 state->send = malloc(len);
899 if (state->send == NULL)
900 return -1;
901
902 state->send_len = len;
903 state->send->type = type;
904
905 /* If we found a unicast option, copy it to our state for sending */
906 if (unicast && uni_len == sizeof(state->unicast))
907 memcpy(&state->unicast, unicast, sizeof(state->unicast));
908 else
909 state->unicast = in6addr_any;
910
911 dhcp6_newxid(ifp, state->send);
912
913 #define COPYIN1(_code, _len) { \
914 o.code = htons((_code)); \
915 o.len = htons((_len)); \
916 memcpy(p, &o, sizeof(o)); \
917 p += sizeof(o); \
918 }
919 #define COPYIN(_code, _data, _len) do { \
920 COPYIN1((_code), (_len)); \
921 if ((_len) != 0) { \
922 memcpy(p, (_data), (_len)); \
923 p += (_len); \
924 } \
925 } while (0 /* CONSTCOND */)
926 #define NEXTLEN (p + offsetof(struct dhcp6_option, len))
927
928 /* Options are listed in numerical order as per RFC 7844 Section 4.1
929 * XXX: They should be randomised. */
930
931 p = (uint8_t *)state->send + sizeof(*state->send);
932 if (ifo->options & DHCPCD_ANONYMOUS)
933 COPYIN(D6_OPTION_CLIENTID, duid,
934 (uint16_t)duid_len);
935 else
936 COPYIN(D6_OPTION_CLIENTID, ifp->ctx->duid,
937 (uint16_t)ifp->ctx->duid_len);
938
939 if (si != NULL)
940 COPYIN(D6_OPTION_SERVERID, si, si_len);
941
942 for (l = 0; IA && l < ifo->ia_len; l++) {
943 ifia = &ifo->ia[l];
944 o_lenp = NEXTLEN;
945 /* TA structure is the same as the others,
946 * it just lacks the T1 and T2 timers.
947 * These happen to be at the end of the struct,
948 * so we just don't copy them in. */
949 if (ifia->ia_type == D6_OPTION_IA_TA)
950 ia_na_len = sizeof(struct dhcp6_ia_ta);
951 else
952 ia_na_len = sizeof(ia_na);
953 memcpy(ia_na.iaid, ifia->iaid, sizeof(ia_na.iaid));
954 ia_na.t1 = 0;
955 ia_na.t2 = 0;
956 COPYIN(ifia->ia_type, &ia_na, ia_na_len);
957 TAILQ_FOREACH(ap, &state->addrs, next) {
958 if (ap->flags & IPV6_AF_STALE)
959 continue;
960 if (!(ap->flags & IPV6_AF_REQUEST) &&
961 (ap->prefix_vltime == 0 ||
962 state->state == DH6S_DISCOVER))
963 continue;
964 if (DECLINE_IA(ap) && state->state != DH6S_DECLINE)
965 continue;
966 if (ap->ia_type != ifia->ia_type)
967 continue;
968 if (memcmp(ap->iaid, ifia->iaid, sizeof(ap->iaid)))
969 continue;
970 if (ap->ia_type == D6_OPTION_IA_PD) {
971 #ifndef SMALL
972 struct dhcp6_pd_addr pdp;
973
974 pdp.pltime = htonl(ap->prefix_pltime);
975 pdp.vltime = htonl(ap->prefix_vltime);
976 pdp.prefix_len = ap->prefix_len;
977 /* pdp.prefix is not aligned, so copy it in. */
978 memcpy(&pdp.prefix, &ap->prefix, sizeof(pdp.prefix));
979 COPYIN(D6_OPTION_IAPREFIX, &pdp, sizeof(pdp));
980 ia_na_len = (uint16_t)
981 (ia_na_len + sizeof(o) + sizeof(pdp));
982
983 /* RFC6603 Section 4.2 */
984 if (ap->prefix_exclude_len) {
985 uint8_t exb[16], *ep, u8;
986 const uint8_t *pp;
987
988 n = (size_t)((ap->prefix_exclude_len -
989 ap->prefix_len - 1) / NBBY) + 1;
990 ep = exb;
991 *ep++ = (uint8_t)ap->prefix_exclude_len;
992 pp = ap->prefix_exclude.s6_addr;
993 pp += (size_t)
994 ((ap->prefix_len - 1) / NBBY) +
995 (n - 1);
996 u8 = ap->prefix_len % NBBY;
997 if (u8)
998 n--;
999 while (n-- > 0)
1000 *ep++ = *pp--;
1001 if (u8)
1002 *ep = (uint8_t)(*pp << u8);
1003 n++;
1004 COPYIN(D6_OPTION_PD_EXCLUDE, exb,
1005 (uint16_t)n);
1006 ia_na_len = (uint16_t)
1007 (ia_na_len + sizeof(o) + n);
1008 }
1009 #endif
1010 } else {
1011 struct dhcp6_ia_addr ia;
1012
1013 ia.addr = ap->addr;
1014 ia.pltime = htonl(ap->prefix_pltime);
1015 ia.vltime = htonl(ap->prefix_vltime);
1016 COPYIN(D6_OPTION_IA_ADDR, &ia, sizeof(ia));
1017 ia_na_len = (uint16_t)
1018 (ia_na_len + sizeof(o) + sizeof(ia));
1019 }
1020 }
1021
1022 /* Update the total option lenth. */
1023 ia_na_len = htons(ia_na_len);
1024 memcpy(o_lenp, &ia_na_len, sizeof(ia_na_len));
1025 }
1026
1027 if (state->send->type != DHCP6_RELEASE &&
1028 state->send->type != DHCP6_DECLINE &&
1029 n_options)
1030 {
1031 o_lenp = NEXTLEN;
1032 o.len = 0;
1033 COPYIN1(D6_OPTION_ORO, 0);
1034 for (l = 0, opt = ifp->ctx->dhcp6_opts;
1035 l < ifp->ctx->dhcp6_opts_len;
1036 l++, opt++)
1037 {
1038 #ifndef SMALL
1039 for (n = 0, opt2 = ifo->dhcp6_override;
1040 n < ifo->dhcp6_override_len;
1041 n++, opt2++)
1042 {
1043 if (opt->option == opt2->option)
1044 break;
1045 }
1046 if (n < ifo->dhcp6_override_len)
1047 continue;
1048 #endif
1049 if (!DHC_REQOPT(opt, ifo->requestmask6, ifo->nomask6))
1050 continue;
1051 o.code = htons((uint16_t)opt->option);
1052 memcpy(p, &o.code, sizeof(o.code));
1053 p += sizeof(o.code);
1054 o.len = (uint16_t)(o.len + sizeof(o.code));
1055 }
1056 #ifndef SMALL
1057 for (l = 0, opt = ifo->dhcp6_override;
1058 l < ifo->dhcp6_override_len;
1059 l++, opt++)
1060 {
1061 if (!DHC_REQOPT(opt, ifo->requestmask6, ifo->nomask6))
1062 continue;
1063 o.code = htons((uint16_t)opt->option);
1064 memcpy(p, &o.code, sizeof(o.code));
1065 p += sizeof(o.code);
1066 o.len = (uint16_t)(o.len + sizeof(o.code));
1067 }
1068 if (dhcp6_findselfsla(ifp)) {
1069 o.code = htons(D6_OPTION_PD_EXCLUDE);
1070 memcpy(p, &o.code, sizeof(o.code));
1071 p += sizeof(o.code);
1072 o.len = (uint16_t)(o.len + sizeof(o.code));
1073 }
1074 #endif
1075 o.len = htons(o.len);
1076 memcpy(o_lenp, &o.len, sizeof(o.len));
1077 }
1078
1079 si_len = 0;
1080 COPYIN(D6_OPTION_ELAPSED, &si_len, sizeof(si_len));
1081
1082 if (state->state == DH6S_DISCOVER &&
1083 !(ifp->ctx->options & DHCPCD_TEST) &&
1084 DHC_REQ(ifo->requestmask6, ifo->nomask6, D6_OPTION_RAPID_COMMIT))
1085 COPYIN1(D6_OPTION_RAPID_COMMIT, 0);
1086
1087 if (!has_option_mask(ifo->nomask6, D6_OPTION_USER_CLASS))
1088 p += dhcp6_makeuser(p, ifp);
1089 if (!has_option_mask(ifo->nomask6, D6_OPTION_VENDOR_CLASS))
1090 p += dhcp6_makevendor(p, ifp);
1091
1092 if (state->send->type != DHCP6_RELEASE &&
1093 state->send->type != DHCP6_DECLINE)
1094 {
1095 if (fqdn != FQDN_DISABLE) {
1096 o_lenp = NEXTLEN;
1097 COPYIN1(D6_OPTION_FQDN, 0);
1098 if (hl == 0)
1099 *p = D6_FQDN_NONE;
1100 else {
1101 switch (fqdn) {
1102 case FQDN_BOTH:
1103 *p = D6_FQDN_BOTH;
1104 break;
1105 case FQDN_PTR:
1106 *p = D6_FQDN_PTR;
1107 break;
1108 default:
1109 *p = D6_FQDN_NONE;
1110 break;
1111 }
1112 }
1113 p++;
1114 encode_rfc1035(hostname, p);
1115 p += hl;
1116 o.len = htons((uint16_t)(hl + 1));
1117 memcpy(o_lenp, &o.len, sizeof(o.len));
1118 }
1119
1120 if (!has_option_mask(ifo->nomask6, D6_OPTION_MUDURL) &&
1121 ifo->mudurl[0])
1122 COPYIN(D6_OPTION_MUDURL,
1123 ifo->mudurl + 1, ifo->mudurl[0]);
1124
1125 #ifdef AUTH
1126 if ((ifo->auth.options & DHCPCD_AUTH_SENDREQUIRE) !=
1127 DHCPCD_AUTH_SENDREQUIRE &&
1128 DHC_REQ(ifo->requestmask6, ifo->nomask6,
1129 D6_OPTION_RECONF_ACCEPT))
1130 COPYIN1(D6_OPTION_RECONF_ACCEPT, 0);
1131 #endif
1132
1133 }
1134
1135 #ifdef AUTH
1136 /* This has to be the last option */
1137 if (ifo->auth.options & DHCPCD_AUTH_SEND && auth_len != 0) {
1138 COPYIN1(D6_OPTION_AUTH, auth_len);
1139 /* data will be filled at send message time */
1140 }
1141 #endif
1142
1143 return 0;
1144 }
1145
1146 static const char *
1147 dhcp6_get_op(uint16_t type)
1148 {
1149 const struct dhcp6_op *d;
1150
1151 for (d = dhcp6_ops; d->name; d++)
1152 if (d->type == type)
1153 return d->name;
1154 return NULL;
1155 }
1156
1157 static void
1158 dhcp6_freedrop_addrs(struct interface *ifp, int drop,
1159 const struct interface *ifd)
1160 {
1161 struct dhcp6_state *state;
1162
1163 state = D6_STATE(ifp);
1164 if (state) {
1165 ipv6_freedrop_addrs(&state->addrs, drop, ifd);
1166 if (drop)
1167 rt_build(ifp->ctx, AF_INET6);
1168 }
1169 }
1170
1171 #ifndef SMALL
1172 static void dhcp6_delete_delegates(struct interface *ifp)
1173 {
1174 struct interface *ifp0;
1175
1176 if (ifp->ctx->ifaces) {
1177 TAILQ_FOREACH(ifp0, ifp->ctx->ifaces, next) {
1178 if (ifp0 != ifp)
1179 dhcp6_freedrop_addrs(ifp0, 1, ifp);
1180 }
1181 }
1182 }
1183 #endif
1184
1185 #ifdef AUTH
1186 static ssize_t
1187 dhcp6_update_auth(struct interface *ifp, struct dhcp6_message *m, size_t len)
1188 {
1189 struct dhcp6_state *state;
1190 uint8_t *opt;
1191 uint16_t opt_len;
1192
1193 opt = dhcp6_findmoption(m, len, D6_OPTION_AUTH, &opt_len);
1194 if (opt == NULL)
1195 return -1;
1196
1197 state = D6_STATE(ifp);
1198 return dhcp_auth_encode(ifp->ctx, &ifp->options->auth,
1199 state->auth.token, (uint8_t *)state->send, state->send_len, 6,
1200 state->send->type, opt, opt_len);
1201 }
1202 #endif
1203
1204 static const struct in6_addr alldhcp = IN6ADDR_LINKLOCAL_ALLDHCP_INIT;
1205 static int
1206 dhcp6_sendmessage(struct interface *ifp, void (*callback)(void *))
1207 {
1208 struct dhcp6_state *state = D6_STATE(ifp);
1209 struct dhcpcd_ctx *ctx = ifp->ctx;
1210 unsigned int RT;
1211 bool broadcast = true;
1212 struct sockaddr_in6 dst = {
1213 .sin6_family = AF_INET6,
1214 /* Setting the port on Linux gives EINVAL when sending.
1215 * This looks like a kernel bug as the equivalent works
1216 * fine with the DHCP counterpart. */
1217 #ifndef __linux__
1218 .sin6_port = htons(DHCP6_SERVER_PORT),
1219 #endif
1220 };
1221 struct udphdr udp = {
1222 .uh_sport = htons(DHCP6_CLIENT_PORT),
1223 .uh_dport = htons(DHCP6_SERVER_PORT),
1224 .uh_ulen = htons((uint16_t)(sizeof(udp) + state->send_len)),
1225 };
1226 struct iovec iov[] = {
1227 { .iov_base = &udp, .iov_len = sizeof(udp), },
1228 { .iov_base = state->send, .iov_len = state->send_len, },
1229 };
1230 union {
1231 struct cmsghdr hdr;
1232 uint8_t buf[CMSG_SPACE(sizeof(struct in6_pktinfo))];
1233 } cmsgbuf = { .buf = { 0 } };
1234 struct msghdr msg = {
1235 .msg_name = &dst, .msg_namelen = sizeof(dst),
1236 .msg_iov = iov, .msg_iovlen = __arraycount(iov),
1237 };
1238 char uaddr[INET6_ADDRSTRLEN];
1239
1240 if (!callback && ifp->carrier <= LINK_DOWN)
1241 return 0;
1242
1243 if (!IN6_IS_ADDR_UNSPECIFIED(&state->unicast)) {
1244 switch (state->send->type) {
1245 case DHCP6_SOLICIT: /* FALLTHROUGH */
1246 case DHCP6_CONFIRM: /* FALLTHROUGH */
1247 case DHCP6_REBIND:
1248 /* Unicasting is denied for these types. */
1249 break;
1250 default:
1251 broadcast = false;
1252 inet_ntop(AF_INET6, &state->unicast, uaddr,
1253 sizeof(uaddr));
1254 break;
1255 }
1256 }
1257 dst.sin6_addr = broadcast ? alldhcp : state->unicast;
1258
1259 if (!callback) {
1260 logdebugx("%s: %s %s with xid 0x%02x%02x%02x%s%s",
1261 ifp->name,
1262 broadcast ? "broadcasting" : "unicasting",
1263 dhcp6_get_op(state->send->type),
1264 state->send->xid[0],
1265 state->send->xid[1],
1266 state->send->xid[2],
1267 !broadcast ? " " : "",
1268 !broadcast ? uaddr : "");
1269 RT = 0;
1270 } else {
1271 if (state->IMD &&
1272 !(ifp->options->options & DHCPCD_INITIAL_DELAY))
1273 state->IMD = 0;
1274 if (state->IMD) {
1275 state->RT = state->IMD * MSEC_PER_SEC;
1276 /* Some buggy PPP servers close the link too early
1277 * after sending an invalid status in their reply
1278 * which means this host won't see it.
1279 * 1 second grace seems to be the sweet spot. */
1280 if (ifp->flags & IFF_POINTOPOINT)
1281 state->RT += MSEC_PER_SEC;
1282 } else if (state->RTC == 0)
1283 state->RT = state->IRT * MSEC_PER_SEC;
1284
1285 if (state->MRT != 0) {
1286 unsigned int mrt = state->MRT * MSEC_PER_SEC;
1287
1288 if (state->RT > mrt)
1289 state->RT = mrt;
1290 }
1291
1292 /* Add -.1 to .1 * RT randomness as per RFC8415 section 15 */
1293 uint32_t lru = arc4random_uniform(
1294 state->RTC == 0 ? DHCP6_RAND_MAX
1295 : DHCP6_RAND_MAX - DHCP6_RAND_MIN);
1296 int lr = (int)lru - (state->RTC == 0 ? 0 : DHCP6_RAND_MAX);
1297 RT = state->RT
1298 + (unsigned int)((float)state->RT
1299 * ((float)lr / DHCP6_RAND_DIV));
1300
1301 if (ifp->carrier > LINK_DOWN)
1302 logdebugx("%s: %s %s (xid 0x%02x%02x%02x)%s%s,"
1303 " next in %0.1f seconds",
1304 ifp->name,
1305 state->IMD != 0 ? "delaying" :
1306 broadcast ? "broadcasting" : "unicasting",
1307 dhcp6_get_op(state->send->type),
1308 state->send->xid[0],
1309 state->send->xid[1],
1310 state->send->xid[2],
1311 state->IMD == 0 && !broadcast ? " " : "",
1312 state->IMD == 0 && !broadcast ? uaddr : "",
1313 (float)RT / MSEC_PER_SEC);
1314
1315 /* Wait the initial delay */
1316 if (state->IMD != 0) {
1317 state->IMD = 0;
1318 eloop_timeout_add_msec(ctx->eloop, RT, callback, ifp);
1319 return 0;
1320 }
1321 }
1322
1323 if (ifp->carrier <= LINK_DOWN)
1324 return 0;
1325
1326 /* Update the elapsed time */
1327 dhcp6_updateelapsed(ifp, state->send, state->send_len);
1328 #ifdef AUTH
1329 if (ifp->options->auth.options & DHCPCD_AUTH_SEND &&
1330 dhcp6_update_auth(ifp, state->send, state->send_len) == -1)
1331 {
1332 logerr("%s: %s: dhcp6_updateauth", __func__, ifp->name);
1333 if (errno != ESRCH)
1334 return -1;
1335 }
1336 #endif
1337
1338 /* Set the outbound interface */
1339 if (broadcast) {
1340 struct cmsghdr *cm;
1341 struct in6_pktinfo pi = { .ipi6_ifindex = ifp->index };
1342
1343 dst.sin6_scope_id = ifp->index;
1344 msg.msg_control = cmsgbuf.buf;
1345 msg.msg_controllen = sizeof(cmsgbuf.buf);
1346 cm = CMSG_FIRSTHDR(&msg);
1347 if (cm == NULL) /* unlikely */
1348 return -1;
1349 cm->cmsg_level = IPPROTO_IPV6;
1350 cm->cmsg_type = IPV6_PKTINFO;
1351 cm->cmsg_len = CMSG_LEN(sizeof(pi));
1352 memcpy(CMSG_DATA(cm), &pi, sizeof(pi));
1353 }
1354
1355 #ifdef PRIVSEP
1356 if (IN_PRIVSEP(ifp->ctx)) {
1357 if (ps_inet_senddhcp6(ifp, &msg) == -1)
1358 logerr(__func__);
1359 goto sent;
1360 }
1361 #endif
1362
1363 if (sendmsg(ctx->dhcp6_wfd, &msg, 0) == -1) {
1364 logerr("%s: %s: sendmsg", __func__, ifp->name);
1365 /* Allow DHCPv6 to continue .... the errors
1366 * would be rate limited by the protocol.
1367 * Generally the error is ENOBUFS when struggling to
1368 * associate with an access point. */
1369 }
1370
1371 #ifdef PRIVSEP
1372 sent:
1373 #endif
1374 state->RTC++;
1375 if (callback) {
1376 state->RT = RT * 2;
1377 if (state->RT < RT) /* Check overflow */
1378 state->RT = RT;
1379 if (state->MRC == 0 || state->RTC < state->MRC)
1380 eloop_timeout_add_msec(ctx->eloop,
1381 RT, callback, ifp);
1382 else if (state->MRC != 0 && state->MRCcallback)
1383 eloop_timeout_add_msec(ctx->eloop,
1384 RT, state->MRCcallback, ifp);
1385 else
1386 logwarnx("%s: sent %d times with no reply",
1387 ifp->name, state->RTC);
1388 }
1389 return 0;
1390 }
1391
1392 static void
1393 dhcp6_sendinform(void *arg)
1394 {
1395
1396 dhcp6_sendmessage(arg, dhcp6_sendinform);
1397 }
1398
1399 static void
1400 dhcp6_senddiscover(void *arg)
1401 {
1402
1403 dhcp6_sendmessage(arg, dhcp6_senddiscover);
1404 }
1405
1406 static void
1407 dhcp6_sendrequest(void *arg)
1408 {
1409
1410 dhcp6_sendmessage(arg, dhcp6_sendrequest);
1411 }
1412
1413 static void
1414 dhcp6_sendrebind(void *arg)
1415 {
1416
1417 dhcp6_sendmessage(arg, dhcp6_sendrebind);
1418 }
1419
1420 static void
1421 dhcp6_sendrenew(void *arg)
1422 {
1423
1424 dhcp6_sendmessage(arg, dhcp6_sendrenew);
1425 }
1426
1427 static void
1428 dhcp6_sendconfirm(void *arg)
1429 {
1430
1431 dhcp6_sendmessage(arg, dhcp6_sendconfirm);
1432 }
1433
1434 static void
1435 dhcp6_senddecline(void *arg)
1436 {
1437
1438 dhcp6_sendmessage(arg, dhcp6_senddecline);
1439 }
1440
1441 static void
1442 dhcp6_sendrelease(void *arg)
1443 {
1444
1445 dhcp6_sendmessage(arg, dhcp6_sendrelease);
1446 }
1447
1448 static void
1449 dhcp6_startrenew(void *arg)
1450 {
1451 struct interface *ifp;
1452 struct dhcp6_state *state;
1453
1454 ifp = arg;
1455 if ((state = D6_STATE(ifp)) == NULL)
1456 return;
1457
1458 /* Only renew in the bound or renew states */
1459 if (state->state != DH6S_BOUND &&
1460 state->state != DH6S_RENEW)
1461 return;
1462
1463 /* Remove the timeout as the renew may have been forced. */
1464 eloop_timeout_delete(ifp->ctx->eloop, dhcp6_startrenew, ifp);
1465
1466 state->state = DH6S_RENEW;
1467 state->RTC = 0;
1468 state->IMD = REN_MAX_DELAY;
1469 state->IRT = REN_TIMEOUT;
1470 state->MRT = REN_MAX_RT;
1471 state->MRC = 0;
1472
1473 if (dhcp6_makemessage(ifp) == -1)
1474 logerr("%s: %s", __func__, ifp->name);
1475 else
1476 dhcp6_sendrenew(ifp);
1477 }
1478
1479 void dhcp6_renew(struct interface *ifp)
1480 {
1481
1482 dhcp6_startrenew(ifp);
1483 }
1484
1485 bool
1486 dhcp6_dadcompleted(const struct interface *ifp)
1487 {
1488 const struct dhcp6_state *state;
1489 const struct ipv6_addr *ap;
1490
1491 state = D6_CSTATE(ifp);
1492 TAILQ_FOREACH(ap, &state->addrs, next) {
1493 if (ap->flags & IPV6_AF_ADDED &&
1494 !(ap->flags & IPV6_AF_DADCOMPLETED))
1495 return false;
1496 }
1497 return true;
1498 }
1499
1500 static void
1501 dhcp6_dadcallback(void *arg)
1502 {
1503 struct ipv6_addr *ia = arg;
1504 struct interface *ifp;
1505 struct dhcp6_state *state;
1506 struct ipv6_addr *ia2;
1507 bool completed, valid, oneduplicated;
1508
1509 completed = (ia->flags & IPV6_AF_DADCOMPLETED);
1510 ia->flags |= IPV6_AF_DADCOMPLETED;
1511 if (ia->addr_flags & IN6_IFF_DUPLICATED)
1512 logwarnx("%s: DAD detected %s", ia->iface->name, ia->saddr);
1513
1514 #ifdef ND6_ADVERTISE
1515 else
1516 ipv6nd_advertise(ia);
1517 #endif
1518 if (completed)
1519 return;
1520
1521 ifp = ia->iface;
1522 state = D6_STATE(ifp);
1523 if (state->state != DH6S_BOUND && state->state != DH6S_DELEGATED)
1524 return;
1525
1526 #ifdef SMALL
1527 valid = true;
1528 #else
1529 valid = (ia->delegating_prefix == NULL);
1530 #endif
1531 completed = true;
1532 oneduplicated = false;
1533 TAILQ_FOREACH(ia2, &state->addrs, next) {
1534 if (ia2->flags & IPV6_AF_ADDED &&
1535 !(ia2->flags & IPV6_AF_DADCOMPLETED))
1536 {
1537 completed = false;
1538 break;
1539 }
1540 if (DECLINE_IA(ia))
1541 oneduplicated = true;
1542 }
1543 if (!completed)
1544 return;
1545
1546 logdebugx("%s: DHCPv6 DAD completed", ifp->name);
1547
1548 if (oneduplicated && state->state == DH6S_BOUND) {
1549 dhcp6_startdecline(ifp);
1550 return;
1551 }
1552
1553 script_runreason(ifp,
1554 #ifndef SMALL
1555 ia->delegating_prefix ? "DELEGATED6" :
1556 #endif
1557 state->reason);
1558 if (valid)
1559 dhcpcd_daemonise(ifp->ctx);
1560 }
1561
1562 static void
1563 dhcp6_addrequestedaddrs(struct interface *ifp)
1564 {
1565 struct dhcp6_state *state;
1566 size_t i;
1567 struct if_ia *ia;
1568 struct ipv6_addr *a;
1569
1570 state = D6_STATE(ifp);
1571 /* Add any requested prefixes / addresses */
1572 for (i = 0; i < ifp->options->ia_len; i++) {
1573 ia = &ifp->options->ia[i];
1574 if (!((ia->ia_type == D6_OPTION_IA_PD && ia->prefix_len) ||
1575 !IN6_IS_ADDR_UNSPECIFIED(&ia->addr)))
1576 continue;
1577 a = ipv6_newaddr(ifp, &ia->addr,
1578 /*
1579 * RFC 5942 Section 5
1580 * We cannot assume any prefix length, nor tie the
1581 * address to an existing one as it could expire
1582 * before the address.
1583 * As such we just give it a 128 prefix.
1584 */
1585 ia->ia_type == D6_OPTION_IA_PD ? ia->prefix_len : 128,
1586 IPV6_AF_REQUEST);
1587 if (a == NULL)
1588 continue;
1589 a->dadcallback = dhcp6_dadcallback;
1590 memcpy(&a->iaid, &ia->iaid, sizeof(a->iaid));
1591 a->ia_type = ia->ia_type;
1592 TAILQ_INSERT_TAIL(&state->addrs, a, next);
1593 }
1594 }
1595
1596 static void
1597 dhcp6_startdiscover(void *arg)
1598 {
1599 struct interface *ifp;
1600 struct dhcp6_state *state;
1601 int llevel;
1602
1603 ifp = arg;
1604 state = D6_STATE(ifp);
1605 #ifndef SMALL
1606 if (state->reason == NULL || strcmp(state->reason, "TIMEOUT6") != 0)
1607 dhcp6_delete_delegates(ifp);
1608 #endif
1609 if (state->new == NULL && !state->failed)
1610 llevel = LOG_INFO;
1611 else
1612 llevel = LOG_DEBUG;
1613 logmessage(llevel, "%s: soliciting a DHCPv6 lease", ifp->name);
1614 state->state = DH6S_DISCOVER;
1615 state->RTC = 0;
1616 state->IMD = SOL_MAX_DELAY;
1617 state->IRT = SOL_TIMEOUT;
1618 state->MRT = state->sol_max_rt;
1619 state->MRC = SOL_MAX_RC;
1620
1621 eloop_timeout_delete(ifp->ctx->eloop, NULL, ifp);
1622 free(state->new);
1623 state->new = NULL;
1624 state->new_len = 0;
1625
1626 if (dhcp6_makemessage(ifp) == -1)
1627 logerr("%s: %s", __func__, ifp->name);
1628 else
1629 dhcp6_senddiscover(ifp);
1630 }
1631
1632 static void
1633 dhcp6_startinform(void *arg)
1634 {
1635 struct interface *ifp;
1636 struct dhcp6_state *state;
1637 int llevel;
1638
1639 ifp = arg;
1640 state = D6_STATE(ifp);
1641 if (state->new == NULL && !state->failed)
1642 llevel = LOG_INFO;
1643 else
1644 llevel = LOG_DEBUG;
1645 logmessage(llevel, "%s: requesting DHCPv6 information", ifp->name);
1646 state->state = DH6S_INFORM;
1647 state->RTC = 0;
1648 state->IMD = INF_MAX_DELAY;
1649 state->IRT = INF_TIMEOUT;
1650 state->MRT = state->inf_max_rt;
1651 state->MRC = 0;
1652
1653 eloop_timeout_delete(ifp->ctx->eloop, NULL, ifp);
1654 if (dhcp6_makemessage(ifp) == -1) {
1655 logerr("%s: %s", __func__, ifp->name);
1656 return;
1657 }
1658 dhcp6_sendinform(ifp);
1659 /* RFC3315 18.1.2 says that if CONFIRM failed then the prior addresses
1660 * SHOULD be used. The wording here is poor, because the addresses are
1661 * merely one facet of the lease as a whole.
1662 * This poor wording might explain the lack of similar text for INFORM
1663 * in 18.1.5 because there are no addresses in the INFORM message. */
1664 eloop_timeout_add_sec(ifp->ctx->eloop,
1665 INF_MAX_RD, dhcp6_failinform, ifp);
1666 }
1667
1668 static bool
1669 dhcp6_startdiscoinform(struct interface *ifp)
1670 {
1671 unsigned long long opts = ifp->options->options;
1672
1673 if (opts & DHCPCD_IA_FORCED || ipv6nd_hasradhcp(ifp, true))
1674 dhcp6_startdiscover(ifp);
1675 else if (opts & DHCPCD_INFORM6 || ipv6nd_hasradhcp(ifp, false))
1676 dhcp6_startinform(ifp);
1677 else
1678 return false;
1679 return true;
1680 }
1681
1682 static void
1683 dhcp6_leaseextend(struct interface *ifp)
1684 {
1685 struct dhcp6_state *state = D6_STATE(ifp);
1686 struct ipv6_addr *ia;
1687
1688 logwarnx("%s: extending DHCPv6 lease", ifp->name);
1689 TAILQ_FOREACH(ia, &state->addrs, next) {
1690 ia->flags |= IPV6_AF_EXTENDED;
1691 /* Set infinite lifetimes. */
1692 ia->prefix_pltime = ND6_INFINITE_LIFETIME;
1693 ia->prefix_vltime = ND6_INFINITE_LIFETIME;
1694 }
1695 }
1696
1697 static void
1698 dhcp6_fail(struct interface *ifp)
1699 {
1700 struct dhcp6_state *state = D6_STATE(ifp);
1701
1702 state->failed = true;
1703
1704 /* RFC3315 18.1.2 says that prior addresses SHOULD be used on failure.
1705 * RFC2131 3.2.3 says that MAY chose to use the prior address.
1706 * Because dhcpcd was written first for RFC2131, we have the LASTLEASE
1707 * option which defaults to off as that makes the most sense for
1708 * mobile clients.
1709 * dhcpcd also has LASTLEASE_EXTEND to extend this lease past it's
1710 * expiry, but this is strictly not RFC compliant in any way or form. */
1711 if (state->new != NULL &&
1712 ifp->options->options & DHCPCD_LASTLEASE_EXTEND)
1713 {
1714 dhcp6_leaseextend(ifp);
1715 dhcp6_bind(ifp, NULL, NULL);
1716 } else {
1717 dhcp6_freedrop_addrs(ifp, 1, NULL);
1718 #ifndef SMALL
1719 dhcp6_delete_delegates(ifp);
1720 #endif
1721 free(state->old);
1722 state->old = state->new;
1723 state->old_len = state->new_len;
1724 state->new = NULL;
1725 state->new_len = 0;
1726 if (state->old != NULL)
1727 script_runreason(ifp, "EXPIRE6");
1728 dhcp_unlink(ifp->ctx, state->leasefile);
1729 dhcp6_addrequestedaddrs(ifp);
1730 }
1731
1732 if (!dhcp6_startdiscoinform(ifp)) {
1733 logwarnx("%s: no advertising IPv6 router wants DHCP",ifp->name);
1734 state->state = DH6S_INIT;
1735 eloop_timeout_delete(ifp->ctx->eloop, NULL, ifp);
1736 }
1737 }
1738
1739 static int
1740 dhcp6_failloglevel(struct interface *ifp)
1741 {
1742 const struct dhcp6_state *state = D6_CSTATE(ifp);
1743
1744 return state->failed ? LOG_DEBUG : LOG_ERR;
1745 }
1746
1747 static void
1748 dhcp6_failconfirm(void *arg)
1749 {
1750 struct interface *ifp = arg;
1751 int llevel = dhcp6_failloglevel(ifp);
1752
1753 logmessage(llevel, "%s: failed to confirm prior DHCPv6 address",
1754 ifp->name);
1755 dhcp6_fail(ifp);
1756 }
1757
1758 static void
1759 dhcp6_failrequest(void *arg)
1760 {
1761 struct interface *ifp = arg;
1762 int llevel = dhcp6_failloglevel(ifp);
1763
1764 logmessage(llevel, "%s: failed to request DHCPv6 address", ifp->name);
1765 dhcp6_fail(ifp);
1766 }
1767
1768 static void
1769 dhcp6_failinform(void *arg)
1770 {
1771 struct interface *ifp = arg;
1772 int llevel = dhcp6_failloglevel(ifp);
1773
1774 logmessage(llevel, "%s: failed to request DHCPv6 information",
1775 ifp->name);
1776 dhcp6_fail(ifp);
1777 }
1778
1779 #ifndef SMALL
1780 static void
1781 dhcp6_failrebind(void *arg)
1782 {
1783 struct interface *ifp = arg;
1784
1785 logerrx("%s: failed to rebind prior DHCPv6 delegation", ifp->name);
1786 dhcp6_fail(ifp);
1787 }
1788
1789 static int
1790 dhcp6_hasprefixdelegation(struct interface *ifp)
1791 {
1792 size_t i;
1793 uint16_t t;
1794
1795 t = 0;
1796 for (i = 0; i < ifp->options->ia_len; i++) {
1797 if (t && t != ifp->options->ia[i].ia_type) {
1798 if (t == D6_OPTION_IA_PD ||
1799 ifp->options->ia[i].ia_type == D6_OPTION_IA_PD)
1800 return 2;
1801 }
1802 t = ifp->options->ia[i].ia_type;
1803 }
1804 return t == D6_OPTION_IA_PD ? 1 : 0;
1805 }
1806 #endif
1807
1808 static void
1809 dhcp6_startrebind(void *arg)
1810 {
1811 struct interface *ifp;
1812 struct dhcp6_state *state;
1813 #ifndef SMALL
1814 int pd;
1815 #endif
1816
1817 ifp = arg;
1818 eloop_timeout_delete(ifp->ctx->eloop, dhcp6_sendrenew, ifp);
1819 state = D6_STATE(ifp);
1820 if (state->state == DH6S_RENEW)
1821 logwarnx("%s: failed to renew DHCPv6, rebinding", ifp->name);
1822 else
1823 loginfox("%s: rebinding prior DHCPv6 lease", ifp->name);
1824 state->state = DH6S_REBIND;
1825 state->RTC = 0;
1826 state->MRC = 0;
1827
1828 #ifndef SMALL
1829 /* RFC 3633 section 12.1 */
1830 pd = dhcp6_hasprefixdelegation(ifp);
1831 if (pd) {
1832 state->IMD = CNF_MAX_DELAY;
1833 state->IRT = CNF_TIMEOUT;
1834 state->MRT = CNF_MAX_RT;
1835 } else
1836 #endif
1837 {
1838 state->IMD = REB_MAX_DELAY;
1839 state->IRT = REB_TIMEOUT;
1840 state->MRT = REB_MAX_RT;
1841 }
1842
1843 if (dhcp6_makemessage(ifp) == -1)
1844 logerr("%s: %s", __func__, ifp->name);
1845 else
1846 dhcp6_sendrebind(ifp);
1847
1848 #ifndef SMALL
1849 /* RFC 3633 section 12.1 */
1850 if (pd)
1851 eloop_timeout_add_sec(ifp->ctx->eloop,
1852 CNF_MAX_RD, dhcp6_failrebind, ifp);
1853 #endif
1854 }
1855
1856
1857 static void
1858 dhcp6_startrequest(struct interface *ifp)
1859 {
1860 struct dhcp6_state *state;
1861
1862 eloop_timeout_delete(ifp->ctx->eloop, dhcp6_senddiscover, ifp);
1863 state = D6_STATE(ifp);
1864 state->state = DH6S_REQUEST;
1865 state->RTC = 0;
1866 state->IMD = 0;
1867 state->IRT = REQ_TIMEOUT;
1868 state->MRT = REQ_MAX_RT;
1869 state->MRC = REQ_MAX_RC;
1870 state->MRCcallback = dhcp6_failrequest;
1871
1872 if (dhcp6_makemessage(ifp) == -1) {
1873 logerr("%s: %s", __func__, ifp->name);
1874 return;
1875 }
1876
1877 dhcp6_sendrequest(ifp);
1878 }
1879
1880 static void
1881 dhcp6_startconfirm(struct interface *ifp)
1882 {
1883 struct dhcp6_state *state;
1884 struct ipv6_addr *ia;
1885
1886 state = D6_STATE(ifp);
1887
1888 TAILQ_FOREACH(ia, &state->addrs, next) {
1889 if (!DECLINE_IA(ia))
1890 continue;
1891 logerrx("%s: prior DHCPv6 has a duplicated address", ifp->name);
1892 dhcp6_startdecline(ifp);
1893 return;
1894 }
1895
1896 state->state = DH6S_CONFIRM;
1897 state->RTC = 0;
1898 state->IMD = CNF_MAX_DELAY;
1899 state->IRT = CNF_TIMEOUT;
1900 state->MRT = CNF_MAX_RT;
1901 state->MRC = CNF_MAX_RC;
1902
1903 loginfox("%s: confirming prior DHCPv6 lease", ifp->name);
1904
1905 if (dhcp6_makemessage(ifp) == -1) {
1906 logerr("%s: %s", __func__, ifp->name);
1907 return;
1908 }
1909 dhcp6_sendconfirm(ifp);
1910 eloop_timeout_add_sec(ifp->ctx->eloop,
1911 CNF_MAX_RD, dhcp6_failconfirm, ifp);
1912 }
1913
1914 static void
1915 dhcp6_startexpire(void *arg)
1916 {
1917 struct interface *ifp;
1918
1919 ifp = arg;
1920 eloop_timeout_delete(ifp->ctx->eloop, dhcp6_sendrebind, ifp);
1921
1922 logerrx("%s: DHCPv6 lease expired", ifp->name);
1923 dhcp6_fail(ifp);
1924 }
1925
1926 static void
1927 dhcp6_faildecline(void *arg)
1928 {
1929 struct interface *ifp = arg;
1930
1931 logerrx("%s: failed to decline duplicated DHCPv6 addresses", ifp->name);
1932 dhcp6_fail(ifp);
1933 }
1934
1935 static void
1936 dhcp6_startdecline(struct interface *ifp)
1937 {
1938 struct dhcp6_state *state;
1939
1940 state = D6_STATE(ifp);
1941 loginfox("%s: declining failed DHCPv6 addresses", ifp->name);
1942 state->state = DH6S_DECLINE;
1943 state->RTC = 0;
1944 state->IMD = 0;
1945 state->IRT = DEC_TIMEOUT;
1946 state->MRT = 0;
1947 state->MRC = DEC_MAX_RC;
1948 state->MRCcallback = dhcp6_faildecline;
1949
1950 if (dhcp6_makemessage(ifp) == -1)
1951 logerr("%s: %s", __func__, ifp->name);
1952 else
1953 dhcp6_senddecline(ifp);
1954 }
1955
1956 static void
1957 dhcp6_finishrelease(void *arg)
1958 {
1959 struct interface *ifp;
1960 struct dhcp6_state *state;
1961
1962 ifp = (struct interface *)arg;
1963 if ((state = D6_STATE(ifp)) != NULL) {
1964 state->state = DH6S_RELEASED;
1965 dhcp6_drop(ifp, "RELEASE6");
1966 }
1967 }
1968
1969 static void
1970 dhcp6_startrelease(struct interface *ifp)
1971 {
1972 struct dhcp6_state *state;
1973
1974 state = D6_STATE(ifp);
1975 if (state->state != DH6S_BOUND)
1976 return;
1977
1978 state->state = DH6S_RELEASE;
1979 state->RTC = 0;
1980 state->IMD = REL_MAX_DELAY;
1981 state->IRT = REL_TIMEOUT;
1982 state->MRT = REL_MAX_RT;
1983 /* MRC of REL_MAX_RC is optional in RFC 3315 18.1.6 */
1984 #if 0
1985 state->MRC = REL_MAX_RC;
1986 state->MRCcallback = dhcp6_finishrelease;
1987 #else
1988 state->MRC = 0;
1989 state->MRCcallback = NULL;
1990 #endif
1991
1992 if (dhcp6_makemessage(ifp) == -1)
1993 logerr("%s: %s", __func__, ifp->name);
1994 else {
1995 dhcp6_sendrelease(ifp);
1996 dhcp6_finishrelease(ifp);
1997 }
1998 }
1999
2000 static int
2001 dhcp6_checkstatusok(const struct interface *ifp,
2002 struct dhcp6_message *m, uint8_t *p, size_t len)
2003 {
2004 struct dhcp6_state *state;
2005 uint8_t *opt;
2006 uint16_t opt_len, code;
2007 size_t mlen;
2008 void * (*f)(void *, size_t, uint16_t, uint16_t *), *farg;
2009 char buf[32], *sbuf;
2010 const char *status;
2011 int loglevel;
2012
2013 state = D6_STATE(ifp);
2014 f = p ? dhcp6_findoption : dhcp6_findmoption;
2015 if (p)
2016 farg = p;
2017 else
2018 farg = m;
2019 if ((opt = f(farg, len, D6_OPTION_STATUS_CODE, &opt_len)) == NULL) {
2020 //logdebugx("%s: no status", ifp->name);
2021 state->lerror = 0;
2022 errno = ESRCH;
2023 return 0;
2024 }
2025
2026 if (opt_len < sizeof(code)) {
2027 logerrx("%s: status truncated", ifp->name);
2028 return -1;
2029 }
2030 memcpy(&code, opt, sizeof(code));
2031 code = ntohs(code);
2032 if (code == D6_STATUS_OK) {
2033 state->lerror = 0;
2034 errno = 0;
2035 return 0;
2036 }
2037
2038 /* Anything after the code is a message. */
2039 opt += sizeof(code);
2040 mlen = opt_len - sizeof(code);
2041 if (mlen == 0) {
2042 sbuf = NULL;
2043 if (code < sizeof(dhcp6_statuses) / sizeof(char *))
2044 status = dhcp6_statuses[code];
2045 else {
2046 snprintf(buf, sizeof(buf), "Unknown Status (%d)", code);
2047 status = buf;
2048 }
2049 } else {
2050 if ((sbuf = malloc(mlen + 1)) == NULL) {
2051 logerr(__func__);
2052 return -1;
2053 }
2054 memcpy(sbuf, opt, mlen);
2055 sbuf[mlen] = '\0';
2056 status = sbuf;
2057 }
2058
2059 if (state->lerror == code || state->state == DH6S_INIT)
2060 loglevel = LOG_DEBUG;
2061 else
2062 loglevel = LOG_ERR;
2063 logmessage(loglevel, "%s: DHCPv6 REPLY: %s", ifp->name, status);
2064 free(sbuf);
2065 state->lerror = code;
2066 errno = 0;
2067 return (int)code;
2068 }
2069
2070 const struct ipv6_addr *
2071 dhcp6_iffindaddr(const struct interface *ifp, const struct in6_addr *addr,
2072 unsigned int flags)
2073 {
2074 const struct dhcp6_state *state;
2075 const struct ipv6_addr *ap;
2076
2077 if ((state = D6_STATE(ifp)) != NULL) {
2078 TAILQ_FOREACH(ap, &state->addrs, next) {
2079 if (ipv6_findaddrmatch(ap, addr, flags))
2080 return ap;
2081 }
2082 }
2083 return NULL;
2084 }
2085
2086 struct ipv6_addr *
2087 dhcp6_findaddr(struct dhcpcd_ctx *ctx, const struct in6_addr *addr,
2088 unsigned int flags)
2089 {
2090 struct interface *ifp;
2091 struct ipv6_addr *ap;
2092 struct dhcp6_state *state;
2093
2094 TAILQ_FOREACH(ifp, ctx->ifaces, next) {
2095 if ((state = D6_STATE(ifp)) != NULL) {
2096 TAILQ_FOREACH(ap, &state->addrs, next) {
2097 if (ipv6_findaddrmatch(ap, addr, flags))
2098 return ap;
2099 }
2100 }
2101 }
2102 return NULL;
2103 }
2104
2105 static int
2106 dhcp6_findna(struct interface *ifp, uint16_t ot, const uint8_t *iaid,
2107 uint8_t *d, size_t l, const struct timespec *acquired)
2108 {
2109 struct dhcp6_state *state;
2110 uint8_t *o, *nd;
2111 uint16_t ol;
2112 struct ipv6_addr *a;
2113 int i;
2114 struct dhcp6_ia_addr ia;
2115
2116 i = 0;
2117 state = D6_STATE(ifp);
2118 while ((o = dhcp6_findoption(d, l, D6_OPTION_IA_ADDR, &ol))) {
2119 /* Set d and l first to ensure we find the next option. */
2120 nd = o + ol;
2121 l -= (size_t)(nd - d);
2122 d = nd;
2123 if (ol < sizeof(ia)) {
2124 errno = EINVAL;
2125 logerrx("%s: IA Address option truncated", ifp->name);
2126 continue;
2127 }
2128 memcpy(&ia, o, sizeof(ia));
2129 ia.pltime = ntohl(ia.pltime);
2130 ia.vltime = ntohl(ia.vltime);
2131 /* RFC 3315 22.6 */
2132 if (ia.pltime > ia.vltime) {
2133 errno = EINVAL;
2134 logerr("%s: IA Address pltime %"PRIu32
2135 " > vltime %"PRIu32,
2136 ifp->name, ia.pltime, ia.vltime);
2137 continue;
2138 }
2139 TAILQ_FOREACH(a, &state->addrs, next) {
2140 if (ipv6_findaddrmatch(a, &ia.addr, 0))
2141 break;
2142 }
2143 if (a == NULL) {
2144 /*
2145 * RFC 5942 Section 5
2146 * We cannot assume any prefix length, nor tie the
2147 * address to an existing one as it could expire
2148 * before the address.
2149 * As such we just give it a 128 prefix.
2150 */
2151 a = ipv6_newaddr(ifp, &ia.addr, 128, IPV6_AF_ONLINK);
2152 a->dadcallback = dhcp6_dadcallback;
2153 a->ia_type = ot;
2154 memcpy(a->iaid, iaid, sizeof(a->iaid));
2155 a->created = *acquired;
2156
2157 TAILQ_INSERT_TAIL(&state->addrs, a, next);
2158 } else {
2159 if (!(a->flags & IPV6_AF_ONLINK))
2160 a->flags |= IPV6_AF_ONLINK | IPV6_AF_NEW;
2161 a->flags &= ~(IPV6_AF_STALE | IPV6_AF_EXTENDED);
2162 }
2163 a->acquired = *acquired;
2164 a->prefix_pltime = ia.pltime;
2165 if (a->prefix_vltime != ia.vltime) {
2166 a->flags |= IPV6_AF_NEW;
2167 a->prefix_vltime = ia.vltime;
2168 }
2169 if (a->prefix_pltime && a->prefix_pltime < state->lowpl)
2170 state->lowpl = a->prefix_pltime;
2171 if (a->prefix_vltime && a->prefix_vltime > state->expire)
2172 state->expire = a->prefix_vltime;
2173 i++;
2174 }
2175 return i;
2176 }
2177
2178 #ifndef SMALL
2179 static int
2180 dhcp6_findpd(struct interface *ifp, const uint8_t *iaid,
2181 uint8_t *d, size_t l, const struct timespec *acquired)
2182 {
2183 struct dhcp6_state *state;
2184 uint8_t *o, *nd;
2185 struct ipv6_addr *a;
2186 int i;
2187 uint8_t nb, *pw;
2188 uint16_t ol;
2189 struct dhcp6_pd_addr pdp;
2190 struct in6_addr pdp_prefix;
2191
2192 i = 0;
2193 state = D6_STATE(ifp);
2194 while ((o = dhcp6_findoption(d, l, D6_OPTION_IAPREFIX, &ol))) {
2195 /* Set d and l first to ensure we find the next option. */
2196 nd = o + ol;
2197 l -= (size_t)(nd - d);
2198 d = nd;
2199 if (ol < sizeof(pdp)) {
2200 errno = EINVAL;
2201 logerrx("%s: IA Prefix option truncated", ifp->name);
2202 continue;
2203 }
2204
2205 memcpy(&pdp, o, sizeof(pdp));
2206 pdp.pltime = ntohl(pdp.pltime);
2207 pdp.vltime = ntohl(pdp.vltime);
2208 /* RFC 3315 22.6 */
2209 if (pdp.pltime > pdp.vltime) {
2210 errno = EINVAL;
2211 logerrx("%s: IA Prefix pltime %"PRIu32
2212 " > vltime %"PRIu32,
2213 ifp->name, pdp.pltime, pdp.vltime);
2214 continue;
2215 }
2216
2217 o += sizeof(pdp);
2218 ol = (uint16_t)(ol - sizeof(pdp));
2219
2220 /* pdp.prefix is not aligned so copy it out. */
2221 memcpy(&pdp_prefix, &pdp.prefix, sizeof(pdp_prefix));
2222 TAILQ_FOREACH(a, &state->addrs, next) {
2223 if (IN6_ARE_ADDR_EQUAL(&a->prefix, &pdp_prefix))
2224 break;
2225 }
2226
2227 if (a == NULL) {
2228 a = ipv6_newaddr(ifp, &pdp_prefix, pdp.prefix_len,
2229 IPV6_AF_DELEGATEDPFX);
2230 if (a == NULL)
2231 break;
2232 a->created = *acquired;
2233 a->dadcallback = dhcp6_dadcallback;
2234 a->ia_type = D6_OPTION_IA_PD;
2235 memcpy(a->iaid, iaid, sizeof(a->iaid));
2236 TAILQ_INSERT_TAIL(&state->addrs, a, next);
2237 } else {
2238 if (!(a->flags & IPV6_AF_DELEGATEDPFX))
2239 a->flags |= IPV6_AF_NEW | IPV6_AF_DELEGATEDPFX;
2240 a->flags &= ~(IPV6_AF_STALE |
2241 IPV6_AF_EXTENDED |
2242 IPV6_AF_REQUEST);
2243 if (a->prefix_vltime != pdp.vltime)
2244 a->flags |= IPV6_AF_NEW;
2245 }
2246
2247 a->acquired = *acquired;
2248 a->prefix_pltime = pdp.pltime;
2249 a->prefix_vltime = pdp.vltime;
2250
2251 if (a->prefix_pltime && a->prefix_pltime < state->lowpl)
2252 state->lowpl = a->prefix_pltime;
2253 if (a->prefix_vltime && a->prefix_vltime > state->expire)
2254 state->expire = a->prefix_vltime;
2255 i++;
2256
2257 a->prefix_exclude_len = 0;
2258 memset(&a->prefix_exclude, 0, sizeof(a->prefix_exclude));
2259 o = dhcp6_findoption(o, ol, D6_OPTION_PD_EXCLUDE, &ol);
2260 if (o == NULL)
2261 continue;
2262
2263 /* RFC 6603 4.2 says option length MUST be between 2 and 17.
2264 * This allows 1 octet for prefix length and 16 for the
2265 * subnet ID. */
2266 if (ol < 2 || ol > 17) {
2267 logerrx("%s: invalid PD Exclude option", ifp->name);
2268 continue;
2269 }
2270
2271 /* RFC 6603 4.2 says prefix length MUST be between the
2272 * length of the IAPREFIX prefix length + 1 and 128. */
2273 if (*o < a->prefix_len + 1 || *o > 128) {
2274 logerrx("%s: invalid PD Exclude length", ifp->name);
2275 continue;
2276 }
2277
2278 ol--;
2279 /* Check option length matches prefix length. */
2280 if (((*o - a->prefix_len - 1) / NBBY) + 1 != ol) {
2281 logerrx("%s: PD Exclude length mismatch", ifp->name);
2282 continue;
2283 }
2284 a->prefix_exclude_len = *o++;
2285
2286 memcpy(&a->prefix_exclude, &a->prefix,
2287 sizeof(a->prefix_exclude));
2288 nb = a->prefix_len % NBBY;
2289 if (nb)
2290 ol--;
2291 pw = a->prefix_exclude.s6_addr +
2292 (a->prefix_exclude_len / NBBY) - 1;
2293 while (ol-- > 0)
2294 *pw-- = *o++;
2295 if (nb)
2296 *pw = (uint8_t)(*pw | (*o >> nb));
2297 }
2298 return i;
2299 }
2300 #endif
2301
2302 static int
2303 dhcp6_findia(struct interface *ifp, struct dhcp6_message *m, size_t l,
2304 const char *sfrom, const struct timespec *acquired)
2305 {
2306 struct dhcp6_state *state;
2307 const struct if_options *ifo;
2308 struct dhcp6_option o;
2309 uint8_t *d, *p;
2310 struct dhcp6_ia_na ia;
2311 int i, e, error;
2312 size_t j;
2313 uint16_t nl;
2314 uint8_t iaid[4];
2315 char buf[sizeof(iaid) * 3];
2316 struct ipv6_addr *ap;
2317 struct if_ia *ifia;
2318
2319 if (l < sizeof(*m)) {
2320 /* Should be impossible with guards at packet in
2321 * and reading leases */
2322 errno = EINVAL;
2323 return -1;
2324 }
2325
2326 ifo = ifp->options;
2327 i = e = 0;
2328 state = D6_STATE(ifp);
2329 TAILQ_FOREACH(ap, &state->addrs, next) {
2330 if (!(ap->flags & IPV6_AF_DELEGATED))
2331 ap->flags |= IPV6_AF_STALE;
2332 }
2333
2334 d = (uint8_t *)m + sizeof(*m);
2335 l -= sizeof(*m);
2336 while (l > sizeof(o)) {
2337 memcpy(&o, d, sizeof(o));
2338 o.len = ntohs(o.len);
2339 if (o.len > l || sizeof(o) + o.len > l) {
2340 errno = EINVAL;
2341 logerrx("%s: option overflow", ifp->name);
2342 break;
2343 }
2344 p = d + sizeof(o);
2345 d = p + o.len;
2346 l -= sizeof(o) + o.len;
2347
2348 o.code = ntohs(o.code);
2349 switch(o.code) {
2350 case D6_OPTION_IA_TA:
2351 nl = 4;
2352 break;
2353 case D6_OPTION_IA_NA:
2354 case D6_OPTION_IA_PD:
2355 nl = 12;
2356 break;
2357 default:
2358 continue;
2359 }
2360 if (o.len < nl) {
2361 errno = EINVAL;
2362 logerrx("%s: IA option truncated", ifp->name);
2363 continue;
2364 }
2365
2366 memcpy(&ia, p, nl);
2367 p += nl;
2368 o.len = (uint16_t)(o.len - nl);
2369
2370 for (j = 0; j < ifo->ia_len; j++) {
2371 ifia = &ifo->ia[j];
2372 if (ifia->ia_type == o.code &&
2373 memcmp(ifia->iaid, ia.iaid, sizeof(ia.iaid)) == 0)
2374 break;
2375 }
2376 if (j == ifo->ia_len &&
2377 !(ifo->ia_len == 0 && ifp->ctx->options & DHCPCD_DUMPLEASE))
2378 {
2379 logdebugx("%s: ignoring unrequested IAID %s",
2380 ifp->name,
2381 hwaddr_ntoa(ia.iaid, sizeof(ia.iaid),
2382 buf, sizeof(buf)));
2383 continue;
2384 }
2385
2386 if (o.code != D6_OPTION_IA_TA) {
2387 ia.t1 = ntohl(ia.t1);
2388 ia.t2 = ntohl(ia.t2);
2389 /* RFC 3315 22.4 */
2390 if (ia.t2 > 0 && ia.t1 > ia.t2) {
2391 logwarnx("%s: IAID %s T1(%d) > T2(%d) from %s",
2392 ifp->name,
2393 hwaddr_ntoa(iaid, sizeof(iaid), buf,
2394 sizeof(buf)),
2395 ia.t1, ia.t2, sfrom);
2396 continue;
2397 }
2398 } else
2399 ia.t1 = ia.t2 = 0; /* appease gcc */
2400 if ((error = dhcp6_checkstatusok(ifp, NULL, p, o.len)) != 0) {
2401 if (error == D6_STATUS_NOBINDING)
2402 state->has_no_binding = true;
2403 e = 1;
2404 continue;
2405 }
2406 if (o.code == D6_OPTION_IA_PD) {
2407 #ifndef SMALL
2408 if (dhcp6_findpd(ifp, ia.iaid, p, o.len,
2409 acquired) == 0)
2410 {
2411 logwarnx("%s: %s: DHCPv6 REPLY missing Prefix",
2412 ifp->name, sfrom);
2413 continue;
2414 }
2415 #endif
2416 } else {
2417 if (dhcp6_findna(ifp, o.code, ia.iaid, p, o.len,
2418 acquired) == 0)
2419 {
2420 logwarnx("%s: %s: DHCPv6 REPLY missing "
2421 "IA Address",
2422 ifp->name, sfrom);
2423 continue;
2424 }
2425 }
2426 if (o.code != D6_OPTION_IA_TA) {
2427 if (ia.t1 != 0 &&
2428 (ia.t1 < state->renew || state->renew == 0))
2429 state->renew = ia.t1;
2430 if (ia.t2 != 0 &&
2431 (ia.t2 < state->rebind || state->rebind == 0))
2432 state->rebind = ia.t2;
2433 }
2434 i++;
2435 }
2436
2437 if (i == 0 && e)
2438 return -1;
2439 return i;
2440 }
2441
2442 #ifndef SMALL
2443 static void
2444 dhcp6_deprecatedele(struct ipv6_addr *ia)
2445 {
2446 struct ipv6_addr *da, *dan, *dda;
2447 struct timespec now;
2448 struct dhcp6_state *state;
2449
2450 timespecclear(&now);
2451 TAILQ_FOREACH_SAFE(da, &ia->pd_pfxs, pd_next, dan) {
2452 if (ia->prefix_vltime == 0) {
2453 if (da->prefix_vltime != 0)
2454 da->prefix_vltime = 0;
2455 else
2456 continue;
2457 } else if (da->prefix_pltime != 0)
2458 da->prefix_pltime = 0;
2459 else
2460 continue;
2461
2462 if (ipv6_doaddr(da, &now) != -1)
2463 continue;
2464
2465 /* Delegation deleted, forget it. */
2466 TAILQ_REMOVE(&ia->pd_pfxs, da, pd_next);
2467
2468 /* Delete it from the interface. */
2469 state = D6_STATE(da->iface);
2470 TAILQ_FOREACH(dda, &state->addrs, next) {
2471 if (IN6_ARE_ADDR_EQUAL(&dda->addr, &da->addr))
2472 break;
2473 }
2474 if (dda != NULL) {
2475 TAILQ_REMOVE(&state->addrs, dda, next);
2476 ipv6_freeaddr(dda);
2477 }
2478 }
2479 }
2480 #endif
2481
2482 static void
2483 dhcp6_deprecateaddrs(struct ipv6_addrhead *addrs)
2484 {
2485 struct ipv6_addr *ia, *ian;
2486
2487 TAILQ_FOREACH_SAFE(ia, addrs, next, ian) {
2488 if (ia->flags & IPV6_AF_EXTENDED)
2489 ;
2490 else if (ia->flags & IPV6_AF_STALE) {
2491 if (ia->prefix_vltime != 0)
2492 logdebugx("%s: %s: became stale",
2493 ia->iface->name, ia->saddr);
2494 /* Technically this violates RFC 8415 18.2.10.1,
2495 * but we need a mechanism to tell the kernel to
2496 * try and prefer other addresses. */
2497 ia->prefix_pltime = 0;
2498 } else if (ia->prefix_vltime == 0)
2499 loginfox("%s: %s: no valid lifetime",
2500 ia->iface->name, ia->saddr);
2501 else
2502 continue;
2503
2504 #ifndef SMALL
2505 /* If we delegated from this prefix, deprecate or remove
2506 * the delegations. */
2507 if (ia->flags & IPV6_AF_DELEGATEDPFX)
2508 dhcp6_deprecatedele(ia);
2509 #endif
2510
2511 if (ia->flags & IPV6_AF_REQUEST) {
2512 ia->prefix_vltime = ia->prefix_pltime = 0;
2513 eloop_q_timeout_delete(ia->iface->ctx->eloop,
2514 ELOOP_QUEUE_ALL, NULL, ia);
2515 continue;
2516 }
2517 TAILQ_REMOVE(addrs, ia, next);
2518 if (ia->flags & IPV6_AF_EXTENDED)
2519 ipv6_deleteaddr(ia);
2520 ipv6_freeaddr(ia);
2521 }
2522 }
2523
2524 static int
2525 dhcp6_validatelease(struct interface *ifp,
2526 struct dhcp6_message *m, size_t len,
2527 const char *sfrom, const struct timespec *acquired)
2528 {
2529 struct dhcp6_state *state;
2530 int nia, ok_errno;
2531 struct timespec aq;
2532
2533 if (len <= sizeof(*m)) {
2534 logerrx("%s: DHCPv6 lease truncated", ifp->name);
2535 return -1;
2536 }
2537
2538 state = D6_STATE(ifp);
2539 errno = 0;
2540 if (dhcp6_checkstatusok(ifp, m, NULL, len) != 0)
2541 return -1;
2542 ok_errno = errno;
2543
2544 state->renew = state->rebind = state->expire = 0;
2545 state->lowpl = ND6_INFINITE_LIFETIME;
2546 if (!acquired) {
2547 clock_gettime(CLOCK_MONOTONIC, &aq);
2548 acquired = &aq;
2549 }
2550 state->has_no_binding = false;
2551 nia = dhcp6_findia(ifp, m, len, sfrom, acquired);
2552 if (nia == 0) {
2553 if (state->state != DH6S_CONFIRM && ok_errno != 0) {
2554 logerrx("%s: no useable IA found in lease", ifp->name);
2555 return -1;
2556 }
2557
2558 /* We are confirming and have an OK,
2559 * so look for ia's in our old lease.
2560 * IA's must have existed here otherwise we would
2561 * have rejected it earlier. */
2562 assert(state->new != NULL && state->new_len != 0);
2563 state->has_no_binding = false;
2564 nia = dhcp6_findia(ifp, state->new, state->new_len,
2565 sfrom, acquired);
2566 }
2567 return nia;
2568 }
2569
2570 static ssize_t
2571 dhcp6_readlease(struct interface *ifp, int validate)
2572 {
2573 union {
2574 struct dhcp6_message dhcp6;
2575 uint8_t buf[UDPLEN_MAX];
2576 } buf;
2577 struct dhcp6_state *state;
2578 ssize_t bytes;
2579 int fd;
2580 time_t mtime, now;
2581 #ifdef AUTH
2582 uint8_t *o;
2583 uint16_t ol;
2584 #endif
2585
2586 state = D6_STATE(ifp);
2587 if (state->leasefile[0] == '\0') {
2588 logdebugx("reading standard input");
2589 bytes = read(fileno(stdin), buf.buf, sizeof(buf.buf));
2590 } else {
2591 logdebugx("%s: reading lease: %s",
2592 ifp->name, state->leasefile);
2593 bytes = dhcp_readfile(ifp->ctx, state->leasefile,
2594 buf.buf, sizeof(buf.buf));
2595 }
2596 if (bytes == -1)
2597 goto ex;
2598
2599 if (ifp->ctx->options & DHCPCD_DUMPLEASE || state->leasefile[0] == '\0')
2600 goto out;
2601
2602 if (bytes == 0)
2603 goto ex;
2604
2605 /* If not validating IA's and if they have expired,
2606 * skip to the auth check. */
2607 if (!validate)
2608 goto auth;
2609
2610 if (dhcp_filemtime(ifp->ctx, state->leasefile, &mtime) == -1)
2611 goto ex;
2612 clock_gettime(CLOCK_MONOTONIC, &state->acquired);
2613 if ((now = time(NULL)) == -1)
2614 goto ex;
2615 state->acquired.tv_sec -= now - mtime;
2616
2617 /* Check to see if the lease is still valid */
2618 fd = dhcp6_validatelease(ifp, &buf.dhcp6, (size_t)bytes, NULL,
2619 &state->acquired);
2620 if (fd == -1)
2621 goto ex;
2622
2623 if (state->expire != ND6_INFINITE_LIFETIME &&
2624 (time_t)state->expire < now - mtime &&
2625 !(ifp->options->options & DHCPCD_LASTLEASE_EXTEND))
2626 {
2627 logdebugx("%s: discarding expired lease", ifp->name);
2628 bytes = 0;
2629 goto ex;
2630 }
2631
2632 auth:
2633 #ifdef AUTH
2634 /* Authenticate the message */
2635 o = dhcp6_findmoption(&buf.dhcp6, (size_t)bytes, D6_OPTION_AUTH, &ol);
2636 if (o) {
2637 if (dhcp_auth_validate(&state->auth, &ifp->options->auth,
2638 buf.buf, (size_t)bytes, 6, buf.dhcp6.type, o, ol) == NULL)
2639 {
2640 logerr("%s: authentication failed", ifp->name);
2641 bytes = 0;
2642 goto ex;
2643 }
2644 if (state->auth.token)
2645 logdebugx("%s: validated using 0x%08" PRIu32,
2646 ifp->name, state->auth.token->secretid);
2647 else
2648 loginfox("%s: accepted reconfigure key", ifp->name);
2649 } else if ((ifp->options->auth.options & DHCPCD_AUTH_SENDREQUIRE) ==
2650 DHCPCD_AUTH_SENDREQUIRE)
2651 {
2652 logerrx("%s: authentication now required", ifp->name);
2653 goto ex;
2654 }
2655 #endif
2656
2657 out:
2658 free(state->new);
2659 state->new = malloc((size_t)bytes);
2660 if (state->new == NULL) {
2661 logerr(__func__);
2662 goto ex;
2663 }
2664
2665 memcpy(state->new, buf.buf, (size_t)bytes);
2666 state->new_len = (size_t)bytes;
2667 return bytes;
2668
2669 ex:
2670 dhcp6_freedrop_addrs(ifp, 0, NULL);
2671 dhcp_unlink(ifp->ctx, state->leasefile);
2672 free(state->new);
2673 state->new = NULL;
2674 state->new_len = 0;
2675 dhcp6_addrequestedaddrs(ifp);
2676 return bytes == 0 ? 0 : -1;
2677 }
2678
2679 static void
2680 dhcp6_startinit(struct interface *ifp)
2681 {
2682 struct dhcp6_state *state;
2683 ssize_t r;
2684 uint8_t has_ta, has_non_ta;
2685 size_t i;
2686
2687 state = D6_STATE(ifp);
2688 state->state = DH6S_INIT;
2689 state->expire = ND6_INFINITE_LIFETIME;
2690 state->lowpl = ND6_INFINITE_LIFETIME;
2691
2692 dhcp6_addrequestedaddrs(ifp);
2693 has_ta = has_non_ta = 0;
2694 for (i = 0; i < ifp->options->ia_len; i++) {
2695 switch (ifp->options->ia[i].ia_type) {
2696 case D6_OPTION_IA_TA:
2697 has_ta = 1;
2698 break;
2699 default:
2700 has_non_ta = 1;
2701 }
2702 }
2703
2704 if (!(ifp->ctx->options & DHCPCD_TEST) &&
2705 !(has_ta && !has_non_ta) &&
2706 ifp->options->reboot != 0)
2707 {
2708 r = dhcp6_readlease(ifp, 1);
2709 if (r == -1) {
2710 if (errno != ENOENT && errno != ESRCH)
2711 logerr("%s: %s", __func__, state->leasefile);
2712 } else if (r != 0 &&
2713 !(ifp->options->options & DHCPCD_ANONYMOUS))
2714 {
2715 /* RFC 3633 section 12.1 */
2716 #ifndef SMALL
2717 if (dhcp6_hasprefixdelegation(ifp))
2718 dhcp6_startrebind(ifp);
2719 else
2720 #endif
2721 dhcp6_startconfirm(ifp);
2722 return;
2723 }
2724 }
2725 dhcp6_startdiscoinform(ifp);
2726 }
2727
2728 #ifndef SMALL
2729 static struct ipv6_addr *
2730 dhcp6_ifdelegateaddr(struct interface *ifp, struct ipv6_addr *prefix,
2731 const struct if_sla *sla, struct if_ia *if_ia)
2732 {
2733 struct dhcp6_state *state;
2734 struct in6_addr addr, daddr;
2735 struct ipv6_addr *ia;
2736 int pfxlen, dadcounter;
2737 uint64_t vl;
2738
2739 /* RFC6603 Section 4.2 */
2740 if (strcmp(ifp->name, prefix->iface->name) == 0) {
2741 if (prefix->prefix_exclude_len == 0) {
2742 /* Don't spam the log automatically */
2743 if (sla != NULL)
2744 logwarnx("%s: DHCPv6 server does not support "
2745 "OPTION_PD_EXCLUDE",
2746 ifp->name);
2747 return NULL;
2748 }
2749 pfxlen = prefix->prefix_exclude_len;
2750 memcpy(&addr, &prefix->prefix_exclude, sizeof(addr));
2751 } else if ((pfxlen = dhcp6_delegateaddr(&addr, ifp, prefix,
2752 sla, if_ia)) == -1)
2753 return NULL;
2754
2755 if (sla != NULL && fls64(sla->suffix) > 128 - pfxlen) {
2756 logerrx("%s: suffix %" PRIu64 " + prefix_len %d > 128",
2757 ifp->name, sla->suffix, pfxlen);
2758 return NULL;
2759 }
2760
2761 /* Add our suffix */
2762 if (sla != NULL && sla->suffix != 0) {
2763 daddr = addr;
2764 vl = be64dec(addr.s6_addr + 8);
2765 vl |= sla->suffix;
2766 be64enc(daddr.s6_addr + 8, vl);
2767 } else {
2768 dadcounter = ipv6_makeaddr(&daddr, ifp, &addr, pfxlen, 0);
2769 if (dadcounter == -1) {
2770 logerrx("%s: error adding slaac to prefix_len %d",
2771 ifp->name, pfxlen);
2772 return NULL;
2773 }
2774 }
2775
2776 /* Find an existing address */
2777 state = D6_STATE(ifp);
2778 TAILQ_FOREACH(ia, &state->addrs, next) {
2779 if (IN6_ARE_ADDR_EQUAL(&ia->addr, &daddr))
2780 break;
2781 }
2782 if (ia == NULL) {
2783 ia = ipv6_newaddr(ifp, &daddr, (uint8_t)pfxlen, IPV6_AF_ONLINK);
2784 if (ia == NULL)
2785 return NULL;
2786 ia->dadcallback = dhcp6_dadcallback;
2787 memcpy(&ia->iaid, &prefix->iaid, sizeof(ia->iaid));
2788 ia->created = prefix->acquired;
2789
2790 TAILQ_INSERT_TAIL(&state->addrs, ia, next);
2791 TAILQ_INSERT_TAIL(&prefix->pd_pfxs, ia, pd_next);
2792 }
2793 ia->delegating_prefix = prefix;
2794 ia->prefix = addr;
2795 ia->prefix_len = (uint8_t)pfxlen;
2796 ia->acquired = prefix->acquired;
2797 ia->prefix_pltime = prefix->prefix_pltime;
2798 ia->prefix_vltime = prefix->prefix_vltime;
2799
2800 /* If the prefix length hasn't changed,
2801 * don't install a reject route. */
2802 if (prefix->prefix_len == pfxlen)
2803 prefix->flags |= IPV6_AF_NOREJECT;
2804 else
2805 prefix->flags &= ~IPV6_AF_NOREJECT;
2806
2807 return ia;
2808 }
2809 #endif
2810
2811 static void
2812 dhcp6_script_try_run(struct interface *ifp, int delegated)
2813 {
2814 struct dhcp6_state *state;
2815 struct ipv6_addr *ap;
2816 int completed;
2817
2818 state = D6_STATE(ifp);
2819 completed = 1;
2820 /* If all addresses have completed DAD run the script */
2821 TAILQ_FOREACH(ap, &state->addrs, next) {
2822 if (!(ap->flags & IPV6_AF_ADDED))
2823 continue;
2824 if (ap->flags & IPV6_AF_ONLINK) {
2825 if (!(ap->flags & IPV6_AF_DADCOMPLETED) &&
2826 ipv6_iffindaddr(ap->iface, &ap->addr,
2827 IN6_IFF_TENTATIVE))
2828 ap->flags |= IPV6_AF_DADCOMPLETED;
2829 if ((ap->flags & IPV6_AF_DADCOMPLETED) == 0
2830 #ifndef SMALL
2831 && ((delegated && ap->delegating_prefix) ||
2832 (!delegated && !ap->delegating_prefix))
2833 #endif
2834 )
2835 {
2836 completed = 0;
2837 break;
2838 }
2839 }
2840 }
2841 if (completed) {
2842 script_runreason(ifp, delegated ? "DELEGATED6" : state->reason);
2843 if (!delegated)
2844 dhcpcd_daemonise(ifp->ctx);
2845 } else
2846 logdebugx("%s: waiting for DHCPv6 DAD to complete", ifp->name);
2847 }
2848
2849 #ifdef SMALL
2850 size_t
2851 dhcp6_find_delegates(__unused struct interface *ifp)
2852 {
2853
2854 return 0;
2855 }
2856 #else
2857 static void
2858 dhcp6_delegate_prefix(struct interface *ifp)
2859 {
2860 struct if_options *ifo;
2861 struct dhcp6_state *state;
2862 struct ipv6_addr *ap;
2863 size_t i, j, k;
2864 struct if_ia *ia;
2865 struct if_sla *sla;
2866 struct interface *ifd;
2867 bool carrier_warned;
2868
2869 ifo = ifp->options;
2870 state = D6_STATE(ifp);
2871
2872 /* Clear the logged flag. */
2873 TAILQ_FOREACH(ap, &state->addrs, next) {
2874 ap->flags &= ~IPV6_AF_DELEGATEDLOG;
2875 }
2876
2877 TAILQ_FOREACH(ifd, ifp->ctx->ifaces, next) {
2878 if (!ifd->active)
2879 continue;
2880 k = 0;
2881 carrier_warned = false;
2882 TAILQ_FOREACH(ap, &state->addrs, next) {
2883 if (!(ap->flags & IPV6_AF_DELEGATEDPFX))
2884 continue;
2885 if (!(ap->flags & IPV6_AF_DELEGATEDLOG)) {
2886 int loglevel;
2887
2888 if (ap->flags & IPV6_AF_NEW)
2889 loglevel = LOG_INFO;
2890 else
2891 loglevel = LOG_DEBUG;
2892 /* We only want to log this the once as we loop
2893 * through many interfaces first. */
2894 ap->flags |= IPV6_AF_DELEGATEDLOG;
2895 logmessage(loglevel, "%s: delegated prefix %s",
2896 ifp->name, ap->saddr);
2897 ap->flags &= ~IPV6_AF_NEW;
2898 }
2899 for (i = 0; i < ifo->ia_len; i++) {
2900 ia = &ifo->ia[i];
2901 if (ia->ia_type != D6_OPTION_IA_PD)
2902 continue;
2903 if (memcmp(ia->iaid, ap->iaid,
2904 sizeof(ia->iaid)))
2905 continue;
2906 if (ia->sla_len == 0) {
2907 /* no SLA configured, so lets
2908 * automate it */
2909 if (ifd->carrier != LINK_UP) {
2910 logdebugx(
2911 "%s: has no carrier, cannot"
2912 " delegate addresses",
2913 ifd->name);
2914 carrier_warned = true;
2915 break;
2916 }
2917 if (dhcp6_ifdelegateaddr(ifd, ap,
2918 NULL, ia))
2919 k++;
2920 }
2921 for (j = 0; j < ia->sla_len; j++) {
2922 sla = &ia->sla[j];
2923 if (strcmp(ifd->name, sla->ifname))
2924 continue;
2925 if (ifd->carrier != LINK_UP) {
2926 logdebugx(
2927 "%s: has no carrier, cannot"
2928 " delegate addresses",
2929 ifd->name);
2930 carrier_warned = true;
2931 break;
2932 }
2933 if (dhcp6_ifdelegateaddr(ifd, ap,
2934 sla, ia))
2935 k++;
2936 }
2937 if (carrier_warned)
2938 break;
2939 }
2940 if (carrier_warned)
2941 break;
2942 }
2943 if (k && !carrier_warned) {
2944 struct dhcp6_state *s = D6_STATE(ifd);
2945
2946 ipv6_addaddrs(&s->addrs);
2947 dhcp6_script_try_run(ifd, 1);
2948 }
2949 }
2950
2951 /* Now all addresses have been added, rebuild the routing table. */
2952 rt_build(ifp->ctx, AF_INET6);
2953 }
2954
2955 static void
2956 dhcp6_find_delegates1(void *arg)
2957 {
2958
2959 dhcp6_find_delegates(arg);
2960 }
2961
2962 size_t
2963 dhcp6_find_delegates(struct interface *ifp)
2964 {
2965 struct if_options *ifo;
2966 struct dhcp6_state *state;
2967 struct ipv6_addr *ap;
2968 size_t i, j, k;
2969 struct if_ia *ia;
2970 struct if_sla *sla;
2971 struct interface *ifd;
2972
2973 k = 0;
2974 TAILQ_FOREACH(ifd, ifp->ctx->ifaces, next) {
2975 ifo = ifd->options;
2976 state = D6_STATE(ifd);
2977 if (state == NULL || state->state != DH6S_BOUND)
2978 continue;
2979 TAILQ_FOREACH(ap, &state->addrs, next) {
2980 if (!(ap->flags & IPV6_AF_DELEGATEDPFX))
2981 continue;
2982 for (i = 0; i < ifo->ia_len; i++) {
2983 ia = &ifo->ia[i];
2984 if (ia->ia_type != D6_OPTION_IA_PD)
2985 continue;
2986 if (memcmp(ia->iaid, ap->iaid,
2987 sizeof(ia->iaid)))
2988 continue;
2989 for (j = 0; j < ia->sla_len; j++) {
2990 sla = &ia->sla[j];
2991 if (strcmp(ifp->name, sla->ifname))
2992 continue;
2993 if (ipv6_linklocal(ifp) == NULL) {
2994 logdebugx(
2995 "%s: delaying adding"
2996 " delegated addresses for"
2997 " LL address",
2998 ifp->name);
2999 ipv6_addlinklocalcallback(ifp,
3000 dhcp6_find_delegates1, ifp);
3001 return 1;
3002 }
3003 if (dhcp6_ifdelegateaddr(ifp, ap,
3004 sla, ia))
3005 k++;
3006 }
3007 }
3008 }
3009 }
3010
3011 if (k) {
3012 loginfox("%s: adding delegated prefixes", ifp->name);
3013 state = D6_STATE(ifp);
3014 state->state = DH6S_DELEGATED;
3015 ipv6_addaddrs(&state->addrs);
3016 rt_build(ifp->ctx, AF_INET6);
3017 dhcp6_script_try_run(ifp, 1);
3018 }
3019 return k;
3020 }
3021 #endif
3022
3023 static void
3024 dhcp6_bind(struct interface *ifp, const char *op, const char *sfrom)
3025 {
3026 struct dhcp6_state *state = D6_STATE(ifp);
3027 bool timedout = (op == NULL), has_new = false, confirmed;
3028 struct ipv6_addr *ia;
3029 int loglevel;
3030 struct timespec now;
3031
3032 TAILQ_FOREACH(ia, &state->addrs, next) {
3033 if (ia->flags & IPV6_AF_NEW) {
3034 has_new = true;
3035 break;
3036 }
3037 }
3038 loglevel = has_new || state->state != DH6S_RENEW ? LOG_INFO : LOG_DEBUG;
3039 if (!timedout) {
3040 logmessage(loglevel, "%s: %s received from %s",
3041 ifp->name, op, sfrom);
3042 #ifndef SMALL
3043 /* If we delegated from an unconfirmed lease we MUST drop
3044 * them now. Hopefully we have new delegations. */
3045 if (state->reason != NULL &&
3046 strcmp(state->reason, "TIMEOUT6") == 0)
3047 dhcp6_delete_delegates(ifp);
3048 #endif
3049 state->reason = NULL;
3050 } else
3051 state->reason = "TIMEOUT6";
3052
3053 eloop_timeout_delete(ifp->ctx->eloop, NULL, ifp);
3054 clock_gettime(CLOCK_MONOTONIC, &now);
3055
3056 switch(state->state) {
3057 case DH6S_INFORM:
3058 {
3059 struct dhcp6_option *o;
3060 uint16_t ol;
3061
3062 if (state->reason == NULL)
3063 state->reason = "INFORM6";
3064 o = dhcp6_findmoption(state->new, state->new_len,
3065 D6_OPTION_INFO_REFRESH_TIME, &ol);
3066 if (o == NULL || ol != sizeof(uint32_t))
3067 state->renew = IRT_DEFAULT;
3068 else {
3069 memcpy(&state->renew, o, ol);
3070 state->renew = ntohl(state->renew);
3071 if (state->renew < IRT_MINIMUM)
3072 state->renew = IRT_MINIMUM;
3073 }
3074 state->rebind = 0;
3075 state->expire = ND6_INFINITE_LIFETIME;
3076 state->lowpl = ND6_INFINITE_LIFETIME;
3077 }
3078 break;
3079
3080 case DH6S_REQUEST:
3081 if (state->reason == NULL)
3082 state->reason = "BOUND6";
3083 /* FALLTHROUGH */
3084 case DH6S_RENEW:
3085 if (state->reason == NULL)
3086 state->reason = "RENEW6";
3087 /* FALLTHROUGH */
3088 case DH6S_REBIND:
3089 if (state->reason == NULL)
3090 state->reason = "REBIND6";
3091 /* FALLTHROUGH */
3092 case DH6S_CONFIRM:
3093 if (state->reason == NULL)
3094 state->reason = "REBOOT6";
3095 if (state->renew != 0) {
3096 bool all_expired = true;
3097
3098 TAILQ_FOREACH(ia, &state->addrs, next) {
3099 if (ia->flags & IPV6_AF_STALE)
3100 continue;
3101 if (!(state->renew == ND6_INFINITE_LIFETIME
3102 && ia->prefix_vltime == ND6_INFINITE_LIFETIME)
3103 && ia->prefix_vltime != 0
3104 && ia->prefix_vltime <= state->renew)
3105 logwarnx(
3106 "%s: %s will expire before renewal",
3107 ifp->name, ia->saddr);
3108 else
3109 all_expired = false;
3110 }
3111 if (all_expired) {
3112 /* All address's vltime happens at or before
3113 * the configured T1 in the IA.
3114 * This is a badly configured server and we
3115 * have to use our own notion of what
3116 * T1 and T2 should be as a result.
3117 *
3118 * Doing this violates RFC 3315 22.4:
3119 * In a message sent by a server to a client,
3120 * the client MUST use the values in the T1
3121 * and T2 fields for the T1 and T2 parameters,
3122 * unless those values in those fields are 0.
3123 */
3124 logwarnx("%s: ignoring T1 %"PRIu32
3125 " due to address expiry",
3126 ifp->name, state->renew);
3127 state->renew = state->rebind = 0;
3128 }
3129 }
3130 if (state->renew == 0 && state->lowpl != ND6_INFINITE_LIFETIME)
3131 state->renew = (uint32_t)(state->lowpl * 0.5);
3132 if (state->rebind == 0 && state->lowpl != ND6_INFINITE_LIFETIME)
3133 state->rebind = (uint32_t)(state->lowpl * 0.8);
3134 break;
3135 default:
3136 state->reason = "UNKNOWN6";
3137 break;
3138 }
3139
3140 if (state->state != DH6S_CONFIRM && !timedout) {
3141 state->acquired = now;
3142 free(state->old);
3143 state->old = state->new;
3144 state->old_len = state->new_len;
3145 state->new = state->recv;
3146 state->new_len = state->recv_len;
3147 state->recv = NULL;
3148 state->recv_len = 0;
3149 confirmed = false;
3150 } else {
3151 /* Reduce timers based on when we got the lease. */
3152 uint32_t elapsed;
3153
3154 elapsed = (uint32_t)eloop_timespec_diff(&now,
3155 &state->acquired, NULL);
3156 if (state->renew && state->renew != ND6_INFINITE_LIFETIME) {
3157 if (state->renew > elapsed)
3158 state->renew -= elapsed;
3159 else
3160 state->renew = 0;
3161 }
3162 if (state->rebind && state->rebind != ND6_INFINITE_LIFETIME) {
3163 if (state->rebind > elapsed)
3164 state->rebind -= elapsed;
3165 else
3166 state->rebind = 0;
3167 }
3168 if (state->expire && state->expire != ND6_INFINITE_LIFETIME) {
3169 if (state->expire > elapsed)
3170 state->expire -= elapsed;
3171 else
3172 state->expire = 0;
3173 }
3174 confirmed = true;
3175 }
3176
3177 if (ifp->ctx->options & DHCPCD_TEST)
3178 script_runreason(ifp, "TEST");
3179 else {
3180 if (state->state == DH6S_INFORM)
3181 state->state = DH6S_INFORMED;
3182 else
3183 state->state = DH6S_BOUND;
3184 state->failed = false;
3185
3186 if (state->renew && state->renew != ND6_INFINITE_LIFETIME)
3187 eloop_timeout_add_sec(ifp->ctx->eloop,
3188 state->renew,
3189 state->state == DH6S_INFORMED ?
3190 dhcp6_startinform : dhcp6_startrenew, ifp);
3191 if (state->rebind && state->rebind != ND6_INFINITE_LIFETIME)
3192 eloop_timeout_add_sec(ifp->ctx->eloop,
3193 state->rebind, dhcp6_startrebind, ifp);
3194 if (state->expire != ND6_INFINITE_LIFETIME)
3195 eloop_timeout_add_sec(ifp->ctx->eloop,
3196 state->expire, dhcp6_startexpire, ifp);
3197
3198 ipv6_addaddrs(&state->addrs);
3199 if (!timedout)
3200 dhcp6_deprecateaddrs(&state->addrs);
3201
3202 if (state->state == DH6S_INFORMED)
3203 logmessage(loglevel, "%s: refresh in %"PRIu32" seconds",
3204 ifp->name, state->renew);
3205 else if (state->renew == ND6_INFINITE_LIFETIME)
3206 logmessage(loglevel, "%s: leased for infinity",
3207 ifp->name);
3208 else if (state->renew || state->rebind)
3209 logmessage(loglevel, "%s: renew in %"PRIu32", "
3210 "rebind in %"PRIu32", "
3211 "expire in %"PRIu32" seconds",
3212 ifp->name,
3213 state->renew, state->rebind, state->expire);
3214 else if (state->expire == 0)
3215 logmessage(loglevel, "%s: will expire", ifp->name);
3216 else
3217 logmessage(loglevel, "%s: expire in %"PRIu32" seconds",
3218 ifp->name, state->expire);
3219 rt_build(ifp->ctx, AF_INET6);
3220 if (!confirmed && !timedout) {
3221 logdebugx("%s: writing lease: %s",
3222 ifp->name, state->leasefile);
3223 if (dhcp_writefile(ifp->ctx, state->leasefile, 0640,
3224 state->new, state->new_len) == -1)
3225 logerr("dhcp_writefile: %s",state->leasefile);
3226 }
3227 #ifndef SMALL
3228 dhcp6_delegate_prefix(ifp);
3229 #endif
3230 dhcp6_script_try_run(ifp, 0);
3231 }
3232
3233 if (ifp->ctx->options & DHCPCD_TEST ||
3234 (ifp->options->options & DHCPCD_INFORM &&
3235 !(ifp->ctx->options & DHCPCD_MASTER)))
3236 {
3237 eloop_exit(ifp->ctx->eloop, EXIT_SUCCESS);
3238 }
3239 }
3240
3241 static void
3242 dhcp6_recvif(struct interface *ifp, const char *sfrom,
3243 struct dhcp6_message *r, size_t len)
3244 {
3245 struct dhcpcd_ctx *ctx;
3246 size_t i;
3247 const char *op;
3248 struct dhcp6_state *state;
3249 uint8_t *o;
3250 uint16_t ol;
3251 const struct dhcp_opt *opt;
3252 const struct if_options *ifo;
3253 bool valid_op;
3254 #ifdef AUTH
3255 uint8_t *auth;
3256 uint16_t auth_len;
3257 #endif
3258
3259 ctx = ifp->ctx;
3260 state = D6_STATE(ifp);
3261 if (state == NULL || state->send == NULL) {
3262 logdebugx("%s: DHCPv6 reply received but not running",
3263 ifp->name);
3264 return;
3265 }
3266
3267 /* We're already bound and this message is for another machine */
3268 /* XXX DELEGATED? */
3269 if (r->type != DHCP6_RECONFIGURE &&
3270 (state->state == DH6S_BOUND || state->state == DH6S_INFORMED))
3271 {
3272 logdebugx("%s: DHCPv6 reply received but already bound",
3273 ifp->name);
3274 return;
3275 }
3276
3277 if (dhcp6_findmoption(r, len, D6_OPTION_SERVERID, NULL) == NULL) {
3278 logdebugx("%s: no DHCPv6 server ID from %s", ifp->name, sfrom);
3279 return;
3280 }
3281
3282 ifo = ifp->options;
3283 for (i = 0, opt = ctx->dhcp6_opts;
3284 i < ctx->dhcp6_opts_len;
3285 i++, opt++)
3286 {
3287 if (has_option_mask(ifo->requiremask6, opt->option) &&
3288 !dhcp6_findmoption(r, len, (uint16_t)opt->option, NULL))
3289 {
3290 logwarnx("%s: reject DHCPv6 (no option %s) from %s",
3291 ifp->name, opt->var, sfrom);
3292 return;
3293 }
3294 if (has_option_mask(ifo->rejectmask6, opt->option) &&
3295 dhcp6_findmoption(r, len, (uint16_t)opt->option, NULL))
3296 {
3297 logwarnx("%s: reject DHCPv6 (option %s) from %s",
3298 ifp->name, opt->var, sfrom);
3299 return;
3300 }
3301 }
3302
3303 #ifdef AUTH
3304 /* Authenticate the message */
3305 auth = dhcp6_findmoption(r, len, D6_OPTION_AUTH, &auth_len);
3306 if (auth != NULL) {
3307 if (dhcp_auth_validate(&state->auth, &ifo->auth,
3308 (uint8_t *)r, len, 6, r->type, auth, auth_len) == NULL)
3309 {
3310 logerr("%s: authentication failed from %s",
3311 ifp->name, sfrom);
3312 return;
3313 }
3314 if (state->auth.token)
3315 logdebugx("%s: validated using 0x%08" PRIu32,
3316 ifp->name, state->auth.token->secretid);
3317 else
3318 loginfox("%s: accepted reconfigure key", ifp->name);
3319 } else if (ifo->auth.options & DHCPCD_AUTH_SEND) {
3320 if (ifo->auth.options & DHCPCD_AUTH_REQUIRE) {
3321 logerrx("%s: no authentication from %s",
3322 ifp->name, sfrom);
3323 return;
3324 }
3325 logwarnx("%s: no authentication from %s", ifp->name, sfrom);
3326 }
3327 #endif
3328
3329 op = dhcp6_get_op(r->type);
3330 valid_op = op != NULL;
3331 switch(r->type) {
3332 case DHCP6_REPLY:
3333 switch(state->state) {
3334 case DH6S_INFORM:
3335 if (dhcp6_checkstatusok(ifp, r, NULL, len) != 0)
3336 return;
3337 break;
3338 case DH6S_CONFIRM:
3339 if (dhcp6_validatelease(ifp, r, len, sfrom, NULL) == -1)
3340 {
3341 dhcp6_startdiscoinform(ifp);
3342 return;
3343 }
3344 break;
3345 case DH6S_DISCOVER:
3346 /* Only accept REPLY in DISCOVER for RAPID_COMMIT.
3347 * Normally we get an ADVERTISE for a DISCOVER. */
3348 if (!has_option_mask(ifo->requestmask6,
3349 D6_OPTION_RAPID_COMMIT) ||
3350 !dhcp6_findmoption(r, len, D6_OPTION_RAPID_COMMIT,
3351 NULL))
3352 {
3353 valid_op = false;
3354 break;
3355 }
3356 /* Validate lease before setting state to REQUEST. */
3357 /* FALLTHROUGH */
3358 case DH6S_REQUEST: /* FALLTHROUGH */
3359 case DH6S_RENEW: /* FALLTHROUGH */
3360 case DH6S_REBIND:
3361 if (dhcp6_validatelease(ifp, r, len, sfrom, NULL) == -1)
3362 {
3363 /*
3364 * If we can't use the lease, fallback to
3365 * DISCOVER and try and get a new one.
3366 *
3367 * This is needed become some servers
3368 * renumber the prefix or address
3369 * and deny the current one before it expires
3370 * rather than sending it back with a zero
3371 * lifetime along with the new prefix or
3372 * address to use.
3373 * This behavior is wrong, but moving to the
3374 * DISCOVER phase works around it.
3375 *
3376 * The currently held lease is still valid
3377 * until a new one is found.
3378 */
3379 if (state->state != DH6S_DISCOVER)
3380 dhcp6_startdiscoinform(ifp);
3381 return;
3382 }
3383 /* RFC8415 18.2.10.1 */
3384 if ((state->state == DH6S_RENEW ||
3385 state->state == DH6S_REBIND) &&
3386 state->has_no_binding)
3387 {
3388 dhcp6_startrequest(ifp);
3389 return;
3390 }
3391 if (state->state == DH6S_DISCOVER)
3392 state->state = DH6S_REQUEST;
3393 break;
3394 case DH6S_DECLINE:
3395 /* This isnt really a failure, but an
3396 * acknowledgement of one. */
3397 loginfox("%s: %s acknowledged DECLINE6",
3398 ifp->name, sfrom);
3399 dhcp6_fail(ifp);
3400 return;
3401 default:
3402 valid_op = false;
3403 break;
3404 }
3405 break;
3406 case DHCP6_ADVERTISE:
3407 if (state->state != DH6S_DISCOVER) {
3408 valid_op = false;
3409 break;
3410 }
3411 /* RFC7083 */
3412 o = dhcp6_findmoption(r, len, D6_OPTION_SOL_MAX_RT, &ol);
3413 if (o && ol == sizeof(uint32_t)) {
3414 uint32_t max_rt;
3415
3416 memcpy(&max_rt, o, sizeof(max_rt));
3417 max_rt = ntohl(max_rt);
3418 if (max_rt >= 60 && max_rt <= 86400) {
3419 logdebugx("%s: SOL_MAX_RT %llu -> %u",
3420 ifp->name,
3421 (unsigned long long)state->sol_max_rt,
3422 max_rt);
3423 state->sol_max_rt = max_rt;
3424 } else
3425 logerr("%s: invalid SOL_MAX_RT %u",
3426 ifp->name, max_rt);
3427 }
3428 o = dhcp6_findmoption(r, len, D6_OPTION_INF_MAX_RT, &ol);
3429 if (o && ol == sizeof(uint32_t)) {
3430 uint32_t max_rt;
3431
3432 memcpy(&max_rt, o, sizeof(max_rt));
3433 max_rt = ntohl(max_rt);
3434 if (max_rt >= 60 && max_rt <= 86400) {
3435 logdebugx("%s: INF_MAX_RT %llu -> %u",
3436 ifp->name,
3437 (unsigned long long)state->inf_max_rt,
3438 max_rt);
3439 state->inf_max_rt = max_rt;
3440 } else
3441 logerrx("%s: invalid INF_MAX_RT %u",
3442 ifp->name, max_rt);
3443 }
3444 if (dhcp6_validatelease(ifp, r, len, sfrom, NULL) == -1)
3445 return;
3446 break;
3447 case DHCP6_RECONFIGURE:
3448 #ifdef AUTH
3449 if (auth == NULL) {
3450 #endif
3451 logerrx("%s: unauthenticated %s from %s",
3452 ifp->name, op, sfrom);
3453 if (ifo->auth.options & DHCPCD_AUTH_REQUIRE)
3454 return;
3455 #ifdef AUTH
3456 }
3457 loginfox("%s: %s from %s", ifp->name, op, sfrom);
3458 o = dhcp6_findmoption(r, len, D6_OPTION_RECONF_MSG, &ol);
3459 if (o == NULL) {
3460 logerrx("%s: missing Reconfigure Message option",
3461 ifp->name);
3462 return;
3463 }
3464 if (ol != 1) {
3465 logerrx("%s: missing Reconfigure Message type",
3466 ifp->name);
3467 return;
3468 }
3469 switch(*o) {
3470 case DHCP6_RENEW:
3471 if (state->state != DH6S_BOUND) {
3472 logerrx("%s: not bound, ignoring %s",
3473 ifp->name, op);
3474 return;
3475 }
3476 dhcp6_startrenew(ifp);
3477 break;
3478 case DHCP6_INFORMATION_REQ:
3479 if (state->state != DH6S_INFORMED) {
3480 logerrx("%s: not informed, ignoring %s",
3481 ifp->name, op);
3482 return;
3483 }
3484 eloop_timeout_delete(ifp->ctx->eloop,
3485 dhcp6_sendinform, ifp);
3486 dhcp6_startinform(ifp);
3487 break;
3488 default:
3489 logerr("%s: unsupported %s type %d",
3490 ifp->name, op, *o);
3491 break;
3492 }
3493 return;
3494 #else
3495 break;
3496 #endif
3497 default:
3498 logerrx("%s: invalid DHCP6 type %s (%d)",
3499 ifp->name, op, r->type);
3500 return;
3501 }
3502 if (!valid_op) {
3503 logwarnx("%s: invalid state for DHCP6 type %s (%d)",
3504 ifp->name, op, r->type);
3505 return;
3506 }
3507
3508 if (state->recv_len < (size_t)len) {
3509 free(state->recv);
3510 state->recv = malloc(len);
3511 if (state->recv == NULL) {
3512 logerr(__func__);
3513 return;
3514 }
3515 }
3516 memcpy(state->recv, r, len);
3517 state->recv_len = len;
3518
3519 if (r->type == DHCP6_ADVERTISE) {
3520 struct ipv6_addr *ia;
3521
3522 if (state->state == DH6S_REQUEST) /* rapid commit */
3523 goto bind;
3524 TAILQ_FOREACH(ia, &state->addrs, next) {
3525 if (!(ia->flags & (IPV6_AF_STALE | IPV6_AF_REQUEST)))
3526 break;
3527 }
3528 if (ia == NULL)
3529 ia = TAILQ_FIRST(&state->addrs);
3530 if (ia == NULL)
3531 loginfox("%s: ADV (no address) from %s",
3532 ifp->name, sfrom);
3533 else
3534 loginfox("%s: ADV %s from %s",
3535 ifp->name, ia->saddr, sfrom);
3536 dhcp6_startrequest(ifp);
3537 return;
3538 }
3539
3540 bind:
3541 dhcp6_bind(ifp, op, sfrom);
3542 }
3543
3544 void
3545 dhcp6_recvmsg(struct dhcpcd_ctx *ctx, struct msghdr *msg, struct ipv6_addr *ia)
3546 {
3547 struct sockaddr_in6 *from = msg->msg_name;
3548 size_t len = msg->msg_iov[0].iov_len;
3549 char sfrom[INET6_ADDRSTRLEN];
3550 struct interface *ifp;
3551 struct dhcp6_message *r;
3552 const struct dhcp6_state *state;
3553 uint8_t *o;
3554 uint16_t ol;
3555
3556 inet_ntop(AF_INET6, &from->sin6_addr, sfrom, sizeof(sfrom));
3557 if (len < sizeof(struct dhcp6_message)) {
3558 logerrx("DHCPv6 packet too short from %s", sfrom);
3559 return;
3560 }
3561
3562 if (ia != NULL)
3563 ifp = ia->iface;
3564 else {
3565 ifp = if_findifpfromcmsg(ctx, msg, NULL);
3566 if (ifp == NULL) {
3567 logerr(__func__);
3568 return;
3569 }
3570 }
3571
3572 r = (struct dhcp6_message *)msg->msg_iov[0].iov_base;
3573
3574 uint8_t duid[DUID_LEN], *dp;
3575 size_t duid_len;
3576 o = dhcp6_findmoption(r, len, D6_OPTION_CLIENTID, &ol);
3577 if (ifp->options->options & DHCPCD_ANONYMOUS) {
3578 duid_len = duid_make(duid, ifp, DUID_LL);
3579 dp = duid;
3580 } else {
3581 duid_len = ctx->duid_len;
3582 dp = ctx->duid;
3583 }
3584 if (o == NULL || ol != duid_len || memcmp(o, dp, ol) != 0) {
3585 logdebugx("%s: incorrect client ID from %s",
3586 ifp->name, sfrom);
3587 return;
3588 }
3589
3590 if (dhcp6_findmoption(r, len, D6_OPTION_SERVERID, NULL) == NULL) {
3591 logdebugx("%s: no DHCPv6 server ID from %s",
3592 ifp->name, sfrom);
3593 return;
3594 }
3595
3596 if (r->type == DHCP6_RECONFIGURE) {
3597 if (!IN6_IS_ADDR_LINKLOCAL(&from->sin6_addr)) {
3598 logerrx("%s: RECONFIGURE6 recv from %s, not LL",
3599 ifp->name, sfrom);
3600 return;
3601 }
3602 goto recvif;
3603 }
3604
3605 state = D6_CSTATE(ifp);
3606 if (state == NULL ||
3607 r->xid[0] != state->send->xid[0] ||
3608 r->xid[1] != state->send->xid[1] ||
3609 r->xid[2] != state->send->xid[2])
3610 {
3611 struct interface *ifp1;
3612 const struct dhcp6_state *state1;
3613
3614 /* Find an interface with a matching xid. */
3615 TAILQ_FOREACH(ifp1, ctx->ifaces, next) {
3616 state1 = D6_CSTATE(ifp1);
3617 if (state1 == NULL || state1->send == NULL)
3618 continue;
3619 if (r->xid[0] == state1->send->xid[0] &&
3620 r->xid[1] == state1->send->xid[1] &&
3621 r->xid[2] == state1->send->xid[2])
3622 break;
3623 }
3624
3625 if (ifp1 == NULL) {
3626 if (state != NULL)
3627 logdebugx("%s: wrong xid 0x%02x%02x%02x"
3628 " (expecting 0x%02x%02x%02x) from %s",
3629 ifp->name,
3630 r->xid[0], r->xid[1], r->xid[2],
3631 state->send->xid[0],
3632 state->send->xid[1],
3633 state->send->xid[2],
3634 sfrom);
3635 return;
3636 }
3637 logdebugx("%s: redirecting DHCP6 message to %s",
3638 ifp->name, ifp1->name);
3639 ifp = ifp1;
3640 }
3641
3642 #if 0
3643 /*
3644 * Handy code to inject raw DHCPv6 packets over responses
3645 * from our server.
3646 * This allows me to take a 3rd party wireshark trace and
3647 * replay it in my code.
3648 */
3649 static int replyn = 0;
3650 char fname[PATH_MAX], tbuf[UDPLEN_MAX];
3651 int fd;
3652 ssize_t tlen;
3653 uint8_t *si1, *si2;
3654 uint16_t si_len1, si_len2;
3655
3656 snprintf(fname, sizeof(fname),
3657 "/tmp/dhcp6.reply%d.raw", replyn++);
3658 fd = open(fname, O_RDONLY, 0);
3659 if (fd == -1) {
3660 logerr("%s: open: %s", __func__, fname);
3661 return;
3662 }
3663 tlen = read(fd, tbuf, sizeof(tbuf));
3664 if (tlen == -1)
3665 logerr("%s: read: %s", __func__, fname);
3666 close(fd);
3667
3668 /* Copy across ServerID so we can work with our own server. */
3669 si1 = dhcp6_findmoption(r, len, D6_OPTION_SERVERID, &si_len1);
3670 si2 = dhcp6_findmoption(tbuf, (size_t)tlen,
3671 D6_OPTION_SERVERID, &si_len2);
3672 if (si1 != NULL && si2 != NULL && si_len1 == si_len2)
3673 memcpy(si2, si1, si_len2);
3674 r = (struct dhcp6_message *)tbuf;
3675 len = (size_t)tlen;
3676 #endif
3677
3678 recvif:
3679 dhcp6_recvif(ifp, sfrom, r, len);
3680 }
3681
3682 static void
3683 dhcp6_recv(struct dhcpcd_ctx *ctx, struct ipv6_addr *ia)
3684 {
3685 struct sockaddr_in6 from;
3686 union {
3687 struct dhcp6_message dhcp6;
3688 uint8_t buf[UDPLEN_MAX]; /* Maximum UDP message size */
3689 } iovbuf;
3690 struct iovec iov = {
3691 .iov_base = iovbuf.buf, .iov_len = sizeof(iovbuf.buf),
3692 };
3693 union {
3694 struct cmsghdr hdr;
3695 uint8_t buf[CMSG_SPACE(sizeof(struct in6_pktinfo))];
3696 } cmsgbuf = { .buf = { 0 } };
3697 struct msghdr msg = {
3698 .msg_name = &from, .msg_namelen = sizeof(from),
3699 .msg_iov = &iov, .msg_iovlen = 1,
3700 .msg_control = cmsgbuf.buf, .msg_controllen = sizeof(cmsgbuf.buf),
3701 };
3702 int s;
3703 ssize_t bytes;
3704
3705 s = ia != NULL ? ia->dhcp6_fd : ctx->dhcp6_rfd;
3706 bytes = recvmsg(s, &msg, 0);
3707 if (bytes == -1) {
3708 logerr(__func__);
3709 return;
3710 }
3711
3712 iov.iov_len = (size_t)bytes;
3713 dhcp6_recvmsg(ctx, &msg, ia);
3714 }
3715
3716 static void
3717 dhcp6_recvaddr(void *arg)
3718 {
3719 struct ipv6_addr *ia = arg;
3720
3721 dhcp6_recv(ia->iface->ctx, ia);
3722 }
3723
3724 static void
3725 dhcp6_recvctx(void *arg)
3726 {
3727 struct dhcpcd_ctx *ctx = arg;
3728
3729 dhcp6_recv(ctx, NULL);
3730 }
3731
3732 int
3733 dhcp6_openraw(void)
3734 {
3735 int fd, v;
3736
3737 fd = socket(PF_INET6, SOCK_RAW | SOCK_CXNB, IPPROTO_UDP);
3738 if (fd == -1)
3739 return -1;
3740
3741 v = 1;
3742 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &v, sizeof(v)) == -1)
3743 goto errexit;
3744
3745 v = offsetof(struct udphdr, uh_sum);
3746 if (setsockopt(fd, IPPROTO_IPV6, IPV6_CHECKSUM, &v, sizeof(v)) == -1)
3747 goto errexit;
3748
3749 return fd;
3750
3751 errexit:
3752 close(fd);
3753 return -1;
3754 }
3755
3756 int
3757 dhcp6_openudp(unsigned int ifindex, struct in6_addr *ia)
3758 {
3759 struct sockaddr_in6 sa;
3760 int n, s;
3761
3762 s = xsocket(PF_INET6, SOCK_DGRAM | SOCK_CXNB, IPPROTO_UDP);
3763 if (s == -1)
3764 goto errexit;
3765
3766 memset(&sa, 0, sizeof(sa));
3767 sa.sin6_family = AF_INET6;
3768 sa.sin6_port = htons(DHCP6_CLIENT_PORT);
3769 #ifdef BSD
3770 sa.sin6_len = sizeof(sa);
3771 #endif
3772
3773 if (ia != NULL) {
3774 memcpy(&sa.sin6_addr, ia, sizeof(sa.sin6_addr));
3775 ipv6_setscope(&sa, ifindex);
3776 }
3777
3778 if (bind(s, (struct sockaddr *)&sa, sizeof(sa)) == -1)
3779 goto errexit;
3780
3781 n = 1;
3782 if (setsockopt(s, IPPROTO_IPV6, IPV6_RECVPKTINFO, &n, sizeof(n)) == -1)
3783 goto errexit;
3784
3785 #ifdef SO_RERROR
3786 n = 1;
3787 if (setsockopt(s, SOL_SOCKET, SO_RERROR, &n, sizeof(n)) == -1)
3788 goto errexit;
3789 #endif
3790
3791 return s;
3792
3793 errexit:
3794 logerr(__func__);
3795 if (s != -1)
3796 close(s);
3797 return -1;
3798 }
3799
3800 #ifndef SMALL
3801 static void
3802 dhcp6_activateinterfaces(struct interface *ifp)
3803 {
3804 struct interface *ifd;
3805 size_t i, j;
3806 struct if_ia *ia;
3807 struct if_sla *sla;
3808
3809 for (i = 0; i < ifp->options->ia_len; i++) {
3810 ia = &ifp->options->ia[i];
3811 if (ia->ia_type != D6_OPTION_IA_PD)
3812 continue;
3813 for (j = 0; j < ia->sla_len; j++) {
3814 sla = &ia->sla[j];
3815 ifd = if_find(ifp->ctx->ifaces, sla->ifname);
3816 if (ifd == NULL) {
3817 logwarn("%s: cannot delegate to %s",
3818 ifp->name, sla->ifname);
3819 continue;
3820 }
3821 if (!ifd->active) {
3822 loginfox("%s: activating for delegation",
3823 sla->ifname);
3824 dhcpcd_activateinterface(ifd,
3825 DHCPCD_IPV6 | DHCPCD_DHCP6);
3826 }
3827 }
3828 }
3829 }
3830 #endif
3831
3832 static void
3833 dhcp6_start1(void *arg)
3834 {
3835 struct interface *ifp = arg;
3836 struct dhcpcd_ctx *ctx = ifp->ctx;
3837 struct if_options *ifo = ifp->options;
3838 struct dhcp6_state *state;
3839 size_t i;
3840 const struct dhcp_compat *dhc;
3841
3842 if ((ctx->options & (DHCPCD_MASTER|DHCPCD_PRIVSEP)) == DHCPCD_MASTER &&
3843 ctx->dhcp6_rfd == -1)
3844 {
3845 ctx->dhcp6_rfd = dhcp6_openudp(0, NULL);
3846 if (ctx->dhcp6_rfd == -1) {
3847 logerr(__func__);
3848 return;
3849 }
3850 eloop_event_add(ctx->eloop, ctx->dhcp6_rfd, dhcp6_recvctx, ctx);
3851 }
3852
3853 if (!IN_PRIVSEP(ctx) && ctx->dhcp6_wfd == -1) {
3854 ctx->dhcp6_wfd = dhcp6_openraw();
3855 if (ctx->dhcp6_wfd == -1) {
3856 logerr(__func__);
3857 return;
3858 }
3859 }
3860
3861 state = D6_STATE(ifp);
3862 /* If no DHCPv6 options are configured,
3863 match configured DHCPv4 options to DHCPv6 equivalents. */
3864 for (i = 0; i < sizeof(ifo->requestmask6); i++) {
3865 if (ifo->requestmask6[i] != '\0')
3866 break;
3867 }
3868 if (i == sizeof(ifo->requestmask6)) {
3869 for (dhc = dhcp_compats; dhc->dhcp_opt; dhc++) {
3870 if (DHC_REQ(ifo->requestmask, ifo->nomask, dhc->dhcp_opt))
3871 add_option_mask(ifo->requestmask6,
3872 dhc->dhcp6_opt);
3873 }
3874 if (ifo->fqdn != FQDN_DISABLE || ifo->options & DHCPCD_HOSTNAME)
3875 add_option_mask(ifo->requestmask6, D6_OPTION_FQDN);
3876 }
3877
3878 #ifndef SMALL
3879 /* Rapid commit won't work with Prefix Delegation Exclusion */
3880 if (dhcp6_findselfsla(ifp))
3881 del_option_mask(ifo->requestmask6, D6_OPTION_RAPID_COMMIT);
3882 #endif
3883
3884 if (state->state == DH6S_INFORM) {
3885 add_option_mask(ifo->requestmask6, D6_OPTION_INFO_REFRESH_TIME);
3886 dhcp6_startinform(ifp);
3887 } else {
3888 del_option_mask(ifo->requestmask6, D6_OPTION_INFO_REFRESH_TIME);
3889 dhcp6_startinit(ifp);
3890 }
3891
3892 #ifndef SMALL
3893 dhcp6_activateinterfaces(ifp);
3894 #endif
3895 }
3896
3897 int
3898 dhcp6_start(struct interface *ifp, enum DH6S init_state)
3899 {
3900 struct dhcp6_state *state;
3901
3902 state = D6_STATE(ifp);
3903 if (state != NULL) {
3904 switch (init_state) {
3905 case DH6S_INIT:
3906 goto gogogo;
3907 case DH6S_INFORM:
3908 if (state->state == DH6S_INIT ||
3909 state->state == DH6S_INFORMED ||
3910 (state->state == DH6S_DISCOVER &&
3911 !(ifp->options->options & DHCPCD_IA_FORCED) &&
3912 !ipv6nd_hasradhcp(ifp, true)))
3913 dhcp6_startinform(ifp);
3914 break;
3915 case DH6S_REQUEST:
3916 if (ifp->options->options & DHCPCD_DHCP6 &&
3917 (state->state == DH6S_INIT ||
3918 state->state == DH6S_INFORM ||
3919 state->state == DH6S_INFORMED ||
3920 state->state == DH6S_DELEGATED))
3921 {
3922 /* Change from stateless to stateful */
3923 init_state = DH6S_INIT;
3924 goto gogogo;
3925 }
3926 break;
3927 case DH6S_CONFIRM:
3928 init_state = DH6S_INIT;
3929 goto gogogo;
3930 default:
3931 /* Not possible, but sushes some compiler warnings. */
3932 break;
3933 }
3934 return 0;
3935 } else {
3936 switch (init_state) {
3937 case DH6S_CONFIRM:
3938 /* No DHCPv6 config, no existing state
3939 * so nothing to do. */
3940 return 0;
3941 case DH6S_INFORM:
3942 break;
3943 default:
3944 init_state = DH6S_INIT;
3945 break;
3946 }
3947 }
3948
3949 if (!(ifp->options->options & DHCPCD_DHCP6))
3950 return 0;
3951
3952 ifp->if_data[IF_DATA_DHCP6] = calloc(1, sizeof(*state));
3953 state = D6_STATE(ifp);
3954 if (state == NULL)
3955 return -1;
3956
3957 state->sol_max_rt = SOL_MAX_RT;
3958 state->inf_max_rt = INF_MAX_RT;
3959 TAILQ_INIT(&state->addrs);
3960
3961 gogogo:
3962 state->state = init_state;
3963 state->lerror = 0;
3964 state->failed = false;
3965 dhcp_set_leasefile(state->leasefile, sizeof(state->leasefile),
3966 AF_INET6, ifp);
3967 if (ipv6_linklocal(ifp) == NULL) {
3968 logdebugx("%s: delaying DHCPv6 for LL address", ifp->name);
3969 ipv6_addlinklocalcallback(ifp, dhcp6_start1, ifp);
3970 return 0;
3971 }
3972
3973 dhcp6_start1(ifp);
3974 return 0;
3975 }
3976
3977 void
3978 dhcp6_reboot(struct interface *ifp)
3979 {
3980 struct dhcp6_state *state;
3981
3982 state = D6_STATE(ifp);
3983 if (state == NULL)
3984 return;
3985
3986 state->lerror = 0;
3987 switch (state->state) {
3988 case DH6S_BOUND:
3989 dhcp6_startrebind(ifp);
3990 break;
3991 default:
3992 dhcp6_startdiscoinform(ifp);
3993 break;
3994 }
3995 }
3996
3997 static void
3998 dhcp6_freedrop(struct interface *ifp, int drop, const char *reason)
3999 {
4000 struct dhcp6_state *state;
4001 struct dhcpcd_ctx *ctx;
4002 unsigned long long options;
4003
4004 if (ifp->options)
4005 options = ifp->options->options;
4006 else
4007 options = ifp->ctx->options;
4008
4009 if (ifp->ctx->eloop)
4010 eloop_timeout_delete(ifp->ctx->eloop, NULL, ifp);
4011
4012 #ifndef SMALL
4013 /* If we're dropping the lease, drop delegated addresses.
4014 * If, for whatever reason, we don't drop them in the future
4015 * then they should at least be marked as deprecated (pltime 0). */
4016 if (drop && (options & DHCPCD_NODROP) != DHCPCD_NODROP)
4017 dhcp6_delete_delegates(ifp);
4018 #endif
4019
4020 state = D6_STATE(ifp);
4021 if (state) {
4022 /* Failure to send the release may cause this function to
4023 * re-enter */
4024 if (state->state == DH6S_RELEASE) {
4025 dhcp6_finishrelease(ifp);
4026 return;
4027 }
4028
4029 if (drop && options & DHCPCD_RELEASE &&
4030 state->state != DH6S_DELEGATED)
4031 {
4032 if (ifp->carrier == LINK_UP &&
4033 state->state != DH6S_RELEASED &&
4034 state->state != DH6S_INFORMED)
4035 {
4036 dhcp6_startrelease(ifp);
4037 return;
4038 }
4039 dhcp_unlink(ifp->ctx, state->leasefile);
4040 }
4041 #ifdef AUTH
4042 else if (state->auth.reconf != NULL) {
4043 /*
4044 * Drop the lease as the token may only be present
4045 * in the initial reply message and not subsequent
4046 * renewals.
4047 * If dhcpcd is restarted, the token is lost.
4048 * XXX persist this in another file?
4049 */
4050 dhcp_unlink(ifp->ctx, state->leasefile);
4051 }
4052 #endif
4053
4054 dhcp6_freedrop_addrs(ifp, drop, NULL);
4055 free(state->old);
4056 state->old = state->new;
4057 state->old_len = state->new_len;
4058 state->new = NULL;
4059 state->new_len = 0;
4060 if (drop && state->old &&
4061 (options & DHCPCD_NODROP) != DHCPCD_NODROP)
4062 {
4063 if (reason == NULL)
4064 reason = "STOP6";
4065 script_runreason(ifp, reason);
4066 }
4067 free(state->old);
4068 free(state->send);
4069 free(state->recv);
4070 free(state);
4071 ifp->if_data[IF_DATA_DHCP6] = NULL;
4072 }
4073
4074 /* If we don't have any more DHCP6 enabled interfaces,
4075 * close the global socket and release resources */
4076 ctx = ifp->ctx;
4077 if (ctx->ifaces) {
4078 TAILQ_FOREACH(ifp, ctx->ifaces, next) {
4079 if (D6_STATE(ifp))
4080 break;
4081 }
4082 }
4083 if (ifp == NULL && ctx->dhcp6_rfd != -1) {
4084 eloop_event_delete(ctx->eloop, ctx->dhcp6_rfd);
4085 close(ctx->dhcp6_rfd);
4086 ctx->dhcp6_rfd = -1;
4087 }
4088 }
4089
4090 void
4091 dhcp6_drop(struct interface *ifp, const char *reason)
4092 {
4093
4094 dhcp6_freedrop(ifp, 1, reason);
4095 }
4096
4097 void
4098 dhcp6_free(struct interface *ifp)
4099 {
4100
4101 dhcp6_freedrop(ifp, 0, NULL);
4102 }
4103
4104 void
4105 dhcp6_abort(struct interface *ifp)
4106 {
4107 struct dhcp6_state *state;
4108 #ifdef ND6_ADVERTISE
4109 struct ipv6_addr *ia;
4110 #endif
4111
4112 eloop_timeout_delete(ifp->ctx->eloop, dhcp6_start1, ifp);
4113 state = D6_STATE(ifp);
4114 if (state == NULL)
4115 return;
4116
4117 #ifdef ND6_ADVERTISE
4118 TAILQ_FOREACH(ia, &state->addrs, next) {
4119 ipv6nd_advertise(ia);
4120 }
4121 #endif
4122
4123 eloop_timeout_delete(ifp->ctx->eloop, dhcp6_startdiscover, ifp);
4124 eloop_timeout_delete(ifp->ctx->eloop, dhcp6_senddiscover, ifp);
4125 eloop_timeout_delete(ifp->ctx->eloop, dhcp6_startinform, ifp);
4126 eloop_timeout_delete(ifp->ctx->eloop, dhcp6_sendinform, ifp);
4127
4128 switch (state->state) {
4129 case DH6S_DISCOVER: /* FALLTHROUGH */
4130 case DH6S_REQUEST: /* FALLTHROUGH */
4131 case DH6S_INFORM:
4132 state->state = DH6S_INIT;
4133 break;
4134 default:
4135 break;
4136 }
4137 }
4138
4139 void
4140 dhcp6_handleifa(int cmd, struct ipv6_addr *ia, pid_t pid)
4141 {
4142 struct dhcp6_state *state;
4143 struct interface *ifp = ia->iface;
4144
4145 /* If not running in master mode, listen to this address */
4146 if (cmd == RTM_NEWADDR &&
4147 !(ia->addr_flags & IN6_IFF_NOTUSEABLE) &&
4148 ifp->active == IF_ACTIVE_USER &&
4149 !(ifp->ctx->options & DHCPCD_MASTER) &&
4150 ifp->options->options & DHCPCD_DHCP6)
4151 {
4152 #ifdef PRIVSEP
4153 if (IN_PRIVSEP_SE(ifp->ctx)) {
4154 if (ps_inet_opendhcp6(ia) == -1)
4155 logerr(__func__);
4156 } else
4157 #endif
4158 {
4159 if (ia->dhcp6_fd == -1)
4160 ia->dhcp6_fd = dhcp6_openudp(ia->iface->index,
4161 &ia->addr);
4162 if (ia->dhcp6_fd != -1)
4163 eloop_event_add(ia->iface->ctx->eloop,
4164 ia->dhcp6_fd, dhcp6_recvaddr, ia);
4165 }
4166 }
4167
4168
4169 if ((state = D6_STATE(ifp)) != NULL)
4170 ipv6_handleifa_addrs(cmd, &state->addrs, ia, pid);
4171 }
4172
4173 ssize_t
4174 dhcp6_env(FILE *fp, const char *prefix, const struct interface *ifp,
4175 const struct dhcp6_message *m, size_t len)
4176 {
4177 const struct if_options *ifo;
4178 struct dhcp_opt *opt, *vo;
4179 const uint8_t *p;
4180 struct dhcp6_option o;
4181 size_t i;
4182 char *pfx;
4183 uint32_t en;
4184 const struct dhcpcd_ctx *ctx;
4185 #ifndef SMALL
4186 const struct dhcp6_state *state;
4187 const struct ipv6_addr *ap;
4188 #endif
4189
4190 if (m == NULL)
4191 goto delegated;
4192
4193 if (len < sizeof(*m)) {
4194 /* Should be impossible with guards at packet in
4195 * and reading leases */
4196 errno = EINVAL;
4197 return -1;
4198 }
4199
4200 ifo = ifp->options;
4201 ctx = ifp->ctx;
4202
4203 /* Zero our indexes */
4204 for (i = 0, opt = ctx->dhcp6_opts;
4205 i < ctx->dhcp6_opts_len;
4206 i++, opt++)
4207 dhcp_zero_index(opt);
4208 for (i = 0, opt = ifp->options->dhcp6_override;
4209 i < ifp->options->dhcp6_override_len;
4210 i++, opt++)
4211 dhcp_zero_index(opt);
4212 for (i = 0, opt = ctx->vivso;
4213 i < ctx->vivso_len;
4214 i++, opt++)
4215 dhcp_zero_index(opt);
4216 if (asprintf(&pfx, "%s_dhcp6", prefix) == -1)
4217 return -1;
4218
4219 /* Unlike DHCP, DHCPv6 options *may* occur more than once.
4220 * There is also no provision for option concatenation unlike DHCP. */
4221 p = (const uint8_t *)m + sizeof(*m);
4222 len -= sizeof(*m);
4223 for (; len != 0; p += o.len, len -= o.len) {
4224 if (len < sizeof(o)) {
4225 errno = EINVAL;
4226 break;
4227 }
4228 memcpy(&o, p, sizeof(o));
4229 p += sizeof(o);
4230 len -= sizeof(o);
4231 o.len = ntohs(o.len);
4232 if (len < o.len) {
4233 errno = EINVAL;
4234 break;
4235 }
4236 o.code = ntohs(o.code);
4237 if (has_option_mask(ifo->nomask6, o.code))
4238 continue;
4239 for (i = 0, opt = ifo->dhcp6_override;
4240 i < ifo->dhcp6_override_len;
4241 i++, opt++)
4242 if (opt->option == o.code)
4243 break;
4244 if (i == ifo->dhcp6_override_len &&
4245 o.code == D6_OPTION_VENDOR_OPTS &&
4246 o.len > sizeof(en))
4247 {
4248 memcpy(&en, p, sizeof(en));
4249 en = ntohl(en);
4250 vo = vivso_find(en, ifp);
4251 } else
4252 vo = NULL;
4253 if (i == ifo->dhcp6_override_len) {
4254 for (i = 0, opt = ctx->dhcp6_opts;
4255 i < ctx->dhcp6_opts_len;
4256 i++, opt++)
4257 if (opt->option == o.code)
4258 break;
4259 if (i == ctx->dhcp6_opts_len)
4260 opt = NULL;
4261 }
4262 if (opt) {
4263 dhcp_envoption(ifp->ctx,
4264 fp, pfx, ifp->name,
4265 opt, dhcp6_getoption, p, o.len);
4266 }
4267 if (vo) {
4268 dhcp_envoption(ifp->ctx,
4269 fp, pfx, ifp->name,
4270 vo, dhcp6_getoption,
4271 p + sizeof(en),
4272 o.len - sizeof(en));
4273 }
4274 }
4275 free(pfx);
4276
4277 delegated:
4278 #ifndef SMALL
4279 /* Needed for Delegated Prefixes */
4280 state = D6_CSTATE(ifp);
4281 TAILQ_FOREACH(ap, &state->addrs, next) {
4282 if (ap->delegating_prefix)
4283 break;
4284 }
4285 if (ap == NULL)
4286 return 1;
4287 if (fprintf(fp, "%s_delegated_dhcp6_prefix=", prefix) == -1)
4288 return -1;
4289 TAILQ_FOREACH(ap, &state->addrs, next) {
4290 if (ap->delegating_prefix == NULL)
4291 continue;
4292 if (ap != TAILQ_FIRST(&state->addrs)) {
4293 if (fputc(' ', fp) == EOF)
4294 return -1;
4295 }
4296 if (fprintf(fp, "%s", ap->saddr) == -1)
4297 return -1;
4298 }
4299 if (fputc('\0', fp) == EOF)
4300 return -1;
4301 #endif
4302
4303 return 1;
4304 }
4305 #endif
4306
4307 #ifndef SMALL
4308 int
4309 dhcp6_dump(struct interface *ifp)
4310 {
4311 struct dhcp6_state *state;
4312
4313 ifp->if_data[IF_DATA_DHCP6] = state = calloc(1, sizeof(*state));
4314 if (state == NULL) {
4315 logerr(__func__);
4316 return -1;
4317 }
4318 TAILQ_INIT(&state->addrs);
4319 if (dhcp6_readlease(ifp, 0) == -1) {
4320 logerr("dhcp6_readlease");
4321 return -1;
4322 }
4323 state->reason = "DUMP6";
4324 return script_runreason(ifp, state->reason);
4325 }
4326 #endif
DragonFly BSD