ap/app/cwmp/netcwmp/libxmlet/src/node.c

///////////////////////////////////////////////////////////////////////////
//
// 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;
}