mirror of https://github.com/ARMmbed/mbed-os.git
489 lines
16 KiB
C
489 lines
16 KiB
C
/*
|
|
* Copyright (c) 2018-2019, Arm Limited 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 <string.h>
|
|
#include "nsconfig.h"
|
|
#include "ns_types.h"
|
|
#include "ns_trace.h"
|
|
#include "net_interface.h"
|
|
#include "eventOS_event.h"
|
|
#include "NWK_INTERFACE/Include/protocol.h"
|
|
#include "6LoWPAN/Bootstraps/protocol_6lowpan.h"
|
|
#include "6LoWPAN/Bootstraps/protocol_6lowpan_interface.h"
|
|
#include "6LoWPAN/ws/ws_config.h"
|
|
#include "6LoWPAN/ws/ws_common.h"
|
|
#include "6LoWPAN/ws/ws_bootstrap.h"
|
|
#include "RPL/rpl_control.h"
|
|
#include "RPL/rpl_data.h"
|
|
#include "Common_Protocols/icmpv6.h"
|
|
#include "Common_Protocols/icmpv6_radv.h"
|
|
#include "ws_management_api.h"
|
|
#include "net_rpl.h"
|
|
#include "Service_Libs/nd_proxy/nd_proxy.h"
|
|
#include "6LoWPAN/ws/ws_bbr_api_internal.h"
|
|
#include "DHCPv6_Server/DHCPv6_server_service.h"
|
|
|
|
#define TRACE_GROUP "wsbs"
|
|
|
|
#define RPL_INSTANCE_ID 1
|
|
|
|
#ifdef HAVE_WS_BORDER_ROUTER
|
|
|
|
|
|
/* when creating BBR make ULA dodag ID always and when network becomes available add prefix to DHCP
|
|
*
|
|
*
|
|
*/
|
|
static int8_t backbone_interface_id = -1; // BBR backbone information
|
|
|
|
static uint8_t static_dodag_prefix[8] = {0xfd, 0x00, 0x61, 0x72, 0x6d};
|
|
static uint8_t static_ula_address[16] = {0};
|
|
static uint8_t static_dodag_id[16] = {0};
|
|
static uint8_t global_dodag_id[16] = {0};
|
|
static uint32_t bbr_delay_timer = 20; // initial delay.
|
|
|
|
static rpl_dodag_conf_t rpl_conf = {
|
|
// Lifetime values
|
|
.default_lifetime = 120,
|
|
.lifetime_unit = 60,
|
|
.objective_code_point = 1, // MRHOF algorithm used
|
|
.authentication = 0,
|
|
.path_control_size = 7,
|
|
.dag_max_rank_increase = 2048,
|
|
.min_hop_rank_increase = 256,
|
|
// DIO configuration
|
|
.dio_interval_min = WS_RPL_DIO_IMIN,
|
|
.dio_interval_doublings = WS_RPL_DIO_DOUBLING,
|
|
.dio_redundancy_constant = WS_RPL_DIO_REDUNDANCY
|
|
};
|
|
|
|
void ws_bbr_rpl_config(uint8_t imin, uint8_t doubling, uint8_t redundancy)
|
|
{
|
|
if (imin == 0 || doubling == 0) {
|
|
// use default values
|
|
imin = WS_RPL_DIO_IMIN;
|
|
doubling = WS_RPL_DIO_DOUBLING;
|
|
redundancy = WS_RPL_DIO_REDUNDANCY;
|
|
}
|
|
if (rpl_conf.dio_interval_min == imin &&
|
|
rpl_conf.dio_interval_doublings == doubling &&
|
|
rpl_conf.dio_redundancy_constant == redundancy) {
|
|
// Same values no update needed
|
|
return;
|
|
}
|
|
rpl_conf.dio_interval_min = imin;
|
|
rpl_conf.dio_interval_doublings = doubling;
|
|
rpl_conf.dio_redundancy_constant = redundancy;
|
|
if (protocol_6lowpan_rpl_root_dodag) {
|
|
rpl_control_update_dodag_config(protocol_6lowpan_rpl_root_dodag, &rpl_conf);
|
|
rpl_control_increment_dodag_version(protocol_6lowpan_rpl_root_dodag);
|
|
}
|
|
}
|
|
|
|
static void ws_bbr_rpl_root_start(uint8_t *dodag_id)
|
|
{
|
|
tr_info("RPL root start");
|
|
rpl_data_init_root();
|
|
|
|
if (protocol_6lowpan_rpl_root_dodag) {
|
|
rpl_control_delete_dodag_root(protocol_6lowpan_rpl_domain, protocol_6lowpan_rpl_root_dodag);
|
|
protocol_6lowpan_rpl_root_dodag = NULL;
|
|
}
|
|
|
|
protocol_6lowpan_rpl_root_dodag = rpl_control_create_dodag_root(protocol_6lowpan_rpl_domain, RPL_INSTANCE_ID, dodag_id, &rpl_conf, rpl_conf.min_hop_rank_increase, RPL_GROUNDED | RPL_MODE_NON_STORING | RPL_DODAG_PREF(0));
|
|
if (!protocol_6lowpan_rpl_root_dodag) {
|
|
tr_err("RPL dodag init failed");
|
|
return;
|
|
}
|
|
memcpy(static_dodag_id, dodag_id, 16);
|
|
|
|
// RPL memory limits set larger for Border router
|
|
rpl_control_set_memory_limits(64 * 1024, 0);
|
|
|
|
uint8_t t_flags = PIO_A;
|
|
|
|
rpl_control_update_dodag_prefix(protocol_6lowpan_rpl_root_dodag, dodag_id, 64, t_flags, 7200, 7200, false);
|
|
rpl_control_update_dodag_route(protocol_6lowpan_rpl_root_dodag, dodag_id, 64, 0x18, 7200, false);
|
|
}
|
|
|
|
static void ws_bbr_rpl_root_stop(void)
|
|
{
|
|
tr_info("RPL root stop");
|
|
rpl_control_delete_dodag_root(protocol_6lowpan_rpl_domain, protocol_6lowpan_rpl_root_dodag);
|
|
protocol_6lowpan_rpl_root_dodag = NULL;
|
|
memset(static_ula_address, 0, 16);
|
|
memset(static_dodag_id, 0, 16);
|
|
memset(global_dodag_id, 0, 16);
|
|
}
|
|
|
|
static int ws_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 ws_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;
|
|
}
|
|
|
|
static int ws_bbr_static_ula_create(protocol_interface_info_entry_t *cur)
|
|
{
|
|
if (memcmp(static_ula_address, ADDR_UNSPECIFIED, 16) != 0) {
|
|
// address generated
|
|
return 0;
|
|
}
|
|
tr_info("BBR generate ula prefix");
|
|
|
|
// This address is only used if no other address available.
|
|
if_address_entry_t *add_entry = icmpv6_slaac_address_add(cur, static_dodag_prefix, 64, 0xffffffff, 0, true, SLAAC_IID_FIXED);
|
|
if (!add_entry) {
|
|
return -1;
|
|
}
|
|
memcpy(static_ula_address, add_entry->address, 16);
|
|
tr_info("BBR generate ula prefix addr %s", trace_ipv6(static_ula_address));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* 0 static non rooted self generated own address
|
|
* 1 static address with backbone connectivity
|
|
*/
|
|
static int ws_bbr_static_dodag_get(protocol_interface_info_entry_t *cur, uint8_t *dodag_id_ptr)
|
|
{
|
|
|
|
protocol_interface_info_entry_t *bb_interface = protocol_stack_interface_info_get_by_id(backbone_interface_id);
|
|
|
|
if (bb_interface && bb_interface->ipv6_configure->ipv6_stack_mode == NET_IPV6_BOOTSTRAP_STATIC) {
|
|
// static configuration for ethernet available
|
|
ns_list_foreach(if_address_entry_t, add_entry, &cur->ip_addresses) {
|
|
if (memcmp(add_entry->address, bb_interface->ipv6_configure->static_prefix64, 8) == 0) {
|
|
//tr_info("BBR static config available");
|
|
if (dodag_id_ptr) {
|
|
memcpy(dodag_id_ptr, add_entry->address, 16);
|
|
}
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
ws_bbr_static_ula_create(cur);
|
|
|
|
// only own generated prefix available
|
|
if (dodag_id_ptr) {
|
|
memcpy(dodag_id_ptr, static_ula_address, 16);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int ws_bbr_dodag_get(protocol_interface_info_entry_t *cur, uint8_t *static_dodag_id_ptr, uint8_t *dodag_id_ptr)
|
|
{
|
|
uint8_t global_address[16];
|
|
|
|
if (static_dodag_id_ptr) {
|
|
memset(static_dodag_id_ptr, 0, 16);
|
|
}
|
|
|
|
if (dodag_id_ptr) {
|
|
memset(dodag_id_ptr, 0, 16);
|
|
}
|
|
|
|
if (ws_bbr_static_dodag_get(cur, static_dodag_id_ptr) < 0) {
|
|
// no static configuration available
|
|
return -1;
|
|
}
|
|
|
|
if (arm_net_address_get(backbone_interface_id, ADDR_IPV6_GP, global_address) != 0) {
|
|
// No global prefix available
|
|
return 0;
|
|
}
|
|
if (memcmp(global_address, dodag_id_ptr, 8) == 0) {
|
|
// static address is same
|
|
return 0;
|
|
}
|
|
memcpy(dodag_id_ptr, global_address, 16);
|
|
return 0;
|
|
}
|
|
static void wisun_bbr_na_send(int8_t interface_id, const uint8_t target[static 16])
|
|
{
|
|
protocol_interface_info_entry_t *cur = protocol_stack_interface_info_get_by_id(interface_id);
|
|
if (!cur) {
|
|
return;
|
|
}
|
|
|
|
buffer_t *buffer = icmpv6_build_na(cur, false, true, true, target, NULL, ADDR_UNSPECIFIED);
|
|
protocol_push(buffer);
|
|
return;
|
|
|
|
}
|
|
|
|
static bool wisun_dhcp_address_add_cb(int8_t interfaceId, dhcp_address_cache_update_t *address_info, void *route_src)
|
|
{
|
|
(void)route_src;
|
|
protocol_interface_info_entry_t *curPtr = protocol_stack_interface_info_get_by_id(interfaceId);
|
|
if (!curPtr) {
|
|
return false;
|
|
}
|
|
|
|
// When address is allocated we send NA to backbone to notify the new address and flush from other BBRs
|
|
wisun_bbr_na_send(backbone_interface_id, address_info->allocatedAddress);
|
|
return true;
|
|
}
|
|
|
|
|
|
static void ws_bbr_rpl_status_check(protocol_interface_info_entry_t *cur)
|
|
{
|
|
|
|
uint8_t static_id[16] = {0};
|
|
uint8_t global_id[16] = {0};
|
|
|
|
//tr_info("BBR status check");
|
|
|
|
ws_bbr_dodag_get(cur, static_id, global_id);
|
|
|
|
if (memcmp(static_dodag_id, static_id, 16) != 0) {
|
|
// Static id updated or first setup
|
|
ws_bbr_rpl_root_start(static_id);
|
|
}
|
|
if (memcmp(global_dodag_id, global_id, 16) != 0) {
|
|
// Global prefix changed
|
|
if (memcmp(global_dodag_id, ADDR_UNSPECIFIED, 16) != 0) {
|
|
// TODO remove old global prefix
|
|
tr_info("RPL GUA deactivate %s", trace_ipv6(global_dodag_id));
|
|
|
|
rpl_control_update_dodag_prefix(protocol_6lowpan_rpl_root_dodag, static_dodag_id, 64, PIO_A, 7200, 7200, false);
|
|
rpl_control_update_dodag_route(protocol_6lowpan_rpl_root_dodag, static_dodag_id, 64, 0x18, 7200, false);
|
|
|
|
// Old backbone information is deleted after 120 seconds
|
|
rpl_control_update_dodag_route(protocol_6lowpan_rpl_root_dodag, NULL, 0, 0, 120, true);
|
|
rpl_control_update_dodag_prefix(protocol_6lowpan_rpl_root_dodag, global_dodag_id, 64, 0, 120, 0, true);
|
|
rpl_control_update_dodag_route(protocol_6lowpan_rpl_root_dodag, global_dodag_id, 64, 0, 120, true);
|
|
ipv6_route_add_with_info(global_dodag_id, 64, backbone_interface_id, NULL, ROUTE_THREAD_BBR, NULL, 0, 120, 0);
|
|
DHCPv6_server_service_delete(cur->id, global_dodag_id, false);
|
|
|
|
// Set old addresses to deferred and timeout
|
|
ws_dhcp_client_address_delete(cur, global_dodag_id);
|
|
}
|
|
// TODO add global prefix
|
|
if (memcmp(global_id, ADDR_UNSPECIFIED, 16) != 0) {
|
|
//DHCPv6 Server set here
|
|
//Interface LL64 address
|
|
uint8_t ll[16];
|
|
memcpy(ll, ADDR_LINK_LOCAL_PREFIX, 8);
|
|
memcpy(&ll[8], cur->mac, 8);
|
|
ll[8] ^= 2;
|
|
|
|
if (DHCPv6_server_service_init(cur->id, global_id, cur->mac, DHCPV6_DUID_HARDWARE_IEEE_802_NETWORKS_TYPE) != 0) {
|
|
tr_error("DHCPv6 Server create fail");
|
|
return;
|
|
}
|
|
DHCPv6_server_service_callback_set(cur->id, global_id, NULL, wisun_dhcp_address_add_cb);
|
|
|
|
DHCPv6_server_service_set_address_autonous_flag(cur->id, global_id, true);
|
|
DHCPv6_server_service_set_address_validlifetime(cur->id, global_id, 7200);
|
|
|
|
tr_info("RPL GUA activate %s", trace_ipv6(global_id));
|
|
ws_dhcp_client_address_request(cur, global_id, ll);
|
|
|
|
rpl_control_update_dodag_route(protocol_6lowpan_rpl_root_dodag, NULL, 0, 0, 7200, false);
|
|
rpl_control_update_dodag_prefix(protocol_6lowpan_rpl_root_dodag, static_dodag_id, 64, PIO_A, 7200, 0, false);
|
|
rpl_control_update_dodag_route(protocol_6lowpan_rpl_root_dodag, static_dodag_id, 64, 0x18, 7200, false);
|
|
rpl_control_update_dodag_prefix(protocol_6lowpan_rpl_root_dodag, global_id, 64, 0, 7200, 7200, false);
|
|
rpl_control_update_dodag_route(protocol_6lowpan_rpl_root_dodag, global_id, 64, 0, 7200, false);
|
|
ipv6_route_add_with_info(global_id, 64, backbone_interface_id, NULL, ROUTE_THREAD_BBR, NULL, 0, 0xffffffff, 0);
|
|
}
|
|
memcpy(global_dodag_id, global_id, 16);
|
|
rpl_control_increment_dodag_version(protocol_6lowpan_rpl_root_dodag);
|
|
nd_proxy_downstream_interface_register(cur->id, ws_border_router_proxy_validate, ws_border_router_proxy_state_update);
|
|
}
|
|
|
|
}
|
|
|
|
void ws_bbr_seconds_timer(protocol_interface_info_entry_t *cur, uint32_t seconds)
|
|
{
|
|
(void)seconds;
|
|
|
|
if (!ws_info(cur)) {
|
|
return;
|
|
}
|
|
if (cur->bootsrap_mode != ARM_NWK_BOOTSRAP_MODE_6LoWPAN_BORDER_ROUTER) {
|
|
// Not a border router
|
|
return;
|
|
}
|
|
if (!cur->rpl_domain) {
|
|
// RPL not started
|
|
return;
|
|
}
|
|
|
|
if (bbr_delay_timer > seconds) {
|
|
bbr_delay_timer -= seconds;
|
|
} else {
|
|
bbr_delay_timer = 20; // 20 second interval between status checks
|
|
|
|
// prequisists
|
|
// Wi-SUN network configuration started without RPL
|
|
|
|
// RPL configured simple
|
|
// 1. Wait for backend connection
|
|
// 2. When address becomes available in backend start RPL dodag
|
|
// 3. if address removed remove dodag
|
|
|
|
// RPL configured Advanced
|
|
// 1. Add ULA DODAG and and start ROOT even without backend
|
|
// a. If static prefix configured use it.
|
|
// b. generate random ULA and publish it to backend
|
|
// 2. if GUA prefix becomes available in backend add new prefix to DODAG
|
|
// 3. if GUA prefix is removed remove the prefix.
|
|
|
|
if (protocol_6lowpan_rpl_root_dodag) {
|
|
// Border router is active
|
|
if (0 != protocol_interface_address_compare(static_dodag_id)) {
|
|
// Dodag has become invalid need to delete
|
|
tr_info("RPL static dodag not valid anymore %s", trace_ipv6(static_dodag_id));
|
|
ws_bbr_rpl_root_stop();
|
|
} else {
|
|
|
|
}
|
|
}
|
|
ws_bbr_rpl_status_check(cur);
|
|
|
|
}
|
|
// 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 {
|
|
// Border router has timed out
|
|
tr_debug("Border router version number update");
|
|
cur->ws_info->pan_version_timer = PAN_VERSION_LIFETIME;
|
|
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);
|
|
}
|
|
// We update the RPL version in same time to allow nodes to reselect parent
|
|
// As configuration is made so that devices cant move downward in dodag this allows it
|
|
// TODO think the correct rate for this
|
|
if (cur->ws_info->pan_information.pan_version && cur->ws_info->pan_information.pan_version % RPL_VERSION_LIFETIME / PAN_VERSION_LIFETIME == 0) {
|
|
// Third the rate of configuration version change at default 5 hours
|
|
rpl_control_increment_dodag_version(protocol_6lowpan_rpl_root_dodag);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
uint16_t test_pan_size_override = 0xffff;
|
|
|
|
uint16_t ws_bbr_pan_size(protocol_interface_info_entry_t *cur)
|
|
{
|
|
uint16_t result = 0;
|
|
if (test_pan_size_override != 0xffff) {
|
|
return test_pan_size_override;
|
|
}
|
|
|
|
rpl_control_get_instance_dao_target_count(cur->rpl_domain, RPL_INSTANCE_ID, NULL, &result);
|
|
return result;
|
|
}
|
|
|
|
|
|
#endif //HAVE_WS_BORDER_ROUTER
|
|
|
|
/* Public APIs
|
|
*
|
|
*/
|
|
|
|
int ws_bbr_start(int8_t interface_id, int8_t bb_interface_id)
|
|
{
|
|
#ifdef HAVE_WS_BORDER_ROUTER
|
|
|
|
(void)interface_id;
|
|
protocol_interface_info_entry_t *bb_interface = protocol_stack_interface_info_get_by_id(bb_interface_id);
|
|
|
|
if (!bb_interface) {
|
|
return -1;
|
|
}
|
|
// TODO make bb configurations
|
|
|
|
backbone_interface_id = bb_interface_id;
|
|
|
|
return 0;
|
|
#else
|
|
(void)interface_id;
|
|
(void)bb_interface_id;
|
|
return -1;
|
|
#endif
|
|
}
|
|
void ws_bbr_stop(int8_t interface_id)
|
|
{
|
|
#ifdef HAVE_WS_BORDER_ROUTER
|
|
|
|
(void)interface_id;
|
|
backbone_interface_id = -1;
|
|
|
|
if (!protocol_6lowpan_rpl_domain) {
|
|
return;
|
|
}
|
|
|
|
rpl_control_delete_dodag_root(protocol_6lowpan_rpl_domain, protocol_6lowpan_rpl_root_dodag);
|
|
protocol_6lowpan_rpl_root_dodag = NULL;
|
|
|
|
#else
|
|
(void)interface_id;
|
|
#endif
|
|
}
|
|
|
|
int ws_bbr_node_keys_remove(int8_t interface_id, uint8_t *eui64)
|
|
{
|
|
(void) interface_id;
|
|
(void) eui64;
|
|
|
|
return -1;
|
|
}
|
|
|
|
int ws_bbr_node_access_revoke_start(int8_t interface_id)
|
|
{
|
|
(void) interface_id;
|
|
|
|
return -1;
|
|
}
|