ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
mbed-os/features/nanostack/sal-stack-nanostack/source/BorderRouter/border_router.c

837 lines
30 KiB
C
Raw Blame History

/*
* Copyright (c) 2012-2018, 2020, Pelion and affiliates.
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "nsconfig.h"
#include "ns_types.h"
#include "string.h"
#include "ns_trace.h"
#include "nsdynmemLIB.h"
#include "NWK_INTERFACE/Include/protocol.h"
#include "NWK_INTERFACE/Include/protocol_timer.h"
#include "6LoWPAN/Bootstraps/protocol_6lowpan.h"
#include "6LoWPAN/Bootstraps/protocol_6lowpan_bootstrap.h"
#ifndef NO_MLE
#include "MLE/mle.h"
#endif
#include "mac_api.h"
#include "RPL/rpl_control.h"
#include "6LoWPAN/ND/nd_router_object.h"
#include "Service_Libs/whiteboard/whiteboard.h"
#include "Service_Libs/blacklist/blacklist.h"
#include "Service_Libs/nd_proxy/nd_proxy.h"
#include "shalib.h"
#ifdef ECC
#include "libX509_V3.h"
#include "ecc.h"
#endif
#include "Security/TLS/tls_lib.h"
#include "Security/Common/sec_lib.h"
#include "net_nvm_api.h"
#include "Security/PANA/pana.h"
#include "Security/PANA/pana_internal_api.h"
#include "Common_Protocols/ipv6.h"
#include "Common_Protocols/icmpv6.h"
#include "Common_Protocols/icmpv6_prefix.h"
#include "Common_Protocols/icmpv6_radv.h"
#include "ipv6_stack/protocol_ipv6.h"
#include "common_functions.h"
#include "net_thread_test.h"
#include "6LoWPAN/Thread/thread_common.h"
#include "6LoWPAN/Thread/thread_bootstrap.h"
#include "6LoWPAN/Thread/thread_routing.h"
#include "BorderRouter/border_router.h"
#include "6LoWPAN/MAC/mac_helper.h"
#include "6LoWPAN/MAC/beacon_handler.h"
#include "6LoWPAN/NVM/nwk_nvm.h"
#include "libNET/src/net_load_balance_internal.h"
#include "6LoWPAN/lowpan_adaptation_interface.h"
#include "6LoWPAN/Fragmentation/cipv6_fragmenter.h"
#ifdef HAVE_6LOWPAN_BORDER_ROUTER
#define TRACE_GROUP_BORDER_ROUTER "br"
#define TRACE_GROUP "br"
static int8_t border_router_nd_abro_periodically_update_by_stack(nd_router_setup_t *nd_router_configuration);
static void border_router_free(protocol_interface_info_entry_t *cur);
void arm_nwk_6lowpan_borderrouter_data_free(protocol_interface_info_entry_t *cur)
{
if (cur->border_router_setup) {
if (cur->border_router_setup->nd_nwk) {
icmp_nd_border_router_release(cur->border_router_setup->nd_nwk);
ns_dyn_mem_free(cur->border_router_setup->nd_nwk);
}
if (cur->border_router_setup->nd_border_router_configure) {
ns_dyn_mem_free(cur->border_router_setup->nd_border_router_configure);
}
ns_dyn_mem_free(cur->border_router_setup);
cur->border_router_setup = 0;
}
}
void nd_border_router_setup_refresh(nwk_interface_id id, bool fresh_abro)
{
uint8_t *ptr = 0;
nd_router_t *nd_router_object;
nd_router_setup_t *nd_configure;
protocol_interface_info_entry_t *cur_interface;
uint8_t nd_options[30];
cur_interface = protocol_stack_interface_info_get(id);
if (!cur_interface) {
return;
} else if (cur_interface->bootsrap_mode != ARM_NWK_BOOTSRAP_MODE_6LoWPAN_BORDER_ROUTER) {
return;
} else if (cur_interface->border_router_setup == 0) {
return;
} else if (!cur_interface->border_router_setup->nd_nwk) {
return;
} else if (!cur_interface->border_router_setup->nd_border_router_configure) {
return;
}
nd_router_object = cur_interface->border_router_setup->nd_nwk;
nd_configure = cur_interface->border_router_setup->nd_border_router_configure;
nd_router_object->life_time = nd_configure->life_time;
if (!ns_list_is_empty(&nd_router_object->prefix_list)) {
tr_debug("Release Prefix");
icmpv6_prefix_list_free(&nd_router_object->prefix_list);
}
if (!ns_list_is_empty(&nd_router_object->context_list)) {
tr_info("Release Context");
lowpan_context_list_free(&nd_router_object->context_list);
}
if (!ns_list_is_empty(&nd_configure->context_list)) {
tr_info("Refresh Contexts");
ns_list_foreach(lowpan_context_t, cur, &nd_configure->context_list) {
uint8_t cid_flags = cur->cid | (cur->compression ? LOWPAN_CONTEXT_C : 0);
uint16_t lifetime_mins = (cur->lifetime + 599) / 600;
/* Update contexts in our ABRO advertising storage */
lowpan_context_update(&nd_router_object->context_list, cid_flags, lifetime_mins, cur->prefix, cur->length, true);
/* And contexts used by the interface itself (we don't hear our own adverts) */
lowpan_context_update(&cur_interface->lowpan_contexts, cid_flags, lifetime_mins, cur->prefix, cur->length, true);
}
}
/* Set Prefixs */
if (!ns_list_is_empty(&nd_configure->prefix_list)) {
tr_info("Refresh Prefixs");
ns_list_foreach(prefix_entry_t, cur, &nd_configure->prefix_list) {
ptr = nd_options;
*ptr++ = cur->prefix_len; //Prefix Len
*ptr++ = cur->options; //Autonomous address enabled
ptr = common_write_32_bit(cur->lifetime, ptr);
ptr = common_write_32_bit(cur->preftime, ptr);
ptr = common_write_32_bit(0, ptr); //Reserved
memcpy(ptr, cur->prefix, 16);
icmp_nd_router_prefix_update(nd_options, nd_router_object, cur_interface);
}
}
//Update version num
if (fresh_abro) {
if (border_router_nd_abro_periodically_update_by_stack(nd_configure) == 0) {
tr_info("ABRO Update and NVM operation OK");
}
}
nd_router_object->abro_version_num = nd_configure->abro_version_num;
}
int8_t arm_nwk_6lowpan_border_route_nd_default_prefix_timeout_set(int8_t interface_id, uint32_t time)
{
int8_t ret_val = -1;
protocol_interface_info_entry_t *cur = 0;
cur = protocol_stack_interface_info_get_by_id(interface_id);
if (cur) {
uint8_t *nd_options = ns_dyn_mem_temporary_alloc(30);
if (nd_options) {
uint8_t *ptr;
ptr = nd_options;
ptr = common_write_16_bit(0x4040, ptr); //Prefix Len + Autonomous address enabled
ptr = common_write_32_bit(time, ptr);
ptr = common_write_32_bit(time, ptr);
memcpy(ptr, cur->border_router_setup->border_router_gp_adr, 8);
ptr += 8;
memset(ptr, 0, 8);
ret_val = icmp_nd_router_prefix_proxy_update(nd_options, cur->border_router_setup->nd_border_router_configure);
ns_dyn_mem_free(nd_options);
}
}
return ret_val;
}
int8_t arm_nwk_6lowpan_border_router_context_update(int8_t interface_id, uint8_t c_id_flags, uint8_t context_len, uint16_t ttl, const uint8_t *context_ptr)
{
int8_t ret_val = -2;
protocol_interface_info_entry_t *cur = 0;
cur = protocol_stack_interface_info_get_by_id(interface_id);
if (cur) {
ret_val = 0;
if (cur->bootsrap_mode != ARM_NWK_BOOTSRAP_MODE_6LoWPAN_BORDER_ROUTER) {
ret_val = -4;
} else if (cur->border_router_setup == 0) {
ret_val = -3;
} else {
if (c_id_flags < 0x20 && context_len >= 64) {
if (cur->border_router_setup->nd_nwk) {
nd_router_setup_t *routerSetup = cur->border_router_setup->nd_border_router_configure;
if (!lowpan_context_get_by_id(&routerSetup->context_list, (c_id_flags & LOWPAN_CONTEXT_CID_MASK))) {
if (ns_list_count(&routerSetup->context_list) >= ND_MAX_PROXY_CONTEXT_COUNT) {
return -1;
}
}
if (lowpan_context_update(&routerSetup->context_list, c_id_flags, ttl, context_ptr, context_len, true) != 0) {
ret_val = -2;
} else {
ret_val = 0;
}
}
} else {
ret_val = -3;
}
}
}
return ret_val;
}
int8_t arm_nwk_6lowpan_border_router_nd_context_load(int8_t interface_id, uint8_t *contex_data)
{
int8_t ret_val = -2;
protocol_interface_info_entry_t *cur = 0;
cur = protocol_stack_interface_info_get_by_id(interface_id);
if (cur) {
ret_val = 0;
if (cur->bootsrap_mode != ARM_NWK_BOOTSRAP_MODE_6LoWPAN_BORDER_ROUTER) {
ret_val = -4;
} else if (cur->border_router_setup == 0) {
ret_val = -3;
} else {
uint8_t c_id;
uint16_t lifetime;
nd_router_setup_t *nd_router_setup;
uint8_t con_len = *contex_data++;
nd_router_setup = cur->border_router_setup->nd_border_router_configure;
c_id = *contex_data++ & 0x1f; // ignore reserved fields
lifetime = common_read_16_bit(contex_data);
contex_data += 2;
//Now Pointer Indicate to prefix
//Check first is current ID at list
if (!lowpan_context_get_by_id(&nd_router_setup->context_list, (c_id & LOWPAN_CONTEXT_CID_MASK))) {
if (ns_list_count(&nd_router_setup->context_list) >= ND_MAX_PROXY_CONTEXT_COUNT) {
tr_debug("All Contexts are allocated");
return -1;
}
}
return lowpan_context_update(&nd_router_setup->context_list, c_id, lifetime, contex_data, con_len, true);
}
}
return ret_val;
}
//int8_t border_router_nd_configure_update(void)
int8_t arm_nwk_6lowpan_border_router_configure_push(int8_t interface_id)
{
int8_t ret_val = -1;
protocol_interface_info_entry_t *cur_interface;
cur_interface = protocol_stack_interface_info_get_by_id(interface_id);
if (cur_interface) {
ret_val = 0;
if (cur_interface->bootsrap_mode != ARM_NWK_BOOTSRAP_MODE_6LoWPAN_BORDER_ROUTER) {
ret_val = -4;
} else if (cur_interface->border_router_setup == 0) {
ret_val = -3;
} else if ((cur_interface->lowpan_info & INTERFACE_NWK_ACTIVE) == 0) {
ret_val = -2;
} else {
if (thread_info(cur_interface) == NULL) {
cur_interface->border_router_setup->nd_nwk->nd_timer = 1;
cur_interface->border_router_setup->nd_nwk->nd_re_validate = 1;
cur_interface->border_router_setup->nd_nwk->abro_version_num++;
ret_val = 0;
}
}
}
return ret_val;
}
int8_t arm_nwk_6lowpan_border_router_context_remove_by_id(int8_t interface_id, uint8_t c_id)
{
lowpan_context_t *entry;
protocol_interface_info_entry_t *cur_interface = 0;
nd_router_setup_t *nd_router_configuration = 0;
cur_interface = protocol_stack_interface_info_get_by_id(interface_id);
if (!cur_interface) {
return -1;
}
if (cur_interface->bootsrap_mode != ARM_NWK_BOOTSRAP_MODE_6LoWPAN_BORDER_ROUTER) {
return -4;
}
if (cur_interface->border_router_setup == 0) {
return -3;
}
nd_router_configuration = cur_interface->border_router_setup->nd_border_router_configure;
entry = lowpan_context_get_by_id(&nd_router_configuration->context_list, c_id);
if (entry) {
ns_list_remove(&nd_router_configuration->context_list, entry);
ns_dyn_mem_free(entry);
}
return 0;
}
int8_t arm_nwk_6lowpan_border_router_context_parameter_update(int8_t interface_id, uint8_t c_id, uint8_t compress_mode, uint16_t ttl)
{
protocol_interface_info_entry_t *cur_interface;
nd_router_setup_t *nd_router_configuration;
lowpan_context_t *entry;
cur_interface = protocol_stack_interface_info_get_by_id(interface_id);
if (!cur_interface) {
return -1;
}
if (cur_interface->bootsrap_mode != ARM_NWK_BOOTSRAP_MODE_6LoWPAN_BORDER_ROUTER) {
return -4;
}
if (cur_interface->border_router_setup == 0) {
return -3;
}
nd_router_configuration = cur_interface->border_router_setup->nd_border_router_configure;
entry = lowpan_context_get_by_id(&nd_router_configuration->context_list, c_id);
if (entry) {
uint8_t cid_flag = entry->cid;
entry->compression = compress_mode;
entry->lifetime = ttl;
cid_flag |= (entry->compression ? LOWPAN_CONTEXT_C : 0);
return 0;
}
return -1;
}
int8_t arm_nwk_6lowpan_border_router_init(int8_t interface_id, const border_router_setup_s *border_router_setup_ptr)
{
int8_t ret_val = -3;
protocol_interface_info_entry_t *cur = 0;
nd_router_setup_t *nd_router_configuration = 0;
cur = protocol_stack_interface_info_get_by_id(interface_id);
if (cur) {
ret_val = 0;
if (cur->bootsrap_mode != ARM_NWK_BOOTSRAP_MODE_6LoWPAN_BORDER_ROUTER) {
ret_val = -4;
} else if (cur->border_router_setup == 0) {
ret_val = -3;
} else if (thread_info(cur)) {
ret_val = -5;
} else if ((cur->lowpan_info & INTERFACE_NWK_ACTIVE) == 0) {
uint8_t *ptr = cur->border_router_setup->border_router_gp_adr;
memcpy(ptr, border_router_setup_ptr->lowpan_nd_prefix, 8);
ptr += 8;
cur->border_router_setup->mac_short_adr = border_router_setup_ptr->mac_short_adr;
if (border_router_setup_ptr->mac_short_adr < 0xfffe) {
cur->lowpan_address_mode = NET_6LOWPAN_GP16_ADDRESS;
mac_helper_mac16_address_set(cur, border_router_setup_ptr->mac_short_adr);
memcpy(ptr, ADDR_SHORT_ADR_SUFFIC, 6);
ptr += 6;
ptr = common_write_16_bit(cur->border_router_setup->mac_short_adr, ptr);
} else {
memcpy(ptr, cur->iid_eui64, 8);
cur->lowpan_address_mode = NET_6LOWPAN_GP64_ADDRESS;
}
nd_router_configuration = cur->border_router_setup->nd_border_router_configure;
nd_router_configuration->life_time = border_router_setup_ptr->ra_life_time;
nd_router_configuration->abro_version_num = border_router_setup_ptr->abro_version_num;
cur->configure_flags |= INTERFACE_ND_BORDER_ROUTER_DEFINED;
} else {
ret_val = -1;
}
if (ret_val == 0) {
uint8_t *nd_options = 0;
uint8_t *beaon_payload = 0;
//Check here FHSS Pointer Hox Hoxs
beaon_payload = mac_helper_beacon_payload_reallocate(cur, 18);
cur->border_router_setup->mac_panid = border_router_setup_ptr->mac_panid;
if (beaon_payload == NULL) {
ret_val = -2;
} else {
*beaon_payload++ = border_router_setup_ptr->beacon_protocol_id;
*beaon_payload++ = 7; //Accept Join / Host & Router
memcpy(beaon_payload, border_router_setup_ptr->network_id, 16);
if (mac_helper_beacon_payload_register(cur) != 0) {
tr_error("Beacon payload register Fail");
}
nd_options = ns_dyn_mem_temporary_alloc(30);
if (nd_options) {
uint8_t *ptr = cur->border_router_setup->nd_nwk->border_router;
nd_router_base_init(cur->border_router_setup->nd_nwk);
cur->border_router_setup->nd_nwk->nd_state = ND_BR_READY;
cur->border_router_setup->nd_nwk->nwk_id = IF_6LoWPAN;
cur->border_router_setup->nd_nwk->life_time = border_router_setup_ptr->ra_life_time;
memcpy(cur->border_router_setup->nd_nwk->border_router, cur->border_router_setup->border_router_gp_adr, 16);
if (border_router_setup_ptr->mac_short_adr < 0xfffe) {
cur->border_router_setup->mac_short_adr = border_router_setup_ptr->mac_short_adr;
} else {
cur->border_router_setup->mac_short_adr = 0xffff;
}
//Create GP64
if (ret_val == 0) {
ptr = nd_options;
*ptr++ = 64;//Prefix Len
*ptr++ = PIO_A; //Autonomous address enabled
memset(ptr, 0xff, 8);/* Valid Life time & Valid Preferred Life time 0xffffff */
ptr += 8;
memcpy(ptr, border_router_setup_ptr->lowpan_nd_prefix, 8);
ptr += 8;
memset(ptr, 0, 8);
ret_val = icmp_nd_router_prefix_proxy_update(nd_options, nd_router_configuration);
//Default Prefix TO ND
}
if (ret_val == 0) {
//Context
if (lowpan_context_update(&nd_router_configuration->context_list, (LOWPAN_CONTEXT_C | 0), (24 * 60), border_router_setup_ptr->lowpan_nd_prefix, 64, true) != 0) {
ret_val = -2;
}
}
ns_dyn_mem_free(nd_options);
if (ret_val == 0) {
tr_info("BR nwk base ready for start");
}
} else {
ret_val = -2;
}
}
if (ret_val == -2) {
if (cur) {
border_router_free(cur);
}
}
}
}
return ret_val;
}
static void border_router_free(protocol_interface_info_entry_t *cur)
{
if (cur->border_router_setup) {
if (cur->border_router_setup->nd_nwk) {
icmp_nd_router_object_reset(cur->border_router_setup->nd_nwk);
ns_dyn_mem_free(cur->border_router_setup->nd_nwk);
}
if (cur->border_router_setup->nd_border_router_configure) {
icmpv6_prefix_list_free(&cur->border_router_setup->nd_border_router_configure->prefix_list);
lowpan_context_list_free(&cur->border_router_setup->nd_border_router_configure->context_list);
}
ns_dyn_mem_free(cur->border_router_setup);
cur->border_router_setup = 0;
}
}
static int8_t border_router_nd_abro_periodically_update_by_stack(nd_router_setup_t *nd_router_configuration)
{
int8_t ret_val = -1;
if (nd_router_configuration) {
nd_router_configuration->abro_version_num++;
ret_val = 0;
}
return ret_val;
}
void border_router_start(protocol_interface_info_entry_t *cur, bool warm_link_restart)
{
nd_router_t *nd_nwk = cur->border_router_setup->nd_nwk;
mlme_start_t start_req;
memset(&start_req, 0, sizeof(mlme_start_t));
start_req.PANId = cur->border_router_setup->mac_panid;
start_req.LogicalChannel = cur->mac_parameters->mac_channel;
start_req.ChannelPage = 0;
start_req.BeaconOrder = 0x0f;
start_req.SuperframeOrder = 0x0f;
start_req.PANCoordinator = 1;
if (cur->mac_api) {
protocol_timer_start(PROTOCOL_TIMER_BOOTSTRAP_TIM, bootstrap_timer_handle, BOOTSTRAP_START_TIMEOUT);
cur->mac_api->mlme_req(cur->mac_api, MLME_START, (void *)&start_req);
}
if (warm_link_restart) {
return;
}
mac_neighbor_table_neighbor_list_clean(mac_neighbor_info(cur));
#ifndef NO_MLE
blacklist_clear();
#endif
cur->border_router_setup->initActive = true;
cur->lowpan_info |= INTERFACE_NWK_BOOTSRAP_ADDRESS_REGISTER_READY;
addr_interface_set_ll64(cur, NULL);
cur->interface_mode = INTERFACE_UP;
cur->nwk_mode = ARM_NWK_GP_IP_MODE;
if (nd_nwk) {
if (cur->lowpan_info & INTERFACE_NWK_BOOTSRAP_MLE) {
protocol_6lowpan_router_synch_to_new_router(cur, NULL, 0, true);
cur->bootsrap_state_machine_cnt = 30;
} else {
nd_nwk->mle_advert_timer = 0;
cur->bootsrap_state_machine_cnt = 1;
}
cur->nwk_bootstrap_state = ER_SCAN;
whiteboard_interface_register(nd_nwk->border_router, cur->id);
cur->nwk_nd_re_scan_count = 2;
} else {
thread_interface_up(cur);
rpl_control_remove_domain_from_interface(cur);
nwk_bootsrap_state_update(ARM_NWK_BOOTSTRAP_READY, cur);
}
}
static int arm_mac_channel_list_analyze(protocol_interface_info_entry_t *cur)
{
int number_of_channels = 0;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 4; j++) {
number_of_channels += common_count_bits((uint8_t)(cur->mac_parameters->mac_channel_list.channel_mask[i] >> (j * 8)));
}
}
return number_of_channels;
}
static int8_t arm_border_router_interface_up(protocol_interface_info_entry_t *cur)
{
bool warm_restart = false;
if (cur->interface_mode == INTERFACE_UP || cur->lowpan_info & INTERFACE_NWK_ACTIVE) {
//Disable interface like starting normal scan request
if (cur->nwk_bootstrap_state != ER_BOOTSRAP_DONE) {
return -4;
}
warm_restart = true;
tr_debug("Do warm link start");
} else {
nd_router_t *nd_nwk = cur->border_router_setup->nd_nwk;
//SET SHort Address
if (cur->border_router_setup->mac_short_adr < 0xfffe) {
mac_helper_mac16_address_set(cur, cur->border_router_setup->mac_short_adr);
cur->lowpan_desired_short_address = cur->border_router_setup->mac_short_adr;
protocol_6lowpan_set_ll16(cur, cur->border_router_setup->mac_short_adr);
}
mac_helper_panid_set(cur, cur->border_router_setup->mac_panid);
if (cur->nwk_wpan_nvm_api) {
wpan_nvm_params_t *params = cur->nwk_wpan_nvm_api->nvm_params_get_cb(cur->nwk_wpan_nvm_api, cur->border_router_setup->mac_panid);
cur->if_lowpan_security_params->mle_security_frame_counter = params->mle_securit_counter;
//SET MAC and MLE security frame counters
mle_service_security_set_frame_counter(cur->id, params->mle_securit_counter);
mac_helper_link_frame_counter_set(cur->id, params->mac_security_frame_counter);
}
// cur->mac_channel = cur->border_router_setup->channel;
if (nd_nwk) {
nd_border_router_setup_refresh(nd_nwk->nwk_id, false);
}
cur->bootsrap_mode = ARM_NWK_BOOTSRAP_MODE_6LoWPAN_BORDER_ROUTER;
icmpv6_recv_ra_routes(cur, false);
protocol_6lowpan_interface_common_init(cur);
mac_helper_pib_boolean_set(cur, macRxOnWhenIdle, true);
mac_helper_pib_boolean_set(cur, macAssociationPermit, true);
arm_6lowpan_security_init_ifup(cur);
mac_helper_default_security_level_set(cur, cur->mac_parameters->mac_configured_sec_level);
//set 6lowpan default
mac_helper_mac_mlme_max_retry_set(cur->id, LOWPAN_MAX_FRAME_RETRIES);
if (cur->lowpan_info & INTERFACE_NWK_BOOTSRAP_PANA_AUTHENTICATION) {
if (pana_server_key_material_load(cur->id) != 0) {
tr_warn("Border router security load fail");
return -3;
}
}
}
int number_of_channels = arm_mac_channel_list_analyze(cur);
cur->lowpan_info |= INTERFACE_NWK_ACTIVE;
/* Start network scan when at least 2 of 256 channels are enabled,
* otherwise MAC is started immediately.
*/
if (number_of_channels > 1) {
if (warm_restart) {
bootsrap_next_state_kick(ER_WARM_ACTIVE_SCAN, cur);
} else {
bootsrap_next_state_kick(ER_ACTIVE_SCAN, cur);
}
} else {
border_router_start(cur, warm_restart);
}
return 0;
}
static int arm_border_router_proxy_validate(int8_t interface_id, uint8_t *address)
{
/* Could also check route type, but I don't think it really matters */
ipv6_route_t *route;
route = ipv6_route_choose_next_hop(address, interface_id, NULL);
if (!route || route->prefix_len < 128) {
return -1;
}
return 0;
}
int arm_border_router_proxy_state_update(int8_t caller_interface_id, int8_t handler_interface_id, bool status)
{
(void)caller_interface_id;
protocol_interface_info_entry_t *cur = protocol_stack_interface_info_get_by_id(handler_interface_id);
if (!cur) {
tr_error("No Interface");
return -1;
}
if (status) {
tr_debug("Border router Backhaul link ready");
} else {
tr_debug("Border router Backhaul link down");
}
return 0;
}
void arm_border_router_ready(protocol_interface_info_entry_t *cur)
{
if (cur->border_router_setup) {
nd_router_t *nd_nwk = cur->border_router_setup->nd_nwk;
if (nd_nwk) {
addr_add_router_groups(cur);
addr_add_group(cur, ADDR_REALM_LOCAL_ALL_ROUTERS);
icmpv6_radv_enable(cur);
if (cur->lowpan_info & INTERFACE_NWK_BOOTSRAP_MLE) {
nd_nwk->mle_advert_timer = 50;
}
nd_nwk->nd_re_validate = nd_nwk->life_time;
nd_nwk->nd_re_validate /= 4;
nd_nwk->nd_re_validate *= 3;
nd_nwk->nd_timer = 10;
nd_set_br(nd_nwk);
icmpv6_restart_router_advertisements(cur, nd_nwk->border_router);
rpl_control_set_domain_on_interface(cur, protocol_6lowpan_rpl_domain, true);
cur->border_router_setup->initActive = false;
//SET Interface Default address
cur->global_address_available = true;
ipv6_prefix_on_link_update(nd_nwk->border_router);
}
//Updates beacon contents
beacon_join_priority_update(cur->id);
cur->bootsrap_state_machine_cnt = 0;
cur->nwk_bootstrap_state = ER_BOOTSRAP_DONE;
net_load_balance_internal_state_activate(cur, true);
nwk_bootsrap_state_update(ARM_NWK_BOOTSTRAP_READY, cur);
nd_proxy_downstream_interface_register(cur->id, arm_border_router_proxy_validate, arm_border_router_proxy_state_update);
}
}
static int8_t arm_border_router_interface_down(protocol_interface_info_entry_t *cur)
{
int8_t ret_val = 0;
nd_router_t *nd_nwk = cur->border_router_setup->nd_nwk;
/* Change Active -> Idle */
/* Disable Protocols Timers */
tr_info("BR-->IDLE");
neighbor_cache_flush(&cur->neigh_cache);
mlme_reset_t reset;
reset.SetDefaultPIB = true;
cur->mac_api->mlme_req(cur->mac_api, MLME_RESET, &reset);
net_load_balance_internal_state_activate(cur, false);
whiteboard_interface_unregister_all_address(cur->id);
if (cur->nwk_wpan_nvm_api) {
cur->nwk_wpan_nvm_api->nvm_params_update_cb(cur->nwk_wpan_nvm_api, true);
}
cur->if_lowpan_security_params->mle_security_frame_counter = mle_service_security_get_frame_counter(cur->id);
mac_neighbor_table_neighbor_list_clean(mac_neighbor_info(cur));
#ifndef NO_MLE
blacklist_clear();
#endif
if (nd_nwk) {
ipv6_prefix_on_link_remove(nd_nwk->border_router);
icmp_nd_border_router_release(nd_nwk);
}
//MAC
mac_helper_link_frame_counter_set(cur->id, 0);
mac_helper_panid_set(cur, 0xffff);
mac_helper_mac16_address_set(cur, 0xffff);
/* Init RPL Timers */
cur->lowpan_info &= ~INTERFACE_NWK_ACTIVE;
mac_helper_default_security_level_set(cur, SEC_NONE);
//Reset WhiteBoard
whiteboard_init(cur->id);
lowpan_adaptation_interface_reset(cur->id);
reassembly_interface_reset(cur->id);
protocol_core_interface_info_reset(cur);
cur->bootsrap_state_machine_cnt = 0;
cur->interface_mode = INTERFACE_IDLE;
nd_proxy_downstream_interface_unregister(cur->id);
return ret_val;
}
int8_t arm_nwk_6lowpan_borderrouter_init(protocol_interface_info_entry_t *cur)
{
/* Border Router Allocate entry */
if (cur->border_router_setup == 0) {
cur->border_router_setup = ns_dyn_mem_alloc(sizeof(br_info_t));
if (!cur->border_router_setup) {
return -1;
}
cur->border_router_setup->nd_nwk = ns_dyn_mem_alloc(sizeof(nd_router_t));
cur->border_router_setup->nd_border_router_configure = ns_dyn_mem_alloc(sizeof(nd_router_setup_t));
if (cur->border_router_setup->nd_nwk == 0 || cur->border_router_setup->nd_border_router_configure == 0) {
arm_nwk_6lowpan_borderrouter_data_free(cur);
}
if (cur->border_router_setup) {
cur->border_router_setup->mac_short_adr = 0xffff;
cur->border_router_setup->mac_panid = 0xffff;
if (cur->border_router_setup->nd_border_router_configure) {
ns_list_init(&cur->border_router_setup->nd_border_router_configure->prefix_list);
ns_list_init(&cur->border_router_setup->nd_border_router_configure->context_list);
}
}
} else {
if (cur->border_router_setup->nd_nwk) {
//Clear Setup
nd_router_t *router_object = cur->border_router_setup->nd_nwk;
/**
* Reset Current ND Setup
*/
icmp_nd_router_object_reset(router_object);
}
}
whiteboard_init(cur->id);
cur->bootsrap_mode = ARM_NWK_BOOTSRAP_MODE_6LoWPAN_BORDER_ROUTER;
cur->lowpan_info |= INTERFACE_NWK_ROUTER_DEVICE;
cur->lowpan_info &= ~INTERFACE_NWK_CONF_MAC_RX_OFF_IDLE;
cur->if_up = arm_border_router_interface_up;
cur->if_down = arm_border_router_interface_down;
return 0;
}
#else
int8_t arm_nwk_6lowpan_border_router_init(int8_t interface_id, const border_router_setup_s *border_router_setup_ptr)
{
(void) interface_id;
(void) border_router_setup_ptr;
return -3;
}
int8_t arm_nwk_6lowpan_border_router_context_parameter_update(int8_t interface_id, uint8_t c_id,
uint8_t compress_mode, uint16_t ttl)
{
(void) interface_id;
(void) c_id;
(void) compress_mode;
(void) ttl;
return -1;
}
int8_t arm_nwk_6lowpan_border_router_context_remove_by_id(int8_t interface_id, uint8_t c_id)
{
(void) interface_id;
(void) c_id;
return -1;
}
int8_t arm_nwk_6lowpan_border_router_configure_push(int8_t interface_id)
{
(void) interface_id;
return -1;
}
int8_t arm_nwk_6lowpan_border_router_nd_context_load(int8_t interface_id, uint8_t *contex_data)
{
(void) interface_id;
(void) contex_data;
return -1;
}
int8_t arm_nwk_6lowpan_border_router_context_update(int8_t interface_id, uint8_t c_id_flags, uint8_t context_len, uint16_t ttl, const uint8_t *context_ptr)
{
(void) interface_id;
(void) c_id_flags;
(void) context_len;
(void) ttl;
(void) context_ptr;
return -1;
}
int8_t arm_nwk_6lowpan_border_route_nd_default_prefix_timeout_set(int8_t interface_id, uint32_t time)
{
(void) interface_id;
(void) time;
return -1;
}
#endif
Reference in New Issue View Git Blame Copy Permalink