//--------------------------------------------------------------------------------------------------
void pa_gnssSimu_ReportEvent
(
void
)
{
// Build the data for the user's event handler.
pa_Gnss_Position_t* posDataPtr = le_mem_ForceAlloc(PositionEventDataPool);
memcpy(posDataPtr, &GnssPositionData, sizeof(pa_Gnss_Position_t));
le_event_ReportWithRefCounting(GnssEventId, posDataPtr);
char* strDataPtr = le_mem_ForceAlloc(NmeaEventDataPool);
strncpy(strDataPtr, "nmea", NMEA_STR_LEN);
le_event_ReportWithRefCounting(NmeaEventId, strDataPtr);
}
//--------------------------------------------------------------------------------------------------
void atmachinestring_AddInList
(
le_dls_List_t *list, ///< List of atmachinestring_t
const char **patternListPtr ///< List of pattern
)
{
uint32_t i = 0;
if (!patternListPtr) {
return;
}
while(patternListPtr[i] != NULL) {
atmachinestring_t* newStringPtr = le_mem_ForceAlloc(AtStringPool);
LE_FATAL_IF(
(strlen(patternListPtr[i])>ATSTRING_SIZE),
"%s is too long (%zd): Max size %d",
patternListPtr[i],strlen(patternListPtr[i]),ATSTRING_SIZE);
strncpy(newStringPtr->line,patternListPtr[i],ATSTRING_SIZE);
newStringPtr->line[ATSTRING_SIZE-1]='\0';
newStringPtr->link = LE_DLS_LINK_INIT;
le_dls_Queue(list,&(newStringPtr->link));
i++;
}
}
//--------------------------------------------------------------------------------------------------
static le_result_t GetFirmwareItem
(
json_t *jsonItemPtr, ///<[IN] json object containing firmware item.
Manifest_t *manPtr ///<[IN] Object containing manifest header.
)
{
Item_t* item = le_mem_ForceAlloc(ItemPoolRef);
item->type = LE_UPDATE_FIRMWARE;
// Now add item in the linked list
le_dls_Queue(&(manPtr->itemList), &(item->link));
memset((item->ActionItem).firmware.version,
0,
sizeof((item->ActionItem).firmware.version));
// Get firmware version. This is optional field
le_result_t result = GetJsonStrField(jsonItemPtr,
JSON_FIELD_VERSION,
(item->ActionItem).firmware.version,
sizeof((item->ActionItem).firmware.version));
result = GetJsonSizeField(jsonItemPtr,
JSON_FIELD_SIZE,
&((item->ActionItem).firmware.size));
LE_DEBUG("Got firmware item: %p, size: %zd",
item,
(item->ActionItem).firmware.size);
return result;
}
//--------------------------------------------------------------------------------------------------
properties_Iter_Ref_t properties_CreateIter
(
const char* fileNamePtr ///< [IN] File name of the .properties file.
)
{
// Open the .properties file.
FILE* filePtr;
do
{
filePtr = fopen(fileNamePtr, "r");
}
while ( (filePtr == NULL) && (errno == EINTR) );
if (filePtr == NULL)
{
LE_ERROR("File '%s' could not be opened. %m.", fileNamePtr);
return NULL;
}
// Create the iterator.
PropertiesIter_t* iterPtr = le_mem_ForceAlloc(PropertiesIterPool);
iterPtr->streamPtr = filePtr;
iterPtr->propertyBuf[0] = '\0';
iterPtr->keyPtr = NULL;
iterPtr->valuePtr = NULL;
// The stored file name is only used for debug log messages so it is fine if the file name gets
// truncated. No need to check the return value.
le_utf8_Copy(iterPtr->fileName, fileNamePtr, LIMIT_MAX_PATH_BYTES, NULL);
return iterPtr;
}
//--------------------------------------------------------------------------------------------------
static _ClientThreadData_t* InitClientThreadData
(
const char* serviceInstanceName
)
{
// Open a session.
le_msg_ProtocolRef_t protocolRef;
le_msg_SessionRef_t sessionRef;
// The instance name must not be an empty string
if ( serviceInstanceName[0] == '\0' )
{
LE_FATAL("Undefined client service instance name (Was StartClient() called?)");
}
protocolRef = le_msg_GetProtocolRef(PROTOCOL_ID_STR, sizeof(_Message_t));
sessionRef = le_msg_CreateSession(protocolRef, serviceInstanceName);
le_msg_SetSessionRecvHandler(sessionRef, ClientIndicationRecvHandler, NULL);
le_msg_OpenSessionSync(sessionRef);
// Store the client sessionRef in thread-local storage, since each thread requires
// its own sessionRef.
_ClientThreadData_t* clientThreadPtr = le_mem_ForceAlloc(_ClientThreadDataPool);
clientThreadPtr->sessionRef = sessionRef;
if (pthread_setspecific(_ThreadDataKey, clientThreadPtr) != 0)
{
LE_FATAL("pthread_setspecific() failed!");
}
return clientThreadPtr;
}
//--------------------------------------------------------------------------------------------------
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;
}
//--------------------------------------------------------------------------------------------------
event_PerThreadRec_t* fa_event_CreatePerThreadInfo
(
void
)
{
event_LinuxPerThreadRec_t* recPtr = le_mem_ForceAlloc(PerThreadPool);
// Create the epoll file descriptor for this thread. This will be used to monitor for
// events on various file descriptors.
recPtr->epollFd = epoll_create1(0);
LE_FATAL_IF(recPtr->epollFd < 0, "epoll_create1(0) failed with errno %d.", errno);
// Open an eventfd for this thread. This will be uses to signal to the epoll fd that there
// are Event Reports on the Event Queue.
recPtr->eventQueueFd = eventfd(0, 0);
LE_FATAL_IF(recPtr->eventQueueFd < 0, "eventfd() failed with errno %d.", errno);
// Add the eventfd to the list of file descriptors to wait for using epoll_wait().
struct epoll_event ev;
memset(&ev, 0, sizeof(ev));
ev.events = EPOLLIN | EPOLLWAKEUP;
ev.data.ptr = NULL; // This being set to NULL is what tells the main event loop that this
// is the Event Queue FD, rather than another FD that is being
// monitored.
if (epoll_ctl(recPtr->epollFd, EPOLL_CTL_ADD, recPtr->eventQueueFd, &ev) == -1)
{
LE_FATAL( "epoll_ctl(ADD) failed for fd %d. errno = %d",
recPtr->eventQueueFd,
errno);
}
return &recPtr->portablePerThreadRec;
}
//--------------------------------------------------------------------------------------------------
le_mrc_ScanInformation_Ref_t le_mrc_GetFirstCellularNetworkScan
(
le_mrc_ScanInformation_ListRef_t scanInformationListRef ///< [IN] The list of scan information.
)
{
pa_mrc_ScanInformation_t* nodePtr;
le_dls_Link_t* linkPtr;
le_mrc_ScanInformationList_t* scanInformationListPtr = le_ref_Lookup(ScanInformationListRefMap,
scanInformationListRef);
if (scanInformationListPtr == NULL)
{
LE_KILL_CLIENT("Invalid reference (%p) provided!", scanInformationListRef);
return NULL;
}
linkPtr = le_dls_Peek(&(scanInformationListPtr->paScanInformationList));
if (linkPtr != NULL)
{
nodePtr = CONTAINER_OF(linkPtr, pa_mrc_ScanInformation_t, link);
scanInformationListPtr->currentLink = linkPtr;
le_mrc_ScanInformationSafeRef_t* newScanInformationPtr = le_mem_ForceAlloc(ScanInformationSafeRefPool);
newScanInformationPtr->safeRef = le_ref_CreateRef(ScanInformationRefMap,nodePtr);
newScanInformationPtr->link = LE_DLS_LINK_INIT;
le_dls_Queue(&(scanInformationListPtr->safeRefScanInformationList),&(newScanInformationPtr->link));
return (le_mrc_ScanInformation_Ref_t)newScanInformationPtr->safeRef;
}
else
{
return NULL;
}
}
//--------------------------------------------------------------------------------------------------
le_msg_SessionEventHandlerRef_t le_msg_AddServiceCloseHandler
(
le_msg_ServiceRef_t serviceRef, ///< [in] Reference to the service.
le_msg_SessionEventHandler_t handlerFunc,///< [in] Handler function.
void* contextPtr ///< [in] Opaque pointer value to pass to handler.
)
//--------------------------------------------------------------------------------------------------
{
LE_FATAL_IF(serviceRef == NULL,
"Service doesn't exist. Make sure service is started before setting handlers");
LE_FATAL_IF(serviceRef->serverThread != le_thread_GetCurrent(),
"Service (%s:%s) not owned by calling thread.",
serviceRef->id.name,
le_msg_GetProtocolIdStr(serviceRef->id.protocolRef));
// Create the node.
SessionEventHandler_t* closeEventPtr = le_mem_ForceAlloc(HandlerEventPoolRef);
// Initialize the node.
closeEventPtr->handler = handlerFunc;
closeEventPtr->contextPtr = contextPtr;
closeEventPtr->link = LE_DLS_LINK_INIT;
closeEventPtr->listPtr = &serviceRef->closeListPtr;
// Add the node to the head of the list by passing in the node's link.
le_dls_Stack(&serviceRef->closeListPtr, &closeEventPtr->link);
// Need to return a unique reference that will be used by the remove function.
closeEventPtr->ref = le_ref_CreateRef(HandlersRefMap, &closeEventPtr->link);
return closeEventPtr->ref;
}
static void Handle_AddTestAHandler
(
le_msg_MessageRef_t _msgRef
)
{
// Get the message buffer pointer
uint8_t* _msgBufPtr = ((_Message_t*)le_msg_GetPayloadPtr(_msgRef))->buffer;
// Needed if we are returning a result or output values
uint8_t* _msgBufStartPtr = _msgBufPtr;
// Unpack the input parameters from the message
void* contextPtr;
_msgBufPtr = UnpackData( _msgBufPtr, &contextPtr, sizeof(void*) );
// Create a new server data object and fill it in
_ServerData_t* serverDataPtr = le_mem_ForceAlloc(_ServerDataPool);
serverDataPtr->clientSessionRef = le_msg_GetSession(_msgRef);
serverDataPtr->contextPtr = contextPtr;
serverDataPtr->handlerRef = NULL;
serverDataPtr->removeHandlerFunc = NULL;
contextPtr = serverDataPtr;
// Define storage for output parameters
// Call the function
TestAHandlerRef_t _result;
_result = AddTestAHandler ( AsyncResponse_AddTestAHandler, contextPtr );
// Put the handler reference result and a pointer to the associated remove function
// into the server data object. This function pointer is needed in case the client
// is closed and the handlers need to be removed.
serverDataPtr->handlerRef = (le_event_HandlerRef_t)_result;
serverDataPtr->removeHandlerFunc = (RemoveHandlerFunc_t)RemoveTestAHandler;
// Return a safe reference to the server data object as the reference.
_LOCK
_result = le_ref_CreateRef(_HandlerRefMap, serverDataPtr);
_UNLOCK
// Re-use the message buffer for the response
_msgBufPtr = _msgBufStartPtr;
// Pack the result first
_msgBufPtr = PackData( _msgBufPtr, &_result, sizeof(_result) );
// Pack any "out" parameters
// Return the response
LE_DEBUG("Sending response to client session %p : %ti bytes sent",
le_msg_GetSession(_msgRef),
_msgBufPtr-_msgBufStartPtr);
le_msg_Respond(_msgRef);
}
//--------------------------------------------------------------------------------------------------
static void CGEVUnsolHandler
(
void* reportPtr
)
{
atmgr_UnsolResponse_t* unsolPtr = reportPtr;
uint32_t numParam=0;
pa_mdc_SessionStateData_t *sessionStatePtr=NULL;
LE_DEBUG("Handler received -%s-",unsolPtr->line);
if ( ( FIND_STRING("+CGEV: NW DEACT", unsolPtr->line) )
||
( FIND_STRING("+CGEV: ME DEACT", unsolPtr->line) )
)
{
numParam = atcmd_CountLineParameter(unsolPtr->line);
if (numParam == 4) {
sessionStatePtr = le_mem_ForceAlloc(NewSessionStatePool);
sessionStatePtr->profileIndex = atoi(atcmd_GetLineParameter(unsolPtr->line,4));
sessionStatePtr->newState = LE_MDC_DISCONNECTED;
SetCurrentDataSessionIndex(INVALID_PROFILE_INDEX);
LE_DEBUG("Send Event for %d with state %d",
sessionStatePtr->profileIndex,sessionStatePtr->newState);
le_event_ReportWithRefCounting(NewSessionStateEvent,sessionStatePtr);
} else {
LE_WARN("this Response pattern is not expected -%s-",unsolPtr->line);
}
}
}
//--------------------------------------------------------------------------------------------------
le_sem_Ref_t CreateSemaphore
(
const char* nameStr,
int initialCount,
bool isTraceable
)
//--------------------------------------------------------------------------------------------------
{
// Allocate a semaphore object and initialize it.
Semaphore_t* semaphorePtr = le_mem_ForceAlloc(SemaphorePoolRef);
semaphorePtr->semaphoreListLink = LE_DLS_LINK_INIT;
semaphorePtr->waitingList = LE_DLS_LIST_INIT;
pthread_mutex_init(&semaphorePtr->waitingListMutex, NULL); // Default attributes = Fast mutex.
semaphorePtr->isTraceable = isTraceable;
if (le_utf8_Copy(semaphorePtr->nameStr, nameStr, sizeof(semaphorePtr->nameStr), NULL) == LE_OVERFLOW)
{
LE_WARN("Semaphore name '%s' truncated to '%s'.", nameStr, semaphorePtr->nameStr);
}
// Initialize the underlying POSIX semaphore shared between thread.
int result = sem_init(&semaphorePtr->semaphore,0, initialCount);
if (result != 0)
{
LE_FATAL("Failed to set the semaphore . errno = %d (%m).", errno);
}
// Add the semaphore to the process's Semaphore List.
LOCK_SEMAPHORE_LIST();
le_dls_Queue(&SemaphoreList, &semaphorePtr->semaphoreListLink);
UNLOCK_SEMAPHORE_LIST();
return semaphorePtr;
}
//--------------------------------------------------------------------------------------------------
static void AppendNetworkScanResult
(
le_mrc_Rat_t rat, /// [IN] Requested simulated RAT result
le_dls_List_t *scanInformationListPtr ///< [OUT] list of pa_mrc_ScanInformation_t
)
{
pa_mrc_ScanInformation_t *newScanInformationPtr = NULL;
char mccStr[LE_MRC_MCC_BYTES];
char mncStr[LE_MRC_MNC_BYTES];
newScanInformationPtr = le_mem_ForceAlloc(ScanInformationPool);
memset(newScanInformationPtr, 0, sizeof(*newScanInformationPtr));
newScanInformationPtr->link = LE_DLS_LINK_INIT;
// @TODO Default to SIM MCC/MNC
strcpy(mccStr, PA_SIMU_SIM_DEFAULT_MCC);
strcpy(mncStr, PA_SIMU_SIM_DEFAULT_MNC);
newScanInformationPtr->rat = rat;
strcpy(newScanInformationPtr->mobileCode.mcc, mccStr);
strcpy(newScanInformationPtr->mobileCode.mnc, mncStr);
newScanInformationPtr->isInUse = IsNetworkInUse(rat, mccStr, mncStr);
newScanInformationPtr->isAvailable = !(newScanInformationPtr->isInUse);
newScanInformationPtr->isHome = true;
newScanInformationPtr->isForbidden = false;
le_dls_Queue(scanInformationListPtr, &(newScanInformationPtr->link));
}
//--------------------------------------------------------------------------------------------------
static le_json_ParsingSessionRef_t NewParser
(
le_json_EventHandler_t eventHandler, ///< Function to call when normal parsing events happen.
le_json_ErrorHandler_t errorHandler, ///< Function to call when errors happen.
void* opaquePtr ///< Opaque pointer to be fetched by handlers using le_json_GetOpaquePtr().
)
{
Parser_t *parserPtr;
LE_UNUSED(eventHandler);
// Create a Parser.
parserPtr = le_mem_ForceAlloc(ParserPool);
memset(parserPtr, 0, sizeof(*parserPtr));
parserPtr->next = EXPECT_OBJECT_OR_ARRAY;
parserPtr->line = 1;
parserPtr->errorHandler = errorHandler;
parserPtr->opaquePtr = opaquePtr;
// Register a thread destructor to be called to clean up this parser if the thread dies.
parserPtr->threadDestructor = le_thread_AddDestructor(ThreadDeathHandler, parserPtr);
parserPtr->contextStack = LE_SLS_LIST_INIT;
return parserPtr;
}
static void Handle_TestCallback
(
le_msg_MessageRef_t _msgRef
)
{
// Get the message buffer pointer
uint8_t* _msgBufPtr = ((_Message_t*)le_msg_GetPayloadPtr(_msgRef))->buffer;
// Needed if we are returning a result or output values
uint8_t* _msgBufStartPtr = _msgBufPtr;
// Unpack the input parameters from the message
uint32_t someParm;
_msgBufPtr = UnpackData( _msgBufPtr, &someParm, sizeof(uint32_t) );
size_t dataArrayNumElements;
_msgBufPtr = UnpackData( _msgBufPtr, &dataArrayNumElements, sizeof(size_t) );
uint8_t dataArray[dataArrayNumElements];
_msgBufPtr = UnpackData( _msgBufPtr, dataArray, dataArrayNumElements*sizeof(uint8_t) );
void* contextPtr;
_msgBufPtr = UnpackData( _msgBufPtr, &contextPtr, sizeof(void*) );
// Create a new server data object and fill it in
_ServerData_t* serverDataPtr = le_mem_ForceAlloc(_ServerDataPool);
serverDataPtr->clientSessionRef = le_msg_GetSession(_msgRef);
serverDataPtr->contextPtr = contextPtr;
serverDataPtr->handlerRef = NULL;
serverDataPtr->removeHandlerFunc = NULL;
contextPtr = serverDataPtr;
// Define storage for output parameters
// Call the function
int32_t _result;
_result = TestCallback ( someParm, dataArray, dataArrayNumElements, AsyncResponse_TestCallback, contextPtr );
// Re-use the message buffer for the response
_msgBufPtr = _msgBufStartPtr;
// Pack the result first
_msgBufPtr = PackData( _msgBufPtr, &_result, sizeof(_result) );
// Pack any "out" parameters
// Return the response
LE_DEBUG("Sending response to client session %p : %ti bytes sent",
le_msg_GetSession(_msgRef),
_msgBufPtr-_msgBufStartPtr);
le_msg_Respond(_msgRef);
}
//--------------------------------------------------------------------------------------------------
le_mcc_CallRef_t le_mcc_Create
(
const char* phoneNumPtr
///< [IN]
///< The target number we are going to
///< call.
)
{
if (phoneNumPtr == NULL)
{
LE_KILL_CLIENT("phoneNumPtr is NULL !");
return NULL;
}
if(strlen(phoneNumPtr) > (LE_MDMDEFS_PHONE_NUM_MAX_BYTES-1))
{
LE_KILL_CLIENT("strlen(phoneNumPtr) > %d", (LE_MDMDEFS_PHONE_NUM_MAX_BYTES-1));
return NULL;
}
// Create the Call object.
le_mcc_Call_t* mccCallPtr = GetCallObject(phoneNumPtr, -1, false);
if (mccCallPtr != NULL)
{
le_mem_AddRef(mccCallPtr);
mccCallPtr->refCount++;
}
else
{
mccCallPtr = CreateCallObject (phoneNumPtr,
-1,
LE_MCC_EVENT_TERMINATED,
LE_MCC_TERM_UNDEFINED,
-1);
}
// Manage client session
SessionRefNode_t* newSessionRefPtr = le_mem_ForceAlloc(SessionRefPool);
newSessionRefPtr->sessionRef = le_mcc_GetClientSessionRef();
newSessionRefPtr->link = LE_DLS_LINK_INIT;
// Add the new sessionRef into the the sessionRef list
le_dls_Queue(&mccCallPtr->sessionRefList,
&(newSessionRefPtr->link));
if (mccCallPtr==NULL)
{
LE_ERROR("mccCallPtr null!!!!");
return NULL;
}
LE_DEBUG("Create Call ref.%p", mccCallPtr->callRef);
// Return a Safe Reference for this Call object.
return (mccCallPtr->callRef);
}
//--------------------------------------------------------------------------------------------------
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;
}
//--------------------------------------------------------------------------------------------------
le_event_FdMonitorRef_t le_event_CreateFdMonitor
(
const char* name, ///< [in] Name of the object (for diagnostics).
int fd ///< [in] File descriptor to be monitored for events.
)
//--------------------------------------------------------------------------------------------------
{
// Get a pointer to the thread-specific event loop data record.
event_PerThreadRec_t* perThreadRecPtr = thread_GetEventRecPtr();
// Allocate the object.
FdMonitor_t* fdMonitorPtr = le_mem_ForceAlloc(FdMonitorPool);
// Initialize the object.
fdMonitorPtr->link = LE_DLS_LINK_INIT;
fdMonitorPtr->fd = fd;
fdMonitorPtr->threadRecPtr = perThreadRecPtr;
memset(fdMonitorPtr->handlerArray, 0, sizeof(fdMonitorPtr->handlerArray));
// To start with, no events are in the set to be monitored. They will be added as handlers
// are registered for them. (Although, EPOLLHUP and EPOLLERR will always be monitored
// regardless of what flags we specify). We use epoll in "level-triggered mode".
fdMonitorPtr->epollEvents = 0;
// Assume that the event should wake up the system; can be changed later.
fdMonitorPtr->wakeUp = true;
// Copy the name into it.
if (le_utf8_Copy(fdMonitorPtr->name, name, sizeof(fdMonitorPtr->name), NULL) == LE_OVERFLOW)
{
LE_WARN("FD Monitor object name '%s' truncated to '%s'.", name, fdMonitorPtr->name);
}
LOCK
// Create a safe reference for the object.
fdMonitorPtr->safeRef = le_ref_CreateRef(FdMonitorRefMap, fdMonitorPtr);
// Add it to the thread's FD Monitor list.
le_dls_Queue(&perThreadRecPtr->fdMonitorList, &fdMonitorPtr->link);
// Tell epoll(7) to start monitoring this fd.
struct epoll_event ev;
ev.events = fdMonitorPtr->epollEvents;
ev.data.ptr = fdMonitorPtr->safeRef;
if (epoll_ctl(perThreadRecPtr->epollFd, EPOLL_CTL_ADD, fd, &ev) == -1)
{
LE_FATAL("epoll_ctl(ADD) failed for fd %d. errno = %d (%m)", fd, errno);
}
UNLOCK
return fdMonitorPtr->safeRef;
}
//--------------------------------------------------------------------------------------------------
ni_IteratorRef_t ni_CreateIterator
(
le_msg_SessionRef_t sessionRef, ///< The user session this request occured on.
tu_UserRef_t userRef, ///< Create the iterator for this user.
tdb_TreeRef_t treeRef, ///< The tree to create the iterator with.
ni_IteratorType_t type, ///< The type of iterator we are creating, read or write?
const char* initialPathPtr ///< The node to move to in the specified tree.
)
//--------------------------------------------------------------------------------------------------
{
LE_ASSERT(sessionRef != NULL);
LE_ASSERT(userRef != NULL);
LE_ASSERT(treeRef != NULL);
// Allocate the object and setup it's initial properties.
ni_IteratorRef_t iteratorRef = le_mem_ForceAlloc(IteratorPoolRef);
iteratorRef->sessionRef = sessionRef;
iteratorRef->userRef = userRef;
iteratorRef->treeRef = treeRef;
iteratorRef->type = type;
iteratorRef->reference = NULL;
iteratorRef->isClosed = false;
// If this is a write iterator, then shadow the tree instead of accessing it directly.
if (iteratorRef->type == NI_WRITE)
{
iteratorRef->treeRef = tdb_ShadowTree(iteratorRef->treeRef);
}
// Get the root node of the requested tree, or if this is a write iterator... Get the shadowed
// root node of the tree.
iteratorRef->currentNodeRef = tdb_GetRootNode(iteratorRef->treeRef);
iteratorRef->pathIterRef = le_pathIter_CreateForUnix("/");
LE_DEBUG("Created a new %s iterator object <%p> for user %u (%s) on tree %s.",
TypeString(type),
iteratorRef,
tu_GetUserId(userRef),
tu_GetUserName(userRef),
tdb_GetTreeName(treeRef));
// If we were given an initial path, go to it now. Otherwise stay on the root node.
if (initialPathPtr)
{
ni_GoToNode(iteratorRef, initialPathPtr);
}
// Update the tree so that it can keep track of this iterator.
tdb_RegisterIterator(treeRef, iteratorRef);
// All done.
return iteratorRef;
}
//--------------------------------------------------------------------------------------------------
static int MessageArrivedHandler
(
void* contextPtr,
char* topicNamePtr,
int topicLen,
MQTTClient_message* messagePtr
)
{
mqtt_Session* s = le_ref_Lookup(SessionRefMap, contextPtr);
if (s == NULL)
{
LE_WARN("Session doesn't exist");
return true;
}
mqtt_Message* storedMsgPtr = le_mem_ForceAlloc(MessagePoolRef);
LE_ASSERT(storedMsgPtr);
memset(storedMsgPtr, 0, sizeof(*storedMsgPtr));
LE_DEBUG("MessageArrivedHandler called for topic=%s. Storing session=0x%p", topicNamePtr, contextPtr);
storedMsgPtr->sessionRef = contextPtr;
// When topicLen is 0 it means that the topic contains embedded nulls and can't be treated as a
// normal C string
storedMsgPtr->topicLength = (topicLen == 0) ? (strlen(topicNamePtr) + 1) : topicLen;
storedMsgPtr->topicPtr = le_mem_ForceAlloc(TopicPoolRef);
LE_ASSERT(storedMsgPtr->topicPtr);
memset(storedMsgPtr->topicPtr, 0, sizeof(MQTT_MAX_TOPIC_LENGTH));
memcpy(storedMsgPtr->topicPtr, topicNamePtr, storedMsgPtr->topicLength);
storedMsgPtr->payloadLength = messagePtr->payloadlen;
storedMsgPtr->payloadPtr = le_mem_ForceAlloc(PayloadPoolRef);
LE_ASSERT(storedMsgPtr->payloadPtr);
memset(storedMsgPtr->payloadPtr, 0, sizeof(MQTT_MAX_PAYLOAD_LENGTH));
memcpy(storedMsgPtr->payloadPtr, messagePtr->payload, storedMsgPtr->payloadLength);
le_event_Report(ReceiveThreadEventId, &storedMsgPtr, sizeof(mqtt_Message*));
return true;
}
//--------------------------------------------------------------------------------------------------
static ThreadObj_t* CreateThread
(
const char* name, ///< [in] Name of the thread.
le_thread_MainFunc_t mainFunc, ///< [in] The thread's main function.
void* context ///< [in] Value to pass to mainFunc when it is called.
)
{
// Create a new thread object.
ThreadObj_t* threadPtr = le_mem_ForceAlloc(ThreadPool);
// Copy the name. We will make the names unique by adding the thread ID later so we allow any
// string as the name.
LE_WARN_IF(le_utf8_Copy(threadPtr->name, name, sizeof(threadPtr->name), NULL) == LE_OVERFLOW,
"Thread name '%s' has been truncated to '%s'.",
name,
threadPtr->name);
// Initialize the pthreads attribute structure.
LE_ASSERT(pthread_attr_init(&(threadPtr->attr)) == 0);
// Make sure when we create the thread it takes it attributes from the attribute object,
// as opposed to inheriting them from its parent thread.
if (pthread_attr_setinheritsched(&(threadPtr->attr), PTHREAD_EXPLICIT_SCHED) != 0)
{
LE_CRIT("Could not set scheduling policy inheritance for thread '%s'.", name);
}
// By default, Legato threads are not joinable (they are detached).
if (pthread_attr_setdetachstate(&(threadPtr->attr), PTHREAD_CREATE_DETACHED) != 0)
{
LE_CRIT("Could not set the detached state for thread '%s'.", name);
}
threadPtr->isJoinable = false;
threadPtr->isStarted = false;
threadPtr->mainFunc = mainFunc;
threadPtr->context = context;
threadPtr->destructorList = LE_SLS_LIST_INIT;
threadPtr->threadHandle = 0;
memset(&threadPtr->mutexRec, 0, sizeof(threadPtr->mutexRec));
memset(&threadPtr->semaphoreRec, 0, sizeof(threadPtr->semaphoreRec));
memset(&threadPtr->eventRec, 0, sizeof(threadPtr->eventRec));
memset(&threadPtr->timerRec, 0, sizeof(threadPtr->timerRec));
// Create a safe reference for this object.
Lock();
threadPtr->safeRef = le_ref_CreateRef(ThreadRefMap, threadPtr);
Unlock();
return threadPtr;
}
//--------------------------------------------------------------------------------------------------
le_mrc_ScanInformation_ListRef_t le_mrc_PerformCellularNetworkScan
(
le_mrc_Rat_t ratMask ///< [IN] Technology mask
)
{
le_result_t result;
le_mrc_ScanInformationList_t* newScanInformationListPtr = NULL;
uint32_t networkScan = 0;
newScanInformationListPtr = le_mem_ForceAlloc(ScanInformationListPool);
newScanInformationListPtr->paScanInformationList = LE_DLS_LIST_INIT;
newScanInformationListPtr->safeRefScanInformationList = LE_DLS_LIST_INIT;
newScanInformationListPtr->currentLink = NULL;
if (ratMask == LE_MRC_RAT_ALL) {
networkScan |= PA_MRC_METWORK_MASK_GSM;
networkScan |= PA_MRC_METWORK_MASK_UTMS;
networkScan |= PA_MRC_METWORK_MASK_LTE;
networkScan |= PA_MRC_METWORK_MASK_TD_SCDMA;
}
else
{
if (ratMask&LE_MRC_RAT_GSM)
{
networkScan |= PA_MRC_METWORK_MASK_GSM;
}
if (ratMask&LE_MRC_RAT_UTMS)
{
networkScan |= PA_MRC_METWORK_MASK_UTMS;
}
if (ratMask&LE_MRC_RAT_LTE)
{
networkScan |= PA_MRC_METWORK_MASK_LTE;
}
if (ratMask&LE_MRC_RAT_TC_SCDMA)
{
networkScan |= PA_MRC_METWORK_MASK_LTE;
}
}
result = pa_mrc_PerformNetworkScan(networkScan,PA_MRC_SCAN_PLMN,
&(newScanInformationListPtr->paScanInformationList));
if (result != LE_OK)
{
le_mem_Release(newScanInformationListPtr);
return NULL;
}
return le_ref_CreateRef(ScanInformationListRefMap, newScanInformationListPtr);
}
void ipcTest_EchoLargeEnum
(
ipcTest_ServerCmdRef_t serverCmdPtr,
ipcTest_LargeEnum_t InValue
)
{
ipcTest_LargeEnum_t* valuePtr = le_mem_ForceAlloc(ValuePool);
*valuePtr = InValue;
le_event_QueueFunction(AsyncServer_EchoLargeEnumRespond,
serverCmdPtr,
valuePtr);
}
//--------------------------------------------------------------------------------------------------
static void ReportStatus
(
uint32_t simCard, ///< [IN] Sim Card Number
le_sim_States_t simState ///< [IN] Sim Card Status
)
{
pa_sim_Event_t* eventPtr = le_mem_ForceAlloc(SimEventPoolRef);
eventPtr->num = simCard;
eventPtr->state = simState;
LE_DEBUG("Send Event SIM number %d, SIM state %d",eventPtr->num,eventPtr->state);
le_event_ReportWithRefCounting(EventNewSimStateId,eventPtr);
}
//--------------------------------------------------------------------------------------------------
LE_SHARED appCfg_Iter_t appCfg_CreateAppsIter
(
void
)
{
AppsIter_t* iterPtr = le_mem_ForceAlloc(AppIterPool);
iterPtr->type = ITER_TYPE_APP;
iterPtr->cfgIter = le_cfg_CreateReadTxn(CFG_APPS_LIST);
iterPtr->atFirst = true;
return iterPtr;
}
//--------------------------------------------------------------------------------------------------
static dstr_Ref_t NewSegment
(
void
)
//--------------------------------------------------------------------------------------------------
{
dstr_Ref_t newSegmentRef = le_mem_ForceAlloc(DynamicStringPoolRef);
memset(newSegmentRef->body.value, 0, SEGMENT_SIZE);
newSegmentRef->body.link = LE_SLS_LINK_INIT;
return newSegmentRef;
}
//--------------------------------------------------------------------------------------------------
dstr_Ref_t dstr_New
(
void
)
//--------------------------------------------------------------------------------------------------
{
dstr_Ref_t newHeadRef = le_mem_ForceAlloc(DynamicStringPoolRef);
newHeadRef->head.magic = HEADER_MAGIC;
newHeadRef->head.list = LE_SLS_LIST_INIT;
return newHeadRef;
}
//--------------------------------------------------------------------------------------------------
le_result_t mqtt_CreateSession
(
const char* brokerURIPtr, ///< [IN] The URI of the MQTT broker to connect to. Should be in
/// the form protocol://host:port. eg. tcp://1.2.3.4:1883 or
/// ssl://example.com:8883
const char* clientIdPtr, ///< [IN] Any unique string. If a client connects to an MQTT
/// broker using the same clientId as an existing session, then
/// the existing session will be terminated.
mqtt_SessionRef_t* sessionRefPtr ///< [OUT] The created session if the return result is LE_OK
)
{
mqtt_Session* s = le_mem_ForceAlloc(MQTTSessionPoolRef);
LE_ASSERT(s);
memset(s, 0, sizeof(*s));
const MQTTClient_connectOptions initConnOpts = MQTTClient_connectOptions_initializer;
memcpy(&(s->connectOptions), &initConnOpts, sizeof(initConnOpts));
const MQTTClient_SSLOptions initSslOpts = MQTTClient_SSLOptions_initializer;
memcpy(&(s->sslOptions), &initSslOpts, sizeof(initSslOpts));
s->sslOptions.trustStore = SslCaCertsPathPtr;
const int createResult = MQTTClient_create(
&(s->client),
brokerURIPtr,
clientIdPtr,
MQTTCLIENT_PERSISTENCE_NONE,
NULL);
if (createResult != MQTTCLIENT_SUCCESS)
{
LE_ERROR("Couldn't create MQTT session. Paho error code: %d", createResult);
le_mem_Release(s);
return LE_FAULT;
}
le_msg_SessionRef_t clientSession = mqtt_GetClientSessionRef();
s->clientSession = clientSession;
*sessionRefPtr = le_ref_CreateRef(SessionRefMap, s);
LE_ASSERT(MQTTClient_setCallbacks(
s->client,
*sessionRefPtr,
&ConnectionLostHandler,
&MessageArrivedHandler,
NULL) == MQTTCLIENT_SUCCESS);
return LE_OK;
}
//--------------------------------------------------------------------------------------------------
le_avdata_AssetInstanceRef_t le_avdata_Create
(
const char* assetName
///< [IN]
)
{
// Get the client's credentials.
pid_t pid;
uid_t uid;
if (le_msg_GetClientUserCreds(le_avdata_GetClientSessionRef(), &uid, &pid) != LE_OK)
{
LE_KILL_CLIENT("Could not get credentials for the client.");
return NULL;
}
// Look up the process's application name.
char appName[LE_LIMIT_APP_NAME_LEN+1];
le_result_t result = le_appInfo_GetName(pid, appName, sizeof(appName));
LE_FATAL_IF(result == LE_OVERFLOW, "Buffer too small to contain the application name.");
// TODO: Should this be LE_KILL_CLIENT instead?
LE_FATAL_IF(result != LE_OK, "Could not get app name");
// Create an instance of the asset
assetData_InstanceDataRef_t instRef;
int instanceId;
LE_ASSERT( assetData_CreateInstanceByName(appName, assetName, -1, &instRef) == LE_OK );
LE_ASSERT( instRef != NULL );
LE_ASSERT( assetData_GetInstanceId(instRef, &instanceId) == LE_OK );
LE_PRINT_VALUE("%i", instanceId);
// Return a safe reference for the instance
InstanceRefData_t* instRefDataPtr = le_mem_ForceAlloc(InstanceRefDataPoolRef);
instRefDataPtr->clientSessionRef = le_avdata_GetClientSessionRef();
instRefDataPtr->instRef = instRef;
instRef = le_ref_CreateRef(InstanceRefMap, instRefDataPtr);
return instRef;
}
void ipcTest_EchoString
(
ipcTest_ServerCmdRef_t serverCmdPtr,
const char* InString,
size_t OutStringSize
)
{
// Cap output string size at maximum size of buffer
if (OutStringSize > MAX_VALUE_SIZE) { OutStringSize = MAX_VALUE_SIZE; }
char* OutString = le_mem_ForceAlloc(ValuePool);
strncpy(OutString, InString, OutStringSize);
OutString[OutStringSize-1] = '\0';
le_event_QueueFunction(AsyncServer_EchoStringRespond,
serverCmdPtr,
OutString);
}
