//-------------------------------------------------------------------------------------------------- tdb_NodeRef_t ni_GetNode ( ni_IteratorRef_t iteratorRef, ///< The iterator object to access. const char* subPathPtr ///< Optional, can be used to specify a node relative to the ///< current one. ) //-------------------------------------------------------------------------------------------------- { // Check to see if we have a current node. If we do, then attempt to traverse from our current // node, to the requested sub-node. If the new path is NULL or empty, then we'll just end up // getting our current node. if (iteratorRef->currentNodeRef != NULL) { le_pathIter_Ref_t newPathRef = le_pathIter_CreateForUnix(subPathPtr); tdb_NodeRef_t nodeRef = tdb_GetNode(iteratorRef->currentNodeRef, newPathRef); le_pathIter_Delete(newPathRef); return nodeRef; } // Ok, the iterator doesn't have a current node. So, copy iterator's existing path, and append // the new sub path to the existing path. Once that's done, attempt to find the requested node // in the tree. If the node still can not be found, return NULL. le_pathIter_Ref_t newPathRef = le_pathIter_Clone(iteratorRef->pathIterRef); tdb_NodeRef_t nodeRef = NULL; le_result_t result = LE_OK; if (subPathPtr != NULL) { result = le_pathIter_Append(newPathRef, subPathPtr); } // Make sure that the append was successful. If it is, get the node. if (result == LE_OVERFLOW) { tu_TerminateClient(iteratorRef->sessionRef, "Specified path too large."); } else if (result == LE_UNDERFLOW) { tu_TerminateClient(iteratorRef->sessionRef, "Specified path attempts to iterate below root."); } else { nodeRef = tdb_GetNode(tdb_GetRootNode(iteratorRef->treeRef), newPathRef); } le_pathIter_Delete(newPathRef); return nodeRef; }
//-------------------------------------------------------------------------------------------------- static le_result_t CloneAndAppendPath ( ni_IteratorRef_t iteratorRef, ///< [IN] The iterator to read. const char* subPathPtr, ///< [IN] Optionally, a sub-path to traverse to. le_pathIter_Ref_t* newPathIterRefPtr ///< [OUT] Pointer to a to-be newly created ref. Must be ///< NULL on entry! ) //-------------------------------------------------------------------------------------------------- { LE_ASSERT(*newPathIterRefPtr == NULL); le_pathIter_Ref_t newPathRef = le_pathIter_Clone(iteratorRef->pathIterRef); le_result_t result = LE_OK; if (subPathPtr != NULL) { result = le_pathIter_Append(newPathRef, subPathPtr); } if (result != LE_OK) { char* terminateMessage; switch (result) { case LE_OVERFLOW: terminateMessage = "Specified path too large."; break; case LE_UNDERFLOW: terminateMessage = "Specified path attempts to iterate below root."; break; default: terminateMessage = "Unexpected error while appending path."; break; } iteratorRef->isTerminated = true; tu_TerminateConfigClient(iteratorRef->sessionRef, terminateMessage); le_pathIter_Delete(newPathRef); return result; } *newPathIterRefPtr = newPathRef; return result; }
//-------------------------------------------------------------------------------------------------- le_result_t ni_GetPathForNode ( ni_IteratorRef_t iteratorRef, ///< The iterator object to access. const char* subPathPtr, ///< Optional, can be used to specify a node relative to the ///< current one. char* destBufferPtr, ///< The buffer to copy string data into. size_t bufferMax ///< The maximum size of the string buffer. ) //-------------------------------------------------------------------------------------------------- { LE_ASSERT(iteratorRef != NULL); LE_ASSERT(destBufferPtr != NULL); LE_ASSERT(bufferMax > 0); // Check to see if they're looking for a path to a node relative to the current one. if ( (subPathPtr != NULL) && (strcmp(subPathPtr, "") != 0)) { // Build up a new path based on the existing path. le_pathIter_Ref_t newPathRef = le_pathIter_Clone(iteratorRef->pathIterRef); le_result_t result = le_pathIter_Append(newPathRef, subPathPtr); if (result == LE_OVERFLOW) { tu_TerminateClient(iteratorRef->sessionRef, "Specified path too large."); } else if (result == LE_UNDERFLOW) { tu_TerminateClient(iteratorRef->sessionRef, "Specified path attempts to iterate below root."); } else { result = le_pathIter_GetPath(newPathRef, destBufferPtr, bufferMax); } le_pathIter_Delete(newPathRef); return result; } // Simply return the current path. return le_pathIter_GetPath(iteratorRef->pathIterRef, destBufferPtr, bufferMax); }
//-------------------------------------------------------------------------------------------------- le_result_t ni_SetNodeName ( ni_IteratorRef_t iteratorRef, ///< [IN] The iterator object to access. const char* pathPtr, ///< [IN] Optional path to another node in the tree. const char* namePtr ///< [IN] The new name to use. ) //-------------------------------------------------------------------------------------------------- { // Try to get or create the requested node. If the optional sub-path results in a new path that // overflows, then the node get will fail. tdb_NodeRef_t nodeRef = ni_TryCreateNode(iteratorRef, pathPtr); le_result_t result = LE_OK; if (nodeRef) { // Ok, the existing path is ok. Cache the existing node name, in case we have to revert it // later, then set the new name. We may have to revert the name later, because, while the // new name itself may be ok. The name may actually be too long for the path limit. char oldName[LE_CFG_NAME_LEN_BYTES] = ""; LE_ASSERT(tdb_GetNodeName(nodeRef, oldName, sizeof(oldName)) == LE_OK); result = tdb_SetNodeName(nodeRef, namePtr); if (result == LE_OK) { // The new name passed validation, now we have to make sure that the full path to the // node is still ok. So, first we have to check, was a relative path used. if (strcmp(pathPtr, "") == 0) { // Looks like the caller was using the iterator's current node. So, remove the old // name from the end of the iterator's current path, and append the new name. If // this fails, it's because the new absolute path is too long, so name change fails, // and we have to revert the changes. LE_ASSERT(le_pathIter_Append(iteratorRef->pathIterRef, "..") == LE_OK); result = le_pathIter_Append(iteratorRef->pathIterRef, namePtr); if (result != LE_OK) { LE_ASSERT(le_pathIter_Append(iteratorRef->pathIterRef, oldName) == LE_OK); } } else { // The user is accessing a node relative to the iterator's current node. So, we // need too build up a new path and validate that the new name still fits within our // limits. The new path ref is for validation only and can be safely discarded once // the check is complete. le_pathIter_Ref_t newPathRef = le_pathIter_Clone(iteratorRef->pathIterRef); result = le_pathIter_Append(newPathRef, pathPtr); if (result == LE_OK) { LE_ASSERT(le_pathIter_Append(newPathRef, "..") == LE_OK); result = le_pathIter_Append(newPathRef, namePtr); } le_pathIter_Delete(newPathRef); } // If we got to this point and everything is ok, then we know that the name set was ok, // and that the resultant path with the new name is also ok. So, make sure that this // node exists in the next commit. Otherwise, revert the node to it's old name and // report the error to the caller. if (result == LE_OK) { tdb_EnsureExists(nodeRef); } else { LE_ASSERT(tdb_SetNodeName(nodeRef, oldName) == LE_OK); } } } return result; }