Removed the PAN version change requirement from routers

Added configuration for border router to disable periodic version number change

Added for RPL
- Minimum DAO interval configuration to force timeouts to happen in 2 hours
- function to trigger DAO refresh

Bootstrap
If routers dont see the version increase they trigger RPL DAO

Author: Mika Tervonen

nanostack/ws_bbr_api.h

@@ -52,6 +52,7 @@ int ws_bbr_start(int8_t interface_id, int8_t backbone_interface_id);
 #define BBR_GUA_ROUTE             0x0002 /**< More specific route is added for GUA prefix */
 #define BBR_BB_WAIT               0x0004 /**< Wait backbone availability before starting Wi-SUN network */
 #define BBR_DEFAULT_ROUTE         0x0008 /**< Add default route parameter to DIO */
+#define BBR_REQUIRE_DAO_REFRESH   0x0010 /**< Do not increment PAN version number when active forces DAO update from nodes*/
 
 /**
  * Configure border router features.

source/6LoWPAN/ws/ws_bbr_api.c

@@ -61,6 +61,7 @@ static uint8_t current_instance_id = RPL_INSTANCE_ID;
  */
 static int8_t backbone_interface_id = -1; // BBR backbone information
 static uint16_t configuration = 0;
+static uint32_t pan_version_timer = 0;
 
 static uint8_t static_dodag_prefix[8] = {0xfd, 0x00, 0x72, 0x83, 0x7e};
 static uint8_t static_dodag_id_prefix[8] = {0xfd, 0x00, 0x61, 0x72, 0x6d};
@@ -532,6 +533,22 @@ static void ws_bbr_rpl_status_check(protocol_interface_info_entry_t *cur)
         }
     }
 }
+void ws_bbr_pan_version_increase(protocol_interface_info_entry_t *cur)
+{
+    if (!cur) {
+        return;
+    }
+    tr_debug("Border router version number update");
+    if (configuration & BBR_REQUIRE_DAO_REFRESH) {
+        // Version number is not periodically increased forcing nodes to check Border router availability using DAO
+        pan_version_timer = 0;
+    } else {
+        pan_version_timer = ws_common_version_timeout_get(cur->ws_info->network_size_config) / PAN_VERSION_CHANGE_INTERVAL;
+    }
+    cur->ws_info->pan_information.pan_version++;
+    // Inconsistent for border router to make information distribute faster
+    ws_bootstrap_configuration_trickle_reset(cur);
+}
 
 void ws_bbr_seconds_timer(protocol_interface_info_entry_t *cur, uint32_t seconds)
 {
@@ -574,18 +591,21 @@ void ws_bbr_seconds_timer(protocol_interface_info_entry_t *cur, uint32_t seconds
     }
     // Normal BBR operation
     if (protocol_6lowpan_rpl_root_dodag) {
-        if (cur->ws_info->pan_version_timer > seconds) {
-            cur->ws_info->pan_version_timer -= seconds;
-        } else {
-            // PAN version number update
-            tr_debug("Border router version number update");
-            cur->ws_info->pan_version_timer = ws_common_version_lifetime_get(cur->ws_info->network_size_config);
-            cur->ws_info->pan_information.pan_version++;
-            // Inconsistent for border router to make information distribute faster
-            ws_bootstrap_configuration_trickle_reset(cur);
-
-            if (cur->ws_info->network_size_config == NETWORK_SIZE_AUTOMATIC) {
-                ws_common_network_size_configure(cur, cur->ws_info->pan_information.pan_size);
+        /*
+         * PAN version change is one way to enable nodes to detect the border router availability
+         * if this is not done periodically devices need to have other means to detect border router condiftion
+         *
+         * If devices do not see version change they need to send DAO to border router before PAN timeout
+         *
+         * The update frequency should be related to PAN timeout and happen for example 4 times.
+         */
+        if (pan_version_timer > 0) {
+            if (pan_version_timer > seconds) {
+                pan_version_timer -= seconds;
+            } else {
+                // PAN version number update
+                pan_version_timer = 0;
+                ws_bbr_pan_version_increase(cur);
             }
         }
         if (cur->ws_info->rpl_version_timer > seconds) {
@@ -723,6 +743,9 @@ int ws_bbr_node_access_revoke_start(int8_t interface_id)
 {
     (void) interface_id;
 #ifdef HAVE_WS_BORDER_ROUTER
+    protocol_interface_info_entry_t *cur = protocol_stack_interface_info_get_by_id(interface_id);
+
+    ws_bbr_pan_version_increase(cur);
     return ws_pae_controller_node_access_revoke_start(interface_id);
 #else
     return -1;

source/6LoWPAN/ws/ws_bbr_api_internal.h

@@ -25,6 +25,8 @@ extern uint16_t test_pan_size_override;
 
 void ws_bbr_seconds_timer(protocol_interface_info_entry_t *cur, uint32_t seconds);
 
+void ws_bbr_pan_version_increase(protocol_interface_info_entry_t *cur);
+
 uint16_t ws_bbr_pan_size(protocol_interface_info_entry_t *cur);
 
 void ws_bbr_rpl_config(protocol_interface_info_entry_t *cur, uint8_t imin, uint8_t doubling, uint8_t redundancy, uint16_t dag_max_rank_increase, uint16_t min_hop_rank_increase);
@@ -35,6 +37,7 @@ bool ws_bbr_ready_to_start(protocol_interface_info_entry_t *cur);
 #else
 
 #define ws_bbr_seconds_timer( cur, seconds)
+#define ws_bbr_pan_version_increase(cur)
 #define ws_bbr_pan_size(cur) 0
 #define ws_bbr_rpl_config( cur, imin, doubling, redundancy, dag_max_rank_increase, min_hop_rank_increase)
 #define ws_bbr_ready_to_start(cur) true

source/6LoWPAN/ws/ws_bootstrap.c

@@ -1278,7 +1278,7 @@ static void ws_bootstrap_pan_config_analyse(struct protocol_interface_info_entry
     tr_info("Updated PAN configuration own:%d, heard:%d", cur->ws_info->pan_information.pan_version, pan_version);
 
     // restart PAN version timer
-    cur->ws_info->pan_version_timeout_timer = ws_common_version_timeout_get(cur->ws_info->network_size_config);
+    cur->ws_info->pan_timeout_timer = ws_common_version_timeout_get(cur->ws_info->network_size_config);
     cur->ws_info->pan_information.pan_version = pan_version;
 
     ws_pae_controller_gtk_hash_update(cur, gtkhash_ptr);
@@ -2017,6 +2017,10 @@ static void ws_bootstrap_rpl_callback(rpl_event_t event, void *handle)
             ws_pae_controller_nw_info_set(cur, cur->ws_info->network_pan_id, cur->ws_info->network_name);
             // Network key is valid
             ws_pae_controller_nw_key_valid(cur);
+
+            // After successful DAO ACK connection to border router is verified
+            cur->ws_info->pan_timeout_timer = ws_common_version_timeout_get(cur->ws_info->network_size_config);
+
         }
 
         ws_set_fhss_hop(cur);
@@ -2274,6 +2278,9 @@ static void ws_bootstrap_rpl_activate(protocol_interface_info_entry_t *cur)
         rpl_control_set_memory_limits(WS_NODE_RPL_SOFT_MEM_LIMIT, WS_NODE_RPL_HARD_MEM_LIMIT);
     }
 
+    // Set the minimum target refresh to sen DAO registrations before pan timeout
+    rpl_control_set_minimum_dao_target_refresh(WS_RPL_DAO_MAX_TIMOUT);
+
     cur->ws_info->rpl_state = 0xff; // Set invalid state and learn from event
 }
 
@@ -2307,7 +2314,8 @@ static void ws_bootstrap_advertise_start(protocol_interface_info_entry_t *cur)
 
 static void ws_bootstrap_pan_version_increment(protocol_interface_info_entry_t *cur)
 {
-    cur->ws_info->pan_version_timer = 1;
+    (void)cur;
+    ws_bbr_pan_version_increase(cur);
 }
 
 // Start network scan
@@ -2319,7 +2327,7 @@ static void ws_bootstrap_start_discovery(protocol_interface_info_entry_t *cur)
     ws_bootstrap_state_change(cur, ER_ACTIVE_SCAN);
     cur->nwk_nd_re_scan_count = 0;
     cur->ws_info->configuration_learned = false;
-    cur->ws_info->pan_version_timeout_timer = 0;
+    cur->ws_info->pan_timeout_timer = 0;
 
     // Clear learned neighbours
     ws_bootstrap_neighbor_list_clean(cur);
@@ -2471,6 +2479,11 @@ static void ws_bootstrap_rpl_scan_start(protocol_interface_info_entry_t *cur)
         // Set timeout for check to 30 -60 seconds
         cur->bootsrap_state_machine_cnt = randLIB_get_random_in_range(WS_RPL_DIS_INITIAL_TIMEOUT / 2, WS_RPL_DIS_INITIAL_TIMEOUT);
     }
+    /* While in Join State 4, if a non Border Router determines it has been unable to communicate with the PAN Border
+     * Router for an interval of PAN_TIMEOUT, a node MUST assume failure of the PAN Border Router and MUST
+     * Transition to Join State 1
+     */
+    cur->ws_info->pan_timeout_timer = ws_common_version_timeout_get(cur->ws_info->network_size_config);
 }
 
 /*
@@ -2685,6 +2698,9 @@ static void ws_bootstrap_event_handler(arm_event_s *event)
             cur->ws_info->pending_key_index_info.state = NO_PENDING_PROCESS;
             cur->mac_parameters->mac_default_key_index = 0;
 
+            // Clear parent blacklist
+            blacklist_clear();
+
             // All trickle timers stopped to allow entry from any state
             cur->ws_info->trickle_pa_running = false;
             cur->ws_info->trickle_pc_running = false;
@@ -2715,7 +2731,7 @@ static void ws_bootstrap_event_handler(arm_event_s *event)
 
                 uint8_t *gtkhash = ws_pae_controller_gtk_hash_ptr_get(cur);
                 ws_llc_set_gtkhash(cur, gtkhash);
-                cur->ws_info->pan_version_timer = ws_common_version_lifetime_get(cur->ws_info->network_size_config);
+                ws_bbr_pan_version_increase(cur);
 
                 // Set default parameters for FHSS when starting a discovery
                 ws_fhss_border_router_configure(cur);
@@ -3018,12 +3034,23 @@ void ws_bootstrap_trickle_timer(protocol_interface_info_entry_t *cur, uint16_t t
 
 void ws_bootstrap_seconds_timer(protocol_interface_info_entry_t *cur, uint32_t seconds)
 {
-    if (cur->ws_info->pan_version_timeout_timer) {
+    /* Border router keep alive check
+     */
+    if (cur->ws_info->pan_timeout_timer) {
         // PAN version timer running
-        if (cur->ws_info->pan_version_timeout_timer > seconds) {
-            cur->ws_info->pan_version_timeout_timer -= seconds;
+        if (cur->ws_info->pan_timeout_timer > seconds) {
+            cur->ws_info->pan_timeout_timer -= seconds;
+            if (cur->ws_info->pan_timeout_timer < ws_common_version_timeout_get(cur->ws_info->network_size_config) / 10) {
+                /* pan timeout is closing need to verify that DAO is tested before the pan times out.
+                   This will give some extra time for RPL to find better parents.
+                   Border router liveliness can be checked from version number change or from successful DAO registrations
+                   in this case there has not been any version number changes during this PAN lifetime.
+                */
+                rpl_control_dao_timeout(cur->rpl_domain, 20);
+            }
         } else {
             // Border router has timed out
+            cur->ws_info->pan_timeout_timer = 0;
             tr_warn("Border router has timed out");
             ws_bootstrap_event_discovery_start(cur);
         }

source/6LoWPAN/ws/ws_common.c

@@ -456,21 +456,6 @@ bool ws_common_negative_aro_mark(protocol_interface_info_entry_t *interface, con
     return true;
 }
 
-uint32_t ws_common_version_lifetime_get(uint8_t config)
-{
-    uint32_t lifetime;
-    if (config == NETWORK_SIZE_SMALL || config == NETWORK_SIZE_CERTIFICATE) {
-        lifetime = PAN_VERSION_SMALL_NETWORK_LIFETIME;
-    } else if (config == NETWORK_SIZE_MEDIUM) {
-        lifetime = PAN_VERSION_MEDIUM_NETWORK_LIFETIME;
-    } else {
-        lifetime = PAN_VERSION_LARGE_NETWORK_LIFETIME;
-    }
-
-    return lifetime;
-
-}
-
 uint32_t ws_common_version_timeout_get(uint8_t config)
 {
     uint32_t lifetime;

source/6LoWPAN/ws/ws_common.h

@@ -89,8 +89,7 @@ typedef struct ws_info_s {
     parent_info_list_t parent_list_free;
     parent_info_list_t parent_list_reserved;
     uint16_t rpl_version_timer;            /**< RPL version update timeout */
-    uint32_t pan_version_timer;            /**< border router version update timeout */
-    uint32_t pan_version_timeout_timer;    /**< routers will fallback to previous state after this */
+    uint32_t pan_timeout_timer;    /**< routers will fallback to previous state after this */
     uint32_t pan_config_sol_max_timeout;
     uint8_t gtkhash[32];
     bool configuration_learned: 1;
@@ -145,9 +144,6 @@ uint8_t ws_common_allow_child_registration(protocol_interface_info_entry_t *cur,
 
 bool ws_common_negative_aro_mark(protocol_interface_info_entry_t *interface, const uint8_t *eui64);
 
-
-uint32_t ws_common_version_lifetime_get(uint8_t config);
-
 uint32_t ws_common_version_timeout_get(uint8_t config);
 
 #define ws_info(cur) ((cur)->ws_info)

source/6LoWPAN/ws/ws_config.h

@@ -37,14 +37,17 @@
 #define WS_CERTIFICATE_RPL_MIN_HOP_RANK_INCREASE 128
 #define WS_CERTIFICATE_RPL_MAX_HOP_RANK_INCREASE 0
 
+/*
+ *  RPL DAO timeout maximum value. This will force DAO timeout to happen before this time
+ */
+#define WS_RPL_DAO_MAX_TIMOUT (3600*2)
+
 /* Border router version change interval
  *
- * Minimum interval at which a Border Router shall increment its PAN Version value.
+ * Amount of version increases border router makes during PAN_TIMEOUT time
  */
 
-#define PAN_VERSION_SMALL_NETWORK_LIFETIME 4*60
-#define PAN_VERSION_MEDIUM_NETWORK_LIFETIME 15*60
-#define PAN_VERSION_LARGE_NETWORK_LIFETIME 30*60 //30min
+#define PAN_VERSION_CHANGE_INTERVAL 3
 
 // RPL version number update intervall
 // after restart version numbers are increased faster and then slowed down when network is stable

source/RPL/rpl_control.c

@@ -185,7 +185,10 @@ void rpl_control_set_dao_retry_count(uint8_t count)
 {
     rpl_policy_set_dao_retry_count(count);
 }
-
+void rpl_control_set_minimum_dao_target_refresh(uint16_t seconds)
+{
+    rpl_policy_set_minimum_dao_target_refresh(seconds);
+}
 void rpl_control_set_initial_dao_ack_wait(uint16_t timeout_in_ms)
 {
     rpl_policy_set_initial_dao_ack_wait(timeout_in_ms);
@@ -673,6 +676,14 @@ void rpl_control_force_leaf(rpl_domain_t *domain, bool leaf)
         }
     }
 }
+
+void rpl_control_dao_timeout(rpl_domain_t *domain, uint16_t seconds)
+{
+    ns_list_foreach(rpl_instance_t, instance, &domain->instances) {
+        rpl_instance_dao_timeout(instance, seconds);
+    }
+}
+
 void rpl_control_process_routes(rpl_domain_t *domain, bool process_routes)
 {
     domain->process_routes = process_routes;

source/RPL/rpl_control.h

@@ -145,6 +145,9 @@ void rpl_control_process_routes(rpl_domain_t *domain, bool process_routes);
 /* Manually send poison on all existing instances a few times */
 void rpl_control_poison(rpl_domain_t *domain, uint8_t poison_count);
 
+/* force DAO to verify connections before given time*/
+void rpl_control_dao_timeout(rpl_domain_t *domain, uint16_t seconds);
+
 /* APIs to create domains and map them to interfaces */
 rpl_domain_t *rpl_control_create_domain(void);
 void rpl_control_delete_domain(rpl_domain_t *domain);
@@ -171,6 +174,7 @@ bool rpl_control_find_worst_neighbor(struct protocol_interface_info_entry *inter
 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_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]);

source/RPL/rpl_downward.c

@@ -109,8 +109,6 @@ static void rpl_downward_topo_sort_invalidate(rpl_instance_t *instance);
 
 #define DEFAULT_DAO_DELAY 10 /* *100ms ticks = 1s */
 
-//#define MINIMUM_DAO_TARGET_REFRESH (5*60) /* seconds */
-
 /* Bit <n> of the PC mask */
 #define PCBIT(n) (UINT8_C(0x80) >> (n))
 
@@ -1603,11 +1601,10 @@ void rpl_instance_dao_acked(rpl_instance_t *instance, const uint8_t src[16], int
                 } else {
                     t = 0xFFFFFFFF;
                 }
-#ifdef MINIMUM_DAO_TARGET_REFRESH
-                if (t > MINIMUM_DAO_TARGET_REFRESH) {
-                    t = randLIB_randomise_base(MINIMUM_DAO_TARGET_REFRESH, 0x7333, 0x8CCD); /* +/- 10% */
+                if (rpl_policy_minimum_dao_target_refresh() && t > rpl_policy_minimum_dao_target_refresh()) {
+                    // set the minimum target refresh time ranging from 25% to 10% below the value
+                    t = randLIB_randomise_base(rpl_policy_minimum_dao_target_refresh(), 0x6000, 0x7333);
                 }
-#endif
                 target->info.non_root.refresh_timer = t;
                 tr_debug("set rfr to %"PRIu32, t);
             }
@@ -1639,6 +1636,21 @@ void rpl_instance_dao_request(struct rpl_instance *instance, struct rpl_neighbou
     rpl_instance_dao_trigger(instance, 0);
 }
 
+void rpl_instance_dao_timeout(struct rpl_instance *instance, uint16_t seconds)
+{
+    // Forces DAO timeout to happen before given time distributed in given time
+    ns_list_foreach(rpl_dao_target_t, target, &instance->dao_targets) {
+        if (!target->published || target->info.non_root.refresh_timer == 0) {
+            continue;
+        }
+        if (target->info.non_root.refresh_timer < seconds) {
+            continue;
+        }
+        // Shorten the timeout
+        target->info.non_root.refresh_timer = randLIB_get_random_in_range(1, seconds);
+    }
+}
+
 
 void rpl_downward_dao_slow_timer(rpl_instance_t *instance, uint16_t seconds)
 {

source/RPL/rpl_downward.h

@@ -38,6 +38,7 @@ void rpl_instance_delete_published_dao_target(struct rpl_instance *instance, con
 struct rpl_dao_target *rpl_instance_match_dao_target(struct rpl_instance *instance, const uint8_t *prefix, uint8_t prefix_len);
 
 void rpl_instance_dao_request(struct rpl_instance *instance, struct rpl_neighbour *neighbour);
+void rpl_instance_dao_timeout(struct rpl_instance *instance, uint16_t seconds);
 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);

source/RPL/rpl_policy.c

@@ -40,7 +40,7 @@ static int16_t rpl_policy_dao_initial_timeout_conf = 20; // Default is 2 seconds
 static uint16_t rpl_policy_dio_validity_period_hysteresis = 0x0180; //Fixed Point 1.5
 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
 /* TODO - application API to control when to join new instances / DODAGs
  *
  * Eg, allow application to ignore local DODAGs, or specify known instance IDs,
@@ -115,6 +115,16 @@ void rpl_policy_set_initial_dao_ack_wait(uint16_t timeout_in_ms)
     rpl_policy_dao_initial_timeout_conf = timeout_in_ms;
 }
 
+void rpl_policy_set_minimum_dao_target_refresh(uint16_t seconds)
+{
+    rpl_policy_minimum_dao_target_refresh_conf = seconds;
+}
+
+uint16_t rpl_policy_minimum_dao_target_refresh(void)
+{
+    return rpl_policy_minimum_dao_target_refresh_conf;
+}
+
 uint16_t rpl_policy_initial_dao_ack_wait(const rpl_domain_t *domain, uint8_t mop)
 {
     (void)mop;