/**
* Produces a JSON-encoded msg containing the TID response
*
* @param mem_ctx talloc context for the return value
* @param resp outgoing response
* @return JSON-encoded message containing the TID response
*/
static char *tids_encode_response(TALLOC_CTX *mem_ctx, TID_RESP *resp)
{
TR_MSG mresp;
char *resp_buf = NULL;
/* Construct the response message */
tid_set_tr_msg_resp(&mresp, resp);
/* Encode the message to JSON */
resp_buf = tr_msg_encode(mem_ctx, &mresp);
if (resp_buf == NULL) {
tr_err("tids_encode_response: Error encoding json response.");
return NULL;
}
tr_debug("tids_encode_response: Encoded response: %s", resp_buf);
/* Success */
return resp_buf;
}
DH *tr_create_matching_dh (unsigned char *priv_key,
size_t keylen,
DH *in_dh) {
DH *dh = NULL;
int dh_err = 0;
if (!in_dh)
return NULL;
if (NULL == (dh = DH_new())) {
tr_crit("tr_create_matching_dh: unable to allocate new DH structure.");
return NULL;
}
if ((NULL == (dh->g = BN_dup(in_dh->g))) ||
(NULL == (dh->p = BN_dup(in_dh->p)))) {
DH_free(dh);
tr_debug("tr_create_matching_dh: Invalid dh parameter values, can't be duped.");
return NULL;
}
/* TBD -- share code with previous function */
if ((priv_key) && (keylen > 0))
dh->priv_key = BN_bin2bn(priv_key, keylen, NULL);
DH_generate_key(dh); /* generates the public key */
DH_check(dh, &dh_err);
if (0 != dh_err) {
tr_warning("Warning: dh_check failed with %d", dh_err);
if (dh_err & DH_CHECK_P_NOT_PRIME)
tr_warning(": p value is not prime");
else if (dh_err & DH_CHECK_P_NOT_SAFE_PRIME)
tr_warning(": p value is not a safe prime");
else if (dh_err & DH_UNABLE_TO_CHECK_GENERATOR)
tr_warning(": unable to check the generator value");
else if (dh_err & DH_NOT_SUITABLE_GENERATOR)
tr_warning(": the g value is not a generator");
else
tr_warning("unhandled error %i", dh_err);
}
return(dh);
}
/*
* \brief A function which will be eventually called by NanoStack OS when ever the OS has an event to deliver.
* @param event, describes the sender, receiver and event type.
*
* NOTE: Interrupts requested by HW are possible during this function!
*/
void nd_tasklet_main(arm_event_s *event)
{
arm_library_event_type_e event_type;
event_type = (arm_library_event_type_e) event->event_type;
switch (event_type) {
case ARM_LIB_NWK_INTERFACE_EVENT:
/* This event is delivered every and each time when there is new
* information of network connectivity.
*/
nd_tasklet_parse_network_event(event);
break;
case ARM_LIB_TASKLET_INIT_EVENT:
/* Event with type EV_INIT is an initializer event of NanoStack OS.
* The event is delivered when the NanoStack OS is running fine.
* This event should be delivered ONLY ONCE.
*/
tasklet_data_ptr->node_main_tasklet_id = event->receiver;
mesh_system_send_connect_event(tasklet_data_ptr->tasklet);
break;
case ARM_LIB_SYSTEM_TIMER_EVENT:
eventOS_event_timer_cancel(event->event_id,
tasklet_data_ptr->node_main_tasklet_id);
if (event->event_id == TIMER_EVENT_START_BOOTSTRAP) {
tr_debug("Restart bootstrap");
nd_tasklet_configure_and_connect_to_network();
}
break;
case APPLICATION_EVENT:
if (event->event_id == APPL_EVENT_CONNECT) {
nd_tasklet_configure_and_connect_to_network();
}
break;
default:
break;
} // switch(event_type)
}
TR_IDP_REALM *tr_cfg_find_idp (TR_CFG *tr_cfg, TR_NAME *idp_id, TR_CFG_RC *rc)
{
TR_IDP_REALM *cfg_idp;
if ((!tr_cfg) || (!idp_id)) {
if (rc)
*rc = TR_CFG_BAD_PARAMS;
return NULL;
}
for (cfg_idp = tr_cfg->idp_realms; NULL != cfg_idp; cfg_idp = cfg_idp->next) {
if (!tr_name_cmp (idp_id, cfg_idp->realm_id)) {
tr_debug("tr_cfg_find_idp: Found %s.", idp_id->buf);
return cfg_idp;
}
}
/* if we didn't find one, return NULL */
return NULL;
}
void thread_security_prev_key_generate(protocol_interface_info_entry_t *cur, uint8_t *masterKey, uint32_t keySequence)
{
uint8_t key_material[32];
uint8_t key_index;
uint32_t thrKeySequenceCounter;
if (keySequence == 0) {
// in initial value there is no prev available
return;
}
thrKeySequenceCounter = keySequence - 1;
/* Produced keys from Thread security material: MAC key | MLE key */
thread_key_get(masterKey, key_material, thrKeySequenceCounter);
/* Update keys as primary keys */
key_index = THREAD_KEY_INDEX(thrKeySequenceCounter);
tr_debug("Set previous key Id: %u", key_index);
mac_helper_security_prev_key_set(cur, &key_material[16], key_index, MAC_KEY_ID_MODE_IDX);
mle_service_security_set_security_key(cur->id, key_material, key_index, false);
//copy master secret material to history
thread_history_key_material_push(cur->thread_info, key_material, key_index);
}
void pana_session_init_by_session_ptr(sec_suite_t *suite, auth_info_t *auth_ptr)
{
if (suite) {
suite->setups = 0;
pana_session_state_init(&suite->pana_session);
suite->pana_session.auth_info = auth_ptr;
eap_fragmentation_init(suite);
if (suite->pana_session.session_ready) {
tr_debug("Ping Notify");
suite->state = PANA_PING_REQ;
suite->timer = 1;
suite->retry_counter = 0;
} else {
if (sec_pana_protocol_init(suite) == 0) {
sec_lib_state_machine_trig(suite, PANA_ERROR);
}
}
}
}
void tr_audit_req(TID_REQ *req) {
if (NULL != req) {
char *attrs[] = { audit_fmt("comm", NULL != req->comm ? req->comm->buf : NULL),
audit_fmt("rp_realm", NULL != req->rp_realm ? req->rp_realm->buf : NULL),
audit_fmt("realm", NULL != req->realm ? req->realm->buf : NULL),
};
char *msg = join_audit_msg(sizeof(attrs) / sizeof(attrs[0]), attrs);
free_array(sizeof(attrs) / sizeof(attrs[0]), attrs);
fire_log(LOG_INFO, AUDIT_FACILITY, "%s%s%s", LOG_PREFIX, msg, LOG_MSG_TERMINATOR);
free(msg);
}
else {
tr_debug("tr_audit_req: Message dropped, null pointer passed.");
}
}
/**
* Parse a signed integer
*
* If the key does not exist in the src object, returns success but does fill in *dest.
*
* @param src JSON object to pull a value from
* @param key key to pull
* @param dest (output) pointer to an allocated integer
* @return TR_CFG_SUCCESS or an error code
*/
static TR_CFG_RC tr_cfg_parse_integer(json_t *src, const char *key, int *dest)
{
json_t *jtmp;
/* Validate parameters */
if ((src == NULL) || (key == NULL) || (dest == NULL))
return TR_CFG_BAD_PARAMS;
/* See if we have a value for this key; do nothing if not */
jtmp = json_object_get(src, key);
if (jtmp) {
if (json_is_number(jtmp)) {
*dest = (int) json_integer_value(jtmp);
} else {
tr_debug("tr_cfg_parse_unsigned: Parsing error, %s is not a number.", key);
return TR_CFG_NOPARSE;
}
}
return TR_CFG_SUCCESS;
}
nsapi_error_t NanostackInterface::socket_bind(void *handle, const SocketAddress &address)
{
// Validate parameters
NanostackSocket *socket = static_cast<NanostackSocket *>(handle);
if (handle == NULL) {
MBED_ASSERT(false);
return NSAPI_ERROR_NO_SOCKET;
}
const void *addr_field;
switch (address.get_ip_version()) {
case NSAPI_IPv6:
addr_field = address.get_ip_bytes();
break;
case NSAPI_UNSPEC:
addr_field = &ns_in6addr_any;
break;
default:
return NSAPI_ERROR_UNSUPPORTED;
}
NanostackLockGuard lock;
ns_address_t ns_address;
ns_address.type = ADDRESS_IPV6;
memcpy(ns_address.address, addr_field, sizeof ns_address.address);
ns_address.identifier = address.get_port();
nsapi_error_t ret;
int retcode = ::socket_bind(socket->socket_id, &ns_address);
if (retcode == 0) {
ret = NSAPI_ERROR_OK;
} else {
ret = NSAPI_ERROR_PARAMETER;
}
tr_debug("socket_bind(socket=%p) sock_id=%d, retcode=%i, ret=%i", socket, socket->socket_id, retcode, ret);
return ret;
}
bool M2MResource::remove_resource_instance(uint16_t inst_id)
{
tr_debug("M2MResource::remove_resource(inst_id %d)", inst_id);
bool success = false;
if(!_resource_instance_list.empty()) {
M2MResourceInstance* res = NULL;
M2MResourceInstanceList::const_iterator it;
it = _resource_instance_list.begin();
int pos = 0;
for ( ; it != _resource_instance_list.end(); it++, pos++ ) {
if(((*it)->instance_id() == inst_id)) {
// Resource found and deleted.
res = *it;
delete res;
_resource_instance_list.erase(pos);
success = true;
break;
}
}
}
return success;
}
TR_RP_CLIENT *tr_cfg_find_rp (TR_CFG *tr_cfg, TR_NAME *rp_gss, TR_CFG_RC *rc)
{
TR_RP_CLIENT *cfg_rp;
int i;
if ((!tr_cfg) || (!rp_gss)) {
if (rc)
*rc = TR_CFG_BAD_PARAMS;
return NULL;
}
for (cfg_rp = tr_cfg->rp_clients; NULL != cfg_rp; cfg_rp = cfg_rp->next) {
for (i = 0; i < TR_MAX_GSS_NAMES; i++) {
if (!tr_name_cmp (rp_gss, cfg_rp->gss_names[i])) {
tr_debug("tr_cfg_find_rp: Found %s.", rp_gss->buf);
return cfg_rp;
}
}
}
/* if we didn't find one, return NULL */
return NULL;
}
int thread_management_partition_weighting_set(int8_t interface_id, uint8_t partition_weighting)
{
#ifdef HAVE_THREAD
protocol_interface_info_entry_t *cur;
cur = protocol_stack_interface_info_get_by_id(interface_id);
if (!cur || !cur->thread_info) {
tr_debug("Invalid interface id");
return -1;
}
if (cur->thread_info->partition_weighting == partition_weighting) {
return 0;
}
bool trig_network_scan = false;
if (cur->thread_info->thread_leader_data) {
if (cur->thread_info->thread_leader_data->weighting < partition_weighting) {
trig_network_scan = true;
}
}
cur->thread_info->partition_weighting = partition_weighting;
if (cur->lowpan_info & INTERFACE_NWK_ACTIVE) {
if (trig_network_scan && thread_extension_enabled(cur)) {
thread_nvm_store_link_info_clear();
// bootstrap active and weighting has changed
thread_bootstrap_reset_restart(interface_id);
}
}
return 0;
#else
(void) interface_id;
(void) partition_weighting;
return -1;
#endif
}
static void thread_discover_device_descriptor_set(struct mac_api_s *api, const uint8_t *device_extended_address, uint8_t attribute_index)
{
if (!api) {
return;
}
mlme_device_descriptor_t device_desc;
mlme_set_t set_req;
device_desc.FrameCounter = 0;
device_desc.Exempt = false;
device_desc.ShortAddress = 0xffff;
memcpy(device_desc.ExtAddress, device_extended_address, 8);
device_desc.PANId = 0xffff;
set_req.attr = macDeviceTable;
set_req.attr_index = attribute_index;
set_req.value_pointer = (void *)&device_desc;
set_req.value_size = sizeof(mlme_device_descriptor_t);
tr_debug("Register Discovery device descriptor");
api->mlme_req(api, MLME_SET, &set_req);
}
int str2sev(const char* sev) {
if (strcmp(sev, "debug") ==0 ) {
return LOG_DEBUG;
}
else if (strcmp(sev, "info") == 0) {
return LOG_INFO;
}
else if (strcmp(sev, "notice") == 0) {
return LOG_NOTICE;
}
else if (strcmp(sev, "warning") == 0 ) {
return LOG_WARNING;
}
else if (strcmp(sev, "err") == 0) {
return LOG_ERR;
}
else if (strcmp(sev, "crit") == 0) {
return LOG_CRIT;
}
else if (strcmp(sev, "alert") == 0) {
return LOG_ALERT;
}
else if (strcmp(sev, "emerg") == 0) {
return LOG_EMERG;
}
tr_debug("str2sev: invalid severity specified: %s, logging everything", sev);
return LOG_DEBUG;
}
int tidc_open_connection (TIDC_INSTANCE *tidc,
const char *server,
unsigned int port,
gss_ctx_id_t *gssctx)
{
int err = 0;
int conn = -1;
unsigned int use_port = 0;
if (0 == port)
use_port = TID_PORT;
else
use_port = port;
tr_debug("tidc_open_connection: opening tidc connection to %s:%d", server, port);
err = gsscon_connect(server, use_port, "trustidentity", &conn, gssctx);
if (!err)
return conn;
else
return -1;
}
void tr_audit_resp(TID_RESP *resp) {
if (NULL != resp) {
char *attrs[] = { audit_fmt("result", resp->result ? "error" : "success"),
audit_fmt("comm", NULL != resp->comm ? resp->comm->buf : NULL),
audit_fmt("rp_realm", NULL != resp->rp_realm ? resp->rp_realm->buf : NULL),
audit_fmt("realm", NULL != resp->realm ? resp->realm->buf : NULL),
audit_fmt("err", NULL != resp->err_msg ? resp->err_msg->buf : NULL)
};
char *msg = join_audit_msg(sizeof(attrs) / sizeof(attrs[0]), attrs);
free_array(sizeof(attrs) / sizeof(attrs[0]), attrs);
fire_log(LOG_INFO, AUDIT_FACILITY, "%s%s%s", LOG_PREFIX, msg, LOG_MSG_TERMINATOR);
free(msg);
}
else {
tr_debug("tr_audit_resp: Message dropped, null pointer passed.");
}
}
static void mac_helper_keytable_pairwise_descriptor_set(struct mac_api_s *api, const uint8_t *key, const uint8_t *mac64, uint8_t attribute_id) {
mlme_set_t set_req;
mlme_key_id_lookup_descriptor_t lookup_description;
mlme_key_descriptor_entry_t key_description;
if (key) {
memcpy(lookup_description.LookupData, mac64, 8);
lookup_description.LookupData[8] = 0;
lookup_description.LookupDataSize = 1;
tr_debug("Key add %u index %s", attribute_id,trace_array(lookup_description.LookupData, 9));
memset(&key_description, 0, sizeof(mlme_key_descriptor_entry_t));
memcpy(key_description.Key, key, 16);
key_description.KeyIdLookupList = &lookup_description;
key_description.KeyIdLookupListEntries = 1;
} else {
memset(&key_description, 0, sizeof(mlme_key_descriptor_entry_t));
}
set_req.attr = macKeyTable;
set_req.attr_index = attribute_id;
set_req.value_pointer = &key_description;
set_req.value_size = sizeof(mlme_key_descriptor_entry_t);
api->mlme_req(api,MLME_SET , &set_req);
}
static TR_CFG_RC tr_cfg_parse_monitoring(TR_CFG *trc, json_t *jmon)
{
int enabled = 1; /* assume we are enabled unless we are told not to be */
const char *allowed_keys[] = {"enabled", "port", "authorized_credentials", 0};
if (!check_allowed_keys(jmon, allowed_keys, NULL))
return TR_CFG_NOPARSE;
NOPARSE_UNLESS(tr_cfg_parse_boolean(jmon, "enabled", &enabled));
if (enabled) {
NOPARSE_UNLESS(tr_cfg_parse_integer(jmon, "port", &(trc->internal->mons_port)));
if (trc->internal->mons_port == 0) {
/* Catch this as a special case because 0 means that monitoring is disabled. */
tr_debug("tr_cfg_parse_monitoring: invalid monitoring port (0). Use \"enabled\":false to disable monitoring.");
return TR_CFG_BAD_PARAMS;
}
NOPARSE_UNLESS(tr_cfg_parse_gss_names(trc->internal,
json_object_get(jmon, "authorized_credentials"),
&(trc->internal->monitoring_credentials)));
}
return TR_CFG_SUCCESS;
}
/**
* Parse a string
*
* If the key does not exist in the src object, returns success but does not allocate
* a return value in dest. Nulls the destination pointer if there is no return value.
*
* Return value is allocated in talloc's NULL context and must be freed with talloc_free()
* or put into a non-NULL context with talloc_steal()
*
* @param src JSON object to pull a value from
* @param key key to pull
* @param dest (output) pointer to a pointer that will hold the newly allocated return value
* @return TR_CFG_SUCCESS or an error code
*/
static TR_CFG_RC tr_cfg_parse_string(json_t *src, const char *key, const char **dest)
{
json_t *jtmp;
/* Validate parameters */
if ((src == NULL) || (key == NULL) || (dest == NULL))
return TR_CFG_BAD_PARAMS;
/* See if we have a value for this key; do nothing if not */
jtmp = json_object_get(src, key);
if (!jtmp) {
*dest = NULL; /* No return value, null this out */
} else {
if (json_is_string(jtmp)) {
*dest = talloc_strdup(NULL, json_string_value(jtmp));
} else {
tr_debug("tr_cfg_parse_string: Parsing error, %s is not a string.", key);
return TR_CFG_NOPARSE;
}
}
return TR_CFG_SUCCESS;
}
int thread_network_data_malformed_check(uint8_t *network_data_ptr, uint16_t network_data_length)
{
uint8_t *dptr;
uint8_t length;
uint8_t type;
dptr = network_data_ptr;
while (network_data_length) {
if (network_data_length >= 2) {
type = *dptr++;
length = *dptr++;
if (length == 0) {
// 0 is not valid length for TLV
return -1;
}
network_data_length -= 2;
if (network_data_length >= length) {
if (type == THREAD_NWK_DATA_TYPE_PREFIX) {
//Do subTLV Malformed test
if (thread_network_data_prefix_sub_tlv_malformed_check(dptr, length) != 0) {
tr_debug("prefixSubMal");
return -1;
}
}
network_data_length -= length;
dptr += length;
} else {
// buffer is overrun this is malformed.
tr_error("Lenf fail");
return -1;
}
} else {
return -1;
}
}
return 0;
}
int NanostackInterface::socket_recvfrom(void *handle, SocketAddress *address, void *buffer, unsigned size)
{
// Validate parameters
NanostackSocket * socket = static_cast<NanostackSocket *>(handle);
if (NULL == handle) {
MBED_ASSERT(false);
return NSAPI_ERROR_NO_SOCKET;
}
if (NULL == buffer) {
MBED_ASSERT(false);
return NSAPI_ERROR_PARAMETER;
}
if (0 == size) {
MBED_ASSERT(false);
return NSAPI_ERROR_PARAMETER;
}
nanostack_lock();
int ret;
if (socket->closed()) {
ret = NSAPI_ERROR_NO_CONNECTION;
} else if (NANOSTACK_SOCKET_TCP == socket->proto) {
tr_error("recv_from() not supported with SOCKET_STREAM!");
ret = NSAPI_ERROR_UNSUPPORTED;
} else if (!socket->data_available()) {
ret = NSAPI_ERROR_WOULD_BLOCK;
} else {
ret = socket->data_copy_and_free(buffer, size, address, false);
}
nanostack_unlock();
tr_debug("socket_recvfrom(socket=%p) sock_id=%d, ret=%i", socket, socket->socket_id, ret);
return ret;
}
M2MReportHandler::M2MReportHandler(M2MReportObserver &observer)
: _observer(observer),
_under_observation(false),
_pmax(-1.0f),
_pmin(1.0f),
_gt(0.0f),
_lt(0.0f),
_st(0.0f),
_pmin_exceeded(false),
_pmax_exceeded(false),
_report_scheduled(false),
_pmin_timer(NULL),
_pmax_timer(NULL),
_high_step(0.0f),
_low_step(0.0f),
_current_value(0.0f),
_last_value(0.0f),
_attribute_state(0),
_notify(false)
{
tr_debug("M2MReportHandler::M2MReportHandler()");
_pmax_timer = new M2MTimer(*this);
_pmin_timer = new M2MTimer(*this);
}
/* TRP update msg */
static json_t *tr_msg_encode_trp_upd(TRP_UPD *update)
{
json_t *jupdate=NULL;
json_t *jrecords=NULL;
json_t *jrec=NULL;
TRP_INFOREC *rec;
if (update==NULL)
return NULL;
jupdate=json_object();
if (jupdate==NULL)
return NULL;
jrecords=json_array();
if (jrecords==NULL) {
json_decref(jupdate);
return NULL;
}
json_object_set_new(jupdate, "records", jrecords); /* jrecords now a "borrowed" reference */
for (rec=trp_upd_get_inforec(update); rec!=NULL; rec=trp_inforec_get_next(rec)) {
tr_debug("tr_msg_encode_trp_upd: encoding inforec.");
jrec=tr_msg_encode_inforec(rec);
if (jrec==NULL) {
json_decref(jupdate); /* also decs jrecords and any elements */
return NULL;
}
if (0!=json_array_append_new(jrecords, jrec)) {
json_decref(jupdate); /* also decs jrecords and any elements */
json_decref(jrec); /* this one did not get added so dec explicitly */
return NULL;
}
}
return jupdate;
}
bool PPPCellularInterface::nwk_registration(uint8_t nwk_type)
{
bool success = false;
bool registered = false;
char str[35];
int retcode;
int retry_counter = 0;
unsigned int reg_status;
success = nwk_type == PACKET_SWITCHED ?
_at->send("AT+CGREG=0") :
_at->send("AT+CREG=0") && _at->recv("OK\n");
success = _at->send("AT+COPS=0") //initiate auto-registration
&& _at->recv("OK");
if (!success) {
tr_error("Modem not responding.");
return false;
}
//Network search
//If not registered after 60 attempts, i.e., 30 seconds wait, give up
tr_debug("Searching Network ...");
while (!registered) {
if (retry_counter > 60) {
success = false;
goto give_up;
}
success = nwk_type == PACKET_SWITCHED ?
_at->send("AT+CGREG?")
&& _at->recv("+CGREG: %34[^\n]\n", str)
&& _at->recv("OK\n") :
_at->send("AT+CREG?")
&& _at->recv("+CREG: %34[^\n]\n", str)
&& _at->recv("OK\n");
retcode = sscanf(str, "%*u,%u", ®_status);
if (retcode >= 1) {
if (nwk_type == PACKET_SWITCHED) {
set_nwk_reg_status_psd(reg_status);
if (is_registered_psd()) {
registered = true;
}
} else if (nwk_type == CIRCUIT_SWITCHED) {
set_nwk_reg_status_csd(reg_status);
if (is_registered_csd()) {
registered = true;
}
}
}
if (registered) {
break;
} else {
wait_ms(500);
}
retry_counter++;
}
give_up:
return registered;
}
nsapi_size_or_error_t NanostackInterface::do_sendto(void *handle, const ns_address_t *address, const void *data, nsapi_size_t size)
{
// Validate parameters
NanostackSocket * socket = static_cast<NanostackSocket *>(handle);
if (handle == NULL) {
MBED_ASSERT(false);
return NSAPI_ERROR_NO_SOCKET;
}
nsapi_size_or_error_t ret;
NanostackLockGuard lock;
if (socket->closed() || (!address && !socket->is_connected())) {
ret = NSAPI_ERROR_NO_CONNECTION;
goto out;
}
if (address && socket->proto == SOCKET_TCP) {
tr_error("socket_sendto() not supported with TCP!");
ret = NSAPI_ERROR_IS_CONNECTED;
goto out;
}
int retcode;
#if 0
retcode = ::socket_sendto(socket->socket_id, address,
data, size);
#else
// Use sendmsg purely to get the new return style
// of returning data written rather than 0 on success,
// which means TCP can do partial writes. (Sadly,
// it's the only call which takes flags so we can
// leave the NS_MSG_LEGACY0 flag clear).
ns_msghdr_t msg;
ns_iovec_t iov;
iov.iov_base = const_cast<void *>(data);
iov.iov_len = size;
msg.msg_name = const_cast<ns_address_t *>(address);
msg.msg_namelen = address ? sizeof *address : 0;
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_control = NULL;
msg.msg_controllen = 0;
retcode = ::socket_sendmsg(socket->socket_id, &msg, 0);
#endif
/*
* \return length if entire amount written (which could be 0)
* \return value >0 and <length if partial amount written (stream only)
* \return NS_EWOULDBLOCK if nothing written due to lack of queue space.
* \return -1 Invalid socket ID or message structure.
* \return -2 Socket memory allocation fail.
* \return -3 TCP state not established or address scope not defined .
* \return -4 Socket TX process busy or unknown interface.
* \return -5 Socket not connected
* \return -6 Packet too short (ICMP raw socket error).
* */
if (retcode == NS_EWOULDBLOCK) {
ret = NSAPI_ERROR_WOULD_BLOCK;
} else if (retcode < 0) {
tr_error("socket_sendmsg: error=%d", retcode);
ret = NSAPI_ERROR_DEVICE_ERROR;
} else {
ret = retcode;
}
out:
tr_debug("socket_sendto(socket=%p) sock_id=%d, ret=%i", socket, socket->socket_id, ret);
return ret;
}
void NanostackSocket::socket_callback(void *cb) {
nanostack_assert_locked();
socket_callback_t *sock_cb = (socket_callback_t *) cb;
NanostackSocket *socket = socket_tbl[sock_cb->socket_id];
MBED_ASSERT(socket != NULL);
tr_debug("socket_callback() sock=%d, event=%d, interface=%d, data len=%d",
sock_cb->socket_id, sock_cb->event_type, sock_cb->interface_id, sock_cb->d_len);
switch (sock_cb->event_type) {
case SOCKET_DATA:
tr_debug("SOCKET_DATA, sock=%d, bytes=%d", sock_cb->socket_id, sock_cb->d_len);
socket->event_data(sock_cb);
break;
case SOCKET_CONNECT_DONE:
tr_debug("SOCKET_CONNECT_DONE");
socket->event_connect_done(sock_cb);
break;
case SOCKET_CONNECT_FAIL:
tr_debug("SOCKET_CONNECT_FAIL");
socket->event_connect_fail(sock_cb);
break;
case SOCKET_CONNECT_AUTH_FAIL:
tr_debug("SOCKET_CONNECT_AUTH_FAIL");
break;
case SOCKET_INCOMING_CONNECTION:
tr_debug("SOCKET_INCOMING_CONNECTION");
socket->event_incoming_connection(sock_cb);
break;
case SOCKET_TX_FAIL:
tr_debug("SOCKET_TX_FAIL");
socket->event_tx_fail(sock_cb);
break;
case SOCKET_CONNECT_CLOSED:
tr_debug("SOCKET_CONNECT_CLOSED");
socket->event_connect_closed(sock_cb);
break;
case SOCKET_CONNECTION_RESET:
tr_debug("SOCKET_CONNECTION_RESET");
socket->event_connection_reset(sock_cb);
break;
case SOCKET_NO_ROUTE:
tr_debug("SOCKET_NO_ROUTE");
socket->event_tx_fail(sock_cb);
break;
case SOCKET_TX_DONE:
socket->event_tx_done(sock_cb);
break;
case SOCKET_NO_RAM:
tr_debug("SOCKET_NO_RAM");
socket->event_tx_fail(sock_cb);
break;
case SOCKET_CONNECTION_PROBLEM:
tr_debug("SOCKET_CONNECTION_PROBLEM");
break;
default:
break;
}
}
void pana_session_startms_parse(buffer_t *buf, pana_header_t *header, sec_suite_t *suite)
{
uint32_t prf_algorythm = 0;
uint32_t integrity_algorythm = 12;
uint32_t key_wrap = 0;
bool key_wrap_parsed = false;
uint16_t len = buffer_data_length(buf);
uint8_t *ptr = buffer_data_pointer(buf);
pana_avp_t avp_temp;
//Read Resul and Key id if they are coming
avp_temp.code = AVP_PRF_ALGORYTHM_CODE;
avp_temp.len = 0;
if (pana_avp_discover(ptr, len, &avp_temp) && avp_temp.len == 4) {
prf_algorythm = common_read_32_bit(avp_temp.avp_ptr);
}
avp_temp.code = AVP_INTEGRIRTY_ALGORYTHM_CODE;
avp_temp.len = 0;
if (pana_avp_discover(ptr, len, &avp_temp) && avp_temp.len == 4) {
integrity_algorythm = common_read_32_bit(avp_temp.avp_ptr);
}
avp_temp.code = AVP_KEY_WRAP_ALG_CODE;
avp_temp.len = 0;
if (pana_avp_discover(ptr, len, &avp_temp) && avp_temp.len == 4) {
key_wrap = common_read_32_bit(avp_temp.avp_ptr);
key_wrap_parsed = true;
}
bool drop_message = false;
if ((header->flags & PANA_FLAGS_REQUEST) == PANA_FLAGS_RESPONSE) {
if (prf_algorythm != suite->pana_session.prf_algorythm) {
tr_debug("PRF!!");
drop_message = true;
} else if (integrity_algorythm != suite->pana_session.integrity_algorythm) {
tr_debug("int!!");
drop_message = true;
}
if (key_wrap_parsed && key_wrap != suite->pana_session.key_wrap) {
tr_debug("key!!");
drop_message = true;
}
} else {
if (prf_algorythm != 5) {
drop_message = true;
} else if (integrity_algorythm != 12) {
drop_message = true;
}
}
if (!drop_message) {
if (key_wrap_parsed) {
suite->pana_session.key_warp = true;
suite->pana_session.key_wrap = key_wrap;
}
len += 16;
ptr -= 16; //Shift Pana Headers back
if ((header->flags & PANA_FLAGS_REQUEST) == PANA_FLAGS_RESPONSE) {
sec_lib_state_machine_trig(suite, EAP_IDENTITY_REQ);
pana_handshake_copy(ptr, len, false, suite);
} else {
suite->pana_session.integrity_algorythm = integrity_algorythm;
suite->pana_session.prf_algorythm = prf_algorythm;
sec_lib_state_machine_trig(suite, PANA_START_RESPONSE);
pana_handshake_copy(ptr, len, true, suite);
}
suite->retry_counter = 0;
}
buffer_free(buf);
}
void pana_down(buffer_t *buf, sec_suite_t *suite)
{
//Check Request Or Response
pana_header_t header;
header.type = PANA_MSG_PA;
if (suite->pana_session.user_server) {
if (suite->state == PANA_REQUEST_TX) {
header.flags = PANA_FLAGS_START | PANA_FLAGS_REQUEST;
} else if (suite->state == EAP_PANA_FINISH || suite->state == PANA_FAILURE) {
header.flags = (PANA_FLAGS_REQUEST | PANA_FLAGS_COMPLETE);
} else if (suite->state == PANA_FAILURE_RESPONSE) {
header.flags = (PANA_FLAGS_RESPONSE | PANA_FLAGS_COMPLETE);
} else {
header.flags = PANA_FLAGS_REQUEST;
}
} else {
if (suite->state == PANA_FAILURE) {
header.flags = PANA_FLAGS_COMPLETE;
} else if (suite->state == PANA_START_RESPONSE) {
header.flags = PANA_FLAGS_START;
} else {
header.flags = 0;
}
}
if (header.flags & PANA_FLAGS_REQUEST) {
header.seq = suite->pana_session.req_seq;
} else {
header.seq = suite->pana_session.res_seq;
}
header.session_id = suite->pana_session.session_id;
pana_set_agend_address(buf, false, suite);
buf = build_pana_base(buf, &header, suite);
if (buf) {
/**
* Copy Authentication start message
*/
if (header.flags & PANA_FLAGS_START) {
uint16_t len = buffer_data_length(buf);
uint8_t *ptr = buffer_data_pointer(buf);
if (header.flags & PANA_FLAGS_REQUEST) {
pana_handshake_copy(ptr, len, true, suite);
} else {
pana_handshake_copy(ptr, len, false, suite);
}
}
if (suite->pana_session.address_status & 1) {
tr_debug("Build Relay");
buf = pana_relay_avp_build(buf, suite);
if (buf) {
header.flags = 0;
header.type = PANA_MSG_RELAY;
header.session_id = 0;
header.seq = 0;
buf = build_pana_base(buf, &header, suite);
}
}
protocol_push(buf);
}
}
/*
* \brief Configure and establish network connection
*
*/
void nd_tasklet_configure_and_connect_to_network(void)
{
int8_t status;
char *sec_mode;
// configure bootstrap
arm_nwk_interface_configure_6lowpan_bootstrap_set(
tasklet_data_ptr->network_interface_id, tasklet_data_ptr->mode,
NET_6LOWPAN_ND_WITH_MLE);
sec_mode = STR(MBED_CONF_MBED_MESH_API_6LOWPAN_ND_SECURITY_MODE);
if (strcmp(sec_mode, "PSK") == 0) {
tr_debug("Using PSK security mode.");
tasklet_data_ptr->sec_mode = NET_SEC_MODE_PSK_LINK_SECURITY;
tasklet_data_ptr->psk_sec_info.key_id = MBED_CONF_MBED_MESH_API_6LOWPAN_ND_PSK_KEY_ID;
memcpy(tasklet_data_ptr->psk_sec_info.security_key, (const uint8_t[16])MBED_CONF_MBED_MESH_API_6LOWPAN_ND_PSK_KEY, 16);
} else {
tr_debug("Link-layer security NOT enabled.");
tasklet_data_ptr->sec_mode = NET_SEC_MODE_NO_LINK_SECURITY;
}
// configure link layer security
arm_nwk_link_layer_security_mode(
tasklet_data_ptr->network_interface_id,
tasklet_data_ptr->sec_mode,
MBED_CONF_MBED_MESH_API_6LOWPAN_ND_SEC_LEVEL,
&tasklet_data_ptr->psk_sec_info);
// configure scan parameters
arm_nwk_6lowpan_link_scan_parameter_set(tasklet_data_ptr->network_interface_id, 5);
// configure scan channels
initialize_channel_list();
// Configure scan options (NULL disables filter)
arm_nwk_6lowpan_link_nwk_id_filter_for_nwk_scan(
tasklet_data_ptr->network_interface_id, NULL);
arm_nwk_6lowpan_link_panid_filter_for_nwk_scan(
tasklet_data_ptr->network_interface_id,
MBED_CONF_MBED_MESH_API_6LOWPAN_ND_PANID_FILTER);
// Enable MPL by default
const uint8_t all_mpl_forwarders[16] = {0xff, 0x03, [15]=0xfc};
multicast_mpl_domain_subscribe(tasklet_data_ptr->network_interface_id,
all_mpl_forwarders,
MULTICAST_MPL_SEED_ID_DEFAULT,
NULL);
status = arm_nwk_interface_up(tasklet_data_ptr->network_interface_id);
if (status >= 0) {
tasklet_data_ptr->tasklet_state = TASKLET_STATE_BOOTSTRAP_STARTED;
tr_info("Start 6LoWPAN ND Bootstrap");
nd_tasklet_network_state_changed(MESH_BOOTSTRAP_STARTED);
} else {
tasklet_data_ptr->tasklet_state = TASKLET_STATE_BOOTSTRAP_FAILED;
tr_err("Bootstrap start failed, %d", status);
nd_tasklet_network_state_changed(MESH_BOOTSTRAP_START_FAILED);
}
}
static void tr_talloc_log(const char *msg)
{
tr_debug("talloc: %s", msg);
}
