/*
* ======== tsk2Fxn ========
*/
Void tsk2Fxn(UArg arg0, UArg arg1)
{
Log_info2("tsk2 Entering. arg0,1 = %d %d",
(Int)arg0, (Int)arg1);
Log_info0("tsk2 Calling Task_yield");
Task_yield();
Log_info0("tsk2 Exiting");
}
/*
* ======== tsk1Fxn ========
*/
Void tsk1Fxn(UArg arg0, UArg arg1)
{
Log_info2("tsk1 Entering. arg0,1 = %d %d",
(Int)arg0, (Int)arg1);
Log_error2("tsk1 demonstrating error event. arg0,1 = %d %d",
(Int)arg0, (Int)arg1);
Log_info0("tsk1 Calling Semaphore_pend");
Semaphore_pend(sem0, BIOS_WAIT_FOREVER);
Log_info0("tsk1 Exiting");
}
/*
* ======== tsk0Fxn ========
*/
Void tsk0Fxn(UArg arg0, UArg arg1)
{
Log_info2("tsk0 Entering. arg0,1 = %d %d",
(Int)arg0, (Int)arg1);
Log_warning2("tsk0 demonstrating warning event. arg0,1 = %d %d",
(Int)arg0, (Int)arg1);
Log_info0("tsk0 Calling Task_yield");
Task_yield();
Log_info0("tsk0 Exiting");
}
/*
* DataService_GetParameter - Get a DataService parameter.
*
* param - Profile parameter ID
* len - pointer to a variable that contains the maximum length that can be written to *value.
After the call, this value will contain the actual returned length.
* value - pointer to data to write. This is dependent on
* the parameter ID and may be cast to the appropriate
* data type (example: data type of uint16_t will be cast to
* uint16_t pointer).
*/
bStatus_t DataService_GetParameter( uint8_t param, uint16_t *len, void *value )
{
bStatus_t ret = SUCCESS;
switch ( param )
{
case DS_STRING_ID:
*len = MIN(*len, ds_StringValLen);
memcpy(value, ds_StringVal, *len);
Log_info2("GetParameter : %s returning %d bytes", (IArg)"String", (IArg)*len);
break;
case DS_STREAM_ID:
*len = MIN(*len, ds_StreamValLen);
memcpy(value, ds_StreamVal, *len);
Log_info2("GetParameter : %s returning %d bytes", (IArg)"Stream", (IArg)*len);
break;
default:
Log_error1("GetParameter: Parameter #%d not valid.", (IArg)param);
ret = INVALIDPARAMETER;
break;
}
return ret;
}
/**
* This is called as sendMessage() by the switch.
* There is only one switch interface which sends all traffic.
* message is aligned on the beginning of the switch header.
*/
static uint8_t incomingFromSwitch(struct Message* message, struct Interface* switchIf)
{
struct Ducttape* context = switchIf->senderContext;
struct Headers_SwitchHeader* switchHeader = (struct Headers_SwitchHeader*) message->bytes;
Message_shift(message, -Headers_SwitchHeader_SIZE);
// The label comes in reversed from the switch because the switch doesn't know that we aren't
// another switch ready to parse more bits, bit reversing the label yields the source address.
switchHeader->label_be = Bits_bitReverse64(switchHeader->label_be);
if (Headers_getMessageType(switchHeader) == Headers_SwitchHeader_TYPE_CONTROL) {
uint8_t labelStr[20];
uint64_t label = Endian_bigEndianToHost64(switchHeader->label_be);
AddrTools_printPath(labelStr, label);
if (message->length < Control_HEADER_SIZE) {
Log_info1(context->logger, "dropped runt ctrl packet from [%s]", labelStr);
return Error_NONE;
} else {
Log_debug1(context->logger, "ctrl packet from [%s]", labelStr);
}
struct Control* ctrl = (struct Control*) message->bytes;
bool pong = false;
if (ctrl->type_be == Control_ERROR_be) {
if (message->length < Control_Error_MIN_SIZE) {
Log_info1(context->logger, "dropped runt error packet from [%s]", labelStr);
return Error_NONE;
}
Log_info2(context->logger,
"error packet from [%s], error type [%d]",
labelStr,
Endian_bigEndianToHost32(ctrl->content.error.errorType_be));
RouterModule_brokenPath(Endian_bigEndianToHost64(switchHeader->label_be),
context->routerModule);
uint8_t causeType = Headers_getMessageType(&ctrl->content.error.cause);
if (causeType == Headers_SwitchHeader_TYPE_CONTROL) {
if (message->length < Control_Error_MIN_SIZE + Control_HEADER_SIZE) {
Log_info1(context->logger,
"error packet from [%s] containing runt cause packet",
labelStr);
return Error_NONE;
}
struct Control* causeCtrl = (struct Control*) &(&ctrl->content.error.cause)[1];
if (causeCtrl->type_be != Control_PING_be) {
Log_info3(context->logger,
"error packet from [%s] caused by [%s] packet ([%d])",
labelStr,
Control_typeString(causeCtrl->type_be),
Endian_bigEndianToHost16(causeCtrl->type_be));
} else {
Log_debug2(context->logger,
"error packet from [%s] in response to ping, length: [%d].",
labelStr,
message->length);
// errors resulting from pings are forwarded back to the pinger.
pong = true;
}
} else if (causeType != Headers_SwitchHeader_TYPE_DATA) {
Log_info1(context->logger,
"error packet from [%s] containing cause of unknown type [%d]",
labelStr);
}
} else if (ctrl->type_be == Control_PONG_be) {
pong = true;
} else if (ctrl->type_be == Control_PING_be) {
ctrl->type_be = Control_PONG_be;
Message_shift(message, Headers_SwitchHeader_SIZE);
switchIf->receiveMessage(message, switchIf);
} else {
Log_info2(context->logger,
"control packet of unknown type from [%s], type [%d]",
labelStr, Endian_bigEndianToHost16(ctrl->type_be));
}
if (pong) {
// Shift back over the header
Message_shift(message, Headers_SwitchHeader_SIZE);
context->switchPingerIf->receiveMessage(message, context->switchPingerIf);
}
return Error_NONE;
}
uint8_t* herKey = extractPublicKey(message, switchHeader->label_be, context->logger);
int herAddrIndex;
if (herKey) {
uint8_t herAddrStore[16];
AddressCalc_addressForPublicKey(herAddrStore, herKey);
if (herAddrStore[0] != 0xFC) {
Log_debug(context->logger,
"Got message from peer whose address is not in fc00::/8 range.\n");
return 0;
}
herAddrIndex = AddressMapper_put(switchHeader->label_be, herAddrStore, &context->addrMap);
} else {
herAddrIndex = AddressMapper_indexOf(switchHeader->label_be, &context->addrMap);
if (herAddrIndex == -1) {
uint64_t label = Endian_bigEndianToHost64(switchHeader->label_be);
struct Node* n = RouterModule_getNode(label, context->routerModule);
if (n) {
herAddrIndex = AddressMapper_put(switchHeader->label_be,
n->address.ip6.bytes,
&context->addrMap);
} else {
#ifdef Log_DEBUG
uint8_t switchAddr[20];
AddrTools_printPath(switchAddr, Endian_bigEndianToHost64(switchHeader->label_be));
Log_debug1(context->logger,
"Dropped traffic packet from unknown node. (%s)\n",
&switchAddr);
#endif
return 0;
}
}
}
// If the source address is the same as the router address, no third layer of crypto.
context->routerAddress = context->addrMap.entries[herAddrIndex].address;
// This is needed so that the priority and other information
// from the switch header can be passed on properly.
context->switchHeader = switchHeader;
context->session = SessionManager_getSession(context->routerAddress, herKey, context->sm);
// This goes to incomingFromCryptoAuth()
// then incomingFromRouter() then core()
context->layer = OUTER_LAYER;
context->session->receiveMessage(message, context->session);
return 0;
}
/*
* DataService_SetParameter - Set a DataService parameter.
*
* param - Profile parameter ID
* len - length of data to write
* value - pointer to data to write. This is dependent on
* the parameter ID and may be cast to the appropriate
* data type (example: data type of uint16_t will be cast to
* uint16_t pointer).
*/
bStatus_t DataService_SetParameter( uint8_t param, uint16_t len, void *value )
{
bStatus_t ret = SUCCESS;
uint8_t *pAttrVal;
uint16_t *pValLen;
uint16_t valMinLen;
uint16_t valMaxLen;
uint8_t sendNotiInd = FALSE;
gattCharCfg_t *attrConfig;
uint8_t needAuth;
switch ( param )
{
case DS_STRING_ID:
pAttrVal = ds_StringVal;
pValLen = &ds_StringValLen;
valMinLen = DS_STRING_LEN_MIN;
valMaxLen = DS_STRING_LEN;
Log_info2("SetParameter : %s len: %d", (IArg)"String", (IArg)len);
break;
case DS_STREAM_ID:
pAttrVal = ds_StreamVal;
pValLen = &ds_StreamValLen;
valMinLen = DS_STREAM_LEN_MIN;
valMaxLen = DS_STREAM_LEN;
sendNotiInd = TRUE;
attrConfig = ds_StreamConfig;
needAuth = FALSE; // Change if authenticated link is required for sending.
Log_info2("SetParameter : %s len: %d", (IArg)"Stream", (IArg)len);
break;
default:
Log_error1("SetParameter: Parameter #%d not valid.", (IArg)param);
return INVALIDPARAMETER;
}
// Check bounds, update value and send notification or indication if possible.
if ( len <= valMaxLen && len >= valMinLen )
{
memcpy(pAttrVal, value, len);
*pValLen = len; // Update length for read and get.
if (sendNotiInd)
{
Log_info2("Trying to send noti/ind: connHandle %x, %s",
(IArg)attrConfig[0].connHandle,
(IArg)((attrConfig[0].value==0)?"\x1b[33mNoti/ind disabled\x1b[0m" :
(attrConfig[0].value==1)?"Notification enabled" :
"Indication enabled"));
// Try to send notification.
GATTServApp_ProcessCharCfg( attrConfig, pAttrVal, needAuth,
Data_ServiceAttrTbl, GATT_NUM_ATTRS( Data_ServiceAttrTbl ),
ds_icall_rsp_task_id, Data_Service_ReadAttrCB);
}
}
else
{
Log_error3("Length outside bounds: Len: %d MinLen: %d MaxLen: %d.", (IArg)len, (IArg)valMinLen, (IArg)valMaxLen);
ret = bleInvalidRange;
}
return ret;
}
