static void CATimeoutCallback(const CAEndpoint_t *endpoint, const void *pdu, uint32_t size)
{
OIC_LOG(DEBUG, TAG, "IN");
CAEndpoint_t* ep = CACloneEndpoint(endpoint);
if (NULL == ep)
{
OIC_LOG(ERROR, TAG, "clone failed");
return;
}
CAResponseInfo_t* resInfo = (CAResponseInfo_t*) OICCalloc(1, sizeof(CAResponseInfo_t));
if (NULL == resInfo)
{
OIC_LOG(ERROR, TAG, "calloc failed");
CAFreeEndpoint(ep);
return;
}
resInfo->result = CA_RETRANSMIT_TIMEOUT;
resInfo->info.type = CAGetMessageTypeFromPduBinaryData(pdu, size);
resInfo->info.messageId = CAGetMessageIdFromPduBinaryData(pdu, size);
if (g_responseHandler)
{
g_responseHandler(ep, resInfo);
}
CAFreeEndpoint(ep);
OICFree(resInfo);
OIC_LOG(DEBUG, TAG, "OUT");
}
/**
* implement for BT-EDR adapter common method
*/
CAResult_t CAEDRGetInterfaceInformation(CAEndpoint_t **info)
{
OIC_LOG(DEBUG, TAG, "IN - CAEDRGetInterfaceInformation");
if (!info)
{
OIC_LOG(ERROR, TAG, "endpoint info is null");
return CA_STATUS_FAILED;
}
int32_t netInfoSize = 1;
char *macAddress = NULL;
CAResult_t ret = CAEDRGetInterfaceInfo(&macAddress);
OIC_LOG_V(ERROR, TAG, "address : %s", macAddress);
if (NULL == macAddress)
{
OIC_LOG(ERROR, TAG, "mac address is null");
return CA_STATUS_FAILED;
}
if (CA_STATUS_OK != ret)
{
OIC_LOG_V(ERROR, TAG, "Failed to get interface info [%d]", ret);
OICFree(macAddress);
return ret;
}
// Create local endpoint using util function
CAEndpoint_t *endpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS, CA_ADAPTER_RFCOMM_BTEDR,
macAddress, 0);
if (NULL == endpoint)
{
OIC_LOG(ERROR, TAG, "Failed to create Local Endpoint!");
OICFree(macAddress);
return CA_STATUS_FAILED;
}
// copy unicast server information
CAEndpoint_t *netInfo = (CAEndpoint_t *)OICMalloc(sizeof(CAEndpoint_t) * netInfoSize);
if (NULL == netInfo)
{
OIC_LOG(ERROR, TAG, "Invalid input..");
OICFree(macAddress);
CAFreeEndpoint(endpoint);
return CA_MEMORY_ALLOC_FAILED;
}
*netInfo = *endpoint;
*info = netInfo;
OICFree(macAddress);
CAFreeEndpoint(endpoint);
OIC_LOG(DEBUG, TAG, "OUT - CAEDRGetInterfaceInformation");
return CA_STATUS_OK;
}
static void CATimeoutCallback(const CAEndpoint_t *endpoint, const void *pdu, uint32_t size)
{
OIC_LOG(DEBUG, TAG, "IN");
VERIFY_NON_NULL_VOID(endpoint, TAG, "endpoint");
VERIFY_NON_NULL_VOID(pdu, TAG, "pdu");
CAEndpoint_t* ep = CACloneEndpoint(endpoint);
if (!ep)
{
OIC_LOG(ERROR, TAG, "clone failed");
return;
}
CAResponseInfo_t* resInfo = (CAResponseInfo_t*)OICCalloc(1, sizeof(CAResponseInfo_t));
if (!resInfo)
{
OIC_LOG(ERROR, TAG, "calloc failed");
CAFreeEndpoint(ep);
return;
}
resInfo->result = CA_RETRANSMIT_TIMEOUT;
resInfo->info.type = CAGetMessageTypeFromPduBinaryData(pdu, size);
resInfo->info.messageId = CAGetMessageIdFromPduBinaryData(pdu, size);
CAResult_t res = CAGetTokenFromPDU((const coap_hdr_t *) pdu, &(resInfo->info));
if (CA_STATUS_OK != res)
{
OIC_LOG(ERROR, TAG, "fail to get Token from retransmission list");
CADestroyResponseInfoInternal(resInfo);
CAFreeEndpoint(ep);
return;
}
CAData_t *cadata = (CAData_t *) OICCalloc(1, sizeof(CAData_t));
if (NULL == cadata)
{
OIC_LOG(ERROR, TAG, "memory allocation failed !");
CAFreeEndpoint(ep);
CADestroyResponseInfoInternal(resInfo);
return;
}
cadata->type = SEND_TYPE_UNICAST;
cadata->remoteEndpoint = ep;
cadata->requestInfo = NULL;
cadata->responseInfo = resInfo;
#ifdef SINGLE_THREAD
CAProcessReceivedData(cadata);
#else
CAQueueingThreadAddData(&g_receiveThread, cadata, sizeof(CAData_t));
#endif
OIC_LOG(DEBUG, TAG, "OUT");
}
void CARANotifyNetworkChange(const char *address, CANetworkStatus_t status)
{
OIC_LOG(DEBUG, RA_ADAPTER_TAG, "CARANotifyNetworkChange IN");
CAEndpoint_t *localEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
CA_ADAPTER_REMOTE_ACCESS,
address, 0);
if (!localEndpoint)
{
OIC_LOG(ERROR, RA_ADAPTER_TAG, "localEndpoint creation failed!");
return;
}
CANetworkChangeCallback networkChangeCallback = g_networkChangeCallback;
if (networkChangeCallback)
{
networkChangeCallback(localEndpoint, status);
}
else
{
OIC_LOG(ERROR, RA_ADAPTER_TAG, "g_networkChangeCallback is NULL");
}
CAFreeEndpoint(localEndpoint);
OIC_LOG(DEBUG, RA_ADAPTER_TAG, "CARANotifyNetworkChange OUT");
}
void CATerminateEDR()
{
OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
// Stop EDR adapter
CAStopEDR();
// Terminate EDR Network Monitor
CAEDRTerminateNetworkMonitor();
// Terminate Send/Receive data messages queues
CAAdapterTerminateQueues();
g_networkPacketReceivedCallback = NULL;
g_networkChangeCallback = NULL;
// Terminate thread pool
g_edrThreadPool = NULL;
// Terminate EDR Client
CAEDRClientTerminate();
// Terminate EDR Server
CAEDRServerTerminate();
// Free LocalConnectivity information
CAFreeEndpoint(g_localConnectivity);
g_localConnectivity = NULL;
OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
}
void CAFreeIPData(CAIPData_t *ipData)
{
VERIFY_NON_NULL_VOID(ipData, TAG, "ipData is NULL");
CAFreeEndpoint(ipData->remoteEndpoint);
OICFree(ipData->data);
OICFree(ipData);
}
void CAEDRFreeNetworkEvent(CAEDRNetworkEvent *event)
{
if (event)
{
CAFreeEndpoint(event->info);
OICFree(event);
}
}
void CAFreeEDRData(CAEDRData *edrData)
{
VERIFY_NON_NULL_VOID(edrData, EDR_ADAPTER_TAG, "edrData is NULL");
CAFreeEndpoint(edrData->remoteEndpoint);
OICFree(edrData->data);
OICFree(edrData);
}
void CAFreeTCPData(CATCPData *tcpData)
{
VERIFY_NON_NULL_VOID(tcpData, TAG, "tcpData is NULL");
CAFreeEndpoint(tcpData->remoteEndpoint);
OICFree(tcpData->data);
OICFree(tcpData);
}
static void CASendErrorInfo(const CAEndpoint_t *endpoint, const CAInfo_t *info, CAResult_t result)
{
OIC_LOG(DEBUG, TAG, "CASendErrorInfo IN");
#ifndef SINGLE_THREAD
CAData_t *cadata = (CAData_t *) OICCalloc(1, sizeof(CAData_t));
if (!cadata)
{
OIC_LOG(ERROR, TAG, "memory allocation failed");
return;
}
CAEndpoint_t* ep = CACloneEndpoint(endpoint);
if (!ep)
{
OIC_LOG(ERROR, TAG, "endpoint clone failed");
OICFree(cadata);
return;
}
CAErrorInfo_t *errorInfo = (CAErrorInfo_t *)OICCalloc(1, sizeof (CAErrorInfo_t));
if (!errorInfo)
{
OICFree(cadata);
CAFreeEndpoint(ep);
return;
}
CAResult_t res = CACloneInfo(info, &errorInfo->info);
if (CA_STATUS_OK != res)
{
OICFree(cadata);
OICFree(errorInfo);
CAFreeEndpoint(ep);
return;
}
errorInfo->result = result;
cadata->remoteEndpoint = ep;
cadata->errorInfo = errorInfo;
cadata->dataType = CA_ERROR_DATA;
CAQueueingThreadAddData(&g_receiveThread, cadata, sizeof(CAData_t));
#endif
OIC_LOG(DEBUG, TAG, "CASendErrorInfo OUT");
}
void CARAXmppMessageReceivedCB(void * const param, xmpp_error_code_t result,
const void *const sender, const void *const msg, size_t messageOctets)
{
if (g_networkPacketCallback)
{
VERIFY_NON_NULL_VOID(sender, RA_ADAPTER_TAG, "sender is NULL");
VERIFY_NON_NULL_VOID(msg, RA_ADAPTER_TAG, "message is NULL");
OIC_LOG_V (ERROR, RA_ADAPTER_TAG, "Message received from %s", sender);
OIC_LOG_V (ERROR, RA_ADAPTER_TAG, "Message reception result %d", result);
CAEndpoint_t *endPoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
CA_ADAPTER_REMOTE_ACCESS, sender, 0);
if (!endPoint)
{
OIC_LOG(ERROR, RA_ADAPTER_TAG, "EndPoint creation failed!");
return;
}
void *buf = OICMalloc(messageOctets);
if (!buf)
{
OIC_LOG(ERROR, RA_ADAPTER_TAG, "Memory alloc of message failed!");
CAFreeEndpoint(endPoint);
return;
}
memcpy(buf, msg, messageOctets);
CANetworkPacketReceivedCallback networkPacketCallback = g_networkPacketCallback;
if (networkPacketCallback)
{
g_networkPacketCallback(endPoint, buf, messageOctets);
}
CAFreeEndpoint (endPoint);
}
else
{
OIC_LOG_V (ERROR, RA_ADAPTER_TAG, "No callback for RA received message found");
}
}
static void CADestroyData(void *data, uint32_t size)
{
OIC_LOG(DEBUG, TAG, "CADestroyData IN");
if ((size_t)size < sizeof(CAData_t))
{
OIC_LOG_V(ERROR, TAG, "Destroy data too small %p %d", data, size);
}
CAData_t *cadata = (CAData_t *) data;
if (NULL == cadata)
{
OIC_LOG(ERROR, TAG, "cadata is NULL");
return;
}
if (NULL != cadata->remoteEndpoint)
{
CAFreeEndpoint(cadata->remoteEndpoint);
}
if (NULL != cadata->requestInfo)
{
CADestroyRequestInfoInternal((CARequestInfo_t *) cadata->requestInfo);
}
if (NULL != cadata->responseInfo)
{
CADestroyResponseInfoInternal((CAResponseInfo_t *) cadata->responseInfo);
}
if (NULL != cadata->errorInfo)
{
CADestroyErrorInfoInternal(cadata->errorInfo);
}
OICFree(cadata);
OIC_LOG(DEBUG, TAG, "CADestroyData OUT");
}
void CAAdapterDataReceiverHandler(void *context)
{
OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN_CAAdapterDataReceiverHandler");
CAEDRData *message = (CAEDRData *) context;
if (NULL == message || NULL == message->remoteEndpoint)
{
OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get message!");
return;
}
CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
CA_ADAPTER_RFCOMM_BTEDR,
message->remoteEndpoint->addr,
0);
OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Sending data up !");
g_networkPacketReceivedCallback(remoteEndpoint, message->data, message->dataLen);
CAFreeEndpoint(remoteEndpoint);
OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT_CAAdapterDataReceiverHandler");
}
CAResult_t CAAdapterSendData(const char *remoteAddress, const char *serviceUUID, const uint8_t *data,
uint32_t dataLength, uint32_t *sentLength)
{
OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CAAdapterSendData");
if (false == g_adapterState)
{
OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
*sentLength = 0;
return CA_ADAPTER_NOT_ENABLED;
}
// Input validation
VERIFY_NON_NULL(serviceUUID, EDR_ADAPTER_TAG, "service UUID is null");
VERIFY_NON_NULL(data, EDR_ADAPTER_TAG, "Data is null");
VERIFY_NON_NULL(sentLength, EDR_ADAPTER_TAG, "Sent data length holder is null");
// Create remote endpoint
CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
CA_ADAPTER_RFCOMM_BTEDR,
remoteAddress, 0);
if (NULL == remoteEndpoint)
{
OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
return CA_MEMORY_ALLOC_FAILED;
}
// Add message to data queue
CAEDRData *edrData = CACreateEDRData(remoteEndpoint, data, dataLength);
CAQueueingThreadAddData(g_sendQueueHandle, edrData, sizeof (CAEDRData));
*sentLength = dataLength;
// Free remote endpoint
CAFreeEndpoint(remoteEndpoint);
OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT - CAAdapterSendData");
return CA_STATUS_OK;
}
void CAEDRErrorHandler(const char *remoteAddress, const uint8_t *data,
uint32_t dataLength, CAResult_t result)
{
OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
// Input validation
VERIFY_NON_NULL_VOID(data, EDR_ADAPTER_TAG, "Data is null");
// Create remote endpoint
CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(0, CA_ADAPTER_RFCOMM_BTEDR,
remoteAddress, 0);
if (!remoteEndpoint)
{
OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
return;
}
g_errorCallback(remoteEndpoint, data, dataLength, result);
// Free remote endpoint
CAFreeEndpoint(remoteEndpoint);
OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
}
void CAAdapterRecvData(const char *remoteAddress, const uint8_t *data, uint32_t dataLength,
uint32_t *sentLength)
{
OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
if (false == g_adapterState)
{
OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
*sentLength = 0;
return;
}
// Input validation
VERIFY_NON_NULL_VOID(data, EDR_ADAPTER_TAG, "Data is null");
VERIFY_NON_NULL_VOID(sentLength, EDR_ADAPTER_TAG, "Sent data length holder is null");
// Create remote endpoint
CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
CA_ADAPTER_RFCOMM_BTEDR,
remoteAddress, 0);
if (NULL == remoteEndpoint)
{
OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
return;
}
// Add message to data queue
CAEDRData *edrData = CACreateEDRData(remoteEndpoint, data, dataLength);
CAQueueingThreadAddData(g_recvQueueHandle, edrData, sizeof(CAEDRData));
*sentLength = dataLength;
// Free remote endpoint
CAFreeEndpoint(remoteEndpoint);
OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
}
void CADestroyEndpoint(CAEndpoint_t *rep)
{
OIC_LOG(DEBUG, TAG, "CADestroyEndpoint");
CAFreeEndpoint(rep);
}
static CAData_t* CAGenerateHandlerData(const CAEndpoint_t *endpoint,
const CARemoteId_t *identity,
const void *data, CADataType_t dataType)
{
OIC_LOG(DEBUG, TAG, "CAGenerateHandlerData IN");
CAInfo_t *info = NULL;
CAData_t *cadata = (CAData_t *) OICCalloc(1, sizeof(CAData_t));
if (!cadata)
{
OIC_LOG(ERROR, TAG, "memory allocation failed");
return NULL;
}
CAEndpoint_t* ep = CACloneEndpoint(endpoint);
if (!ep)
{
OIC_LOG(ERROR, TAG, "endpoint clone failed");
OICFree(cadata);
return NULL;
}
OIC_LOG_V(DEBUG, TAG, "address : %s", ep->addr);
CAResult_t result;
if(CA_RESPONSE_DATA == dataType)
{
CAResponseInfo_t* resInfo = (CAResponseInfo_t*)OICCalloc(1, sizeof(CAResponseInfo_t));
if (!resInfo)
{
OIC_LOG(ERROR, TAG, "memory allocation failed");
OICFree(cadata);
CAFreeEndpoint(ep);
return NULL;
}
result = CAGetResponseInfoFromPDU(data, resInfo, endpoint);
if (CA_STATUS_OK != result)
{
OIC_LOG(ERROR, TAG, "CAGetResponseInfoFromPDU Failed");
CAFreeEndpoint(ep);
CADestroyResponseInfoInternal(resInfo);
OICFree(cadata);
return NULL;
}
cadata->responseInfo = resInfo;
info = &resInfo->info;
if (identity)
{
info->identity = *identity;
}
OIC_LOG(DEBUG, TAG, "Response Info :");
CALogPayloadInfo(info);
}
else if (CA_REQUEST_DATA == dataType)
{
CARequestInfo_t* reqInfo = (CARequestInfo_t*)OICCalloc(1, sizeof(CARequestInfo_t));
if (!reqInfo)
{
OIC_LOG(ERROR, TAG, "memory allocation failed");
OICFree(cadata);
CAFreeEndpoint(ep);
return NULL;
}
result = CAGetRequestInfoFromPDU(data, endpoint, reqInfo);
if (CA_STATUS_OK != result)
{
OIC_LOG(ERROR, TAG, "CAGetRequestInfoFromPDU failed");
CAFreeEndpoint(ep);
CADestroyRequestInfoInternal(reqInfo);
OICFree(cadata);
return NULL;
}
if (CADropSecondMessage(&caglobals.ca.requestHistory, endpoint, reqInfo->info.messageId,
reqInfo->info.token, reqInfo->info.tokenLength))
{
OIC_LOG(ERROR, TAG, "Second Request with same Token, Drop it");
CAFreeEndpoint(ep);
CADestroyRequestInfoInternal(reqInfo);
OICFree(cadata);
return NULL;
}
cadata->requestInfo = reqInfo;
info = &reqInfo->info;
if (identity)
{
info->identity = *identity;
}
OIC_LOG(DEBUG, TAG, "Request Info :");
CALogPayloadInfo(info);
}
else if (CA_ERROR_DATA == dataType)
{
CAErrorInfo_t *errorInfo = (CAErrorInfo_t *)OICCalloc(1, sizeof (CAErrorInfo_t));
if (!errorInfo)
{
OIC_LOG(ERROR, TAG, "Memory allocation failed!");
OICFree(cadata);
CAFreeEndpoint(ep);
return NULL;
}
CAResult_t result = CAGetErrorInfoFromPDU(data, endpoint, errorInfo);
if (CA_STATUS_OK != result)
{
OIC_LOG(ERROR, TAG, "CAGetErrorInfoFromPDU failed");
CAFreeEndpoint(ep);
OICFree(errorInfo);
OICFree(cadata);
return NULL;
}
cadata->errorInfo = errorInfo;
info = &errorInfo->info;
if (identity)
{
info->identity = *identity;
}
OIC_LOG(DEBUG, TAG, "error Info :");
CALogPayloadInfo(info);
}
cadata->remoteEndpoint = ep;
cadata->dataType = dataType;
return cadata;
OIC_LOG(DEBUG, TAG, "CAGenerateHandlerData OUT");
}
