Send address registration to all PC parents (ARMmbed#1618)

Send non-ll address registration to path control parents.

Author: Tero Heinonen

source/6LoWPAN/ws/ws_bootstrap.c

@@ -77,7 +77,7 @@ static void ws_bootstrap_state_change(protocol_interface_info_entry_t *cur, icmp
 static bool ws_bootstrap_state_active(struct protocol_interface_info_entry *cur);
 static bool ws_bootstrap_state_discovery(struct protocol_interface_info_entry *cur);
 static bool ws_bootstrap_state_wait_rpl(struct protocol_interface_info_entry *cur);
-
+static int8_t ws_bootsrap_event_trig(ws_bootsrap_event_type_e event_type, int8_t interface_id, arm_library_event_priority_e priority, void *event_data);
 static mac_neighbor_table_entry_t * ws_bootstrap_add_neighbor(struct protocol_interface_info_entry *interface, const uint8_t *src64)
 {
     mac_neighbor_table_entry_t *neighbor = mac_neighbor_table_address_discover(interface->mac_parameters->mac_neighbor_table, src64, MAC_ADDR_MODE_64_BIT);
@@ -94,30 +94,6 @@ static mac_neighbor_table_entry_t * ws_bootstrap_add_neighbor(struct protocol_in
 }
 
 
-static void ws_bootstrap_address_registration_ns_send(struct protocol_interface_info_entry *interface, const struct if_address_entry *addr)
-{
-    aro_t aro;
-    buffer_t *buf;
-
-    tr_debug("Send ARO");
-
-    aro.status = ARO_SUCCESS;
-    aro.present = true;
-    aro.lifetime = addr->preferred_lifetime;
-    memcpy(aro.eui64, interface->mac, 8);
-
-    /* Fill address to be registered */
-    memcpy(&interface->if_6lowpan_dad_process.address, addr->address, 16);
-
-    ns_list_foreach(struct rpl_instance, instance, &interface->rpl_domain->instances) {
-        const uint8_t *preferred_parent = rpl_control_preferred_parent_addr(instance, false);
-        if (preferred_parent) {
-            buf = icmpv6_build_ns(interface, preferred_parent, addr->address, true, false, &aro);
-            protocol_push(buf);
-        }
-    }
-}
-
 
 static void ws_bootstrap_address_notification_cb(struct protocol_interface_info_entry *interface, const struct if_address_entry *addr, if_address_callback_t reason)
 {
@@ -127,12 +103,12 @@ static void ws_bootstrap_address_notification_cb(struct protocol_interface_info_
     }
 
     if (reason == ADDR_CALLBACK_DAD_COMPLETE) {
-        // When SLAAC address is created, send NS with ARO to parent
-        ws_bootstrap_address_registration_ns_send(interface, addr);
+        ws_bootsrap_event_trig(WS_ADDRESS_ADDED, interface->bootStrapId, ARM_LIB_LOW_PRIORITY_EVENT, (void *)addr);
     } else if (reason == ADDR_CALLBACK_DELETED) {
         // What to do?
     }
 }
+
 static int ws_bootstrap_tasklet_init(protocol_interface_info_entry_t *cur)
 {
     if (cur->bootStrapId < 0) {
@@ -149,13 +125,14 @@ static int ws_bootstrap_tasklet_init(protocol_interface_info_entry_t *cur)
     return 0;
 }
 
-static int8_t ws_bootsrap_event_trig(ws_bootsrap_event_type_e event_type, int8_t interface_id, arm_library_event_priority_e priority)
+static int8_t ws_bootsrap_event_trig(ws_bootsrap_event_type_e event_type, int8_t interface_id, arm_library_event_priority_e priority, void *event_data)
 {
     arm_event_s event = {
         .receiver = interface_id,
         .sender = 0,
         .event_type = event_type,
         .priority = priority,
+        .data_ptr = event_data,
     };
     return eventOS_event_send(&event);
 }
@@ -912,23 +889,23 @@ static void ws_bootstrap_start_discovery(protocol_interface_info_entry_t *cur)
  * */
 void ws_bootstrap_event_discovery_start(protocol_interface_info_entry_t *cur)
 {
-    ws_bootsrap_event_trig(WS_DISCOVERY_START, cur->bootStrapId, ARM_LIB_LOW_PRIORITY_EVENT);
+    ws_bootsrap_event_trig(WS_DISCOVERY_START, cur->bootStrapId, ARM_LIB_LOW_PRIORITY_EVENT, NULL);
 }
 void ws_bootstrap_event_configuration_start(protocol_interface_info_entry_t *cur)
 {
-    ws_bootsrap_event_trig(WS_CONFIGURATION_START, cur->bootStrapId, ARM_LIB_LOW_PRIORITY_EVENT);
+    ws_bootsrap_event_trig(WS_CONFIGURATION_START, cur->bootStrapId, ARM_LIB_LOW_PRIORITY_EVENT, NULL);
 }
 void ws_bootstrap_event_authentication_start(protocol_interface_info_entry_t *cur)
 {
-    ws_bootsrap_event_trig(WS_AUTHENTICATION_START, cur->bootStrapId, ARM_LIB_LOW_PRIORITY_EVENT);
+    ws_bootsrap_event_trig(WS_AUTHENTICATION_START, cur->bootStrapId, ARM_LIB_LOW_PRIORITY_EVENT, NULL);
 }
 void ws_bootstrap_event_operation_start(protocol_interface_info_entry_t *cur)
 {
-    ws_bootsrap_event_trig(WS_OPERATION_START, cur->bootStrapId, ARM_LIB_LOW_PRIORITY_EVENT);
+    ws_bootsrap_event_trig(WS_OPERATION_START, cur->bootStrapId, ARM_LIB_LOW_PRIORITY_EVENT, NULL);
 }
 void ws_bootstrap_event_routing_ready(protocol_interface_info_entry_t *cur)
 {
-    ws_bootsrap_event_trig(WS_ROUTING_READY, cur->bootStrapId, ARM_LIB_LOW_PRIORITY_EVENT);
+    ws_bootsrap_event_trig(WS_ROUTING_READY, cur->bootStrapId, ARM_LIB_LOW_PRIORITY_EVENT, NULL);
 }
 
 
@@ -1010,6 +987,17 @@ static void ws_bootstrap_pan_config(protocol_interface_info_entry_t *cur)
     ws_llc_asynch_request(cur, &async_req);
 }
 
+static bool ws_bootstrap_address_registration_ongoing(protocol_interface_info_entry_t *cur)
+{
+    ns_list_foreach(if_address_entry_t, addr, &cur->ip_addresses) {
+        if (addr->addr_reg_pend != 0) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
 static void ws_bootstrap_event_handler(arm_event_s *event)
 {
     ws_bootsrap_event_type_e event_type;
@@ -1085,6 +1073,11 @@ static void ws_bootstrap_event_handler(arm_event_s *event)
         tr_info("Routing ready");
         ws_bootstrap_state_change(cur, ER_BOOTSRAP_DONE);
         break;
+    case WS_ADDRESS_ADDED:
+        if (!ws_bootstrap_address_registration_ongoing(cur)) {
+            rpl_control_register_address(cur, (if_address_entry_t *) event->data_ptr);
+        }
+        break;
     default:
         tr_err("Invalid event received");
         break;

source/6LoWPAN/ws/ws_bootstrap.h

@@ -20,12 +20,13 @@
 
 
 typedef enum {
-    WS_INIT_EVENT = 0, /**< tasklet initializion event*/
-    WS_DISCOVERY_START, /**< discovery start*/
-    WS_CONFIGURATION_START, /**< configuration learn start*/
+    WS_INIT_EVENT = 0,       /**< tasklet initializion event*/
+    WS_DISCOVERY_START,      /**< discovery start*/
+    WS_CONFIGURATION_START,  /**< configuration learn start*/
     WS_AUTHENTICATION_START, /**< authentication start*/
-    WS_OPERATION_START, /**< active operation start*/
-    WS_ROUTING_READY /**< RPL routing connected to BR*/
+    WS_OPERATION_START,      /**< active operation start*/
+    WS_ROUTING_READY,        /**< RPL routing connected to BR*/
+    WS_ADDRESS_ADDED         /**< Address added to IF*/
 } ws_bootsrap_event_type_e;
 
 #ifdef HAVE_WS

source/Common_Protocols/icmpv6.c

@@ -20,8 +20,8 @@
 #include "ns_trace.h"
 #include "randLIB.h"
 #include "NWK_INTERFACE/Include/protocol.h"
-#ifdef HAVE_RPL
 #include "RPL/rpl_control.h"
+#ifdef HAVE_RPL
 #include "RPL/rpl_data.h"
 #endif
 #include "RPL/rpl_protocol.h"
@@ -1214,25 +1214,6 @@ uint8_t *icmpv6_write_mtu_option(uint32_t mtu, uint8_t *dptr)
     return dptr;
 }
 
-static void icmpv6_ns_ack_cb(struct buffer *buf, uint8_t status)
-{
-    (void) buf;
-
-    if (status == SOCKET_TX_DONE) {
-        tr_debug("NS ARO ack received %s", trace_ipv6(buf->interface->if_6lowpan_dad_process.address));
-
-        if_address_entry_t *addr_entry = addr_get_entry(buf->interface, buf->interface->if_6lowpan_dad_process.address);
-        if (!addr_entry) {
-            return;
-        }
-        /* State_timer is 1/10 s. Set renewal to 75-85% of lifetime */
-        addr_entry->state_timer = (addr_entry->preferred_lifetime * randLIB_get_random_in_range(75, 85) / 10);
-    } else {
-        // todo: What to do when address registration fails?
-        tr_debug("NS ARO send failed");
-    }
-}
-
 buffer_t *icmpv6_build_ns(protocol_interface_info_entry_t *cur, const uint8_t target_addr[16], const uint8_t *prompting_src_addr, bool unicast, bool unspecified_source, const aro_t *aro)
 {
     if (!cur || addr_is_ipv6_multicast(target_addr)) {
@@ -1308,7 +1289,7 @@ buffer_t *icmpv6_build_ns(protocol_interface_info_entry_t *cur, const uint8_t ta
         /* If ARO Success sending is omitted, MAC ACK is used instead */
         /* Setting callback for receiving ACK from adaptation layer */
         if (aro && cur->ipv6_neighbour_cache.omit_aro_success) {
-            buf->ack_receive_cb = icmpv6_ns_ack_cb;
+            buf->ack_receive_cb = rpl_control_address_register_done;
         }
     }
     buf->src_sa.addr_type = ADDR_IPV6;

source/Core/include/address.h

@@ -96,6 +96,8 @@ typedef struct if_address_entry {
     bool temporary:1;           // RFC 4941 temporary address
     bool tentative:1;           // Tentative address (Duplicate Address Detection running)
     bool group_added:1;         // Solicited-Node group added
+    uint8_t addr_reg_pend;      // Bitmask for pending address registrations. Based on RPL path control bits
+    uint8_t addr_reg_done;      // Bitmask for address registration done. Based on RPL path control bits
     if_address_source_t source; //
     if_address_callback_fn *cb; // Address protocol callback function
     void *data;                 // Address protocol data

source/RPL/rpl_control.c

@@ -182,6 +182,51 @@ void rpl_control_unpublish_address(rpl_domain_t *domain, const uint8_t addr[16])
     }
 }
 
+static if_address_entry_t *rpl_instance_reg_addr_get(protocol_interface_info_entry_t *interface)
+{
+    ns_list_foreach(if_address_entry_t, address, &interface->ip_addresses) {
+        if (!address->addr_reg_done && !addr_is_ipv6_link_local(address->address)) {
+            return address;
+        }
+    }
+
+    return NULL;
+}
+
+/* Send address registration to either specified address, or to non-registered address */
+void rpl_control_register_address(protocol_interface_info_entry_t *interface, if_address_entry_t *addr)
+{
+    if_address_entry_t *reg_addr = addr;
+
+    if (!reg_addr) {
+        reg_addr = rpl_instance_reg_addr_get(interface);
+
+        if (!reg_addr) {
+            return;
+        }
+    }
+    ns_list_foreach(struct rpl_instance, instance, &interface->rpl_domain->instances) {
+        rpl_instance_send_address_registration(interface, instance, addr);
+    }
+}
+
+void rpl_control_address_register_done(struct buffer *buf, uint8_t status)
+{
+    ns_list_foreach(if_address_entry_t, addr, &buf->interface->ip_addresses) {
+
+        /* Optimize, ll addresses are not registered anyway.. */
+        if (addr_is_ipv6_link_local(addr->address) || !addr->addr_reg_pend) {
+            continue;
+        }
+
+        ns_list_foreach(struct rpl_instance, instance, &buf->interface->rpl_domain->instances) {
+            if (rpl_instance_address_registration_done(buf->interface, instance, addr, status)) {
+                return;
+            }
+        }
+    }
+}
+
 /* Address changes need to trigger DAO target re-evaluation */
 static void rpl_control_addr_notifier(struct protocol_interface_info_entry *interface, const if_address_entry_t *addr, if_address_callback_t reason)
 {

source/RPL/rpl_control.h

@@ -143,6 +143,8 @@ void rpl_control_set_callback(rpl_domain_t *domain, rpl_domain_callback_t callba
 /* Target publishing */
 void rpl_control_publish_host_address(rpl_domain_t *domain, const uint8_t addr[16], uint32_t lifetime);
 void rpl_control_unpublish_address(rpl_domain_t *domain, const uint8_t addr[16]);
+void rpl_control_register_address(struct protocol_interface_info_entry *interface, if_address_entry_t *addr);
+void rpl_control_address_register_done(struct buffer *buf, 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]);
@@ -157,11 +159,14 @@ bool rpl_control_read_dodag_info(const struct rpl_instance *instance, struct rpl
 const rpl_dodag_conf_t *rpl_control_get_dodag_config(const struct rpl_instance *instance);
 const uint8_t *rpl_control_preferred_parent_addr(const struct rpl_instance *instance, bool global);
 
+
 #else /* HAVE_RPL */
 
 #define rpl_control_fast_timer(ticks) ((void) 0)
 #define rpl_control_slow_timer(seconds) ((void) 0)
 #define rpl_control_remove_domain_from_interface(cur) ((void) 0)
+#define rpl_control_register_address(interface, addr) ((void) 0)
+#define rpl_control_address_register_done NULL
 
 #endif /* HAVE_RPL */
 

source/RPL/rpl_downward.c

@@ -88,6 +88,7 @@
 #include "randLIB.h"
 #include "ip6string.h"
 
+#include "Common_Protocols/icmpv6.h"
 #include "NWK_INTERFACE/Include/protocol.h"
 #include "ipv6_stack/ipv6_routing_table.h"
 
@@ -580,6 +581,61 @@ static void rpl_downward_reset_assigning(rpl_instance_t *instance, uint8_t pcs_m
 }
 
 
+void rpl_instance_send_address_registration(protocol_interface_info_entry_t *interface, rpl_instance_t *instance, if_address_entry_t *addr)
+{
+    aro_t aro;
+    buffer_t *buf;
+
+    aro.status = ARO_SUCCESS;
+    aro.present = true;
+    aro.lifetime = addr->preferred_lifetime;
+    memcpy(aro.eui64, interface->mac, 8);
+
+    // go through neighbour list, and send to all assigned parents.
+    ns_list_foreach(rpl_neighbour_t, neighbour, &instance->candidate_neighbours) {
+        if (neighbour->dao_path_control) {
+            tr_debug("Send ARO %s to %s", trace_ipv6(addr->address), trace_ipv6(neighbour->ll_address));
+            buf = icmpv6_build_ns(interface, neighbour->ll_address, addr->address, true, false, &aro);
+            addr->addr_reg_pend |= neighbour->dao_path_control;
+            protocol_push(buf);
+        } else {
+            tr_debug("Skip ARO to %s - no pc", trace_ipv6(neighbour->ll_address));
+        }
+    }
+}
+
+bool rpl_instance_address_registration_done(protocol_interface_info_entry_t *interface, rpl_instance_t *instance, if_address_entry_t *addr, uint8_t status)
+{
+    ns_list_foreach(rpl_neighbour_t, neighbour, &instance->candidate_neighbours) {
+        // Check path control mask
+        if (!(addr->addr_reg_pend & neighbour->dao_path_control)) {
+            continue;
+        }
+
+        tr_debug("Address %s register to %s", trace_ipv6(addr->address), trace_ipv6(neighbour->ll_address));
+
+        /* Clear pending flag */
+        addr->addr_reg_pend &= ~neighbour->dao_path_control;
+
+        if (status == SOCKET_TX_DONE) {
+            addr->addr_reg_done |= neighbour->dao_path_control;
+            /* State_timer is 1/10 s. Set renewal to 75-85% of lifetime */
+            addr->state_timer = (addr->preferred_lifetime * randLIB_get_random_in_range(75, 85) / 10);
+        } else {
+            tr_error("Address registration failed");
+        }
+
+        /* If that was last one to reply, send next one. */
+        if (!addr->addr_reg_pend) {
+            rpl_control_register_address(interface, NULL);
+        }
+
+        return true;
+    }
+
+    return false;
+}
+
 /* We are optimised for sending updates to existing targets to current parents;
  * we track the state of what information DAO parents have, and manage the
  * updates together with message coalescing and ack tracking.

source/RPL/rpl_downward.h

@@ -41,6 +41,9 @@ void rpl_instance_dao_request(struct rpl_instance *instance, struct rpl_neighbou
 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_send_address_registration(protocol_interface_info_entry_t *interface, rpl_instance_t *instance, if_address_entry_t *addr);
+bool rpl_instance_address_registration_done(protocol_interface_info_entry_t *interface, rpl_instance_t *instance, if_address_entry_t *addr, uint8_t status);
+
 #ifdef HAVE_RPL_DAO_HANDLING
 bool rpl_instance_dao_received(struct rpl_instance *instance, const uint8_t src[16], int8_t interface_id, bool multicast, const uint8_t *opts, uint16_t opts_len, uint8_t *status_out);
 #endif

test/nanostack/unittest/stub/rpl_control_stub.c

@@ -223,3 +223,13 @@ void rpl_control_print(route_print_fn_t *print_fn)
 {
 
 }
+
+void rpl_control_register_address(struct protocol_interface_info_entry *interface, if_address_entry_t *addr)
+{
+
+}
+
+void rpl_control_address_register_done(struct buffer *buf, uint8_t status)
+{
+
+}

test/nanostack/unittest/stub/rpl_downward_stub.c

@@ -137,4 +137,13 @@ void rpl_downward_print_instance(rpl_instance_t *instance, route_print_fn_t *pri
 {
 }
 
+void rpl_instance_send_address_registration(protocol_interface_info_entry_t *interface, rpl_instance_t *instance, if_address_entry_t *addr)
+{
+}
+
+bool rpl_instance_address_registration_done(protocol_interface_info_entry_t *interface, rpl_instance_t *instance, if_address_entry_t *addr, uint8_t status)
+{
+    return true;
+}
+
 #endif /* HAVE_RPL */