ProvisioningInfo *PrepareProvisioingStatusCB(OCClientResponse *clientResponse, ProvStatus provStatus) { ProvisioningInfo *provInfo = (ProvisioningInfo *) OICCalloc(1, sizeof(ProvisioningInfo)); if (provInfo == NULL) { OIC_LOG_V(ERROR, ES_PROV_TAG, "Failed to allocate memory"); return NULL; } OCDevAddr *devAddr = (OCDevAddr *) OICCalloc(1, sizeof(OCDevAddr)); if (devAddr == NULL) { OIC_LOG_V(ERROR, ES_PROV_TAG, "Failed to allocate memory"); OICFree(provInfo); return NULL; } OICStrcpy(devAddr->addr, sizeof(devAddr->addr), clientResponse->addr->addr); devAddr->port = clientResponse->addr->port; provInfo->provDeviceInfo.addr = devAddr; provInfo->provStatus = provStatus; return provInfo; }
CAResult_t CASendMulticastData(const CAEndpoint_t *endpoint, const void *data, uint32_t length) { u_arraylist_t *list = CAGetSelectedNetworkList(); if (!list) { OIC_LOG(DEBUG, TAG, "No selected network"); return CA_SEND_FAILED; } CATransportFlags_t requestedAdapter = endpoint->adapter ? endpoint->adapter : CA_ALL_ADAPTERS; size_t selectedLength = u_arraylist_length(list); for (size_t i = 0; i < selectedLength; i++) { void* ptrType = u_arraylist_get(list, i); if(ptrType == NULL) { continue; } CATransportAdapter_t connType = *(CATransportAdapter_t *)ptrType; if ((connType & requestedAdapter) == 0) { continue; } int index = CAGetAdapterIndex(connType); if (0 > index) { OIC_LOG(DEBUG, TAG, "unknown connectivity type!"); continue; } uint32_t sentDataLen = 0; if (g_adapterHandler[index].sendDataToAll != NULL) { void *payload = (void *) OICMalloc(length); if (!payload) { OIC_LOG(ERROR, TAG, "Out of memory!"); return CA_MEMORY_ALLOC_FAILED; } memcpy(payload, data, length); sentDataLen = g_adapterHandler[index].sendDataToAll(endpoint, payload, length); OICFree(payload); } if (sentDataLen != length) { OIC_LOG(ERROR, TAG, "sendDataToAll failed! Error will be reported from adapter"); #ifdef SINGLE_THREAD //in case of single thread, no error handler. Report error immediately return CA_SEND_FAILED; #endif } } return CA_STATUS_OK; }
void OCFreeLinksResource(OCLinksPayload *payload) { if (!payload) { return; } OICFree(payload->href); OCFreeOCStringLL(payload->rt); OCFreeOCStringLL(payload->itf); OICFree(payload->rel); OICFree(payload->title); OICFree(payload->uri); OCFreeOCStringLL(payload->mt); OCFreeLinksResource(payload->next); OICFree(payload); }
void OCFreeLinksResource(OCLinksPayload *links) { if (!links) { return; } OICFree(links->href); OICFree(links->rel); OCFreeOCStringLL(links->rt); OCFreeOCStringLL(links->itf); OICFree(links->title); OICFree(links->anchor); OCFreeOCStringLL(links->type); OCFreeLinksResource(links->next); OICFree(links); }
CAResult_t u_linklist_free(u_linklist_t **linklist) { VERIFY_NON_NULL(linklist, TAG, "linklist is null"); if (!(*linklist)) { OIC_LOG(DEBUG, TAG, "List is already Empty"); return CA_STATUS_OK; } u_linklist_data_t *free_node=NULL; while((*linklist)->size) { free_node = (*linklist)->list; (*linklist)->list = (*linklist)->list->next; if(free_node != NULL) { OICFree(free_node); free_node=NULL; } (*linklist)->size -= 1; } *linklist=NULL; return CA_STATUS_OK; }
void CAEDRNativeRemoveAllDeviceSocket(JNIEnv *env) { OIC_LOG(DEBUG, TAG, "CANativeRemoveAllDeviceObjsList"); if (!g_deviceObjectList) { OIC_LOG(ERROR, TAG, "gdeviceObjectList is null"); return; } jint length = u_arraylist_length(g_deviceStateList); for (jint index = 0; index < length; index++) { jobject jarrayObj = (jobject) u_arraylist_get(g_deviceObjectList, index); if (!jarrayObj) { OIC_LOG(ERROR, TAG, "jarrayObj is null"); return; } (*env)->DeleteGlobalRef(env, jarrayObj); } OICFree(g_deviceObjectList); g_deviceObjectList = NULL; return; }
void DeleteSVCList(OicSecSvc_t* svc) { if (svc) { OicSecSvc_t *svcTmp1 = NULL, *svcTmp2 = NULL; LL_FOREACH_SAFE(svc, svcTmp1, svcTmp2) { LL_DELETE(svc, svcTmp1); // Clean Owners OICFree(svcTmp1->owners); // Clean SVC node itself OICFree(svcTmp1); } }
CAResult_t CABleGattDiscoverCharacteristics(bt_gatt_attribute_h service, const char *remoteAddress) { OIC_LOG(DEBUG, TZ_BLE_CLIENT_TAG, "IN"); VERIFY_NON_NULL_RET(service, TZ_BLE_CLIENT_TAG, "service is NULL", CA_STATUS_FAILED); VERIFY_NON_NULL_RET(remoteAddress, TZ_BLE_CLIENT_TAG, "remoteAddress is NULL", CA_STATUS_FAILED); char *addr = OICStrdup(remoteAddress); VERIFY_NON_NULL_RET(addr, TZ_BLE_CLIENT_TAG, "Malloc failed", CA_STATUS_FAILED); int32_t ret = bt_gatt_discover_characteristics(service, CABleGattCharacteristicsDiscoveredCb, (void *)addr); // addr will be freed in callback. if (BT_ERROR_NONE != ret) { OIC_LOG_V(ERROR, TZ_BLE_CLIENT_TAG, "bt_gatt_discover_characteristics failed with error [%d]", ret); OICFree(addr); return CA_STATUS_FAILED; } OIC_LOG(DEBUG, TZ_BLE_CLIENT_TAG, "OUT"); return CA_STATUS_OK; }
void OCPayloadDestroy(OCPayload* payload) { if(!payload) { return; } switch(payload->type) { case PAYLOAD_TYPE_REPRESENTATION: OCRepPayloadDestroy((OCRepPayload*)payload); break; case PAYLOAD_TYPE_DISCOVERY: OCDiscoveryPayloadDestroy((OCDiscoveryPayload*)payload); break; case PAYLOAD_TYPE_DEVICE: OCDevicePayloadDestroy((OCDevicePayload*)payload); break; case PAYLOAD_TYPE_PLATFORM: OCPlatformPayloadDestroy((OCPlatformPayload*)payload); break; case PAYLOAD_TYPE_PRESENCE: OCPresencePayloadDestroy((OCPresencePayload*)payload); break; case PAYLOAD_TYPE_SECURITY: OCSecurityPayloadDestroy((OCSecurityPayload*)payload); break; default: OC_LOG_V(ERROR, TAG, "Unsupported payload type in destroy: %d", payload->type); OICFree(payload); break; } }
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 CABleGattDiscoverServices(const char *remoteAddress) { OIC_LOG(DEBUG, TZ_BLE_CLIENT_TAG, "IN"); VERIFY_NON_NULL_RET(remoteAddress, TZ_BLE_CLIENT_TAG, "remote address is NULL", CA_STATUS_FAILED); char *addr = OICStrdup(remoteAddress); VERIFY_NON_NULL_RET(addr, TZ_BLE_CLIENT_TAG, "Malloc failed", CA_STATUS_FAILED); int32_t ret = bt_gatt_foreach_primary_services(remoteAddress, CABleGattPrimaryServiceCb, (void *)addr); // addr memory will be free in callback. if (BT_ERROR_NONE != ret) { OIC_LOG_V(ERROR, TZ_BLE_CLIENT_TAG, "bt_gatt_foreach_primary_services Failed with ret value [%d] ", ret); OICFree(addr); return CA_STATUS_FAILED; } else { OIC_LOG_V(DEBUG, TZ_BLE_CLIENT_TAG, "bt_gatt_foreach_primary_services success for address [%s]", remoteAddress); } OIC_LOG(DEBUG, TZ_BLE_CLIENT_TAG, "OUT"); return CA_STATUS_OK; }
void CAEDRNativeRemoveDevice(const char *remoteAddress) { OIC_LOG(DEBUG, TAG, "CAEDRNativeRemoveDeviceforStateList"); if(!g_deviceStateList) { OIC_LOG(ERROR, TAG, "[EDR][Native] gdeviceStateList is null"); return; } if (!remoteAddress) { OIC_LOG(ERROR, TAG, "[EDR][Native] remoteAddress is null"); return; } jint index; for (index = 0; index < u_arraylist_length(g_deviceStateList); index++) { state_t* state = (state_t*) u_arraylist_get(g_deviceStateList, index); if(!state) { OIC_LOG(DEBUG, TAG, "[EDR][Native] state_t object is null"); continue; } if(!strcmp(state->address, remoteAddress)) { OIC_LOG_V(DEBUG, TAG, "[EDR][Native] remove state : %s", remoteAddress); OICFree(state); CAEDRReorderingDeviceList(index); break; } } return; }
u_queue_message_t *u_queue_get_element(u_queue_t *queue) { u_queue_element *element = NULL; u_queue_message_t *message = NULL; if (NULL == queue) { OIC_LOG(DEBUG, TAG, "QueueAddElement FAIL, Invalid Queue"); return NULL; } element = queue->element; if (NULL == element) { return NULL; } queue->element = element->next;; queue->count--; message = element->message; OICFree(element); return message; }
static OCStackResult OCParseSecurityPayload(OCPayload** outPayload, CborValue* rootValue) { OCStackResult ret = OC_STACK_MALFORMED_RESPONSE; CborError err; char *securityData = NULL; VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid parameter"); VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid cbor"); CborValue strVal; err = cbor_value_enter_container(rootValue, &strVal); VERIFY_CBOR_SUCCESS(TAG, err, "Failed entering container"); if (cbor_value_is_text_string(&strVal)) { size_t len = 0; err = cbor_value_dup_text_string(&strVal, &securityData, &len, NULL); VERIFY_CBOR_SUCCESS(TAG, err, "Failed reading security data"); *outPayload = (OCPayload *)OCSecurityPayloadCreate(securityData); VERIFY_PARAM_NON_NULL(TAG, *outPayload, "Invalid cbor"); ret = OC_STACK_OK; } exit: OICFree(securityData); return ret; }
void CAIPTerminateServer() { OIC_LOG(DEBUG, IP_SERVER_TAG, "IN"); ca_mutex_lock(g_mutexAdapterServerContext); if (!g_adapterIPServerContext) { OIC_LOG(ERROR, IP_SERVER_TAG, "g_adapterIPServerContext NULL"); ca_mutex_unlock(g_mutexAdapterServerContext); return; } OICFree(g_adapterIPServerContext); g_adapterIPServerContext = NULL; ca_mutex_unlock(g_mutexAdapterServerContext); ca_mutex_lock(g_mutexServerInfoList); CAClearServerInfoList(g_serverInfoList); g_serverInfoList = NULL; ca_mutex_unlock(g_mutexServerInfoList); // Destroy mutex CAIPServerDestroyMutex(); OIC_LOG(DEBUG, IP_SERVER_TAG, "OUT"); }
/** * Initialize DOXM resource by loading data from persistent storage. * * @retval OC_STACK_OK for Success, otherwise some error value */ OCStackResult InitDoxmResource() { OCStackResult ret = OC_STACK_ERROR; //Read DOXM resource from PS char* jsonSVRDatabase = GetSVRDatabase(); if(jsonSVRDatabase) { //Convert JSON DOXM into binary format gDoxm = JSONToDoxmBin(jsonSVRDatabase); } /* * If SVR database in persistent storage got corrupted or * is not available for some reason, a default doxm is created * which allows user to initiate doxm provisioning again. */ if(!jsonSVRDatabase || !gDoxm) { gDoxm = GetDoxmDefault(); } CheckDeviceID(); //Instantiate 'oic.sec.doxm' ret = CreateDoxmResource(); OICFree(jsonSVRDatabase); return ret; }
CAResult_t CAInitLEGattServer() { OIC_LOG(DEBUG, TAG, "IN"); int ret = bt_gatt_server_initialize(); if (0 != ret) { OIC_LOG_V(ERROR, TAG, "bt_gatt_server_initialize failed with ret[%s]", CALEGetErrorMsg(ret)); return CA_STATUS_FAILED; } bt_gatt_server_h server; ret = bt_gatt_server_create(&server); if (0 != ret) { OIC_LOG_V(ERROR, TAG, "bt_gatt_server_create failed with ret[%s]", CALEGetErrorMsg(ret)); return CA_STATUS_FAILED; } if (NULL != g_gattServer) { OICFree(g_gattServer); g_gattServer = NULL; } g_gattServer = server; OIC_LOG(DEBUG, TAG, "OUT"); return CA_STATUS_OK; }
bool ca_mutex_free(ca_mutex mutex) { bool bRet=false; ca_mutex_internal *mutexInfo = (ca_mutex_internal*) mutex; if (mutexInfo) { int ret = pthread_mutex_destroy(&mutexInfo->mutex); if (0 == ret) { OICFree(mutexInfo); bRet=true; } else { OIC_LOG_V(ERROR, TAG, "%s Failed to free mutex !", __func__); } } else { OIC_LOG_V(ERROR, TAG, "%s Invalid mutex !", __func__); } return bRet; }
/** * Initialize pstat resource by loading data from persistent storage. * * @retval OC_STACK_OK for Success, otherwise some error value */ OCStackResult InitPstatResource() { OCStackResult ret = OC_STACK_ERROR; // Read Pstat resource from PS char* jsonSVRDatabase = GetSVRDatabase(); if (jsonSVRDatabase) { // Convert JSON Pstat into binary format gPstat = JSONToPstatBin(jsonSVRDatabase, true); } /* * If SVR database in persistent storage got corrupted or * is not available for some reason, a default pstat is created * which allows user to initiate pstat provisioning again. */ if(!jsonSVRDatabase || !gPstat) { gPstat = GetPstatDefault(); } // Instantiate 'oic.sec.pstat' ret = CreatePstatResource(); OICFree(jsonSVRDatabase); return ret; }
void CAIPErrorHandler (const CAEndpoint_t *endpoint, const void *data, uint32_t dataLength, CAResult_t result) { OIC_LOG(DEBUG, TAG, "IN"); VERIFY_NON_NULL_VOID(endpoint, TAG, "endpoint is NULL"); VERIFY_NON_NULL_VOID(data, TAG, "data is NULL"); void *buf = (void*)OICMalloc(sizeof(char) * dataLength); if (!buf) { OIC_LOG(ERROR, TAG, "Memory Allocation failed!"); return; } memcpy(buf, data, dataLength); if (g_errorCallback) { g_errorCallback(endpoint, buf, dataLength, result); } else { OICFree(buf); } OIC_LOG(DEBUG, TAG, "OUT"); }
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; }
// passthrough function to convert the pthreads call to a u_thread_func call void* ca_thread_pool_pthreads_delegate(void* data) { ca_thread_pool_callback_info_t* info = (ca_thread_pool_callback_info_t*)data; info->func(info->data); OICFree(info); return NULL; }
void CAIPTerminateNetworkMonitor() { OIC_LOG(DEBUG, IP_MONITOR_TAG, "IN"); ca_mutex_lock(g_networkMonitorContextMutex); g_networkMonitorContext->threadPool = NULL; CAClearNetInterfaceInfoList(g_networkMonitorContext->netInterfaceList); g_networkMonitorContext->netInterfaceList = NULL; g_networkMonitorContext->nwConnectivityStatus = CA_INTERFACE_DOWN; g_networkMonitorContext->networkChangeCb = NULL; g_networkMonitorContext->threadPool = NULL; OICFree(g_networkMonitorContext); g_networkMonitorContext = NULL; ca_mutex_unlock(g_networkMonitorContextMutex); ca_mutex_lock(g_stopNetworkMonitorMutex); g_stopNetworkMonitor = true; ca_mutex_unlock(g_stopNetworkMonitorMutex); CADestroyNetworkMonitorMutexes(); OIC_LOG(DEBUG, IP_MONITOR_TAG, "OUT"); }
/** * 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; }
static void CARemoveNetworkMonitorList(int ifiindex) { VERIFY_NON_NULL_VOID(g_netInterfaceList, TAG, "g_netInterfaceList is NULL"); ca_mutex_lock(g_networkMonitorContextMutex); uint32_t list_length = u_arraylist_length(g_netInterfaceList); for (uint32_t list_index = 0; list_index < list_length; list_index++) { CAInterface_t *removedifitem = (CAInterface_t *) u_arraylist_get( g_netInterfaceList, list_index); if (removedifitem && removedifitem->index == ifiindex) { if (u_arraylist_remove(g_netInterfaceList, list_index)) { OICFree(removedifitem); ca_mutex_unlock(g_networkMonitorContextMutex); return; } continue; } } ca_mutex_unlock(g_networkMonitorContextMutex); return; }
CAResult_t CAIPInitializeQueueHandles() { // Check if the message queue is already initialized if (g_sendQueueHandle) { OIC_LOG(DEBUG, TAG, "send queue handle is already initialized!"); return CA_STATUS_OK; } // Create send message queue g_sendQueueHandle = OICMalloc(sizeof(CAQueueingThread_t)); if (!g_sendQueueHandle) { OIC_LOG(ERROR, TAG, "Memory allocation failed!"); return CA_MEMORY_ALLOC_FAILED; } if (CA_STATUS_OK != CAQueueingThreadInitialize(g_sendQueueHandle, (const ca_thread_pool_t)caglobals.ip.threadpool, CAIPSendDataThread, CADataDestroyer)) { OIC_LOG(ERROR, TAG, "Failed to Initialize send queue thread"); OICFree(g_sendQueueHandle); g_sendQueueHandle = NULL; return CA_STATUS_FAILED; } return CA_STATUS_OK; }
static void CARemovePeerFromPeerInfoList(const char * addr, uint16_t port) { if (NULL == addr || 0 >= port) { OIC_LOG(ERROR, NET_DTLS_TAG, "CADTLSGetPeerPSKId invalid parameters"); return; } uint32_t list_length = u_arraylist_length(g_caDtlsContext->peerInfoList); for (uint32_t list_index = 0; list_index < list_length; list_index++) { CAEndpoint_t *peerInfo = (CAEndpoint_t *)u_arraylist_get( g_caDtlsContext->peerInfoList,list_index); if (NULL == peerInfo) { continue; } if((0 == strncmp(addr, peerInfo->addr, MAX_ADDR_STR_SIZE_CA)) && (port == peerInfo->port)) { OICFree(u_arraylist_remove(g_caDtlsContext->peerInfoList, list_index)); return; } } }
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; }
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; }
bool ClearMemory() { OIC_LOG(DEBUG, ES_PROV_TAG, "thread_pool_add_task of FindProvisioningResource failed"); OICFree(netProvInfo); return true; }