Renaming and cleaning ws bootstrap (ARMmbed#2688)

Author: Jarkko Paso

source/6LoWPAN/ws/ws_bootstrap.c

@@ -88,14 +88,11 @@
 
 #define TRACE_GROUP "wsbs"
 
-
 static void ws_bootstrap_event_handler(arm_event_s *event);
 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 uint16_t ws_bootstrap_routing_cost_calculate(protocol_interface_info_entry_t *cur);
 static uint16_t ws_bootstrap_rank_get(protocol_interface_info_entry_t *cur);
 static uint16_t ws_bootstrap_min_rank_inc_get(protocol_interface_info_entry_t *cur);
-
 static void ws_bootstrap_mac_security_enable(protocol_interface_info_entry_t *cur);
 static void ws_bootstrap_nw_key_set(protocol_interface_info_entry_t *cur, uint8_t operation, uint8_t index, uint8_t *key);
 static void ws_bootstrap_nw_key_clear(protocol_interface_info_entry_t *cur, uint8_t slot);
@@ -110,15 +107,12 @@ static void ws_bootstrap_pan_version_increment(protocol_interface_info_entry_t *
 static ws_nud_table_entry_t *ws_nud_entry_discover(protocol_interface_info_entry_t *cur, void *neighbor);
 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_bootstrap_dhcp_neighbour_update_cb(int8_t interface_id, uint8_t ll_addr[static 16]);
 static void ws_bootstrap_dhcp_info_notify_cb(int8_t interface, dhcp_option_notify_t *options, dhcp_server_notify_info_t *server_info);
-
 static void ws_bootstrap_test_procedure_trigger_timer(protocol_interface_info_entry_t *cur, uint32_t seconds);
 
 uint16_t test_pan_version = 1;
 
-
 static mac_neighbor_table_entry_t *ws_bootstrap_mac_neighbor_allocate(struct protocol_interface_info_entry *interface, const uint8_t *src64)
 {
     mac_neighbor_table_entry_t *neighbor = mac_neighbor_table_entry_allocate(mac_neighbor_info(interface), src64);
@@ -136,7 +130,6 @@ static mac_neighbor_table_entry_t *ws_bootstrap_mac_neighbor_allocate(struct pro
 }
 
 mac_neighbor_table_entry_t *ws_bootstrap_mac_neighbor_add(struct protocol_interface_info_entry *interface, const uint8_t *src64)
-
 {
     mac_neighbor_table_entry_t *neighbor = mac_neighbor_table_address_discover(mac_neighbor_info(interface), src64, MAC_ADDR_MODE_64_BIT);
     if (neighbor) {
@@ -277,6 +270,7 @@ static int ws_bootstrap_tasklet_init(protocol_interface_info_entry_t *cur)
 
     return 0;
 }
+
 static void ws_nwk_event_post(protocol_interface_info_entry_t *cur, arm_nwk_interface_status_type_e posted_event)
 {
     arm_event_s event = {
@@ -292,6 +286,7 @@ static void ws_nwk_event_post(protocol_interface_info_entry_t *cur, arm_nwk_inte
         tr_error("nwk_net_event_post(): event send failed");
     }
 }
+
 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 = {
@@ -336,7 +331,6 @@ static ws_nud_table_entry_t *ws_nud_entry_get_free(protocol_interface_info_entry
     return entry;
 }
 
-
 void ws_nud_entry_remove_active(protocol_interface_info_entry_t *cur, void *neighbor)
 {
     ws_nud_table_entry_t *entry = ws_nud_entry_discover(cur, neighbor);
@@ -353,7 +347,6 @@ void ws_nud_entry_remove_active(protocol_interface_info_entry_t *cur, void *neig
     }
 }
 
-
 static ws_nud_table_entry_t *ws_nud_entry_discover(protocol_interface_info_entry_t *cur, void *neighbor)
 {
     ns_list_foreach(ws_nud_table_entry_t, entry, &cur->ws_info->active_nud_process) {
@@ -364,7 +357,6 @@ static ws_nud_table_entry_t *ws_nud_entry_discover(protocol_interface_info_entry
     return NULL;
 }
 
-
 static void ws_nud_state_clean(protocol_interface_info_entry_t *cur, ws_nud_table_entry_t *entry)
 {
     mac_neighbor_table_entry_t *neighbor = entry->neighbor_info;
@@ -383,6 +375,7 @@ static void ws_nud_entry_remove(protocol_interface_info_entry_t *cur, mac_neighb
         ws_nud_state_clean(cur, nud_entry);
     }
 }
+
 if_address_entry_t *ws_probe_aro_address(protocol_interface_info_entry_t *interface)
 {
     if (interface->global_address_available) {
@@ -395,7 +388,6 @@ if_address_entry_t *ws_probe_aro_address(protocol_interface_info_entry_t *interf
     return NULL;
 }
 
-
 static bool ws_nud_message_build(protocol_interface_info_entry_t *cur, mac_neighbor_table_entry_t *neighbor, bool nud_process)
 {
     //Send NS
@@ -483,7 +475,7 @@ void ws_nud_active_timer(protocol_interface_info_entry_t *cur, uint16_t ticks)
     }
 }
 
-static fhss_ws_neighbor_timing_info_t *ws_get_neighbor_info(const fhss_api_t *api, uint8_t eui64[8])
+static fhss_ws_neighbor_timing_info_t *ws_bootstrap_get_neighbor_info(const fhss_api_t *api, uint8_t eui64[8])
 {
     protocol_interface_info_entry_t *cur = protocol_stack_interface_info_get_by_fhss_api(api);
     if (!cur || !cur->mac_parameters || !mac_neighbor_info(cur)) {
@@ -504,6 +496,7 @@ static fhss_ws_neighbor_timing_info_t *ws_get_neighbor_info(const fhss_api_t *ap
     }
     return &temp_entry->neigh_info_list.fhss_data;
 }
+
 void ws_bootstrap_llc_hopping_update(struct protocol_interface_info_entry *cur, const fhss_ws_configuration_t *fhss_configuration)
 {
     cur->ws_info->hopping_schdule.uc_fixed_channel = fhss_configuration->unicast_fixed_channel;
@@ -517,7 +510,7 @@ void ws_bootstrap_llc_hopping_update(struct protocol_interface_info_entry *cur,
     cur->ws_info->hopping_schdule.fhss_bsi = fhss_configuration->bsi;
 }
 
-static uint8_t ws_generate_exluded_channel_list_from_active_channels(ws_excluded_channel_data_t *excluded_data, const uint32_t *selected_channel_mask, const uint32_t *global_channel_mask, uint16_t number_of_channels)
+static uint8_t ws_bootstrap_generate_exluded_channel_list_from_active_channels(ws_excluded_channel_data_t *excluded_data, const uint32_t *selected_channel_mask, const uint32_t *global_channel_mask, uint16_t number_of_channels)
 {
     bool active_range = false;
 
@@ -580,7 +573,7 @@ static uint8_t ws_generate_exluded_channel_list_from_active_channels(ws_excluded
     return channel_plan;
 }
 
-void ws_fhss_configure_channel_masks(protocol_interface_info_entry_t *cur, fhss_ws_configuration_t *fhss_configuration)
+void ws_bootstrap_fhss_configure_channel_masks(protocol_interface_info_entry_t *cur, fhss_ws_configuration_t *fhss_configuration)
 {
     fhss_configuration->channel_mask_size = cur->ws_info->hopping_schdule.number_of_channels;
     ws_common_generate_channel_list(fhss_configuration->channel_mask, cur->ws_info->hopping_schdule.number_of_channels, cur->ws_info->hopping_schdule.regulatory_domain, cur->ws_info->hopping_schdule.operating_class, cur->ws_info->hopping_schdule.channel_plan_id);
@@ -590,18 +583,18 @@ void ws_fhss_configure_channel_masks(protocol_interface_info_entry_t *cur, fhss_
         fhss_configuration->unicast_channel_mask[n] &= cur->ws_info->cfg->fhss.fhss_channel_mask[n];
     }
     //Update Exluded channels
-    cur->ws_info->hopping_schdule.channel_plan = ws_generate_exluded_channel_list_from_active_channels(&cur->ws_info->hopping_schdule.excluded_channels, fhss_configuration->unicast_channel_mask, fhss_configuration->channel_mask, cur->ws_info->hopping_schdule.number_of_channels);
+    cur->ws_info->hopping_schdule.channel_plan = ws_bootstrap_generate_exluded_channel_list_from_active_channels(&cur->ws_info->hopping_schdule.excluded_channels, fhss_configuration->unicast_channel_mask, fhss_configuration->channel_mask, cur->ws_info->hopping_schdule.number_of_channels);
 }
 
-static int8_t ws_fhss_initialize(protocol_interface_info_entry_t *cur)
+static int8_t ws_bootstrap_fhss_initialize(protocol_interface_info_entry_t *cur)
 {
     fhss_api_t *fhss_api = ns_sw_mac_get_fhss_api(cur->mac_api);
     fhss_ws_configuration_t fhss_configuration;
     memset(&fhss_configuration, 0, sizeof(fhss_ws_configuration_t));
     if (!fhss_api) {
         // When FHSS doesn't exist yet, create one
-        ws_fhss_configure_channel_masks(cur, &fhss_configuration);
-        ws_fhss_set_defaults(cur, &fhss_configuration);
+        ws_bootstrap_fhss_configure_channel_masks(cur, &fhss_configuration);
+        ws_bootstrap_fhss_set_defaults(cur, &fhss_configuration);
         fhss_api = ns_fhss_ws_create(&fhss_configuration, cur->ws_info->fhss_timer_ptr);
 
         if (!fhss_api) {
@@ -617,7 +610,7 @@ static int8_t ws_fhss_initialize(protocol_interface_info_entry_t *cur)
     return 0;
 }
 
-int8_t ws_fhss_set_defaults(protocol_interface_info_entry_t *cur, fhss_ws_configuration_t *fhss_configuration)
+int8_t ws_bootstrap_fhss_set_defaults(protocol_interface_info_entry_t *cur, fhss_ws_configuration_t *fhss_configuration)
 {
     fhss_configuration->fhss_uc_dwell_interval = cur->ws_info->cfg->fhss.fhss_uc_dwell_interval;
     fhss_configuration->ws_uc_channel_function = (fhss_ws_channel_functions)cur->ws_info->cfg->fhss.fhss_uc_channel_function;
@@ -630,19 +623,20 @@ int8_t ws_fhss_set_defaults(protocol_interface_info_entry_t *cur, fhss_ws_config
     fhss_configuration->broadcast_fixed_channel = cur->ws_info->cfg->fhss.fhss_bc_fixed_channel;
     return 0;
 }
-static bool ws_channel_allowed(uint8_t channel, uint32_t *channel_mask)
+
+static bool ws_bootstrap_channel_allowed(uint8_t channel, uint32_t *channel_mask)
 {
     if ((1U << (channel % 32)) & (channel_mask[channel / 32])) {
         return true;
     }
     return false;
 }
 
-uint16_t ws_randomize_fixed_channel(uint16_t configured_fixed_channel, uint8_t number_of_channels, uint32_t *channel_mask)
+uint16_t ws_bootstrap_randomize_fixed_channel(uint16_t configured_fixed_channel, uint8_t number_of_channels, uint32_t *channel_mask)
 {
     if (configured_fixed_channel == 0xFFFF) {
         uint16_t random_channel = randLIB_get_random_in_range(0, number_of_channels - 1);
-        while (ws_channel_allowed(random_channel, channel_mask) == false) {
+        while (ws_bootstrap_channel_allowed(random_channel, channel_mask) == false) {
             random_channel = randLIB_get_random_in_range(0, number_of_channels - 1);
         }
         return random_channel;
@@ -651,46 +645,18 @@ uint16_t ws_randomize_fixed_channel(uint16_t configured_fixed_channel, uint8_t n
     }
 }
 
-int8_t ws_fhss_configure(protocol_interface_info_entry_t *cur, bool discovery)
-{
-    // Read configuration of existing FHSS and start using the default values for any network
-    fhss_ws_configuration_t fhss_configuration = ws_common_get_current_fhss_configuration(cur);
-    ws_fhss_set_defaults(cur, &fhss_configuration);
-    ws_fhss_configure_channel_masks(cur, &fhss_configuration);
-
-    // Discovery is done using fixed channel
-    if (discovery) {
-        fhss_configuration.ws_uc_channel_function = WS_FIXED_CHANNEL;
-    } else {
-        fhss_configuration.ws_uc_channel_function = (fhss_ws_channel_functions)cur->ws_info->cfg->fhss.fhss_uc_channel_function;
-    }
-    fhss_configuration.ws_bc_channel_function = WS_FIXED_CHANNEL;
-    fhss_configuration.fhss_broadcast_interval = 0;
-    uint8_t tmp_uc_fixed_channel = ws_randomize_fixed_channel(cur->ws_info->cfg->fhss.fhss_uc_fixed_channel, cur->ws_info->hopping_schdule.number_of_channels, fhss_configuration.channel_mask);
-    uint8_t tmp_bc_fixed_channel = ws_randomize_fixed_channel(cur->ws_info->cfg->fhss.fhss_bc_fixed_channel, cur->ws_info->hopping_schdule.number_of_channels, fhss_configuration.channel_mask);
-    fhss_configuration.unicast_fixed_channel = tmp_uc_fixed_channel;
-    fhss_configuration.broadcast_fixed_channel = tmp_bc_fixed_channel;
-    ns_fhss_ws_configuration_set(cur->ws_info->fhss_api, &fhss_configuration);
-    ns_fhss_ws_set_hop_count(cur->ws_info->fhss_api, 0xff);
-    ws_bootstrap_llc_hopping_update(cur, &fhss_configuration);
-
-    return 0;
-}
-
-static int8_t ws_fhss_enable(protocol_interface_info_entry_t *cur)
+static int8_t ws_bootstrap_fhss_enable(protocol_interface_info_entry_t *cur)
 {
     fhss_ws_configuration_t fhss_configuration = ws_common_get_current_fhss_configuration(cur);
 
     // Set the LLC information to follow the actual fhss settings
     ws_bootstrap_llc_hopping_update(cur, &fhss_configuration);
 
     // Set neighbor info callback
-    if (ns_fhss_set_neighbor_info_fp(cur->ws_info->fhss_api, &ws_get_neighbor_info)) {
+    if (ns_fhss_set_neighbor_info_fp(cur->ws_info->fhss_api, &ws_bootstrap_get_neighbor_info)) {
         return -1;
     }
-    if (cur->bootsrap_mode == ARM_NWK_BOOTSRAP_MODE_6LoWPAN_BORDER_ROUTER) {
-        ns_fhss_ws_set_hop_count(cur->ws_info->fhss_api, 0);
-    }
+
     return 0;
 }
 
@@ -709,7 +675,7 @@ void ws_bootstrap_primary_parent_set(struct protocol_interface_info_entry *cur,
     // Learning broadcast network configuration
     if (neighbor_info->ws_neighbor->broadcast_shedule_info_stored) {
         if (synch_req != WS_EAPOL_PARENT_SYNCH) {
-            ws_fhss_set_defaults(cur, &fhss_configuration);
+            ws_bootstrap_fhss_set_defaults(cur, &fhss_configuration);
         }
         fhss_configuration.ws_bc_channel_function = (fhss_ws_channel_functions)neighbor_info->ws_neighbor->fhss_data.bc_timing_info.broadcast_channel_function;
         if (fhss_configuration.ws_bc_channel_function == WS_FIXED_CHANNEL) {
@@ -887,7 +853,7 @@ static int8_t ws_bootstrap_up(protocol_interface_info_entry_t *cur)
         tr_error("Interface not yet fully configured");
         return -2;
     }
-    if (ws_fhss_initialize(cur) != 0) {
+    if (ws_bootstrap_fhss_initialize(cur) != 0) {
         tr_error("fhss initialization failed");
         return -3;
     }
@@ -1991,7 +1957,7 @@ static void ws_bootstrap_mac_activate(protocol_interface_info_entry_t *cur, uint
 void ws_bootstrap_fhss_activate(protocol_interface_info_entry_t *cur)
 {
     tr_debug("FHSS activate");
-    ws_fhss_enable(cur);
+    ws_bootstrap_fhss_enable(cur);
     ws_llc_hopping_schedule_config(cur, &cur->ws_info->hopping_schdule);
     // Only supporting fixed channel
 
@@ -2019,7 +1985,7 @@ void ws_bootstrap_ip_stack_activate(protocol_interface_info_entry_t *cur)
     ws_bootstrap_ip_stack_reset(cur);
 }
 
-static void ws_set_fhss_hop(protocol_interface_info_entry_t *cur)
+static void ws_bootstrap_set_fhss_hop(protocol_interface_info_entry_t *cur)
 {
     uint16_t own_rank = ws_bootstrap_rank_get(cur);
     uint16_t rank_inc = ws_bootstrap_min_rank_inc_get(cur);
@@ -2341,7 +2307,7 @@ static void ws_bootstrap_rpl_callback(rpl_event_t event, void *handle)
             ws_bootstrap_advertise_start(cur);
         }
 
-        ws_set_fhss_hop(cur);
+        ws_bootstrap_set_fhss_hop(cur);
         // Set retry configuration for bootstrap ready state
         ws_bootstrap_configure_max_retries(cur, WS_MAX_FRAME_RETRIES);
         // Set TX failure request restart configuration
@@ -2566,7 +2532,7 @@ static uint16_t ws_bootstrap_routing_cost_calculate(protocol_interface_info_entr
     return ws_neighbor->routing_cost + etx;
 }
 
-static struct rpl_instance *ws_get_rpl_instance(protocol_interface_info_entry_t *cur)
+static struct rpl_instance *ws_bootstrap_get_rpl_instance(protocol_interface_info_entry_t *cur)
 {
     if (!cur || !cur->rpl_domain) {
         return NULL;
@@ -2581,7 +2547,7 @@ static struct rpl_instance *ws_get_rpl_instance(protocol_interface_info_entry_t
 
 static uint16_t ws_bootstrap_rank_get(protocol_interface_info_entry_t *cur)
 {
-    struct rpl_instance *rpl_instance = ws_get_rpl_instance(cur);
+    struct rpl_instance *rpl_instance = ws_bootstrap_get_rpl_instance(cur);
     if (!rpl_instance) {
         return 0xffff;
     }
@@ -2591,7 +2557,7 @@ static uint16_t ws_bootstrap_rank_get(protocol_interface_info_entry_t *cur)
 
 static uint16_t ws_bootstrap_min_rank_inc_get(protocol_interface_info_entry_t *cur)
 {
-    struct rpl_instance *rpl_instance = ws_get_rpl_instance(cur);
+    struct rpl_instance *rpl_instance = ws_bootstrap_get_rpl_instance(cur);
     if (!rpl_instance) {
         return 0xffff;
     }
@@ -2923,7 +2889,7 @@ void ws_bootstrap_configuration_trickle_reset(protocol_interface_info_entry_t *c
     trickle_inconsistent_heard(&cur->ws_info->trickle_pan_config, &cur->ws_info->trickle_params_pan_discovery);
 }
 
-static void ws_set_asynch_channel_list(protocol_interface_info_entry_t *cur, asynch_request_t *async_req)
+static void ws_bootstrap_set_asynch_channel_list(protocol_interface_info_entry_t *cur, asynch_request_t *async_req)
 {
     memset(&async_req->channel_list, 0, sizeof(channel_list_s));
     if (cur->ws_info->cfg->fhss.fhss_uc_channel_function == WS_FIXED_CHANNEL) {
@@ -2947,7 +2913,7 @@ static void ws_bootstrap_pan_advert_solicit(protocol_interface_info_entry_t *cur
     async_req.wp_requested_nested_ie_list.us_ie = true;
     async_req.wp_requested_nested_ie_list.net_name_ie = true;
 
-    ws_set_asynch_channel_list(cur, &async_req);
+    ws_bootstrap_set_asynch_channel_list(cur, &async_req);
 
 
     async_req.security.SecurityLevel = 0;
@@ -2966,7 +2932,7 @@ static void ws_bootstrap_pan_config_solicit(protocol_interface_info_entry_t *cur
     async_req.wp_requested_nested_ie_list.us_ie = true;
     async_req.wp_requested_nested_ie_list.net_name_ie = true;
 
-    ws_set_asynch_channel_list(cur, &async_req);
+    ws_bootstrap_set_asynch_channel_list(cur, &async_req);
     async_req.security.SecurityLevel = 0;
 
     ws_stats_update(cur, STATS_WS_ASYNCH_TX_PCS, 1);
@@ -2987,7 +2953,7 @@ static void ws_bootstrap_pan_advert(protocol_interface_info_entry_t *cur)
         async_req.wp_requested_nested_ie_list.phy_cap_ie = true;
     }
 
-    ws_set_asynch_channel_list(cur, &async_req);
+    ws_bootstrap_set_asynch_channel_list(cur, &async_req);
     async_req.security.SecurityLevel = 0;
 
     if (cur->bootsrap_mode == ARM_NWK_BOOTSRAP_MODE_6LoWPAN_BORDER_ROUTER) {
@@ -3021,7 +2987,7 @@ static void ws_bootstrap_pan_config(protocol_interface_info_entry_t *cur)
         async_req.wp_requested_nested_ie_list.lfn_gtk_version_ie = ws_lfn_version_learned(cur);
     }
 
-    ws_set_asynch_channel_list(cur, &async_req);
+    ws_bootstrap_set_asynch_channel_list(cur, &async_req);
 
     async_req.security.SecurityLevel = mac_helper_default_security_level_get(cur);
     async_req.security.KeyIdMode = mac_helper_default_security_key_id_mode_get(cur);
@@ -3436,8 +3402,6 @@ static uint16_t ws_bootstrap_packet_per_seconds(protocol_interface_info_entry_t
     return data_rate / 5;
 }
 
-
-
 void ws_bootstrap_packet_congestion_init(protocol_interface_info_entry_t *cur)
 {
     random_early_detection_free(cur->random_early_detection);

source/6LoWPAN/ws/ws_bootstrap.h

@@ -175,11 +175,10 @@ void ws_address_registration_update(protocol_interface_info_entry_t *interface,
 
 
 void ws_bootstrap_configure_csma_ca_backoffs(protocol_interface_info_entry_t *cur, uint8_t max_backoffs, uint8_t min_be, uint8_t max_be);
-int8_t ws_fhss_configure(protocol_interface_info_entry_t *cur, bool discovery);
-void ws_fhss_configure_channel_masks(protocol_interface_info_entry_t *cur, fhss_ws_configuration_t *fhss_configuration);
-int8_t ws_fhss_set_defaults(protocol_interface_info_entry_t *cur, fhss_ws_configuration_t *fhss_configuration);
+void ws_bootstrap_fhss_configure_channel_masks(protocol_interface_info_entry_t *cur, fhss_ws_configuration_t *fhss_configuration);
+int8_t ws_bootstrap_fhss_set_defaults(protocol_interface_info_entry_t *cur, fhss_ws_configuration_t *fhss_configuration);
 void ws_bootstrap_fhss_activate(protocol_interface_info_entry_t *cur);
-uint16_t ws_randomize_fixed_channel(uint16_t configured_fixed_channel, uint8_t number_of_channels, uint32_t *channel_mask);
+uint16_t ws_bootstrap_randomize_fixed_channel(uint16_t configured_fixed_channel, uint8_t number_of_channels, uint32_t *channel_mask);
 int ws_bootstrap_set_domain_rf_config(protocol_interface_info_entry_t *cur);
 void ws_bootstrap_configure_max_retries(protocol_interface_info_entry_t *cur, uint8_t max_mac_retries);
 void ws_bootstrap_configure_data_request_restart(protocol_interface_info_entry_t *cur, uint8_t cca_failure_restart_max, uint8_t tx_failure_restart_max, uint16_t blacklist_min_ms, uint16_t blacklist_max_ms);