[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/element.c b/ap/app/cwmp/netcwmp/libxmlet/src/element.c
new file mode 100755
index 0000000..ee89df5
--- /dev/null
+++ b/ap/app/cwmp/netcwmp/libxmlet/src/element.c
@@ -0,0 +1,1199 @@
+///////////////////////////////////////////////////////////////////////////

+//

+// 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"

+

+

+/*================================================================

+*   XmlElement_Init

+*       Initializes an element node.

+*       External function.

+*

+*=================================================================*/

+void

+XmlElementInit( XmlElement * element )

+{

+    if ( element != NULL )

+    {

+        memset( element, 0, sizeof( XmlElement ) );

+        element->node.nodeType = XML_ELEMENT_NODE;

+    }

+}

+

+/*================================================================

+*   XmlElementGetTagName

+*       Gets the element node's tagName

+*       External function.

+*

+*=================================================================*/

+const char *

+XmlElementGetTagName( XmlElement * element )

+{

+

+    if ( element != NULL )

+    {

+        return element->tagName;

+    }

+    else

+    {

+        return NULL;

+    }

+}

+

+/*================================================================

+*   XmlElementSetTagName

+*       Sets the given element's tagName.

+*   Parameters:

+*       tagName: new tagName for the element.

+*

+*=================================================================*/

+int

+XmlElementSetTagName(

+    Pool * pool,

+    XmlElement * element,

+    const char *tagName )

+{

+    int rc = XML_OK;

+

+//    assert( ( element != NULL ) && ( tagName != NULL ) );

+    if ( ( element == NULL ) || ( tagName == NULL ) )

+    {

+        return XML_FAILED;

+    }

+

+    if ( element->tagName != NULL )

+    {

+        PFREE( element->tagName );

+    }

+

+    element->tagName = PSTRDUP( tagName );

+    if ( element->tagName == NULL )

+    {

+        rc = XML_INSUFFICIENT_MEMORY;

+    }

+

+    return rc;

+

+}

+

+/*=========================================================================

+*   XmlElementGetAttribute

+*       Retrievea an attribute value by name.

+*       External function.

+*   Parameters:

+*       name: the name of the attribute to retrieve.

+*   Return Values:

+*       attribute value as a string, or the empty string if that attribute

+*       does not have a specified value.

+*

+*========================================================================*/

+char *

+XmlElementGetAttribute( XmlElement * element,

+                        const char *  name )

+{

+    XmlNode *  attrNode;

+

+    if ( ( element == NULL ) || ( name == NULL ) )

+    {

+        return NULL;

+    }

+

+    attrNode = element->node.firstAttr;

+    while ( attrNode != NULL )

+    {

+        if ( strcmp( attrNode->nodeName, name ) == 0 )  // found it

+        {

+            return attrNode->nodeValue;

+        }

+        else

+        {

+            attrNode = attrNode->nextSibling;

+        }

+    }

+

+    return NULL;

+}

+

+/*======================================================================

+*   XmlElementSetAttribute

+*  	Adds a new attribute.  If an attribute with that name is already

+*  	present in the element, its value is changed to be that of the value

+*  	parameter. If not, a new attribute is inserted into the element.

+*

+*  	External function.

+*   Parameters:

+*   name: the name of the attribute to create or alter.

+*  	value: value to set in string form

+*   Return Values:

+*  	XML_OK or failure code.

+*=======================================================================*/

+int

+XmlElementSetAttribute(

+    Pool * pool,

+    XmlElement * element,

+    const char *name,

+    const char *value )

+{

+    XmlNode *  attrNode;

+    XmlAttribute *newAttrNode;

+    short errCode = XML_OK;

+

+    if ( ( element == NULL ) || ( name == NULL ) || ( value == NULL ) )

+    {

+        errCode = XML_INVALID_PARAMETER;

+        goto ErrorHandler;

+    }

+

+    if ( XmlParserIsValidXmlName( name ) == FALSE )

+    {

+        errCode = XML_INVALID_CHARACTER_ERR;

+        goto ErrorHandler;

+    }

+

+    attrNode = element->node.firstAttr;

+    while ( attrNode != NULL )

+    {

+        if ( strcmp( attrNode->nodeName, name ) == 0 )

+        {

+            break;              //found it

+        }

+        else

+        {

+            attrNode = attrNode->nextSibling;

+        }

+    }

+

+    if ( attrNode == NULL )     // add a new attribute

+    {

+        errCode =

+            XmlDocCreateAttributeEx(

+#ifdef USE_CWMP_MEMORY_POOL

+                pool ,

+#endif

+

+                ( XmlDocument * ) element->node.

+                ownerDocument, name,

+                &newAttrNode );

+        if ( errCode != XML_OK )

+        {

+            goto ErrorHandler;

+        }

+

+        attrNode = ( XmlNode *   ) newAttrNode;

+

+        attrNode->nodeValue = XmlStrduptrim(

+#ifdef USE_CWMP_MEMORY_POOL

+                                  pool ,

+#endif

+                                  value );

+        if ( attrNode->nodeValue == NULL )

+        {

+            XmlAttrFree(

+#ifdef USE_CWMP_MEMORY_POOL

+                pool ,

+#endif

+                newAttrNode );

+            errCode = XML_INSUFFICIENT_MEMORY;

+            goto ErrorHandler;

+        }

+

+        errCode =

+            XmlElementSetAttributeNode( element, newAttrNode, NULL );

+        if ( errCode != XML_OK )

+        {

+            XmlAttrFree(

+#ifdef USE_CWMP_MEMORY_POOL

+                pool ,

+#endif

+                newAttrNode );

+            goto ErrorHandler;

+        }

+

+    }

+    else

+    {

+        if ( attrNode->nodeValue != NULL )  // attribute name has a value already

+        {

+            PFREE( attrNode->nodeValue );

+        }

+

+        attrNode->nodeValue = XmlStrduptrim(

+#ifdef USE_CWMP_MEMORY_POOL

+                                  pool ,

+#endif

+                                  value );

+        if ( attrNode->nodeValue == NULL )

+        {

+            errCode = XML_INSUFFICIENT_MEMORY;

+        }

+    }

+

+ErrorHandler:

+    return errCode;

+}

+

+/*================================================================

+*   XmlElementRemoveAttribute

+*       Removes an attribute value by name. The attribute node is

+*       not removed.

+*       External function.

+*   Parameters:

+*       name: the name of the attribute to remove.

+*   Return Values:

+*       XML_OK or error code.

+*

+*=================================================================*/

+int

+XmlElementRemoveAttribute(

+    Pool * pool,

+    XmlElement * element,

+    const char *name )

+{

+

+    XmlNode *  attrNode;

+

+    if ( ( element == NULL ) || ( name == NULL ) )

+    {

+        return XML_INVALID_PARAMETER;

+    }

+

+    attrNode = element->node.firstAttr;

+    while ( attrNode != NULL )

+    {

+        if ( strcmp( attrNode->nodeName, name ) == 0 )

+        {

+            break;              //found it

+        }

+        else

+        {

+            attrNode = attrNode->nextSibling;

+        }

+    }

+

+    if ( attrNode != NULL )     // has the attribute

+    {

+        if ( attrNode->nodeValue != NULL )

+        {

+            PFREE( attrNode->nodeValue );

+            attrNode->nodeValue = NULL;

+        }

+    }

+

+    return XML_OK;

+}

+

+/*================================================================

+*   XmlElementGetAttributeNode

+*       Retrieve an attribute node by name.

+*       External function.

+*   Parameters:

+*       name: the name(nodeName) of the attribute to retrieve.

+*   Return Value:

+*       The attr node with the specified name (nodeName) or NULL if

+*       there is no such attribute.

+*

+*=================================================================*/

+XmlAttribute *

+XmlElementGetAttributeNode( XmlElement * element,

+                            IN char *name )

+{

+

+    XmlNode *  attrNode;

+

+    if ( ( element == NULL ) || ( name == NULL ) )

+    {

+        return NULL;

+    }

+

+    attrNode = element->node.firstAttr;

+    while ( attrNode != NULL )

+    {

+        if ( strcmp( attrNode->nodeName, name ) == 0 )  // found it

+        {

+            break;

+        }

+        else

+        {

+            attrNode = attrNode->nextSibling;

+        }

+    }

+

+    return ( XmlAttribute * ) attrNode;

+

+}

+

+/*==========================================================================

+*   XmlElementSetAttributeNode

+*       Adds a new attribute node.  If an attribute with that name(nodeName)

+*       is already present in the element, it is replaced by the new one.

+*       External function.

+*   Parameters:

+*       The attr node to add to the attribute list.

+*   Return Value:

+*       if newAttr replaces an existing attribute, the replaced

+*       attr node is returned, otherwise NULL is returned.

+*

+*===========================================================================*/

+int

+XmlElementSetAttributeNode( XmlElement * element,

+                            XmlAttribute * newAttr,

+                            OUT XmlAttribute ** rtAttr )

+{

+

+    XmlNode *  attrNode;

+    XmlNode *  node;

+    XmlNode *  nextAttr = NULL;

+    XmlNode *  prevAttr = NULL;

+    XmlNode *  preSib;

+    XmlNode *  nextSib;

+

+    if ( ( element == NULL ) || ( newAttr == NULL ) )

+    {

+        return XML_INVALID_PARAMETER;

+    }

+

+    if ( newAttr->node.ownerDocument != element->node.ownerDocument )

+    {

+        return XML_WRONG_DOCUMENT_ERR;

+    }

+

+    if ( newAttr->ownerElement != NULL )

+    {

+        return XML_INUSE_ATTRIBUTE_ERR;

+    }

+

+    newAttr->ownerElement = element;

+    node = ( XmlNode *   ) newAttr;

+

+    attrNode = element->node.firstAttr;

+    while ( attrNode != NULL )

+    {

+        if ( strcmp( attrNode->nodeName, node->nodeName ) == 0 )

+        {

+            break;              //found it

+        }

+        else

+        {

+            attrNode = attrNode->nextSibling;

+        }

+    }

+

+    if ( attrNode != NULL )     // already present, will replace by newAttr

+    {

+        preSib = attrNode->prevSibling;

+        nextSib = attrNode->nextSibling;

+

+        if ( preSib != NULL )

+        {

+            preSib->nextSibling = node;

+        }

+

+        if ( nextSib != NULL )

+        {

+            nextSib->prevSibling = node;

+        }

+

+        if ( element->node.firstAttr == attrNode )

+        {

+            element->node.firstAttr = node;

+        }

+

+        if ( rtAttr != NULL )

+        {

+            *rtAttr = ( XmlAttribute * ) attrNode;

+        }

+    }

+    else                      // add this attribute

+    {

+        if ( element->node.firstAttr != NULL )

+        {

+            prevAttr = element->node.firstAttr;

+            nextAttr = prevAttr->nextSibling;

+            while ( nextAttr != NULL )

+            {

+                prevAttr = nextAttr;

+                nextAttr = prevAttr->nextSibling;

+            }

+            prevAttr->nextSibling = node;

+            node->prevSibling = prevAttr;

+        }

+        else                  // this is the first attribute node

+        {

+            element->node.firstAttr = node;

+            node->prevSibling = NULL;

+            node->nextSibling = NULL;

+        }

+

+        if ( rtAttr != NULL )

+        {

+            *rtAttr = NULL;

+        }

+    }

+

+    return XML_OK;

+}

+

+/*=======================================================================

+*   XmlElementFindAttributeNode

+*       Find a attribute node whose contents are the same as the oldAttr.

+*       Internal only to parser.

+*   Parameter:

+*       oldAttr: the attribute node to match

+*   Return:

+*       if found it, the attribute node is returned,

+*       otherwise, return NULL.

+*

+*========================================================================*/

+XmlNode *

+XmlElementFindAttributeNode( XmlElement * element,

+                             XmlAttribute * oldAttr )

+{

+    XmlNode *  attrNode;

+    XmlNode *  oldAttrNode = ( XmlNode *   ) oldAttr;

+

+    assert( ( element != NULL ) && ( oldAttr != NULL ) );

+

+    attrNode = element->node.firstAttr;

+    while ( attrNode != NULL )  // parentNode, prevSib, nextSib and ownerDocument doesn't matter

+    {

+        if ( XmlNodeCompare( attrNode, oldAttrNode ) == TRUE )

+        {

+            break;              //found it

+        }

+        else

+        {

+            attrNode = attrNode->nextSibling;

+        }

+    }

+

+    return attrNode;

+

+}

+

+/*==================================================================

+*   XmlElementRemoveAttributeNode

+*       Removes the specified attribute node.

+*       External function.

+*

+*   Parameters:

+*       oldAttr: the attr node to remove from the attribute list.

+*

+*   Return Value:

+*       XML_OK or failure

+*

+*===================================================================*/

+int

+XmlElementRemoveAttributeNode( XmlElement * element,

+                               XmlAttribute    * oldAttr,

+                               OUT XmlAttribute   ** rtAttr )

+{

+    XmlNode * attrNode;

+    XmlNode * preSib;

+    XmlNode * nextSib;

+

+    if ( ( element == NULL ) || ( oldAttr == NULL ) )

+    {

+        return XML_INVALID_PARAMETER;

+    }

+

+    attrNode = XmlElementFindAttributeNode( element, oldAttr );

+    if ( attrNode != NULL )     // has the attribute

+    {

+        preSib = attrNode->prevSibling;

+        nextSib = attrNode->nextSibling;

+

+        if ( preSib != NULL )

+        {

+            preSib->nextSibling = nextSib;

+        }

+

+        if ( nextSib != NULL )

+        {

+            nextSib->prevSibling = preSib;

+        }

+

+        if ( element->node.firstAttr == attrNode )

+        {

+            element->node.firstAttr = nextSib;

+        }

+

+        attrNode->parentNode = 0;

+        attrNode->prevSibling = 0 ;

+        attrNode->nextSibling = 0;

+        *rtAttr = ( XmlAttribute * ) attrNode;

+        return XML_OK;

+

+    }

+    else

+    {

+        return XML_NOT_FOUND_ERR;

+    }

+

+}

+

+/*================================================================

+*   XmlElementGetElementsByTagName

+*       Returns a nodeList of all descendant Elements with a given

+*       tag name, in the order in which they are encountered in a preorder

+*       traversal of this element tree.

+*       External function.

+*

+*   Parameters:

+*       tagName: the name of the tag to match on. The special value "*"

+*       matches all tags.

+*

+*   Return Value:

+*       a nodeList of matching element nodes.

+*

+*=================================================================*/

+XmlNodeList *

+XmlElementGetElementsByTagName(

+    Pool * pool,

+    XmlElement * element,

+    IN char *tagName )

+{

+    XmlNodeList *returnNodeList = NULL;

+

+    if ( ( element != NULL ) && ( tagName != NULL ) )

+    {

+        XmlNodeGetElementsByTagName(

+#ifdef USE_CWMP_MEMORY_POOL

+            pool ,

+#endif

+

+            ( XmlNode *   ) element, tagName,

+            &returnNodeList );

+    }

+    return returnNodeList;

+}

+

+/*================================================================

+*   XmlElementGetAttributeNS

+*       Retrieves an attribute value by local name and namespace URI.

+*       External function.

+*

+*   Parameters:

+*       namespaceURI: the namespace URI of the attribute to retrieve.

+*       localName: the local name of the attribute to retrieve.

+*

+*   Return Value:

+*       the attr value as a string, or NULL if that attribute does

+*       not have the specified value.

+*

+*=================================================================*/

+char *

+XmlElementGetAttributeNS( XmlElement * element,

+                          const char *  namespaceURI,

+                          const char *  localName )

+{

+    XmlNode *  attrNode;

+

+    if ( ( element == NULL ) || ( namespaceURI == NULL )

+            || ( localName == NULL ) )

+    {

+        return NULL;

+    }

+

+    attrNode = element->node.firstAttr;

+    while ( attrNode != NULL )

+    {

+        if ( strcmp( attrNode->localName, localName ) == 0 && strcmp( attrNode->namespaceURI, namespaceURI ) == 0 )     // found it

+        {

+            return attrNode->nodeValue;

+        }

+        else

+        {

+            attrNode = attrNode->nextSibling;

+        }

+    }

+

+    return NULL;

+

+}

+

+/*================================================================

+*   XmlElementSetAttributeNS

+*       Adds a new attribute. If an attribute with the same local name

+*       and namespace URI is already present on the element, its prefix

+*       is changed to be the prefix part of the qualifiedName, and its

+*       value is changed to be the value parameter.  This value is a

+*       simple string.

+*       External function.

+*

+*   Parameter:

+*       namespaceURI: the namespace of the attribute to create or alter.

+*       qualifiedName: the qualified name of the attribute to create or alter.

+*       value: the value to set in string form.

+*

+*   Return Value:

+*       XML_OK or failure

+*

+*=================================================================*/

+int

+XmlElementSetAttributeNS(

+    Pool * pool,

+    XmlElement * element,

+    const char *  namespaceURI,

+    const char *  qualifiedName,

+    const char *  value )

+{

+    XmlNode *  attrNode = NULL;

+    XmlNode newAttrNode;

+    XmlAttribute *newAttr;

+    int rc;

+

+    if ( ( element == NULL ) || ( namespaceURI == NULL ) ||

+            ( qualifiedName == NULL ) || ( value == NULL ) )

+    {

+        return XML_INVALID_PARAMETER;

+    }

+

+    if ( XmlParserIsValidXmlName( qualifiedName ) == FALSE )

+    {

+        return XML_INVALID_CHARACTER_ERR;

+    }

+

+    XmlNodeInit( &newAttrNode );

+

+    newAttrNode.nodeName = PSTRDUP( qualifiedName );

+    if ( newAttrNode.nodeName == NULL )

+    {

+        return XML_INSUFFICIENT_MEMORY;

+    }

+

+    rc = XmlParserSetNodePrefixAndLocalName(

+#ifdef USE_CWMP_MEMORY_POOL

+             pool ,

+#endif

+

+             &newAttrNode );

+    if ( rc != XML_OK )

+    {

+        XmlParserFreeNodeContent(

+#ifdef USE_CWMP_MEMORY_POOL

+            pool ,

+#endif

+            &newAttrNode );

+        return rc;

+    }

+    // see DOM 2 spec page 59

+    if ( /*( newAttrNode.prefix != NULL && namespaceURI == NULL ) ||*/

+            (newAttrNode.prefix != NULL && strcmp( newAttrNode.prefix, "xml" ) == 0 &&

+              strcmp( namespaceURI,

+                      "http://www.w3.org/XML/1998/namespace" ) != 0 )

+            || ( strcmp( qualifiedName, "xmlns" ) == 0

+                 && strcmp( namespaceURI,

+                            "http://www.w3.org/2000/xmlns/" ) != 0 ) )

+    {

+        XmlParserFreeNodeContent(

+#ifdef USE_CWMP_MEMORY_POOL

+            pool ,

+#endif

+            &newAttrNode );

+        return XML_NAMESPACE_ERR;

+    }

+

+    attrNode = element->node.firstAttr;

+    while ( attrNode != NULL )

+    {

+        if ( strcmp( attrNode->localName, newAttrNode.localName ) == 0 &&

+                strcmp( attrNode->namespaceURI, namespaceURI ) == 0 )

+        {

+            break;              //found it

+        }

+        else

+        {

+            attrNode = attrNode->nextSibling;

+        }

+    }

+

+    if ( attrNode != NULL )

+    {

+        if ( attrNode->prefix != NULL )

+        {

+            PFREE( attrNode->prefix );   // remove the old prefix

+        }

+        // replace it with the new prefix

+        attrNode->prefix = PSTRDUP( newAttrNode.prefix );

+        if ( attrNode->prefix == NULL )

+        {

+            XmlParserFreeNodeContent(

+#ifdef USE_CWMP_MEMORY_POOL

+                pool ,

+#endif

+                &newAttrNode );

+            return XML_INSUFFICIENT_MEMORY;

+        }

+

+        if ( attrNode->nodeValue != NULL )

+        {

+            PFREE( attrNode->nodeValue );

+        }

+

+        attrNode->nodeValue = XmlStrduptrim(

+#ifdef USE_CWMP_MEMORY_POOL

+                                  pool ,

+#endif

+                                  value );

+        if ( attrNode->nodeValue == NULL )

+        {

+            PFREE( attrNode->prefix );

+            XmlParserFreeNodeContent(

+#ifdef USE_CWMP_MEMORY_POOL

+                pool ,

+#endif

+                &newAttrNode );

+            return XML_INSUFFICIENT_MEMORY;

+        }

+

+    }

+    else

+    {

+        // add a new attribute

+        rc = XmlDocCreateAttributeNSEx(

+#ifdef USE_CWMP_MEMORY_POOL

+                 pool ,

+#endif

+

+                 ( XmlDocument * )

+                 element->node.ownerDocument,

+                 namespaceURI, qualifiedName,

+                 &newAttr );

+        if ( rc != XML_OK )

+        {

+            return rc;

+        }

+

+        newAttr->node.nodeValue = XmlStrduptrim(

+#ifdef USE_CWMP_MEMORY_POOL

+                                      pool ,

+#endif

+                                      value );

+        if ( newAttr->node.nodeValue == NULL )

+        {

+            XmlAttrFree(

+#ifdef USE_CWMP_MEMORY_POOL

+                pool ,

+#endif

+                newAttr );

+            return XML_INSUFFICIENT_MEMORY;

+        }

+

+        if ( XmlElementSetAttributeNodeNS( element, newAttr, NULL ) !=

+                XML_OK )

+        {

+            XmlAttrFree(

+#ifdef USE_CWMP_MEMORY_POOL

+                pool ,

+#endif

+                newAttr );

+            return XML_FAILED;

+        }

+

+    }

+

+    XmlParserFreeNodeContent(

+#ifdef USE_CWMP_MEMORY_POOL

+        pool ,

+#endif

+        &newAttrNode );

+    return XML_OK;

+}

+

+/*================================================================

+*   XmlElementRemoveAttributeNS

+*       Removes an attribute by local name and namespace URI. The replacing

+*       attribute has the same namespace URI and local name, as well as

+*       the original prefix.

+*       External function.

+*

+*   Parameters:

+*       namespaceURI: the namespace URI of the attribute to remove.

+*       localName: the local name of the atribute to remove.

+*

+*   Return Value:

+*       XML_OK or failure.

+*

+*=================================================================*/

+int

+XmlElementRemoveAttributeNS(

+    Pool * pool,

+    XmlElement * element,

+    const char *  namespaceURI,

+    const char *  localName )

+{

+    XmlNode *  attrNode;

+

+    if ( ( element == NULL ) || ( namespaceURI == NULL )

+            || ( localName == NULL ) )

+    {

+        return XML_INVALID_PARAMETER;

+    }

+

+    attrNode = element->node.firstAttr;

+    while ( attrNode != NULL )

+    {

+        if ( strcmp( attrNode->localName, localName ) == 0 &&

+                strcmp( attrNode->namespaceURI, namespaceURI ) == 0 )

+        {

+            break;              //found it

+        }

+        else

+        {

+            attrNode = attrNode->nextSibling;

+        }

+    }

+

+    if ( attrNode != NULL )     // has the attribute

+    {

+        if ( attrNode->nodeValue != NULL )

+        {

+            PFREE( attrNode->nodeValue );

+            attrNode->nodeValue = NULL;

+        }

+    }

+

+    return XML_OK;

+

+}

+

+/*================================================================

+*   XmlElementGetAttributeNodeNS

+*       Retrieves an attr node by local name and namespace URI.

+*       External function.

+*

+*   Parameter:

+*       namespaceURI: the namespace of the attribute to retrieve.

+*       localName: the local name of the attribute to retrieve.

+*

+*   Return Value:

+*       The attr node with the specified attribute local name and

+*       namespace URI or null if there is no such attribute.

+*

+*=================================================================*/

+XmlAttribute *

+XmlElementGetAttributeNodeNS( XmlElement * element,

+                              const char *  namespaceURI,

+                              const char *  localName )

+{

+

+    XmlNode *  attrNode;

+

+    if ( ( element == NULL ) || ( namespaceURI == NULL )

+            || ( localName == NULL ) )

+    {

+        return NULL;

+    }

+

+    attrNode = element->node.firstAttr;

+    while ( attrNode != NULL )

+    {

+        if ( strcmp( attrNode->localName, localName ) == 0 && strcmp( attrNode->namespaceURI, namespaceURI ) == 0 )     // found it

+        {

+            break;

+        }

+        else

+        {

+            attrNode = attrNode->nextSibling;

+        }

+    }

+

+    return ( XmlAttribute * ) attrNode;

+

+}

+

+/*================================================================

+*   XmlElementSetAttributeNodeNS

+*       Adds a new attribute. If an attribute with that local name and

+*       that namespace URI is already present in the element, it is replaced

+*       by the new one.

+*       External function.

+*

+*   Parameter:

+*       newAttr: the attr node to add to the attribute list.

+*

+*   Return Value:

+*       If the newAttr attribute replaces an existing attribute with the

+*       same local name and namespace, the replaced attr node is returned,

+*       otherwise null is returned.

+*

+*=================================================================*/

+int

+XmlElementSetAttributeNodeNS( XmlElement * element,

+                              XmlAttribute * newAttr,

+                              OUT XmlAttribute ** rtAttr )

+{

+    XmlNode *  attrNode;

+    XmlNode *  node;

+    XmlNode *  prevAttr = NULL;

+    XmlNode *  nextAttr = NULL;

+    XmlNode *  preSib;

+    XmlNode *  nextSib;

+

+    if ( ( element == NULL ) || ( newAttr == NULL ) )

+    {

+        return XML_INVALID_PARAMETER;

+    }

+

+    if ( newAttr->node.ownerDocument != element->node.ownerDocument )

+    {

+        return XML_WRONG_DOCUMENT_ERR;

+    }

+

+    if ( ( newAttr->ownerElement != NULL )

+            && ( newAttr->ownerElement != element ) )

+    {

+        return XML_INUSE_ATTRIBUTE_ERR;

+    }

+

+    newAttr->ownerElement = element;

+    node = ( XmlNode *   ) newAttr;

+

+    attrNode = element->node.firstAttr;

+    while ( attrNode != NULL )

+    {

+        if ( strcmp( attrNode->localName, node->localName ) == 0 &&

+                strcmp( attrNode->namespaceURI, node->namespaceURI ) == 0 )

+        {

+            break;              //found it

+        }

+        else

+        {

+            attrNode = attrNode->nextSibling;

+        }

+    }

+

+    if ( attrNode != NULL )     // already present, will replace by newAttr

+    {

+        preSib = attrNode->prevSibling;

+        nextSib = attrNode->nextSibling;

+

+        if ( preSib != NULL )

+        {

+            preSib->nextSibling = node;

+        }

+

+        if ( nextSib != NULL )

+        {

+            nextSib->prevSibling = node;

+        }

+

+        if ( element->node.firstAttr == attrNode )

+        {

+            element->node.firstAttr = node;

+        }

+

+        if ( rtAttr != NULL )

+        {

+            *rtAttr = ( XmlAttribute * ) attrNode;

+        }		

+

+    }

+    else                      // add this attribute

+    {

+        if ( element->node.firstAttr != NULL ) // element has attribute already

+        {

+            prevAttr = element->node.firstAttr;

+            nextAttr = prevAttr->nextSibling;

+            while ( nextAttr != NULL )

+            {

+                prevAttr = nextAttr;

+                nextAttr = prevAttr->nextSibling;

+            }

+            prevAttr->nextSibling = node;

+        }

+        else                  // this is the first attribute node

+        {

+            element->node.firstAttr = node;

+            node->prevSibling = NULL;

+            node->nextSibling = NULL;

+        }

+

+        if ( rtAttr != NULL )

+        {

+            *rtAttr = NULL;

+        }

+    }

+

+    return XML_OK;

+}

+

+/*================================================================

+*   XmlElementGetElementsByTagNameNS

+*       Returns a nodeList of all the descendant Elements with a given

+*       local name and namespace in the order in which they are encountered

+*       in a preorder traversal of the element tree.

+*       External function.

+*

+*   Parameters:

+*       namespaceURI: the namespace URI of the elements to match on. The

+*               special value "*" matches all namespaces.

+*       localName: the local name of the elements to match on. The special

+*               value "*" matches all local names.

+*

+*   Return Value:

+*       A new nodeList object containing all the matched Elements.

+*

+*=================================================================*/

+XmlNodeList *

+XmlElementGetElementsByTagNameNS(

+    Pool * pool,

+    XmlElement * element,

+    const char *  namespaceURI,

+    const char *  localName )

+{

+    XmlNode *  node = ( XmlNode *   ) element;

+    XmlNodeList *nodeList = NULL;

+

+    if ( ( element != NULL ) && ( namespaceURI != NULL )

+            && ( localName != NULL ) )

+    {

+        XmlNodeGetElementsByTagNameNS(

+#ifdef USE_CWMP_MEMORY_POOL

+            pool ,

+#endif

+

+            node, namespaceURI, localName,

+            &nodeList );

+    }

+

+    return nodeList;

+}

+

+/*================================================================

+*   XmlElementHasAttribute

+*       Returns true when an attribute with a given name is specified on

+*       this element, false otherwise.

+*       External function.

+*

+*   Parameters:

+*       name: the name of the attribute to look for.

+*

+*   Return Value:

+*       ture if an attribute with the given name is specified on this

+*       element, false otherwise.

+*

+*=================================================================*/

+BOOL

+XmlElementHasAttribute( XmlElement * element,

+                        const char *  name )

+{

+

+    XmlNode *  attrNode;

+

+    if ( ( element == NULL ) || ( name == NULL ) )

+    {

+        return FALSE;

+    }

+

+    attrNode = element->node.firstAttr;

+    while ( attrNode != NULL )

+    {

+        if ( strcmp( attrNode->nodeName, name ) == 0 )

+        {

+            return TRUE;

+        }

+        else

+        {

+            attrNode = attrNode->nextSibling;

+        }

+    }

+

+    return FALSE;

+}

+

+/*================================================================

+*   XmlElementHasAttributeNS

+*       Returns true when attribute with a given local name and namespace

+*       URI is specified on this element, false otherwise.

+*       External function.

+*

+*   Parameters:

+*       namespaceURI: the namespace URI of the attribute to look for.

+*       localName: the local name of the attribute to look for.

+*

+*   Return Value:

+*       true if an attribute with the given local name and namespace URI

+*       is specified, false otherwise.

+*

+*=================================================================*/

+BOOL

+XmlElementHasAttributeNS( XmlElement * element,

+                          const char *  namespaceURI,

+                          const char *  localName )

+{

+

+    XmlNode *  attrNode;

+

+    if ( ( element == NULL ) || ( namespaceURI == NULL )

+            || ( localName == NULL ) )

+    {

+        return FALSE;

+    }

+

+    attrNode = element->node.firstAttr;

+    while ( attrNode != NULL )

+    {

+        if ( strcmp( attrNode->localName, localName ) == 0 &&

+                strcmp( attrNode->namespaceURI, namespaceURI ) == 0 )

+        {

+            return TRUE;

+        }

+        else

+        {

+            attrNode = attrNode->nextSibling;

+        }

+    }

+

+    return FALSE;

+}

+

+

+/*================================================================

+*   XmlElementFree

+*       XFREEs a element node.

+*       External function.

+*

+*=================================================================*/

+void

+XmlElementFree(

+    Pool * pool,

+    XmlElement * element )

+{

+    if ( element != NULL )

+    {

+        XmlNodeFree(

+#ifdef USE_CWMP_MEMORY_POOL

+            pool ,

+#endif

+            ( XmlNode *   ) element );

+    }

+}