//-------------------------------------------------------------------------------------------------- static le_result_t StartPDPConnection ( uint32_t profileIndex ///< [IN] The profile identifier ) { char atcommand[ATCOMMAND_SIZE] ; atcmd_Ref_t atReqRef=NULL; atcmdsync_ResultRef_t atresRef; const char* finalRespOkPtr[] = { "CONNECT" , NULL }; const char* finalRespKoPtr[] = { "NO CARRIER", "TIMEOUT", NULL}; atcmdsync_PrepareString(atcommand,ATCOMMAND_SIZE,"ATD*99***%d#",profileIndex); atReqRef = atcmdsync_PrepareStandardCommand(atcommand, NULL, finalRespOkPtr, finalRespKoPtr, 30000); atresRef = atcmdsync_SendCommand(atports_GetInterface(ATPORT_PPP),atReqRef); le_result_t result = atcmdsync_CheckCommandResult(atresRef,finalRespOkPtr,finalRespKoPtr); le_mem_Release(atReqRef); le_mem_Release(atresRef); return result; }
//-------------------------------------------------------------------------------------------------- le_result_t pa_sim_EnterPUK ( pa_sim_PukType_t type, ///< [IN] puk type const pa_sim_Puk_t puk, ///< [IN] PUK code const pa_sim_Pin_t pin ///< [IN] new PIN code ) { atcmdsync_ResultRef_t resRef = NULL; char atcommand[ATCOMMAND_SIZE] ; atcmdsync_PrepareString(atcommand,ATCOMMAND_SIZE,"at+cpin=%s,%s",puk,pin); le_result_t result = atcmdsync_SendStandard(atports_GetInterface(ATPORT_COMMAND), atcommand, &resRef, NULL, 30000); if ( result != LE_OK ) { le_mem_Release(resRef); return result; } le_sim_States_t simState=LE_SIM_STATE_UNKNOWN; char* line = atcmdsync_GetLine(resRef,0); if (CheckStatus(line,&simState)) { ReportStatus(NumCard,simState); } le_mem_Release(resRef); // release atcmdsync_SendCommandDefault return LE_OK; }
//-------------------------------------------------------------------------------------------------- static le_result_t resetModem ( void ) { atcmdsync_ResultRef_t resRef=NULL; const char* finalRespOkPtr[] = {"+WIND: 4",NULL }; const char* finalRespKoPtr[] = {"ERROR","+CME ERROR:","+CMS ERROR:","TIMEOUT",NULL}; atcmd_Ref_t atReqRef = atcmd_Create(); atcmd_AddCommand(atReqRef,"at+cfun=1",false); atcmd_AddData (atReqRef,NULL,0); atcmd_SetTimer (atReqRef,30000,atcmdsync_GetTimerExpiryHandler()); atcmd_AddIntermediateResp (atReqRef,atcmdsync_GetIntermediateEventId(),NULL); atcmd_AddFinalResp(atReqRef,atcmdsync_GetFinalEventId(),finalRespOkPtr); atcmd_AddFinalResp(atReqRef,atcmdsync_GetFinalEventId(),finalRespKoPtr); resRef = atcmdsync_SendCommand(atports_GetInterface(ATPORT_COMMAND),atReqRef); le_result_t result = atcmdsync_CheckCommandResult(resRef,finalRespOkPtr,finalRespKoPtr); le_mem_Release(atReqRef); // Release e_atmgr_Object_CreateATCommand le_mem_Release(resRef); // Release le_pa_at_SendSync return result; }
//-------------------------------------------------------------------------------------------------- le_result_t pa_sim_GetIMSI ( pa_sim_Imsi_t imsi ///< [OUT] IMSI value ) { le_result_t result; atcmdsync_ResultRef_t resRef = NULL; // IMSI start with 0|1|2|3|4|5|6|7|8|9 const char* interRespPtr[] = {"0","1","2","3","4","5","6","7","8","9",NULL}; if (!imsi) { LE_DEBUG("One parameter is NULL"); return LE_BAD_PARAMETER; } result = atcmdsync_SendStandard(atports_GetInterface(ATPORT_COMMAND), "at+cimi", &resRef, interRespPtr, 30000); if ( result != LE_OK ) { le_mem_Release(resRef); return result; } le_sim_States_t simState=LE_SIM_STATE_UNKNOWN; char* line = atcmdsync_GetLine(resRef,0); if (CheckStatus(line,&simState)) { ReportStatus(NumCard,simState); } // If there is more than one line then it mean that the command is OK so the first line is // the intermediate one if (atcmdsync_GetNumLines(resRef) == 2) { line = atcmdsync_GetLine(resRef,0); // copy just the first line because of '\0' atcmd_CopyStringWithoutQuote(imsi, line, strlen(line)); result = LE_OK; } // it is not expected else { LE_WARN("this pattern is not expected"); result=LE_NOT_POSSIBLE; } le_mem_Release(resRef); // Release atcmdsync_SendCommandDefaultExt return result; }
//-------------------------------------------------------------------------------------------------- le_result_t pa_mrc_GetRadioPower ( le_onoff_t* powerPtr ///< [OUT] The power state. ) { int32_t result=LE_NOT_POSSIBLE; atcmdsync_ResultRef_t resRef = NULL; const char* interRespPtr[] = {"+CFUN:",NULL}; result = atcmdsync_SendStandard(atports_GetInterface(ATPORT_COMMAND), "at+cfun?", &resRef, interRespPtr, 30000); if ( result != LE_OK ) { le_mem_Release(resRef); // release atcmdsync_SendCommandDefaultExt return result; } // If there is more than one line then it mean that the command is OK so the first line is // the intermediate one if (atcmdsync_GetNumLines(resRef) == 2) { // it parse just the first line because of '\0' char* line = atcmdsync_GetLine(resRef,0); // it parse just the first line because of '\0' uint32_t numParam = atcmd_CountLineParameter(line); // Check is the +CREG intermediate response is in good format if (FIND_STRING("+CFUN:",atcmd_GetLineParameter(line,1))) { if (numParam==2) { if(atoi(atcmd_GetLineParameter(line,2)) != 0) { *powerPtr = LE_ON; } else { *powerPtr = LE_OFF; } result = LE_OK; } else { LE_WARN("this pattern is not expected"); result=LE_NOT_POSSIBLE; } } else { LE_WARN("this pattern is not expected"); result=LE_NOT_POSSIBLE; } } le_mem_Release(resRef); // Release atcmdsync_SendCommand return result; }
//-------------------------------------------------------------------------------------------------- le_result_t le_media_PlayDtmf ( le_audio_Stream_t* streamPtr, ///< [IN] Stream object const char* dtmfPtr, ///< [IN] The DTMFs to play. uint32_t duration, ///< [IN] The DTMF duration in milliseconds. uint32_t pause ///< [IN] The pause duration between tones in milliseconds. ) { le_result_t res; DtmfThreadCtx_t* threadCtxPtr = le_mem_ForceAlloc(DtmfThreadContextPool); memset(threadCtxPtr, 0, sizeof(DtmfThreadCtx_t)); streamPtr->samplePcmConfig.sampleRate = 16000; streamPtr->samplePcmConfig.bitsPerSample = 16; streamPtr->samplePcmConfig.channelsCount = 1; streamPtr->samplePcmConfig.fileSize = -1; streamPtr->samplePcmConfig.pcmFormat = PCM_RAW; threadCtxPtr->duration = duration; threadCtxPtr->pause = pause; threadCtxPtr->sampleRate = 16000; threadCtxPtr->dtmfPtr = dtmfPtr; if (pipe(threadCtxPtr->pipefd) == -1) { LE_ERROR("Failed to create the pipe"); le_mem_Release(threadCtxPtr); return LE_FAULT; } streamPtr->fd = threadCtxPtr->pipefd[0]; if ((res=pa_audio_PlaySamples(streamPtr->audioInterface, streamPtr->fd, &streamPtr->samplePcmConfig)) == LE_OK) { LE_INFO("Spawn DTMF thread"); if (DtmfTreadRef == NULL) { DtmfTreadRef = le_thread_Create("PlayDtmfs", PlayDtmfThread, threadCtxPtr); le_thread_AddChildDestructor(DtmfTreadRef, DestroyPlayDtmfThread, threadCtxPtr); le_thread_Start(DtmfTreadRef); } } else { le_mem_Release(threadCtxPtr); LE_ERROR("Cannot spawn DTMF thread!"); } return res; }
//-------------------------------------------------------------------------------------------------- static le_result_t pa_sim_GetRemainingAttempts ( uint32_t idx, ///< [IN] idx to read uint32_t* attemptsPtr ///< [OUT] The number of attempts still possible ) { le_result_t result=LE_NOT_POSSIBLE; atcmdsync_ResultRef_t resRef = NULL; const char* interRespPtr[] = {"+CPINC:",NULL}; if (!attemptsPtr) { LE_DEBUG("One parameter is NULL"); return LE_BAD_PARAMETER; } result = atcmdsync_SendStandard(atports_GetInterface(ATPORT_COMMAND), "at+cpinc", &resRef, interRespPtr, 30000); if ( result != LE_OK ) { le_mem_Release(resRef); // release atcmdsync_SendCommandDefaultExt return result; } // If there is more than one line then it mean that the command is OK so the first line is // the intermediate one if (atcmdsync_GetNumLines(resRef) == 2) { // it parse just the first line because of '\0' char* line = atcmdsync_GetLine(resRef,0); uint32_t numParam = atcmd_CountLineParameter(line); // it parse just the first line because of '\0' if ((numParam==5) && (FIND_STRING("+CPINC:",atcmd_GetLineParameter(line,1)))) { *attemptsPtr = atoi(atcmd_GetLineParameter(line,idx)); result = LE_OK; } else { LE_WARN("this pattern is not expected"); result=LE_NOT_POSSIBLE; } } else { LE_WARN("this pattern is not expected"); result=LE_NOT_POSSIBLE; } le_mem_Release(resRef); // Release atcmdsync_SendCommandDefaultExt return result; }
//-------------------------------------------------------------------------------------------------- static void DestroySessionInternal ( mqtt_Session* sessionPtr ) { MQTTClient_destroy(&(sessionPtr->client)); // It is necessary to cast to char* from const char* in order to free the memory // associated with the username and password. le_mem_Release((char*)sessionPtr->connectOptions.username); le_mem_Release((char*)sessionPtr->connectOptions.password); le_mem_Release(sessionPtr); }
// ------------------------------------------------------------------------------------------------- static void ThreadDestructor ( void* destructorContext ) // ------------------------------------------------------------------------------------------------- { Context_t* contextPtr = destructorContext; LE_INFO("Thread '%s' destructor running.", le_thread_GetMyName()); le_mem_Release(contextPtr->completionObjPtr); le_mem_Release(contextPtr); }
//-------------------------------------------------------------------------------------------------- le_result_t pa_sim_GetState ( le_sim_States_t* statePtr ///< [OUT] SIM state ) { int32_t result=LE_NOT_POSSIBLE; atcmd_Ref_t atReqRef; atcmdsync_ResultRef_t resRef = NULL; const char* finalRespOkPtr[] = {"OK","+CPIN:",NULL}; const char* finalRespKoPtr[] = {"ERROR","+CME ERROR:","+CMS ERROR:","TIMEOUT",NULL}; if (!statePtr) { LE_DEBUG("One parameter is NULL"); return LE_BAD_PARAMETER; } *statePtr=LE_SIM_STATE_UNKNOWN; atReqRef = atcmd_Create(); atcmd_AddCommand(atReqRef,"at+cpin?",false); atcmd_AddData(atReqRef,NULL,0); atcmd_SetTimer(atReqRef,30000,atcmdsync_GetTimerExpiryHandler()); atcmd_AddIntermediateResp (atReqRef,atcmdsync_GetIntermediateEventId(),NULL); atcmd_AddFinalResp(atReqRef,atcmdsync_GetFinalEventId(),finalRespOkPtr); atcmd_AddFinalResp(atReqRef,atcmdsync_GetFinalEventId(),finalRespKoPtr); resRef = atcmdsync_SendCommand(atports_GetInterface(ATPORT_COMMAND),atReqRef); char* line = atcmdsync_GetFinalLine(resRef); // Check timeout if (FIND_STRING("TIMEOUT",line)) { LE_WARN("Modem failed"); le_mem_Release(atReqRef); le_mem_Release(resRef); return LE_TIMEOUT; } if (CheckStatus(line,statePtr)) { ReportStatus(NumCard,*statePtr); result = LE_OK; } le_mem_Release(atReqRef); // Release atcmdsync_SetCommand le_mem_Release(resRef); // Release atcmdsync_SendCommand return result; }
//-------------------------------------------------------------------------------------------------- static void* ThreadMain(void* completionObjPtr) { le_thread_InitLegatoThreadData("externalApiTest"); int i; for (i = 0; i < 10000; i++) { Lock(); Counter++; Unlock(); Lock(); Counter--; Unlock(); } le_thread_CleanupLegatoThreadData(); le_mem_Release(completionObjPtr); // Signal that I'm done. return NULL; }
//-------------------------------------------------------------------------------------------------- void proc_Delete ( proc_Ref_t procRef ///< [IN] The process to start. ) { le_mem_Release(procRef); }
//-------------------------------------------------------------------------------------------------- proc_Ref_t proc_Create ( const char* cfgPathRootPtr, ///< [IN] The path in the config tree for this process. app_Ref_t appRef ///< [IN] Reference to the app that we are part of. ) { Process_t* procPtr = le_mem_ForceAlloc(ProcessPool); // Copy the config path. if (le_utf8_Copy(procPtr->cfgPathRoot, cfgPathRootPtr, sizeof(procPtr->cfgPathRoot), NULL) == LE_OVERFLOW) { LE_ERROR("Config path '%s' is too long.", cfgPathRootPtr); le_mem_Release(procPtr); return NULL; } procPtr->name = le_path_GetBasenamePtr(procPtr->cfgPathRoot, "/"); procPtr->appRef = appRef; procPtr->faultTime = 0; procPtr->paused = false; procPtr->pid = -1; // Processes that are not running are assigned -1 as its pid. procPtr->cmdKill = false; return procPtr; }
//-------------------------------------------------------------------------------------------------- le_result_t pa_common_GetWindIndicator ( uint32_t* windPtr ) { le_result_t result = LE_OK; atcmdsync_ResultRef_t resRef = NULL; const char* interRespPtr[] = {"+WIND:",NULL}; LE_ASSERT(windPtr); result = atcmdsync_SendStandard(atports_GetInterface(ATPORT_COMMAND), "AT+WIND?", &resRef, interRespPtr, 30000); if ( result == LE_OK ) { char* line = atcmdsync_GetLine(resRef,0); if ( sscanf(line,"+WIND: %d",windPtr) != 1) { LE_DEBUG("cannot qet wind indicator"); result = LE_FAULT; } } le_mem_Release(resRef); return result; }
//-------------------------------------------------------------------------------------------------- LE_SHARED le_result_t le_comm_Delete (void* handle) { HandleRecord_t* connectionRecordPtr = (HandleRecord_t*) handle; LE_INFO("Deleting AF_INET socket, fd %d .........", connectionRecordPtr->fd); if (FdMonitorRef != NULL) { // Delete FD monitor le_fdMonitor_Delete(FdMonitorRef); FdMonitorRef = NULL; } // Remove the Handle record le_hashmap_Remove(HandleRecordByFileDescriptor, (void*)(intptr_t) connectionRecordPtr->fd); // Shut-down the open socket shutdown(connectionRecordPtr->fd, SHUT_RDWR); // Close Socket Handle close(connectionRecordPtr->fd); connectionRecordPtr->fd = -1; // Free the Handle Record memory le_mem_Release(connectionRecordPtr); connectionRecordPtr = NULL; // Reset the Network IP Address and TCP Port memset(NetworkSocketIpAddress, 0, sizeof(NetworkSocketIpAddress)); NetworkSocketTCPListeningPort = 0; return LE_OK; }
//-------------------------------------------------------------------------------------------------- void ni_Release ( ni_IteratorRef_t iteratorRef ///< [IN] Free the resources used by this iterator. ) //-------------------------------------------------------------------------------------------------- { LE_ASSERT(iteratorRef != NULL); // Make sure that the transaction timer isn't still running. if (iteratorRef->timerRef != NULL) { if (le_timer_GetExpiryCount(iteratorRef->timerRef) == 0) { le_timer_Stop(iteratorRef->timerRef); } le_timer_Delete(iteratorRef->timerRef); iteratorRef->timerRef = NULL; } // Release the rest of the iterator's resources. LE_DEBUG("Releasing iterator, <%p> with a lifetime of %d seconds.", iteratorRef, (uint32_t)(le_clk_GetRelativeTime().sec - iteratorRef->creationTime.sec)); ni_Close(iteratorRef); tdb_UnregisterIterator(iteratorRef->treeRef, iteratorRef); le_pathIter_Delete(iteratorRef->pathIterRef); tdb_ReleaseTree(iteratorRef->treeRef); le_mem_Release(iteratorRef); }
//-------------------------------------------------------------------------------------------------- void StopClient ( void ) { _ClientThreadData_t* clientThreadPtr = pthread_getspecific(_ThreadDataKey); // If the thread specific data is NULL, then there is no current client session. if (clientThreadPtr == NULL) { LE_ERROR("Trying to stop non-existent client session for '%s' service", GlobalServiceInstanceName); } else { le_msg_CloseSession( clientThreadPtr->sessionRef ); // Need to delete the thread specific data, since it is no longer valid. If a new // client session is started, new thread specific data will be allocated. le_mem_Release(clientThreadPtr); if (pthread_setspecific(_ThreadDataKey, NULL) != 0) { LE_FATAL("pthread_setspecific() failed!"); } LE_DEBUG("======= Stopping Client %s ========", GlobalServiceInstanceName); } }
//-------------------------------------------------------------------------------------------------- void le_mrc_DeleteCellularNetworkScan ( le_mrc_ScanInformation_ListRef_t scanInformationListRef ///< [IN] The list of scan information. ) { le_mrc_ScanInformationList_t* scanInformationListPtr = le_ref_Lookup(ScanInformationListRefMap, scanInformationListRef); if (scanInformationListPtr == NULL) { LE_KILL_CLIENT("Invalid reference (%p) provided!", scanInformationListRef); return; } scanInformationListPtr->currentLink = NULL; pa_mrc_DeleteScanInformation(&(scanInformationListPtr->paScanInformationList)); // Delete the safe Reference list. DeleteSafeRefList(&(scanInformationListPtr->safeRefScanInformationList)); // Invalidate the Safe Reference. le_ref_DeleteRef(ScanInformationListRefMap, scanInformationListRef); le_mem_Release(scanInformationListPtr); }
//-------------------------------------------------------------------------------------------------- static void DeleteFdMonitor ( FdMonitor_t* fdMonitorPtr ///< [in] Pointer to the FD Monitor to be deleted. ) //-------------------------------------------------------------------------------------------------- { event_PerThreadRec_t* perThreadRecPtr = thread_GetEventRecPtr(); LE_ASSERT(perThreadRecPtr == fdMonitorPtr->threadRecPtr); // Remove the FD Monitor from the thread's FD Monitor List. le_dls_Remove(&perThreadRecPtr->fdMonitorList, &fdMonitorPtr->link); LOCK // Delete the Safe References used for the FD Monitor and any of its Handler objects. le_ref_DeleteRef(FdMonitorRefMap, fdMonitorPtr->safeRef); UNLOCK // Tell epoll(7) to stop monitoring this fd. StopMonitoringFd(fdMonitorPtr); // Release the object back to it's pool. le_mem_Release(fdMonitorPtr); }
//-------------------------------------------------------------------------------------------------- void le_msg_DeleteService ( le_msg_ServiceRef_t serviceRef ///< [in] Reference to the service. ) //-------------------------------------------------------------------------------------------------- { LE_FATAL_IF(serviceRef->serverThread != le_thread_GetCurrent(), "Attempted to delete service (%s:%s) not owned by thread.", serviceRef->id.name, le_msg_GetProtocolIdStr(serviceRef->id.protocolRef)); // If the service is still advertised, hide it. le_msg_HideService(serviceRef); // Close any remaining open sessions. CloseAllSessions(serviceRef); // NOTE: Lock the mutex here to prevent a race between this thread dropping ownership // of the service and another thread trying to offer the same service. This is very // unlikely to ever happen, but just in case, make sure it fails with a sensible // ("duplicate") log message, instead of just quietly messing up the hashmap or something. LOCK // Clear out the server thread reference. serviceRef->serverThread = NULL; // Release the server's hold on the object. le_mem_Release(serviceRef); UNLOCK }
//-------------------------------------------------------------------------------------------------- void le_msg_RemoveServiceHandler ( le_msg_SessionEventHandlerRef_t handlerRef ///< [in] Reference to a previously call of /// le_msg_AddServiceCloseHandler() ) //-------------------------------------------------------------------------------------------------- { le_dls_Link_t* linkPtr = le_ref_Lookup(HandlersRefMap, handlerRef); if ( linkPtr == NULL ) { LE_ERROR("Invalid data request reference"); } else { SessionEventHandler_t* eventPtr = CONTAINER_OF(linkPtr, SessionEventHandler_t, link); /* Remove the link from the close handlers dls */ le_dls_Remove(eventPtr->listPtr, linkPtr); /* Release memory */ le_mem_Release(eventPtr); /* Delete the reference */ le_ref_DeleteRef(HandlersRefMap, handlerRef); } }
//-------------------------------------------------------------------------------------------------- void le_mem_DeleteSubPool ( le_mem_PoolRef_t subPool ///< [IN] The sub-pool to be deleted. ) { LE_ASSERT(subPool != NULL); Lock(); // Make sure all sub-pool objects are free. le_mem_PoolRef_t superPool = subPool->superPoolPtr; LE_FATAL_IF(subPool->numBlocksInUse != 0, "Subpool '%s' deleted while %zu blocks remain allocated.", subPool->name, subPool->numBlocksInUse); size_t numBlocks = subPool->totalBlocks; // Move the blocks from the subPool back to the superpool. MoveBlocks(superPool, subPool, numBlocks); // Update the superPool's block use count. superPool->numBlocksInUse -= numBlocks; // Remove the sub-pool from the list of sub-pools. ListOfPoolsChgCnt++; le_dls_Remove(&ListOfPools, &(subPool->poolLink)); Unlock(); // Release the sub-pool. le_mem_Release(subPool); }
//-------------------------------------------------------------------------------------------------- static void DeleteFdMonitor ( FdMonitor_t* fdMonitorPtr ///< [in] Pointer to the FD Monitor to be deleted. ) //-------------------------------------------------------------------------------------------------- { int i; event_PerThreadRec_t* perThreadRecPtr = thread_GetEventRecPtr(); LE_ASSERT(perThreadRecPtr == fdMonitorPtr->threadRecPtr); // Remove the FD Monitor from the thread's FD Monitor List. le_dls_Remove(&perThreadRecPtr->fdMonitorList, &fdMonitorPtr->link); LOCK // Delete the Safe References used for the FD Monitor and any of its Handler objects. le_ref_DeleteRef(FdMonitorRefMap, fdMonitorPtr->safeRef); for (i = 0; i < LE_EVENT_NUM_FD_EVENT_TYPES; i++) { void* safeRef = fdMonitorPtr->handlerArray[i].safeRef; if (safeRef != NULL) { le_ref_DeleteRef(HandlerRefMap, safeRef); } } UNLOCK // Tell epoll(7) to stop monitoring this fd. StopMonitoringFd(fdMonitorPtr); // Release the object back to it's pool. le_mem_Release(fdMonitorPtr); }
//-------------------------------------------------------------------------------------------------- static void ServiceDestructor ( void* objPtr ) //-------------------------------------------------------------------------------------------------- { le_dls_Link_t* linkPtr = NULL; Service_t* servicePtr = objPtr; le_hashmap_Remove(ServiceMapRef, &servicePtr->id); /* Release the close handlers dls */ do { linkPtr = le_dls_PopTail(&servicePtr->closeListPtr); if (linkPtr) { SessionEventHandler_t* closeEventPtr = CONTAINER_OF(linkPtr, SessionEventHandler_t, link); /* Delete the reference */ le_ref_DeleteRef(HandlersRefMap, closeEventPtr->ref); /* Release the memory */ le_mem_Release(closeEventPtr); } } while (linkPtr); /* Release the open handlers dls */ do { linkPtr = le_dls_PopTail(&servicePtr->openListPtr); if (linkPtr) { SessionEventHandler_t* openEventPtr = CONTAINER_OF(linkPtr, SessionEventHandler_t, link); /* Delete the reference */ le_ref_DeleteRef(HandlersRefMap, openEventPtr->ref); le_mem_Release(openEventPtr); } } while (linkPtr); }
//-------------------------------------------------------------------------------------------------- static void PopContext ( Parser_t* parserPtr ) //-------------------------------------------------------------------------------------------------- { // Don't do anything if a client handler has already stopped parsing. if (NotStopped(parserPtr)) { // Pop the top one and release it. le_sls_Link_t* linkPtr = le_sls_Pop(&parserPtr->contextStack); le_mem_Release(CONTAINER_OF(linkPtr, Context_t, link)); // Check the new context le_json_ContextType_t context = GetContext(parserPtr)->type; switch (context) { case LE_JSON_CONTEXT_DOC: // We've finished parsing the whole document. // Automatically stop parsing and report the document end to the client. StopParsing(parserPtr); Report(parserPtr, LE_JSON_DOC_END); break; case LE_JSON_CONTEXT_OBJECT: // We've finished parsing an object member. // Expect a comma separator or the end of the object next. parserPtr->next = EXPECT_COMMA_OR_OBJECT_END; break; case LE_JSON_CONTEXT_MEMBER: // We've finished parsing the value of an object member. // This is also the end of the member, so pop that context too. PopContext(parserPtr); break; case LE_JSON_CONTEXT_ARRAY: // We've finished parsing an array element value. // Expect a comma separator or the end of the array next. parserPtr->next = EXPECT_COMMA_OR_ARRAY_END; break; // These are all leaf contexts. That is, we should never find one of these // contexts after popping another one off the stack. case LE_JSON_CONTEXT_STRING: case LE_JSON_CONTEXT_NUMBER: case LE_JSON_CONTEXT_TRUE: case LE_JSON_CONTEXT_FALSE: case LE_JSON_CONTEXT_NULL: LE_FATAL("Unexpected context after pop: %s", le_json_GetContextName(context)); } } }
//-------------------------------------------------------------------------------------------------- le_result_t le_mcc_Delete ( le_mcc_CallRef_t callRef ///< [IN] The call object to free. ) { le_mcc_Call_t* callPtr = le_ref_Lookup(MccCallRefMap, callRef); if (callPtr == NULL) { LE_ERROR("Invalid reference (%p) provided!", callRef); return LE_NOT_FOUND; } if (callPtr->inProgress) { return LE_FAULT; } else { SessionRefNode_t* sessionRefNodePtr; le_dls_Link_t* linkPtr; callPtr->refCount--; LE_DEBUG("refcount %d", callPtr->refCount); // Remove corresponding node from the sessionRefList linkPtr = le_dls_Peek(&(callPtr->sessionRefList)); while (linkPtr != NULL) { sessionRefNodePtr = CONTAINER_OF(linkPtr, SessionRefNode_t, link); linkPtr = le_dls_PeekNext(&(callPtr->sessionRefList), linkPtr); if ( sessionRefNodePtr->sessionRef == le_mcc_GetClientSessionRef() ) { le_dls_Remove( &(callPtr->sessionRefList), &(sessionRefNodePtr->link)); le_mem_Release(sessionRefNodePtr); } } le_mem_Release(callPtr); return LE_OK; } }
//-------------------------------------------------------------------------------------------------- static void ThreadDeathHandler ( void* parserPtr ) //-------------------------------------------------------------------------------------------------- { // Release the client's reference to the parser object. le_mem_Release(parserPtr); }
//-------------------------------------------------------------------------------------------------- void dstr_Release ( dstr_Ref_t strRef ///< [IN] The dynamic string to free. ) //-------------------------------------------------------------------------------------------------- { dstr_Ref_t segmentRef = FirstSegmentRef(strRef); while (segmentRef != NULL) { dstr_Ref_t nextSegmentRef = NextSegmentRef(strRef, segmentRef); le_mem_Release(segmentRef); segmentRef = nextSegmentRef; } le_mem_Release(strRef); }
//-------------------------------------------------------------------------------------------------- LE_SHARED void appCfg_DeleteIter ( appCfg_Iter_t iter ///< [IN] Iterator ) { le_cfg_CancelTxn(iter->cfgIter); le_mem_Release(iter); }
//-------------------------------------------------------------------------------------------------- static void MessageReceivedEventHandler ( void* reportPtr ) { mqtt_Message* storedMsgPtr = *((mqtt_Message**)reportPtr); mqtt_Session* s = le_ref_Lookup(SessionRefMap, storedMsgPtr->sessionRef); if (s == NULL) { LE_WARN("Session lookup failed for session=0x%p", storedMsgPtr->sessionRef); return; } if (s->messageArrivedHandler != NULL) { if (storedMsgPtr->topicLength <= MQTT_MAX_TOPIC_LENGTH && storedMsgPtr->payloadLength <= MQTT_MAX_PAYLOAD_LENGTH) { s->messageArrivedHandler( storedMsgPtr->topicPtr, storedMsgPtr->payloadPtr, storedMsgPtr->payloadLength, s->messageArrivedHandlerContextPtr); } else { LE_WARN( "Message arrived from broker, but it is too large to deliver using Legato IPC - " "topicLength=%zu, payloadLength=%zu", storedMsgPtr->topicLength, storedMsgPtr->payloadLength); } } else { LE_WARN( "Message has arrived, but no handler is registered to receive the notification"); } le_mem_Release(storedMsgPtr->topicPtr); le_mem_Release(storedMsgPtr->payloadPtr); le_mem_Release(storedMsgPtr); }