Modified ARO registrations timeouts from the address lifetime

ARO registrations are changed to the same length as Link timeout

Created periodic timer to update ARO registrations at NUD interval
This prevents NUDS to be sent to parent and replaced with ARO messages

In RPL created interface to allow flexible address registration time

ARO registrations update link timeout for parents
if cild links are about to die NUD is sent

Author: Mika Tervonen

source/6LoWPAN/ws/ws_bootstrap.c

@@ -98,6 +98,8 @@ static ws_nud_table_entry_t *ws_nud_entry_discover(protocol_interface_info_entry
 static void ws_nud_entry_remove(protocol_interface_info_entry_t *cur, mac_neighbor_table_entry_t *entry_ptr);
 static bool ws_neighbor_entry_nud_notify(mac_neighbor_table_entry_t *entry_ptr, void *user_data);
 
+static void ws_address_registration_update(protocol_interface_info_entry_t *interface, const uint8_t addr[16]);
+
 
 static void ws_bootstrap_candidate_table_reset(protocol_interface_info_entry_t *cur);
 static parent_info_t *ws_bootstrap_candidate_parent_get(struct protocol_interface_info_entry *cur, const uint8_t *addr, bool create);
@@ -161,7 +163,7 @@ static void ws_bootstrap_address_notification_cb(struct protocol_interface_info_
         //Trig Address Registartion only when Bootstrap is ready
         if (interface->nwk_bootstrap_state == ER_BOOTSRAP_DONE && addr->source != ADDR_SOURCE_DHCP) {
             tr_debug("Address registration %s", trace_ipv6(addr->address));
-            rpl_control_register_address(interface, addr->address);
+            ws_address_registration_update(interface, addr->address);
         }
         if (addr_ipv6_scope(addr->address, interface) > IPV6_SCOPE_LINK_LOCAL) {
             // at least ula address available inside mesh.
@@ -192,7 +194,7 @@ static void ws_bootstrap_address_notification_cb(struct protocol_interface_info_
         if (addr->source != ADDR_SOURCE_DHCP) {
             tr_debug("Address Re registration %s", trace_ipv6(addr->address));
             //Register
-            rpl_control_register_address(interface, addr->address);
+            ws_address_registration_update(interface, addr->address);
         }
     }
 }
@@ -1622,12 +1624,19 @@ static bool ws_neighbor_entry_nud_notify(mac_neighbor_table_entry_t *entry_ptr,
 
     if (time_from_start > WS_NEIGHBOR_NUD_TIMEOUT) {
 
-        if (ipv6_neighbour_has_registered_by_eui64(&cur->ipv6_neighbour_cache, entry_ptr->mac64)) {
-            // This is our child with valid ARO registration Change link timeout to future we check at 2 minute intervals
-            entry_ptr->lifetime = entry_ptr->lifetime + 120;
-            if (entry_ptr->lifetime > entry_ptr->link_lifetime) {
-                entry_ptr->lifetime = entry_ptr->link_lifetime;
-            }
+        /* For parents ARO registration is sent in link timeout times
+         * For candidate parents NUD is needed
+         * For children NUD is sent only at very close to end
+         */
+        if (ipv6_neighbour_has_registered_by_eui64(&cur->ipv6_neighbour_cache, entry_ptr->mac64) &&
+                (time_from_start < WS_NEIGHBOR_NUD_TIMEOUT * 1.8)) {
+            /* This is our child with valid ARO registration send NUD if we are close to delete
+             *
+             * if ARO was received link is considered active so this is only in case of very long ARO registration times
+             *
+             * 1.8 means with link timeout of 30 minutes that NUD is sent 6 minutes before timeout
+             *
+             */
             return false;
         }
 
@@ -1993,10 +2002,33 @@ static void ws_set_fhss_hop(protocol_interface_info_entry_t *cur)
     tr_debug("own hop: %u, own rank: %u, rank inc: %u", own_hop, own_rank, rank_inc);
 }
 
-static void ws_address_registration_update(protocol_interface_info_entry_t *interface)
+static void ws_address_registration_update(protocol_interface_info_entry_t *interface, const uint8_t addr[16])
+{
+    rpl_control_register_address(interface, addr);
+    // Timer is used only to track full registrations
+
+    if (addr != NULL && interface->ws_info->aro_registration_timer) {
+        // Single address update and timer is running
+        return;
+    }
+
+    if (interface->ws_info->aro_registration_timer == 0) {
+        // Timer expired and check if we have valid address to register
+        ns_list_foreach(if_address_entry_t, address, &interface->ip_addresses) {
+            if (!addr_is_ipv6_link_local(address->address)) {
+                // We have still valid addresses let the timer run for next period
+                tr_info("ARO registration timer start");
+                interface->ws_info->aro_registration_timer = WS_NEIGHBOR_NUD_TIMEOUT;
+                return;
+            }
+        }
+    }
+}
+
+static void ws_address_parent_update(protocol_interface_info_entry_t *interface)
 {
-    rpl_control_register_address(interface, NULL);
     tr_info("RPL parent update ... register ARO");
+    ws_address_registration_update(interface, NULL);
 }
 
 static void ws_bootstrap_rpl_callback(rpl_event_t event, void *handle)
@@ -2042,7 +2074,7 @@ static void ws_bootstrap_rpl_callback(rpl_event_t event, void *handle)
          */
 
     } else if (event == RPL_EVENT_DAO_PARENT_ADD) {
-        ws_address_registration_update(cur);
+        ws_address_parent_update(cur);
     }
     cur->ws_info->rpl_state = event;
     tr_info("RPL event %d", event);
@@ -2057,7 +2089,7 @@ static void ws_dhcp_client_global_adress_cb(int8_t interface, uint8_t dhcp_addr[
     if (register_status) {
         protocol_interface_info_entry_t *cur = protocol_stack_interface_info_get_by_id(interface);
         if (cur) {
-            rpl_control_register_address(cur, prefix);
+            ws_address_registration_update(cur, prefix);
         }
     } else {
         //Delete dhcpv6 client
@@ -2283,6 +2315,7 @@ static void ws_bootstrap_rpl_activate(protocol_interface_info_entry_t *cur)
     rpl_control_process_routes(protocol_6lowpan_rpl_domain, false); // Wi-SUN assumes that no default route needed
     rpl_control_request_parent_link_confirmation(true);
     rpl_control_set_dio_multicast_min_config_advertisment_count(WS_MIN_DIO_MULTICAST_CONFIG_ADVERTISMENT_COUNT);
+    rpl_control_set_address_registration_timeout((WS_NEIGHBOR_LINK_TIMEOUT / 60) + 1);
     rpl_control_set_dao_retry_count(WS_MAX_DAO_RETRIES);
     rpl_control_set_initial_dao_ack_wait(WS_MAX_DAO_INITIAL_TIMEOUT);
     rpl_control_set_mrhof_parent_set_size(WS_MAX_PARENT_SET_COUNT);
@@ -3083,6 +3116,16 @@ void ws_bootstrap_seconds_timer(protocol_interface_info_entry_t *cur, uint32_t s
             ws_bootstrap_event_discovery_start(cur);
         }
     }
+    if (cur->ws_info->aro_registration_timer) {
+        if (cur->ws_info->aro_registration_timer > seconds) {
+            cur->ws_info->aro_registration_timer -= seconds;
+        } else {
+            // Update all addressess. This function will update the timer value if needed
+            cur->ws_info->aro_registration_timer = 0;
+            ws_address_registration_update(cur, NULL);
+        }
+    }
+
 }
 
 void ws_primary_parent_update(protocol_interface_info_entry_t *interface, mac_neighbor_table_entry_t *neighbor)
@@ -3105,7 +3148,7 @@ void ws_secondary_parent_update(protocol_interface_info_entry_t *interface)
     if (interface->ws_info) {
         ns_list_foreach(if_address_entry_t, address, &interface->ip_addresses) {
             if (!addr_is_ipv6_link_local(address->address)) {
-                ws_address_registration_update(interface);
+                ws_address_parent_update(interface);
             }
         }
     }

source/6LoWPAN/ws/ws_common.c

@@ -418,6 +418,14 @@ uint8_t ws_common_allow_child_registration(protocol_interface_info_entry_t *inte
 
     //Validate Is EUI64 already allocated for any address
     if (ipv6_neighbour_has_registered_by_eui64(&interface->ipv6_neighbour_cache, eui64)) {
+        /*
+         * ARO registration from child can update the link timeout so we don't need to send extra NUD if ARO received
+         */
+        mac_neighbor_table_entry_t *mac_neighbor = mac_neighbor_entry_get_by_mac64(mac_neighbor_info(interface), eui64, false, false);
+
+        if (mac_neighbor) {
+            mac_neighbor_table_neighbor_refresh(mac_neighbor_info(interface), mac_neighbor, mac_neighbor->link_lifetime);
+        }
         tr_info("Child registration from old child");
         return ARO_SUCCESS;
     }

source/6LoWPAN/ws/ws_common.h

@@ -88,6 +88,7 @@ typedef struct ws_info_s {
     parent_info_t parent_info[WS_PARENT_LIST_SIZE];
     parent_info_list_t parent_list_free;
     parent_info_list_t parent_list_reserved;
+    uint16_t aro_registration_timer;       /**< Aro registration timer */
     uint16_t rpl_version_timer;            /**< RPL version update timeout */
     uint32_t pan_timeout_timer;    /**< routers will fallback to previous state after this */
     uint32_t pan_config_sol_max_timeout;

source/Common_Protocols/icmpv6.c

@@ -1377,6 +1377,7 @@ void ack_remove_neighbour_cb(struct buffer *buffer_ptr, uint8_t status)
 
 static void icmpv6_aro_cb(buffer_t *buf, uint8_t status)
 {
+    (void)status;
     uint8_t ll_address[16];
     if (buf->dst_sa.addr_type == ADDR_IPV6) {
         /*Full IPv6 address*/
@@ -1387,8 +1388,8 @@ static void icmpv6_aro_cb(buffer_t *buf, uint8_t status)
         memcpy(ll_address + 8, &buf->dst_sa.address[2], 8);
         ll_address[8] ^= 2;
     }
-    rpl_control_address_register_done(buf->interface, ll_address, status);
-    if (status != SOCKET_TX_DONE) {
+    if (rpl_control_address_register_done(buf->interface, ll_address, status)) {
+        // When RPL returns true neighbor should be blacklisted
         ws_common_aro_failure(buf->interface, ll_address);
     }
 }

source/RPL/rpl_control.c

@@ -181,6 +181,11 @@ void rpl_control_set_dio_multicast_min_config_advertisment_count(uint8_t min_cou
     rpl_policy_set_dio_multicast_config_advertisment_min_count(min_count);
 }
 
+void rpl_control_set_address_registration_timeout(uint16_t timeout_in_minutes)
+{
+    rpl_policy_set_address_registration_timeout(timeout_in_minutes);
+}
+
 void rpl_control_set_dao_retry_count(uint8_t count)
 {
     rpl_policy_set_dao_retry_count(count);
@@ -201,6 +206,9 @@ void rpl_control_set_mrhof_parent_set_size(uint16_t parent_set_size)
 /* Send address registration to either specified address, or to non-registered address */
 void rpl_control_register_address(protocol_interface_info_entry_t *interface, const uint8_t addr[16])
 {
+    if (!interface->rpl_domain) {
+        return;
+    }
     if (!rpl_policy_parent_confirmation_requested()) {
         return;
     }
@@ -209,21 +217,23 @@ void rpl_control_register_address(protocol_interface_info_entry_t *interface, co
     }
 }
 
-void rpl_control_address_register_done(protocol_interface_info_entry_t *interface, const uint8_t ll_addr[16], uint8_t status)
+bool rpl_control_address_register_done(protocol_interface_info_entry_t *interface, const uint8_t ll_addr[16], uint8_t status)
 {
+    bool blacklist_neighbour = false;
     if (!interface->rpl_domain) {
-        return;
+        return false;
     }
     if (!rpl_policy_parent_confirmation_requested()) {
-        return;
+        return false;
     }
 
     ns_list_foreach(struct rpl_instance, instance, &interface->rpl_domain->instances) {
         rpl_neighbour_t *neighbour = rpl_lookup_neighbour_by_ll_address(instance, ll_addr, interface->id);
         if (neighbour) {
-            rpl_instance_address_registration_done(interface, instance, neighbour, status);
+            blacklist_neighbour = blacklist_neighbour || rpl_instance_address_registration_done(interface, instance, neighbour, status);
         }
     }
+    return blacklist_neighbour;
 }
 
 bool rpl_control_is_dodag_parent(protocol_interface_info_entry_t *interface, const uint8_t ll_addr[16])

source/RPL/rpl_control.h

@@ -173,12 +173,13 @@ bool rpl_control_find_worst_neighbor(struct protocol_interface_info_entry *inter
 /* Parent link confirmation API extension */
 void rpl_control_request_parent_link_confirmation(bool requested);
 void rpl_control_set_dio_multicast_min_config_advertisment_count(uint8_t min_count);
+void rpl_control_set_address_registration_timeout(uint16_t timeout_in_minutes);
 void rpl_control_set_dao_retry_count(uint8_t count);
 void rpl_control_set_minimum_dao_target_refresh(uint16_t seconds);
 void rpl_control_set_initial_dao_ack_wait(uint16_t timeout_in_ms);
 void rpl_control_set_mrhof_parent_set_size(uint16_t parent_set_size);
 void rpl_control_register_address(struct protocol_interface_info_entry *interface, const uint8_t addr[16]);
-void rpl_control_address_register_done(struct protocol_interface_info_entry *interface, const uint8_t ll_addr[16], uint8_t status);
+bool rpl_control_address_register_done(struct protocol_interface_info_entry *interface, const uint8_t ll_addr[16], uint8_t status);
 
 /* Configure and return the routing lookup predicate for a specified RPL instance ID */
 ipv6_route_predicate_fn_t *rpl_control_get_route_predicate(rpl_domain_t *domain, uint8_t instance_id, const uint8_t src[16], const uint8_t dst[16]);
@@ -202,7 +203,7 @@ uint8_t rpl_policy_mrhof_parent_set_size_get(const rpl_domain_t *domain);
 #define rpl_control_remove_domain_from_interface(cur) ((void) 0)
 #define rpl_control_free_domain_instances_from_interface(cur) ((void) 0)
 #define rpl_control_register_address(interface, addr) ((void) 0)
-#define rpl_control_address_register_done(interface, ll_addr, status) ((void) 0)
+#define rpl_control_address_register_done(interface, ll_addr, status) (false)
 #define rpl_policy_mrhof_parent_set_size_get(domain) (0)
 #define rpl_control_set_mrhof_parent_set_size(parent_set_size)
 

source/RPL/rpl_downward.c

@@ -1783,8 +1783,11 @@ static bool rpl_instance_push_address_registration(protocol_interface_info_entry
 
     aro.status = ARO_SUCCESS;
     aro.present = true;
-    aro.lifetime = (addr->valid_lifetime / 60) + 1;
     memcpy(aro.eui64, interface->mac, 8);
+    aro.lifetime = rpl_policy_address_registration_timeout();
+    if (!aro.lifetime) {
+        aro.lifetime = (addr->valid_lifetime / 60) + 1;
+    }
 
     buffer_t *buf = icmpv6_build_ns(interface, neighbour->ll_address, addr->address, true, false, &aro);
     if (!buf) {
@@ -1819,6 +1822,13 @@ static void rpl_instance_address_registration_cancel(rpl_instance_t *instance)
     instance->dao_retry_timer = 0;
 }
 
+static void rpl_instance_address_registration_retry(rpl_dao_target_t *dao_target)
+{
+    dao_target->active_confirmation_state = true; // Active timer is set true so the response_wait_time runs out
+    dao_target->trig_confirmation_state = true;
+    dao_target->response_wait_time = 20; // Wait 20 seconds before retry
+}
+
 void rpl_instance_parent_address_reg_timer_update(rpl_instance_t *instance, uint16_t seconds)
 {
     if (!instance->pending_neighbour_confirmation) {
@@ -1873,41 +1883,48 @@ void rpl_instance_parent_address_reg_timer_update(rpl_instance_t *instance, uint
         return;
     }
 
-
     if (rpl_instance_push_address_registration(interface, neighbour, address)) {
         instance->wait_response = neighbour;
         dao_target->response_wait_time = 5;
     }
 
 }
 
-void rpl_instance_address_registration_done(protocol_interface_info_entry_t *interface, rpl_instance_t *instance, rpl_neighbour_t *neighbour, uint8_t status)
+bool rpl_instance_address_registration_done(protocol_interface_info_entry_t *interface, rpl_instance_t *instance, rpl_neighbour_t *neighbour, uint8_t status)
 {
-
     if (!instance->pending_neighbour_confirmation) {
-        return;
+        return false;
     }
 
     rpl_dao_target_t *dao_target = rpl_instance_get_active_target_confirmation(instance);
     if (!dao_target || instance->wait_response != neighbour) {
-        return;
+        return false;
     }
 
     tr_debug("Address %s register to %s", trace_ipv6(dao_target->prefix), trace_ipv6(neighbour->ll_address));
 
-    if (status == SOCKET_TX_DONE) {
-        /* State_timer is 1/10 s. Set renewal to 75-85% of lifetime */
-        if_address_entry_t *address = rpl_interface_addr_get(interface, dao_target->prefix);
-        if (address && address->source != ADDR_SOURCE_DHCP) {
-            address->state_timer = (address->preferred_lifetime * randLIB_get_random_in_range(75, 85) / 10);
+    if (status != SOCKET_TX_DONE) {
+        if (neighbour->addr_reg_failures > 0) {
+            // Neighbor should be blacklisted after this.
+            tr_error("Address registration failed delete neighbor");
+            rpl_instance_address_registration_cancel(instance);
+            rpl_delete_neighbour(instance, neighbour);
+            return true;
         }
-        neighbour->confirmed = true;
-        dao_target->response_wait_time = 6;
-    } else {
-        tr_error("Address registration failed");
-        rpl_delete_neighbour(instance, neighbour);
-        rpl_instance_address_registration_cancel(instance);
+        tr_warn("Address registration ACK fail retry selection");
+        neighbour->addr_reg_failures++;
+        rpl_instance_address_registration_retry(dao_target);
+        return false;
+    }
+    /* State_timer is 1/10 s. Set renewal to 75-85% of lifetime */
+    if_address_entry_t *address = rpl_interface_addr_get(interface, dao_target->prefix);
+    if (address && address->source != ADDR_SOURCE_DHCP) {
+        address->state_timer = (address->preferred_lifetime * randLIB_get_random_in_range(75, 85) / 10);
     }
+    neighbour->addr_reg_failures = 0;
+    neighbour->confirmed = true;
+    dao_target->response_wait_time = 6;
+    return false;
 }
 
 #endif /* HAVE_RPL */

source/RPL/rpl_downward.h

@@ -43,7 +43,7 @@ void rpl_instance_dao_trigger(struct rpl_instance *instance, uint16_t delay);
 void rpl_instance_dao_acked(struct rpl_instance *instance, const uint8_t src[16], int8_t interface_id, uint8_t dao_sequence, uint8_t status);
 void rpl_instance_parent_address_reg_timer_update(struct rpl_instance *instance, uint16_t seconds);
 void rpl_instance_send_address_registration(rpl_instance_t *instance, const uint8_t addr[16]);
-void rpl_instance_address_registration_done(protocol_interface_info_entry_t *interface, rpl_instance_t *instance, rpl_neighbour_t *neighbour, uint8_t status);
+bool rpl_instance_address_registration_done(protocol_interface_info_entry_t *interface, rpl_instance_t *instance, rpl_neighbour_t *neighbour, uint8_t status);
 struct rpl_dao_target *rpl_instance_get_active_target_confirmation(struct rpl_instance *instance);
 
 #ifdef HAVE_RPL_DAO_HANDLING

source/RPL/rpl_policy.c

@@ -41,6 +41,8 @@ static uint16_t rpl_policy_dio_validity_period_hysteresis = 0x0180; //Fixed Poin
 static uint8_t rpl_policy_multicast_config_min_advertisment_count = 0;
 static uint8_t rpl_policy_mrhof_parent_set_size_conf = 3; // default parent set size
 static uint16_t rpl_policy_minimum_dao_target_refresh_conf = 0; // by default follow the configuration
+static uint16_t rpl_policy_address_registration_timeout_value = 0; // Address registration timeouts in minutes 0 use address lifetime
+
 /* TODO - application API to control when to join new instances / DODAGs
  *
  * Eg, allow application to ignore local DODAGs, or specify known instance IDs,
@@ -391,6 +393,16 @@ void rpl_policy_set_dio_multicast_config_advertisment_min_count(uint8_t min_coun
     rpl_policy_multicast_config_min_advertisment_count = min_count;
 }
 
+uint16_t rpl_policy_address_registration_timeout()
+{
+    return rpl_policy_address_registration_timeout_value;
+}
+
+void rpl_policy_set_address_registration_timeout(uint16_t timeout_in_minutes)
+{
+    rpl_policy_address_registration_timeout_value = timeout_in_minutes;
+}
+
 
 #ifdef RPL_STRUCTURES_H_
 #error "rpl_structures.h should not be included by rpl_policy.c"

source/RPL/rpl_policy.h

@@ -71,5 +71,7 @@ bool rpl_policy_parent_confirmation_requested(void);
 void rpl_policy_set_parent_confirmation_request(bool confirmation_requested);
 uint8_t rpl_policy_dio_multicast_config_advertisment_min_count(void);
 void rpl_policy_set_dio_multicast_config_advertisment_min_count(uint8_t min_count);
+uint16_t rpl_policy_address_registration_timeout();
+void rpl_policy_set_address_registration_timeout(uint16_t timeout_in_minutes);
 
 #endif /* RPL_POLICY_H_ */