Enable softwire-support by default
[odhcp6c.git] / src / dhcpv6.c
index 7c6da00..b7fccac 100644 (file)
@@ -179,11 +179,9 @@ int init_dhcpv6(const char *ifname, unsigned int options, int sol_timeout)
 #ifdef EXT_CER_ID
                        htons(DHCPV6_OPT_CER_ID),
 #endif
-#ifdef EXT_S46
                        htons(DHCPV6_OPT_S46_CONT_MAPE),
                        htons(DHCPV6_OPT_S46_CONT_MAPT),
                        htons(DHCPV6_OPT_S46_CONT_LW),
-#endif
                };
                odhcp6c_add_state(STATE_ORO, oro, sizeof(oro));
        }
@@ -366,7 +364,7 @@ static void dhcpv6_send(enum dhcpv6_msg type, uint8_t trid[3], uint32_t ecs)
        struct dhcpv6_ia_hdr hdr_ia_na = {
                htons(DHCPV6_OPT_IA_NA),
                htons(sizeof(hdr_ia_na) - 4),
-               1, 0, 0
+               htonl(1), 0, 0
        };
 
        struct dhcpv6_ia_addr pa[ia_na_entries];
@@ -922,16 +920,19 @@ static int dhcpv6_handle_reply(enum dhcpv6_msg orig, _unused const int rc,
                odhcp6c_clear_state(STATE_S46_MAPT);
                odhcp6c_clear_state(STATE_S46_MAPE);
                odhcp6c_clear_state(STATE_S46_LW);
+               odhcp6c_clear_state(STATE_PASSTHRU);
        }
 
        // Parse and find all matching IAs
        dhcpv6_for_each_option(opt, end, otype, olen, odata) {
+               bool passthru = true;
+
                if ((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]);
 
                        // Test ID
-                       if (ia_hdr->iaid != 1 && otype == DHCPV6_OPT_IA_NA)
+                       if (ia_hdr->iaid != htonl(1) && otype == DHCPV6_OPT_IA_NA)
                                continue;
 
                        uint16_t code = DHCPV6_Success;
@@ -963,18 +964,21 @@ static int dhcpv6_handle_reply(enum dhcpv6_msg orig, _unused const int rc,
                                continue;
 
                        dhcpv6_parse_ia(ia_hdr, odata + olen + sizeof(*ia_hdr));
+                       passthru = false;
                } else if (otype == DHCPV6_OPT_STATUS && olen >= 2) {
                        uint8_t *mdata = (olen > 2) ? &odata[2] : NULL;
                        uint16_t mlen = (olen > 2) ? olen - 2 : 0;
                        uint16_t code = ((int)odata[0]) << 8 | ((int)odata[1]);
 
                        dhcpv6_handle_status_code(orig, code, mdata, mlen, &ret);
+                       passthru = false;
                }
                else if (otype == DHCPV6_OPT_DNS_SERVERS) {
                        if (olen % 16 == 0)
                                odhcp6c_add_state(STATE_DNS, odata, olen);
                } else if (otype == DHCPV6_OPT_DNS_DOMAIN) {
                        odhcp6c_add_state(STATE_SEARCH, odata, olen);
+                       passthru = false;
                } else if (otype == DHCPV6_OPT_SNTP_SERVERS) {
                        if (olen % 16 == 0)
                                odhcp6c_add_state(STATE_SNTP_IP, odata, olen);
@@ -999,27 +1003,33 @@ static int dhcpv6_handle_reply(enum dhcpv6_msg orig, _unused const int rc,
                        odhcp6c_add_state(STATE_SIP_FQDN, odata, olen);
                } else if (otype == DHCPV6_OPT_INFO_REFRESH && olen >= 4) {
                        refresh = ntohl(*((uint32_t*)odata));
-               } else if (otype == DHCPV6_OPT_AUTH && olen == -4 +
-                               sizeof(struct dhcpv6_auth_reconfigure)) {
-                       struct dhcpv6_auth_reconfigure *r = (void*)&odata[-4];
-                       if (r->protocol == 3 && r->algorithm == 1 &&
-                                       r->reconf_type == 1)
-                               memcpy(reconf_key, r->key, sizeof(r->key));
+                       passthru = false;
+               } else if (otype == DHCPV6_OPT_AUTH) {
+                       if (olen == -4 + sizeof(struct dhcpv6_auth_reconfigure)) {
+                               struct dhcpv6_auth_reconfigure *r = (void*)&odata[-4];
+                               if (r->protocol == 3 && r->algorithm == 1 &&
+                                               r->reconf_type == 1)
+                                       memcpy(reconf_key, r->key, sizeof(r->key));
+                       }
+                       passthru = false;
                } else if (otype == DHCPV6_OPT_AFTR_NAME && olen > 3) {
                        size_t cur_len;
                        odhcp6c_get_state(STATE_AFTR_NAME, &cur_len);
                        if (cur_len == 0)
                                odhcp6c_add_state(STATE_AFTR_NAME, odata, olen);
+                       passthru = false;
                } else if (otype == DHCPV6_OPT_SOL_MAX_RT && olen == 4) {
                        uint32_t sol_max_rt = ntohl(*((uint32_t *)odata));
                        if (sol_max_rt >= DHCPV6_SOL_MAX_RT_MIN &&
                                        sol_max_rt <= DHCPV6_SOL_MAX_RT_MAX)
                                dhcpv6_retx[DHCPV6_MSG_SOLICIT].max_timeo = sol_max_rt;
+                       passthru = false;
                } else if (otype == DHCPV6_OPT_INF_MAX_RT && olen == 4) {
                        uint32_t inf_max_rt = ntohl(*((uint32_t *)odata));
                        if (inf_max_rt >= DHCPV6_INF_MAX_RT_MIN &&
                                        inf_max_rt <= DHCPV6_INF_MAX_RT_MAX)
                                dhcpv6_retx[DHCPV6_MSG_INFO_REQ].max_timeo = inf_max_rt;
+                       passthru = false;
 #ifdef EXT_CER_ID
                } else if (otype == DHCPV6_OPT_CER_ID && olen == -4 +
                                sizeof(struct dhcpv6_cer_id)) {
@@ -1027,23 +1037,34 @@ static int dhcpv6_handle_reply(enum dhcpv6_msg orig, _unused const int rc,
                        struct in6_addr any = IN6ADDR_ANY_INIT;
                        if (memcmp(&cer_id->addr, &any, sizeof(any)))
                                odhcp6c_add_state(STATE_CER, &cer_id->addr, sizeof(any));
+                       passthru = false;
 #endif
-#ifdef EXT_S46
                } else if (otype == DHCPV6_OPT_S46_CONT_MAPT) {
                        odhcp6c_add_state(STATE_S46_MAPT, odata, olen);
+                       passthru = false;
                } else if (otype == DHCPV6_OPT_S46_CONT_MAPE) {
                        size_t mape_len;
                        odhcp6c_get_state(STATE_S46_MAPE, &mape_len);
                        if (mape_len == 0)
                                odhcp6c_add_state(STATE_S46_MAPE, odata, olen);
+                       passthru = false;
                } else if (otype == DHCPV6_OPT_S46_CONT_LW) {
                        odhcp6c_add_state(STATE_S46_LW, odata, olen);
-#endif
-               } else if (otype != DHCPV6_OPT_CLIENTID &&
-                               otype != DHCPV6_OPT_SERVERID) {
-                       odhcp6c_add_state(STATE_CUSTOM_OPTS,
-                                       &odata[-4], olen + 4);
+                       passthru = false;
+               } else if (otype == DHCPV6_OPT_CLIENTID ||
+                               otype == DHCPV6_OPT_SERVERID ||
+                               otype == DHCPV6_OPT_IA_TA ||
+                               otype == DHCPV6_OPT_PREF ||
+                               otype == DHCPV6_OPT_UNICAST ||
+                               otype == DHCPV6_OPT_FQDN ||
+                               otype == DHCPV6_OPT_RECONF_ACCEPT) {
+                       passthru = false;
+               } else {
+                       odhcp6c_add_state(STATE_CUSTOM_OPTS, &odata[-4], olen + 4);
                }
+
+               if (passthru)
+                       odhcp6c_add_state(STATE_PASSTHRU, &odata[-4], olen + 4);
        }
 
        if (orig != DHCPV6_MSG_INFO_REQ) {