text: /*
   * 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 <ns_list.h>
  #include <nsdynmemLIB.h>
  #include "fhss_config.h"
  #include "ws_management_api.h"
  #include "NWK_INTERFACE/Include/protocol.h"
  #include "6LoWPAN/ws/ws_common.h"
  #include "6LoWPAN/ws/ws_bootstrap.h"
  #include "6LoWPAN/ws/ws_cfg_settings.h"
  
  #define TRACE_GROUP "wsmg"
  
  #ifdef HAVE_WS
  
  int ws_management_node_init(
      int8_t interface_id,
      uint8_t regulatory_domain,
      char *network_name_ptr,
      fhss_timer_t *fhss_timer_ptr)
  {
      protocol_interface_info_entry_t *cur;
  
      cur = protocol_stack_interface_info_get_by_id(interface_id);
  
      if (interface_id >= 0 && (!cur || !ws_info(cur))) {
          return -1;
      }
  
      if (!network_name_ptr || !fhss_timer_ptr) {
          return -2;
      }
  
      ws_phy_cfg_t phy_cfg;
      if (ws_cfg_phy_get(&phy_cfg, NULL) < 0) {
          return -3;
      }
  
      phy_cfg.regulatory_domain = regulatory_domain;
  
      if (ws_cfg_phy_set(cur, NULL, &phy_cfg, 0) < 0) {
          return -4;
      }
  
      ws_gen_cfg_t gen_cfg;
      if (ws_cfg_gen_get(&gen_cfg, NULL) < 0) {
          return -3;
      }
  
      strncpy(gen_cfg.network_name, network_name_ptr, 32);
  
      if (ws_cfg_gen_set(cur, NULL, &gen_cfg, 0) < 0) {
          return -4;
      }
  
      if (cur && ws_info(cur)) {
          cur->ws_info->fhss_timer_ptr = fhss_timer_ptr;
      }
  
      return 0;
  }
  
  int ws_management_network_name_set(
      int8_t interface_id,
      char *network_name_ptr)
  {
      protocol_interface_info_entry_t *cur;
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (interface_id >= 0 && (!cur || !ws_info(cur))) {
          return -1;
      }
      if (!network_name_ptr) {
          return -2;
      }
  
      ws_gen_cfg_t cfg;
      if (ws_cfg_gen_get(&cfg, NULL) < 0) {
          return -3;
      }
  
      strncpy(cfg.network_name, network_name_ptr, 32);
  
      if (ws_cfg_gen_set(cur, NULL, &cfg, 0) < 0) {
          return -4;
      }
  
      return 0;
  }
  
  int ws_management_network_name_get(
      int8_t interface_id,
      char *network_name_ptr)
  {
      protocol_interface_info_entry_t *cur;
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (interface_id >= 0 && (!cur || !ws_info(cur))) {
          return -1;
      }
      if (!network_name_ptr) {
          return -2;
      }
  
      ws_gen_cfg_t cfg;
      if (ws_cfg_gen_get(&cfg, NULL) < 0) {
          return -3;
      }
  
      memcpy(network_name_ptr, cfg.network_name, 32);
  
      return 0;
  }
  
  int ws_management_network_name_validate(
      int8_t interface_id,
      char *network_name_ptr)
  {
      protocol_interface_info_entry_t *cur;
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (interface_id >= 0 && (!cur || !ws_info(cur))) {
          return -1;
      }
      if (!network_name_ptr) {
          return -2;
      }
  
      ws_gen_cfg_t cfg;
      if (ws_cfg_gen_get(&cfg, NULL) < 0) {
          return -3;
      }
  
      strncpy(cfg.network_name, network_name_ptr, 32);
  
      if (ws_cfg_gen_validate(NULL, &cfg) < 0) {
          return -4;
      }
  
      return 0;
  }
  
  int ws_management_domain_configuration_set(
      int8_t interface_id,
      uint8_t regulatory_domain,
      uint8_t phy_mode_id,
      uint8_t channel_plan_id)
  {
      protocol_interface_info_entry_t *cur;
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (interface_id >= 0 && (!cur || !ws_info(cur))) {
          return -1;
      }
  
      ws_phy_cfg_t cfg;
      ws_phy_cfg_t cfg_default;
      if (ws_cfg_phy_get(&cfg, NULL) < 0) {
          return -3;
      }
  
      if (ws_cfg_phy_default_set(&cfg_default) < 0) {
          return -3;
      }
  
      if (regulatory_domain == 255) {
          cfg.regulatory_domain = cfg_default.regulatory_domain;
      } else if (regulatory_domain != 0) {
          cfg.regulatory_domain = regulatory_domain;
      }
  
      if (phy_mode_id == 255) {
          cfg.phy_mode_id = cfg_default.phy_mode_id;
      } else if (phy_mode_id != 0) {
          cfg.phy_mode_id = phy_mode_id;
      }
  
      if (channel_plan_id == 255) {
          cfg.channel_plan_id = cfg_default.channel_plan_id;
      } else if (channel_plan_id != 0) {
          cfg.channel_plan_id = channel_plan_id;
      }
  
      if (ws_cfg_phy_set(cur, NULL, &cfg, 0) < 0) {
          return -4;
      }
  
      return 0;
  }
  
  int ws_management_domain_configuration_get(
      int8_t interface_id,
      uint8_t *regulatory_domain,
      uint8_t *phy_mode_id,
      uint8_t *channel_plan_id)
  {
      protocol_interface_info_entry_t *cur;
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (interface_id >= 0 && (!cur || !ws_info(cur))) {
          return -1;
      }
  
      ws_phy_cfg_t cfg;
      if (ws_cfg_phy_get(&cfg, NULL) < 0) {
          return -2;
      }
  
      if (regulatory_domain) {
          *regulatory_domain = cfg.regulatory_domain;
      }
      if (phy_mode_id) {
          *phy_mode_id = cfg.phy_mode_id;
      }
      if (channel_plan_id) {
          *channel_plan_id = cfg.channel_plan_id;
      }
  
      return 0;
  }
  
  int ws_management_domain_configuration_validate(
      int8_t interface_id,
      uint8_t regulatory_domain,
      uint8_t phy_mode_id,
      uint8_t channel_plan_id)
  {
      protocol_interface_info_entry_t *cur;
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (interface_id >= 0 && (!cur || !ws_info(cur))) {
          return -1;
      }
  
      ws_phy_cfg_t cfg;
      if (ws_cfg_phy_get(&cfg, NULL) < 0) {
          return -3;
      }
  
      cfg.regulatory_domain = regulatory_domain;
      cfg.phy_mode_id = phy_mode_id;
      cfg.channel_plan_id = channel_plan_id;
  
      if (ws_cfg_phy_validate(NULL, &cfg) < 0) {
          return -4;
      }
  
      return 0;
  }
  
  int ws_management_regulatory_domain_set(
      int8_t interface_id,
      uint8_t regulatory_domain,
      uint8_t operating_class,
      uint8_t operating_mode)
  {
      protocol_interface_info_entry_t *cur;
  
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (interface_id >= 0 && (!cur || !ws_info(cur))) {
          return -1;
      }
  
      ws_phy_cfg_t cfg;
      ws_phy_cfg_t cfg_default;
      if (ws_cfg_phy_get(&cfg, NULL) < 0) {
          return -3;
      }
  
      if (ws_cfg_phy_default_set(&cfg_default) < 0) {
          return -3;
      }
  
      if (regulatory_domain != 255) {
          cfg.regulatory_domain = regulatory_domain;
      } else {
          cfg.regulatory_domain = cfg_default.regulatory_domain;
      }
      if (operating_mode != 255) {
          cfg.operating_mode = operating_mode;
      } else {
          cfg.operating_mode = cfg_default.operating_mode;
      }
      if (operating_class != 255) {
          cfg.operating_class = operating_class;
      } else {
          cfg.operating_class = cfg_default.operating_class;
      }
  
      if (ws_cfg_phy_set(cur, NULL, &cfg, 0) < 0) {
          return -4;
      }
  
      return 0;
  }
  
  int ws_management_regulatory_domain_get(
      int8_t interface_id,
      uint8_t *regulatory_domain,
      uint8_t *operating_class,
      uint8_t *operating_mode)
  {
      protocol_interface_info_entry_t *cur;
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (interface_id >= 0 && (!cur || !ws_info(cur))) {
          return -1;
      }
      if (!regulatory_domain || !operating_class || !operating_mode) {
          return -2;
      }
  
      ws_phy_cfg_t cfg;
      if (ws_cfg_phy_get(&cfg, NULL) < 0) {
          return -3;
      }
  
      *regulatory_domain = cfg.regulatory_domain;
      *operating_class = cfg.operating_class;
      *operating_mode = cfg.operating_mode;
  
      return 0;
  }
  
  int ws_management_regulatory_domain_validate(
      int8_t interface_id,
      uint8_t regulatory_domain,
      uint8_t operating_class,
      uint8_t operating_mode)
  {
      protocol_interface_info_entry_t *cur;
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (interface_id >= 0 && (!cur || !ws_info(cur))) {
          return -1;
      }
  
      ws_phy_cfg_t cfg;
      if (ws_cfg_phy_get(&cfg, NULL) < 0) {
          return -3;
      }
  
      cfg.regulatory_domain = regulatory_domain;
      cfg.operating_class = operating_class;
      cfg.operating_mode = operating_mode;
  
      if (ws_cfg_phy_validate(NULL, &cfg) < 0) {
          return -4;
      }
  
      return 0;
  }
  
  int ws_management_network_size_set(
      int8_t interface_id,
      uint8_t network_size)
  {
      protocol_interface_info_entry_t *cur;
  
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (interface_id >= 0 && (!cur || !ws_info(cur))) {
          return -1;
      }
  
      ws_gen_cfg_t cfg;
      if (ws_cfg_network_size_get(&cfg, NULL) < 0) {
          return -3;
      }
  
      cfg.network_size = network_size;
  
      if (ws_cfg_network_size_set(cur, NULL, &cfg, 0) < 0) {
          return -3;
      }
  
      return 0;
  }
  
  int ws_management_network_size_get(
      int8_t interface_id,
      uint8_t *network_size)
  {
      protocol_interface_info_entry_t *cur;
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (interface_id >= 0 && (!cur || !ws_info(cur))) {
          return -1;
      }
      if (!network_size) {
          return -2;
      }
  
      ws_gen_cfg_t cfg;
      if (ws_cfg_network_size_get(&cfg, NULL) < 0) {
          return -3;
      }
  
      *network_size = cfg.network_size;
  
      return 0;
  }
  
  int ws_management_network_size_validate(
      int8_t interface_id,
      uint8_t network_size)
  {
      protocol_interface_info_entry_t *cur;
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (interface_id >= 0 && (!cur || !ws_info(cur))) {
          return -1;
      }
  
      ws_gen_cfg_t cfg;
      if (ws_cfg_network_size_get(&cfg, NULL) < 0) {
          return -3;
      }
  
      cfg.network_size = network_size;
  
      if (ws_cfg_network_size_validate(NULL, &cfg) < 0) {
          return -4;
      }
  
      return 0;
  }
  
  int ws_management_channel_mask_set(
      int8_t interface_id,
      uint32_t channel_mask[8])
  {
      protocol_interface_info_entry_t *cur;
  
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (interface_id >= 0 && (!cur || !ws_info(cur))) {
          return -1;
      }
  
      ws_fhss_cfg_t cfg;
      if (ws_cfg_fhss_get(&cfg, NULL) < 0) {
          return -2;
      }
  
      ws_fhss_cfg_t cfg_default;
      if (ws_cfg_fhss_default_set(&cfg_default) < 0) {
          return -2;
      }
  
      if (channel_mask) {
          memcpy(cfg.fhss_channel_mask, channel_mask, sizeof(uint32_t) * 8);
      } else {
          // Use the default
          memcpy(cfg.fhss_channel_mask, cfg_default.fhss_channel_mask, sizeof(uint32_t) * 8);
      }
  
  
      if (ws_cfg_fhss_set(cur, NULL, &cfg, 0) < 0) {
          return -3;
      }
  
      return 0;
  }
  
  int ws_management_channel_mask_get(
      int8_t interface_id,
      uint32_t *channel_mask)
  {
      protocol_interface_info_entry_t *cur;
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (interface_id >= 0 && (!cur || !ws_info(cur))) {
          return -1;
      }
      if (!channel_mask) {
          return -2;
      }
  
      ws_fhss_cfg_t cfg;
      if (ws_cfg_fhss_get(&cfg, NULL) < 0) {
          return -2;
      }
  
      memcpy(channel_mask, cfg.fhss_channel_mask, sizeof(uint32_t) * 8);
  
      return 0;
  }
  
  int ws_management_channel_mask_validate(
      int8_t interface_id,
      uint32_t channel_mask[8])
  {
      protocol_interface_info_entry_t *cur;
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (interface_id >= 0 && (!cur || !ws_info(cur))) {
          return -1;
      }
  
      ws_fhss_cfg_t cfg;
      if (ws_cfg_fhss_get(&cfg, NULL) < 0) {
          return -2;
      }
  
      memcpy(cfg.fhss_channel_mask, channel_mask, sizeof(uint32_t) * 8);
  
      if (ws_cfg_fhss_validate(NULL, &cfg) < 0) {
          return -4;
      }
  
      return 0;
  }
  
  int ws_management_channel_plan_set(
      int8_t interface_id,
      uint8_t channel_plan,
      uint8_t uc_channel_function,
      uint8_t bc_channel_function,
      uint32_t ch0_freq, // Stack can not modify this
      uint8_t channel_spacing,// Stack can not modify this
      uint8_t number_of_channels)
  {
      protocol_interface_info_entry_t *cur;
  
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (!cur || !ws_info(cur)) {
          return -1;
      }
      cur->ws_info->hopping_schdule.channel_plan = channel_plan;
      cur->ws_info->hopping_schdule.uc_channel_function = uc_channel_function;
      cur->ws_info->hopping_schdule.bc_channel_function = bc_channel_function;
      cur->ws_info->hopping_schdule.ch0_freq = ch0_freq;
      cur->ws_info->hopping_schdule.channel_spacing = channel_spacing;
      cur->ws_info->hopping_schdule.number_of_channels = number_of_channels;
  
      // TODO update fields to llc
      return 0;
  }
  
  int ws_management_fhss_timing_configure(
      int8_t interface_id,
      uint8_t fhss_uc_dwell_interval,
      uint32_t fhss_broadcast_interval,
      uint8_t fhss_bc_dwell_interval)
  {
      protocol_interface_info_entry_t *cur;
  
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (interface_id >= 0 && (!cur || !ws_info(cur))) {
          return -1;
      }
  
      ws_fhss_cfg_t cfg;
      if (ws_cfg_fhss_get(&cfg, NULL) < 0) {
          return -2;
      }
  
      ws_fhss_cfg_t cfg_default;
      if (ws_cfg_fhss_default_set(&cfg_default) < 0) {
          return -2;
      }
  
      if (fhss_uc_dwell_interval == 0) {
          cfg.fhss_uc_dwell_interval = cfg_default.fhss_uc_dwell_interval;
      } else {
          cfg.fhss_uc_dwell_interval = fhss_uc_dwell_interval;
      }
  
      if (fhss_broadcast_interval > 0xffffff) {
          cfg.fhss_bc_interval = cfg_default.fhss_bc_interval;
      } else if (fhss_broadcast_interval > 0) {
          cfg.fhss_bc_interval = fhss_broadcast_interval;
      }
  
      if (fhss_bc_dwell_interval == 0) {
          cfg.fhss_bc_dwell_interval = cfg_default.fhss_bc_dwell_interval;
      } else {
          cfg.fhss_bc_dwell_interval = fhss_bc_dwell_interval;
      }
  
      if (ws_cfg_fhss_set(cur, NULL, &cfg, 0) < 0) {
          return -3;
      }
  
      return 0;
  }
  
  int ws_management_fhss_unicast_channel_function_configure(
      int8_t interface_id,
      uint8_t channel_function,
      uint16_t fixed_channel,
      uint8_t dwell_interval)
  {
      protocol_interface_info_entry_t *cur;
  
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (interface_id >= 0 && (!cur || !ws_info(cur))) {
          return -1;
      }
  
      ws_fhss_cfg_t cfg;
      if (ws_cfg_fhss_get(&cfg, NULL) < 0) {
          return -2;
      }
  
      ws_fhss_cfg_t cfg_default;
      if (ws_cfg_fhss_default_set(&cfg_default) < 0) {
          return -2;
      }
  
      if (dwell_interval == 0) {
          cfg.fhss_uc_dwell_interval = cfg_default.fhss_uc_dwell_interval;
      } else {
          cfg.fhss_uc_dwell_interval = dwell_interval;
      }
      if (channel_function < 0xff) {
          cfg.fhss_uc_channel_function = channel_function;
      } else {
          cfg.fhss_uc_channel_function = cfg_default.fhss_uc_channel_function;
      }
  
      if (fixed_channel < 0xffff) {
          cfg.fhss_uc_fixed_channel = fixed_channel;
      } else {
          cfg.fhss_uc_fixed_channel = cfg_default.fhss_uc_fixed_channel;
      }
  
      if (ws_cfg_fhss_set(cur, NULL, &cfg, 0) < 0) {
          return -3;
      }
  
      return 0;
  }
  
  int ws_management_fhss_unicast_channel_function_get(
      int8_t interface_id,
      uint8_t *channel_function,
      uint16_t *fixed_channel,
      uint8_t *dwell_interval)
  {
      protocol_interface_info_entry_t *cur;
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (interface_id >= 0 && (!cur || !ws_info(cur))) {
          return -1;
      }
      if (!channel_function || !fixed_channel || !dwell_interval) {
          return -2;
      }
  
      ws_fhss_cfg_t cfg;
      if (ws_cfg_fhss_get(&cfg, NULL) < 0) {
          return -2;
      }
  
      *dwell_interval = cfg.fhss_uc_dwell_interval;
      *channel_function = cfg.fhss_uc_channel_function;
      *fixed_channel = cfg.fhss_uc_fixed_channel;
  
      return 0;
  }
  
  int ws_management_fhss_unicast_channel_function_validate(
      int8_t interface_id,
      uint8_t channel_function,
      uint16_t fixed_channel,
      uint8_t dwell_interval)
  {
      protocol_interface_info_entry_t *cur;
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (interface_id >= 0 && (!cur || !ws_info(cur))) {
          return -1;
      }
  
      ws_fhss_cfg_t cfg;
      if (ws_cfg_fhss_get(&cfg, NULL) < 0) {
          return -2;
      }
  
      cfg.fhss_uc_dwell_interval = dwell_interval;
      cfg.fhss_uc_channel_function = channel_function;
      cfg.fhss_uc_fixed_channel = fixed_channel;
  
      if (ws_cfg_fhss_validate(NULL, &cfg) < 0) {
          return -4;
      }
  
      return 0;
  }
  
  int ws_management_fhss_broadcast_channel_function_configure(
      int8_t interface_id,
      uint8_t channel_function,
      uint16_t fixed_channel,
      uint8_t dwell_interval,
      uint32_t broadcast_interval)
  {
      protocol_interface_info_entry_t *cur;
  
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (interface_id >= 0 && (!cur || !ws_info(cur))) {
          return -1;
      }
  
      ws_fhss_cfg_t cfg;
      if (ws_cfg_fhss_get(&cfg, NULL) < 0) {
          return -2;
      }
      ws_fhss_cfg_t cfg_default;
      if (ws_cfg_fhss_default_set(&cfg_default) < 0) {
          return -2;
      }
  
      if (dwell_interval == 0) {
          cfg.fhss_bc_dwell_interval = cfg_default.fhss_bc_dwell_interval;
      } else {
          cfg.fhss_bc_dwell_interval = dwell_interval;
      }
  
      if (broadcast_interval > 0xffffff) {
          cfg.fhss_bc_interval = cfg_default.fhss_bc_interval;
      } else if (broadcast_interval > 0) {
          cfg.fhss_bc_interval = broadcast_interval;
      }
  
      if (channel_function != 0xff) {
          cfg.fhss_bc_channel_function = channel_function;
      } else {
          cfg.fhss_bc_channel_function = cfg_default.fhss_bc_channel_function;
      }
  
      if (fixed_channel != 0xffff) {
          cfg.fhss_bc_fixed_channel = fixed_channel;
      } else {
          cfg.fhss_bc_fixed_channel = cfg_default.fhss_bc_fixed_channel;
      }
  
      if (ws_cfg_fhss_set(cur, NULL, &cfg, 0) < 0) {
          return -3;
      }
  
      return 0;
  }
  
  int ws_management_fhss_broadcast_channel_function_get(
      int8_t interface_id,
      uint8_t *channel_function,
      uint16_t *fixed_channel,
      uint8_t *dwell_interval,
      uint32_t *broadcast_interval)
  {
      protocol_interface_info_entry_t *cur;
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (interface_id >= 0 && (!cur || !ws_info(cur))) {
          return -1;
      }
      if (!channel_function || !fixed_channel || !dwell_interval) {
          return -2;
      }
  
      ws_fhss_cfg_t cfg;
      if (ws_cfg_fhss_get(&cfg, NULL) < 0) {
          return -2;
      }
  
      *dwell_interval = cfg.fhss_bc_dwell_interval;
      *broadcast_interval = cfg.fhss_bc_interval;
      *channel_function = cfg.fhss_bc_channel_function;
      *fixed_channel = cfg.fhss_bc_fixed_channel;
  
      return 0;
  }
  
  int ws_management_fhss_broadcast_channel_function_validate(
      int8_t interface_id,
      uint8_t channel_function,
      uint16_t fixed_channel,
      uint8_t dwell_interval,
      uint32_t broadcast_interval)
  {
      protocol_interface_info_entry_t *cur;
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (interface_id >= 0 && (!cur || !ws_info(cur))) {
          return -1;
      }
  
      ws_fhss_cfg_t cfg;
      if (ws_cfg_fhss_get(&cfg, NULL) < 0) {
          return -2;
      }
  
      cfg.fhss_bc_dwell_interval = dwell_interval;
      cfg.fhss_bc_interval = broadcast_interval;
      cfg.fhss_bc_channel_function = channel_function;
      cfg.fhss_bc_fixed_channel = fixed_channel;
  
      if (ws_cfg_fhss_validate(NULL, &cfg) < 0) {
          return -4;
      }
  
      return 0;
  }
  
  int ws_management_timing_parameters_set(
      int8_t interface_id,
      uint16_t disc_trickle_imin,
      uint16_t disc_trickle_imax,
      uint8_t disc_trickle_k,
      uint16_t pan_timeout)
  {
      protocol_interface_info_entry_t *cur;
  
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (interface_id >= 0 && (!cur || !ws_info(cur))) {
          return -1;
      }
  
      ws_timing_cfg_t cfg;
      if (ws_cfg_timing_get(&cfg, NULL) < 0) {
          return -2;
      }
  
      ws_timing_cfg_t cfg_default;
      if (ws_cfg_timing_default_set(&cfg_default) < 0) {
          return -2;
      }
  
      if (disc_trickle_imin > 0) {
          cfg.disc_trickle_imin = disc_trickle_imin;
      } else {
          cfg.disc_trickle_imin = cfg_default.disc_trickle_imin;
      }
  
      if (disc_trickle_imax > 0) {
          cfg.disc_trickle_imax = disc_trickle_imax;
      } else {
          cfg.disc_trickle_imax = cfg_default.disc_trickle_imax;;
      }
  
      if (disc_trickle_k > 0) {
          cfg.disc_trickle_k = disc_trickle_k;
      } else {
          cfg.disc_trickle_k = cfg_default.disc_trickle_k;;
      }
  
      if (pan_timeout > 0) {
          cfg.pan_timeout = pan_timeout;
      } else {
          cfg.pan_timeout = cfg_default.pan_timeout;;
      }
  
      if (ws_cfg_timing_set(cur, NULL, &cfg, 0) < 0) {
          return -3;
      }
  
      return 0;
  }
  
  int ws_management_timing_parameters_get(
      int8_t interface_id,
      uint16_t *disc_trickle_imin,
      uint16_t *disc_trickle_imax,
      uint8_t *disc_trickle_k,
      uint16_t *pan_timeout)
  {
      protocol_interface_info_entry_t *cur;
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (interface_id >= 0 && (!cur || !ws_info(cur))) {
          return -1;
      }
      if (!disc_trickle_imin || !disc_trickle_imax || !disc_trickle_k || !pan_timeout) {
          return -2;
      }
  
      ws_timing_cfg_t cfg;
      if (ws_cfg_timing_get(&cfg, NULL) < 0) {
          return -2;
      }
  
      *disc_trickle_imin = cfg.disc_trickle_imin;
      *disc_trickle_imax = cfg.disc_trickle_imax;
      *disc_trickle_k = cfg.disc_trickle_k;
      *pan_timeout = cfg.pan_timeout;
  
      return 0;
  }
  
  int ws_management_timing_parameters_validate(
      int8_t interface_id,
      uint16_t disc_trickle_imin,
      uint16_t disc_trickle_imax,
      uint8_t disc_trickle_k,
      uint16_t pan_timeout)
  {
      protocol_interface_info_entry_t *cur;
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (interface_id >= 0 && (!cur || !ws_info(cur))) {
          return -1;
      }
  
      ws_timing_cfg_t cfg;
      if (ws_cfg_timing_get(&cfg, NULL) < 0) {
          return -2;
      }
  
      cfg.disc_trickle_imin = disc_trickle_imin;
      cfg.disc_trickle_imax = disc_trickle_imax;
      cfg.disc_trickle_k = disc_trickle_k;
      cfg.pan_timeout = pan_timeout;
  
      if (ws_cfg_timing_validate(NULL, &cfg) < 0) {
          return -4;
      }
  
      return 0;
  }
  
  int ws_stack_info_get(int8_t interface_id, ws_stack_info_t *info_ptr)
  {
      protocol_interface_info_entry_t *cur;
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (!cur || !ws_info(cur) || !info_ptr) {
          return -1;
      }
      return ws_bootstrap_stack_info_get(cur, info_ptr);
  }
  
  int ws_neighbor_info_get(
      int8_t interface_id,
      ws_neighbour_info_t *neighbor_ptr,
      uint16_t count)
  {
      protocol_interface_info_entry_t *cur;
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (!cur || !ws_info(cur)) {
          return -1;
      }
      return ws_bootstrap_neighbor_info_get(cur, neighbor_ptr, count);
  }
  
  int ws_device_min_sens_set(
      int8_t interface_id,
      uint8_t device_min_sens)
  {
      protocol_interface_info_entry_t *cur;
      cur = protocol_stack_interface_info_get_by_id(interface_id);
      if (!cur || !ws_info(cur)) {
          return -1;
      }
      DEVICE_MIN_SENS = device_min_sens;
      ws_info(cur)->device_min_sens = device_min_sens;
      return 0;
  }
  
  #endif // HAVE_WS
  