[T106][ZXW-22]7520V3SCV2.01.01.02P42U09_VEC_V0.8_AP_VEC origin source commit
Change-Id: Ic6e05d89ecd62fc34f82b23dcf306c93764aec4b
diff --git a/ap/app/cwmp/netcwmp/libxmlet/src/node.c b/ap/app/cwmp/netcwmp/libxmlet/src/node.c
new file mode 100755
index 0000000..3bb3f8b
--- /dev/null
+++ b/ap/app/cwmp/netcwmp/libxmlet/src/node.c
@@ -0,0 +1,2173 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2000-2003 Intel Corporation
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+// * Neither name of Intel Corporation nor the names of its contributors
+// may be used to endorse or promote products derived from this software
+// without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL OR
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#include "xmlparser.h"
+
+/*================================================================
+* XmlNodeInit
+* Intializes a node.
+* External function.
+*
+*=================================================================*/
+void
+XmlNodeInit( XmlNode * nodeptr )
+{
+ assert( nodeptr != NULL );
+ memset( nodeptr, 0, sizeof( XmlNode ) );
+
+}
+
+/*================================================================
+* XmlCDATASectionInit
+* Initializes a CDATASection node.
+* External function.
+*
+*=================================================================*/
+void
+XmlCDATASectionInit( XmlCDATASection * nodeptr )
+{
+ memset( nodeptr, 0, sizeof( XmlCDATASection ) );
+}
+
+/*================================================================
+* XmlCDATASectionFree
+* XFREEs a CDATASection node.
+* External function.
+*
+*=================================================================*/
+void
+XmlCDATASectionFree(
+ Pool * pool,
+ XmlCDATASection * nodeptr )
+{
+ if ( nodeptr != NULL )
+ {
+ XmlNodeFree(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ ( XmlNode * ) nodeptr );
+ }
+}
+
+/*================================================================
+* XmlNodeFreeSingleNode
+* XFREEs a node content.
+* Internal to parser only.
+*
+*=================================================================*/
+void
+XmlNodeFreeSingleNode(
+ Pool * pool,
+ XmlNode * nodeptr )
+{
+ XmlElement *element = NULL;
+
+ if ( nodeptr != NULL )
+ {
+
+ if ( nodeptr->nodeName != NULL )
+ {
+ PFREE( nodeptr->nodeName );
+ }
+
+ if ( nodeptr->nodeValue != NULL )
+ {
+ PFREE( nodeptr->nodeValue );
+ }
+
+ if ( nodeptr->namespaceURI != NULL )
+ {
+ PFREE( nodeptr->namespaceURI );
+ }
+
+ if ( nodeptr->prefix != NULL )
+ {
+ PFREE( nodeptr->prefix );
+ }
+
+ if ( nodeptr->localName != NULL )
+ {
+ PFREE( nodeptr->localName );
+ }
+
+ if ( nodeptr->nodeType == XML_ELEMENT_NODE )
+ {
+ element = ( XmlElement * ) nodeptr;
+ PFREE( element->tagName );
+ }
+
+ PFREE( nodeptr );
+
+ }
+}
+
+/*================================================================
+* XmlNodeFree
+* Frees all nodes under nodeptr subtree.
+* External function.
+*
+*=================================================================*/
+void
+XmlNodeFree(
+
+
+ Pool * pool,
+ XmlNode * nodeptr )
+{
+ if ( nodeptr != NULL )
+ {
+ XmlNodeFree(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ nodeptr->firstChild );
+ XmlNodeFree(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ nodeptr->nextSibling );
+ XmlNodeFree(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ nodeptr->firstAttr );
+
+ XmlNodeFreeSingleNode(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ nodeptr );
+ }
+}
+
+/*================================================================
+* XmlNodeGetNodeName
+* Returns the nodename(the qualified name)
+* External function.
+*
+*=================================================================*/
+const char *
+XmlNodeGetNodeName( XmlNode * nodeptr )
+{
+
+ if ( nodeptr != NULL )
+ {
+ return ( nodeptr->nodeName );
+ }
+
+ return NULL;
+}
+
+/*================================================================
+* XmlNodeGetLocalName
+* Returns the node local name
+* External function.
+*
+*=================================================================*/
+const char *
+XmlNodeGetLocalName( XmlNode * nodeptr )
+{
+
+ if ( nodeptr != NULL )
+ {
+ return ( nodeptr->localName );
+ }
+
+ return NULL;
+}
+
+/*================================================================
+* XmlNodeSetNamespaceURI
+* sets the namespace URI of the node.
+* Internal function.
+* Return:
+* XML_OK or failure
+*
+*=================================================================*/
+int
+XmlNodeSetNamespaceURI(
+ Pool * pool,
+ XmlNode * nodeptr,
+ IN char *namespaceURI )
+{
+
+ if ( nodeptr == NULL )
+ {
+ return XML_INVALID_PARAMETER;
+ }
+
+ if ( nodeptr->namespaceURI != NULL )
+ {
+ PFREE( nodeptr->namespaceURI );
+ nodeptr->namespaceURI = NULL;
+ }
+
+ if ( namespaceURI != NULL )
+ {
+ nodeptr->namespaceURI = PSTRDUP( namespaceURI );
+ if ( nodeptr->namespaceURI == NULL )
+ {
+ return XML_INSUFFICIENT_MEMORY;
+ }
+ }
+
+ return XML_OK;
+}
+
+/*================================================================
+* XmlNodeSetPrefix
+* set the prefix of the node.
+* Internal to parser only.
+* Returns:
+* XML_OK or failure.
+*
+*=================================================================*/
+int
+XmlNodeSetPrefix(
+ Pool * pool,
+ XmlNode * nodeptr,
+ IN char *prefix )
+{
+
+ if ( nodeptr == NULL )
+ {
+ return XML_INVALID_PARAMETER;
+ }
+
+ if ( nodeptr->prefix != NULL )
+ {
+ PFREE( nodeptr->prefix );
+ nodeptr->prefix = NULL;
+ }
+
+ if ( prefix != NULL )
+ {
+ nodeptr->prefix = PSTRDUP( prefix );
+ if ( nodeptr->prefix == NULL )
+ {
+ return XML_INSUFFICIENT_MEMORY;
+ }
+ }
+
+ return XML_OK;
+
+}
+
+/*================================================================
+* XmlNodeSetLocalName
+* set the localName of the node.
+* Internal to parser only.
+* Returns:
+* XML_OK or failure.
+*
+*=================================================================*/
+int
+XmlNodeSetLocalName(
+ Pool * pool,
+ XmlNode * nodeptr,
+ IN char *localName )
+{
+
+ assert( nodeptr != NULL );
+
+ if ( nodeptr->localName != NULL )
+ {
+ PFREE( nodeptr->localName );
+ nodeptr->localName = NULL;
+ }
+
+ if ( localName != NULL )
+ {
+ nodeptr->localName = PSTRDUP( localName );
+ if ( nodeptr->localName == NULL )
+ {
+ return XML_INSUFFICIENT_MEMORY;
+ }
+ }
+
+ return XML_OK;
+}
+
+/*================================================================
+* XmlNodeGetNodeNamespaceURI
+* Returns the node namespaceURI
+* External function.
+* Returns:
+* the namespaceURI of the node
+*
+*=================================================================*/
+const char *
+XmlNodeGetNamespaceURI( XmlNode * nodeptr )
+{
+ char * retNamespaceURI = NULL;
+
+ if ( nodeptr != NULL )
+ {
+ retNamespaceURI = nodeptr->namespaceURI;
+ }
+
+ return retNamespaceURI;
+}
+
+/*================================================================
+* XmlNodeGetPrefix
+* Returns the node prefix
+* External function.
+* Returns:
+* the prefix of the node.
+*
+*=================================================================*/
+char *
+XmlNodeGetPrefix( XmlNode * nodeptr )
+{
+ char * prefix = NULL;
+
+ if ( nodeptr != NULL )
+ {
+ prefix = nodeptr->prefix;
+ }
+
+ return prefix;
+
+}
+
+/*================================================================
+* XmlNodeGetNodeValue
+* Returns the nodeValue of this node
+* External function.
+* Return:
+* the nodeValue of the node.
+*
+*=================================================================*/
+char *
+XmlNodeGetNodeValue( XmlNode * nodeptr )
+{
+
+ if ( nodeptr != NULL )
+ {
+ return ( nodeptr->nodeValue );
+ }
+
+ return NULL;
+}
+
+/*================================================================
+* XmlNodeSetNodeValue
+* Sets the nodeValue
+* Internal function.
+* Returns:
+* XML_OK or failure
+*
+*=================================================================*/
+int
+XmlNodeSetNodeValue(
+ Pool * pool,
+ XmlNode * nodeptr,
+ const char *newNodeValue )
+{
+ int rc = XML_OK;
+
+ if ( nodeptr == NULL )
+ {
+ return XML_INVALID_PARAMETER;
+ }
+
+ if ( nodeptr->nodeValue != NULL )
+ {
+ PFREE( nodeptr->nodeValue );
+ nodeptr->nodeValue = NULL;
+ }
+
+ if ( newNodeValue != NULL )
+ {
+ nodeptr->nodeValue = XmlStrduptrim(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ newNodeValue );
+ if ( nodeptr->nodeValue == NULL )
+ {
+ return XML_INSUFFICIENT_MEMORY;
+ }
+ }
+
+ return rc;
+}
+
+/*================================================================
+* XmlNodeGetNodeType
+* Gets the NodeType of this node
+* External function.
+*
+*=================================================================*/
+int
+XmlNodeGetNodeType( XmlNode * nodeptr )
+{
+ if ( nodeptr != NULL )
+ {
+ return ( nodeptr->nodeType );
+ }
+ else
+ {
+ return ( XML_INVALID_NODE );
+ }
+}
+
+/*================================================================
+* XmlNodeGetParentNode
+* Get the parent node
+* External function.
+* Return:
+*
+*=================================================================*/
+XmlNode *
+XmlNodeGetParentNode( XmlNode * nodeptr )
+{
+
+ if ( nodeptr != NULL )
+ {
+ return nodeptr->parentNode;
+ }
+ else
+ {
+ return NULL;
+ }
+}
+
+/*================================================================
+* XmlNodeGetFirstChild
+* Returns the first child of nodeptr.
+* External function.
+*
+*=================================================================*/
+XmlNode *
+XmlNodeGetFirstChild( XmlNode * nodeptr )
+{
+ if ( nodeptr != NULL )
+ {
+ return nodeptr->firstChild;
+ }
+ else
+ {
+ return NULL;
+ }
+}
+
+/*================================================================
+* XmlNodeGetLastChild
+* Returns the last child of nodeptr.
+* External function.
+*
+*=================================================================*/
+XmlNode *
+XmlNodeGetLastChild( XmlNode * nodeptr )
+{
+ XmlNode * prev;
+ XmlNode * next;
+
+ if ( nodeptr != NULL )
+ {
+ prev = nodeptr;
+ next = nodeptr->firstChild;
+
+ while ( next != NULL )
+ {
+ prev = next;
+ next = next->nextSibling;
+ }
+ return prev;
+ }
+ else
+ {
+ return NULL;
+ }
+
+}
+
+/*================================================================
+* XmlNodeGetPreviousSibling
+* returns the previous sibling node of nodeptr.
+* External function.
+*
+*=================================================================*/
+XmlNode *
+XmlNodeGetPreviousSibling( XmlNode * nodeptr )
+{
+ if ( nodeptr != NULL )
+ {
+ return nodeptr->prevSibling;
+ }
+ else
+ {
+ return NULL;
+ }
+}
+
+/*================================================================
+* XmlNodeGetNextSibling
+* Returns the next sibling node.
+* External function.
+*
+*=================================================================*/
+XmlNode *
+XmlNodeGetNextSibling( XmlNode * nodeptr )
+{
+
+ if ( nodeptr != NULL )
+ {
+ return nodeptr->nextSibling;
+ }
+ else
+ {
+ return NULL;
+ }
+
+}
+
+/*================================================================
+* XmlNodeGetOwnerDocument
+* Returns the owner document node.
+* External function.
+*
+*=================================================================*/
+XmlDocument *
+XmlNodeGetOwnerDocument( XmlNode * nodeptr )
+{
+ if ( nodeptr != NULL )
+ {
+ return ( XmlDocument * ) nodeptr->ownerDocument;
+ }
+ else
+ {
+ return NULL;
+ }
+}
+
+/*================================================================
+* XmlNodeIsAncestor
+* check if ancestorNode is ancestor of toFind
+* Internal to parser only.
+* Returns:
+* TRUE or FALSE
+*
+*=================================================================*/
+BOOL
+XmlNodeIsAncestor( XmlNode * ancestorNode,
+ XmlNode * toFind )
+{
+
+ BOOL found = FALSE;
+
+ if ( ( ancestorNode != NULL ) && ( toFind != NULL ) )
+ {
+ if ( toFind->parentNode == ancestorNode )
+ {
+ return TRUE;
+ }
+ else
+ {
+ found =
+ XmlNodeIsAncestor( ancestorNode->firstChild, toFind );
+ if ( found == FALSE )
+ {
+ found =
+ XmlNodeIsAncestor( ancestorNode->nextSibling,
+ toFind );
+ }
+ }
+ }
+
+ return found;
+}
+
+/*================================================================
+* XmlNodeIsParent
+* Check whether toFind is a children of nodeptr.
+* Internal to parser only.
+* Return:
+* TRUE or FALSE
+*
+*=================================================================*/
+BOOL
+XmlNodeIsParent( XmlNode * nodeptr,
+ XmlNode * toFind )
+{
+ BOOL found = FALSE;
+
+ assert( nodeptr != NULL && toFind != NULL );
+ if ( toFind->parentNode == nodeptr )
+ {
+ found = TRUE;
+ }
+
+ return found;
+}
+
+/*================================================================
+* XmlNodeAllowChildren
+* Check to see whether nodeptr allows children of type newChild.
+* Internal to parser only.
+* Returns:
+* TRUE, if nodeptr can have newChild as children
+* FALSE,if nodeptr cannot have newChild as children
+*
+*=================================================================*/
+BOOL
+XmlNodeAllowChildren( XmlNode * nodeptr,
+ XmlNode * newChild )
+{
+
+ assert( nodeptr != NULL && newChild != NULL );
+ switch ( nodeptr->nodeType )
+ {
+ case XML_ATTRIBUTE_NODE:
+ case XML_TEXT_NODE:
+ case XML_CDATA_SECTION_NODE:
+ return FALSE;
+ break;
+
+ case XML_ELEMENT_NODE:
+ if ( ( newChild->nodeType == XML_ATTRIBUTE_NODE ) ||
+ ( newChild->nodeType == XML_DOCUMENT_NODE ) )
+ {
+ return FALSE;
+ }
+ break;
+
+ case XML_DOCUMENT_NODE:
+ if ( newChild->nodeType != XML_ELEMENT_NODE )
+ {
+ return FALSE;
+ }
+
+ default:
+ break;
+ }
+
+ return TRUE;
+}
+
+/*================================================================
+* XmlNodeCompare
+* Compare two nodes to see whether they are the same node.
+* Parent, sibling and children node are ignored.
+* Internal to parser only.
+* Returns:
+* TRUE, the two nodes are the same.
+* FALSE, the two nodes are not the same.
+*
+*=================================================================*/
+BOOL
+XmlNodeCompare( XmlNode * srcNode,
+ XmlNode * destNode )
+{
+ assert( srcNode != NULL && destNode != NULL );
+ if ( ( srcNode == destNode ) ||
+ ( strcmp( srcNode->nodeName, destNode->nodeName ) == 0 &&
+ strcmp( srcNode->nodeValue, destNode->nodeValue ) == 0 &&
+ ( srcNode->nodeType == destNode->nodeType ) &&
+ strcmp( srcNode->namespaceURI, destNode->namespaceURI ) == 0 &&
+ strcmp( srcNode->prefix, destNode->prefix ) == 0 &&
+ strcmp( srcNode->localName, destNode->localName ) == 0 ) )
+ {
+ return TRUE;
+ }
+ else
+ {
+ return FALSE;
+ }
+}
+
+/*================================================================
+* XmlNodeInsertBefore
+* Inserts the node newChild before the existing child node refChild.
+* If refChild is null, insert newChild at the end of the list of
+* children. If the newChild is already in the tree, it is first
+* removed.
+* External function.
+* Parameters:
+* newChild: the node to insert.
+* Returns:
+*
+*=================================================================*/
+int
+XmlNodeInsertBefore( XmlNode * nodeptr,
+ XmlNode * newChild,
+ XmlNode * refChild )
+{
+
+ int ret = XML_OK;
+
+ if ( ( nodeptr == NULL ) || ( newChild == NULL ) )
+ {
+ return XML_INVALID_PARAMETER;
+ }
+ // whether nodeptr allow children of the type of newChild
+ if ( XmlNodeAllowChildren( nodeptr, newChild ) == FALSE )
+ {
+ return XML_HIERARCHY_REQUEST_ERR;
+ }
+ // or if newChild is one of nodeptr's ancestors
+ if ( XmlNodeIsAncestor( newChild, nodeptr ) == TRUE )
+ {
+ return XML_HIERARCHY_REQUEST_ERR;
+ }
+ // if newChild was created from a different document
+ if ( nodeptr->ownerDocument != newChild->ownerDocument )
+ {
+ return XML_WRONG_DOCUMENT_ERR;
+ }
+ // if refChild is not a child of nodeptr
+ if ( XmlNodeIsParent( nodeptr, refChild ) == FALSE )
+ {
+ return XML_NOT_FOUND_ERR;
+ }
+
+ if ( refChild != NULL )
+ {
+ if ( XmlNodeIsParent( nodeptr, newChild ) == TRUE )
+ {
+ XmlNodeRemoveChild( nodeptr, newChild, NULL );
+ newChild->nextSibling = NULL;
+ newChild->prevSibling = NULL;
+ }
+
+ newChild->nextSibling = refChild;
+ if ( refChild->prevSibling != NULL )
+ {
+ ( refChild->prevSibling )->nextSibling = newChild;
+ newChild->prevSibling = refChild->prevSibling;
+ }
+
+ refChild->prevSibling = newChild;
+
+ if ( newChild->prevSibling == NULL )
+ {
+ nodeptr->firstChild = newChild;
+ }
+
+ newChild->parentNode = nodeptr;
+
+ }
+ else
+ {
+ ret = XmlNodeAppendChild( nodeptr, newChild );
+ }
+
+ return ret;
+}
+
+/*================================================================
+* XmlNodeReplaceChild
+* Replaces the child node oldChild with newChild in the list of children,
+* and returns the oldChild node.
+* External function.
+* Parameters:
+* newChild: the new node to put in the child list.
+* oldChild: the node being replaced in the list.
+* returnNode: the node replaced.
+* Return Value:
+* XML_OK
+* XML_INVALID_PARAMETER: if anyone of nodeptr, newChild or oldChild is NULL.
+* XML_HIERARCHY_REQUEST_ERR: if the newChild is ancestor of nodeptr or nodeptr
+* is of a type that does not allow children of the
+* type of the newChild node.
+* XML_WRONG_DOCUMENT_ERR: if newChild was created from a different document than
+* the one that created this node.
+* XML_NOT_FOUND_ERR: if oldChild is not a child of nodeptr.
+*
+*=================================================================*/
+int
+XmlNodeReplaceChild( XmlNode * nodeptr,
+ XmlNode * newChild,
+ XmlNode * oldChild,
+ OUT XmlNode ** returnNode )
+{
+ int ret = XML_OK;
+
+ if ( ( nodeptr == NULL ) || ( newChild == NULL )
+ || ( oldChild == NULL ) )
+ {
+ return XML_INVALID_PARAMETER;
+ }
+ // if nodetype of nodeptr does not allow children of the type of newChild
+ // needs to add later
+
+ // or if newChild is one of nodeptr's ancestors
+ if ( XmlNodeIsAncestor( newChild, nodeptr ) == TRUE )
+ {
+ return XML_HIERARCHY_REQUEST_ERR;
+ }
+
+ if ( XmlNodeAllowChildren( nodeptr, newChild ) == FALSE )
+ {
+ return XML_HIERARCHY_REQUEST_ERR;
+ }
+ // if newChild was created from a different document
+ if ( nodeptr->ownerDocument != newChild->ownerDocument )
+ {
+ return XML_WRONG_DOCUMENT_ERR;
+ }
+ // if refChild is not a child of nodeptr
+ if ( XmlNodeIsParent( nodeptr, oldChild ) != TRUE )
+ {
+ return XML_NOT_FOUND_ERR;
+ }
+
+ ret = XmlNodeInsertBefore( nodeptr, newChild, oldChild );
+ if ( ret != XML_OK )
+ {
+ return ret;
+ }
+
+ ret = XmlNodeRemoveChild( nodeptr, oldChild, returnNode );
+ return ret;
+}
+
+/*================================================================
+* XmlNodeRemoveChild
+* Removes the child node indicated by oldChild from the list of
+* children, and returns it.
+* External function.
+* Parameters:
+* oldChild: the node being removed.
+* returnNode: the node removed.
+* Return Value:
+* XML_OK
+* XML_NOT_FOUND_ERR: if oldChild is not a child of this node.
+* XML_INVALID_PARAMETER: if either oldChild or nodeptr is NULL
+*
+*=================================================================*/
+int
+XmlNodeRemoveChild( XmlNode * nodeptr,
+ XmlNode * oldChild,
+ OUT XmlNode ** returnNode )
+{
+
+ if ( ( nodeptr == NULL ) || ( oldChild == NULL ) )
+ {
+ return XML_INVALID_PARAMETER;
+ }
+
+ if ( XmlNodeIsParent( nodeptr, oldChild ) == FALSE )
+ {
+ return XML_NOT_FOUND_ERR;
+ }
+
+ if ( oldChild->prevSibling != NULL )
+ {
+ ( oldChild->prevSibling )->nextSibling = oldChild->nextSibling;
+ }
+
+ if ( nodeptr->firstChild == oldChild )
+ {
+ nodeptr->firstChild = oldChild->nextSibling;
+ }
+
+ if ( oldChild->nextSibling != NULL )
+ {
+ ( oldChild->nextSibling )->prevSibling = oldChild->prevSibling;
+ }
+
+ oldChild->nextSibling = NULL;
+ oldChild->prevSibling = NULL;
+ oldChild->parentNode = NULL;
+
+ if ( returnNode != NULL )
+ {
+ *returnNode = oldChild;
+ }
+ return XML_OK;
+}
+
+/*========================================================================================
+* XmlNodeAppendChild
+* Adds the node newChild to the end of the list of children of this node.
+* If the newChild is already in the tree, it is first removed.
+* External function.
+* Parameter:
+* newChild: the node to add.
+* Return Value:
+* XML_OK
+* XML_INVALID_PARAMETER: if either nodeptr or newChild is NULL
+* XML_WRONG_DOCUMENT_ERR: if newChild was created from a different document than
+* the one that created nodeptr.
+* XML_HIERARCHY_REQUEST_ERR: if newChild is ancestor of nodeptr or if nodeptr is of
+* a type that does not allow children of the type of the
+* newChild node.
+*
+*========================================================================================*/
+int
+XmlNodeAppendChild( XmlNode * nodeptr,
+ XmlNode * newChild )
+{
+
+ XmlNode * prev = NULL;
+ XmlNode * next = NULL;
+
+
+ if ( ( nodeptr == NULL ) || ( newChild == NULL ) )
+ {
+ return XML_INVALID_PARAMETER;
+ }
+ // if newChild was created from a different document
+ if ( ( newChild->ownerDocument != NULL ) &&
+ ( nodeptr->ownerDocument != newChild->ownerDocument ) )
+ {
+ return XML_WRONG_DOCUMENT_ERR;
+ }
+ // if newChild is an ancestor of nodeptr
+ if ( XmlNodeIsAncestor( newChild, nodeptr ) == TRUE )
+ {
+ return XML_HIERARCHY_REQUEST_ERR;
+ }
+ // if nodeptr does not allow to have newChild as children
+ if ( XmlNodeAllowChildren( nodeptr, newChild ) == FALSE )
+ {
+ return XML_HIERARCHY_REQUEST_ERR;
+ }
+
+ if ( XmlNodeIsParent( nodeptr, newChild ) == TRUE )
+ {
+ XmlNodeRemoveChild( nodeptr, newChild, NULL );
+ }
+ // set the parent node pointer
+ newChild->parentNode = nodeptr;
+ newChild->ownerDocument = nodeptr->ownerDocument;
+
+ //if the first child
+ if ( nodeptr->firstChild == NULL )
+ {
+ nodeptr->firstChild = newChild;
+ }
+ else
+ {
+ prev = nodeptr->firstChild;
+ next = prev->nextSibling;
+ while ( next != NULL )
+ {
+ prev = next;
+ next = prev->nextSibling;
+ }
+ prev->nextSibling = newChild;
+ newChild->prevSibling = prev;
+ }
+
+
+ return XML_OK;
+}
+
+/*================================================================
+* XmlNodeCloneTextNode
+* Returns a clone of nodeptr
+* Internal to parser only.
+*
+*=================================================================*/
+XmlNode *
+#ifdef USE_CWMP_MEMORY_POOL
+XmlNodeCloneTextNode(Pool * pool, XmlNode * nodeptr )
+#else
+XmlNodeCloneTextNode( XmlNode * nodeptr )
+#endif
+
+{
+ XmlNode * newNode = NULL;
+
+ assert( nodeptr != NULL );
+
+ newNode = ( XmlNode * ) PMALLOC( sizeof( XmlNode ) );
+ if ( newNode == NULL )
+ {
+ return NULL;
+ }
+ else
+ {
+ XmlNodeInit( newNode );
+
+ XmlNodeSetNodeName(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+
+ newNode, nodeptr->nodeName );
+ XmlNodeSetNodeValue(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ newNode, nodeptr->nodeValue );
+ newNode->nodeType = XML_TEXT_NODE;
+ }
+
+ return newNode;
+}
+
+/*================================================================
+* XmlNodeCloneCDATASect
+* Return a clone of CDATASection node.
+* Internal to parser only.
+*
+*=================================================================*/
+XmlCDATASection *
+#ifdef USE_CWMP_MEMORY_POOL
+XmlNodeCloneCDATASect(Pool * pool, XmlCDATASection * nodeptr )
+#else
+XmlNodeCloneCDATASect( XmlCDATASection * nodeptr )
+#endif
+
+{
+ XmlCDATASection *newCDATA = NULL;
+ XmlNode * newNode;
+ XmlNode * srcNode;
+
+ assert( nodeptr != NULL );
+ newCDATA =
+ ( XmlCDATASection * ) PMALLOC( sizeof( XmlCDATASection ) );
+ if ( newCDATA != NULL )
+ {
+ newNode = ( XmlNode * ) newCDATA;
+ XmlNodeInit( newNode );
+
+ srcNode = ( XmlNode * ) nodeptr;
+ XmlNodeSetNodeName(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ newNode, srcNode->nodeName );
+ XmlNodeSetNodeValue(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ newNode, srcNode->nodeValue );
+ newNode->nodeType = XML_CDATA_SECTION_NODE;
+ }
+
+ return newCDATA;
+}
+
+/*================================================================
+* XmlNodeCloneElement
+* returns a clone of element node
+* Internal to parser only.
+*
+*=================================================================*/
+XmlElement *
+#ifdef USE_CWMP_MEMORY_POOL
+XmlNodeCloneElement(Pool * pool, XmlElement * nodeptr )
+#else
+XmlNodeCloneElement( XmlElement * nodeptr )
+#endif
+
+{
+ XmlElement *newElement;
+ XmlNode * elementNode;
+ XmlNode * srcNode;
+ int rc;
+
+ assert( nodeptr != NULL );
+
+ newElement = ( XmlElement * ) PMALLOC( sizeof( XmlElement ) );
+ if ( newElement == NULL )
+ {
+ return NULL;
+ }
+
+ XmlElementInit( newElement );
+ rc = XmlElementSetTagName(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ newElement, nodeptr->tagName );
+ if ( rc != XML_OK )
+ {
+ goto ErrorHandle;
+ }
+
+ elementNode = ( XmlNode * ) newElement;
+ srcNode = ( XmlNode * ) nodeptr;
+ rc = XmlNodeSetNodeName(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ elementNode, srcNode->nodeName );
+ if ( rc != XML_OK )
+ {
+ goto ErrorHandle;
+ }
+
+ rc = XmlNodeSetNodeValue(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ elementNode, srcNode->nodeValue );
+ if ( rc != XML_OK )
+ {
+ goto ErrorHandle;
+ }
+
+ rc = XmlNodeSetNamespaceURI(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ elementNode, srcNode->namespaceURI );
+ if ( rc != XML_OK )
+ {
+ goto ErrorHandle;
+ }
+
+ rc = XmlNodeSetPrefix(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ elementNode, srcNode->prefix );
+ if ( rc != XML_OK )
+ {
+ goto ErrorHandle;
+ }
+
+ rc = XmlNodeSetLocalName(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ elementNode, srcNode->localName );
+ if ( rc != XML_OK )
+ {
+ goto ErrorHandle;
+ }
+
+ elementNode->nodeType = XML_ELEMENT_NODE;
+
+ return newElement;
+
+ErrorHandle:
+ XmlElementFree(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ newElement );
+
+ return NULL;
+
+}
+
+/*================================================================
+* XmlNodeCloneDoc
+* Returns a clone of document node
+* Internal to parser only.
+*
+*=================================================================*/
+XmlDocument *
+#ifdef USE_CWMP_MEMORY_POOL
+XmlNodeCloneDoc(Pool * pool, XmlDocument * nodeptr)
+#else
+XmlNodeCloneDoc(XmlDocument * nodeptr)
+#endif
+{
+ XmlDocument *newDoc;
+ XmlNode * docNode;
+ int rc;
+
+ assert( nodeptr != NULL );
+ newDoc = ( XmlDocument * ) PMALLOC( sizeof( XmlDocument ) );
+ if ( newDoc == NULL )
+ {
+ return NULL;
+ }
+
+ XmlDocumentInit( newDoc );
+ docNode = ( XmlNode * ) newDoc;
+
+ rc = XmlNodeSetNodeName(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+
+ docNode, DOCUMENTNODENAME );
+ if ( rc != XML_OK )
+ {
+ XmlDocumentFree(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ newDoc );
+ return NULL;
+ }
+
+ newDoc->node.nodeType = XML_DOCUMENT_NODE;
+
+ return newDoc;
+
+}
+
+/*================================================================
+* XmlNodeCloneAttr
+* Returns a clone of attribute node
+* Internal to parser only
+*
+*=================================================================*/
+XmlAttribute *
+#ifdef USE_CWMP_MEMORY_POOL
+XmlNodeCloneAttr(Pool * pool, XmlAttribute * nodeptr )
+#else
+XmlNodeCloneAttr( XmlAttribute * nodeptr )
+#endif
+{
+ XmlAttribute *newAttr;
+ XmlNode * attrNode;
+ XmlNode * srcNode;
+ int rc;
+
+ assert( nodeptr != NULL );
+ newAttr = ( XmlAttribute * ) PMALLOC( sizeof( XmlAttribute ) );
+ if ( newAttr == NULL )
+ {
+ return NULL;
+ }
+
+ XmlAttrInit( newAttr );
+ attrNode = ( XmlNode * ) newAttr;
+ srcNode = ( XmlNode * ) nodeptr;
+
+ rc = XmlNodeSetNodeName(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ attrNode, srcNode->nodeName );
+ if ( rc != XML_OK )
+ {
+ XmlAttrFree(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+
+ newAttr );
+ return NULL;
+ }
+
+ rc = XmlNodeSetNodeValue(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ attrNode, srcNode->nodeValue );
+ if ( rc != XML_OK )
+ {
+ XmlAttrFree(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ newAttr );
+ return NULL;
+ }
+ //check to see whether we need to split prefix and localname for attribute
+ rc = XmlNodeSetNamespaceURI(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ attrNode, srcNode->namespaceURI );
+ if ( rc != XML_OK )
+ {
+ XmlAttrFree(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ newAttr );
+ return NULL;
+ }
+
+ rc = XmlNodeSetPrefix(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ attrNode, srcNode->prefix );
+ if ( rc != XML_OK )
+ {
+ XmlAttrFree(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ newAttr );
+ return NULL;
+ }
+
+ rc = XmlNodeSetLocalName(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ attrNode, srcNode->localName );
+ if ( rc != XML_OK )
+ {
+ XmlAttrFree(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ newAttr );
+ return NULL;
+ }
+
+ attrNode->nodeType = XML_ATTRIBUTE_NODE;
+
+ return newAttr;
+}
+
+/*================================================================
+* XmlNodeCloneAttrDirect
+* Return a clone of attribute node, with specified field set
+* to TRUE.
+*
+*=================================================================*/
+XmlAttribute *
+XmlNodeCloneAttrDirect(
+ Pool * pool,
+
+ XmlAttribute * nodeptr )
+{
+
+ XmlAttribute *newAttr;
+
+ assert( nodeptr != NULL );
+
+ newAttr = XmlNodeCloneAttr(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+
+ nodeptr );
+ if ( newAttr != NULL )
+ {
+ newAttr->specified = TRUE;
+ }
+
+ return newAttr;
+}
+
+void
+XmlNodeSetSiblingNodesParent( XmlNode * nodeptr )
+{
+ XmlNode * parentNode = nodeptr->parentNode;
+ XmlNode * nextptr = nodeptr->nextSibling;
+
+ while ( nextptr != NULL )
+ {
+ nextptr->parentNode = parentNode;
+ nextptr = nextptr->nextSibling;
+ }
+}
+
+/*================================================================
+* XmlNodeCloneNodeTreeRecursive
+* recursive functions that clones node tree of nodeptr.
+* Internal to parser only.
+*
+*=================================================================*/
+XmlNode *
+XmlNodeCloneNodeTreeRecursive(
+ Pool * pool,
+
+ XmlNode * nodeptr,
+ IN BOOL deep )
+{
+ XmlNode * newNode = NULL;
+ XmlElement *newElement;
+ XmlAttribute *newAttr = NULL;
+ XmlCDATASection *newCDATA = NULL;
+ XmlDocument *newDoc;
+ XmlNode * nextSib;
+
+ if ( nodeptr != NULL )
+ {
+ switch ( nodeptr->nodeType )
+ {
+ case XML_ELEMENT_NODE:
+ newElement =
+ XmlNodeCloneElement(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ ( XmlElement * ) nodeptr );
+ if(NULL == newElement)
+ {
+ return NULL;
+ }
+
+ newElement->node.firstAttr =
+ XmlNodeCloneNodeTreeRecursive(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ nodeptr->firstAttr,
+ deep );
+ if ( deep )
+ {
+ newElement->node.firstChild =
+ XmlNodeCloneNodeTreeRecursive(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ nodeptr->
+ firstChild,
+ deep );
+ if ( newElement->node.firstChild != NULL )
+ {
+ ( newElement->node.firstChild )->parentNode =
+ ( XmlNode * ) newElement;
+ XmlNodeSetSiblingNodesParent( newElement->node.
+ firstChild );
+ }
+ nextSib =
+ XmlNodeCloneNodeTreeRecursive(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+
+ nodeptr->
+ nextSibling,
+ deep );
+ newElement->node.nextSibling = nextSib;
+ if ( nextSib != NULL )
+ {
+ nextSib->prevSibling = ( XmlNode * ) newElement;
+ }
+ }
+
+ newNode = ( XmlNode * ) newElement;
+ break;
+
+ case XML_ATTRIBUTE_NODE:
+ newAttr = XmlNodeCloneAttr(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+
+ ( XmlAttribute * ) nodeptr );
+ if(NULL == newAttr)
+ {
+ return NULL;
+ }
+
+
+ nextSib =
+ XmlNodeCloneNodeTreeRecursive(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ nodeptr->nextSibling,
+ deep );
+ newAttr->node.nextSibling = nextSib;
+
+ if ( nextSib != NULL )
+ {
+ nextSib->prevSibling = ( XmlNode * ) newAttr;
+ }
+ newNode = ( XmlNode * ) newAttr;
+ break;
+
+ case XML_TEXT_NODE:
+ newNode = XmlNodeCloneTextNode(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+
+ nodeptr );
+ break;
+
+ case XML_CDATA_SECTION_NODE:
+ newCDATA =
+ XmlNodeCloneCDATASect(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+
+ ( XmlCDATASection * )
+ nodeptr );
+ newNode = ( XmlNode * ) newCDATA;
+ break;
+
+ case XML_DOCUMENT_NODE:
+ newDoc = XmlNodeCloneDoc(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+
+ ( XmlDocument * ) nodeptr );
+
+ if(NULL == newDoc)
+ {
+ return NULL;
+ }
+
+ newNode = ( XmlNode * ) newDoc;
+ if ( deep )
+ {
+ newNode->firstChild =
+ XmlNodeCloneNodeTreeRecursive(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+
+ nodeptr->
+ firstChild,
+ deep );
+ if ( newNode->firstChild != NULL )
+ {
+ newNode->firstChild->parentNode = newNode;
+ }
+ }
+
+ break;
+
+ case XML_INVALID_NODE:
+ case XML_ENTITY_REFERENCE_NODE:
+ case XML_ENTITY_NODE:
+ case XML_PROCESSING_INSTRUCTION_NODE:
+ case XML_COMMENT_NODE:
+ case XML_DOCUMENT_TYPE_NODE:
+ case XML_DOCUMENT_FRAGMENT_NODE:
+ case XML_NOTATION_NODE:
+ break;
+ }
+ }
+
+ return newNode;
+}
+
+/*================================================================
+* XmlNodeCloneNodeTree
+* clones a node tree.
+* Internal to parser only.
+*
+*=================================================================*/
+XmlNode *
+XmlNodeCloneNodeTree(
+ Pool * pool,
+ XmlNode * nodeptr,
+ IN BOOL deep )
+{
+ XmlNode * newNode = NULL;
+ XmlElement *newElement;
+ XmlNode * childNode;
+
+ assert( nodeptr != NULL );
+
+ switch ( nodeptr->nodeType )
+ {
+ case XML_ELEMENT_NODE:
+ newElement =
+ XmlNodeCloneElement(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+
+ ( XmlElement * ) nodeptr );
+
+ if(NULL == newElement)
+ {
+ return NULL;
+ }
+
+ newElement->node.firstAttr =
+ XmlNodeCloneNodeTreeRecursive(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+
+ nodeptr->firstAttr,
+ deep );
+ if ( deep )
+ {
+ newElement->node.firstChild =
+ XmlNodeCloneNodeTreeRecursive(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+
+ nodeptr->firstChild,
+ deep );
+ childNode = newElement->node.firstChild;
+ while ( childNode != NULL )
+ {
+ childNode->parentNode = ( XmlNode * ) newElement;
+ childNode = childNode->nextSibling;
+ }
+ newElement->node.nextSibling = NULL;
+ }
+
+ newNode = ( XmlNode * ) newElement;
+ break;
+
+ case XML_ATTRIBUTE_NODE:
+ case XML_TEXT_NODE:
+ case XML_CDATA_SECTION_NODE:
+ case XML_DOCUMENT_NODE:
+ newNode = XmlNodeCloneNodeTreeRecursive(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+
+ nodeptr, deep );
+ break;
+
+ case XML_INVALID_NODE:
+ case XML_ENTITY_REFERENCE_NODE:
+ case XML_ENTITY_NODE:
+ case XML_PROCESSING_INSTRUCTION_NODE:
+ case XML_COMMENT_NODE:
+ case XML_DOCUMENT_TYPE_NODE:
+ case XML_DOCUMENT_FRAGMENT_NODE:
+ case XML_NOTATION_NODE:
+ break;
+ }
+
+ if(NULL != newNode)
+ {
+ // by spec, the duplicate node has no parent
+ newNode->parentNode = NULL;
+ }
+
+ return newNode;
+}
+
+/*================================================================
+* XmlNodeCloneNode
+* Clones a node, if deep==TRUE, clones subtree under nodeptr.
+* External function.
+* Returns:
+* the cloned node or NULL if error occurs.
+*
+*=================================================================*/
+XmlNode *
+XmlNodeCloneNode(
+ Pool * pool,
+
+ XmlNode * nodeptr,
+ IN BOOL deep )
+{
+
+ XmlNode * newNode;
+ XmlAttribute *newAttrNode;
+
+ if ( nodeptr == NULL )
+ {
+ return NULL;
+ }
+
+ switch ( nodeptr->nodeType )
+ {
+ case XML_ATTRIBUTE_NODE:
+ newAttrNode =
+ XmlNodeCloneAttrDirect(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+
+ ( XmlAttribute * ) nodeptr );
+ return ( XmlNode * ) newAttrNode;
+ break;
+
+ default:
+ newNode = XmlNodeCloneNodeTree(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+
+ nodeptr, deep );
+ return newNode;
+ break;
+ }
+
+}
+
+/*================================================================
+* XmlNodeGetChildNodes
+* Returns a XmlNodeList of all the child nodes of nodeptr.
+* External function.
+*
+*=================================================================*/
+XmlNodeList *
+#ifdef USE_CWMP_MEMORY_POOL
+XmlNodeGetChildNodes(Pool * pool, XmlNode * nodeptr )
+#else
+XmlNodeGetChildNodes( XmlNode * nodeptr )
+#endif
+{
+ XmlNode * tempNode;
+ XmlNodeList *newNodeList;
+ int rc;
+
+ if ( nodeptr == NULL )
+ {
+ return NULL;
+ }
+
+ newNodeList = ( XmlNodeList * ) PMALLOC( sizeof( XmlNodeList ) );
+ if ( newNodeList == NULL )
+ {
+ return NULL;
+ }
+
+ XmlNodeListInit( newNodeList );
+
+ tempNode = nodeptr->firstChild;
+ while ( tempNode != NULL )
+ {
+ rc = XmlNodeListAddToNodeList(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+
+ &newNodeList, tempNode );
+ if ( rc != XML_OK )
+ {
+ XmlNodeListFree(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ newNodeList );
+ return NULL;
+ }
+
+ tempNode = tempNode->nextSibling;
+ }
+ return newNodeList;
+}
+
+/*================================================================
+* XmlNodeGetAttributes
+* returns a namedNodeMap of attributes of nodeptr
+* External function.
+* Returns:
+*
+*=================================================================*/
+XmlNamedNodeMap *
+#ifdef USE_CWMP_MEMORY_POOL
+XmlNodeGetAttributes(Pool * pool, XmlNode * nodeptr )
+#else
+XmlNodeGetAttributes( XmlNode * nodeptr )
+#endif
+{
+ XmlNamedNodeMap *returnNamedNodeMap = NULL;
+ XmlNode * tempNode;
+ int rc;
+
+ if ( nodeptr == NULL )
+ {
+ return NULL;
+ }
+
+ if ( nodeptr->nodeType == XML_ELEMENT_NODE )
+ {
+ returnNamedNodeMap =
+ ( XmlNamedNodeMap * ) PMALLOC( sizeof( XmlNamedNodeMap ) );
+ if ( returnNamedNodeMap == NULL )
+ {
+ return NULL;
+ }
+
+ XmlNamedNodeMapInit( returnNamedNodeMap );
+
+ tempNode = nodeptr->firstAttr;
+ while ( tempNode != NULL )
+ {
+ rc = XmlNamedNodeMapAddToNamedNodeMap(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ &returnNamedNodeMap,
+ tempNode );
+ if ( rc != XML_OK )
+ {
+ XmlNamedNodeMapFree(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ returnNamedNodeMap );
+ return NULL;
+ }
+
+ tempNode = tempNode->nextSibling;
+ }
+ return returnNamedNodeMap;
+ }
+ else // if not an ELEMENT_NODE
+ {
+ return NULL;
+ }
+}
+
+/*================================================================
+* XmlNodeHasChildNodes
+* External function.
+*
+*=================================================================*/
+BOOL
+XmlNodeHasChildNodes( XmlNode * nodeptr )
+{
+ if ( nodeptr == NULL )
+ {
+ return FALSE;
+ }
+
+ return ( nodeptr->firstChild != NULL );
+
+}
+
+/*================================================================
+* XmlNodeHasAttributes
+* External function.
+*
+*=================================================================*/
+BOOL
+XmlNodeHasAttributes( XmlNode * nodeptr )
+{
+ if ( nodeptr != NULL )
+ {
+ if ( ( nodeptr->nodeType == XML_ELEMENT_NODE )
+ && ( nodeptr->firstAttr != NULL ) )
+ {
+ return TRUE;
+ }
+ }
+ return FALSE;
+
+}
+
+/*================================================================
+* XmlNodeGetElementsByTagNameRecursive
+* Recursively traverse the whole tree, search for element
+* with the given tagname.
+* Internal to parser.
+*
+*=================================================================*/
+void
+XmlNodeGetElementsByTagNameRecursive(
+ Pool * pool,
+ XmlNode * n,
+ IN char *tagname,
+ OUT XmlNodeList ** list )
+{
+ const char *name;
+
+ if ( n != NULL )
+ {
+ if ( XmlNodeGetNodeType( n ) == XML_ELEMENT_NODE )
+ {
+ name = XmlNodeGetNodeName( n )? XmlNodeGetNodeName( n ):"";
+ if ( strcmp( tagname, name ) == 0
+ || strcmp( tagname, "*" ) == 0 )
+ {
+ XmlNodeListAddToNodeList(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+
+ list, n );
+ }
+ }
+
+ XmlNodeGetElementsByTagNameRecursive(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ XmlNodeGetFirstChild
+ ( n ), tagname, list );
+ XmlNodeGetElementsByTagNameRecursive(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+
+ XmlNodeGetNextSibling
+ ( n ), tagname, list );
+ }
+
+}
+
+/*================================================================
+* XmlNodeGetElementsByTagName
+* Returns a nodeList of all descendant Elements with a given
+* tagName, in the order in which they are encountered in a
+* traversal of this element tree.
+* External function.
+*
+*=================================================================*/
+void
+XmlNodeGetElementsByTagName(
+ Pool * pool,
+ XmlNode * n,
+ IN char *tagname,
+ OUT XmlNodeList ** list )
+{
+ const char *name;
+
+ assert( n != NULL && tagname != NULL );
+
+ if ( XmlNodeGetNodeType( n ) == XML_ELEMENT_NODE )
+ {
+ name = XmlNodeGetNodeName( n )?XmlNodeGetNodeName( n ):"";
+ if ( strcmp( tagname, name ) == 0 || strcmp( tagname, "*" ) == 0 )
+ {
+ XmlNodeListAddToNodeList(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ list, n );
+ }
+ }
+
+ XmlNodeGetElementsByTagNameRecursive(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ XmlNodeGetFirstChild( n ),
+ tagname, list );
+
+}
+
+/*================================================================
+* XmlNodeGetElementsByTagNameNSRecursive
+* Internal function to parser.
+*
+*
+*=================================================================*/
+void
+XmlNodeGetElementsByTagNameNSRecursive(
+ Pool * pool,
+ XmlNode * n,
+ const char *namespaceURI,
+ const char *localName,
+ OUT XmlNodeList ** list )
+{
+ const char * nsURI;
+ const char * name;
+
+ if ( n != NULL )
+ {
+ if ( XmlNodeGetNodeType( n ) == XML_ELEMENT_NODE )
+ {
+ name = XmlNodeGetLocalName( n );
+ nsURI = XmlNodeGetNamespaceURI( n );
+
+ if ( ( name != NULL ) && ( nsURI != NULL ) &&
+ ( strcmp( namespaceURI, nsURI ) == 0
+ || strcmp( namespaceURI, "*" ) == 0 )
+ && ( strcmp( name, localName ) == 0
+ || strcmp( localName, "*" ) == 0 ) )
+ {
+ XmlNodeListAddToNodeList(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ list, n );
+ }
+ }
+
+ XmlNodeGetElementsByTagNameNSRecursive(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+
+ XmlNodeGetFirstChild
+ ( n ), namespaceURI,
+ localName, list );
+ XmlNodeGetElementsByTagNameNSRecursive(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ XmlNodeGetNextSibling
+ ( n ), namespaceURI,
+ localName, list );
+ }
+
+}
+
+/*================================================================
+* XmlNodeGetElementsByTagNameNS
+* Returns a nodeList of all the descendant Elements with a given
+* local name and namespace URI in the order in which they are
+* encountered in a preorder traversal of this Elememt tree.
+* External function.
+*
+*=================================================================*/
+void
+XmlNodeGetElementsByTagNameNS(
+ Pool * pool,
+ XmlNode * n,
+ const char *namespaceURI,
+ const char *localName,
+ OUT XmlNodeList ** list )
+{
+ const char * nsURI;
+ const char * name;
+
+ assert( n != NULL && namespaceURI != NULL && localName != NULL );
+
+ if ( XmlNodeGetNodeType( n ) == XML_ELEMENT_NODE )
+ {
+ name = XmlNodeGetLocalName( n );
+ nsURI = XmlNodeGetNamespaceURI( n );
+
+ if ( ( name != NULL ) && ( nsURI != NULL ) &&
+ ( strcmp( namespaceURI, nsURI ) == 0
+ || strcmp( namespaceURI, "*" ) == 0 )
+ && ( strcmp( name, localName ) == 0
+ || strcmp( localName, "*" ) == 0 ) )
+ {
+ XmlNodeListAddToNodeList(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ list, n );
+ }
+ }
+
+ XmlNodeGetElementsByTagNameNSRecursive(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ XmlNodeGetFirstChild( n ),
+ namespaceURI, localName,
+ list );
+
+}
+
+/*================================================================
+* XmlNodeSetNodeName
+* Internal to parser only.
+*
+*=================================================================*/
+int
+XmlNodeSetNodeName(
+ Pool * pool,
+
+ XmlNode * node,
+ const char * qualifiedName )
+{
+ int rc = XML_OK;
+
+ assert( node != NULL );
+
+ if ( node->nodeName != NULL )
+ {
+ PFREE( node->nodeName );
+ node->nodeName = NULL;
+ }
+
+ if ( qualifiedName != NULL )
+ {
+ // set the name part
+ node->nodeName = PSTRDUP( qualifiedName );
+ if ( node->nodeName == NULL )
+ {
+ return XML_INSUFFICIENT_MEMORY;
+ }
+
+ rc = XmlParserSetNodePrefixAndLocalName(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ node );
+ if ( rc != XML_OK )
+ {
+ PFREE( node->nodeName );
+ }
+ }
+
+ return rc;
+}
+
+/*================================================================
+* XmlNodeSetNodeProperties
+* Internal to parser only.
+*
+*=================================================================*/
+int
+XmlNodeSetNodeProperties(
+ Pool * pool,
+ XmlNode * destNode,
+ XmlNode * src )
+{
+
+ int rc;
+
+ assert( destNode != NULL || src != NULL );
+
+ rc = XmlNodeSetNodeValue(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ destNode, src->nodeValue );
+ if ( rc != XML_OK )
+ {
+ goto ErrorHandler;
+ }
+
+ rc = XmlNodeSetLocalName(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ destNode, src->localName );
+ if ( rc != XML_OK )
+ {
+ goto ErrorHandler;
+ }
+
+ rc = XmlNodeSetPrefix(
+#ifdef USE_CWMP_MEMORY_POOL
+ pool ,
+#endif
+ destNode, src->prefix );
+ if ( rc != XML_OK )
+ {
+ goto ErrorHandler;
+ }
+ // set nodetype
+ destNode->nodeType = src->nodeType;
+
+ return XML_OK;
+
+ErrorHandler:
+#ifndef USE_CWMP_MEMORY_POOL
+ if ( destNode->nodeName != NULL )
+ {
+ PFREE( destNode->nodeName );
+ destNode->nodeName = NULL;
+ }
+ if ( destNode->nodeValue != NULL )
+ {
+ PFREE( destNode->nodeValue );
+ destNode->nodeValue = NULL;
+ }
+ if ( destNode->localName != NULL )
+ {
+ PFREE( destNode->localName );
+ destNode->localName = NULL;
+ }
+#endif
+ return XML_INSUFFICIENT_MEMORY;
+}