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");
}
CAIPData_t *CACreateIPData(const CAEndpoint_t *remoteEndpoint, const void *data,
uint32_t dataLength, bool isMulticast)
{
VERIFY_NON_NULL_RET(remoteEndpoint, TAG, "remoteEndpoint is NULL", NULL);
VERIFY_NON_NULL_RET(data, TAG, "IPData is NULL", NULL);
CAIPData_t *ipData = (CAIPData_t *) OICMalloc(sizeof(*ipData));
if (!ipData)
{
OIC_LOG(ERROR, TAG, "Memory allocation failed!");
return NULL;
}
ipData->remoteEndpoint = CACloneEndpoint(remoteEndpoint);
ipData->data = (void *) OICMalloc(dataLength);
if (!ipData->data)
{
OIC_LOG(ERROR, TAG, "Memory allocation failed!");
CAFreeIPData(ipData);
return NULL;
}
memcpy(ipData->data, data, dataLength);
ipData->dataLen = dataLength;
ipData->isMulticast = isMulticast;
return ipData;
}
CATCPData *CACreateTCPData(const CAEndpoint_t *remoteEndpoint, const void *data,
size_t dataLength, bool isMulticast)
{
VERIFY_NON_NULL_RET(remoteEndpoint, TAG, "remoteEndpoint is NULL", NULL);
VERIFY_NON_NULL_RET(data, TAG, "data is NULL", NULL);
CATCPData *tcpData = (CATCPData *) OICCalloc(1, sizeof(*tcpData));
if (!tcpData)
{
OIC_LOG(ERROR, TAG, "Memory allocation failed!");
return NULL;
}
tcpData->remoteEndpoint = CACloneEndpoint(remoteEndpoint);
tcpData->data = (void *) OICMalloc(dataLength);
if (!tcpData->data)
{
OIC_LOG(ERROR, TAG, "Memory allocation failed!");
CAFreeTCPData(tcpData);
return NULL;
}
memcpy(tcpData->data, data, dataLength);
tcpData->dataLen = dataLength;
tcpData->isMulticast = isMulticast;
return tcpData;
}
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");
}
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");
}
CAEDRNetworkEvent *CAEDRCreateNetworkEvent(CAEndpoint_t *connectivity,
CANetworkStatus_t status)
{
VERIFY_NON_NULL_RET(connectivity, EDR_ADAPTER_TAG, "connectivity is NULL", NULL);
// Create CAEDRNetworkEvent
CAEDRNetworkEvent *event = (CAEDRNetworkEvent *) OICMalloc(sizeof(CAEDRNetworkEvent));
if (NULL == event)
{
OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to allocate memory to network event!");
return NULL;
}
// Create duplicate of Local connectivity
event->info = CACloneEndpoint(connectivity);
event->status = status;
return event;
}
CAEDRData *CACreateEDRData(const CAEndpoint_t *remoteEndpoint,
const uint8_t *data, uint32_t dataLength)
{
CAEDRData *edrData = (CAEDRData *)OICMalloc(sizeof (CAEDRData));
if (!edrData)
{
OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
return NULL;
}
edrData->remoteEndpoint = CACloneEndpoint(remoteEndpoint);
edrData->data = OICMalloc(dataLength);
if (NULL == edrData->data)
{
OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
CAFreeEDRData(edrData);
return NULL;
}
memcpy(edrData->data, data, dataLength);
edrData->dataLen = dataLength;
return edrData;
}
static CAData_t* CAPrepareSendData(const CAEndpoint_t *endpoint, const void *sendData,
CADataType_t dataType)
{
OIC_LOG(DEBUG, TAG, "CAPrepareSendData IN");
CAData_t *cadata = (CAData_t *) OICCalloc(1, sizeof(CAData_t));
if (!cadata)
{
OIC_LOG(ERROR, TAG, "memory allocation failed");
return NULL;
}
if(CA_REQUEST_DATA == dataType)
{
// clone request info
CARequestInfo_t *request = CACloneRequestInfo((CARequestInfo_t *)sendData);
if(!request)
{
OIC_LOG(ERROR, TAG, "CACloneRequestInfo failed");
OICFree(cadata);
return NULL;
}
cadata->type = request->isMulticast ? SEND_TYPE_MULTICAST : SEND_TYPE_UNICAST;
cadata->requestInfo = request;
}
else if(CA_RESPONSE_DATA == dataType)
{
// clone response info
CAResponseInfo_t *response = CACloneResponseInfo((CAResponseInfo_t *)sendData);
if(!response)
{
OIC_LOG(ERROR, TAG, "CACloneResponseInfo failed");
OICFree(cadata);
return NULL;
}
cadata->type = response->isMulticast ? SEND_TYPE_MULTICAST : SEND_TYPE_UNICAST;
cadata->responseInfo = response;
}
else
{
OIC_LOG(ERROR, TAG, "CAPrepareSendData unknown data type");
OICFree(cadata);
return NULL;
}
CAEndpoint_t* ep = CACloneEndpoint(endpoint);
if (!ep)
{
OIC_LOG(ERROR, TAG, "endpoint clone failed");
CADestroyData(cadata, sizeof(CAData_t));
return NULL;
}
cadata->remoteEndpoint = ep;
cadata->dataType = dataType;
return cadata;
}
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");
}
