//--------------------------------------------------------------------------------------------------
static void LoadECallSettings
(
int32_t* hMinAccuracyPtr,
int32_t* dirMinAccuracyPtr
)
{
char psapStr[LE_MDMDEFS_PHONE_NUM_MAX_BYTES] = {0};
LE_DEBUG("Start reading eCall app settings in Configuration Tree");
le_cfg_IteratorRef_t eCallCfgRef = le_cfg_CreateReadTxn(CFG_ECALL_APP_PATH);
// Get PSAP
if (le_cfg_NodeExists(eCallCfgRef, CFG_NODE_PSAP))
{
if ( le_cfg_GetString(eCallCfgRef, CFG_NODE_PSAP, psapStr, sizeof(psapStr), "") != LE_OK )
{
LE_FATAL("No node value set for '%s', exit the app!", CFG_NODE_PSAP);
}
LE_DEBUG("eCall settings, PSAP number is %s", psapStr);
if (le_ecall_SetPsapNumber(psapStr) != LE_OK)
{
LE_FATAL("Cannot set PSAP number, exit the app!");
}
}
else
{
LE_FATAL("No value set for '%s', restart the app!", CFG_NODE_PSAP);
}
// Get minimum horizontal accuracy
if (le_cfg_NodeExists(eCallCfgRef, CFG_NODE_H_MIN_ACCURACY))
{
*hMinAccuracyPtr = le_cfg_GetInt(eCallCfgRef, CFG_NODE_H_MIN_ACCURACY, DEFAULT_H_ACCURACY);
LE_DEBUG("eCall app settings, horizontal accuracy is %d meter(s)", *hMinAccuracyPtr);
}
else
{
*hMinAccuracyPtr = DEFAULT_H_ACCURACY;
}
// Get minimum direction accuracy
if (le_cfg_NodeExists(eCallCfgRef, CFG_NODE_DIR_MIN_ACCURACY))
{
*dirMinAccuracyPtr = le_cfg_GetInt(eCallCfgRef, CFG_NODE_DIR_MIN_ACCURACY, DEFAULT_DIR_ACCURACY);
LE_DEBUG("eCall app settings, direction accuracy is %d degree(s)", *dirMinAccuracyPtr);
}
else
{
*dirMinAccuracyPtr = DEFAULT_DIR_ACCURACY;
}
le_cfg_CancelTxn(eCallCfgRef);
}
// -------------------------------------------------------------------------------------------------
static json_t* CreateJsonNodeFromIterator
(
le_cfg_IteratorRef_t iterRef ///< The iterator to read from.
)
// -------------------------------------------------------------------------------------------------
{
char nodeName[LE_CFG_NAME_LEN_BYTES] = "";
le_cfg_nodeType_t type = le_cfg_GetNodeType(iterRef, "");
le_cfg_GetNodeName(iterRef, "", nodeName, sizeof(nodeName));
json_t* nodePtr = CreateJsonNode(nodeName, NodeTypeStr(type));
switch (type)
{
case LE_CFG_TYPE_EMPTY:
json_object_set_new(nodePtr,
JSON_FIELD_TYPE,
json_string(NodeTypeStr(LE_CFG_TYPE_STEM)));
json_object_set_new(nodePtr, JSON_FIELD_CHILDREN, json_array());
break;
case LE_CFG_TYPE_BOOL:
json_object_set_new(nodePtr,
JSON_FIELD_VALUE,
json_boolean(le_cfg_GetBool(iterRef, "", false)));
break;
case LE_CFG_TYPE_STRING:
{
char strBuffer[LE_CFG_STR_LEN_BYTES] = "";
le_cfg_GetString(iterRef, "", strBuffer, LE_CFG_STR_LEN_BYTES, "");
json_object_set_new(nodePtr, JSON_FIELD_VALUE, json_string(strBuffer));
}
break;
case LE_CFG_TYPE_INT:
json_object_set_new(nodePtr,
JSON_FIELD_VALUE,
json_integer(le_cfg_GetInt(iterRef, "", false)));
break;
case LE_CFG_TYPE_FLOAT:
json_object_set_new(nodePtr,
JSON_FIELD_VALUE,
json_real(le_cfg_GetFloat(iterRef, "", false)));
break;
case LE_CFG_TYPE_STEM:
default:
// Unknown type, nothing to do
json_decref(nodePtr);
nodePtr = NULL;
break;
}
return nodePtr;
}
//--------------------------------------------------------------------------------------------------
LE_SHARED size_t appCfg_GetSecStoreLimit
(
appCfg_Iter_t appIterRef ///< [IN] Apps iterator
)
{
CheckFor(appIterRef, ITER_TYPE_APP);
return le_cfg_GetInt(appIterRef->cfgIter, CFG_LIMIT_SEC_STORE, DEFAULT_LIMIT_SEC_STORE);
}
static void IncTestCount
(
void
)
{
le_cfg_IteratorRef_t iterRef = le_cfg_CreateWriteTxn("/configTest/testCount");
le_cfg_SetInt(iterRef, "", le_cfg_GetInt(iterRef, "", 0) + 1);
le_cfg_CommitTxn(iterRef);
}
//--------------------------------------------------------------------------------------------------
static int GetRebootCount
(
void
)
{
le_cfg_IteratorRef_t iterRef = le_cfg_CreateReadTxn(BOOT_COUNT_CFG);
int bootCount = le_cfg_GetInt(iterRef, BOOT_COUNT_CFG_VAR, -1);
le_cfg_CancelTxn(iterRef);
return bootCount;
}
//--------------------------------------------------------------------------------------------------
static int GetCfgResourceLimit
(
le_cfg_IteratorRef_t limitCfg, // The iterator to use to read the configured limit. This
// iterator is owned by the caller and should not be deleted
// in this function.
const char* nodeName, // The name of the node in the config tree that holds the value.
int defaultValue // The default value to use if the config value is invalid.
)
{
int limitValue = le_cfg_GetInt(limitCfg, nodeName, defaultValue);
if (!le_cfg_NodeExists(limitCfg, nodeName))
{
LE_INFO("Configured resource limit %s is not available. Using the default value %d.",
nodeName, defaultValue);
return defaultValue;
}
if (le_cfg_IsEmpty(limitCfg, nodeName))
{
LE_WARN("Configured resource limit %s is empty. Using the default value %d.",
nodeName, defaultValue);
return defaultValue;
}
if (le_cfg_GetNodeType(limitCfg, nodeName) != LE_CFG_TYPE_INT)
{
LE_ERROR("Configured resource limit %s is the wrong type. Using the default value %d.",
nodeName, defaultValue);
return defaultValue;
}
if (limitValue < 0)
{
LE_ERROR("Configured resource limit %s is negative. Using the default value %d.",
nodeName, defaultValue);
return defaultValue;
}
return limitValue;
}
//--------------------------------------------------------------------------------------------------
static le_result_t GetCfgResourceLimit
(
le_cfg_IteratorRef_t limitCfg, // The iterator pointing to the configured limit to read. This
// iterator is a owned by the caller and should not be deleted
// in this function.
rlim_t* limitValuePtr // The value read from the config tree.
)
{
if (le_cfg_IsEmpty(limitCfg, ""))
{
return LE_FAULT;
}
int limitValue = le_cfg_GetInt(limitCfg, "", 0);
if (limitValue < 0)
{
// Negative values are not allowed.
return LE_FAULT;
}
*limitValuePtr = (rlim_t)limitValue;
return LE_OK;
}
//--------------------------------------------------------------------------------------------------
static assetData_InstanceDataRef_t GetObject9InstanceForApp
(
const char* appName, ///< Name of the application in question.
bool mapIfNotFound ///< If an instance was created, should a mapping be created for it?
)
//--------------------------------------------------------------------------------------------------
{
LE_DEBUG("Getting object 9 instance for application '%s'.", appName);
// Attempt to read the mapping from the configuration.
assetData_InstanceDataRef_t instanceRef = NULL;
le_cfg_IteratorRef_t iterRef = le_cfg_CreateReadTxn(CFG_OBJECT_INFO_PATH);
le_cfg_GoToNode(iterRef, appName);
int instanceId = le_cfg_GetInt(iterRef, "oiid", -1);
le_cfg_CancelTxn(iterRef);
if (instanceId != -1)
{
LE_DEBUG("Was mapped to instance, %d.", instanceId);
// Looks like there was a mapping. Try to get that instance and make sure it's not taken
// by another application. If the instance was taken by another application, remap this
// application to a new instance and update the mapping.
if (LE_OK == assetData_GetInstanceRefById(LWM2M_NAME,
LWM2M_SOFTWARE_UPDATE,
instanceId,
&instanceRef))
{
char newName[MAX_APP_NAME_BYTES] = "";
LE_ASSERT(assetData_client_GetString(instanceRef,
O9F_PKG_NAME,
newName,
sizeof(newName)) == LE_OK);
if (strcmp(newName, appName) != 0)
{
LE_DEBUG("Instance has been taken by '%s', creating new.", newName);
LE_ASSERT(assetData_CreateInstanceById(LWM2M_NAME, 9, -1, &instanceRef) == LE_OK);
LE_ASSERT(assetData_client_SetString(instanceRef, O9F_PKG_NAME, appName) == LE_OK);
if (mapIfNotFound)
{
LE_DEBUG("Recording new instance id.");
SetObject9InstanceForApp(appName, instanceRef);
}
}
else
{
LE_DEBUG("Instance is existing and has been reused.");
}
}
else
{
LE_DEBUG("No instance found, creating new as mapped.");
LE_ASSERT(assetData_CreateInstanceById(LWM2M_NAME,
9,
instanceId,
&instanceRef) == LE_OK);
LE_ASSERT(assetData_client_SetString(instanceRef, O9F_PKG_NAME, appName) == LE_OK);
}
}
else
{
LE_DEBUG("No instance mapping found, creating new.");
// A mapping was not found. So create a new object, and let the data store assign an
// instance Id. If desired, at this point record the instance mapping for later use.
LE_ASSERT(assetData_CreateInstanceById(LWM2M_NAME, 9, -1, &instanceRef) == LE_OK);
LE_ASSERT(assetData_client_SetString(instanceRef, O9F_PKG_NAME, appName) == LE_OK);
if (mapIfNotFound)
{
LE_DEBUG("Recording new instance id.");
SetObject9InstanceForApp(appName, instanceRef);
}
}
return instanceRef;
}
//--------------------------------------------------------------------------------------------------
static void ConfigureGdb
(
void
)
{
le_cfg_ConnectService();
le_cfgAdmin_ConnectService();
// Get a write iterator to the application node.
le_cfg_IteratorRef_t cfgIter = le_cfg_CreateWriteTxn("/apps");
le_cfg_GoToNode(cfgIter, AppName);
// Check if this is a temporary configuration that was previously created by this or a similar
// tool.
if (!le_cfg_IsEmpty(cfgIter, CFG_DEBUG_TOOL))
{
char debugTool[LIMIT_MAX_PATH_BYTES];
// Don't need to check return code because the value is just informative and does not matter
// if it is truncated.
le_cfg_GetString(cfgIter, CFG_DEBUG_TOOL, debugTool, sizeof(debugTool), "");
fprintf(stderr, "This application has already been configured for %s debug mode.\n", debugTool);
exit(EXIT_FAILURE);
}
// Write into the config's debug tool node to indicate that this configuration has been modified.
le_cfg_SetString(cfgIter, CFG_DEBUG_TOOL, "gdb");
// Add 512K to the maxFileSytemBytes so that we can debug this app in sandboxed mode
uint32_t maxBytes;
maxBytes = le_cfg_GetInt(cfgIter, "maxFileSystemBytes", DEFAULT_LIMIT_MAX_FILE_SYSTEM_BYTES);
maxBytes += ADD_FILE_SYSTEM_BYTES; // add an additional 512KBytes
LE_INFO("Resetting maxFileSystemBytes to %d bytes", maxBytes);
le_cfg_SetInt(cfgIter, "maxFileSystemBytes", maxBytes);
// Add gdbserver and libs to the app's 'requires/files' section.
le_cfg_GoToNode(cfgIter, "requires/files");
AddImportFiles(cfgIter, &GdbFilesImports, NUM_ARRAY_MEMBERS(GdbFilesImports));
// Add /proc to the app's dirs section.
le_cfg_GoToParent(cfgIter);
le_cfg_GoToNode(cfgIter, "dirs");
AddImportFiles(cfgIter, &GdbDirsImports, NUM_ARRAY_MEMBERS(GdbDirsImports));
// Delete the list of processes.
le_cfg_GoToParent(cfgIter);
le_cfg_GoToParent(cfgIter);
int i;
for (i = 0; i < NumProcs; i++)
{
char nodePath[LIMIT_MAX_PATH_BYTES];
int n = snprintf(nodePath, sizeof(nodePath), "procs/%s", ProcNames[i]);
INTERNAL_ERR_IF(n >= sizeof(nodePath), "Node name is too long.");
INTERNAL_ERR_IF(n < 0, "Format error. %m");
le_cfg_DeleteNode(cfgIter, nodePath);
}
le_cfg_CommitTxn(cfgIter);
}
