X-Git-Url: http://git.archive.openwrt.org/?p=project%2Fodhcpd.git;a=blobdiff_plain;f=src%2Fdhcpv6-ia.c;h=3a12114544e780e4f783849731b106deae663097;hp=ccf7a58e6861fb6a1f8b219019ce4824cf848fc7;hb=ec3320078c11474b8ea48225f330c15d9471e312;hpb=436f29d4d6acda4b95fc72a654a81fd8986e002b diff --git a/src/dhcpv6-ia.c b/src/dhcpv6-ia.c index ccf7a58..3a12114 100644 --- a/src/dhcpv6-ia.c +++ b/src/dhcpv6-ia.c @@ -15,16 +15,21 @@ #include "odhcpd.h" #include "dhcpv6.h" #include "dhcpv4.h" -#include "md5.h" +#include "libubox/md5.h" +#include "libubox/usock.h" #include #include #include +#include +#include #include #include #include #include +#include #include +#include #include #include @@ -32,26 +37,41 @@ static void update(struct interface *iface); static void reconf_timer(struct uloop_timeout *event); static struct uloop_timeout reconf_event = {.cb = reconf_timer}; -static int socket_fd = -1; static uint32_t serial = 0; +static uint8_t statemd5[16]; -int dhcpv6_ia_init(int dhcpv6_socket) +int dhcpv6_ia_init(void) { - socket_fd = dhcpv6_socket; uloop_timeout_set(&reconf_event, 2000); return 0; } +void free_dhcpv6_assignment(struct dhcpv6_assignment *c) +{ + if (c->managed_sock.fd.registered) { + ustream_free(&c->managed_sock.stream); + close(c->managed_sock.fd.fd); + } + + if (c->head.next) + list_del(&c->head); + + free(c->managed); + free(c->hostname); + free(c->classes); + free(c); +} + + int setup_dhcpv6_ia_interface(struct interface *iface, bool enable) { if (!enable && iface->ia_assignments.next) { struct dhcpv6_assignment *c; while (!list_empty(&iface->ia_assignments)) { c = list_first_entry(&iface->ia_assignments, struct dhcpv6_assignment, head); - list_del(&c->head); - free(c); + free_dhcpv6_assignment(c); } } @@ -61,6 +81,11 @@ int setup_dhcpv6_ia_interface(struct interface *iface, bool enable) if (list_empty(&iface->ia_assignments)) { struct dhcpv6_assignment *border = calloc(1, sizeof(*border)); + if (!border) { + syslog(LOG_ERR, "Calloc failed for border on interface %s", iface->ifname); + return -1; + } + border->length = 64; list_add(&border->head, &iface->ia_assignments); } @@ -72,9 +97,20 @@ int setup_dhcpv6_ia_interface(struct interface *iface, bool enable) list_for_each_entry(lease, &leases, head) { // Construct entry struct dhcpv6_assignment *a = calloc(1, sizeof(*a) + lease->duid_len); + if (!a) { + syslog(LOG_ERR, "Calloc failed for static lease assignment on interface %s", + iface->ifname); + return -1; + } + a->clid_len = lease->duid_len; a->length = 128; - a->assigned = lease->hostid; + if (lease->hostid) { + a->assigned = lease->hostid; + } else { + uint32_t i4a = ntohl(lease->ipaddr.s_addr) & 0xff; + a->assigned = ((i4a / 100) << 8) | (((i4a % 100) / 10) << 4) | (i4a % 10); + } odhcpd_urandom(a->key, sizeof(a->key)); memcpy(a->clid_data, lease->duid, a->clid_len); memcpy(a->mac, lease->mac.ether_addr_octet, sizeof(a->mac)); @@ -84,6 +120,7 @@ int setup_dhcpv6_ia_interface(struct interface *iface, bool enable) list_for_each_entry(c, &iface->ia_assignments, head) { if (c->length != 128 || c->assigned > a->assigned) { list_add_tail(&a->head, &c->head); + break; } else if (c->assigned == a->assigned) { // Already an assignment with that number break; @@ -96,6 +133,8 @@ int setup_dhcpv6_ia_interface(struct interface *iface, bool enable) a->hostname = strdup(lease->hostname); } } else { + free(a->classes); + free(a->hostname); free(a); } } @@ -142,8 +181,9 @@ static int send_reconf(struct interface *iface, struct dhcpv6_assignment *assign struct iovec iov = {&reconf_msg, sizeof(reconf_msg) - 128 + assign->clid_len}; md5_ctx_t md5; - uint8_t secretbytes[16]; - memcpy(secretbytes, assign->key, sizeof(secretbytes)); + uint8_t secretbytes[64]; + memset(secretbytes, 0, sizeof(secretbytes)); + memcpy(secretbytes, assign->key, sizeof(assign->key)); for (size_t i = 0; i < sizeof(secretbytes); ++i) secretbytes[i] ^= 0x36; @@ -163,12 +203,15 @@ static int send_reconf(struct interface *iface, struct dhcpv6_assignment *assign md5_hash(reconf_msg.auth.key, 16, &md5); md5_end(reconf_msg.auth.key, &md5); - return odhcpd_send(socket_fd, &assign->peer, &iov, 1, iface); + return odhcpd_send(iface->dhcpv6_event.uloop.fd, &assign->peer, &iov, 1, iface); } void dhcpv6_write_statefile(void) { + md5_ctx_t md5; + md5_begin(&md5); + if (config.dhcp_statefile) { time_t now = odhcpd_time(), wall_time = time(NULL); int fd = open(config.dhcp_statefile, O_CREAT | O_WRONLY | O_CLOEXEC, 0644); @@ -189,10 +232,10 @@ void dhcpv6_write_statefile(void) if (iface->dhcpv6 != RELAYD_SERVER && iface->dhcpv4 != RELAYD_SERVER) continue; - if (iface->dhcpv6 == RELAYD_SERVER) { + if (iface->dhcpv6 == RELAYD_SERVER && iface->ia_assignments.next) { struct dhcpv6_assignment *c; list_for_each_entry(c, &iface->ia_assignments, head) { - if (c->clid_len == 0) + if (c->clid_len == 0 || c->managed_size < 0) continue; char ipbuf[INET6_ADDRSTRLEN]; @@ -209,28 +252,43 @@ void dhcpv6_write_statefile(void) c->assigned, (unsigned)c->length); struct in6_addr addr; - for (size_t i = 0; i < iface->ia_addr_len; ++i) { - if (iface->ia_addr[i].prefix > 64) + struct odhcpd_ipaddr *addrs = (c->managed) ? c->managed : iface->ia_addr; + size_t addrlen = (c->managed) ? (size_t)c->managed_size : iface->ia_addr_len; + + for (size_t i = 0; i < addrlen; ++i) { + if (addrs[i].prefix > 96) continue; - addr = iface->ia_addr[i].addr; + addr = addrs[i].addr; if (c->length == 128) addr.s6_addr32[3] = htonl(c->assigned); else addr.s6_addr32[1] |= htonl(c->assigned); + inet_ntop(AF_INET6, &addr, ipbuf, sizeof(ipbuf) - 1); - if (c->length == 128 && c->hostname && i == 0) - fprintf(fp, "%s\t%s\n", ipbuf, c->hostname); + if (c->length == 128 && c->hostname && i == 0) { + fputs(ipbuf, fp); - l += snprintf(leasebuf + l, sizeof(leasebuf) - l, "%s/%hhu ", ipbuf, c->length); + char b[256]; + if (dn_expand(iface->search, iface->search + iface->search_len, + iface->search, b, sizeof(b)) > 0) + fprintf(fp, "\t%s.%s", c->hostname, b); + + fprintf(fp, "\t%s\n", c->hostname); + md5_hash(ipbuf, strlen(ipbuf), &md5); + md5_hash(c->hostname, strlen(c->hostname), &md5); + } + + l += snprintf(leasebuf + l, sizeof(leasebuf) - l, "%s/%d ", ipbuf, + (c->managed_size) ? addrs[i].prefix : c->length); } leasebuf[l - 1] = '\n'; fwrite(leasebuf, 1, l, fp); } } - if (iface->dhcpv4 == RELAYD_SERVER) { + if (iface->dhcpv4 == RELAYD_SERVER && iface->dhcpv4_assignments.next) { struct dhcpv4_assignment *c; list_for_each_entry(c, &iface->dhcpv4_assignments, head) { char ipbuf[INET6_ADDRSTRLEN]; @@ -249,8 +307,18 @@ void dhcpv6_write_statefile(void) struct in_addr addr = {htonl(c->addr)}; inet_ntop(AF_INET, &addr, ipbuf, sizeof(ipbuf) - 1); - if (c->hostname[0]) - fprintf(fp, "%s\t%s\n", ipbuf, c->hostname); + if (c->hostname[0]) { + fputs(ipbuf, fp); + + char b[256]; + if (dn_expand(iface->search, iface->search + iface->search_len, + iface->search, b, sizeof(b)) > 0) + fprintf(fp, "\t%s.%s", c->hostname, b); + + fprintf(fp, "\t%s\n", c->hostname); + md5_hash(ipbuf, strlen(ipbuf), &md5); + md5_hash(c->hostname, strlen(c->hostname), &md5); + } l += snprintf(leasebuf + l, sizeof(leasebuf) - l, "%s/32 ", ipbuf); leasebuf[l - 1] = '\n'; @@ -262,7 +330,11 @@ void dhcpv6_write_statefile(void) fclose(fp); } - if (config.dhcp_cb) { + uint8_t newmd5[16]; + md5_end(newmd5, &md5); + + if (config.dhcp_cb && memcmp(newmd5, statemd5, sizeof(newmd5))) { + memcpy(statemd5, newmd5, sizeof(statemd5)); char *argv[2] = {config.dhcp_cb, NULL}; if (!vfork()) { execv(argv[0], argv); @@ -274,28 +346,145 @@ void dhcpv6_write_statefile(void) static void apply_lease(struct interface *iface, struct dhcpv6_assignment *a, bool add) { - if (a->length > 64) + if (a->length > 64 || a->managed_size < 0) return; - for (size_t i = 0; i < iface->ia_addr_len; ++i) { - struct in6_addr prefix = iface->ia_addr[i].addr; + struct odhcpd_ipaddr *addrs = (a->managed) ? a->managed : iface->ia_addr; + size_t addrlen = (a->managed) ? (size_t)a->managed_size : iface->ia_addr_len; + + for (size_t i = 0; i < addrlen; ++i) { + struct in6_addr prefix = addrs[i].addr; prefix.s6_addr32[1] |= htonl(a->assigned); - odhcpd_setup_route(&prefix, a->length, iface, &a->peer.sin6_addr, add); + odhcpd_setup_route(&prefix, (a->managed_size) ? addrs[i].prefix : a->length, + iface, &a->peer.sin6_addr, add); } } +// More data was received from TCP connection +static void managed_handle_pd_data(struct ustream *s, _unused int bytes_new) +{ + struct dhcpv6_assignment *c = container_of(s, struct dhcpv6_assignment, managed_sock); + time_t now = odhcpd_time(); + bool first = c->managed_size < 0; + + for (;;) { + int pending; + char *data = ustream_get_read_buf(s, &pending); + char *end = memmem(data, pending, "\n\n", 2); + + if (!end) + break; + + end += 2; + end[-1] = 0; + + c->managed_size = 0; + if (c->accept_reconf) + c->reconf_cnt = 1; + + char *saveptr; + for (char *line = strtok_r(data, "\n", &saveptr); line; line = strtok_r(NULL, "\n", &saveptr)) { + c->managed = realloc(c->managed, (c->managed_size + 1) * sizeof(*c->managed)); + struct odhcpd_ipaddr *n = &c->managed[c->managed_size]; + + char *saveptr2, *x = strtok_r(line, "/", &saveptr2); + if (!x || inet_pton(AF_INET6, x, &n->addr) < 1) + continue; + + x = strtok_r(NULL, ",", &saveptr2); + if (sscanf(x, "%hhu", &n->prefix) < 1) + continue; + + x = strtok_r(NULL, ",", &saveptr2); + if (sscanf(x, "%u", &n->preferred) < 1) + continue; + + x = strtok_r(NULL, ",", &saveptr2); + if (sscanf(x, "%u", &n->valid) < 1) + continue; + + if (n->preferred > n->valid) + continue; + + if (UINT32_MAX - now < n->preferred) + n->preferred = UINT32_MAX; + else + n->preferred += now; + + if (UINT32_MAX - now < n->valid) + n->valid = UINT32_MAX; + else + n->valid += now; + + n->has_class = false; + n->class = 0; + n->dprefix = 0; + + ++c->managed_size; + } + + ustream_consume(s, end - data); + } + + if (first && c->managed_size == 0) + free_dhcpv6_assignment(c); + else if (first) + c->valid_until = now + 150; +} + + +// TCP transmission has ended, either because of success or timeout or other error +static void managed_handle_pd_done(struct ustream *s) +{ + struct dhcpv6_assignment *c = container_of(s, struct dhcpv6_assignment, managed_sock); + c->valid_until = odhcpd_time() + 15; + c->managed_size = 0; + if (c->accept_reconf) + c->reconf_cnt = 1; +} + + + static bool assign_pd(struct interface *iface, struct dhcpv6_assignment *assign) { struct dhcpv6_assignment *c; - if (iface->ia_addr_len < 1) + + if (iface->dhcpv6_pd_manager[0]) { + int fd = usock(USOCK_UNIX | USOCK_TCP, iface->dhcpv6_pd_manager, NULL); + if (fd >= 0) { + char iaidbuf[298]; + odhcpd_hexlify(iaidbuf, assign->clid_data, assign->clid_len); + + assign->managed_sock.stream.notify_read = managed_handle_pd_data; + assign->managed_sock.stream.notify_state = managed_handle_pd_done; + ustream_fd_init(&assign->managed_sock, fd); + ustream_printf(&assign->managed_sock.stream, "%s,%x\n::/%d,0,0\n\n", + iaidbuf, assign->iaid, assign->length); + ustream_write_pending(&assign->managed_sock.stream); + assign->managed_size = -1; + assign->valid_until = odhcpd_time() + 15; + list_add(&assign->head, &iface->ia_assignments); + + // Wait initial period of up to 250ms for immediate assignment + struct pollfd pfd = { .fd = fd, .events = POLLIN }; + poll(&pfd, 1, 250); + managed_handle_pd_data(&assign->managed_sock.stream, 0); + + if (fcntl(fd, F_GETFL) >= 0 && assign->managed_size > 0) + return true; + } + + return false; + } else if (iface->ia_addr_len < 1) { return false; + } // Try honoring the hint first uint32_t current = 1, asize = (1 << (64 - assign->length)) - 1; if (assign->assigned) { list_for_each_entry(c, &iface->ia_assignments, head) { - if (c->length == 128) + if (c->length == 128 || c->length == 0) continue; if (assign->assigned >= current && assign->assigned + asize < c->assigned) { @@ -312,7 +501,7 @@ static bool assign_pd(struct interface *iface, struct dhcpv6_assignment *assign) // Fallback to a variable assignment current = 1; list_for_each_entry(c, &iface->ia_assignments, head) { - if (c->length == 128) + if (c->length == 128 || c->length == 0) continue; current = (current + asize) & (~asize); @@ -333,7 +522,21 @@ static bool assign_pd(struct interface *iface, struct dhcpv6_assignment *assign) static bool assign_na(struct interface *iface, struct dhcpv6_assignment *assign) { - if (iface->ia_addr_len < 1) + bool match = false; + for (size_t i = 0; i < iface->ia_addr_len; ++i) { + if (!iface->ia_addr[i].has_class) { + match = true; + continue; + } else if (assign->classes_cnt) { + for (size_t j = 0; j < assign->classes_cnt; ++j) + if (assign->classes[j] == iface->ia_addr[i].class) + match = true; + } else if (assign->all_class) { + match = true; + } + } + + if (!match) return false; // Seed RNG with checksum of DUID @@ -349,6 +552,9 @@ static bool assign_na(struct interface *iface, struct dhcpv6_assignment *assign) struct dhcpv6_assignment *c; list_for_each_entry(c, &iface->ia_assignments, head) { + if (c->length == 0) + continue; + if (c->assigned > try || c->length != 128) { assign->assigned = try; list_add_tail(&assign->head, &c->head); @@ -390,7 +596,6 @@ static void update(struct interface *iface) if (addr[i].prefix > minprefix) minprefix = addr[i].prefix; - addr[i].addr.s6_addr32[2] = 0; addr[i].addr.s6_addr32[3] = 0; if (addr[i].preferred < UINT32_MAX - now) @@ -426,7 +631,7 @@ static void update(struct interface *iface) struct list_head reassign = LIST_HEAD_INIT(reassign); struct dhcpv6_assignment *c, *d; list_for_each_entry_safe(c, d, &iface->ia_assignments, head) { - if (c->clid_len == 0 || c->valid_until < now) + if (c->clid_len == 0 || c->valid_until < now || c->managed_size) continue; if (c->length < 128 && c->assigned >= border->assigned && c != border) @@ -476,8 +681,7 @@ static void reconf_timer(struct uloop_timeout *event) if ((a->length < 128 && a->clid_len > 0) || (a->length == 128 && a->clid_len == 0)) { list_del(&a->head); - free(a->hostname); - free(a); + free_dhcpv6_assignment(a); } } else if (a->reconf_cnt > 0 && a->reconf_cnt < 8 && now > a->reconf_sent + (1 << a->reconf_cnt)) { @@ -486,13 +690,7 @@ static void reconf_timer(struct uloop_timeout *event) send_reconf(iface, a); } } - - if (iface->ia_reconf) { - update(iface); - iface->ia_reconf = false; - } } - uloop_timeout_set(event, 2000); } @@ -522,23 +720,31 @@ static size_t append_reply(uint8_t *buf, size_t buflen, uint16_t status, if (a) { uint32_t pref = 3600; uint32_t valid = 3600; - bool have_non_ula = false; - for (size_t i = 0; i < iface->ia_addr_len; ++i) - if ((iface->ia_addr[i].addr.s6_addr[0] & 0xfe) != 0xfc) - have_non_ula = true; - for (size_t i = 0; i < iface->ia_addr_len; ++i) { - uint32_t prefix_pref = iface->ia_addr[i].preferred - now; - uint32_t prefix_valid = iface->ia_addr[i].valid - now; + struct odhcpd_ipaddr *addrs = (a->managed) ? a->managed : iface->ia_addr; + size_t addrlen = (a->managed) ? (size_t)a->managed_size : iface->ia_addr_len; + + for (size_t i = 0; i < addrlen; ++i) { + bool match = true; + if (addrs[i].has_class) { + match = false; + if (a->classes_cnt) { + for (size_t j = 0; j < a->classes_cnt; ++j) + if (a->classes[j] == addrs[i].class) + match = true; + } else if (a->all_class) { + match = true; + } + } - if (iface->ia_addr[i].prefix > 64 || - iface->ia_addr[i].preferred <= (uint32_t)now) + if (!match) continue; - // ULA-deprecation compatibility workaround - if ((iface->ia_addr[i].addr.s6_addr[0] & 0xfe) == 0xfc && - a->length == 128 && have_non_ula && - iface->deprecate_ula_if_public_avail) + uint32_t prefix_pref = addrs[i].preferred - now; + uint32_t prefix_valid = addrs[i].valid - now; + + if (addrs[i].prefix > 96 || + addrs[i].preferred <= (uint32_t)now) continue; if (prefix_pref > 86400) @@ -547,37 +753,70 @@ static size_t append_reply(uint8_t *buf, size_t buflen, uint16_t status, if (prefix_valid > 86400) prefix_valid = 86400; +#ifdef DHCPV6_OPT_PREFIX_CLASS + struct { + uint16_t code; + uint16_t length; + uint16_t class; + } pclass = {htons(DHCPV6_OPT_PREFIX_CLASS), + htons(2), htons(iface->ia_addr[i].class)}; +#endif + if (a->length < 128) { struct dhcpv6_ia_prefix p = { .type = htons(DHCPV6_OPT_IA_PREFIX), .len = htons(sizeof(p) - 4), .preferred = htonl(prefix_pref), .valid = htonl(prefix_valid), - .prefix = a->length, - .addr = iface->ia_addr[i].addr + .prefix = (a->managed_size) ? addrs[i].prefix : a->length, + .addr = addrs[i].addr }; p.addr.s6_addr32[1] |= htonl(a->assigned); - if (datalen + sizeof(p) > buflen || a->assigned == 0) + size_t entrlen = sizeof(p) - 4; + +#ifdef DHCPV6_OPT_PREFIX_CLASS + if (iface->ia_addr[i].has_class) { + entrlen += sizeof(pclass); + p.len = htons(entrlen); + } +#endif + + if (datalen + entrlen + 4 > buflen || + (a->assigned == 0 && a->managed_size == 0)) continue; memcpy(buf + datalen, &p, sizeof(p)); - datalen += sizeof(p); +#ifdef DHCPV6_OPT_PREFIX_CLASS + memcpy(buf + datalen + sizeof(p), &pclass, sizeof(pclass)); +#endif + datalen += entrlen + 4; } else { struct dhcpv6_ia_addr n = { .type = htons(DHCPV6_OPT_IA_ADDR), .len = htons(sizeof(n) - 4), - .addr = iface->ia_addr[i].addr, + .addr = addrs[i].addr, .preferred = htonl(prefix_pref), .valid = htonl(prefix_valid) }; n.addr.s6_addr32[3] = htonl(a->assigned); + size_t entrlen = sizeof(n) - 4; - if (datalen + sizeof(n) > buflen || a->assigned == 0) +#ifdef DHCPV6_OPT_PREFIX_CLASS + if (iface->ia_addr[i].has_class) { + entrlen += sizeof(pclass); + n.len = htons(entrlen); + } +#endif + + if (datalen + entrlen + 4 > buflen || a->assigned == 0) continue; memcpy(buf + datalen, &n, sizeof(n)); - datalen += sizeof(n); +#ifdef DHCPV6_OPT_PREFIX_CLASS + memcpy(buf + datalen + sizeof(n), &pclass, sizeof(pclass)); +#endif + datalen += entrlen + 4; } // Calculate T1 / T2 based on non-deprecated addresses @@ -613,22 +852,25 @@ static size_t append_reply(uint8_t *buf, size_t buflen, uint16_t status, bool found = false; if (a) { - for (size_t i = 0; i < iface->ia_addr_len; ++i) { - if (iface->ia_addr[i].prefix > 64 || - iface->ia_addr[i].preferred <= (uint32_t)now) + struct odhcpd_ipaddr *addrs = (a->managed) ? a->managed : iface->ia_addr; + size_t addrlen = (a->managed) ? (size_t)a->managed_size : iface->ia_addr_len; + + for (size_t i = 0; i < addrlen; ++i) { + if (addrs[i].prefix > 96 || + addrs[i].preferred <= (uint32_t)now) continue; - struct in6_addr addr = iface->ia_addr[i].addr; + struct in6_addr addr = addrs[i].addr; if (ia->type == htons(DHCPV6_OPT_IA_PD)) { addr.s6_addr32[1] |= htonl(a->assigned); - if (IN6_ARE_ADDR_EQUAL(&p->addr, &addr) && + if (!memcmp(&p->addr, &addr, sizeof(addr)) && p->prefix == a->length) found = true; } else { addr.s6_addr32[3] = htonl(a->assigned); - if (IN6_ARE_ADDR_EQUAL(&n->addr, &addr)) + if (!memcmp(&n->addr, &addr, sizeof(addr))) found = true; } } @@ -676,7 +918,7 @@ static size_t append_reply(uint8_t *buf, size_t buflen, uint16_t status, } -size_t dhcpv6_handle_ia(uint8_t *buf, size_t buflen, struct interface *iface, +ssize_t dhcpv6_handle_ia(uint8_t *buf, size_t buflen, struct interface *iface, const struct sockaddr_in6 *addr, const void *data, const uint8_t *end) { time_t now = odhcpd_time(); @@ -690,6 +932,9 @@ size_t dhcpv6_handle_ia(uint8_t *buf, size_t buflen, struct interface *iface, uint8_t *clid_data = NULL, clid_len = 0, mac[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; char hostname[256]; size_t hostname_len = 0; + bool class_oro = false; + bool notonlink = false; + dhcpv6_for_each_option(start, end, otype, olen, odata) { if (otype == DHCPV6_OPT_CLIENTID) { clid_data = odata; @@ -706,6 +951,14 @@ size_t dhcpv6_handle_ia(uint8_t *buf, size_t buflen, struct interface *iface, if (dn_expand(&fqdn_buf[1], &fqdn_buf[olen], &fqdn_buf[1], hostname, sizeof(hostname)) > 0) hostname_len = strcspn(hostname, "."); + } else if (otype == DHCPV6_OPT_ORO) { +#ifdef DHCPV6_OPT_PREFIX_CLASS + for (size_t i = 0; i + 1 < olen; i += 2) { + if (odata[i] == (DHCPV6_OPT_PREFIX_CLASS >> 8) && + odata[i + 1] == (DHCPV6_OPT_PREFIX_CLASS & 0xff)) + class_oro = true; + } +#endif } else if (otype == DHCPV6_OPT_RECONF_ACCEPT) { accept_reconf = true; } @@ -721,6 +974,7 @@ size_t dhcpv6_handle_ia(uint8_t *buf, size_t buflen, struct interface *iface, dhcpv6_for_each_option(start, end, otype, olen, odata) { bool is_pd = (otype == DHCPV6_OPT_IA_PD); bool is_na = (otype == DHCPV6_OPT_IA_NA); + bool ia_addr_present = false; if (!is_pd && !is_na) continue; @@ -729,25 +983,66 @@ size_t dhcpv6_handle_ia(uint8_t *buf, size_t buflen, struct interface *iface, uint8_t reqlen = (is_pd) ? 62 : 128; uint32_t reqhint = 0; + const uint8_t classes_max = 32; + uint8_t classes_cnt = 0; + uint16_t classes[classes_max]; + // Parse request hint for IA-PD if (is_pd) { uint8_t *sdata; uint16_t stype, slen; dhcpv6_for_each_option(&ia[1], odata + olen, stype, slen, sdata) { - if (stype == DHCPV6_OPT_IA_PREFIX && slen >= sizeof(struct dhcpv6_ia_prefix) - 4) { - struct dhcpv6_ia_prefix *p = (struct dhcpv6_ia_prefix*)&sdata[-4]; - if (p->prefix) { - reqlen = p->prefix; - reqhint = ntohl(p->addr.s6_addr32[1]); - if (reqlen > 32 && reqlen <= 64) - reqhint &= (1U << (64 - reqlen)) - 1; - } - break; + if (stype != DHCPV6_OPT_IA_PREFIX || slen < sizeof(struct dhcpv6_ia_prefix) - 4) + continue; + + struct dhcpv6_ia_prefix *p = (struct dhcpv6_ia_prefix*)&sdata[-4]; + if (p->prefix) { + reqlen = p->prefix; + reqhint = ntohl(p->addr.s6_addr32[1]); + if (reqlen > 32 && reqlen <= 64) + reqhint &= (1U << (64 - reqlen)) - 1; + } + +#ifdef DHCPV6_OPT_PREFIX_CLASS + uint8_t *xdata; + uint16_t xtype, xlen; + dhcpv6_for_each_option(&p[1], sdata + slen, xtype, xlen, xdata) { + if (xtype != DHCPV6_OPT_PREFIX_CLASS || xlen != 2) + continue; + + if (classes_cnt >= classes_max) + continue; + + classes[classes_cnt++] = (uint16_t)xdata[0] << 8 | (uint16_t)xdata[1]; } +#endif } if (reqlen > 64) reqlen = 64; + } else if (is_na) { + uint8_t *sdata; + uint16_t stype, slen; + dhcpv6_for_each_option(&ia[1], odata + olen, stype, slen, sdata) { + if (stype != DHCPV6_OPT_IA_ADDR || slen < sizeof(struct dhcpv6_ia_addr) - 4) + continue; + + ia_addr_present = true; +#ifdef DHCPV6_OPT_PREFIX_CLASS + uint8_t *xdata; + uint16_t xtype, xlen; + struct dhcpv6_ia_addr *p = (struct dhcpv6_ia_addr*)&sdata[-4]; + dhcpv6_for_each_option(&p[1], sdata + slen, xtype, xlen, xdata) { + if (xtype != DHCPV6_OPT_PREFIX_CLASS || xlen != 2) + continue; + + if (classes_cnt >= classes_max) + continue; + + classes[classes_cnt++] = (uint16_t)xdata[0] << 8 | (uint16_t)xdata[1]; + } +#endif + } } // Find assignment @@ -768,32 +1063,53 @@ size_t dhcpv6_handle_ia(uint8_t *buf, size_t buflen, struct interface *iface, a->peer = *addr; a->reconf_cnt = 0; a->reconf_sent = 0; + a->all_class = class_oro; + a->classes_cnt = classes_cnt; + a->classes = realloc(a->classes, classes_cnt * sizeof(uint16_t)); + if (a->classes) + memcpy(a->classes, classes, classes_cnt * sizeof(uint16_t)); break; } } // Generic message handling uint16_t status = DHCPV6_STATUS_OK; - if (hdr->msg_type == DHCPV6_MSG_SOLICIT || hdr->msg_type == DHCPV6_MSG_REQUEST) { + if (a && a->managed_size < 0) { + return -1; + } else if (hdr->msg_type == DHCPV6_MSG_SOLICIT || hdr->msg_type == DHCPV6_MSG_REQUEST) { bool assigned = !!a; if (!a && !iface->no_dynamic_dhcp) { // Create new binding a = calloc(1, sizeof(*a) + clid_len); - a->clid_len = clid_len; - a->iaid = ia->iaid; - a->length = reqlen; - a->peer = *addr; - a->assigned = reqhint; - if (first) - memcpy(a->key, first->key, sizeof(a->key)); - else - odhcpd_urandom(a->key, sizeof(a->key)); - memcpy(a->clid_data, clid_data, clid_len); + if (a) { + a->clid_len = clid_len; + a->iaid = ia->iaid; + a->length = reqlen; + a->peer = *addr; + a->assigned = reqhint; + a->all_class = class_oro; + a->classes_cnt = classes_cnt; + if (classes_cnt) { + a->classes = malloc(classes_cnt * sizeof(uint16_t)); + if (a->classes) + memcpy(a->classes, classes, classes_cnt * sizeof(uint16_t)); + } + + if (first) + memcpy(a->key, first->key, sizeof(a->key)); + else + odhcpd_urandom(a->key, sizeof(a->key)); + memcpy(a->clid_data, clid_data, clid_len); - if (is_pd) - while (!(assigned = assign_pd(iface, a)) && ++a->length <= 64); - else - assigned = assign_na(iface, a); + if (is_pd) + while (!(assigned = assign_pd(iface, a)) && + !a->managed_size && ++a->length <= 64); + else + assigned = assign_na(iface, a); + + if (a->managed_size && !assigned) + return -1; + } } if (!assigned || iface->ia_addr_len == 0) { // Set error status @@ -834,15 +1150,16 @@ size_t dhcpv6_handle_ia(uint8_t *buf, size_t buflen, struct interface *iface, } else if (assigned && hdr->msg_type == DHCPV6_MSG_REQUEST) { if (hostname_len > 0) { a->hostname = realloc(a->hostname, hostname_len + 1); - memcpy(a->hostname, hostname, hostname_len); - a->hostname[hostname_len] = 0; + if (a->hostname) { + memcpy(a->hostname, hostname, hostname_len); + a->hostname[hostname_len] = 0; + } } a->accept_reconf = accept_reconf; apply_lease(iface, a, true); update_state = true; - } else if (!assigned && a) { // Cleanup failed assignment - free(a->hostname); - free(a); + } else if (!assigned && a && a->managed_size == 0) { // Cleanup failed assignment + free_dhcpv6_assignment(a); } } else if (hdr->msg_type == DHCPV6_MSG_RENEW || hdr->msg_type == DHCPV6_MSG_RELEASE || @@ -865,10 +1182,11 @@ size_t dhcpv6_handle_ia(uint8_t *buf, size_t buflen, struct interface *iface, a->valid_until = now + 3600; // Block address for 1h update_state = true; } - } else if (hdr->msg_type == DHCPV6_MSG_CONFIRM) { - // Always send NOTONLINK for CONFIRM so that clients restart connection + } else if (hdr->msg_type == DHCPV6_MSG_CONFIRM && ia_addr_present) { + // Send NOTONLINK for CONFIRM with addr present so that clients restart connection status = DHCPV6_STATUS_NOTONLINK; ia_response_len = append_reply(buf, buflen, status, ia, a, iface, true); + notonlink = true; } buf += ia_response_len; @@ -876,13 +1194,14 @@ size_t dhcpv6_handle_ia(uint8_t *buf, size_t buflen, struct interface *iface, response_len += ia_response_len; } - if (hdr->msg_type == DHCPV6_MSG_RELEASE && response_len + 6 < buflen) { + if ((hdr->msg_type == DHCPV6_MSG_RELEASE || hdr->msg_type == DHCPV6_MSG_DECLINE || notonlink) && + response_len + 6 < buflen) { buf[0] = 0; buf[1] = DHCPV6_OPT_STATUS; buf[2] = 0; buf[3] = 2; buf[4] = 0; - buf[5] = DHCPV6_STATUS_OK; + buf[5] = (notonlink) ? DHCPV6_STATUS_NOTONLINK : DHCPV6_STATUS_OK; response_len += 6; }