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