/* * dhcpcd - DHCP client daemon * Copyright (c) 2006-2014 Roy Marples * 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 */ #ifdef __rtems__ #include #endif /* __rtems__ */ #if defined(__rtems__) && defined(INET6) #include #include #include #ifdef __linux__ # define _LINUX_IN6_H # include #endif #include #include #include #include #include #include #include #include #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; } #endif /* defined(__rtems__) && defined(INET6) */