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; }