Wi-sun DHCPV6, RPL DIO forwarding, dhcpv6 client update

Wi-sun RPL prefix callback not use lifetime anymore if just R-flag is active.

RPL DIO prefix use 0 lifetime/preferred timeout added support that node not remove after 3 multicast forward.

DHCPv6 SOL not set any spesific hint for address get also same for renew.

Added DHCPv6 Client to  support 1 instance for request address and deprecate old address if new is given.

Cleaned some trace prints away which cuold cause confuse.

Change-Id: I0a69fa176aaa83fdec40ecbdc7667136a88d1a17

Author: Juha Heiskanen

source/6LoWPAN/Thread/thread_bootstrap.c

@@ -888,6 +888,7 @@ void thread_interface_init(protocol_interface_info_entry_t *cur)
     thread_discovery_reset(cur->id);
     thread_routing_set_mesh_callbacks(cur);
     dhcp_client_init(cur->id);
+    dhcp_client_configure(cur->id, false, false, false);
     thread_management_client_init(cur->id);
     thread_address_registration_init();
     cur->mpl_seed_id_mode = MULTICAST_MPL_SEED_ID_MAC_SHORT;

source/6LoWPAN/ws/ws_bbr_api.c

@@ -343,7 +343,7 @@ static void ws_bbr_rpl_status_check(protocol_interface_info_entry_t *cur)
 
             // Old backbone information is deleted after 120 seconds
             rpl_control_update_dodag_route(protocol_6lowpan_rpl_root_dodag, NULL, 0, 0, 120, true);
-            rpl_control_update_dodag_prefix(protocol_6lowpan_rpl_root_dodag, global_dodag_id, 64, 0, 120, 0, true);
+            rpl_control_update_dodag_prefix(protocol_6lowpan_rpl_root_dodag, global_dodag_id, 64, 0, 0, 0, true);
             rpl_control_update_dodag_route(protocol_6lowpan_rpl_root_dodag, global_dodag_id, 64, 0, 120, true);
             ipv6_route_add_with_info(global_dodag_id, 64, backbone_interface_id, NULL, ROUTE_THREAD_BBR, NULL, 0, 120, 0);
 
@@ -369,7 +369,7 @@ static void ws_bbr_rpl_status_check(protocol_interface_info_entry_t *cur)
 
             if (configuration & BBR_GUA_C) {
                 // Add also global prefix and route to RPL
-                rpl_control_update_dodag_prefix(protocol_6lowpan_rpl_root_dodag, global_id, 64, t_flags, 7200, 7200, false);
+                rpl_control_update_dodag_prefix(protocol_6lowpan_rpl_root_dodag, global_id, 64, t_flags, 0, 0, false);
             }
             if (configuration & BBR_GUA_ROUTE) {
                 // Add also global prefix and route to RPL

source/6LoWPAN/ws/ws_bootstrap.c

@@ -171,8 +171,6 @@ static void ws_bootstrap_address_notification_cb(struct protocol_interface_info_
             tr_info("Register ARO");
             ws_bootsrap_event_trig(WS_ADDRESS_ADDED, interface->bootStrapId, ARM_LIB_LOW_PRIORITY_EVENT, NULL);
         }
-    } else {
-        tr_debug("Address notification addr: %s reason: %d", trace_ipv6(addr->address), reason);
     }
 }
 
@@ -725,7 +723,7 @@ static int8_t ws_bootstrap_up(protocol_interface_info_entry_t *cur)
     cur->ipv6_neighbour_cache.send_nud_probes = false;
     cur->ipv6_neighbour_cache.probe_avoided_routers = true;
     dhcp_client_init(cur->id);
-    dhcp_client_configure(cur->id, true); //RENEW uses SOLICIT
+    dhcp_client_configure(cur->id, true, true, true); //RENEW uses SOLICIT
     dhcp_client_solicit_timeout_set(cur->id, WS_DHCP_SOLICIT_TIMEOUT, WS_DHCP_SOLICIT_MAX_RT, WS_DHCP_SOLICIT_MAX_RC);
 
 
@@ -1877,21 +1875,8 @@ static void ws_rpl_prefix_callback(prefix_entry_t *prefix, void *handle, uint8_t
             addr_policy_table_add_entry(prefix->prefix, prefix->prefix_len, 2, WS_NON_PREFFRED_LABEL);
         }
     } else if (prefix->prefix_len) {
-        if (prefix->preftime == 0) {
-            // Delete all pending transactions from DHCP
-            // TODO this also deletes the address even when lifetime would allow it to be present
-            dhcp_client_global_address_delete(cur->id, NULL, prefix->prefix);
-        } else {
-            // Create new address using DHCP
-            ws_dhcp_client_address_request(cur, prefix->prefix, parent_link_local);
-        }
-        // If we have addresses generated we update the lifetimes always
-        ns_list_foreach(if_address_entry_t, entry, &cur->ip_addresses) {
-            if (entry->prefix_len == prefix->prefix_len && bitsequal(entry->address, prefix->prefix, prefix->prefix_len)) {
-                entry->preferred_lifetime = prefix->preftime;
-                entry->valid_lifetime = prefix->lifetime;
-            }
-        }
+        // Create new address using DHCP
+        ws_dhcp_client_address_request(cur, prefix->prefix, parent_link_local);
     }
 }
 

source/Common_Protocols/icmpv6.c

@@ -570,16 +570,8 @@ int icmpv6_slaac_prefix_update(struct protocol_interface_info_entry *cur, const
     //Validate first current list If prefix is already defined adress
     ns_list_foreach_safe(if_address_entry_t, e, &cur->ip_addresses) {
         if (e->source == ADDR_SOURCE_SLAAC && (e->prefix_len == prefix_len) && bitsequal(e->address, prefix_ptr, prefix_len)) {
-            //Update Current lifetimes (see RFC 4862 for rules detail)
-            if (valid_lifetime > (2 * 60 * 60) || valid_lifetime > e->valid_lifetime) {
-                addr_set_valid_lifetime(cur, e, valid_lifetime);
-            } else if (e->valid_lifetime <= (2 * 60 * 60)) {
-                //NOT Update Valid Lifetime
-            } else {
-                addr_set_valid_lifetime(cur, e, 2 * 60 * 60);
-            }
 
-            addr_set_preferred_lifetime(cur, e, preferred_lifetime);
+            addr_prefix_lifetime_update(cur, e, valid_lifetime, preferred_lifetime, 2 * 60 * 60);
             ret_val = 0;
         }
     }

source/Common_Protocols/icmpv6_prefix.c

@@ -35,9 +35,11 @@ prefix_entry_t *icmpv6_prefix_add(prefix_list_t *list, const uint8_t *prefixPtr,
 
     entry = icmpv6_prefix_compare(list, prefixPtr, prefix_len);
     if (entry) {
-        entry->options = flags;
-        entry->lifetime = lifeTime;
-        entry->preftime = prefTime;
+        if (flags != 0xff) {
+            entry->options = flags;
+            entry->lifetime = lifeTime;
+            entry->preftime = prefTime;
+        }
         return entry;
     }
 

source/Core/include/ns_address_internal.h

@@ -166,6 +166,8 @@ void addr_cb(struct protocol_interface_info_entry *interface, if_address_entry_t
 void addr_set_valid_lifetime(struct protocol_interface_info_entry *interface, if_address_entry_t *entry, uint32_t valid_lifetime);
 void addr_set_preferred_lifetime(struct protocol_interface_info_entry *interface, if_address_entry_t *entry, uint32_t preferred_lifetime);
 
+void addr_prefix_lifetime_update(struct protocol_interface_info_entry *interface, if_address_entry_t *address, uint32_t valid_lifetime, uint32_t preferred_lifetime, uint32_t threshold);
+
 int_fast8_t addr_policy_table_add_entry(const uint8_t *prefix, uint8_t len, uint8_t precedence, uint8_t label);
 int_fast8_t addr_policy_table_delete_entry(const uint8_t *prefix, uint8_t len);
 uint8_t addr_len_from_type(addrtype_t addr_type);

source/Core/ns_address_internal.c

@@ -1099,6 +1099,20 @@ void addr_set_preferred_lifetime(protocol_interface_info_entry_t *interface, if_
     }
 }
 
+void addr_prefix_lifetime_update(protocol_interface_info_entry_t *interface, if_address_entry_t *address, uint32_t valid_lifetime, uint32_t preferred_lifetime, uint32_t threshold)
+{
+    //Update Current lifetimes (see RFC 4862 for rules detail)
+    if (valid_lifetime > (threshold) || valid_lifetime > address->valid_lifetime) {
+        addr_set_valid_lifetime(interface, address, valid_lifetime);
+    } else if (address->valid_lifetime <= (threshold)) {
+        //NOT Update Valid Lifetime
+    } else {
+        addr_set_valid_lifetime(interface, address, threshold);
+    }
+
+    addr_set_preferred_lifetime(interface, address, preferred_lifetime);
+}
+
 void memswap(uint8_t *restrict a, uint8_t *restrict b, uint_fast8_t len)
 {
     while (len--) {

source/DHCPv6_client/dhcpv6_client_api.h

@@ -38,9 +38,12 @@ void dhcp_client_init(int8_t interface);
 
 /* Set configurations for DHCP client
  *
+ * /param interface Client Inteface ID
  * /param renew_uses_solicit Instead of renew message SOLICIT is used.
+ * /param one_client_for_this_interface True Interface use oneinstance for allocate address
+ * /param no_address_hint IAID use address at Solicit
  */
-void dhcp_client_configure(int8_t interface, bool renew_uses_solicit);
+void dhcp_client_configure(int8_t interface, bool renew_uses_solicit, bool one_client_for_this_interface, bool no_address_hint);
 
 /* Set Timeout parameters for SOLICIT transactions
  *

source/DHCPv6_client/dhcpv6_client_service.c

@@ -41,11 +41,14 @@ typedef struct {
     uint8_t libDhcp_instance;
     int8_t interface;
     bool renew_uses_solicit: 1;
+    bool one_instance_interface: 1;
+    bool no_address_hint: 1;
 } dhcp_client_class_t;
 
 static dhcp_client_class_t dhcp_client;
 
 void dhcpv6_client_set_address(int8_t interface_id, dhcpv6_client_server_data_t *srv_data_ptr);
+void dhcpv6_renew(protocol_interface_info_entry_t *interface, if_address_entry_t *addr, if_address_callback_t reason);
 
 
 void dhcp_client_init(int8_t interface)
@@ -57,14 +60,19 @@ void dhcp_client_init(int8_t interface)
     dhcp_client.sol_timeout = 0;
     dhcp_client.sol_max_rt = 0;
     dhcp_client.sol_max_rc = 0;
+    dhcp_client.renew_uses_solicit = false;
+    dhcp_client.one_instance_interface = false;
+    dhcp_client.no_address_hint = false;
 
     return;
 }
-void dhcp_client_configure(int8_t interface, bool renew_uses_solicit)
+void dhcp_client_configure(int8_t interface, bool renew_uses_solicit, bool one_client_for_this_interface, bool no_address_hint)
 {
     // Set true if RENEW is not used and SOLICIT sent instead.
     (void)interface;
     dhcp_client.renew_uses_solicit = renew_uses_solicit;
+    dhcp_client.one_instance_interface = one_client_for_this_interface;
+    dhcp_client.no_address_hint = no_address_hint;
 }
 
 void dhcp_client_solicit_timeout_set(int8_t interface, uint16_t timeout, uint16_t max_rt, uint8_t max_rc)
@@ -170,6 +178,19 @@ int dhcp_solicit_resp_cb(uint16_t instance_id, void *ptr, uint8_t msg_name,  uin
         goto error_exit;
     }
 
+    if (dhcp_client.one_instance_interface && memcmp(srv_data_ptr->iaNontemporalAddress.addressPrefix, dhcp_ia_non_temporal_params.nonTemporalAddress, 16)) {
+
+        protocol_interface_info_entry_t *cur = protocol_stack_interface_info_get_by_id(dhcp_client.interface);
+        if (cur) {
+            ns_list_foreach(if_address_entry_t, e, &cur->ip_addresses) {
+                if (memcmp(e->address, srv_data_ptr->iaNontemporalAddress.addressPrefix, 16) == 0) {
+                    tr_debug("Depreacate address %s", trace_ipv6(srv_data_ptr->iaNontemporalAddress.addressPrefix));
+                    addr_prefix_lifetime_update(cur, e, 0, 0, 30*60); //Accept max 30 min lifetime
+                }
+            }
+        }
+    }
+
     memcpy(srv_data_ptr->iaNontemporalAddress.addressPrefix, dhcp_ia_non_temporal_params.nonTemporalAddress, 16);
     srv_data_ptr->iaNontemporalAddress.preferredTime = dhcp_ia_non_temporal_params.preferredValidLifeTime;
     srv_data_ptr->iaNontemporalAddress.validLifetime = dhcp_ia_non_temporal_params.validLifeTime;
@@ -198,16 +219,25 @@ int dhcp_client_get_global_address(int8_t interface, uint8_t dhcp_addr[static 16
     uint8_t *payload_ptr;
     uint32_t payload_len;
     dhcpv6_client_server_data_t *srv_data_ptr;
+    bool add_prefix;
 
     if (mac64 == NULL || dhcp_addr == NULL) {
         tr_error("Invalid parameters");
         return -1;
     }
 
-    if (!prefix) {
+    if (!prefix || dhcp_client.one_instance_interface) {
         //NULL Definition will only check That Interface is not generated
-        if (libdhcpv6_nonTemporal_entry_get_by_instance(dhcp_client.libDhcp_instance)) {
+        srv_data_ptr = libdhcpv6_nonTemporal_entry_get_by_instance(dhcp_client.libDhcp_instance);
+        if (srv_data_ptr) {
             //Already Created to same interface
+            if (dhcp_client.one_instance_interface && prefix) {
+                if (srv_data_ptr->iaNonTemporalStructValid) {
+                    srv_data_ptr->iaNonTemporalStructValid = false;
+                    dhcpv6_renew(protocol_stack_interface_info_get_by_id(interface), NULL, ADDR_CALLBACK_TIMER);
+                    return 0;
+                }
+            }
             return -1;
         }
     } else if (libdhcpv6_nonTemporal_entry_get_by_prefix(interface, prefix)) {
@@ -224,7 +254,15 @@ int dhcp_client_get_global_address(int8_t interface, uint8_t dhcp_addr[static 16
         return -1;
     }
 
-    payload_len = libdhcpv6_solication_message_length(link_type, prefix != NULL, 0);
+
+    if (!prefix || dhcp_client.no_address_hint) {
+        add_prefix = false;
+    } else {
+        add_prefix = prefix != NULL;
+    }
+
+    payload_len = libdhcpv6_solication_message_length(link_type, add_prefix, 0);
+
 
     payload_ptr = ns_dyn_mem_temporary_alloc(payload_len);
     if (!payload_ptr) {
@@ -243,7 +281,7 @@ int dhcp_client_get_global_address(int8_t interface, uint8_t dhcp_addr[static 16
     solPacket.transActionId = libdhcpv6_txid_get();
     /*Non Temporal Address */
 
-    if (prefix) {
+    if (prefix && !dhcp_client.no_address_hint) {
         dhcpv6_ia_non_temporal_address_s nonTemporalAddress = {0};
         nonTemporalAddress.requestedAddress = prefix;
         libdhcpv6_generic_nontemporal_address_message_write(payload_ptr, &solPacket, &nonTemporalAddress, NULL);
@@ -258,6 +296,7 @@ int dhcp_client_get_global_address(int8_t interface, uint8_t dhcp_addr[static 16
         libdhcvp6_nontemporalAddress_server_data_free(srv_data_ptr);
         return -1;
     }
+    srv_data_ptr->iaNonTemporalStructValid = false;
     if (dhcp_client.sol_timeout != 0) {
         // Default retry values are modified from specification update to message
         dhcp_service_set_retry_timers(srv_data_ptr->transActionId, dhcp_client.sol_timeout, dhcp_client.sol_max_rt, dhcp_client.sol_max_rc);
@@ -299,14 +338,18 @@ void dhcp_client_global_address_delete(int8_t interface, uint8_t *dhcp_addr, uin
 
 void dhcpv6_renew(protocol_interface_info_entry_t *interface, if_address_entry_t *addr, if_address_callback_t reason)
 {
-    dhcpv6_ia_non_temporal_address_s nonTemporalAddress = {0};
+
     dhcp_link_options_params_t serverLink;
     uint8_t *payload_ptr;
     uint32_t payload_len;
-    dhcpv6_client_server_data_t *srv_data_ptr = libdhcpv6_nonTemporal_entry_get_by_prefix(interface->id, addr->address);
+    dhcpv6_client_server_data_t *srv_data_ptr;
+    if (addr) {
+        srv_data_ptr = libdhcpv6_nonTemporal_entry_get_by_prefix(interface->id, addr->address);
+    } else {
+        srv_data_ptr = libdhcpv6_nonTemporal_entry_get_by_instance(dhcp_client.libDhcp_instance);
+    }
 
     if (srv_data_ptr == NULL) {
-        tr_warn("Dhcp address lost");
         return ;
     }
     if (reason == ADDR_CALLBACK_INVALIDATED) {
@@ -320,7 +363,7 @@ void dhcpv6_renew(protocol_interface_info_entry_t *interface, if_address_entry_t
         return;
     }
 
-    payload_len = libdhcpv6_address_request_message_len(srv_data_ptr->clientLinkIdType, srv_data_ptr->serverLinkType, 0);
+    payload_len = libdhcpv6_address_request_message_len(srv_data_ptr->clientLinkIdType, srv_data_ptr->serverLinkType, 0, !dhcp_client.no_address_hint);
     payload_ptr = ns_dyn_mem_temporary_alloc(payload_len);
     if (payload_ptr == NULL) {
         addr->state_timer = 200; //Retry after 20 seconds
@@ -342,13 +385,21 @@ void dhcpv6_renew(protocol_interface_info_entry_t *interface, if_address_entry_t
         packetReq.messageType = DHCPV6_SOLICATION_TYPE;
     }
 
-    // Set Address information
-    nonTemporalAddress.requestedAddress = srv_data_ptr->iaNontemporalAddress.addressPrefix;
-    nonTemporalAddress.preferredLifeTime = srv_data_ptr->iaNontemporalAddress.preferredTime;
-    nonTemporalAddress.validLifeTime = srv_data_ptr->iaNontemporalAddress.validLifetime;
+
     serverLink.linkID = srv_data_ptr->serverLinkId;
     serverLink.linkType = srv_data_ptr->serverLinkType;
-    libdhcpv6_generic_nontemporal_address_message_write(payload_ptr, &packetReq, &nonTemporalAddress, &serverLink);
+    if (dhcp_client.no_address_hint && dhcp_client.renew_uses_solicit) {
+        packetReq.timerT0 = 0;
+        packetReq.timerT1 = 0;
+        libdhcpv6_generic_nontemporal_address_message_write(payload_ptr, &packetReq, NULL, &serverLink);
+    } else {
+        // Set Address information
+        dhcpv6_ia_non_temporal_address_s nonTemporalAddress = {0};
+        nonTemporalAddress.requestedAddress = srv_data_ptr->iaNontemporalAddress.addressPrefix;
+        nonTemporalAddress.preferredLifeTime = srv_data_ptr->iaNontemporalAddress.preferredTime;
+        nonTemporalAddress.validLifeTime = srv_data_ptr->iaNontemporalAddress.validLifetime;
+        libdhcpv6_generic_nontemporal_address_message_write(payload_ptr, &packetReq, &nonTemporalAddress, &serverLink);
+    }
     // send solicit
     uint8_t *server_address = dhcp_service_relay_global_addres_get(dhcp_client.relay_instance);
     if (!server_address) {

source/RPL/rpl_control.c

@@ -691,7 +691,7 @@ static void rpl_control_process_prefix_options(protocol_interface_info_entry_t *
 
     rpl_neighbour_t *pref_parent = rpl_instance_preferred_parent(instance);
 
-//    const rpl_dodag_conf_t *conf = rpl_dodag_get_config(dodag);
+    rpl_dodag_update_unpublished_dio_prefix_start(dodag);
 
     for (;;) {
         const uint8_t *ptr = rpl_control_find_option(start, end - start, RPL_PREFIX_INFO_OPTION, 30);
@@ -735,6 +735,8 @@ static void rpl_control_process_prefix_options(protocol_interface_info_entry_t *
 
         start = ptr + 32;
     }
+
+    rpl_dodag_update_unpublished_dio_prefix_finish(dodag);
 }
 
 void rpl_control_process_prefix_option(prefix_entry_t *prefix, protocol_interface_info_entry_t *cur)
@@ -1156,7 +1158,7 @@ void rpl_control_transmit_dio(rpl_domain_t *domain, protocol_interface_info_entr
         } else {
             prefix->options &= ~ PIO_R;
 
-            if (rpl_dodag_mop(dodag) == RPL_MODE_NON_STORING) {
+            if (rpl_dodag_mop(dodag) == RPL_MODE_NON_STORING && prefix->lifetime != 0) {
                 continue;
             }
         }
@@ -1194,7 +1196,7 @@ void rpl_control_transmit_dio(rpl_domain_t *domain, protocol_interface_info_entr
     ns_list_foreach_safe(prefix_entry_t, prefix, prefixes) {
         /* See equivalent checks in length calculation above */
         if ((prefix->options & (PIO_L | RPL_PIO_PUBLISHED)) == PIO_L ||
-                (!(prefix->options & PIO_R) && rpl_dodag_mop(dodag) == RPL_MODE_NON_STORING)) {
+                (!(prefix->options & PIO_R) && rpl_dodag_mop(dodag) == RPL_MODE_NON_STORING && prefix->lifetime != 0)) {
             continue;
         }
 
@@ -1207,6 +1209,14 @@ void rpl_control_transmit_dio(rpl_domain_t *domain, protocol_interface_info_entr
         common_write_32_bit(0, ptr + 12); // reserved
         memcpy(ptr + 16, prefix->prefix, 16);
         ptr += 32;
+        /* Transmitting a multicast DIO decrements the hold count for 0 lifetime prefixes */
+        if (dst == NULL && (prefix->options & RPL_PIO_AGE)) {
+            int hold_count = prefix->options & RPL_PIO_HOLD_MASK;
+            if (hold_count) {
+                hold_count--;
+                prefix->options = (prefix->options & ~RPL_PIO_HOLD_MASK) | hold_count;
+            }
+        }
     }
 
     ns_list_foreach_safe(rpl_dio_route_t, route, routes) {