Add missing NDP sync features
[project/odhcpd.git] / src / dhcpv6-ia.c
index f933da6..fe47130 100644 (file)
 #include "dhcpv6.h"
 #include "dhcpv4.h"
 #include "libubox/md5.h"
+#include "libubox/usock.h"
 
 #include <time.h>
 #include <errno.h>
 #include <fcntl.h>
+#include <stdio.h>
+#include <poll.h>
 #include <alloca.h>
 #include <resolv.h>
 #include <limits.h>
 #include <stdlib.h>
+#include <string.h>
 #include <unistd.h>
+#include <stdbool.h>
 #include <arpa/inet.h>
 #include <sys/timerfd.h>
 
@@ -33,6 +38,7 @@ static void update(struct interface *iface);
 static void reconf_timer(struct uloop_timeout *event);
 static struct uloop_timeout reconf_event = {.cb = reconf_timer};
 static uint32_t serial = 0;
+static uint8_t statemd5[16];
 
 
 int dhcpv6_ia_init(void)
@@ -42,16 +48,30 @@ int dhcpv6_ia_init(void)
 }
 
 
+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->hostname);
-                       free(c->classes);
-                       free(c);
+                       free_dhcpv6_assignment(c);
                }
        }
 
@@ -100,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;
@@ -160,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;
@@ -187,6 +209,9 @@ static int send_reconf(struct interface *iface, struct dhcpv6_assignment *assign
 
 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);
@@ -207,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];
@@ -227,28 +252,45 @@ 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;
+                                               if (c->valid_until <= now)
                                                        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];
@@ -267,8 +309,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';
@@ -280,7 +332,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);
@@ -292,28 +348,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) {
@@ -330,7 +503,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);
@@ -381,6 +554,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);
@@ -422,7 +598,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)
@@ -458,7 +633,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)
@@ -508,9 +683,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->classes);
-                                       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)) {
@@ -519,13 +692,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);
 }
 
@@ -553,16 +720,25 @@ static size_t append_reply(uint8_t *buf, size_t buflen, uint16_t status,
                datalen += sizeof(stat);
        } else {
                if (a) {
-                       uint32_t pref = 3600;
-                       uint32_t valid = 3600;
+                       uint32_t leasetime = iface->dhcpv4_leasetime;
+                       if (leasetime == 0)
+                               leasetime = 3600;
+                       else if (leasetime < 60)
+                               leasetime = 60;
+
+                       uint32_t pref = leasetime;
+                       uint32_t valid = leasetime;
 
-                       for (size_t i = 0; i < iface->ia_addr_len; ++i) {
+                       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 (iface->ia_addr[i].has_class) {
+                               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] == iface->ia_addr[i].class)
+                                                       if (a->classes[j] == addrs[i].class)
                                                                match = true;
                                        } else if (a->all_class) {
                                                match = true;
@@ -572,11 +748,11 @@ static size_t append_reply(uint8_t *buf, size_t buflen, uint16_t status,
                                if (!match)
                                        continue;
 
-                               uint32_t prefix_pref = iface->ia_addr[i].preferred - now;
-                               uint32_t prefix_valid = iface->ia_addr[i].valid - now;
+                               uint32_t prefix_pref = addrs[i].preferred - now;
+                               uint32_t prefix_valid = addrs[i].valid - now;
 
-                               if (iface->ia_addr[i].prefix > 64 ||
-                                               iface->ia_addr[i].preferred <= (uint32_t)now)
+                               if (addrs[i].prefix > 96 ||
+                                               addrs[i].preferred <= (uint32_t)now)
                                        continue;
 
                                if (prefix_pref > 86400)
@@ -600,10 +776,11 @@ static size_t append_reply(uint8_t *buf, size_t buflen, uint16_t status,
                                                .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);
+
                                        size_t entrlen = sizeof(p) - 4;
 
 #ifdef DHCPV6_OPT_PREFIX_CLASS
@@ -613,7 +790,8 @@ static size_t append_reply(uint8_t *buf, size_t buflen, uint16_t status,
                                        }
 #endif
 
-                                       if (datalen + entrlen + 4 > buflen || a->assigned == 0)
+                                       if (datalen + entrlen + 4 > buflen ||
+                                                       (a->assigned == 0 && a->managed_size == 0))
                                                continue;
 
                                        memcpy(buf + datalen, &p, sizeof(p));
@@ -625,7 +803,7 @@ static size_t append_reply(uint8_t *buf, size_t buflen, uint16_t status,
                                        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)
                                        };
@@ -682,22 +860,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;
                                                }
                                        }
@@ -745,7 +926,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();
@@ -760,6 +941,8 @@ size_t dhcpv6_handle_ia(uint8_t *buf, size_t buflen, struct interface *iface,
        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;
@@ -799,6 +982,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;
 
@@ -851,6 +1035,7 @@ size_t dhcpv6_handle_ia(uint8_t *buf, size_t buflen, struct interface *iface,
                                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;
@@ -897,7 +1082,9 @@ size_t dhcpv6_handle_ia(uint8_t *buf, size_t buflen, struct interface *iface,
 
                // 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
@@ -923,9 +1110,13 @@ size_t dhcpv6_handle_ia(uint8_t *buf, size_t buflen, struct interface *iface,
                                        memcpy(a->clid_data, clid_data, clid_len);
 
                                        if (is_pd)
-                                               while (!(assigned = assign_pd(iface, a)) && ++a->length <= 64);
+                                               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;
                                }
                        }
 
@@ -975,10 +1166,8 @@ size_t dhcpv6_handle_ia(uint8_t *buf, size_t buflen, struct interface *iface,
                                a->accept_reconf = accept_reconf;
                                apply_lease(iface, a, true);
                                update_state = true;
-                       } else if (!assigned && a) { // Cleanup failed assignment
-                               free(a->classes);
-                               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 ||
@@ -1001,10 +1190,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;
@@ -1012,13 +1202,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;
        }