ProvisioningInfo *PrepareProvisioingStatusCB(OCClientResponse *clientResponse,
ProvStatus provStatus) {
ProvisioningInfo *provInfo = (ProvisioningInfo *) OICCalloc(1, sizeof(ProvisioningInfo));
if (provInfo == NULL) {
OIC_LOG_V(ERROR, TAG, "Failed to allocate memory");
return NULL;
}
OCDevAddr *devAddr = (OCDevAddr *) OICCalloc(1, sizeof(OCDevAddr));
if (devAddr == NULL) {
OIC_LOG_V(ERROR, TAG, "Failed to allocate memory");
return NULL;
}
strncpy(devAddr->addr, clientResponse->addr->addr, sizeof(devAddr->addr));
devAddr->port = clientResponse->addr->port;
provInfo->provDeviceInfo.addr = devAddr;
provInfo->provStatus = provStatus;
return provInfo;
}
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 CborError FindStringLLInMap(const CborValue *linksMap, char *tag, OCStringLL **links)
{
size_t len;
CborError cborFindResult;
CborValue rtArray;
cborFindResult = cbor_value_map_find_value(linksMap, tag, &rtArray);
if (CborNoError != cborFindResult)
{
return CborUnknownError;
}
CborValue rtVal;
cborFindResult = cbor_value_enter_container(&rtArray, &rtVal);
if (CborNoError != cborFindResult)
{
return CborUnknownError;
}
OCStringLL* llPtr = *links;
while (cbor_value_is_text_string(&rtVal))
{
if (llPtr == NULL)
{
llPtr = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL));
if (!llPtr)
{
return CborUnknownError;
}
*links = llPtr;
}
else if(llPtr)
{
while (llPtr->next)
{
llPtr = llPtr->next;
}
llPtr->next = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL));
if (!llPtr->next)
{
return CborUnknownError;
}
}
cborFindResult = cbor_value_dup_text_string(&rtVal, &(llPtr->value), &len, NULL);
if (CborNoError != cborFindResult)
{
return CborUnknownError;
}
cborFindResult = cbor_value_advance(&rtVal);
if (CborNoError != cborFindResult)
{
return CborUnknownError;
}
}
cborFindResult = cbor_value_leave_container(&rtArray, &rtVal);
return cborFindResult;
}
OCStackResult SetPlatformInfo()
{
static const OCPlatformInfo platformInfo =
{
.platformID = "IoTivityZigbeeID",
.manufacturerName = "IoTivity",
.manufacturerUrl = "http://iotivity.org",
.modelNumber = "T1000",
.dateOfManufacture = "January 14th, 2015",
.platformVersion = "0.9.2",
.operatingSystemVersion = "7",
.hardwareVersion = "0.5",
.firmwareVersion = "0",
.supportUrl = "http://iotivity.org",
.systemTime = ""
};
return OCSetPlatformInfo(platformInfo);
}
OCStackResult SetDeviceInfo()
{
static OCDeviceInfo deviceInfo =
{
.deviceName = "IoTivity/Zigbee Server Sample",
.specVersion = "IoTivity/Zigbee Device Spec Version",
};
char *dmv = OICStrdup("IoTivity/Zigbee Data Model Version");
deviceInfo.dataModelVersions = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL));
deviceInfo.dataModelVersions->value = dmv;
char *dup = OICStrdup("oic.wk.d");
deviceInfo.types = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL));
deviceInfo.types->value = dup;
return OCSetDeviceInfo(deviceInfo);
}
bool processSignal(bool set)
{
static sig_atomic_t signal = 0;
if (set)
{
signal = 1;
}
return signal == 1;
}
void processCancel(int signal)
{
if(signal == SIGINT)
{
processSignal(true);
}
}
static OicSecPdAcl_t* createPdAcl(const int dev_num)
{
if(0>=dev_num || g_own_cnt<dev_num)
{
OIC_LOG(ERROR, TAG, "createAcl invalid parameters");
return NULL; // not need to 'goto' |ERROR| before allocating |acl|
}
// allocate memory for |pdacl| struct
printf(" **** Create PDACL for the Selected Device[%d]\n", dev_num);
OicSecPdAcl_t* pdAcl = (OicSecPdAcl_t*) OICCalloc(1, sizeof(OicSecPdAcl_t));
if(!pdAcl)
{
OIC_LOG(ERROR, TAG, "createAcl: OICCalloc error return");
return NULL; // not need to 'goto' |ERROR| before allocating |acl|
}
// number of resources
char rsrc_in[][ACL_RESRC_MAX_LEN+1] = {"*", "/rsrc/*"};
pdAcl->resourcesLen = 1;
// resource
int num = pdAcl->resourcesLen;
pdAcl->resources = (char**) OICCalloc(num, sizeof(char*));
if(!pdAcl->resources)
{
OIC_LOG(ERROR, TAG, "createPdAcl: OICCalloc error return");
goto CRPDACL_ERROR;
}
for(int i=0; num>i; ++i)
{
size_t len = strlen(rsrc_in[i])+1; // '1' for null termination
char* rsrc = (char*) OICCalloc(len, sizeof(char));
if(!rsrc)
{
OIC_LOG(ERROR, TAG, "createPdAcl: OICCalloc error return");
goto CRPDACL_ERROR;
}
OICStrcpy(rsrc, len, rsrc_in[i]);
pdAcl->resources[i] = rsrc; // after here, |rsrc| points nothing
}
// permission
pdAcl->permission = PERMISSION_FULL_CONTROL;
return pdAcl;
CRPDACL_ERROR:
OCDeletePdAclList(pdAcl);
return NULL;
}
static char* OCStringLLJoin(OCStringLL* val)
{
OCStringLL* temp = val;
size_t size = strlen(temp->value);
while (temp->next)
{
++size;
temp = temp->next;
size += strlen(temp->value);
}
char* joinedStr = (char*)OICCalloc(sizeof(char), size + 1);
if (!joinedStr)
{
return NULL;
}
OICStrcat(joinedStr, size + 1, val->value);
while (val->next)
{
val = val->next;
OICStrcat(joinedStr, size + 1, " ");
OICStrcat(joinedStr, size + 1, val->value);
}
return joinedStr;
}
OCStackResult ConvertUuidToStr(const OicUuid_t* uuid, char** strUuid)
{
if(NULL == uuid || NULL == strUuid || NULL != *strUuid)
{
OIC_LOG(ERROR, TAG, "ConvertUuidToStr : Invalid param");
return OC_STACK_INVALID_PARAM;
}
size_t uuidIdx = 0;
size_t urnIdx = 0;
const size_t urnBufSize = (UUID_LENGTH * 2) + 4 + 1;
char* convertedUrn = (char*)OICCalloc(urnBufSize, sizeof(char));
VERIFY_NON_NULL(TAG, convertedUrn, ERROR);
for(uuidIdx=0, urnIdx=0; uuidIdx < UUID_LENGTH && urnIdx < urnBufSize; uuidIdx++, urnIdx+=2)
{
// canonical format for UUID has '8-4-4-4-12'
if(uuidIdx==4 || uuidIdx==6 || uuidIdx==8 || uuidIdx==10)
{
snprintf(convertedUrn + urnIdx, 2, "%c", '-');
urnIdx++;
}
snprintf(convertedUrn + urnIdx, 3, "%02x", (uint8_t)(uuid->id[uuidIdx]));
}
convertedUrn[urnBufSize - 1] = '\0';
*strUuid = convertedUrn;
return OC_STACK_OK;
exit:
return OC_STACK_NO_MEMORY;
}
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");
}
CAResult_t CADetachResponseMessage(const CAEndpoint_t *object,
const CAResponseInfo_t *response)
{
OIC_LOG(DEBUG, TAG, "IN");
VERIFY_NON_NULL(object, TAG, "object");
VERIFY_NON_NULL(response, TAG, "response");
// allocate & initialize
CAData_t *data = (CAData_t *) OICCalloc(1, sizeof(CAData_t));
CA_MEMORY_ALLOC_CHECK(data);
// save data
data->type = SEND_TYPE_UNICAST;
data->remoteEndpoint = object;
data->requestInfo = NULL;
data->responseInfo = response;
CAProcessData(data);
OICFree(data);
OIC_LOG(DEBUG, TAG, "OUT");
return CA_STATUS_OK;
// memory error label.
memory_error_exit:
OICFree(data);
OIC_LOG(DEBUG, TAG, "OUT");
return CA_MEMORY_ALLOC_FAILED;
}
CAResult_t CADetachRequestMessage(const CAEndpoint_t *object, const CARequestInfo_t *request)
{
OIC_LOG(DEBUG, TAG, "IN");
VERIFY_NON_NULL(object, TAG, "object");
VERIFY_NON_NULL(request, TAG, "request");
// If max retransmission queue is reached, then don't handle new request
if (CA_MAX_RT_ARRAY_SIZE == u_arraylist_length(g_retransmissionContext.dataList))
{
OIC_LOG(ERROR, TAG, "max RT queue size reached!");
return CA_SEND_FAILED;
}
// allocate & initialize
CAData_t *data = (CAData_t *) OICCalloc(1, sizeof(CAData_t));
CA_MEMORY_ALLOC_CHECK(data);
// save data
data->type = request->isMulticast ? SEND_TYPE_MULTICAST : SEND_TYPE_UNICAST;
data->remoteEndpoint = object;
data->requestInfo = request;
data->responseInfo = NULL;
CAProcessData(data);
OICFree(data);
OIC_LOG(DEBUG, TAG, "OUT");
return CA_STATUS_OK;
// memory error label.
memory_error_exit:
OICFree(data);
OIC_LOG(DEBUG, TAG, "OUT");
return CA_MEMORY_ALLOC_FAILED;
}
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;
}
TEST(MarshalingAndUnMarshalingTest, BinToPstatJSONAndJSONToPstatBin)
{
const char* id = "ZGV2aWNlaWQAAAAAABhanw==";
OicSecPstat_t pstat;
pstat.cm = NORMAL;
pstat.commitHash = 0;
uint32_t outLen = 0;
unsigned char base64Buff[sizeof(((OicUuid_t*) 0)->id)] = {};
EXPECT_EQ(B64_OK, b64Decode(id, strlen(id), base64Buff, sizeof(base64Buff), &outLen));
memcpy(pstat.deviceID.id, base64Buff, outLen);
pstat.isOp = true;
pstat.tm = NORMAL;
pstat.om = SINGLE_SERVICE_CLIENT_DRIVEN;
pstat.smLen = 2;
pstat.sm = (OicSecDpom_t*)OICCalloc(pstat.smLen, sizeof(OicSecDpom_t));
pstat.sm[0] = SINGLE_SERVICE_CLIENT_DRIVEN;
pstat.sm[1] = SINGLE_SERVICE_SERVER_DRIVEN;
char* jsonPstat = BinToPstatJSON(&pstat);
printf("BinToJSON Dump:\n%s\n\n", jsonPstat);
EXPECT_TRUE(jsonPstat != NULL);
OicSecPstat_t *pstat1 = JSONToPstatBin(jsonPstat);
EXPECT_TRUE(pstat1 != NULL);
OICFree(pstat1->sm);
OICFree(pstat1);
OICFree(jsonPstat);
OICFree(pstat.sm);
}
static void CAReceiveMessage(int fd)
{
// #1. get remote device information from file descriptor.
size_t index = 0;
CATCPSessionInfo_t *svritem = CAGetSessionInfoFromFD(fd, &index);
if (!svritem)
{
OIC_LOG(ERROR, TAG, "there is no connection information in list");
return;
}
// #2. get already allocated memory size.
size_t bufSize = (svritem->totalDataLen == 0) ? TCP_MAX_HEADER_LEN : svritem->totalDataLen;
if (!svritem->recvData)
{
svritem->recvData = (unsigned char *) OICCalloc(1, bufSize);
if (!svritem->recvData)
{
OIC_LOG(ERROR, TAG, "out of memory");
CADisconnectTCPSession(svritem, index);
return;
}
}
// #3. receive data from remote device.
ssize_t recvLen = recv(fd, svritem->recvData + svritem->recvDataLen,
bufSize - svritem->recvDataLen, 0);
if (recvLen <= 0)
{
if(EWOULDBLOCK != errno)
{
OIC_LOG_V(ERROR, TAG, "Recvfrom failed %s", strerror(errno));
CADisconnectTCPSession(svritem, index);
}
return;
}
svritem->recvDataLen += recvLen;
// #4. get actual data length from coap over tcp header.
if (!svritem->totalDataLen)
{
coap_transport_type transport = coap_get_tcp_header_type_from_initbyte(
((unsigned char *) svritem->recvData)[0] >> 4);
size_t headerLen = coap_get_tcp_header_length_for_transport(transport);
if (svritem->recvDataLen >= headerLen)
{
svritem->totalDataLen = CAGetTotalLengthFromHeader(
(unsigned char *) svritem->recvData);
bufSize = svritem->totalDataLen;
unsigned char *newBuf = OICRealloc(svritem->recvData, bufSize);
if (!newBuf)
{
OIC_LOG(ERROR, TAG, "out of memory");
CADisconnectTCPSession(svritem, index);
return;
}
svritem->recvData = newBuf;
}
}
OCEntityHandlerResult getDoubleValueFromString (const char *str, double *outDouble)
{
size_t hexOutValSize = strlen(HexPrepend) + strlen(str) + 1;
char * hexOutVal = (char *) OICCalloc(1, hexOutValSize);
if(!hexOutVal)
{
return OC_EH_ERROR;
}
OICStrcpy(hexOutVal, hexOutValSize, HexPrepend);
OICStrcat(hexOutVal, hexOutValSize, str);
char *endPtr = NULL;
errno = 0;
double value = strtod(hexOutVal, &endPtr);
if(errno != 0 || *endPtr != 0 || value == HUGE_VALF || value == HUGE_VALL)
{
OICFree(hexOutVal);
return OC_EH_ERROR;
}
OICFree(hexOutVal);
*outDouble = value;
return OC_EH_OK;
}
static OCStackResult appendStringLL(OCStringLL **type, const unsigned char *value)
{
OCStringLL *temp= (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
if (!temp)
{
return OC_STACK_NO_MEMORY;
}
temp->value = OICStrdup((char *)value);
if (!temp->value)
{
return OC_STACK_NO_MEMORY;
}
temp->next = NULL;
if (!*type)
{
*type = temp;
}
else
{
OCStringLL *tmp = *type;
for (; tmp->next; tmp = tmp->next);
tmp->next = temp;
}
return OC_STACK_OK;
}
OCRDDiscoveryPayload *OCRDDiscoveryPayloadCreate(const char *deviceName, const char *id, int biasFactor)
{
OCRDDiscoveryPayload *discoveryPayload = (OCRDDiscoveryPayload *)OICCalloc(1, sizeof(OCRDDiscoveryPayload));
if (!discoveryPayload)
{
return NULL;
}
if (deviceName)
{
discoveryPayload->n.deviceName = OICStrdup(deviceName);
if (!discoveryPayload->n.deviceName)
{
OICFree(discoveryPayload);
return NULL;
}
}
if (id)
{
OICStrcpy((char*)discoveryPayload->di.id, MAX_IDENTITY_SIZE, id);
}
discoveryPayload->sel = biasFactor;
return discoveryPayload;
}
static CborError OCTagsCborToPayload(CborValue *tagsMap, OCTagsPayload **tagsPayload)
{
CborError cborFindResult = CborErrorOutOfMemory;
OCTagsPayload *tags = (OCTagsPayload *)OICCalloc(1, sizeof(OCTagsPayload));
VERIFY_PARAM_NON_NULL(TAG, tags, "Failed allocating tags");
cborFindResult = FindStringInMap(tagsMap, OC_RSRVD_DEVICE_NAME, &tags->n.deviceName);
VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding deviceName");
{
char *deviceId = NULL;
cborFindResult = FindStringInMap(tagsMap, OC_RSRVD_DEVICE_ID, &deviceId);
if (deviceId)
{
memcpy(tags->di.id, deviceId, strlen(deviceId));
OICFree(deviceId);
}
VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding deviceId");
}
cborFindResult = FindIntInMap(tagsMap, OC_RSRVD_DEVICE_TTL, &tags->ttl);
VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding ttl");
*tagsPayload = tags;
return cborFindResult;
exit:
OCFreeTagsResource(tags);
return cborFindResult;
}
OCTagsPayload* OCCopyTagsResources(const char *deviceName, const unsigned char *id, uint64_t ttl)
{
OCTagsPayload *tags = (OCTagsPayload *)OICCalloc(1, sizeof(OCTagsPayload));
if (!tags)
{
return NULL;
}
if (deviceName)
{
tags->n.deviceName = OICStrdup(deviceName);
if (!tags->n.deviceName)
{
goto memory_allocation_failed;
}
}
if (id)
{
OICStrcpy((char*)tags->di.id, MAX_IDENTITY_SIZE, (char *)id);
}
tags->ttl = ttl;
return tags;
memory_allocation_failed:
OIC_LOG(ERROR, TAG, "Memory allocation failed.");
OCFreeTagsResource(tags);
return NULL;
}
OCStackResult PDMGetOwnedDevices(OCUuidList_t **uuidList, size_t *numOfDevices)
{
CHECK_PDM_INIT(TAG);
if (NULL != *uuidList)
{
OC_LOG(ERROR, TAG, "Not null list will cause memory leak");
return OC_STACK_INVALID_PARAM;
}
sqlite3_stmt *stmt = 0;
int res = 0;
res = sqlite3_prepare_v2(g_db, PDM_SQLITE_LIST_ALL_UUID,
strlen(PDM_SQLITE_LIST_ALL_UUID) + 1, &stmt, NULL);
PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
int counter = 0;
while (SQLITE_ROW == sqlite3_step(stmt))
{
const void *ptr = sqlite3_column_blob(stmt, PDM_FIRST_INDEX);
OicUuid_t *uid = (OicUuid_t *)ptr;
OCUuidList_t *temp = (OCUuidList_t *) OICCalloc(1,sizeof(OCUuidList_t));
if (NULL == temp)
{
OC_LOG_V(ERROR, TAG, "Memory allocation problem");
sqlite3_finalize(stmt);
return OC_STACK_NO_MEMORY;
}
memcpy(&temp->dev.id, uid->id, UUID_LENGTH);
LL_PREPEND(*uuidList,temp);
++counter;
}
*numOfDevices = counter;
sqlite3_finalize(stmt);
return OC_STACK_OK;
}
OCStackResult UpdateAmsMgrContext(PEContext_t *context, const CAEndpoint_t *endpoint,
const CARequestInfo_t *requestInfo)
{
OCStackResult ret = OC_STACK_ERROR;
//The AmsMgr context endpoint and requestInfo will be free from ,
//AmsMgrAclReqCallback function
if(context->amsMgrContext->endpoint)
{
OICFree(context->amsMgrContext->endpoint);
context->amsMgrContext->endpoint = NULL;
}
context->amsMgrContext->endpoint = (CAEndpoint_t *)OICCalloc(1, sizeof(CAEndpoint_t ));
VERIFY_NON_NULL(TAG, context->amsMgrContext->endpoint, ERROR);
*context->amsMgrContext->endpoint = *endpoint;
if(context->amsMgrContext->requestInfo)
{
FreeCARequestInfo(context->amsMgrContext->requestInfo);
context->amsMgrContext->requestInfo = NULL;
}
context->amsMgrContext->requestInfo = CACloneRequestInfo(requestInfo);
VERIFY_NON_NULL(TAG, context->amsMgrContext->requestInfo, ERROR);
ret = OC_STACK_OK;
exit:
return ret;
}
/**
* Add a server response to the server response list
*
* @param response initialized server response that is created by this function
* @param requestHandle - handle of the response
*
* @return
* OCStackResult
*/
static OCStackResult AddServerResponse (OCServerResponse ** response, OCRequestHandle requestHandle)
{
if (!response)
{
return OC_STACK_INVALID_PARAM;
}
OCServerResponse * serverResponse = NULL;
serverResponse = (OCServerResponse *) OICCalloc(1, sizeof(OCServerResponse));
VERIFY_NON_NULL(serverResponse);
serverResponse->payload = NULL;
serverResponse->requestHandle = requestHandle;
*response = serverResponse;
OIC_LOG(INFO, TAG, "Server Response Added!!");
LL_APPEND (serverResponseList, serverResponse);
return OC_STACK_OK;
exit:
if (serverResponse)
{
OICFree(serverResponse);
serverResponse = NULL;
}
*response = NULL;
return OC_STACK_NO_MEMORY;
}
/**
* Callback handler of default ACL provisioning.
*
* @param[in] ctx ctx value passed to callback from calling function.
* @param[in] UNUSED handle to an invocation
* @param[in] clientResponse Response from queries to remote servers.
* @return OC_STACK_DELETE_TRANSACTION to delete the transaction
* and OC_STACK_KEEP_TRANSACTION to keep it.
*/
static OCStackApplicationResult ProvisionDefaultACLCB(void *ctx, OCDoHandle UNUSED,
OCClientResponse *clientResponse)
{
OC_LOG_V(INFO, TAG, "IN ProvisionDefaultACLCB.");
VERIFY_NON_NULL(TAG, clientResponse, ERROR);
VERIFY_NON_NULL(TAG, ctx, ERROR);
OTMContext_t* otmCtx = (OTMContext_t*) ctx;
(void)UNUSED;
if (OC_STACK_RESOURCE_CREATED == clientResponse->result)
{
OC_LOG_V(INFO, TAG, "Staring commit hash task.");
// TODO hash currently have fixed value 0.
uint16_t aclHash = 0;
otmCtx->selectedDeviceInfo->pstat->commitHash = aclHash;
otmCtx->selectedDeviceInfo->pstat->tm = NORMAL;
OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
if(!secPayload)
{
OC_LOG(ERROR, TAG, "Failed to memory allocation");
return OC_STACK_NO_MEMORY;
}
secPayload->base.type = PAYLOAD_TYPE_SECURITY;
secPayload->securityData = BinToPstatJSON(otmCtx->selectedDeviceInfo->pstat);
if (NULL == secPayload->securityData)
{
OICFree(secPayload);
SetResult(otmCtx, OC_STACK_INVALID_JSON);
return OC_STACK_DELETE_TRANSACTION;
}
OC_LOG_V(INFO, TAG, "Created payload for commit hash: %s",secPayload->securityData);
char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
if(!PMGenerateQuery(true,
otmCtx->selectedDeviceInfo->endpoint.addr,
otmCtx->selectedDeviceInfo->securePort,
otmCtx->selectedDeviceInfo->connType,
query, sizeof(query), OIC_RSRC_PSTAT_URI))
{
OC_LOG(ERROR, TAG, "ProvisionDefaultACLCB : Failed to generate query");
return OC_STACK_ERROR;
}
OC_LOG_V(DEBUG, TAG, "Query=%s", query);
OCCallbackData cbData = {.context=NULL, .cb=NULL, .cd=NULL};
cbData.cb = &FinalizeProvisioningCB;
cbData.context = (void*)otmCtx;
cbData.cd = NULL;
OCStackResult ret = OCDoResource(NULL, OC_REST_PUT, query, 0, (OCPayload*)secPayload,
otmCtx->selectedDeviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0);
OC_LOG_V(INFO, TAG, "OCDoResource returned: %d",ret);
if (ret != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack resource error");
SetResult(otmCtx, ret);
}
}
OCTagsPayload* OCCopyTagsResources(const char *deviceName, const unsigned char *id, const char *baseURI,
uint8_t bitmap, uint16_t port, uint8_t ins, const char *rts,const char *drel, uint32_t ttl)
{
OCTagsPayload *tags = (OCTagsPayload *)OICCalloc(1, sizeof(OCTagsPayload));
if (!tags)
{
return NULL;
}
if (deviceName)
{
tags->n.deviceName = OICStrdup(deviceName);
if (!tags->n.deviceName)
{
goto memory_allocation_failed;
}
}
if (id)
{
OICStrcpy((char*)tags->di.id, MAX_IDENTITY_SIZE, (char *)id);
if (!tags->di.id)
{
goto memory_allocation_failed;
}
}
if (baseURI)
{
tags->baseURI = OICStrdup(baseURI);
if (!tags->baseURI)
{
goto memory_allocation_failed;
}
}
tags->bitmap = bitmap;
tags->port = port;
tags->ins = ins;
if (rts)
{
tags->rts = OICStrdup(rts);
if (!tags->rts)
{
goto memory_allocation_failed;
}
}
if (drel)
{
tags->drel = OICStrdup(drel);
if (!tags->drel)
{
goto memory_allocation_failed;
}
}
tags->ttl = ttl;
return tags;
memory_allocation_failed:
OC_LOG(ERROR, TAG, "Memory allocation failed.");
OCFreeTagsResource(tags);
return NULL;
}
static OCStackResult CreateStringLL(uint8_t numElements, OCResourceHandle handle,
const char* (*getValue)(OCResourceHandle handle, uint8_t i),
OCStringLL **stringLL)
{
for (uint8_t i = 0; i < numElements; ++i)
{
const char *value = getValue(handle, i);
OIC_LOG_V(ERROR, TAG, "value: %s", value);
if (!*stringLL)
{
*stringLL = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL));
if (!*stringLL)
{
OIC_LOG(ERROR, TAG, "Failed allocating memory.");
return OC_STACK_NO_MEMORY;
}
(*stringLL)->value = OICStrdup(value);
if (!(*stringLL)->value)
{
OIC_LOG(ERROR, TAG, "Failed copying to OCStringLL.");
return OC_STACK_NO_MEMORY;
}
}
else
{
OCStringLL *cur = *stringLL;
while (cur->next)
{
cur = cur->next;
}
cur->next = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL));
if (!cur->next)
{
OIC_LOG(ERROR, TAG, "Failed allocating memory.");
return OC_STACK_NO_MEMORY;
}
cur->next->value = OICStrdup(value);
if (!cur->next->value)
{
OIC_LOG(ERROR, TAG, "Failed copying to OCStringLL.");
return OC_STACK_NO_MEMORY;
}
}
}
return OC_STACK_OK;
}
void CABleGattDescriptorDiscoveredCb(int result, unsigned char format, int total,
bt_gatt_attribute_h descriptor,
bt_gatt_attribute_h characteristic, void *userData)
{
OIC_LOG(DEBUG, TZ_BLE_CLIENT_TAG, "IN");
stGattCharDescriptor_t *stTemp = (stGattCharDescriptor_t *)OICCalloc(1, sizeof(
stGattCharDescriptor_t));
VERIFY_NON_NULL_VOID(stTemp, TZ_BLE_CLIENT_TAG, "malloc failed!");
stTemp->desc = (uint8_t *)OICMalloc(total);
if (NULL == stTemp->desc)
{
OIC_LOG(ERROR, TZ_BLE_CLIENT_TAG, "malloc failed");
OICFree(stTemp);
return;
}
memcpy(stTemp->desc, descriptor, total);
OIC_LOG_V(DEBUG, TZ_BLE_CLIENT_TAG, "result[%d] format[%d] total[%d]", result, format, total);
OIC_LOG_V(DEBUG, TZ_BLE_CLIENT_TAG, "characteristic [%s]", (const char *) characteristic);
bt_gatt_clone_attribute_handle(&(stTemp->characteristic), characteristic);
stTemp->total = total;
ca_mutex_lock(g_bleClientThreadPoolMutex);
if (NULL == g_bleClientThreadPool)
{
OIC_LOG(ERROR, TZ_BLE_CLIENT_TAG, "g_bleClientThreadPool is NULL");
bt_gatt_destroy_attribute_handle(stTemp->characteristic);
OICFree(stTemp->desc);
OICFree(stTemp);
ca_mutex_unlock(g_bleClientThreadPoolMutex);
return;
}
CAResult_t ret = ca_thread_pool_add_task(g_bleClientThreadPool,
CASetCharacteristicDescriptorValueThread,
stTemp);
if (CA_STATUS_OK != ret)
{
OIC_LOG(ERROR, TZ_BLE_CLIENT_TAG, "ca_thread_pool_add_task failed");
bt_gatt_destroy_attribute_handle(stTemp->characteristic);
OICFree(stTemp->desc);
OICFree(stTemp);
ca_mutex_unlock(g_bleClientThreadPoolMutex);
return;
}
OIC_LOG(DEBUG, TZ_BLE_CLIENT_TAG,
"LE Client initialization flow complete");
ca_mutex_unlock(g_bleClientThreadPoolMutex);
OIC_LOG(DEBUG, TZ_BLE_CLIENT_TAG, "OUT");
}
static OCStackResult OCParseDevicePayload(OCPayload **outPayload, CborValue *rootValue)
{
OCStackResult ret = OC_STACK_INVALID_PARAM;
CborError err = CborNoError;
OCDevicePayload *out = NULL;
VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid param outPayload");
VERIFY_PARAM_NON_NULL(TAG, rootValue, "Invalid param rootValue");
*outPayload = NULL;
out = (OCDevicePayload *)OICCalloc(1, sizeof(OCDevicePayload));
VERIFY_PARAM_NON_NULL(TAG, out, "Failed allocating device payload")
out->base.type = PAYLOAD_TYPE_DEVICE;
ret = OC_STACK_MALFORMED_RESPONSE;
if (cbor_value_is_map(rootValue))
{
// Device ID
size_t len = 0;
CborValue curVal;
err = cbor_value_map_find_value(rootValue, OC_RSRVD_DEVICE_ID, &curVal);
if (cbor_value_is_valid(&curVal))
{
err = cbor_value_dup_byte_string(&curVal, &out->sid, &len, NULL);
VERIFY_CBOR_SUCCESS(TAG, err, "to find device id in device payload");
}
// Device Name
err = cbor_value_map_find_value(rootValue, OC_RSRVD_DEVICE_NAME, &curVal);
if (cbor_value_is_valid(&curVal))
{
err = cbor_value_dup_text_string(&curVal, &out->deviceName, &len, NULL);
VERIFY_CBOR_SUCCESS(TAG, err, "to find device name in device payload");
}
// Device Spec Version
err = cbor_value_map_find_value(rootValue, OC_RSRVD_SPEC_VERSION, &curVal);
if (cbor_value_is_valid(&curVal))
{
err = cbor_value_dup_text_string(&curVal, &out->specVersion, &len, NULL);
VERIFY_CBOR_SUCCESS(TAG, err, "to find spec version in device payload");
}
// Data Model Version
err = cbor_value_map_find_value(rootValue, OC_RSRVD_DATA_MODEL_VERSION, &curVal);
if (cbor_value_is_valid(&curVal))
{
err = cbor_value_dup_text_string(&curVal, &out->dataModelVersion, &len, NULL);
VERIFY_CBOR_SUCCESS(TAG, err, "to find data model version in device payload");
}
err = cbor_value_advance(rootValue);
VERIFY_CBOR_SUCCESS(TAG, err, "to advance device payload");
*outPayload = (OCPayload *)out;
return OC_STACK_OK;
}
exit:
OCDevicePayloadDestroy(out);
return ret;
}
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");
}
OCRDPayload *OCRDPayloadCreate()
{
OCRDPayload *rdPayload = (OCRDPayload *)OICCalloc(1, sizeof(OCRDPayload));
VERIFY_PARAM_NON_NULL(TAG, rdPayload, "Failed allocating rdPayload");
rdPayload->base.type = PAYLOAD_TYPE_RD;
exit:
return rdPayload;
}
static OCStackResult OCParsePresencePayload(OCPayload **outPayload, CborValue *rootValue)
{
OCStackResult ret = OC_STACK_INVALID_PARAM;
OCPresencePayload *payload = NULL;
VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid Parameter outPayload");
*outPayload = NULL;
payload = (OCPresencePayload *)OICCalloc(1, sizeof(OCPresencePayload));
ret = OC_STACK_NO_MEMORY;
VERIFY_PARAM_NON_NULL(TAG, payload, "Failed allocating presence payload");
payload->base.type = PAYLOAD_TYPE_PRESENCE;
ret = OC_STACK_MALFORMED_RESPONSE;
if (cbor_value_is_map(rootValue))
{
CborValue curVal;
// Sequence Number
CborError err = cbor_value_map_find_value(rootValue, OC_RSRVD_NONCE, &curVal);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding nonce tag");
err = cbor_value_get_uint64(&curVal, (uint64_t *)&payload->sequenceNumber);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding nonce value");
// Max Age
err = cbor_value_map_find_value(rootValue, OC_RSRVD_TTL, &curVal);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding ttl tag");
err = cbor_value_get_uint64(&curVal, (uint64_t *)&payload->maxAge);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding ttl value");
// Trigger
err = cbor_value_map_find_value(rootValue, OC_RSRVD_TRIGGER, &curVal);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding trigger tag");
err = cbor_value_get_simple_type(&curVal, (uint8_t *)&payload->trigger);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding trigger value");
// Resource type name
err = cbor_value_map_find_value(rootValue, OC_RSRVD_RESOURCE_TYPE, &curVal);
if (cbor_value_is_valid(&curVal))
{
size_t len = 0;
err = cbor_value_dup_text_string(&curVal, &payload->resourceType, &len, NULL);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding resource type value");
}
err = cbor_value_advance(rootValue);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed advancing root value");
*outPayload = (OCPayload *)payload;
return OC_STACK_OK;
}
exit:
OIC_LOG(ERROR, TAG, "CBOR error Parse Presence Payload");
OCPresencePayloadDestroy(payload);
return ret;
}
OCStackResult CHPGetHttpOption(const OCHeaderOption* option, HttpHeaderOption_t** httpOption)
{
OIC_LOG_V(DEBUG, TAG, "%s IN", __func__);
if (!option)
{
OIC_LOG(ERROR, TAG, "option is NULL");
return OC_STACK_INVALID_PARAM;
}
*httpOption = (HttpHeaderOption_t *)OICCalloc(1, sizeof(HttpHeaderOption_t));
if (NULL == *httpOption)
{
OIC_LOG(ERROR, TAG, "Memory allocation failed");
return OC_STACK_NO_MEMORY;
}
switch (option->optionID)
{
case COAP_OPTION_ACCEPT:
OICStrcpy((*httpOption)->optionName, sizeof((*httpOption)->optionName),
HTTP_OPTION_ACCEPT);
break;
case COAP_OPTION_IF_MATCH:
OICStrcpy((*httpOption)->optionName, sizeof((*httpOption)->optionName),
HTTP_OPTION_IF_MATCH);
break;
case COAP_OPTION_IF_NONE_MATCH:
OICStrcpy((*httpOption)->optionName, sizeof((*httpOption)->optionName),
HTTP_OPTION_IF_NONE_MATCH);
break;
case COAP_OPTION_ETAG:
OICStrcpy((*httpOption)->optionName, sizeof((*httpOption)->optionName),
HTTP_OPTION_ETAG);
break;
case COAP_OPTION_CONTENT_TYPE:
OICStrcpy((*httpOption)->optionName, sizeof((*httpOption)->optionName),
HTTP_OPTION_CONTENT_TYPE);
break;
default:
OIC_LOG_V(INFO, TAG, "No Matching found for the ID %d", option->optionID);
}
if ('\0' == (*httpOption)->optionName[0])
{
OIC_LOG(ERROR, TAG, "No matching is found");
OICFree(*httpOption);
return OC_STACK_INVALID_OPTION;
}
(*httpOption)->optionLength = option->optionLength < sizeof((*httpOption)->optionData) ?
option->optionLength : sizeof((*httpOption)->optionData);
memcpy((*httpOption)->optionData, option->optionData, (*httpOption)->optionLength);
OIC_LOG_V(DEBUG, TAG, "%s OUT", __func__);
return OC_STACK_OK;
}
