diff options
Diffstat (limited to 'dhcpcd/dhcp6.c')
-rw-r--r-- | dhcpcd/dhcp6.c | 2811 |
1 files changed, 2811 insertions, 0 deletions
diff --git a/dhcpcd/dhcp6.c b/dhcpcd/dhcp6.c new file mode 100644 index 00000000..ec585883 --- /dev/null +++ b/dhcpcd/dhcp6.c @@ -0,0 +1,2811 @@ +/* + * dhcpcd - DHCP client daemon + * Copyright (c) 2006-2014 Roy Marples <roy@marples.name> + * All rights reserved + + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* TODO: We should decline dupliate addresses detected */ + +#include <sys/stat.h> +#include <sys/utsname.h> + +#include <netinet/in.h> +#ifdef __linux__ +# define _LINUX_IN6_H +# include <linux/ipv6.h> +#endif + +#include <ctype.h> +#include <errno.h> +#include <fcntl.h> +#include <inttypes.h> +#include <stdlib.h> +#include <string.h> +#include <syslog.h> +#include <unistd.h> + +#define ELOOP_QUEUE 3 + +#include "config.h" +#include "common.h" +#include "dhcp.h" +#include "dhcp6.h" +#include "duid.h" +#include "eloop.h" +#include "ipv6nd.h" +#include "platform.h" +#include "script.h" + +#ifndef __UNCONST +#define __UNCONST(a) ((void *)(unsigned long)(const void *)(a)) +#endif + +/* DHCPCD Project has been assigned an IANA PEN of 40712 */ +#define DHCPCD_IANA_PEN 40712 + +/* Unsure if I want this */ +//#define VENDOR_SPLIT + +static int sock = -1; +static const struct in6_addr in6addr_linklocal_alldhcp = + IN6ADDR_LINKLOCAL_ALLDHCP_INIT; +static struct sockaddr_in6 from; +static struct msghdr sndhdr; +static struct iovec sndiov[2]; +static unsigned char *sndbuf; +static struct msghdr rcvhdr; +static struct iovec rcviov[2]; +static unsigned char *rcvbuf; +static unsigned char ansbuf[1500]; +static char ntopbuf[INET6_ADDRSTRLEN]; +static char *status; +static size_t status_len; + +struct dhcp6_op { + uint16_t type; + const char *name; +}; + +static const struct dhcp6_op dhcp6_ops[] = { + { DHCP6_SOLICIT, "SOLICIT6" }, + { DHCP6_ADVERTISE, "ADVERTISE6" }, + { DHCP6_REQUEST, "REQUEST6" }, + { DHCP6_REPLY, "REPLY6" }, + { DHCP6_RENEW, "RENEW6" }, + { DHCP6_REBIND, "REBIND6" }, + { DHCP6_CONFIRM, "CONFIRM6" }, + { DHCP6_INFORMATION_REQ, "INFORM6" }, + { DHCP6_RELEASE, "RELEASE6" }, + { 0, NULL } +}; + +struct dhcp_opt *dhcp6_opts = NULL; +size_t dhcp6_opts_len = 0; + +struct dhcp_compat { + uint8_t dhcp_opt; + uint16_t dhcp6_opt; +}; + +const struct dhcp_compat dhcp_compats[] = { + { DHO_DNSSERVER, D6_OPTION_DNS_SERVERS }, + { DHO_HOSTNAME, D6_OPTION_FQDN }, + { DHO_DNSDOMAIN, D6_OPTION_FQDN }, + { DHO_NISSERVER, D6_OPTION_NIS_SERVERS }, + { DHO_NTPSERVER, D6_OPTION_SNTP_SERVERS }, + { DHO_RAPIDCOMMIT, D6_OPTION_RAPID_COMMIT }, + { DHO_FQDN, D6_OPTION_FQDN }, + { DHO_VIVCO, D6_OPTION_VENDOR_CLASS }, + { DHO_VIVSO, D6_OPTION_VENDOR_OPTS }, + { DHO_DNSSEARCH, D6_OPTION_DOMAIN_LIST }, + { 0, 0 } +}; + +static const char * const dhcp6_statuses[] = { + "Success", + "Unspecified Failure", + "No Addresses Available", + "No Binding", + "Not On Link", + "Use Multicast" +}; + +#if DEBUG_MEMORY +static void +dhcp6_cleanup(void) +{ + + free(sndbuf); + free(rcvbuf); + free(status); +} +#endif + +void +dhcp6_printoptions(void) +{ + size_t i; + const struct dhcp_opt *opt; + + for (i = 0, opt = dhcp6_opts; i < dhcp6_opts_len; i++, opt++) + printf("%05d %s\n", opt->option, opt->var); +} + +static int +dhcp6_init(void) +{ + int len; + +#if DEBUG_MEMORY + atexit(dhcp6_cleanup); +#endif + + len = CMSG_SPACE(sizeof(struct in6_pktinfo)); + sndbuf = calloc(1, len); + if (sndbuf == NULL) + return -1; + sndhdr.msg_namelen = sizeof(struct sockaddr_in6); + sndhdr.msg_iov = sndiov; + sndhdr.msg_iovlen = 1; + sndhdr.msg_control = sndbuf; + sndhdr.msg_controllen = len; + + rcvbuf = calloc(1, len); + if (rcvbuf == NULL) { + free(sndbuf); + sndbuf = NULL; + return -1; + } + rcvhdr.msg_name = &from; + rcvhdr.msg_namelen = sizeof(from); + rcvhdr.msg_iov = rcviov; + rcvhdr.msg_iovlen = 1; + rcvhdr.msg_control = rcvbuf; + rcvhdr.msg_controllen = len; + rcviov[0].iov_base = ansbuf; + rcviov[0].iov_len = sizeof(ansbuf); + + return 0; +} + +static size_t +dhcp6_makevendor(struct dhcp6_option *o, const struct interface *ifp) +{ + const struct if_options *ifo; + size_t len; + uint8_t *p; + uint16_t u16; + uint32_t u32; + size_t vlen, i; + const struct vivco *vivco; + + ifo = ifp->options; + len = sizeof(uint32_t); /* IANA PEN */ + if (ifo->vivco_en) { + for (i = 0, vivco = ifo->vivco; + i < ifo->vivco_len; + i++, vivco++) + len += sizeof(uint16_t) + vivco->len; + vlen = 0; /* silence bogus gcc warning */ + } else { + vlen = strlen(vendor); + len += sizeof(uint16_t) + vlen; + } + + if (len > UINT16_MAX) { + syslog(LOG_ERR, "%s: DHCPv6 Vendor Class too big", ifp->name); + return 0; + } + + if (o) { + o->code = htons(D6_OPTION_VENDOR_CLASS); + o->len = htons(len); + p = D6_OPTION_DATA(o); + u32 = htonl(ifo->vivco_en ? ifo->vivco_en : DHCPCD_IANA_PEN); + memcpy(p, &u32, sizeof(u32)); + p += sizeof(u32); + if (ifo->vivco_en) { + for (i = 0, vivco = ifo->vivco; + i < ifo->vivco_len; + i++, vivco++) + { + u16 = htons(vivco->len); + memcpy(p, &u16, sizeof(u16)); + p += sizeof(u16); + memcpy(p, vivco->data, vivco->len); + p += vivco->len; + } + } else { + u16 = htons(vlen); + memcpy(p, &u16, sizeof(u16)); + p += sizeof(u16); + memcpy(p, vendor, vlen); + } + } + + return len; +} + +static const struct dhcp6_option * +dhcp6_findoption(int code, const uint8_t *d, ssize_t len) +{ + const struct dhcp6_option *o; + + code = htons(code); + for (o = (const struct dhcp6_option *)d; + len > (ssize_t)sizeof(*o); + o = D6_CNEXT_OPTION(o)) + { + len -= sizeof(*o) + ntohs(o->len); + if (len < 0) { + errno = EINVAL; + return NULL; + } + if (o->code == code) + return o; + } + + errno = ESRCH; + return NULL; +} + +static const uint8_t * +dhcp6_getoption(unsigned int *os, unsigned int *code, unsigned int *len, + const uint8_t *od, unsigned int ol, struct dhcp_opt **oopt) +{ + const struct dhcp6_option *o; + size_t i; + struct dhcp_opt *opt; + + if (od) { + *os = sizeof(*o); + if (ol < *os) { + errno = EINVAL; + return NULL; + } + o = (const struct dhcp6_option *)od; + *len = ntohs(o->len); + if (*len > ol) { + errno = EINVAL; + return NULL; + } + *code = ntohs(o->code); + } else + o = NULL; + + for (i = 0, opt = dhcp6_opts; i < dhcp6_opts_len; i++, opt++) { + if (opt->option == *code) { + *oopt = opt; + break; + } + } + + if (o) + return D6_COPTION_DATA(o); + return NULL; +} + +static const struct dhcp6_option * +dhcp6_getmoption(int code, const struct dhcp6_message *m, ssize_t len) +{ + + len -= sizeof(*m); + return dhcp6_findoption(code, + (const uint8_t *)D6_CFIRST_OPTION(m), len); +} + +static int +dhcp6_updateelapsed(struct interface *ifp, struct dhcp6_message *m, ssize_t len) +{ + struct dhcp6_state *state; + const struct dhcp6_option *co; + struct dhcp6_option *o; + time_t up; + uint16_t u16; + + co = dhcp6_getmoption(D6_OPTION_ELAPSED, m, len); + if (co == NULL) + return -1; + + o = __UNCONST(co); + state = D6_STATE(ifp); + up = uptime() - state->start_uptime; + if (up < 0 || up > (time_t)UINT16_MAX) + up = (time_t)UINT16_MAX; + u16 = htons(up); + memcpy(D6_OPTION_DATA(o), &u16, sizeof(u16)); + return 0; +} + +static void +dhcp6_newxid(const struct interface *ifp, struct dhcp6_message *m) +{ + uint32_t xid; + + if (ifp->options->options & DHCPCD_XID_HWADDR && + ifp->hwlen >= sizeof(xid)) + /* The lower bits are probably more unique on the network */ + memcpy(&xid, (ifp->hwaddr + ifp->hwlen) - sizeof(xid), + sizeof(xid)); + else + xid = arc4random(); + + m->xid[0] = (xid >> 16) & 0xff; + m->xid[1] = (xid >> 8) & 0xff; + m->xid[2] = xid & 0xff; +} + +static int +dhcp6_makemessage(struct interface *ifp) +{ + struct dhcp6_state *state; + struct dhcp6_message *m; + struct dhcp6_option *o, *so; + const struct dhcp6_option *si, *unicast; + ssize_t len, ml; + size_t l; + int auth_len; + uint8_t u8; + uint16_t *u16, n_options, type; + const struct if_options *ifo; + const struct dhcp_opt *opt; + uint8_t IA, *p; + uint32_t u32; + const struct ipv6_addr *ap; + const char *hostname = NULL; /* assignment just to appease GCC*/ + int fqdn; + + state = D6_STATE(ifp); + if (state->send) { + free(state->send); + state->send = NULL; + } + + ifo = ifp->options; + fqdn = ifo->fqdn; + + if (fqdn == FQDN_DISABLE && ifo->options & DHCPCD_HOSTNAME) { + /* We're sending the DHCPv4 hostname option, so send FQDN as + * DHCPv6 has no FQDN option and DHCPv4 must not send + * hostname and FQDN according to RFC4702 */ + fqdn = FQDN_BOTH; + } + if (fqdn != FQDN_DISABLE) { + if (ifo->hostname[0] == '\0') + hostname = get_hostname(ifo->options & + DHCPCD_HOSTNAME_SHORT ? 1 : 0); + else + hostname = ifo->hostname; + } + + /* Work out option size first */ + n_options = 0; + len = 0; + si = NULL; + if (state->state != DH6S_RELEASE) { + for (l = 0, opt = dhcp6_opts; l < dhcp6_opts_len ; l++, opt++) { + if (!(opt->type & NOREQ) && + (opt->type & REQUEST || + has_option_mask(ifo->requestmask6, opt->option))) + { + n_options++; + len += sizeof(*u16); + } + } + if (len) + len += sizeof(*o); + + if (fqdn != FQDN_DISABLE) + len += sizeof(*o) + 1 + encode_rfc1035(hostname, NULL); + } + + len += sizeof(*state->send); + len += sizeof(*o) + duid_len; + len += sizeof(*o) + sizeof(uint16_t); /* elapsed */ + len += sizeof(*o) + dhcp6_makevendor(NULL, ifp); + + /* IA */ + m = NULL; + ml = 0; + switch(state->state) { + case DH6S_REQUEST: + m = state->recv; + ml = state->recv_len; + /* FALLTHROUGH */ + case DH6S_RELEASE: + /* FALLTHROUGH */ + case DH6S_RENEW: + if (m == NULL) { + m = state->new; + ml = state->new_len; + } + si = dhcp6_getmoption(D6_OPTION_SERVERID, m, ml); + if (si == NULL) { + errno = ESRCH; + return -1; + } + len += sizeof(*si) + ntohs(si->len); + /* FALLTHROUGH */ + case DH6S_REBIND: + /* FALLTHROUGH */ + case DH6S_CONFIRM: + if (m == NULL) { + m = state->new; + ml = state->new_len; + } + TAILQ_FOREACH(ap, &state->addrs, next) { + if (ap->prefix_vltime == 0) + continue; + if (ifo->ia_type == D6_OPTION_IA_PD) + len += sizeof(*o) + sizeof(u8) + + sizeof(u32) + sizeof(u32) + + sizeof(ap->prefix.s6_addr); + else + len += sizeof(*o) + sizeof(ap->addr.s6_addr) + + sizeof(u32) + sizeof(u32); + } + /* FALLTHROUGH */ + case DH6S_INIT: /* FALLTHROUGH */ + case DH6S_DISCOVER: + len += ifo->ia_len * (sizeof(*o) + (sizeof(u32) * 3)); + IA = 1; + break; + default: + IA = 0; + } + + if (state->state == DH6S_DISCOVER && + !(options & DHCPCD_TEST) && + has_option_mask(ifo->requestmask6, D6_OPTION_RAPID_COMMIT)) + len += sizeof(*o); + + if (m == NULL) { + m = state->new; + ml = state->new_len; + } + unicast = NULL; + /* Depending on state, get the unicast address */ + switch(state->state) { + break; + case DH6S_INIT: /* FALLTHROUGH */ + case DH6S_DISCOVER: + type = DHCP6_SOLICIT; + break; + case DH6S_REQUEST: + type = DHCP6_REQUEST; + unicast = dhcp6_getmoption(D6_OPTION_UNICAST, m, ml); + break; + case DH6S_CONFIRM: + type = DHCP6_CONFIRM; + break; + case DH6S_REBIND: + type = DHCP6_REBIND; + break; + case DH6S_RENEW: + type = DHCP6_RENEW; + unicast = dhcp6_getmoption(D6_OPTION_UNICAST, m, ml); + break; + case DH6S_INFORM: + type = DHCP6_INFORMATION_REQ; + break; + case DH6S_RELEASE: + type = DHCP6_RELEASE; + unicast = dhcp6_getmoption(D6_OPTION_UNICAST, m, ml); + break; + default: + errno = EINVAL; + return -1; + } + + if (ifo->auth.options & DHCPCD_AUTH_SEND) { + auth_len = dhcp_auth_encode(&ifo->auth, state->auth.token, + NULL, 0, 6, type, NULL, 0); + if (auth_len > 0) + len += sizeof(*o) + auth_len; + } else + auth_len = 0; /* appease GCC */ + + state->send = malloc(len); + if (state->send == NULL) + return -1; + + state->send_len = len; + state->send->type = type; + + /* If we found a unicast option, copy it to our state for sending */ + if (unicast && ntohs(unicast->len) == sizeof(state->unicast.s6_addr)) + memcpy(&state->unicast.s6_addr, D6_COPTION_DATA(unicast), + sizeof(state->unicast.s6_addr)); + else + state->unicast = in6addr_any; + + dhcp6_newxid(ifp, state->send); + + o = D6_FIRST_OPTION(state->send); + o->code = htons(D6_OPTION_CLIENTID); + o->len = htons(duid_len); + memcpy(D6_OPTION_DATA(o), duid, duid_len); + + if (si) { + o = D6_NEXT_OPTION(o); + memcpy(o, si, sizeof(*si) + ntohs(si->len)); + } + + o = D6_NEXT_OPTION(o); + o->code = htons(D6_OPTION_ELAPSED); + o->len = htons(sizeof(uint16_t)); + p = D6_OPTION_DATA(o); + memset(p, 0, sizeof(u16)); + + o = D6_NEXT_OPTION(o); + dhcp6_makevendor(o, ifp); + + if (state->state == DH6S_DISCOVER && + !(options & DHCPCD_TEST) && + has_option_mask(ifo->requestmask6, D6_OPTION_RAPID_COMMIT)) + { + o = D6_NEXT_OPTION(o); + o->code = htons(D6_OPTION_RAPID_COMMIT); + o->len = 0; + } + + for (l = 0; IA && l < ifo->ia_len; l++) { + o = D6_NEXT_OPTION(o); + o->code = htons(ifo->ia_type); + o->len = htons(sizeof(u32) + sizeof(u32) + sizeof(u32)); + p = D6_OPTION_DATA(o); + memcpy(p, ifo->ia[l].iaid, sizeof(u32)); + p += sizeof(u32); + memset(p, 0, sizeof(u32) + sizeof(u32)); + TAILQ_FOREACH(ap, &state->addrs, next) { + if (ap->prefix_vltime == 0) + continue; + if (memcmp(ifo->ia[l].iaid, ap->iaid, sizeof(u32))) + continue; + so = D6_NEXT_OPTION(o); + if (ifo->ia_type == D6_OPTION_IA_PD) { + so->code = htons(D6_OPTION_IAPREFIX); + so->len = htons(sizeof(ap->prefix.s6_addr) + + sizeof(u32) + sizeof(u32) + sizeof(u8)); + p = D6_OPTION_DATA(so); + u32 = htonl(ap->prefix_pltime); + memcpy(p, &u32, sizeof(u32)); + p += sizeof(u32); + u32 = htonl(ap->prefix_vltime); + memcpy(p, &u32, sizeof(u32)); + p += sizeof(u32); + u8 = ap->prefix_len; + memcpy(p, &u8, sizeof(u8)); + p += sizeof(u8); + memcpy(p, &ap->prefix.s6_addr, + sizeof(ap->prefix.s6_addr)); + /* Avoid a shadowed declaration warning by + * moving our addition outside of the htons + * macro */ + u32 = ntohs(o->len) + sizeof(*so) + + ntohs(so->len); + o->len = htons(u32); + } else { + so->code = htons(D6_OPTION_IA_ADDR); + so->len = htons(sizeof(ap->addr.s6_addr) + + sizeof(u32) + sizeof(u32)); + p = D6_OPTION_DATA(so); + memcpy(p, &ap->addr.s6_addr, + sizeof(ap->addr.s6_addr)); + p += sizeof(ap->addr.s6_addr); + u32 = htonl(ap->prefix_pltime); + memcpy(p, &u32, sizeof(u32)); + p += sizeof(u32); + u32 = htonl(ap->prefix_vltime); + memcpy(p, &u32, sizeof(u32)); + /* Avoid a shadowed declaration warning by + * moving our addition outside of the htons + * macro */ + u32 = ntohs(o->len) + sizeof(*so) + + ntohs(so->len); + o->len = htons(u32); + } + } + } + + if (state->send->type != DHCP6_RELEASE) { + if (fqdn != FQDN_DISABLE) { + o = D6_NEXT_OPTION(o); + o->code = htons(D6_OPTION_FQDN); + p = D6_OPTION_DATA(o); + switch (fqdn) { + case FQDN_BOTH: + *p = D6_FQDN_BOTH; + break; + case FQDN_PTR: + *p = D6_FQDN_PTR; + break; + default: + *p = D6_FQDN_NONE; + break; + } + l = encode_rfc1035(hostname, p + 1); + if (l == 0) + *p = D6_FQDN_NONE; + o->len = htons(l + 1); + } + + if (n_options) { + o = D6_NEXT_OPTION(o); + o->code = htons(D6_OPTION_ORO); + o->len = 0; + u16 = (uint16_t *)(void *)D6_OPTION_DATA(o); + for (l = 0, opt = dhcp6_opts; + l < dhcp6_opts_len; + l++, opt++) + { + if (!(opt->type & NOREQ) && + (opt->type & REQUEST || + has_option_mask(ifo->requestmask6, + opt->option))) + { + *u16++ = htons(opt->option); + o->len += sizeof(*u16); + } + } + o->len = htons(o->len); + } + } + + /* This has to be the last option */ + if (ifo->auth.options & DHCPCD_AUTH_SEND && auth_len > 0) { + o = D6_NEXT_OPTION(o); + o->code = htons(D6_OPTION_AUTH); + o->len = htons(auth_len); + /* data will be filled at send message time */ + } + + return 0; +} + +static const char * +dhcp6_get_op(uint16_t type) +{ + const struct dhcp6_op *d; + + for (d = dhcp6_ops; d->name; d++) + if (d->type == type) + return d->name; + return NULL; +} + +static void +dhcp6_freedrop_addrs(struct interface *ifp, int drop, + const struct interface *ifd) +{ + struct dhcp6_state *state; + + state = D6_STATE(ifp); + if (state) { + ipv6_freedrop_addrs(&state->addrs, drop, ifd); + if (drop) + ipv6_buildroutes(); + } +} + +static void dhcp6_delete_delegates(struct interface *ifp) +{ + struct interface *ifp0; + + if (ifaces) { + TAILQ_FOREACH(ifp0, ifaces, next) { + if (ifp0 != ifp) + dhcp6_freedrop_addrs(ifp0, 1, ifp); + } + } +} + + +static int +dhcp6_update_auth(struct interface *ifp, struct dhcp6_message *m, ssize_t len) +{ + struct dhcp6_state *state; + const struct dhcp6_option *co; + struct dhcp6_option *o; + + co = dhcp6_getmoption(D6_OPTION_AUTH, m, len); + if (co == NULL) + return -1; + + o = __UNCONST(co); + state = D6_STATE(ifp); + + return dhcp_auth_encode(&ifp->options->auth, state->auth.token, + (uint8_t *)state->send, state->send_len, + 6, state->send->type, + D6_OPTION_DATA(o), ntohs(o->len)); +} + +static int +dhcp6_sendmessage(struct interface *ifp, void (*callback)(void *)) +{ + struct dhcp6_state *state; + struct sockaddr_in6 to; + struct cmsghdr *cm; + struct in6_pktinfo pi; + struct timeval RTprev; + double rnd; + suseconds_t ms; + uint8_t neg; + const char *broad_uni; + + memset(&to, 0, sizeof(to)); + to.sin6_family = AF_INET6; + to.sin6_port = htons(DHCP6_SERVER_PORT); +#ifdef SIN6_LEN + to.sin6_len = sizeof(to); +#endif + + state = D6_STATE(ifp); + /* We need to ensure we have sufficient scope to unicast the address */ + /* XXX FIXME: We should check any added addresses we have like from + * a Router Advertisement */ + if (IN6_IS_ADDR_UNSPECIFIED(&state->unicast) || + (state->state == DH6S_REQUEST && + (!IN6_IS_ADDR_LINKLOCAL(&state->unicast) || !ipv6_linklocal(ifp)))) + { + to.sin6_addr = in6addr_linklocal_alldhcp; + broad_uni = "broadcasting"; + } else { + to.sin6_addr = state->unicast; + broad_uni = "unicasting"; + } + + if (!callback) + syslog(LOG_DEBUG, "%s: %s %s with xid 0x%02x%02x%02x", + ifp->name, + broad_uni, + dhcp6_get_op(state->send->type), + state->send->xid[0], + state->send->xid[1], + state->send->xid[2]); + else { + if (state->IMD) { + /* Some buggy PPP servers close the link too early + * after sending an invalid status in their reply + * which means this host won't see it. + * 1 second grace seems to be the sweet spot. */ + if (ifp->flags & IFF_POINTOPOINT) + state->RT.tv_sec = 1; + else + state->RT.tv_sec = 0; + state->RT.tv_usec = arc4random() % + (state->IMD * 1000000); + timernorm(&state->RT); + broad_uni = "delaying"; + goto logsend; + } + if (state->RTC == 0) { + RTprev.tv_sec = state->IRT; + RTprev.tv_usec = 0; + state->RT.tv_sec = RTprev.tv_sec; + state->RT.tv_usec = 0; + } else { + RTprev = state->RT; + timeradd(&state->RT, &state->RT, &state->RT); + } + + rnd = DHCP6_RAND_MIN; + rnd += arc4random() % (DHCP6_RAND_MAX - DHCP6_RAND_MIN); + rnd /= 1000; + neg = (rnd < 0.0); + if (neg) + rnd = -rnd; + tv_to_ms(ms, &RTprev); + ms *= rnd; + ms_to_tv(&RTprev, ms); + if (neg) + timersub(&state->RT, &RTprev, &state->RT); + else + timeradd(&state->RT, &RTprev, &state->RT); + + if (state->RT.tv_sec > state->MRT) { + RTprev.tv_sec = state->MRT; + RTprev.tv_usec = 0; + state->RT.tv_sec = state->MRT; + state->RT.tv_usec = 0; + tv_to_ms(ms, &RTprev); + ms *= rnd; + ms_to_tv(&RTprev, ms); + if (neg) + timersub(&state->RT, &RTprev, &state->RT); + else + timeradd(&state->RT, &RTprev, &state->RT); + } + +logsend: + syslog(LOG_DEBUG, + "%s: %s %s (xid 0x%02x%02x%02x)," + " next in %0.1f seconds", + ifp->name, + broad_uni, + dhcp6_get_op(state->send->type), + state->send->xid[0], + state->send->xid[1], + state->send->xid[2], + timeval_to_double(&state->RT)); + + /* Wait the initial delay */ + if (state->IMD) { + state->IMD = 0; + eloop_timeout_add_tv(&state->RT, callback, ifp); + return 0; + } + } + + /* Update the elapsed time */ + dhcp6_updateelapsed(ifp, state->send, state->send_len); + if (ifp->options->auth.options & DHCPCD_AUTH_SEND && + dhcp6_update_auth(ifp, state->send, state->send_len) == -1) + { + syslog(LOG_ERR, "%s: dhcp6_updateauth: %m", ifp->name); + return -1; + } + + to.sin6_scope_id = ifp->index; + sndhdr.msg_name = (caddr_t)&to; + sndhdr.msg_iov[0].iov_base = (caddr_t)state->send; + sndhdr.msg_iov[0].iov_len = state->send_len; + + /* Set the outbound interface */ + cm = CMSG_FIRSTHDR(&sndhdr); + cm->cmsg_level = IPPROTO_IPV6; + cm->cmsg_type = IPV6_PKTINFO; + cm->cmsg_len = CMSG_LEN(sizeof(pi)); + memset(&pi, 0, sizeof(pi)); + pi.ipi6_ifindex = ifp->index; + memcpy(CMSG_DATA(cm), &pi, sizeof(pi)); + + if (sendmsg(sock, &sndhdr, 0) == -1) { + syslog(LOG_ERR, "%s: %s: sendmsg: %m", ifp->name, __func__); + ifp->options->options &= ~DHCPCD_IPV6; + dhcp6_drop(ifp, "EXPIRE6"); + return -1; + } + + state->RTC++; + if (callback) { + if (state->MRC == 0 || state->RTC < state->MRC) + eloop_timeout_add_tv(&state->RT, callback, ifp); + else if (state->MRC != 0 && state->MRCcallback) + eloop_timeout_add_tv(&state->RT, state->MRCcallback, + ifp); + else + syslog(LOG_WARNING, "%s: sent %d times with no reply", + ifp->name, state->RTC); + } + return 0; +} + +static void +dhcp6_sendinform(void *arg) +{ + + dhcp6_sendmessage(arg, dhcp6_sendinform); +} + +static void +dhcp6_senddiscover(void *arg) +{ + + dhcp6_sendmessage(arg, dhcp6_senddiscover); +} + +static void +dhcp6_sendrequest(void *arg) +{ + + dhcp6_sendmessage(arg, dhcp6_sendrequest); +} + +static void +dhcp6_sendrebind(void *arg) +{ + + dhcp6_sendmessage(arg, dhcp6_sendrebind); +} + +static void +dhcp6_sendrenew(void *arg) +{ + + dhcp6_sendmessage(arg, dhcp6_sendrenew); +} + +static void +dhcp6_sendconfirm(void *arg) +{ + + dhcp6_sendmessage(arg, dhcp6_sendconfirm); +} + +/* +static void +dhcp6_sendrelease(void *arg) +{ + + dhcp6_sendmessage(arg, dhcp6_sendrelease); +} +*/ + +static void +dhcp6_startrenew(void *arg) +{ + struct interface *ifp; + struct dhcp6_state *state; + + ifp = arg; + state = D6_STATE(ifp); + state->state = DH6S_RENEW; + state->start_uptime = uptime(); + state->RTC = 0; + state->IRT = REN_TIMEOUT; + state->MRT = REN_MAX_RT; + state->MRC = 0; + + if (dhcp6_makemessage(ifp) == -1) + syslog(LOG_ERR, "%s: dhcp6_makemessage: %m", ifp->name); + else + dhcp6_sendrenew(ifp); +} + +static void +dhcp6_startdiscover(void *arg) +{ + struct interface *ifp; + struct dhcp6_state *state; + + ifp = arg; + dhcp6_delete_delegates(ifp); + syslog(LOG_INFO, "%s: soliciting a DHCPv6 lease", ifp->name); + state = D6_STATE(ifp); + state->state = DH6S_DISCOVER; + state->start_uptime = uptime(); + state->RTC = 0; + state->IMD = SOL_MAX_DELAY; + state->IRT = SOL_TIMEOUT; + state->MRT = SOL_MAX_RT; + state->MRC = 0; + + eloop_timeout_delete(NULL, ifp); + free(state->new); + state->new = NULL; + state->new_len = 0; + + dhcp6_freedrop_addrs(ifp, 0, NULL); + unlink(state->leasefile); + + if (dhcp6_makemessage(ifp) == -1) + syslog(LOG_ERR, "%s: dhcp6_makemessage: %m", ifp->name); + else + dhcp6_senddiscover(ifp); +} + +static void +dhcp6_failconfirm(void *arg) +{ + struct interface *ifp; + + ifp = arg; + syslog(LOG_ERR, "%s: failed to confirm prior address", ifp->name); + /* Section 18.1.2 says that we SHOULD use the last known + * IP address(s) and lifetimes if we didn't get a reply. + * I disagree with this. */ + dhcp6_startdiscover(ifp); +} + +static void +dhcp6_failrequest(void *arg) +{ + struct interface *ifp; + + ifp = arg; + syslog(LOG_ERR, "%s: failed to request address", ifp->name); + /* Section 18.1.1 says that client local policy dictates + * what happens if a REQUEST fails. + * Of the possible scenarios listed, moving back to the + * DISCOVER phase makes more sense for us. */ + dhcp6_startdiscover(ifp); +} + +static void +dhcp6_failrebind(void *arg) +{ + struct interface *ifp; + + ifp = arg; + syslog(LOG_ERR, "%s: failed to rebind prior delegation", ifp->name); + dhcp6_delete_delegates(ifp); + /* Section 18.1.2 says that we SHOULD use the last known + * IP address(s) and lifetimes if we didn't get a reply. + * I disagree with this. */ + dhcp6_startdiscover(ifp); +} + +static void +dhcp6_startrebind(void *arg) +{ + struct interface *ifp; + struct dhcp6_state *state; + + ifp = arg; + eloop_timeout_delete(dhcp6_sendrenew, ifp); + state = D6_STATE(ifp); + if (state->state == DH6S_RENEW) + syslog(LOG_WARNING, "%s: failed to renew DHCPv6, rebinding", + ifp->name); + state->state = DH6S_REBIND; + state->RTC = 0; + state->MRC = 0; + + /* RFC 3633 section 12.1 */ + if (ifp->options->ia_type == D6_OPTION_IA_PD) { + syslog(LOG_INFO, "%s: confirming Prefix Delegation", ifp->name); + state->IMD = CNF_MAX_DELAY; + state->IRT = CNF_TIMEOUT; + state->MRT = CNF_MAX_RT; + } else { + state->IRT = REB_TIMEOUT; + state->MRT = REB_MAX_RT; + } + + if (dhcp6_makemessage(ifp) == -1) + syslog(LOG_ERR, "%s: dhcp6_makemessage: %m", ifp->name); + else + dhcp6_sendrebind(ifp); + + /* RFC 3633 section 12.1 */ + if (ifp->options->ia_type == D6_OPTION_IA_PD) + eloop_timeout_add_sec(CNF_MAX_RD, dhcp6_failrebind, ifp); +} + + +static void +dhcp6_startrequest(struct interface *ifp) +{ + struct dhcp6_state *state; + + eloop_timeout_delete(dhcp6_senddiscover, ifp); + state = D6_STATE(ifp); + state->state = DH6S_REQUEST; + state->RTC = 0; + state->IRT = REQ_TIMEOUT; + state->MRT = REQ_MAX_RT; + state->MRC = REQ_MAX_RC; + state->MRCcallback = dhcp6_failrequest; + + if (dhcp6_makemessage(ifp) == -1) { + syslog(LOG_ERR, "%s: dhcp6_makemessage: %m", ifp->name); + return; + } + + dhcp6_sendrequest(ifp); +} + +static void +dhcp6_startconfirm(struct interface *ifp) +{ + struct dhcp6_state *state; + + state = D6_STATE(ifp); + state->state = DH6S_CONFIRM; + state->start_uptime = uptime(); + state->RTC = 0; + state->IMD = CNF_MAX_DELAY; + state->IRT = CNF_TIMEOUT; + state->MRT = CNF_MAX_RT; + state->MRC = 0; + + syslog(LOG_INFO, "%s: confirming prior DHCPv6 lease", ifp->name); + if (dhcp6_makemessage(ifp) == -1) { + syslog(LOG_ERR, "%s: dhcp6_makemessage: %m", ifp->name); + return; + } + dhcp6_sendconfirm(ifp); + eloop_timeout_add_sec(CNF_MAX_RD, dhcp6_failconfirm, ifp); +} + +static void +dhcp6_startinform(void *arg) +{ + struct interface *ifp; + struct dhcp6_state *state; + + ifp = arg; + state = D6_STATE(ifp); + if (state->new == NULL || ifp->options->options & DHCPCD_DEBUG) + syslog(LOG_INFO, "%s: requesting DHCPv6 information", + ifp->name); + state->state = DH6S_INFORM; + state->start_uptime = uptime(); + state->RTC = 0; + state->IMD = INF_MAX_DELAY; + state->IRT = INF_TIMEOUT; + state->MRT = INF_MAX_RT; + state->MRC = 0; + + if (dhcp6_makemessage(ifp) == -1) + syslog(LOG_ERR, "%s: dhcp6_makemessage: %m", ifp->name); + else + dhcp6_sendinform(ifp); +} + +static void +dhcp6_startexpire(void *arg) +{ + struct interface *ifp; + + ifp = arg; + eloop_timeout_delete(dhcp6_sendrebind, ifp); + + syslog(LOG_ERR, "%s: DHCPv6 lease expired", ifp->name); + dhcp6_freedrop_addrs(ifp, 1, NULL); + dhcp6_delete_delegates(ifp); + script_runreason(ifp, "EXPIRE6"); + dhcp6_startdiscover(ifp); +} + +static void +dhcp6_startrelease(struct interface *ifp) +{ + struct dhcp6_state *state; + + state = D6_STATE(ifp); + if (state->state != DH6S_BOUND) + return; + + state->state = DH6S_RELEASE; + state->start_uptime = uptime(); + state->RTC = 0; + state->IRT = REL_TIMEOUT; + state->MRT = 0; + state->MRC = REL_MAX_RC; + //state->MRCcallback = dhcp6_failrelease; + state->MRCcallback = NULL; + + if (dhcp6_makemessage(ifp) == -1) + syslog(LOG_ERR, "%s: dhcp6_makemessage: %m", ifp->name); + else + /* XXX: We should loop a few times + * Luckily RFC3315 section 18.1.6 says this is optional */ + //dhcp6_sendrelease(ifp); + dhcp6_sendmessage(ifp, NULL); +} + +static int dhcp6_getstatus(const struct dhcp6_option *o) +{ + uint16_t code; + char *nstatus; + size_t len; + const uint8_t *p; + + len = ntohs(o->len); + if (len < sizeof(code)) { + syslog(LOG_ERR, "status truncated"); + return -1; + } + if (ntohs(o->code) != D6_OPTION_STATUS_CODE) { + /* unlikely */ + syslog(LOG_ERR, "not a status"); + return -1; + } + p = D6_COPTION_DATA(o); + len = ntohs(o->len); + memcpy(&code, p, sizeof(code)); + code = ntohs(code); + len -= sizeof(code); + + if (len == 0) { + if (code < sizeof(dhcp6_statuses) / sizeof(char *)) { + p = (const uint8_t *)dhcp6_statuses[code]; + len = strlen((const char *)p); + } else + p = NULL; + } else { + p = D6_COPTION_DATA(o) + sizeof(uint16_t); + } + if (status == NULL || len + 1 > status_len) { + status_len = len; + nstatus = realloc(status, status_len + 1); + if (nstatus == NULL) { + syslog(LOG_ERR, "%s: %m", __func__); + free(status); + } + status = nstatus; + } + if (status) { + memcpy(status, p, len); + status[len] = '\0'; + } + return code; +} + +static int +dhcp6_checkstatusok(const struct interface *ifp, + const struct dhcp6_message *m, const uint8_t *p, size_t len) +{ + const struct dhcp6_option *o; + + if (p) + o = dhcp6_findoption(D6_OPTION_STATUS_CODE, p, len); + else + o = dhcp6_getmoption(D6_OPTION_STATUS_CODE, m, len); + if (o == NULL) { + //syslog(LOG_DEBUG, "%s: no status", ifp->name); + return 0; + } + if (dhcp6_getstatus(o) != D6_STATUS_OK) { + syslog(LOG_ERR, "%s: DHCPv6 REPLY: %s", ifp->name, status); + return -1; + } + //syslog(LOG_DEBUG, "%s: status: %s", ifp->name, status); + return 1; +} + +static struct ipv6_addr * +dhcp6_findaddr(struct interface *ifp, const struct in6_addr *addr) +{ + const struct dhcp6_state *state; + struct ipv6_addr *ap; + + state = D6_CSTATE(ifp); + if (state) { + TAILQ_FOREACH(ap, &state->addrs, next) { + if (addr == NULL) { + if ((ap->flags & + (IPV6_AF_ADDED | IPV6_AF_DADCOMPLETED)) == + (IPV6_AF_ADDED | IPV6_AF_DADCOMPLETED)) + return ap; + } else if (IN6_ARE_ADDR_EQUAL(&ap->addr, addr)) + return ap; + } + } + return NULL; +} + +int +dhcp6_addrexists(const struct ipv6_addr *addr) +{ + struct interface *ifp; + + TAILQ_FOREACH(ifp, ifaces, next) { + if (dhcp6_findaddr(ifp, addr == NULL ? NULL : &addr->addr)) + return 1; + } + return 0; +} + +static void +dhcp6_dadcallback(void *arg) +{ + struct ipv6_addr *ap = arg; + struct interface *ifp; + struct dhcp6_state *state; + int wascompleted; + + wascompleted = (ap->flags & IPV6_AF_DADCOMPLETED); + ipv6nd_cancelprobeaddr(ap); + ap->flags |= IPV6_AF_DADCOMPLETED; + if (ap->flags & IPV6_AF_DUPLICATED) + /* XXX FIXME + * We should decline the address */ + syslog(LOG_WARNING, "%s: DAD detected %s", + ap->iface->name, ap->saddr); +#ifdef IPV6_SEND_DAD + else + ipv6_addaddr(ap); +#endif + + if (!wascompleted) { + ifp = ap->iface; + state = D6_STATE(ifp); + if (state->state == DH6S_BOUND || + state->state == DH6S_DELEGATED) + { + TAILQ_FOREACH(ap, &state->addrs, next) { + if ((ap->flags & IPV6_AF_DADCOMPLETED) == 0) { + wascompleted = 1; + break; + } + } + if (!wascompleted) { + syslog(LOG_DEBUG, "%s: DHCPv6 DAD completed", + ifp->name); + script_runreason(ifp, state->reason); + daemonise(); + } + } + } +} + +static int +dhcp6_findna(struct interface *ifp, const uint8_t *iaid, + const uint8_t *d, size_t l) +{ + struct dhcp6_state *state; + const struct dhcp6_option *o; + const uint8_t *p; + struct in6_addr in6; + struct ipv6_addr *a; + char iabuf[INET6_ADDRSTRLEN]; + const char *ia; + int i; + uint32_t u32; + + i = 0; + state = D6_STATE(ifp); + while ((o = dhcp6_findoption(D6_OPTION_IA_ADDR, d, l))) { + l -= ((const uint8_t *)o - d); + d += ((const uint8_t *)o - d); + u32 = ntohs(o->len); + l -= sizeof(*o) + u32; + d += sizeof(*o) + u32; + if (u32 < 24) { + errno = EINVAL; + syslog(LOG_ERR, "%s: IA Address option truncated", + ifp->name); + continue; + } + p = D6_COPTION_DATA(o); + memcpy(&in6.s6_addr, p, sizeof(in6.s6_addr)); + p += sizeof(in6.s6_addr); + a = dhcp6_findaddr(ifp, &in6); + if (a == NULL) { + a = calloc(1, sizeof(*a)); + if (a == NULL) { + syslog(LOG_ERR, "%s: %m", __func__); + break; + } + a->iface = ifp; + a->flags = IPV6_AF_NEW | IPV6_AF_ONLINK; + a->dadcallback = dhcp6_dadcallback; + memcpy(a->iaid, iaid, sizeof(a->iaid)); + memcpy(&a->addr.s6_addr, &in6.s6_addr, + sizeof(in6.s6_addr)); + + /* + * RFC 5942 Section 5 + * We cannot assume any prefix length, nor tie the + * address to an existing one as it could expire + * before the address. + * As such we just give it a 128 prefix. + */ + a->prefix_len = 128; + if (ipv6_makeprefix(&a->prefix, &a->addr, + a->prefix_len) == -1) + { + syslog(LOG_ERR, "%s: %m", __func__); + free(a); + continue; + } + ia = inet_ntop(AF_INET6, &a->addr.s6_addr, + iabuf, sizeof(iabuf)); + snprintf(a->saddr, sizeof(a->saddr), + "%s/%d", ia, a->prefix_len); + } + memcpy(&u32, p, sizeof(u32)); + a->prefix_pltime = ntohl(u32); + p += sizeof(u32); + memcpy(&u32, p, sizeof(u32)); + u32 = ntohl(u32); + if (a->prefix_vltime != u32) { + a->flags |= IPV6_AF_NEW; + a->prefix_vltime = u32; + } + if (a->prefix_pltime && a->prefix_pltime < state->lowpl) + state->lowpl = a->prefix_pltime; + if (a->prefix_vltime && a->prefix_vltime > state->expire) + state->expire = a->prefix_vltime; + if (a->flags & IPV6_AF_STALE) + a->flags &= ~IPV6_AF_STALE; + else + TAILQ_INSERT_TAIL(&state->addrs, a, next); + i++; + } + return i; +} + +static int +dhcp6_findpd(struct interface *ifp, const uint8_t *iaid, + const uint8_t *d, size_t l) +{ + struct dhcp6_state *state; + const struct dhcp6_option *o; + const uint8_t *p; + struct ipv6_addr *a; + char iabuf[INET6_ADDRSTRLEN]; + const char *ia; + int i; + uint8_t u8, len; + uint32_t u32, pltime, vltime; + struct in6_addr prefix; + + i = 0; + state = D6_STATE(ifp); + while ((o = dhcp6_findoption(D6_OPTION_IAPREFIX, d, l))) { + l -= ((const uint8_t *)o - d); + d += ((const uint8_t *)o - d); + u32 = ntohs(o->len); + l -= sizeof(*o) + u32; + d += sizeof(*o) + u32; + if (u32 < 25) { + errno = EINVAL; + syslog(LOG_ERR, "%s: IA Prefix option truncated", + ifp->name); + continue; + } + p = D6_COPTION_DATA(o); + memcpy(&u32, p, sizeof(u32)); + pltime = ntohl(u32); + p += sizeof(u32); + memcpy(&u32, p, sizeof(u32)); + p += sizeof(u32); + vltime = ntohl(u32); + memcpy(&u8, p, sizeof(u8)); + p += sizeof(u8); + len = u8; + memcpy(&prefix.s6_addr, p, sizeof(prefix.s6_addr)); + p += sizeof(prefix.s6_addr); + + TAILQ_FOREACH(a, &state->addrs, next) { + if (IN6_ARE_ADDR_EQUAL(&a->prefix, &prefix)) + break; + } + if (a == NULL) { + a = calloc(1, sizeof(*a)); + if (a == NULL) { + syslog(LOG_ERR, "%s: %m", __func__); + break; + } + a->iface = ifp; + a->flags = IPV6_AF_NEW; + a->dadcallback = dhcp6_dadcallback; + memcpy(a->iaid, iaid, sizeof(a->iaid)); + memcpy(&a->prefix.s6_addr, + &prefix.s6_addr, sizeof(a->prefix.s6_addr)); + a->prefix_len = len; + ia = inet_ntop(AF_INET6, &a->prefix.s6_addr, + iabuf, sizeof(iabuf)); + snprintf(a->saddr, sizeof(a->saddr), + "%s/%d", ia, a->prefix_len); + } else if (a->prefix_vltime != vltime) + a->flags |= IPV6_AF_NEW; + + a->prefix_pltime = pltime; + a->prefix_vltime = vltime; + if (a->prefix_pltime && a->prefix_pltime < state->lowpl) + state->lowpl = a->prefix_pltime; + if (a->prefix_vltime && a->prefix_vltime > state->expire) + state->expire = a->prefix_vltime; + if (a->flags & IPV6_AF_STALE) + a->flags &= ~IPV6_AF_STALE; + else + TAILQ_INSERT_TAIL(&state->addrs, a, next); + i++; + } + return i; +} + +static int +dhcp6_findia(struct interface *ifp, const uint8_t *d, size_t l, + const char *sfrom) +{ + struct dhcp6_state *state; + const struct if_options *ifo; + const struct dhcp6_option *o; + const uint8_t *p; + int i; + uint32_t u32, renew, rebind; + uint8_t iaid[4]; + size_t ol; + struct ipv6_addr *ap, *nap; + + ifo = ifp->options; + i = 0; + state = D6_STATE(ifp); + TAILQ_FOREACH(ap, &state->addrs, next) { + ap->flags |= IPV6_AF_STALE; + } + while ((o = dhcp6_findoption(ifo->ia_type, d, l))) { + l -= ((const uint8_t *)o - d); + d += ((const uint8_t *)o - d); + ol = ntohs(o->len); + l -= sizeof(*o) + ol; + d += sizeof(*o) + ol; + u32 = ifo->ia_type == D6_OPTION_IA_TA ? 4 : 12; + if (ol < u32) { + errno = EINVAL; + syslog(LOG_ERR, "%s: IA option truncated", ifp->name); + continue; + } + + p = D6_COPTION_DATA(o); + memcpy(iaid, p, sizeof(iaid)); + p += sizeof(iaid); + ol -= sizeof(iaid); + if (ifo->ia_type != D6_OPTION_IA_TA) { + memcpy(&u32, p, sizeof(u32)); + renew = ntohl(u32); + p += sizeof(u32); + ol -= sizeof(u32); + memcpy(&u32, p, sizeof(u32)); + rebind = ntohl(u32); + p += sizeof(u32); + ol -= sizeof(u32); + if (renew > rebind && rebind > 0) { + if (sfrom) + syslog(LOG_WARNING, + "%s: T1 (%d) > T2 (%d) from %s", + ifp->name, renew, rebind, sfrom); + renew = 0; + rebind = 0; + } + if (renew != 0 && + (renew < state->renew || state->renew == 0)) + state->renew = renew; + if (rebind != 0 && + (rebind < state->rebind || state->rebind == 0)) + state->rebind = rebind; + } + if (dhcp6_checkstatusok(ifp, NULL, p, ol) == -1) + return -1; + if (ifo->ia_type == D6_OPTION_IA_PD) { + if (dhcp6_findpd(ifp, iaid, p, ol) == 0) { + syslog(LOG_ERR, + "%s: %s: DHCPv6 REPLY missing Prefix", + ifp->name, sfrom); + return -1; + } + } else { + if (dhcp6_findna(ifp, iaid, p, ol) == 0) { + syslog(LOG_ERR, + "%s: %s: DHCPv6 REPLY missing IA Address", + ifp->name, sfrom); + return -1; + } + } + i++; + } + TAILQ_FOREACH_SAFE(ap, &state->addrs, next, nap) { + if (ap->flags & IPV6_AF_STALE) { + TAILQ_REMOVE(&state->addrs, ap, next); + if (ap->dadcallback) + eloop_q_timeout_delete(0, NULL, + ap->dadcallback); + free(ap); + } + } + return i; +} + +static int +dhcp6_validatelease(struct interface *ifp, + const struct dhcp6_message *m, size_t len, + const char *sfrom) +{ + struct dhcp6_state *state; + const struct dhcp6_option *o; + + state = D6_STATE(ifp); + o = dhcp6_getmoption(ifp->options->ia_type, m, len); + if (o == NULL) { + if (sfrom && + dhcp6_checkstatusok(ifp, m, NULL, len) != -1) + syslog(LOG_ERR, "%s: no IA in REPLY from %s", + ifp->name, sfrom); + return -1; + } + + if (dhcp6_checkstatusok(ifp, m, NULL, len) == -1) + return -1; + + state->renew = state->rebind = state->expire = 0; + state->lowpl = ND6_INFINITE_LIFETIME; + len -= (const char *)o - (const char *)m; + return dhcp6_findia(ifp, (const uint8_t *)o, len, sfrom); +} + +static ssize_t +dhcp6_writelease(const struct interface *ifp) +{ + const struct dhcp6_state *state; + int fd; + ssize_t bytes; + + state = D6_CSTATE(ifp); + syslog(LOG_DEBUG, "%s: writing lease `%s'", + ifp->name, state->leasefile); + + fd = open(state->leasefile, O_WRONLY | O_CREAT | O_TRUNC, 0644); + if (fd == -1) { + syslog(LOG_ERR, "%s: dhcp6_writelease: %m", ifp->name); + return -1; + } + bytes = write(fd, state->new, state->new_len); + close(fd); + return bytes; +} + +static int +dhcp6_readlease(struct interface *ifp) +{ + struct dhcp6_state *state; + struct stat st; + int fd; + ssize_t bytes; + struct timeval now; + const struct dhcp6_option *o; + + state = D6_STATE(ifp); + if (stat(state->leasefile, &st) == -1) { + if (errno == ENOENT) + return 0; + return -1; + } + syslog(LOG_DEBUG, "%s: reading lease `%s'", + ifp->name, state->leasefile); + state->new = malloc(st.st_size); + if (state->new == NULL) + return -1; + state->new_len = st.st_size; + fd = open(state->leasefile, O_RDONLY); + if (fd == -1) + return -1; + bytes = read(fd, state->new, state->new_len); + close(fd); + if (bytes < (ssize_t)state->new_len) { + syslog(LOG_ERR, "%s: read: %m", __func__); + goto ex; + } + + /* Check to see if the lease is still valid */ + fd = dhcp6_validatelease(ifp, state->new, state->new_len, NULL); + if (fd == -1) + goto ex; + if (fd == 0) { + syslog(LOG_INFO, "%s: lease was for different IA type", + ifp->name); + goto ex; + } + + if (state->expire != ND6_INFINITE_LIFETIME) { + gettimeofday(&now, NULL); + if ((time_t)state->expire < now.tv_sec - st.st_mtime) { + syslog(LOG_DEBUG,"%s: discarding expired lease", + ifp->name); + goto ex; + } + } + + /* Authenticate the message */ + o = dhcp6_getmoption(D6_OPTION_AUTH, state->new, state->new_len); + if (o) { + if (dhcp_auth_validate(&state->auth, &ifp->options->auth, + (uint8_t *)state->new, state->new_len, 6, state->new->type, + D6_COPTION_DATA(o), ntohs(o->len)) == NULL) + { + syslog(LOG_DEBUG, "%s: dhcp_auth_validate: %m", + ifp->name); + syslog(LOG_ERR, "%s: authentication failed", + ifp->name); + goto ex; + } + syslog(LOG_DEBUG, "%s: validated using 0x%08" PRIu32, + ifp->name, state->auth.token->secretid); + } else if (ifp->options->auth.options & DHCPCD_AUTH_REQUIRE) { + syslog(LOG_ERR, "%s: authentication now required", ifp->name); + goto ex; + } + + return fd; + +ex: + dhcp6_freedrop_addrs(ifp, 0, NULL); + free(state->new); + state->new = NULL; + state->new_len = 0; + unlink(state->leasefile); + return 0; +} + +static void +dhcp6_startinit(struct interface *ifp) +{ + struct dhcp6_state *state; + int r; + + state = D6_STATE(ifp); + state->state = DH6S_INIT; + state->expire = ND6_INFINITE_LIFETIME; + state->lowpl = ND6_INFINITE_LIFETIME; + if (!(options & DHCPCD_TEST) && + ifp->options->ia_type != D6_OPTION_IA_TA && + ifp->options->reboot != 0) + { + r = dhcp6_readlease(ifp); + if (r == -1) + syslog(LOG_ERR, "%s: dhcp6_readlease: %s: %m", + ifp->name, state->leasefile); + else if (r != 0) { + /* RFC 3633 section 12.1 */ + if (ifp->options->ia_type == D6_OPTION_IA_PD) + dhcp6_startrebind(ifp); + else + dhcp6_startconfirm(ifp); + return; + } + } + dhcp6_startdiscover(ifp); +} + +static uint32_t +dhcp6_findsla(void) +{ + uint32_t sla; + const struct interface *ifp; + const struct dhcp6_state *state; + + /* Slow, but finding the lowest free SLA is needed if we get a + * /62 or /63 prefix from upstream */ + for (sla = 0; sla < UINT32_MAX; sla++) { + TAILQ_FOREACH(ifp, ifaces, next) { + state = D6_CSTATE(ifp); + if (state && state->sla_set && state->sla == sla) + break; + } + if (ifp == NULL) + return sla; + } + + errno = E2BIG; + return 0; +} + +static struct ipv6_addr * +dhcp6_delegate_addr(struct interface *ifp, const struct ipv6_addr *prefix, + const struct if_sla *sla, struct interface *ifs) +{ + struct dhcp6_state *state; + struct if_sla asla; + struct in6_addr addr; + struct ipv6_addr *a, *ap, *apn; + char iabuf[INET6_ADDRSTRLEN]; + const char *ia; + + state = D6_STATE(ifp); + if (state == NULL) { + ifp->if_data[IF_DATA_DHCP6] = calloc(1, sizeof(*state)); + state = D6_STATE(ifp); + if (state == NULL) { + syslog(LOG_ERR, "%s: %m", __func__); + return NULL; + } + + TAILQ_INIT(&state->addrs); + state->state = DH6S_DELEGATED; + state->reason = "DELEGATED6"; + } + + if (sla == NULL || sla->sla_set == 0) { + if (!state->sla_set) { + errno = 0; + state->sla = dhcp6_findsla(); + if (errno) { + syslog(LOG_ERR, "%s: dhcp6_find_sla: %m", + ifp->name); + return NULL; + } + syslog(LOG_DEBUG, "%s: set SLA %d", + ifp->name, state->sla); + state->sla_set = 1; + } + asla.sla = state->sla; + asla.prefix_len = 64; + sla = &asla; + } + + if (ipv6_userprefix(&prefix->prefix, prefix->prefix_len, + sla->sla, &addr, sla->prefix_len) == -1) + { + ia = inet_ntop(AF_INET6, &prefix->prefix.s6_addr, + iabuf, sizeof(iabuf)); + syslog(LOG_ERR, "%s: invalid prefix %s/%d + %d/%d: %m", + ifp->name, ia, prefix->prefix_len, + sla->sla, sla->prefix_len); + return NULL; + } + + a = calloc(1, sizeof(*a)); + if (a == NULL) { + syslog(LOG_ERR, "%s: %m", __func__); + return NULL; + } + a->iface = ifp; + a->flags = IPV6_AF_NEW | IPV6_AF_ONLINK; + a->dadcallback = dhcp6_dadcallback; + a->delegating_iface = ifs; + memcpy(&a->iaid, &prefix->iaid, sizeof(a->iaid)); + a->prefix_pltime = prefix->prefix_pltime; + a->prefix_vltime = prefix->prefix_vltime; + memcpy(&a->prefix.s6_addr, &addr.s6_addr, sizeof(a->prefix.s6_addr)); + a->prefix_len = sla->prefix_len; + + if (ipv6_makeaddr(&a->addr, ifp, &a->prefix, a->prefix_len) == -1) + { + ia = inet_ntop(AF_INET6, &a->addr.s6_addr, + iabuf, sizeof(iabuf)); + syslog(LOG_ERR, "%s: %m (%s/%d)", __func__, ia, a->prefix_len); + free(a); + return NULL; + } + + /* Remove any exiting address */ + TAILQ_FOREACH_SAFE(ap, &state->addrs, next, apn) { + if (IN6_ARE_ADDR_EQUAL(&ap->addr, &a->addr)) { + TAILQ_REMOVE(&state->addrs, ap, next); + /* Keep our flags */ + a->flags |= ap->flags; + a->flags &= ~IPV6_AF_NEW; + free(ap); + } + } + + ia = inet_ntop(AF_INET6, &a->addr.s6_addr, iabuf, sizeof(iabuf)); + snprintf(a->saddr, sizeof(a->saddr), "%s/%d", ia, a->prefix_len); + TAILQ_INSERT_TAIL(&state->addrs, a, next); + return a; +} + +static void +dhcp6_delegate_prefix(struct interface *ifp) +{ + struct if_options *ifo; + struct dhcp6_state *state, *ifd_state; + struct ipv6_addr *ap; + size_t i, j, k; + struct if_ia *ia; + struct if_sla *sla; + struct interface *ifd; + uint8_t carrier_warned; + + ifo = ifp->options; + state = D6_STATE(ifp); + TAILQ_FOREACH(ifd, ifaces, next) { + k = 0; + carrier_warned = 0; + TAILQ_FOREACH(ap, &state->addrs, next) { + if (ap->flags & IPV6_AF_NEW) { + ap->flags &= ~IPV6_AF_NEW; + syslog(LOG_DEBUG, "%s: delegated prefix %s", + ifp->name, ap->saddr); + } + for (i = 0; i < ifo->ia_len; i++) { + ia = &ifo->ia[i]; + if (memcmp(ia->iaid, ap->iaid, + sizeof(ia->iaid))) + continue; + if (ia->sla_len == 0) { + /* no SLA configured, so lets + * automate it */ + if (ifp == ifd) + continue; + if (ifd->carrier == LINK_DOWN) { + syslog(LOG_DEBUG, + "%s: has no carrier, cannot" + " delegate addresses", + ifd->name); + carrier_warned = 1; + break; + } + if (dhcp6_delegate_addr(ifd, ap, + NULL, ifp)) + k++; + } + for (j = 0; j < ia->sla_len; j++) { + sla = &ia->sla[j]; + if (strcmp(ifd->name, sla->ifname)) + continue; + if (ifd->carrier == LINK_DOWN) { + syslog(LOG_DEBUG, + "%s: has no carrier, cannot" + " delegate addresses", + ifd->name); + carrier_warned = 1; + break; + } + if (dhcp6_delegate_addr(ifd, ap, + sla, ifp)) + k++; + } + if (carrier_warned) + break; + } + if (carrier_warned) + break; + } + if (k && !carrier_warned) { + ifd_state = D6_STATE(ifd); + ipv6nd_probeaddrs(&ifd_state->addrs); + } + } + + /* Warn about configured interfaces for delegation that do not exist */ + for (i = 0; i < ifo->ia_len; i++) { + ia = &ifo->ia[i]; + for (j = 0; j < ia->sla_len; j++) { + sla = &ia->sla[j]; + for (k = 0; k < i; j++) + if (strcmp(sla->ifname, ia->sla[j].ifname) == 0) + break; + if (j >= i && find_interface(sla->ifname) == NULL) + syslog(LOG_ERR, + "%s: interface does not exist" + " for delegation", + sla->ifname); + } + } +} + +static void +dhcp6_find_delegates1(void *arg) +{ + + dhcp6_find_delegates(arg); +} + +int +dhcp6_find_delegates(struct interface *ifp) +{ + struct if_options *ifo; + struct dhcp6_state *state; + struct ipv6_addr *ap; + size_t i, j, k; + struct if_ia *ia; + struct if_sla *sla; + struct interface *ifd; + + k = 0; + TAILQ_FOREACH(ifd, ifaces, next) { + ifo = ifd->options; + if (ifo->ia_type != D6_OPTION_IA_PD) + continue; + state = D6_STATE(ifd); + if (state == NULL || state->state != DH6S_BOUND) + continue; + TAILQ_FOREACH(ap, &state->addrs, next) { + for (i = 0; i < ifo->ia_len; i++) { + ia = &ifo->ia[i]; + if (memcmp(ia->iaid, ap->iaid, + sizeof(ia->iaid))) + continue; + for (j = 0; j < ia->sla_len; j++) { + sla = &ia->sla[j]; + if (strcmp(ifp->name, sla->ifname)) + continue; + if (ipv6_linklocal(ifp) == NULL) { + syslog(LOG_DEBUG, + "%s: delaying adding" + " delegated addresses for" + " LL address", + ifp->name); + ipv6_addlinklocalcallback(ifp, + dhcp6_find_delegates1, ifp); + return 1; + } + if (dhcp6_delegate_addr(ifp, ap, + sla, ifd)) + k++; + } + } + } + } + + if (k) { + syslog(LOG_INFO, "%s: adding delegated prefixes", ifp->name); + state = D6_STATE(ifp); + state->state = DH6S_DELEGATED; + ipv6nd_probeaddrs(&state->addrs); + ipv6_buildroutes(); + } + return k; +} + +/* ARGSUSED */ +static void +dhcp6_handledata(__unused void *arg) +{ + ssize_t len; + size_t i; + struct cmsghdr *cm; + struct in6_pktinfo pkt; + struct interface *ifp; + const char *sfrom, *op; + struct dhcp6_message *r; + struct dhcp6_state *state; + const struct dhcp6_option *o; + const struct dhcp_opt *opt; + const struct if_options *ifo; + struct ipv6_addr *ap; + uint8_t has_new; + int error; + uint32_t u32; + + len = recvmsg(sock, &rcvhdr, 0); + if (len == -1) { + syslog(LOG_ERR, "recvmsg: %m"); + return; + } + sfrom = inet_ntop(AF_INET6, &from.sin6_addr, + ntopbuf, INET6_ADDRSTRLEN); + if ((size_t)len < sizeof(struct dhcp6_message)) { + syslog(LOG_ERR, "DHCPv6 RA packet too short from %s", sfrom); + return; + } + + pkt.ipi6_ifindex = 0; + for (cm = (struct cmsghdr *)CMSG_FIRSTHDR(&rcvhdr); + cm; + cm = (struct cmsghdr *)CMSG_NXTHDR(&rcvhdr, cm)) + { + if (cm->cmsg_level != IPPROTO_IPV6) + continue; + switch(cm->cmsg_type) { + case IPV6_PKTINFO: + if (cm->cmsg_len == CMSG_LEN(sizeof(pkt))) + memcpy(&pkt, CMSG_DATA(cm), sizeof(pkt)); + break; + } + } + + if (pkt.ipi6_ifindex == 0) { + syslog(LOG_ERR, + "DHCPv6 reply did not contain index from %s", + sfrom); + return; + } + + TAILQ_FOREACH(ifp, ifaces, next) { + if (ifp->index == (unsigned int)pkt.ipi6_ifindex) + break; + } + if (ifp == NULL) { + syslog(LOG_DEBUG, + "DHCPv6 reply for unexpected interface from %s", sfrom); + return; + } + state = D6_STATE(ifp); + if (state == NULL || state->send == NULL) { + syslog(LOG_DEBUG, "%s: DHCPv6 reply received but not running", + ifp->name); + return; + } + /* We're already bound and this message is for another machine */ + /* XXX DELEGATED? */ + if (state->state == DH6S_BOUND || + state->state == DH6S_INFORMED) + return; + + r = (struct dhcp6_message *)rcvhdr.msg_iov[0].iov_base; + if (r->xid[0] != state->send->xid[0] || + r->xid[1] != state->send->xid[1] || + r->xid[2] != state->send->xid[2]) + { + syslog(LOG_DEBUG, + "%s: wrong xid 0x%02x%02x%02x" + " (expecting 0x%02x%02x%02x) from %s", + ifp->name, + r->xid[0], r->xid[1], r->xid[2], + state->send->xid[0], state->send->xid[1], + state->send->xid[2], + sfrom); + return; + } + + if (dhcp6_getmoption(D6_OPTION_SERVERID, r, len) == NULL) { + syslog(LOG_DEBUG, "%s: no DHCPv6 server ID from %s", + ifp->name, sfrom); + return; + } + + o = dhcp6_getmoption(D6_OPTION_CLIENTID, r, len); + if (o == NULL || ntohs(o->len) != duid_len || + memcmp(D6_COPTION_DATA(o), duid, duid_len) != 0) + { + syslog(LOG_DEBUG, "%s: incorrect client ID from %s", + ifp->name, sfrom); + return; + } + + ifo = ifp->options; + for (i = 0, opt = dhcp6_opts; i < dhcp6_opts_len; i++, opt++) { + if (has_option_mask(ifo->requiremask6, opt->option) && + dhcp6_getmoption(opt->option, r, len) == NULL) + { + syslog(LOG_WARNING, + "%s: reject DHCPv6 (no option %s) from %s", + ifp->name, opt->var, sfrom); + return; + } + } + + /* Authenticate the message */ + o = dhcp6_getmoption(D6_OPTION_AUTH, r, len); + if (o) { + if (dhcp_auth_validate(&state->auth, &ifo->auth, + (uint8_t *)r, len, 6, r->type, + D6_COPTION_DATA(o), ntohs(o->len)) == NULL) + { + syslog(LOG_DEBUG, "dhcp_auth_validate: %m"); + syslog(LOG_ERR, "%s: authentication failed from %s", + ifp->name, sfrom); + return; + } + syslog(LOG_DEBUG, "%s: validated using 0x%08" PRIu32, + ifp->name, state->auth.token->secretid); + } else if (ifo->auth.options & DHCPCD_AUTH_REQUIRE) { + syslog(LOG_ERR, "%s: missing authentiation from %s", + ifp->name, sfrom); + return; + } else if (ifo->auth.options & DHCPCD_AUTH_SEND) + syslog(LOG_WARNING, + "%s: missing authentiation from %s", + ifp->name, sfrom); + + op = dhcp6_get_op(r->type); + switch(r->type) { + case DHCP6_REPLY: + switch(state->state) { + case DH6S_INFORM: + /* RFC4242 */ + o = dhcp6_getmoption(D6_OPTION_INFO_REFRESH_TIME, + r, len); + if (o == NULL || ntohs(o->len) != sizeof(u32)) + state->renew = IRT_DEFAULT; + else { + memcpy(&u32, D6_COPTION_DATA(o), sizeof(u32)); + state->renew = ntohl(u32); + if (state->renew < IRT_MINIMUM) + state->renew = IRT_MINIMUM; + } + break; + case DH6S_CONFIRM: + error = dhcp6_checkstatusok(ifp, r, NULL, len); + /* If we got an OK status the chances are that we + * didn't get the IA's returned, so preserve them + * from our saved response */ + if (error == 1) + goto recv; + if (error == -1 || + dhcp6_validatelease(ifp, r, len, sfrom) == -1) { + dhcp6_startdiscover(ifp); + return; + } + break; + case DH6S_DISCOVER: + if (has_option_mask(ifo->requestmask6, + D6_OPTION_RAPID_COMMIT) && + dhcp6_getmoption(D6_OPTION_RAPID_COMMIT, r, len)) + state->state = DH6S_REQUEST; + else + op = NULL; + case DH6S_REQUEST: /* FALLTHROUGH */ + case DH6S_RENEW: /* FALLTHROUGH */ + case DH6S_REBIND: + if (dhcp6_validatelease(ifp, r, len, sfrom) == -1) { + /* PD doesn't use CONFIRM, so REBIND could + * throw up an invalid prefix if we + * changed link */ + if (ifp->options->ia_type == D6_OPTION_IA_PD) + dhcp6_startdiscover(ifp); + return; + } + break; + default: + op = NULL; + } + break; + case DHCP6_ADVERTISE: + if (state->state != DH6S_DISCOVER) { + op = NULL; + break; + } + if (dhcp6_validatelease(ifp, r, len, sfrom) == -1) + return; + break; + default: + syslog(LOG_ERR, "%s: invalid DHCP6 type %s (%d)", + ifp->name, op, r->type); + return; + } + if (op == NULL) { + syslog(LOG_WARNING, "%s: invalid state for DHCP6 type %s (%d)", + ifp->name, op, r->type); + return; + } + + if (state->recv_len < (size_t)len) { + free(state->recv); + state->recv = malloc(len); + if (state->recv == NULL) { + syslog(LOG_ERR, "%s: malloc recv: %m", ifp->name); + return; + } + } + memcpy(state->recv, r, len); + state->recv_len = len; + + switch(r->type) { + case DHCP6_ADVERTISE: + if (state->state == DH6S_REQUEST) /* rapid commit */ + break; + ap = TAILQ_FIRST(&state->addrs); + syslog(LOG_INFO, "%s: ADV %s from %s", + ifp->name, ap->saddr, sfrom); + if (options & DHCPCD_TEST) + break; + dhcp6_startrequest(ifp); + return; + } + +recv: + has_new = 0; + TAILQ_FOREACH(ap, &state->addrs, next) { + if (ap->flags & IPV6_AF_NEW) { + has_new = 1; + break; + } + } + syslog(has_new ? LOG_INFO : LOG_DEBUG, + "%s: %s received from %s", ifp->name, op, sfrom); + + state->reason = NULL; + eloop_timeout_delete(NULL, ifp); + switch(state->state) { + case DH6S_INFORM: + state->rebind = 0; + state->expire = ND6_INFINITE_LIFETIME; + state->lowpl = ND6_INFINITE_LIFETIME; + state->reason = "INFORM6"; + break; + case DH6S_REQUEST: + if (state->reason == NULL) + state->reason = "BOUND6"; + /* FALLTHROUGH */ + case DH6S_RENEW: + if (state->reason == NULL) + state->reason = "RENEW6"; + /* FALLTHROUGH */ + case DH6S_REBIND: + if (state->reason == NULL) + state->reason = "REBIND6"; + /* FALLTHROUGH */ + case DH6S_CONFIRM: + if (state->reason == NULL) + state->reason = "REBOOT6"; + if (state->renew == 0) { + if (state->expire == ND6_INFINITE_LIFETIME) + state->renew = ND6_INFINITE_LIFETIME; + else + state->renew = state->lowpl * 0.5; + } + if (state->rebind == 0) { + if (state->expire == ND6_INFINITE_LIFETIME) + state->rebind = ND6_INFINITE_LIFETIME; + else + state->rebind = state->lowpl * 0.8; + } + break; + default: + state->reason = "UNKNOWN6"; + break; + } + + if (state->state != DH6S_CONFIRM) { + free(state->old); + state->old = state->new; + state->old_len = state->new_len; + state->new = state->recv; + state->new_len = state->recv_len; + state->recv = NULL; + state->recv_len = 0; + } + + if (options & DHCPCD_TEST) + script_runreason(ifp, "TEST"); + else { + if (state->state == DH6S_INFORM) + state->state = DH6S_INFORMED; + else + state->state = DH6S_BOUND; + if (state->renew && state->renew != ND6_INFINITE_LIFETIME) + eloop_timeout_add_sec(state->renew, + state->state == DH6S_INFORMED ? + dhcp6_startinform : dhcp6_startrenew, ifp); + if (state->rebind && state->rebind != ND6_INFINITE_LIFETIME) + eloop_timeout_add_sec(state->rebind, + dhcp6_startrebind, ifp); + if (state->expire && state->expire != ND6_INFINITE_LIFETIME) + eloop_timeout_add_sec(state->expire, + dhcp6_startexpire, ifp); + if (ifp->options->ia_type == D6_OPTION_IA_PD) + dhcp6_delegate_prefix(ifp); + ipv6nd_probeaddrs(&state->addrs); + if (state->state == DH6S_INFORMED) + syslog(has_new ? LOG_INFO : LOG_DEBUG, + "%s: refresh in %"PRIu32" seconds", + ifp->name, state->renew); + else if (state->renew || state->rebind) + syslog(has_new ? LOG_INFO : LOG_DEBUG, + "%s: renew in %"PRIu32" seconds," + " rebind in %"PRIu32" seconds", + ifp->name, state->renew, state->rebind); + ipv6_buildroutes(); + dhcp6_writelease(ifp); + + len = 1; + /* If all addresses have completed DAD run the script */ + TAILQ_FOREACH(ap, &state->addrs, next) { + if (ap->flags & IPV6_AF_ONLINK) { + if (!(ap->flags & IPV6_AF_DADCOMPLETED) && + ipv6_findaddr(ap->iface, &ap->addr)) + ap->flags |= IPV6_AF_DADCOMPLETED; + if ((ap->flags & IPV6_AF_DADCOMPLETED) == 0) { + len = 0; + break; + } + } + } + if (len) { + script_runreason(ifp, state->reason); + daemonise(); + } else + syslog(LOG_DEBUG, + "%s: waiting for DHCPv6 DAD to complete", + ifp->name); + } + + if (options & DHCPCD_TEST || + (ifp->options->options & DHCPCD_INFORM && + !(options & DHCPCD_MASTER))) + { +#ifdef DEBUG_MEMORY + dhcp6_free(ifp); +#endif + exit(EXIT_SUCCESS); + } +} + +static int +dhcp6_open(void) +{ + struct sockaddr_in6 sa; + int n; + + if (sndbuf == NULL && dhcp6_init() == -1) + return -1; + + memset(&sa, 0, sizeof(sa)); + sa.sin6_family = AF_INET6; + sa.sin6_port = htons(DHCP6_CLIENT_PORT); +#ifdef BSD + sa.sin6_len = sizeof(sa); +#endif + + sock = socket(PF_INET6, SOCK_DGRAM, IPPROTO_UDP); + if (sock == -1) + return -1; + + n = 1; + if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, + &n, sizeof(n)) == -1) + goto errexit; + + n = 1; + if (setsockopt(sock, SOL_SOCKET, SO_BROADCAST, + &n, sizeof(n)) == -1) + goto errexit; + +#ifdef SO_REUSEPORT + n = 1; + if (setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, + &n, sizeof(n)) == -1) + goto errexit; +#endif + + if (bind(sock, (struct sockaddr *)&sa, sizeof(sa)) == -1) + goto errexit; + + n = 1; + if (setsockopt(sock, IPPROTO_IPV6, IPV6_RECVPKTINFO, + &n, sizeof(n)) == -1) + goto errexit; + + if (set_cloexec(sock) == -1 || set_nonblock(sock) == -1) + goto errexit; + + eloop_event_add(sock, dhcp6_handledata, NULL); + + return 0; + +errexit: + close(sock); + return -1; +} + +static void +dhcp6_start1(void *arg) +{ + struct interface *ifp = arg; + struct if_options *ifo = ifp->options; + struct dhcp6_state *state; + size_t i; + const struct dhcp_compat *dhc; + + state = D6_STATE(ifp); + /* Match any DHCPv4 opton to DHCPv6 options if given for easy + * configuration */ + for (i = 0; i < sizeof(ifo->requestmask6); i++) { + if (ifo->requestmask6[i] != '\0') + break; + } + if (i == sizeof(ifo->requestmask6)) { + for (dhc = dhcp_compats; dhc->dhcp_opt; dhc++) { + if (has_option_mask(ifo->requestmask, dhc->dhcp_opt)) + add_option_mask(ifo->requestmask6, + dhc->dhcp6_opt); + } + if (ifo->fqdn != FQDN_DISABLE || + ifo->options & DHCPCD_HOSTNAME) + add_option_mask(ifo->requestmask6, D6_OPTION_FQDN); + } + + if (state->state == DH6S_INFORM) { + add_option_mask(ifo->requestmask6, D6_OPTION_INFO_REFRESH_TIME); + dhcp6_startinform(ifp); + } else { + del_option_mask(ifo->requestmask6, D6_OPTION_INFO_REFRESH_TIME); + dhcp6_startinit(ifp); + } +} + +int +dhcp6_start(struct interface *ifp, enum DH6S init_state) +{ + struct dhcp6_state *state; + + state = D6_STATE(ifp); + if (state) { + if (state->state == DH6S_DELEGATED) { + dhcp6_find_delegates(ifp); + return 0; + } + if (state->state == DH6S_INFORMED && + init_state == DH6S_INFORM) + { + dhcp6_startinform(ifp); + return 0; + } + /* We're already running DHCP6 */ + /* XXX: What if the managed flag changes? */ + return 0; + } + + if (!(ifp->options->options & DHCPCD_DHCP6)) + return 0; + + if (sock == -1 && dhcp6_open() == -1) + return -1; + + ifp->if_data[IF_DATA_DHCP6] = calloc(1, sizeof(*state)); + state = D6_STATE(ifp); + if (state == NULL) + return -1; + + TAILQ_INIT(&state->addrs); + if (dhcp6_find_delegates(ifp)) + return 0; + + state->state = init_state; + snprintf(state->leasefile, sizeof(state->leasefile), + LEASEFILE6, ifp->name); + + if (ipv6_linklocal(ifp) == NULL) { + syslog(LOG_DEBUG, + "%s: delaying DHCPv6 soliciation for LL address", + ifp->name); + ipv6_addlinklocalcallback(ifp, dhcp6_start1, ifp); + return 0; + } + + dhcp6_start1(ifp); + return 0; +} + +void +dhcp6_reboot(struct interface *ifp) +{ + struct dhcp6_state *state; + + state = D6_STATE(ifp); + if (state) { + switch (state->state) { + case DH6S_BOUND: + dhcp6_startrebind(ifp); + break; + case DH6S_INFORMED: + dhcp6_startinform(ifp); + break; + default: + dhcp6_startdiscover(ifp); + break; + } + } +} + +static void +dhcp6_freedrop(struct interface *ifp, int drop, const char *reason) +{ + struct dhcp6_state *state; + + eloop_timeout_delete(NULL, ifp); + + /* + * As the interface is going away from dhcpcd we need to + * remove the delegated addresses, otherwise we lose track + * of which interface is delegating as we remeber it by pointer. + * So if we need to change this behaviour, we need to change + * how we remember which interface delegated. + * To make it more interesting, on some OS's with PPP links + * there is no guarantee the delegating interface will have + * the same name or index so think very hard before changing + * this. + */ + if (ifp->options && + ifp->options->options & (DHCPCD_STOPPING | DHCPCD_RELEASE) && + (ifp->options->options & (DHCPCD_EXITING | DHCPCD_PERSISTENT)) != + (DHCPCD_EXITING | DHCPCD_PERSISTENT)) + dhcp6_delete_delegates(ifp); + + state = D6_STATE(ifp); + if (state) { + if (ifp->options->options & DHCPCD_RELEASE) { + if (ifp->carrier != LINK_DOWN) + dhcp6_startrelease(ifp); + unlink(state->leasefile); + } + dhcp6_freedrop_addrs(ifp, drop, NULL); + if (drop && state->new && + (ifp->options->options & + (DHCPCD_EXITING | DHCPCD_PERSISTENT)) != + (DHCPCD_EXITING | DHCPCD_PERSISTENT)) + { + if (reason == NULL) + reason = "STOP6"; + script_runreason(ifp, reason); + } + free(state->send); + free(state->recv); + free(state->new); + free(state->old); + free(state->auth.reconf); + free(state); + ifp->if_data[IF_DATA_DHCP6] = NULL; + } + + /* If we don't have any more DHCP6 enabled interfaces, + * close the global socket */ + if (ifaces) { + TAILQ_FOREACH(ifp, ifaces, next) { + if (D6_STATE(ifp)) + break; + } + } + if (ifp == NULL && sock != -1) { + close(sock); + eloop_event_delete(sock); + sock = -1; + } +} + +void +dhcp6_drop(struct interface *ifp, const char *reason) +{ + + dhcp6_freedrop(ifp, 1, reason); +} + +void +dhcp6_free(struct interface *ifp) +{ + + dhcp6_freedrop(ifp, 0, NULL); +} + +void +dhcp6_handleifa(int cmd, const char *ifname, + const struct in6_addr *addr, int flags) +{ + struct interface *ifp; + struct dhcp6_state *state; + + if (ifaces == NULL) + return; + + TAILQ_FOREACH(ifp, ifaces, next) { + state = D6_STATE(ifp); + if (state == NULL || strcmp(ifp->name, ifname)) + continue; + ipv6_handleifa_addrs(cmd, &state->addrs, addr, flags); + } + +} + +ssize_t +dhcp6_env(char **env, const char *prefix, const struct interface *ifp, + const struct dhcp6_message *m, ssize_t len) +{ + const struct dhcp6_state *state; + const struct if_options *ifo; + struct dhcp_opt *opt, *vo; + const struct dhcp6_option *o; + size_t i, n; + uint16_t ol, oc; + char *v, *val, *pfx; + const struct ipv6_addr *ap; + uint32_t en; + + state = D6_CSTATE(ifp); + n = 0; + ifo = ifp->options; + + /* Zero our indexes */ + if (env) { + for (i = 0, opt = dhcp6_opts; i < dhcp6_opts_len; i++, opt++) + dhcp_zero_index(opt); + for (i = 0, opt = ifp->options->dhcp6_override; + i < ifp->options->dhcp6_override_len; + i++, opt++) + dhcp_zero_index(opt); + for (i = 0, opt = vivso; i < vivso_len; i++, opt++) + dhcp_zero_index(opt); + i = strlen(prefix) + strlen("_dhcp6") + 1; + pfx = malloc(i); + if (pfx == NULL) { + syslog(LOG_ERR, "%s: %m", __func__); + return 0; + } + snprintf(pfx, i, "%s_dhcp6", prefix); + } else + pfx = NULL; + + /* Unlike DHCP, DHCPv6 options *may* occur more than once. + * There is also no provision for option concatenation unlike DHCP. */ + for (o = D6_CFIRST_OPTION(m); + len > (ssize_t)sizeof(*o); + o = D6_CNEXT_OPTION(o)) + { + ol = ntohs(o->len); + len -= sizeof(*o) + ol; + if (len < 0) { + errno = EINVAL; + break; + } + oc = ntohs(o->code); + if (has_option_mask(ifo->nomask6, oc)) + continue; + for (i = 0, opt = ifo->dhcp6_override; + i < ifo->dhcp6_override_len; + i++, opt++) + if (opt->option == oc) + break; + if (i == ifo->dhcp6_override_len && + oc == D6_OPTION_VENDOR_OPTS && + ol > sizeof(en)) + { + memcpy(&en, D6_COPTION_DATA(o), sizeof(en)); + en = ntohl(en); + vo = vivso_find(en, ifp); + } else + vo = NULL; + if (i == ifo->dhcp6_override_len) { + for (i = 0, opt = dhcp6_opts; + i < dhcp6_opts_len; + i++, opt++) + if (opt->option == oc) + break; + if (i == dhcp6_opts_len) + opt = NULL; + } + if (opt) { + n += dhcp_envoption(env == NULL ? NULL : &env[n], + pfx, ifp->name, + opt, dhcp6_getoption, D6_COPTION_DATA(o), ol); + } + if (vo) { + n += dhcp_envoption(env == NULL ? NULL : &env[n], + pfx, ifp->name, + vo, dhcp6_getoption, + D6_COPTION_DATA(o) + sizeof(en), + ol - sizeof(en)); + } + } + free(pfx); + + /* It is tempting to remove this section. + * However, we need it at least for Delegated Prefixes + * (they don't have a DHCPv6 message to parse to get the addressses) + * and it's easier for shell scripts to see which addresses have + * been added */ + if (TAILQ_FIRST(&state->addrs)) { + if (env) { + if (ifo->ia_type == D6_OPTION_IA_PD) { + i = strlen(prefix) + + strlen("_dhcp6_prefix="); + TAILQ_FOREACH(ap, &state->addrs, next) { + i += strlen(ap->saddr) + 1; + } + v = val = env[n] = malloc(i); + if (v == NULL) { + syslog(LOG_ERR, "%s: %m", __func__); + return -1; + } + v += snprintf(val, i, "%s_dhcp6_prefix=", + prefix); + TAILQ_FOREACH(ap, &state->addrs, next) { + strcpy(v, ap->saddr); + v += strlen(ap->saddr); + *v++ = ' '; + } + *--v = '\0'; + } else { + i = strlen(prefix) + + strlen("_dhcp6_ip_address="); + TAILQ_FOREACH(ap, &state->addrs, next) { + i += strlen(ap->saddr) + 1; + } + v = val = env[n] = malloc(i); + if (v == NULL) { + syslog(LOG_ERR, "%s: %m", __func__); + return -1; + } + v += snprintf(val, i, "%s_dhcp6_ip_address=", + prefix); + TAILQ_FOREACH(ap, &state->addrs, next) { + strcpy(v, ap->saddr); + v += strlen(ap->saddr); + *v++ = ' '; + } + *--v = '\0'; + } + } + n++; + } + + return n; +} |