Merge remote-tracking branch 'up/master' into hnet

[odhcp6c.git] / src / dhcpv6.c

diff --git a/src/dhcpv6.c b/src/dhcpv6.c
index cfa5a407f1408f2d6d03a452121fac9e16ee66c3..fe4cc0b48e8f5dd4ca56139ee1c7fdcc5e353f1f 100644 (file)
--- a/src/dhcpv6.c
+++ b/src/dhcpv6.c
@@ -142,8 +142,10 @@ int init_dhcpv6(const char *ifname, int request_pd)
                        htons(DHCPV6_OPT_DNS_SERVERS),
                        htons(DHCPV6_OPT_DNS_DOMAIN),
                        htons(DHCPV6_OPT_NTP_SERVER),
+                       htons(DHCPV6_OPT_SIP_SERVER_A),
                        htons(DHCPV6_OPT_AFTR_NAME),
                        htons(DHCPV6_OPT_PD_EXCLUDE),
+                       htons(DHCPV6_OPT_PREFIX_CLASS),
        };
        odhcp6c_add_state(STATE_ORO, oro, sizeof(oro));
 
@@ -350,14 +352,14 @@ static int64_t dhcpv6_rand_delay(int64_t time)
 {
        int random;
        odhcp6c_random(&random, sizeof(random));
-       return (time * (random % 1000)) / 10000;
+       return (time * ((int64_t)random % 1000LL)) / 10000LL;
 }
 
 
 int dhcpv6_request(enum dhcpv6_msg type)
 {
        uint8_t buf[1536];
-       uint32_t timeout = UINT32_MAX;
+       uint64_t timeout = UINT32_MAX;
        struct dhcpv6_retx *retx = &dhcpv6_retx[type];
 
        if (retx->delay) {
@@ -371,14 +373,14 @@ int dhcpv6_request(enum dhcpv6_msg type)
        else if (type == DHCPV6_MSG_UNKNOWN)
                timeout = t1;
        else if (type == DHCPV6_MSG_RENEW)
-               timeout = t2 - t1;
+               timeout = (t2 > t1) ? t2 - t1 : 0;
        else if (type == DHCPV6_MSG_REBIND)
-               timeout = t3 - t2;
+               timeout = (t3 > t2) ? t3 - t2 : 0;
 
        if (timeout == 0)
                return -1;
 
-       syslog(LOG_NOTICE, "Sending %s (timeout %us)", retx->name, timeout);
+       syslog(LOG_NOTICE, "Sending %s (timeout %us)", retx->name, (unsigned)timeout);
 
        uint64_t start = odhcp6c_get_milli_time(), round_start = start, elapsed;
 
@@ -559,14 +561,21 @@ static int dhcpv6_handle_reconfigure(_unused enum dhcpv6_msg orig,
 
 
 // Collect all advertised servers
-static int dhcpv6_handle_advert(_unused enum dhcpv6_msg orig,
+static int dhcpv6_handle_advert(enum dhcpv6_msg orig,
                const void *opt, const void *end)
 {
        uint16_t olen, otype;
        uint8_t *odata;
-       struct dhcpv6_server_cand cand = {false, false, 0, 0, {0}};
+       struct dhcpv6_server_cand cand = {false, false, 0, 0, {0}, NULL, NULL, 0, 0};
 
        dhcpv6_for_each_option(opt, end, otype, olen, odata) {
+               if (orig == DHCPV6_MSG_SOLICIT &&
+                               (otype == DHCPV6_OPT_IA_PD || otype == DHCPV6_OPT_IA_NA) &&
+                               olen > sizeof(struct dhcpv6_ia_hdr)) {
+                       struct dhcpv6_ia_hdr *ia_hdr = (void*)(&odata[-4]);
+                       dhcpv6_parse_ia(&ia_hdr[1], odata + olen);
+               }
+
                if (otype == DHCPV6_OPT_SERVERID && olen <= 130) {
                        memcpy(cand.duid, odata, olen);
                        cand.duid_len = olen;
@@ -600,8 +609,16 @@ static int dhcpv6_handle_advert(_unused enum dhcpv6_msg orig,
                }
        }
 
-       if (cand.duid_len > 0)
+       if (cand.duid_len > 0) {
+               cand.ia_na = odhcp6c_move_state(STATE_IA_NA, &cand.ia_na_len);
+               cand.ia_pd = odhcp6c_move_state(STATE_IA_PD, &cand.ia_pd_len);
                odhcp6c_add_state(STATE_SERVER_CAND, &cand, sizeof(cand));
+       }
+
+       if (orig == DHCPV6_MSG_SOLICIT) {
+               odhcp6c_clear_state(STATE_IA_NA);
+               odhcp6c_clear_state(STATE_IA_PD);
+       }
 
        return -1;
 }
@@ -634,8 +651,14 @@ static int dhcpv6_commit_advert(void)
                odhcp6c_add_state(STATE_SERVER_ID, hdr, sizeof(hdr));
                odhcp6c_add_state(STATE_SERVER_ID, c->duid, c->duid_len);
                accept_reconfig = c->wants_reconfigure;
+               odhcp6c_add_state(STATE_IA_NA, c->ia_na, c->ia_na_len);
+               odhcp6c_add_state(STATE_IA_PD, c->ia_pd, c->ia_pd_len);
        }
 
+       for (size_t i = 0; i < cand_len / sizeof(*c); ++i) {
+               free(cand[i].ia_na);
+               free(cand[i].ia_pd);
+       }
        odhcp6c_clear_state(STATE_SERVER_CAND);
 
        if (!c)
@@ -691,6 +714,12 @@ static int dhcpv6_handle_reply(enum dhcpv6_msg orig,
                t1 = t2 = t3 = UINT32_MAX;
        }
 
+       if (orig == DHCPV6_MSG_REQUEST) {
+               // Delete NA and PD we have in the state from the Advert
+               odhcp6c_clear_state(STATE_IA_NA);
+               odhcp6c_clear_state(STATE_IA_PD);
+       }
+
        if (opt) {
                odhcp6c_clear_state(STATE_DNS);
                odhcp6c_clear_state(STATE_SEARCH);
@@ -726,29 +755,23 @@ static int dhcpv6_handle_reply(enum dhcpv6_msg orig,
                        if (error)
                                continue;
 
-                       // Update times
-                       if (l_t1 > 0 && t1 > l_t1)
-                               t1 = l_t1;
-
-                       if (l_t2 > 0 && t2 > l_t2)
-                               t2 = l_t2;
-
                        uint32_t n = dhcpv6_parse_ia(&ia_hdr[1], odata + olen);
 
-                       if (n < t1)
-                               t1 = n;
+                       if (!l_t1)
+                               l_t1 = 300;
 
-                       if (n < t2)
-                               t2 = n;
+                       if (!l_t2)
+                               l_t2 = 600;
 
                        if (n < t3)
                                t3 = n;
 
-                       if (t2 >= t3)
-                               t2 = 8 * t3 / 10;
+                       // Update times
+                       if (l_t1 > 0 && t1 > l_t1)
+                               t1 = l_t1;
 
-                       if (t1 >= t2)
-                               t1 = 5 * t2 / 8;
+                       if (l_t2 > 0 && t2 > l_t2)
+                               t2 = l_t2;
 
                } else if (otype == DHCPV6_OPT_DNS_SERVERS) {
                        if (olen % 16 == 0)
@@ -806,11 +829,11 @@ static uint32_t dhcpv6_parse_ia(void *opt, void *end)
        uint16_t otype, olen;
        uint8_t *odata;
 
-       struct odhcp6c_entry entry = {IN6ADDR_ANY_INIT,
-                       0, 0, IN6ADDR_ANY_INIT, 0, 0};
-
        // Update address IA
        dhcpv6_for_each_option(opt, end, otype, olen, odata) {
+          struct odhcp6c_entry entry = {IN6ADDR_ANY_INIT,
+                                        0, 0, IN6ADDR_ANY_INIT, 0, 0, 0};
+
                if (otype == DHCPV6_OPT_IA_PREFIX) {
                        struct dhcpv6_ia_prefix *prefix = (void*)&odata[-4];
                        if (olen + 4U < sizeof(*prefix))
@@ -824,11 +847,17 @@ static uint32_t dhcpv6_parse_ia(void *opt, void *end)
 
                        entry.length = prefix->prefix;
                        entry.target = prefix->addr;
+                       uint16_t stype, slen;
+                       uint8_t *sdata;
+
+                        // Find prefix class, if any
+                       dhcpv6_for_each_option(&prefix[1], odata + olen,
+                                               stype, slen, sdata)
+                          if (stype == DHCPV6_OPT_PREFIX_CLASS && slen == 2) 
+                            entry.prefix_class = ntohs(*((uint16_t*)sdata));
 
                        // Parse PD-exclude
                        bool ok = true;
-                       uint16_t stype, slen;
-                       uint8_t *sdata;
                        dhcpv6_for_each_option(odata + sizeof(*prefix) - 4U,
                                        odata + olen, stype, slen, sdata) {
                                if (stype != DHCPV6_OPT_PD_EXCLUDE || slen < 2)
@@ -883,6 +912,15 @@ static uint32_t dhcpv6_parse_ia(void *opt, void *end)
                        entry.length = 128;
                        entry.target = addr->addr;
 
+                       uint16_t stype, slen;
+                       uint8_t *sdata;
+                       
+                       // Find prefix class, if any
+                       dhcpv6_for_each_option(&addr[1], odata + olen,
+                                              stype, slen, sdata)
+                         if (stype == DHCPV6_OPT_PREFIX_CLASS && slen == 2) 
+                            entry.prefix_class = ntohs(*((uint16_t*)sdata));
+                       
                        odhcp6c_update_entry(STATE_IA_NA, &entry);
                }