//-------------------------------------------------------------------------------------------------- le_result_t ni_SetNodeName ( ni_IteratorRef_t iteratorRef, ///< The iterator object to access. const char* pathPtr, ///< Optional path to another node in the tree. const char* namePtr ///< The new name to use. ) //-------------------------------------------------------------------------------------------------- { // Try to get the node, and if found, set the value. tdb_NodeRef_t nodeRef = ni_GetNode(iteratorRef, pathPtr); if (nodeRef) { return tdb_SetNodeName(nodeRef, namePtr); } // Because this is a write operation, and if the node wasn't found at this point then that means // there was a problem with the supplied path and ternimiate client was called, so we just // return LE_OK. return LE_OK; }
//-------------------------------------------------------------------------------------------------- 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; }