//-------------------------------------------------------------------------------------------------- static le_result_t GetUserUid ( le_cfg_IteratorRef_t i, ///< [in] Configuration tree iterator. uid_t* uidPtr ///< [out] Pointer to where the user ID will be put if successful. ) //-------------------------------------------------------------------------------------------------- { le_result_t result; char userName[LIMIT_MAX_USER_NAME_BYTES]; result = le_cfg_GetNodeName(i, "", userName, sizeof(userName)); if (result != LE_OK) { LE_CRIT("Configuration node name too long under 'system/users/'."); return LE_OVERFLOW; } // Convert the user name into a user ID. result = user_GetUid(userName, uidPtr); if (result != LE_OK) { LE_CRIT("Failed to get user ID for user '%s'. (%s)", userName, LE_RESULT_TXT(result)); return LE_NOT_FOUND; } return LE_OK; }
// ------------------------------------------------------------------------------------------------- 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; }
// ------------------------------------------------------------------------------------------------- static void DumpTreeJSON ( le_cfg_IteratorRef_t iterRef, ///< Read the tree data from this iterator. json_t* jsonObject ///< JSON object to hold the tree data. ) // ------------------------------------------------------------------------------------------------- { // Note that because this is a recursive function, the buffer here is static in order to save on // stack space. The implication here is that we then have to be careful how it is later // accessed. Also, this makes the function not thread safe. But this trade off was made as // this was not intended to be a multi-threaded program. static char strBuffer[LE_CFG_STR_LEN_BYTES] = ""; // Build up the child array. json_t* childArrayPtr = json_array(); do { // Simply grab the name and the type of the current node. le_cfg_GetNodeName(iterRef, "", strBuffer, sizeof(strBuffer)); le_cfg_nodeType_t type = le_cfg_GetNodeType(iterRef, ""); switch (type) { // It's a stem object, so mark this item as being a stem and recurse into the stem's // sub-items. case LE_CFG_TYPE_STEM: { json_t* nodePtr = CreateJsonNode(strBuffer, NodeTypeStr(type)); le_cfg_GoToFirstChild(iterRef); DumpTreeJSON(iterRef, nodePtr); le_cfg_GoToParent(iterRef); json_array_append(childArrayPtr, nodePtr); } break; default: { json_t* nodePtr = CreateJsonNodeFromIterator(iterRef); if (nodePtr != NULL) { json_array_append(childArrayPtr, nodePtr); } } break; } } while (le_cfg_GoToNextSibling(iterRef) == LE_OK); // Set children into the JSON document. json_object_set_new(jsonObject, JSON_FIELD_CHILDREN, childArrayPtr); }
//-------------------------------------------------------------------------------------------------- LE_SHARED le_result_t appCfg_GetProcName ( appCfg_Iter_t procIterRef, ///< [IN] Apps iterator char* bufPtr, ///< [OUT] Buffer to store the app name. size_t bufSize ///< [IN] Size of the buffer. ) { CheckFor(procIterRef, ITER_TYPE_PROC); if (le_cfg_NodeExists(procIterRef->cfgIter, "") == false) { return LE_NOT_FOUND; } return le_cfg_GetNodeName(procIterRef->cfgIter, "", bufPtr, bufSize); }
//-------------------------------------------------------------------------------------------------- static le_result_t GetAppUid ( le_cfg_IteratorRef_t i, ///< [in] Configuration tree iterator. uid_t* uidPtr ///< [out] Pointer to where the user ID will be put if successful. ) //-------------------------------------------------------------------------------------------------- { le_result_t result; char appName[LIMIT_MAX_APP_NAME_BYTES]; result = le_cfg_GetNodeName(i, "", appName, sizeof(appName)); if (result != LE_OK) { LE_CRIT("Configuration node name too long under 'system/apps/'."); return LE_OVERFLOW; } // If this is an "unsandboxed" app, use the root user ID. if (le_cfg_GetBool(i, "sandboxed", true) == false) { char path[256]; le_cfg_GetPath(i, "", path, sizeof(path)); LE_DEBUG("'%s' = <root>", path); *uidPtr = 0; return LE_OK; } // Convert the app name into a user name by prefixing it with "app". char userName[LIMIT_MAX_USER_NAME_BYTES] = "app"; result = le_utf8_Append(userName, appName, sizeof(userName), NULL); if (result != LE_OK) { LE_CRIT("Failed to convert app name into user name."); return LE_OVERFLOW; } // Convert the app user name into a user ID. result = user_GetUid(userName, uidPtr); if (result != LE_OK) { LE_CRIT("Failed to get user ID for user '%s'. (%s)", userName, LE_RESULT_TXT(result)); return LE_NOT_FOUND; } return LE_OK; }
//-------------------------------------------------------------------------------------------------- static le_result_t GetEnvironmentVariables ( proc_Ref_t procRef, ///< [IN] The process to get the environment variables for. EnvVar_t envVars[], ///< [IN] The list of environment variables. size_t maxNumEnvVars ///< [IN] The maximum number of items envVars can hold. ) { le_cfg_IteratorRef_t procCfg = le_cfg_CreateReadTxn(procRef->cfgPathRoot); le_cfg_GoToNode(procCfg, CFG_NODE_ENV_VARS); if (le_cfg_GoToFirstChild(procCfg) != LE_OK) { LE_WARN("No environment variables for process '%s'.", procRef->name); le_cfg_CancelTxn(procCfg); return LE_NOT_FOUND; } int i; for (i = 0; i < maxNumEnvVars; i++) { if ( (le_cfg_GetNodeName(procCfg, "", envVars[i].name, LIMIT_MAX_ENV_VAR_NAME_BYTES) != LE_OK) || (le_cfg_GetString(procCfg, "", envVars[i].value, LIMIT_MAX_PATH_BYTES, "") != LE_OK) ) { LE_ERROR("Error reading environment variables for process '%s'.", procRef->name); le_cfg_CancelTxn(procCfg); return LE_FAULT; } if (le_cfg_GoToNextSibling(procCfg) != LE_OK) { break; } else if (i >= maxNumEnvVars-1) { LE_ERROR("There were too many environment variables for process '%s'.", procRef->name); le_cfg_CancelTxn(procCfg); return LE_FAULT; } } le_cfg_CancelTxn(procCfg); return i + 1; }
static void DumpTree(le_cfg_IteratorRef_t iterRef, size_t indent) { if (le_arg_NumArgs() == 1) { return; } static char strBuffer[STR_SIZE] = { 0 }; do { size_t i; for (i = 0; i < indent; i++) { printf(" "); } le_cfg_GetNodeName(iterRef, "", strBuffer, STR_SIZE); le_cfg_nodeType_t type = le_cfg_GetNodeType(iterRef, ""); switch (type) { case LE_CFG_TYPE_STEM: printf("%s/\n", strBuffer); le_cfg_GoToFirstChild(iterRef); DumpTree(iterRef, indent + 2); le_cfg_GoToParent(iterRef); break; case LE_CFG_TYPE_EMPTY: printf("%s~~\n", strBuffer); break; default: printf("%s<%s> == ", strBuffer, NodeTypeStr(iterRef)); le_cfg_GetString(iterRef, "", strBuffer, STR_SIZE, ""); printf("%s\n", strBuffer); break; } } while (le_cfg_GoToNextSibling(iterRef) == LE_OK); }
//-------------------------------------------------------------------------------------------------- static void SendBindRequest ( uid_t uid, ///< [in] Unix user ID of the client whose binding is being created. le_cfg_IteratorRef_t i ///< [in] Configuration read iterator. ) //-------------------------------------------------------------------------------------------------- { le_result_t result; le_msg_MessageRef_t msgRef = le_msg_CreateMsg(SessionRef); le_sdtp_Msg_t* msgPtr = le_msg_GetPayloadPtr(msgRef); msgPtr->msgType = LE_SDTP_MSGID_BIND; msgPtr->client = uid; // Fetch the client's service name. result = le_cfg_GetNodeName(i, "", msgPtr->clientServiceName, sizeof(msgPtr->clientServiceName)); if (result != LE_OK) { char path[LIMIT_MAX_PATH_BYTES]; le_cfg_GetPath(i, "", path, sizeof(path)); LE_CRIT("Configured client service name too long (@ %s)", path); return; } // Fetch the server's user ID. result = GetServerUid(i, &msgPtr->server); if (result != LE_OK) { return; } // Fetch the server's service name. result = le_cfg_GetString(i, "interface", msgPtr->serverServiceName, sizeof(msgPtr->serverServiceName), ""); if (result != LE_OK) { char path[LIMIT_MAX_PATH_BYTES]; le_cfg_GetPath(i, "interface", path, sizeof(path)); LE_CRIT("Server interface name too big (@ %s)", path); return; } if (msgPtr->serverServiceName[0] == '\0') { char path[LIMIT_MAX_PATH_BYTES]; le_cfg_GetPath(i, "interface", path, sizeof(path)); LE_CRIT("Server interface name missing (@ %s)", path); return; } msgRef = le_msg_RequestSyncResponse(msgRef); if (msgRef == NULL) { ExitWithErrorMsg("Communication with Service Directory failed."); } le_msg_ReleaseMsg(msgRef); }
// ------------------------------------------------------------------------------------------------- static int HandleGetJSON ( const char* nodePathPtr, ///< Path to the node in the configTree. const char* filePathPtr ///< Path to the file in the file system. If NULL STDOUT is used ///< instead of a file. ) // ------------------------------------------------------------------------------------------------- { json_t* nodePtr = NULL; // Get the node path from our command line arguments. if (strcmp("*", nodePathPtr) == 0) { // Dump all trees // Create JSON root item json_t* rootPtr = CreateJsonNode("root", "root"); json_t* treeListPtr = json_array(); // Loop through the trees in the system. le_cfgAdmin_IteratorRef_t iteratorRef = le_cfgAdmin_CreateTreeIterator(); while (le_cfgAdmin_NextTree(iteratorRef) == LE_OK) { // Allocate space for the tree name, plus space for a trailing :/ used when we create a // transaction for that tree. char treeName[MAX_TREE_NAME_BYTES + 2] = ""; if (le_cfgAdmin_GetTreeName(iteratorRef, treeName, MAX_TREE_NAME_BYTES) != LE_OK) { continue; } // JSON node for the tree. json_t* treeNodePtr = CreateJsonNode(treeName, "tree"); strcat(treeName, ":/"); // Start a read transaction at the specified node path. Then dump the value, (if any.) le_cfg_IteratorRef_t iterRef = le_cfg_CreateReadTxn(treeName); le_cfg_GoToFirstChild(iterRef); // Dump tree to JSON DumpTreeJSON(iterRef, treeNodePtr); le_cfg_CancelTxn(iterRef); json_array_append(treeListPtr, treeNodePtr); } le_cfgAdmin_ReleaseTreeIterator(iteratorRef); // Finalize root object... json_object_set_new(rootPtr, "trees", treeListPtr); nodePtr = rootPtr; } else { // Start a read transaction at the specified node path. Then dump the value, (if any.) le_cfg_IteratorRef_t iterRef = le_cfg_CreateReadTxn(nodePathPtr); le_cfg_nodeType_t type = le_cfg_GetNodeType(iterRef, ""); switch (type) { case LE_CFG_TYPE_STEM: { char strBuffer[LE_CFG_STR_LEN_BYTES] = ""; char nodeType[LE_CFG_STR_LEN_BYTES] = ""; le_cfg_GetNodeName(iterRef, "", strBuffer, sizeof(strBuffer)); // If no name, we are dumping a complete tree. if (strlen(strBuffer) == 0) { strcpy(nodeType, "tree"); } else { strcpy(nodeType, NodeTypeStr(type)); } nodePtr = CreateJsonNode(strBuffer, nodeType); le_cfg_GoToFirstChild(iterRef); DumpTreeJSON(iterRef, nodePtr); le_cfg_GoToParent(iterRef); } break; default: nodePtr = CreateJsonNodeFromIterator(iterRef); break; } le_cfg_CancelTxn(iterRef); } if (nodePtr == NULL) { // Empty node nodePtr = json_object(); } // Dump Json content // stdout mode? int result = EXIT_SUCCESS; if (filePathPtr == NULL) { printf("%s\n", json_dumps(nodePtr, JSON_COMPACT)); } else if (json_dump_file(nodePtr, filePathPtr, JSON_COMPACT) != 0) { result = EXIT_FAILURE; } json_decref(nodePtr); return result; }
// ------------------------------------------------------------------------------------------------- static void DumpTree ( le_cfg_IteratorRef_t iterRef, ///< Write out the tree pointed to by this iterator. size_t indent ///< The amount of indentation to use for this item. ) // ------------------------------------------------------------------------------------------------- { // Note that because this is a recursive function, the buffer here is static in order to save on // stack space. The implication here is that we then have to be careful how it is later // accessed. Also, this makes the function not thread safe. But this trade off was made as // this was not intended to be a multi-threaded program. static char strBuffer[LE_CFG_STR_LEN_BYTES] = ""; do { // Quick and dirty way to indent the tree item. size_t i; for (i = 0; i < indent; i++) { printf(" "); } // Simply grab the name and the type of the current node. le_cfg_GetNodeName(iterRef, "", strBuffer, LE_CFG_STR_LEN_BYTES); le_cfg_nodeType_t type = le_cfg_GetNodeType(iterRef, ""); switch (type) { // It's a stem object, so mark this item as being a stem and recurse into the stem's // sub-items. case LE_CFG_TYPE_STEM: printf("%s/\n", strBuffer); le_cfg_GoToFirstChild(iterRef); DumpTree(iterRef, indent + 2); le_cfg_GoToParent(iterRef); // If we got back up to where we started then don't iterate the "root" node's // siblings. if (indent == 0) { return; } break; // The node is empty, so simply mark it as such. case LE_CFG_TYPE_EMPTY: printf("%s<empty>\n", strBuffer); break; case LE_CFG_TYPE_BOOL: { char* value = NULL; if (le_cfg_GetBool(iterRef, "", false)) { value = "true"; } else { value = "false"; } printf("%s<bool> == %s\n", strBuffer, value); } break; // The node has a different type. So write out the name and the type. Then print the // value. default: printf("%s<%s> == ", strBuffer, NodeTypeStr(le_cfg_GetNodeType(iterRef, ""))); le_cfg_GetString(iterRef, "", strBuffer, LE_CFG_STR_LEN_BYTES, ""); printf("%s\n", strBuffer); break; } } while (le_cfg_GoToNextSibling(iterRef) == LE_OK); }