int str_to_mods(const char *s)
{
int mods = MOD_NM;
for (int i = 0; s[i]; i += STR_MOD_LENGTH) {
IF_MOD_SET("EZ", MOD_EZ, mods, s, i);
IF_MOD_SET("HR", MOD_HR, mods, s, i);
IF_MOD_SET("HT", MOD_HT, mods, s, i);
IF_MOD_SET("DT", MOD_DT, mods, s, i);
IF_MOD_SET("HD", MOD_HD, mods, s, i);
IF_MOD_SET("FL", MOD_FL, mods, s, i);
IF_MOD_SET("__", MOD_NM, mods, s, i);
for (int k = 1; k < STR_MOD_LENGTH; k++) {
if (s[i+k] == 0) {
tr_error("Wrong mod length.");
goto break2;
}
}
tr_error("Unknown mod used.");
}
break2:
if ((mods & MOD_EZ) && (mods & MOD_HR))
tr_error("Incompatible mods EZ and HR");
if ((mods & MOD_HT) && (mods & MOD_DT))
tr_error("Incompatible mods HT and DT");
return mods;
}
void nd_tasklet_trace_bootstrap_info()
{
network_layer_address_s app_nd_address_info;
link_layer_address_s app_link_address_info;
uint8_t temp_ipv6[16];
if (arm_nwk_nd_address_read(tasklet_data_ptr->network_interface_id,
&app_nd_address_info) != 0) {
tr_error("ND Address read fail");
} else {
tr_debug("ND Access Point: %s", trace_ipv6(app_nd_address_info.border_router));
tr_debug("ND Prefix 64: %s", trace_array(app_nd_address_info.prefix, 8));
if (arm_net_address_get(tasklet_data_ptr->network_interface_id,
ADDR_IPV6_GP, temp_ipv6) == 0) {
tr_debug("GP IPv6: %s", trace_ipv6(temp_ipv6));
}
}
if (arm_nwk_mac_address_read(tasklet_data_ptr->network_interface_id,
&app_link_address_info) != 0) {
tr_error("MAC Address read fail\n");
} else {
uint8_t temp[2];
common_write_16_bit(app_link_address_info.mac_short,temp);
tr_debug("MAC 16-bit: %s", trace_array(temp, 2));
common_write_16_bit(app_link_address_info.PANId, temp);
tr_debug("PAN ID: %s", trace_array(temp, 2));
tr_debug("MAC 64-bit: %s", trace_array(app_link_address_info.mac_long, 8));
tr_debug("IID (Based on MAC 64-bit address): %s", trace_array(app_link_address_info.iid_eui64, 8));
}
tr_debug("Channel: %d", arm_net_get_current_channel(tasklet_data_ptr->network_interface_id));
}
void NanostackSocket::event_data(socket_callback_t *sock_cb)
{
nanostack_assert_locked();
MBED_ASSERT((SOCKET_MODE_DATAGRAM == mode) ||
(SOCKET_MODE_STREAM == mode));
// Allocate buffer
NanostackBuffer *recv_buff = (NanostackBuffer *) MALLOC(
sizeof(NanostackBuffer) + sock_cb->d_len);
if (NULL == recv_buff) {
tr_error("alloc failed!");
return;
}
recv_buff->next = NULL;
// Write data to buffer
int16_t length = socket_read(sock_cb->socket_id,
&recv_buff->ns_address, recv_buff->payload,
sock_cb->d_len);
if (length < 0) {
tr_error("socket_read failed!");
FREE(recv_buff);
return;
}
recv_buff->length = length;
data_attach(recv_buff);
}
/**
* \brief Initializes the SLIP MAC backhaul driver.
* This function is called by the border router module.
*/
void backhaul_driver_init(void (*backhaul_driver_status_cb)(uint8_t, int8_t))
{
const char *driver = STR(YOTTA_CFG_K64F_BORDER_ROUTER_BACKHAUL_DRIVER);
if (strcmp(driver, "SLIP") == 0) {
int8_t slipdrv_id;
pslipmacdriver = new SlipMACDriver(SERIAL_TX, SERIAL_RX, SERIAL_RTS, SERIAL_CTS);
tr_debug("Using SLIP backhaul driver...");
if (pslipmacdriver == NULL) {
tr_error("Unable to create SLIP driver");
return;
}
slipdrv_id = pslipmacdriver->Slip_Init(mac, YOTTA_CFG_K64F_BORDER_ROUTER_BACKHAUL_SERIAL_BAUD);
if (slipdrv_id >= 0) {
backhaul_driver_status_cb(1, slipdrv_id);
return;
}
tr_error("Backhaul driver init failed, retval = %d", slipdrv_id);
} else if (strcmp(driver, "ETH") == 0) {
tr_debug("Using ETH backhaul driver...");
arm_eth_phy_device_register(mac, backhaul_driver_status_cb);
return;
}
tr_error("Unsupported backhaul driver: %s", driver);
}
int NanostackInterface::socket_sendto(void *handle, const SocketAddress &address, const void *data, unsigned int size)
{
// Validate parameters
NanostackSocket * socket = static_cast<NanostackSocket *>(handle);
if (NULL == handle) {
MBED_ASSERT(false);
return NSAPI_ERROR_NO_SOCKET;
}
nanostack_lock();
int ret;
if (socket->closed()) {
ret = NSAPI_ERROR_NO_CONNECTION;
} else if (NANOSTACK_SOCKET_TCP == socket->proto) {
tr_error("socket_sendto() not supported with SOCKET_STREAM!");
ret = NSAPI_ERROR_UNSUPPORTED;
} else {
ns_address_t ns_address;
convert_mbed_addr_to_ns(&ns_address, &address);
if (!socket->is_bound()) {
socket->set_bound();
}
int8_t send_to_status = ::socket_sendto(socket->socket_id, &ns_address,
(uint8_t *)data, size);
/*
* \return 0 on success.
* \return -1 invalid socket id.
* \return -2 Socket memory allocation fail.
* \return -3 TCP state not established.
* \return -4 Socket tx process busy.
* \return -5 TLS authentication not ready.
* \return -6 Packet too short.
* */
if (-4 == send_to_status) {
ret = NSAPI_ERROR_WOULD_BLOCK;
} else if (0 != send_to_status) {
tr_error("socket_sendto: error=%d", send_to_status);
ret = NSAPI_ERROR_DEVICE_ERROR;
} else {
ret = size;
}
}
nanostack_unlock();
tr_debug("socket_sendto(socket=%p) sock_id=%d, ret=%i", socket, socket->socket_id, ret);
return ret;
}
nsapi_error_t EasyCellularConnection::connect()
{
nsapi_error_t err = check_connect();
if (err) {
return err;
}
#if USE_APN_LOOKUP
if (!_credentials_set) {
_target_state = CellularConnectionFSM::STATE_SIM_PIN;
err = _cellularConnectionFSM->continue_to_state(_target_state);
if (err == NSAPI_ERROR_OK) {
int sim_wait = _cellularSemaphore.wait(60 * 1000); // reserve 60 seconds to access to SIM
if (sim_wait != 1) {
tr_error("NO SIM ACCESS");
err = NSAPI_ERROR_NO_CONNECTION;
} else {
char imsi[MAX_IMSI_LENGTH + 1];
wait(1); // need to wait to access SIM in some modems
err = _cellularConnectionFSM->get_sim()->get_imsi(imsi);
if (err == NSAPI_ERROR_OK) {
const char *apn_config = apnconfig(imsi);
if (apn_config) {
const char* apn = _APN_GET(apn_config);
const char* uname = _APN_GET(apn_config);
const char* pwd = _APN_GET(apn_config);
tr_info("Looked up APN %s", apn);
err = _cellularConnectionFSM->get_network()->set_credentials(apn, uname, pwd);
}
}
}
}
if (err) {
tr_error("APN lookup failed");
return err;
}
}
#endif // USE_APN_LOOKUP
_target_state = CellularConnectionFSM::STATE_CONNECTED;
err = _cellularConnectionFSM->continue_to_state(_target_state);
if (err == NSAPI_ERROR_OK) {
int ret_wait = _cellularSemaphore.wait(10 * 60 * 1000); // cellular network searching may take several minutes
if (ret_wait != 1) {
tr_info("No cellular connection");
err = NSAPI_ERROR_NO_CONNECTION;
}
}
return err;
}
DeviceKey::DeviceKey()
{
int ret = kv_init_storage_config();
if (ret != MBED_SUCCESS) {
tr_error("DeviceKey: Fail to initialize KvStore configuration.");
}
#if defined(MBEDTLS_PLATFORM_C)
ret = mbedtls_platform_setup(NULL);
if (ret != MBED_SUCCESS) {
tr_error("DeviceKey: Fail in mbedtls_platform_setup.");
}
#endif /* MBEDTLS_PLATFORM_C */
return;
}
static void thread_parse_annoucement(protocol_interface_info_entry_t *cur, mle_message_t *mle_msg)
{
uint64_t timestamp;
uint16_t panid;
uint8_t *ptr;
uint8_t channel_page;
uint16_t channel;
link_configuration_s *linkConfiguration = thread_joiner_application_get_config(cur->id);
tr_info("Recv Dataset Announce");
if (8 > thread_tmfcop_tlv_data_get_uint64(mle_msg->data_ptr, mle_msg->data_length,MLE_TYPE_ACTIVE_TIMESTAMP,×tamp)) {
tr_error("Missing timestamp TLV");
return;
}
if (2 > thread_tmfcop_tlv_data_get_uint16(mle_msg->data_ptr, mle_msg->data_length,MLE_TYPE_PANID,&panid)) {
tr_error("Missing Panid TLV");
return;
}
if (3 > thread_tmfcop_tlv_find(mle_msg->data_ptr, mle_msg->data_length,MLE_TYPE_CHANNEL,&ptr)) {
tr_error("Missing Channel TLV");
return;
}
channel_page = ptr[0];
channel = common_read_16_bit(&ptr[1]);
if (linkConfiguration->timestamp == timestamp) {
// We received same timestamp
tr_debug("Same timestamp");
return;
}
if (cur->thread_info->announcement_info && cur->thread_info->announcement_info->timestamp == timestamp){
// We received same timestamp again
tr_debug("Processing announce with same timestamp");
return;
}
if (linkConfiguration->timestamp > timestamp) {
// We received older time stamp we just announce back to originator channel
thread_bootstrap_announce_send(cur, linkConfiguration->channel_page, linkConfiguration->rfChannel, linkConfiguration->panId, linkConfiguration->timestamp, channel);
return;
}
tr_debug("New configuration received");
thread_bootstrap_temporary_attach(cur,channel_page, channel, panid, timestamp);
}
int thread_network_data_sub_tlv_malformed_check(uint8_t *network_data_ptr, uint8_t network_data_length)
{
uint8_t *dptr;
uint8_t length;
if (!network_data_ptr) {
return -1;
}
dptr = network_data_ptr;
while (network_data_length) {
if (network_data_length >= 2) {
dptr++;
length = *dptr++;
network_data_length -= 2;
if (length) {
if (network_data_length >= length) {
network_data_length -= length;
dptr += length;
} else {
// buffer is overrun this is malformed.
tr_error("Sub Tlv Length fail");
return -1;
}
}
} else {
return -1;
}
}
return 0;
}
bool NanostackSocket::open(void)
{
nanostack_assert_locked();
MBED_ASSERT(SOCKET_MODE_UNOPENED == mode);
int temp_socket = socket_open(proto, 0, socket_callback);
if (temp_socket < 0) {
tr_error("NanostackSocket::open() failed");
return false;
}
if (temp_socket >= NS_INTERFACE_SOCKETS_MAX) {
MBED_ASSERT(false);
return false;
}
if (socket_tbl[temp_socket] != NULL) {
MBED_ASSERT(false);
return false;
}
socket_id = temp_socket;
socket_tbl[socket_id] = this;
mode = SOCKET_MODE_OPENED;
return true;
}
/**
* \fn static int8_t sn_coap_builder_header_build(uint8_t **dst_packet_data_pptr, sn_coap_hdr_s *src_coap_msg_ptr)
*
* \brief Builds Header part of Packet data
*
* \param **dst_packet_data_pptr is destination for built Packet data
*
* \param *src_coap_msg_ptr is source for building Packet data
*
* \return Return value is 0 in ok case and -1 in failure case
**************************************************************************** */
static int8_t sn_coap_builder_header_build(uint8_t **dst_packet_data_pptr, sn_coap_hdr_s *src_coap_msg_ptr)
{
/* * * * Check validity of Header values * * * */
if (sn_coap_header_validity_check(src_coap_msg_ptr, COAP_VERSION) != 0) {
tr_error("sn_coap_builder_header_build - header build failed!");
return -1;
}
/* * * Add CoAP Version * * */
**dst_packet_data_pptr += COAP_VERSION;
/* * * Add Message type * * */
**dst_packet_data_pptr += src_coap_msg_ptr->msg_type;
/* * * Add Token length * * */
**dst_packet_data_pptr += (src_coap_msg_ptr->token_len);
(*dst_packet_data_pptr) ++;
/* * * Add Message code * * */
**dst_packet_data_pptr = src_coap_msg_ptr->msg_code;
(*dst_packet_data_pptr) ++;
/* * * Add Message ID * * */
**dst_packet_data_pptr = (uint8_t)(src_coap_msg_ptr->msg_id >> COAP_HEADER_MSG_ID_MSB_SHIFT); /* MSB part */
(*dst_packet_data_pptr) ++;
**dst_packet_data_pptr = (uint8_t)src_coap_msg_ptr->msg_id; /* LSB part */
(*dst_packet_data_pptr) ++;
/* Success */
return 0;
}
int thread_management_max_child_count(
int8_t interface_id,
uint8_t maxChildCount)
{
#ifdef HAVE_THREAD
protocol_interface_info_entry_t *cur;
cur = protocol_stack_interface_info_get_by_id(interface_id);
if (!cur) {
tr_warn("Invalid interface id");
return -1;
}
if (!cur->thread_info) {
tr_warn("Not Thread specific interface");
return -1;
}
mac_description_storage_size_t buffer;
if (!cur->mac_api || !cur->mac_api->mac_storage_sizes_get || cur->mac_api->mac_storage_sizes_get(cur->mac_api, &buffer) != 0) {
return -1;
}
if (maxChildCount > buffer.device_decription_table_size) {
tr_error("Accept values are between 0-%d for max Child count", buffer.device_decription_table_size);
return -1;
}
cur->thread_info->maxChildCount = maxChildCount;
return 0;
#else
(void) interface_id;
(void) maxChildCount;
return -1;
#endif
}
int16_t sn_coap_builder_2(uint8_t *dst_packet_data_ptr, sn_coap_hdr_s *src_coap_msg_ptr, uint16_t blockwise_payload_size)
{
uint8_t *base_packet_data_ptr = NULL;
/* * * * Check given pointers * * * */
if (dst_packet_data_ptr == NULL || src_coap_msg_ptr == NULL) {
return -2;
}
/* Initialize given Packet data memory area with zero values */
uint16_t dst_byte_count_to_be_built = sn_coap_builder_calc_needed_packet_data_size_2(src_coap_msg_ptr, blockwise_payload_size);
if (!dst_byte_count_to_be_built) {
tr_error("sn_coap_builder_2 - failed to allocate message!");
return -1;
}
memset(dst_packet_data_ptr, 0, dst_byte_count_to_be_built);
/* * * * Store base (= original) destination Packet data pointer for later usage * * * */
base_packet_data_ptr = dst_packet_data_ptr;
/* * * * * * * * * * * * * * * * * * */
/* * * * Header part building * * * */
/* * * * * * * * * * * * * * * * * * */
if (sn_coap_builder_header_build(&dst_packet_data_ptr, src_coap_msg_ptr) != 0) {
/* Header building failed */
tr_error("sn_coap_builder_2 - header building failed!");
return -1;
}
/* If else than Reset message because Reset message must be empty */
if (src_coap_msg_ptr->msg_type != COAP_MSG_TYPE_RESET) {
/* * * * * * * * * * * * * * * * * * */
/* * * * Options part building * * * */
/* * * * * * * * * * * * * * * * * * */
sn_coap_builder_options_build(&dst_packet_data_ptr, src_coap_msg_ptr);
/* * * * * * * * * * * * * * * * * * */
/* * * * Payload part building * * * */
/* * * * * * * * * * * * * * * * * * */
sn_coap_builder_payload_build(&dst_packet_data_ptr, src_coap_msg_ptr);
}
/* * * * Return built Packet data length * * * */
return (dst_packet_data_ptr - base_packet_data_ptr);
}
/**
* \brief Initializes the SLIP MAC backhaul driver.
* This function is called by the border router module.
*/
void backhaul_driver_init(void (*backhaul_driver_status_cb)(uint8_t, int8_t))
{
const char *driver;
#ifndef MBED_CONF_RTOS_PRESENT
driver = STR(YOTTA_CFG_K64F_BORDER_ROUTER_BACKHAUL_DRIVER);
#else
driver = STR(MBED_CONF_APP_BACKHAUL_DRIVER);
#endif
if (strcmp(driver, "SLIP") == 0) {
int8_t slipdrv_id;
#if defined(MBED_CONF_APP_SLIP_HW_FLOW_CONTROL) || defined(YOTTA_CFG_K64F_BORDER_ROUTER_SLIP_HW_FLOW_CONTROL)
pslipmacdriver = new SlipMACDriver(SERIAL_TX, SERIAL_RX, SERIAL_RTS, SERIAL_CTS);
#else
pslipmacdriver = new SlipMACDriver(SERIAL_TX, SERIAL_RX);
#endif
if (pslipmacdriver == NULL) {
tr_error("Unable to create SLIP driver");
return;
}
tr_info("Using SLIP backhaul driver...");
#ifndef MBED_CONF_RTOS_PRESENT
slipdrv_id = pslipmacdriver->Slip_Init(mac, YOTTA_CFG_K64F_BORDER_ROUTER_BACKHAUL_SERIAL_BAUD);
#else
slipdrv_id = pslipmacdriver->Slip_Init(mac, MBED_CONF_APP_SLIP_SERIAL_BAUD_RATE);
#endif
if (slipdrv_id >= 0) {
backhaul_driver_status_cb(1, slipdrv_id);
return;
}
tr_error("Backhaul driver init failed, retval = %d", slipdrv_id);
} else if (strcmp(driver, "ETH") == 0) {
tr_info("Using ETH backhaul driver...");
arm_eth_phy_device_register(mac, backhaul_driver_status_cb);
return;
}
tr_error("Unsupported backhaul driver: %s", driver);
}
M2MConnectionHandlerPimpl::M2MConnectionHandlerPimpl(M2MConnectionHandler* base, M2MConnectionObserver &observer,
M2MConnectionSecurity* sec,
M2MInterface::BindingMode mode,
M2MInterface::NetworkStack stack)
:_base(base),
_observer(observer),
_security_impl(sec),
_security(NULL),
_use_secure_connection(false),
_binding_mode(mode),
_socket(0),
_is_handshaking(false),
_listening(true),
_server_type(M2MConnectionObserver::LWM2MServer),
_server_port(0),
_listen_port(0),
_running(false),
_net_iface(0),
_socket_state(ESocketStateDisconnected)
{
#ifndef PAL_NET_TCP_AND_TLS_SUPPORT
if (is_tcp_connection()) {
tr_error("ConnectionHandler: TCP support not available.");
return;
}
#endif
if(PAL_SUCCESS != pal_init()){
tr_error("PAL init failed.");
}
memset(&_address, 0, sizeof _address);
memset(&_socket_address, 0, sizeof _socket_address);
memset(&_ipV4Addr, 0, sizeof(palIpV4Addr_t));
memset(&_ipV6Addr, 0, sizeof(palIpV6Addr_t));
memset(&_recv_buffer, 0, BUFFER_LENGTH);
connection_handler = this;
eventOS_scheduler_mutex_wait();
if (M2MConnectionHandlerPimpl::_tasklet_id == -1) {
M2MConnectionHandlerPimpl::_tasklet_id = eventOS_event_handler_create(&connection_event_handler, ESocketIdle);
}
eventOS_scheduler_mutex_release();
}
sn_coap_hdr_s *sn_coap_build_response(struct coap_s *handle, sn_coap_hdr_s *coap_packet_ptr, uint8_t msg_code)
{
sn_coap_hdr_s *coap_res_ptr;
if (!coap_packet_ptr || !handle) {
return NULL;
}
coap_res_ptr = sn_coap_parser_alloc_message(handle);
if (!coap_res_ptr) {
tr_error("sn_coap_build_response - failed to allocate message!");
return NULL;
}
if (coap_packet_ptr->msg_type == COAP_MSG_TYPE_CONFIRMABLE) {
coap_res_ptr->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
coap_res_ptr->msg_code = (sn_coap_msg_code_e)msg_code;
coap_res_ptr->msg_id = coap_packet_ptr->msg_id;
}
else if (coap_packet_ptr->msg_type == COAP_MSG_TYPE_NON_CONFIRMABLE) {
coap_res_ptr->msg_type = COAP_MSG_TYPE_NON_CONFIRMABLE;
coap_res_ptr->msg_code = (sn_coap_msg_code_e)msg_code;
/* msg_id needs to be set by the caller in this case */
}
else {
handle->sn_coap_protocol_free( coap_res_ptr );
return NULL;
}
if (coap_packet_ptr->token_ptr) {
coap_res_ptr->token_len = coap_packet_ptr->token_len;
coap_res_ptr->token_ptr = handle->sn_coap_protocol_malloc(coap_res_ptr->token_len);
if (!coap_res_ptr->token_ptr) {
tr_error("sn_coap_build_response - failed to allocate token!");
handle->sn_coap_protocol_free(coap_res_ptr);
return NULL;
}
memcpy(coap_res_ptr->token_ptr, coap_packet_ptr->token_ptr, coap_res_ptr->token_len);
}
return coap_res_ptr;
}
void tr_db_init(void)
{
sql = mysql_init(NULL);
if (sql == NULL) {
tr_error("Error: mysql init");
return;
}
if (NULL == mysql_real_connect(
sql, GLOBAL_CONFIG->db_ip, GLOBAL_CONFIG->db_login,
GLOBAL_CONFIG->db_passwd, NULL, 0, NULL, 0)) {
tr_error("%s", mysql_error(sql));
mysql_close(sql);
sql = NULL;
return;
}
new_rq(sql, "USE %s;", TR_DB_NAME);
atexit(tr_db_exit);
}
/**
* Powers up the modem
*
* Enables the GPIO lines to the modem and then wriggles the power line in short pulses.
*/
bool PPPCellularInterface::power_up()
{
/* Initialize GPIO lines */
modem_init();
/* Give modem a little time to settle down */
wait(0.25);
bool success = false;
int retry_count = 0;
while (true) {
modem_power_up();
/* Modem tends to spit out noise during power up - don't confuse the parser */
_at->flush();
/* It is mandatory to avoid sending data to the serial port during the first 200 ms
* of the module startup. Telit_xE910 Global form factor App note.
* Not necessary for all types of modems however. Let's wait just to be on the safe side */
wait_ms(200);
_at->set_timeout(1000);
if (_at->send("AT") && _at->recv("OK")) {
tr_info("Modem Ready.");
break;
}
if (++retry_count > 10) {
goto failure;
}
}
_at->set_timeout(8000);
/*For more details regarding DCD and DTR circuitry, please refer to Modem AT manual */
success = _at->send("AT"
"E0;" //turn off modem echoing
"+CMEE=2;"//turn on verbose responses
"&K0"//turn off RTC/CTS handshaking
"+IPR=115200;"//setup baud rate
"&C1;"//set DCD circuit(109), changes in accordance with the carrier detect status
"&D0")//set DTR circuit, we ignore the state change of DTR
&& _at->recv("OK");
if (!success) {
goto failure;
}
/* If everything alright, return from here with success*/
return success;
failure:
tr_error("Preliminary modem setup failed.");
return false;
}
void trm_db_insert(const struct tr_map *map)
{
if (sql == NULL) {
tr_error("Couldn't connect to DB. Data won't be stored.");
return;
}
int user_id = tr_db_insert_user(map);
int mod_id = tr_db_insert_mod(map);
int mapset_id = tr_db_insert_mapset(map, user_id);
int diff_id = tr_db_insert_diff(map, mapset_id);
tr_db_insert_update_score(map, diff_id, mod_id);
}
void fhss_synch_state_set_cb(const fhss_api_t *api, fhss_states fhss_state, uint16_t pan_id)
{
fhss_structure_t *fhss_structure = fhss_get_object_with_api(api);
if (!fhss_structure) {
return;
}
// State is already set
if (fhss_structure->fhss_state == fhss_state) {
tr_debug("Synch same state %u", fhss_state);
return;
}
if (fhss_state == FHSS_UNSYNCHRONIZED) {
tr_debug("FHSS down");
fhss_down(fhss_structure);
} else {
// Do not synchronize to current pan
if (fhss_structure->synch_panid == pan_id) {
tr_debug("Synch same panid %u", pan_id);
return;
}
uint32_t datarate = fhss_structure->callbacks.read_datarate(api);
fhss_set_datarate(fhss_structure, datarate);
uint8_t mac_address[8];
fhss_structure->callbacks.read_mac_address(fhss_structure->fhss_api, mac_address);
fhss_structure->uc_channel_index = fhss_get_offset(fhss_structure, mac_address);
// Get Beacon info from storage
fhss_beacon_info_t *beacon_info = fhss_get_beacon_info(fhss_structure, pan_id);
if (beacon_info) {
memcpy(fhss_structure->synch_parent, beacon_info->source_address, 8);
platform_enter_critical();
// Calculate time since the Beacon was received
uint32_t elapsed_time = api->read_timestamp(api) - beacon_info->timestamp;
// Synchronize to given PAN
fhss_beacon_received(fhss_structure, beacon_info->synch_info, elapsed_time);
platform_exit_critical();
// Delete stored Beacon infos
fhss_flush_beacon_info_storage(fhss_structure);
fhss_structure->synch_panid = pan_id;
} else if (fhss_is_synch_root(fhss_structure) == true) {
// Synch root will start new network
fhss_start_timer(fhss_structure, fhss_structure->synch_configuration.fhss_superframe_length, fhss_superframe_handler);
} else {
tr_error("Synch info not find");
}
}
fhss_structure->fhss_state = fhss_state;
}
void nwk_parent_poll_fail_cb(int8_t id)
{
protocol_interface_info_entry_t *cur = protocol_stack_interface_info_get_by_id(id);
if (!cur) {
tr_error("Data Poll Fail Event: No interface");
return;
}
if (thread_info(cur)) {
//Initialize Bootsrap
thread_bootstrap_connection_error(cur->id, CON_ERROR_POLL, NULL);
} else {
nwk_bootsrap_state_update(ARM_NWK_NWK_PARENT_POLL_FAIL, cur);
}
}
int NanostackSocket::accept(NanostackSocket *accepted_socket, ns_address_t *addr)
{
nanostack_assert_locked();
MBED_ASSERT(SOCKET_MODE_LISTENING == mode && SOCKET_MODE_UNOPENED == accepted_socket->mode);
int temp_socket = socket_accept(socket_id, addr, socket_callback);
if (temp_socket < 0) {
tr_error("NanostackSocket::accept() failed");
return temp_socket;
}
if (!accepted_socket->attach(temp_socket)) {
return -1;
}
accepted_socket->mode = SOCKET_MODE_STREAM;
return temp_socket;
}
/*
* Heap error handler, called when heap problem is detected.
* Function is for-ever loop.
*/
static void mesh_system_heap_error_handler(heap_fail_t event)
{
tr_error("Heap error, mesh_system_heap_error_handler() %d", event);
switch (event) {
case NS_DYN_MEM_NULL_FREE:
case NS_DYN_MEM_DOUBLE_FREE:
case NS_DYN_MEM_ALLOCATE_SIZE_NOT_VALID:
case NS_DYN_MEM_POINTER_NOT_VALID:
case NS_DYN_MEM_HEAP_SECTOR_CORRUPTED:
case NS_DYN_MEM_HEAP_SECTOR_UNITIALIZED:
break;
default:
break;
}
while (1);
}
static int new_rq(MYSQL *sql, const char *rq, ...)
{
va_list va;
va_start(va, rq);
char *buf = NULL;
vasprintf(&buf, rq, va);
va_end(va);
if (mysql_query(sql, buf)) {
tr_error("'%s' request: '%s'", mysql_error(sql), buf);
free(buf);
return -1;
}
free(buf);
return 0;
}
void trm_compute_accuracy(struct tr_map *map)
{
if (ht_cst_acc == NULL) {
tr_error("Unable to compute accuracy stars.");
return;
}
/*
Compuatation is in three parts:
- hit window, the time given to hit correctly the object
- spacing, based on spacing frequency
- slow, when object are very slow they are harder to acc'
*/
trm_set_hit_window(map);
trm_set_spacing(map);
trm_set_slow(map);
trm_set_accuracy_star(map);
}
struct vector *cst_vect(GHashTable *ht, const char *key)
{
typedef struct vector *(*cst_vect_f)(GHashTable*, const char*);
static cst_vect_f funs[] = {
cst_vect_from_decl,
cst_vect_from_list,
};
tr_set_print_level(NONE);
struct vector *v = NULL;
for (unsigned int i = 0; i < ARRAY_LENGTH(funs); i++) {
v = funs[i](ht, key);
if (v != NULL)
break;
}
tr_set_print_level(ALL);
if (v == NULL)
tr_error("Failed to find '%s'", key);
return v;
}
void thread_tasklet_trace_bootstrap_info()
{
link_layer_address_s app_link_address_info;
uint8_t temp_ipv6[16];
if (arm_net_address_get(thread_tasklet_data_ptr->nwk_if_id,
ADDR_IPV6_GP, temp_ipv6) == 0) {
tr_debug("GP IPv6: %s", trace_ipv6(temp_ipv6));
}
if (arm_nwk_mac_address_read(thread_tasklet_data_ptr->nwk_if_id,
&app_link_address_info) != 0) {
tr_error("MAC Address read fail\n");
} else {
uint8_t temp[2];
common_write_16_bit(app_link_address_info.mac_short,temp);
tr_debug("MAC 16-bit: %s", trace_array(temp, 2));
common_write_16_bit(app_link_address_info.PANId, temp);
tr_debug("PAN ID: %s", trace_array(temp, 2));
tr_debug("MAC 64-bit: %s", trace_array(app_link_address_info.mac_long, 8));
tr_debug("IID (Based on MAC 64-bit address): %s", trace_array(app_link_address_info.iid_eui64, 8));
}
}
bool NanostackSocket::open(void)
{
nanostack_assert_locked();
MBED_ASSERT(SOCKET_MODE_UNOPENED == mode);
int temp_socket = socket_open(proto, 0, socket_callback);
if (temp_socket < 0) {
tr_error("NanostackSocket::open() failed");
return false;
}
if (proto == SOCKET_TCP) {
/* Receive and send buffers enabled by default */
mode = SOCKET_MODE_OPENED;
} else {
static const int32_t rcvbuf_size = 2048;
socket_setsockopt(temp_socket, SOCKET_SOL_SOCKET, SOCKET_SO_RCVBUF, &rcvbuf_size, sizeof rcvbuf_size);
mode = SOCKET_MODE_DATAGRAM;
}
return attach(temp_socket);
}
void EasyCellularConnection::set_credentials(const char *apn, const char *uname, const char *pwd)
{
if (apn && strlen(apn) > 0) {
_credentials_err = init();
if (_credentials_err) {
return;
}
CellularNetwork *network = _cellularConnectionFSM->get_network();
if (network) {
_credentials_err = network->set_credentials(apn, uname, pwd);
#if USE_APN_LOOKUP
if (_credentials_err == NSAPI_ERROR_OK) {
_credentials_set = true;
}
#endif // #if USE_APN_LOOKUP
} else {
//if get_network() returns NULL it means there was not enough memory for
//an AT_CellularNetwork element during CellularConnectionFSM initialization
tr_error("There was not enough memory during CellularConnectionFSM initialization");
}
}
}
/**
* \brief Error handler for errors in dynamic memory handling.
*/
static void app_heap_error_handler(heap_fail_t event)
{
tr_error("Dyn mem error %x", (int8_t)event);
switch (event) {
case NS_DYN_MEM_NULL_FREE:
break;
case NS_DYN_MEM_DOUBLE_FREE:
break;
case NS_DYN_MEM_ALLOCATE_SIZE_NOT_VALID:
break;
case NS_DYN_MEM_POINTER_NOT_VALID:
break;
case NS_DYN_MEM_HEAP_SECTOR_CORRUPTED:
break;
case NS_DYN_MEM_HEAP_SECTOR_UNITIALIZED:
break;
default:
break;
}
while (1);
}
