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");
}
static void CAReceivedPacketCallback(CAEndpoint_t *endpoint, void *data, uint32_t dataLen)
{
OIC_LOG(DEBUG, TAG, "IN");
VERIFY_NON_NULL_VOID(data, TAG, "data");
uint32_t code = CA_NOT_FOUND;
coap_pdu_t *pdu = (coap_pdu_t *) CAParsePDU((const char *) data, dataLen, &code);
OICFree(data);
if (NULL == pdu)
{
OIC_LOG(ERROR, TAG, "Parse PDU failed");
return;
}
char uri[CA_MAX_URI_LENGTH] = { };
if (CA_GET == code || CA_POST == code || CA_PUT == code || CA_DELETE == code)
{
CARequestInfo_t *ReqInfo = (CARequestInfo_t *) OICCalloc(1, sizeof(CARequestInfo_t));
if (NULL == ReqInfo)
{
OIC_LOG(ERROR, TAG, "CAReceivedPacketCallback, Memory allocation failed!");
coap_delete_pdu(pdu);
return;
}
CAResult_t res = CAGetRequestInfoFromPDU(pdu, ReqInfo);
if (CA_STATUS_OK != res)
{
OIC_LOG_V(ERROR, TAG, "CAGetRequestInfoFromPDU failed : %d", res);
OICFree(ReqInfo);
coap_delete_pdu(pdu);
return;
}
if (NULL != ReqInfo->info.options)
{
for (uint32_t i = 0; i < ReqInfo->info.numOptions; i++)
{
OIC_LOG_V(DEBUG, TAG, "optionID: %d", ReqInfo->info.options[i].optionID);
OIC_LOG_V(DEBUG, TAG, "list: %s", ReqInfo->info.options[i].optionData);
}
}
if (NULL != ReqInfo->info.payload)
{
OIC_LOG_V(DEBUG, TAG, "Request- payload: %s", ReqInfo->info.payload);
}
OIC_LOG_V(DEBUG, TAG, "code: %d", ReqInfo->method);
OIC_LOG(DEBUG, TAG, "token:");
OIC_LOG_BUFFER(DEBUG, TAG, (const uint8_t *) ReqInfo->info.token, CA_MAX_TOKEN_LEN);
if (g_requestHandler)
{
g_requestHandler(endpoint, ReqInfo);
}
CADestroyRequestInfoInternal(ReqInfo);
}
else
{
CAResponseInfo_t *ResInfo = (CAResponseInfo_t *) OICCalloc(1, sizeof(CAResponseInfo_t));
if (NULL == ResInfo)
{
OIC_LOG(ERROR, TAG, "CAReceivedPacketCallback, Memory allocation failed!");
coap_delete_pdu(pdu);
return;
}
CAResult_t res = CAGetResponseInfoFromPDU(pdu, ResInfo);
if (CA_STATUS_OK != res)
{
OIC_LOG_V(ERROR, TAG, "CAGetResponseInfoFromPDU failed : %d", res);
OICFree(ResInfo);
coap_delete_pdu(pdu);
return;
}
if (NULL != ResInfo->info.options)
{
for (uint32_t i = 0; i < ResInfo->info.numOptions; i++)
{
OIC_LOG_V(DEBUG, TAG, "optionID: %d", ResInfo->info.options[i].optionID);
OIC_LOG_V(DEBUG, TAG, "list: %s", ResInfo->info.options[i].optionData);
}
}
if (NULL != ResInfo->info.payload)
{
OIC_LOG_V(DEBUG, TAG, "payload: %s", ResInfo->info.payload);
}
OIC_LOG_V(DEBUG, TAG, "code: %d", ResInfo->result);
// for retransmission
void *retransmissionPdu = NULL;
CARetransmissionReceivedData(&g_retransmissionContext, endpoint, pdu->hdr, pdu->length,
&retransmissionPdu);
// get token from saved data in retransmission list
if (retransmissionPdu && CA_EMPTY == code)
{
CAResult_t res = CAGetTokenFromPDU((const coap_hdr_t *)retransmissionPdu,
&(ResInfo->info));
if(CA_STATUS_OK != res)
{
OIC_LOG(ERROR, TAG, "fail to get Token from retransmission list");
OICFree(ResInfo->info.token);
}
}
OICFree(retransmissionPdu);
if (NULL != ResInfo)
{
if (g_responseHandler)
{
g_responseHandler(endpoint, ResInfo);
}
CADestroyResponseInfoInternal(ResInfo);
}
}
if (pdu)
{
coap_delete_pdu(pdu);
}
OIC_LOG(DEBUG, TAG, "OUT");
}
