Beispiel #1
0
//--------------------------------------------------------------------------------------------------
static void AddImportFiles
(
    le_cfg_IteratorRef_t cfgIter,           ///< [IN] Iterator to the application config.
    const ImportObj_t (*importsPtr)[],      ///< [IN] Imports to include in the application.
    size_t numImports                       ///< [IN] Number of import elements.
)
{
    // Find the last node under the 'files' or 'dirs' section.
    size_t nodeNum = 0;
    char nodePath[LIMIT_MAX_PATH_BYTES];

    while (1)
    {
        int n = snprintf(nodePath, sizeof(nodePath), "%zd", nodeNum);

        INTERNAL_ERR_IF(n >= sizeof(nodePath), "Node name is too long.");
        INTERNAL_ERR_IF(n < 0, "Format error.  %m");

        if (!le_cfg_NodeExists(cfgIter, nodePath))
        {
            break;
        }

        nodeNum++;
    }

    // Start adding files/directories at the end of the current list.
    int i;
    for (i = 0; i < numImports; i++)
    {
        // Add the source.
        int n = snprintf(nodePath, sizeof(nodePath), "%zd/src", nodeNum + i);

        INTERNAL_ERR_IF(n >= sizeof(nodePath), "Node name is too long.");
        INTERNAL_ERR_IF(n < 0, "Format error.  %m");

        le_cfg_SetString(cfgIter, nodePath, (*importsPtr)[i].src);

        // Add the destination.
        n = snprintf(nodePath, sizeof(nodePath), "%zd/dest", nodeNum + i);

        INTERNAL_ERR_IF(n >= sizeof(nodePath), "Node name is too long.");
        INTERNAL_ERR_IF(n < 0, "Format error.  %m");

        le_cfg_SetString(cfgIter, nodePath, (*importsPtr)[i].dest);
    }
}
Beispiel #2
0
static void DeleteTest()
{
    static char pathBuffer[STR_SIZE] = { 0 };

    snprintf(pathBuffer, STR_SIZE, "%s/deleteTest/", TestRootDir);

    le_cfg_IteratorRef_t iterRef = le_cfg_CreateWriteTxn(pathBuffer);

    le_cfg_SetString(iterRef, "valueA", "aNewValue");
    le_cfg_SetString(iterRef, "valueB", "aNewValue");
    le_cfg_SetString(iterRef, "valueC", "aNewValue");

    TestValue(iterRef, "valueA", "aNewValue");
    TestValue(iterRef, "valueB", "aNewValue");
    TestValue(iterRef, "valueC", "aNewValue");

    le_cfg_CommitTxn(iterRef);



    iterRef = le_cfg_CreateWriteTxn(pathBuffer);

    le_cfg_DeleteNode(iterRef, "valueB");

    TestValue(iterRef, "valueA", "aNewValue");
    TestValue(iterRef, "valueB", "");
    TestValue(iterRef, "valueC", "aNewValue");

    le_cfg_CommitTxn(iterRef);



    iterRef = le_cfg_CreateReadTxn(pathBuffer);

    TestValue(iterRef, "valueA", "aNewValue");
    TestValue(iterRef, "valueB", "");
    TestValue(iterRef, "valueC", "aNewValue");

    DumpTree(iterRef, 0);

    le_cfg_CancelTxn(iterRef);
}
Beispiel #3
0
static void ExistAndEmptyTest()
{
    static char pathBuffer[STR_SIZE] = { 0 };
    snprintf(pathBuffer, STR_SIZE, "/%s/existAndEmptyTest/", TestRootDir);

    {
        le_cfg_IteratorRef_t iterRef = le_cfg_CreateWriteTxn(pathBuffer);

        le_cfg_SetEmpty(iterRef, "");
        LE_TEST(le_cfg_IsEmpty(iterRef, "") == true);

        LE_TEST(le_cfg_NodeExists(iterRef, "valueA") == false);
        LE_TEST(le_cfg_NodeExists(iterRef, "valueB") == false);
        LE_TEST(le_cfg_NodeExists(iterRef, "valueC") == false);
        LE_TEST(le_cfg_NodeExists(iterRef, "valueD") == false);

        LE_TEST(le_cfg_IsEmpty(iterRef, "valueA") == true);
        LE_TEST(le_cfg_IsEmpty(iterRef, "valueB") == true);
        LE_TEST(le_cfg_IsEmpty(iterRef, "valueC") == true);
        LE_TEST(le_cfg_IsEmpty(iterRef, "valueD") == true);


        le_cfg_SetString(iterRef, "valueA", "aNewValue");
        le_cfg_SetInt(iterRef, "valueB", 10);
        le_cfg_SetBool(iterRef, "valueC", true);
        le_cfg_SetFloat(iterRef, "valueD", 10.24);

        LE_TEST(le_cfg_NodeExists(iterRef, "valueA") == true);
        LE_TEST(le_cfg_NodeExists(iterRef, "valueB") == true);
        LE_TEST(le_cfg_NodeExists(iterRef, "valueC") == true);
        LE_TEST(le_cfg_NodeExists(iterRef, "valueD") == true);

        LE_TEST(le_cfg_IsEmpty(iterRef, "valueA") == false);
        LE_TEST(le_cfg_IsEmpty(iterRef, "valueB") == false);
        LE_TEST(le_cfg_IsEmpty(iterRef, "valueC") == false);
        LE_TEST(le_cfg_IsEmpty(iterRef, "valueD") == false);

        le_cfg_CommitTxn(iterRef);
    }
}
Beispiel #4
0
//--------------------------------------------------------------------------------------------------
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);
}
//--------------------------------------------------------------------------------------------------
le_result_t le_cellnet_SetSimPinCode
(
    le_sim_Id_t simId,
        ///< [IN]
        ///< SIM identifier.

    const char* pinCodePtr
        ///< [IN]
        ///< PIN code to insert in the config tree.
)
{

    le_result_t result=LE_OK;
    size_t pinCodeLength = strlen(pinCodePtr);

    LE_DEBUG("simId= %d, pinCode= %s",simId,pinCodePtr);

    if (simId >= LE_SIM_ID_MAX)
    {
        LE_ERROR("Invalid simId (%d) provided!", simId);
        result = LE_OUT_OF_RANGE;
    }
    else
    {
        //void entry is taken into account
        if (strncmp(pinCodePtr,"",LE_SIM_PIN_MAX_LEN)!=0)
        {
            if (pinCodeLength > LE_SIM_PIN_MAX_LEN)
            {
                LE_KILL_CLIENT("PIN code exceeds %d", LE_SIM_PIN_MAX_LEN);
                return LE_FAULT;
            }
            else if (pinCodeLength < LE_SIM_PIN_MIN_LEN)
            {
                LE_ERROR("SIM PIN code is not long enough (min 4 digits)");
                result = LE_UNDERFLOW;
            }
            else
            {
                // test SIM pincode format
                int i;
                bool test_ok = true;
                for (i=0; ((i<pinCodeLength) && test_ok); i++)
                {
                    if ((pinCodePtr[i] < 0x30) || (pinCodePtr[i] > 0x39))
                    {
                        test_ok = false;
                        break;
                    }
                }
                if (false == test_ok)
                {
                    LE_ERROR("SIM PIN code format error");
                    result = LE_FORMAT_ERROR;
                }
            }
        }
    }
    if (LE_OK == result)
    {
        // Set the configuration path for the SIM.
        char configPath[LIMIT_MAX_PATH_BYTES];
        snprintf(configPath, sizeof(configPath), "%s/%d",
                 CFG_MODEMSERVICE_SIM_PATH,
                 simId);

        le_cfg_IteratorRef_t simCfgRef = le_cfg_CreateWriteTxn(configPath);
        le_cfg_SetString(simCfgRef, CFG_NODE_PIN, pinCodePtr);
        le_cfg_CommitTxn(simCfgRef);

        LE_DEBUG("SIM PIN code (%s) inserted OK in config Tree",pinCodePtr);

        // New SIM pincode is taken into account
        LoadSimFromConfigDb(simId);
        SendCellNetStateEvent();
    }

    return result;
}
Beispiel #6
0
// -------------------------------------------------------------------------------------------------
static int HandleSet
(
    void
)
// -------------------------------------------------------------------------------------------------
{
    // Looks like we're trying to write a value to a node.  Get the node's current type and then
    // write the requested value to that node.
    le_cfg_IteratorRef_t iterRef = le_cfg_CreateWriteTxn(NodePath);

    le_cfg_nodeType_t originalType = le_cfg_GetNodeType(iterRef, "");
    le_cfg_nodeType_t newType = DataType;

    if (   (newType != originalType)
        && (originalType != LE_CFG_TYPE_DOESNT_EXIST))
    {
        printf("Converting node '%s' type from %s to %s.\n",
               NodePath,
               NodeTypeStr(originalType),
               NodeTypeStr(newType));
    }

    int result = EXIT_SUCCESS;

    switch (newType)
    {
        case LE_CFG_TYPE_STRING:
            le_cfg_SetString(iterRef, "", NodeValue);
            break;

        case LE_CFG_TYPE_BOOL:
            if (strcmp(NodeValue, "false") == 0)
            {
                le_cfg_SetBool(iterRef, "", false);
            }
            else if (strcmp(NodeValue, "true") == 0)
            {
                le_cfg_SetBool(iterRef, "", true);
            }
            else
            {
                fprintf(stderr, "Bad boolean value '%s'.\n", NodeValue);
            }
            break;

        case LE_CFG_TYPE_INT:
            {
                char *endIntp;

                errno = 0;
                int32_t value = strtol(NodeValue, &endIntp, 10);

                if (errno != 0)
                {
                    fprintf(stderr, "Integer '%s' out of range\n", NodeValue);
                    result = EXIT_FAILURE;
                }
                else if (*endIntp != '\0')
                {
                    fprintf(stderr, "Invalid character in integer '%s'\n", NodeValue);
                    result = EXIT_FAILURE;
                }
                else
                {
                    le_cfg_SetInt(iterRef, "", value);
                }
                break;
            }

        case LE_CFG_TYPE_FLOAT:
            {
                char *endFloatp;

                errno = 0;
                double floatVal = strtod(NodeValue, &endFloatp);

                if (errno != 0)
                {
                    fprintf(stderr, "Float value '%s' out of range\n", NodeValue);
                    result = EXIT_FAILURE;
                }
                else if (*endFloatp != '\0')
                {
                    fprintf(stderr, "Invalid character in float value '%s'\n", NodeValue);
                    result = EXIT_FAILURE;
                }
                else
                {
                    le_cfg_SetFloat(iterRef, "", floatVal);
                }
                break;
            }

        case LE_CFG_TYPE_DOESNT_EXIST:
            result = EXIT_FAILURE;
            break;

        default:
            fprintf(stderr, "Unexpected node type specified, %s.\n", NodeTypeStr(newType));
            result = EXIT_FAILURE;
            break;
    }

    // Finally, commit the value update, if the set was successful.
    if (result != EXIT_FAILURE)
    {
        le_cfg_CommitTxn(iterRef);
    }
    else
    {
        le_cfg_CancelTxn(iterRef);
    }

    return result;
}
Beispiel #7
0
// -------------------------------------------------------------------------------------------------
static le_result_t HandleImportJSONIteration
(
    le_cfg_IteratorRef_t iterRef,  ///< Dump the JSON data into this iterator.
    json_t* nodePtr                ///< From this JSON object.
)
// -------------------------------------------------------------------------------------------------
{
    // Get value
    json_t* value = json_object_get(nodePtr, JSON_FIELD_VALUE);

    // Check type
    const char* typeStr = json_string_value(json_object_get(nodePtr, JSON_FIELD_TYPE));
    le_cfg_nodeType_t type = GetNodeTypeFromString(typeStr);

    switch (type)
    {
        case LE_CFG_TYPE_BOOL:
            le_cfg_SetBool(iterRef, "", json_is_true(value));
            break;

        case LE_CFG_TYPE_STRING:
            le_cfg_SetString(iterRef, "", json_string_value(value));
            break;

        case LE_CFG_TYPE_INT:
            le_cfg_SetInt(iterRef, "", json_integer_value(value));
            break;

        case LE_CFG_TYPE_FLOAT:
            le_cfg_SetFloat(iterRef, "", json_real_value(value));
            break;

        case LE_CFG_TYPE_STEM:
            {
                // Iterate on children
                json_t* childrenPtr = json_object_get(nodePtr, JSON_FIELD_CHILDREN);
                json_t* childPtr;
                int i;

                json_array_foreach(childrenPtr, i, childPtr)
                {
                    // Get name
                    const char* name = json_string_value(json_object_get(childPtr,
                                                                         JSON_FIELD_NAME));

                    // Is node exist with this name?
                    le_cfg_nodeType_t existingType = le_cfg_GetNodeType(iterRef, name);
                    switch (existingType)
                    {
                        case LE_CFG_TYPE_DOESNT_EXIST:
                        case LE_CFG_TYPE_STEM:
                        case LE_CFG_TYPE_EMPTY:
                            // Not existing, already a stem or empty node, nothing to do
                        break;

                        default:
                            // Issue with node creation
                            fprintf(stderr, "Node conflict when importing, at node %s", name);
                            return LE_NOT_POSSIBLE;
                        break;
                    }

                    // Iterate to this child
                    le_cfg_GoToNode(iterRef, name);

                    // Iterate
                    le_result_t subResult = HandleImportJSONIteration(iterRef, childPtr);
                    if (subResult != LE_OK)
                    {
                        // Something went wrong
                        return subResult;
                    }

                    // Go back to parent
                    le_cfg_GoToParent(iterRef);
                }
            }
            break;

        default:
            return LE_FAULT;
    }

    return LE_OK;
}