//--------------------------------------------------------------------------------------------------
static Service_t* GetService
(
le_msg_ProtocolRef_t protocolRef,
const char* serviceName
)
//--------------------------------------------------------------------------------------------------
{
ServiceId_t id;
id.protocolRef = protocolRef;
LE_FATAL_IF(le_utf8_Copy(id.name, serviceName, sizeof(id.name), NULL) == LE_OVERFLOW,
"Service ID '%s' too long (should only be %zu bytes total).",
serviceName,
sizeof(id.name));
Service_t* servicePtr = le_hashmap_Get(ServiceMapRef, &id);
if (servicePtr == NULL)
{
servicePtr = CreateService(protocolRef, serviceName);
}
else
{
le_mem_AddRef(servicePtr);
}
return servicePtr;
}
//--------------------------------------------------------------------------------------------------
void le_pm_Relax(le_pm_WakeupSourceRef_t w)
{
WakeupSource_t *ws, *entry;
// Validate the reference, check if it exists
ws = ToWakeupSource(w);
// If the wakeup source is NULL then the client will have
// been killed and we can just return
if (NULL == ws)
return;
entry = (WakeupSource_t*)le_hashmap_Get(PowerManager.locks, ws->name);
if (!entry)
LE_FATAL("Wakeup source '%s' not created.\n", ws->name);
if (!entry->taken) {
LE_ERROR("Wakeup source '%s' already released.", entry->name);
return;
}
// write to /sys/power/wake_unlock
if (0 > write(PowerManager.wu, entry->name, strlen(entry->name)))
LE_FATAL("Error releasing wakeup soruce '%s', errno = %d.",
entry->name, errno);
entry->taken = LE_OFF;
return;
}
//--------------------------------------------------------------------------------------------------
static WatchdogObj_t* LookupClientWatchdogPtrById
(
pid_t clientPid ///< Client we want the watchdog for
)
{
return le_hashmap_Get(WatchdogRefsContainer, &clientPid);
}
static int mangoh_bridge_air_vantage_pushString(void* param, const unsigned char* data, uint32_t size)
{
mangoh_bridge_air_vantage_t* airVantage = (mangoh_bridge_air_vantage_t*)param;
int32_t res = LE_OK;
LE_ASSERT(airVantage);
LE_ASSERT(data);
LE_DEBUG("---> PUSH STRING");
uint8_t* ptr = (uint8_t*)data;
uint8_t len = 0;
memcpy(&len, ptr, sizeof(len));
LE_DEBUG("len(%u)", len);
ptr += sizeof(len);
char fieldName[MANGOH_BRIDGE_AIR_VANTAGE_FIELD_NAME_MAX_LEN] = {0};
memcpy(fieldName, ptr, len);
LE_DEBUG("field('%s')", fieldName);
ptr += len;
char val[MANGOH_BRIDGE_AIR_VANTAGE_VALUE_MAX_LEN] = {0};
memcpy(val, ptr, size - len - sizeof(len));
LE_DEBUG("value('%s')", val);
dataRouter_WriteString(fieldName, val, time(NULL));
dataRouter_DataUpdateHandlerRef_t dataUpdateHandlerRef = le_hashmap_Get(airVantage->dataUpdateHandlers, fieldName);
if (!dataUpdateHandlerRef)
{
LE_DEBUG("add data update handler('%s')", fieldName);
dataUpdateHandlerRef = dataRouter_AddDataUpdateHandler(fieldName, mangoh_bridge_air_vantage_dataUpdateHdlr, airVantage);
if (!dataUpdateHandlerRef)
{
LE_ERROR("ERROR dataRouter_AddDataUpdateHandler() failed");
res = LE_FAULT;
goto cleanup;
}
if (le_hashmap_Put(airVantage->dataUpdateHandlers, fieldName, dataUpdateHandlerRef))
{
LE_ERROR("ERROR le_hashmap_Put() failed");
res = LE_FAULT;
goto cleanup;
}
}
res = mangoh_bridge_sendResult(airVantage->bridge, 0);
if (res != LE_OK)
{
LE_ERROR("ERROR mangoh_bridge_sendResult() failed(%d)", res);
goto cleanup;
}
cleanup:
return res;
}
//--------------------------------------------------------------------------------------------------
le_pm_WakeupSourceRef_t le_pm_NewWakeupSource(uint32_t opts, const char *tag)
{
WakeupSource_t *ws;
Client_t *cl;
char name[LEGATO_WS_NAME_LEN];
if (!tag || *tag == '\0' || strlen(tag) > LE_PM_TAG_LEN) {
LE_KILL_CLIENT("Error: Tag value is invalid or NULL.");
return NULL;
}
// Find and validate client record
cl = to_Client_t(le_hashmap_Get(PowerManager.clients,
le_pm_GetClientSessionRef()));
// Check if identical wakeup source already exists for this client
sprintf(name, LEGATO_WS_NAME_FORMAT, tag, cl->pid);
// Lookup wakeup source by name
ws = (WakeupSource_t*)le_hashmap_Get(PowerManager.locks, name);
if (ws) {
LE_KILL_CLIENT("Error: Tag '%s' already exists.", tag);
return NULL;
}
// Allocate and populate wakeup source record (exits on error)
ws = (WakeupSource_t*)le_mem_ForceAlloc(PowerManager.lpool);
ws->cookie = PM_WAKEUP_SOURCE_COOKIE;
strcpy(ws->name, name);
ws->taken = LE_OFF;
ws->pid = cl->pid;
ws->wsref = le_ref_CreateRef(PowerManager.refs, ws);
// Store record in table of wakeup sources
if (le_hashmap_Put(PowerManager.locks, ws->name, ws))
LE_FATAL("Error adding wakeup source '%s'.", ws->name);
LE_INFO("Created new wakeup source '%s' for pid %d.", ws->name, ws->pid);
return (le_pm_WakeupSourceRef_t)ws->wsref;
}
//--------------------------------------------------------------------------------------------------
static void AsyncRecvHandler(void* handle, short events)
{
// Retrieve the Handle record, using the FD
HandleRecord_t* connectionRecordPtr = le_hashmap_Get(HandleRecordByFileDescriptor, handle);
if (connectionRecordPtr == NULL)
{
LE_ERROR("Unable to find matching Handle Record, fd [%" PRIiPTR "]", (intptr_t) handle);
return;
}
// Notify the RPC Proxy
AsyncReceiveHandlerFuncPtr(connectionRecordPtr, events);
}
//--------------------------------------------------------------------------------------------------
static tu_UserRef_t GetUser
(
uid_t userId, ///< [IN] The user id to look up.
bool* wasCreated ///< [OUT] Was the user info created for this request? Pass NULL if you don't
///< need this.
)
//--------------------------------------------------------------------------------------------------
{
// If the connected user has the same uid we're running under, treat the user as if they're
// root.
if (userId == geteuid())
{
userId = 0;
}
if (wasCreated)
{
*wasCreated = false;
}
// Now try to look up this user in our hash table. If not found, create it now.
tu_UserRef_t userRef = le_hashmap_Get(UserCollectionRef, &userId);
if (userRef == NULL)
{
// At this point, grab the user's app name, which will succeed if it is an app, otherwise we get
// the standard user name.
char userName[LIMIT_MAX_USER_NAME_BYTES] = "";
if (user_GetAppName(userId, userName, sizeof(userName)) != LE_OK)
{
LE_ASSERT(user_GetName(userId, userName, sizeof(userName)) == LE_OK);
}
userRef = CreateUserInfo(userId, userName, userName);
if (wasCreated)
{
*wasCreated = true;
}
}
return userRef;
}
//--------------------------------------------------------------------------------------------------
static void ListeningRecvHandler(void* handle, short events)
{
int clientFd = -1;
if (events != POLLIN)
{
LE_ERROR("Unexpected fd event(s): 0x%hX", events);
return;
}
// Retrieve the Handle record, using the FD
HandleRecord_t* parentRecordPtr = le_hashmap_Get(HandleRecordByFileDescriptor, handle);
if (parentRecordPtr == NULL)
{
LE_ERROR("Unable to find matching Handle Record, fd [%" PRIiPTR "]", (intptr_t) handle);
return;
}
// Accept the connection, setting the connection to be non-blocking.
clientFd = accept((int)(size_t)handle, NULL, NULL);
if (clientFd < 0)
{
LE_ERROR("Failed to accept client connection. Errno %d", errno);
}
LE_INFO("Accepting Client socket connection, fd [%d]", clientFd);
HandleRecord_t *connectionRecordPtr = le_mem_AssertAlloc(HandleRecordPoolRef);
// Initialize the connection record
connectionRecordPtr->fd = clientFd;
connectionRecordPtr->isListeningFd = false;
connectionRecordPtr->parentRecordPtr = parentRecordPtr;
le_hashmap_Put(HandleRecordByFileDescriptor, (void*)(intptr_t) connectionRecordPtr->fd, connectionRecordPtr);
LE_INFO("Notifying RPC Proxy Client socket connected, fd [%d]", clientFd);
// Notify the RPC Proxy of the Client connection
AsyncConnectionHandlerFuncPtr(connectionRecordPtr, events);
}
static int mangoh_bridge_air_vantage_pushFloat(void* param, const unsigned char* data, uint32_t size)
{
mangoh_bridge_air_vantage_t* airVantage = (mangoh_bridge_air_vantage_t*)param;
double fVal = 0;
int32_t res = LE_OK;
LE_ASSERT(airVantage);
LE_ASSERT(data);
LE_DEBUG("---> PUSH FLOAT");
uint8_t* ptr = (uint8_t*)data;
uint8_t len = 0;
memcpy(&len, ptr, sizeof(len));
LE_DEBUG("len(%u)", len);
ptr += sizeof(len);
char fieldName[MANGOH_BRIDGE_AIR_VANTAGE_FIELD_NAME_MAX_LEN] = {0};
memcpy(fieldName, ptr, len);
LE_DEBUG("field('%s')", fieldName);
ptr += len;
int8_t precision = 0;
memcpy(&precision, ptr, sizeof(precision));
LE_DEBUG("precision(%u)", precision);
ptr += sizeof(precision);
int32_t val = 0;
memcpy(&val, ptr, sizeof(val));
LE_DEBUG("value(%d)", val);
fVal = val;
while (precision-- > 0) fVal /= 10.0;
LE_DEBUG("write(%f)", fVal);
dataRouter_WriteFloat(fieldName, fVal, time(NULL));
dataRouter_DataUpdateHandlerRef_t dataUpdateHandlerRef = le_hashmap_Get(airVantage->dataUpdateHandlers, fieldName);
if (!dataUpdateHandlerRef)
{
LE_DEBUG("add data update handler('%s')", fieldName);
dataUpdateHandlerRef = dataRouter_AddDataUpdateHandler(fieldName, mangoh_bridge_air_vantage_dataUpdateHdlr, airVantage);
if (!dataUpdateHandlerRef)
{
LE_ERROR("ERROR dataRouter_AddDataUpdateHandler() failed");
res = LE_FAULT;
goto cleanup;
}
if (le_hashmap_Put(airVantage->dataUpdateHandlers, fieldName, dataUpdateHandlerRef))
{
LE_ERROR("ERROR le_hashmap_Put() failed");
res = LE_FAULT;
goto cleanup;
}
}
res = mangoh_bridge_sendResult(airVantage->bridge, 0);
if (res != LE_OK)
{
LE_ERROR("ERROR mangoh_bridge_sendResult() failed(%d)", res);
goto cleanup;
}
cleanup:
return res;
}
