Add support for DHCPv6 option passthru
authorSteven Barth <steven@midlink.org>
Fri, 23 May 2014 06:15:49 +0000 (08:15 +0200)
committerSteven Barth <steven@midlink.org>
Fri, 23 May 2014 06:15:49 +0000 (08:15 +0200)
src/dhcpv6.c
src/odhcp6c.h
src/script.c

index 7c6da00..4fbff84 100644 (file)
@@ -922,10 +922,13 @@ 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]);
@@ -963,12 +966,14 @@ 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)
@@ -999,27 +1004,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 +1038,35 @@ 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);
+                       passthru = false;
 #endif
-               } else if (otype != DHCPV6_OPT_CLIENTID &&
-                               otype != DHCPV6_OPT_SERVERID) {
-                       odhcp6c_add_state(STATE_CUSTOM_OPTS,
-                                       &odata[-4], olen + 4);
+               } 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) {
+                       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) {
index 8abb631..01fb072 100644 (file)
@@ -37,12 +37,14 @@ enum dhcvp6_opt {
        DHCPV6_OPT_CLIENTID = 1,
        DHCPV6_OPT_SERVERID = 2,
        DHCPV6_OPT_IA_NA = 3,
+       DHCPV6_OPT_IA_TA = 4,
        DHCPV6_OPT_IA_ADDR = 5,
        DHCPV6_OPT_ORO = 6,
        DHCPV6_OPT_PREF = 7,
        DHCPV6_OPT_ELAPSED = 8,
        DHCPV6_OPT_RELAY_MSG = 9,
        DHCPV6_OPT_AUTH = 11,
+       DHCPV6_OPT_UNICAST = 12,
        DHCPV6_OPT_STATUS = 13,
        DHCPV6_OPT_RAPID_COMMIT = 14,
        DHCPV6_OPT_USER_CLASS = 15,
@@ -268,6 +270,7 @@ enum odhcp6c_state {
        STATE_S46_MAPT,
        STATE_S46_MAPE,
        STATE_S46_LW,
+       STATE_PASSTHRU,
        _STATE_MAX
 };
 
index 9325085..389dc37 100644 (file)
@@ -359,7 +359,7 @@ void script_call(const char *status)
 {
        size_t dns_len, search_len, custom_len, sntp_ip_len, ntp_ip_len, ntp_dns_len;
        size_t sip_ip_len, sip_fqdn_len, aftr_name_len, cer_len;
-       size_t s46_mapt_len, s46_mape_len, s46_lw_len;
+       size_t s46_mapt_len, s46_mape_len, s46_lw_len, passthru_len;
 
        odhcp6c_expire();
        if (delayed_call) {
@@ -380,6 +380,7 @@ void script_call(const char *status)
        uint8_t *s46_mapt = odhcp6c_get_state(STATE_S46_MAPT, &s46_mapt_len);
        uint8_t *s46_mape = odhcp6c_get_state(STATE_S46_MAPE, &s46_mape_len);
        uint8_t *s46_lw = odhcp6c_get_state(STATE_S46_LW, &s46_lw_len);
+       uint8_t *passthru = odhcp6c_get_state(STATE_PASSTHRU, &passthru_len);
 
        size_t prefix_len, address_len, ra_pref_len, ra_route_len, ra_dns_len;
        uint8_t *prefix = odhcp6c_get_state(STATE_IA_PD, &prefix_len);
@@ -410,6 +411,11 @@ void script_call(const char *status)
                entry_to_env("RA_ROUTES", ra_route, ra_route_len, ENTRY_ROUTE);
                entry_to_env("RA_DNS", ra_dns, ra_dns_len, ENTRY_HOST);
 
+               char *buf = malloc(10 + passthru_len * 2);
+               strncpy(buf, "PASSTHRU=", 10);
+               script_hexlify(&buf[9], passthru, passthru_len);
+               putenv(buf);
+
                argv[2] = (char*)status;
                execv(argv[0], argv);
                _exit(128);