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); }