/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_xmlsecurity.hxx"
#include "xmldocumentwrapper_xmlsecimpl.hxx"
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <xmloff/attrlist.hxx>
#include "xmlelementwrapper_xmlsecimpl.hxx"
//#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*
* Deleted by AF
#include <memory.h>
*/
#include <sys/types.h>
#include <sys/stat.h>
#ifndef INCLUDED_VECTOR
#include <vector>
#define INCLUDED_VECTOR
#endif
#ifdef UNX
#define stricmp strcasecmp
#endif
namespace cssu = com::sun::star::uno;
namespace cssl = com::sun::star::lang;
namespace cssxc = com::sun::star::xml::crypto;
namespace cssxcsax = com::sun::star::xml::csax;
namespace cssxs = com::sun::star::xml::sax;
namespace cssxw = com::sun::star::xml::wrapper;
#define SERVICE_NAME "com.sun.star.xml.wrapper.XMLDocumentWrapper"
#define IMPLEMENTATION_NAME "com.sun.star.xml.security.bridge.xmlsec.XMLDocumentWrapper_XmlSecImpl"
#define STRXMLNS "xmlns"
#define RTL_ASCII_USTRINGPARAM( asciiStr ) asciiStr, strlen( asciiStr ), RTL_TEXTENCODING_ASCII_US
#define RTL_UTF8_USTRINGPARAM( asciiStr ) asciiStr, strlen( asciiStr ), RTL_TEXTENCODING_UTF8
/* used by the recursiveDelete method */
#define NODE_REMOVED 0
#define NODE_NOTREMOVED 1
#define NODE_STOPED 2
XMLDocumentWrapper_XmlSecImpl::XMLDocumentWrapper_XmlSecImpl( )
{
saxHelper.startDocument();
m_pDocument = saxHelper.getDocument();
/*
* creates the virtual root element
*/
saxHelper.startElement(rtl::OUString(RTL_UTF8_USTRINGPARAM( "root" )), cssu::Sequence<cssxcsax::XMLAttribute>());
m_pRootElement = saxHelper.getCurrentNode();
m_pCurrentElement = m_pRootElement;
}
XMLDocumentWrapper_XmlSecImpl::~XMLDocumentWrapper_XmlSecImpl()
{
saxHelper.endDocument();
xmlFreeDoc(m_pDocument);
}
void XMLDocumentWrapper_XmlSecImpl::getNextSAXEvent()
/****** XMLDocumentWrapper_XmlSecImpl/getNextSAXEvent *************************
*
* NAME
* getNextSAXEvent -- Prepares the next SAX event to be manipulate
*
* SYNOPSIS
* getNextSAXEvent();
*
* FUNCTION
* When converting the document into SAX events, this method is used to
* decide the next SAX event to be generated.
* Two member variables are checked to make the decision, the
* m_pCurrentElement and the m_nCurrentPosition.
* The m_pCurrentElement represents the node which have been covered, and
* the m_nCurrentPosition represents the event which have been sent.
* For example, suppose that the m_pCurrentElement
* points to element A, and the m_nCurrentPosition equals to
* NODEPOSITION_STARTELEMENT, then the next SAX event should be the
* endElement for element A if A has no child, or startElement for the
* first child element of element A otherwise.
* The m_nCurrentPosition can be one of following values:
* NODEPOSITION_STARTELEMENT for startElement;
* NODEPOSITION_ENDELEMENT for endElement;
* NODEPOSITION_NORMAL for other SAX events;
*
* INPUTS
* empty
*
* RESULT
* empty
*
* HISTORY
* 05.01.2004 - implemented
*
* AUTHOR
* Michael Mi
* Email: michael.mi@sun.com
******************************************************************************/
{
OSL_ASSERT( m_pCurrentElement != NULL );
/*
* Get the next event through tree order.
*
* if the current event is a startElement, then the next
* event depends on whether or not the current node has
* children.
*/
if (m_nCurrentPosition == NODEPOSITION_STARTELEMENT)
{
/*
* If the current node has children, then its first child
* should be next current node, and the next event will be
* startElement or charaters(PI) based on that child's node
* type. Otherwise, the endElement of current node is the
* next event.
*/
if (m_pCurrentElement->children != NULL)
{
m_pCurrentElement = m_pCurrentElement->children;
m_nCurrentPosition
= (m_pCurrentElement->type == XML_ELEMENT_NODE)?
NODEPOSITION_STARTELEMENT:NODEPOSITION_NORMAL;
}
else
{
m_nCurrentPosition = NODEPOSITION_ENDELEMENT;
}
}
/*
* if the current event is a not startElement, then the next
* event depends on whether or not the current node has
* following sibling.
*/
else if (m_nCurrentPosition == NODEPOSITION_ENDELEMENT || m_nCurrentPosition == NODEPOSITION_NORMAL)
{
xmlNodePtr pNextSibling = m_pCurrentElement->next;
/*
* If the current node has following sibling, that sibling
* should be next current node, and the next event will be
* startElement or charaters(PI) based on that sibling's node
* type. Otherwise, the endElement of current node's parent
* becomes the next event.
*/
if (pNextSibling != NULL)
{
m_pCurrentElement = pNextSibling;
m_nCurrentPosition
= (m_pCurrentElement->type == XML_ELEMENT_NODE)?
NODEPOSITION_STARTELEMENT:NODEPOSITION_NORMAL;
}
else
{
m_pCurrentElement = m_pCurrentElement->parent;
m_nCurrentPosition = NODEPOSITION_ENDELEMENT;
}
}
}
void XMLDocumentWrapper_XmlSecImpl::sendStartElement(
const cssu::Reference< cssxs::XDocumentHandler >& xHandler,
const cssu::Reference< cssxs::XDocumentHandler >& xHandler2,
const xmlNodePtr pNode) const
throw (cssxs::SAXException)
/****** XMLDocumentWrapper_XmlSecImpl/sendStartElement ************************
*
* NAME
* sendStartElement -- Constructs a startElement SAX event
*
* SYNOPSIS
* sendStartElement(xHandler, xHandler2, pNode);
*
* FUNCTION
* Used when converting the document into SAX event stream.
* This method constructs a startElement SAX event for a particular
* element, then calls the startElement methods of the XDocumentHandlers.
*
* INPUTS
* xHandler - the first XDocumentHandler interface to receive the
* startElement SAX event. It can be NULL.
* xHandler2 - the second XDocumentHandler interface to receive the
* startElement SAX event. It can't be NULL.
* pNode - the node on which the startElement should be generated.
* This node must be a element type.
*
* RESULT
* empty
*
* HISTORY
* 05.01.2004 - implemented
*
* AUTHOR
* Michael Mi
* Email: michael.mi@sun.com
******************************************************************************/
{
SvXMLAttributeList* pAttributeList = new SvXMLAttributeList();
cssu::Reference < cssxs::XAttributeList > xAttrList = cssu::Reference< cssxs::XAttributeList > (pAttributeList);
xmlNsPtr pNsDef = pNode->nsDef;
while (pNsDef != NULL)
{
const xmlChar* pNsPrefix = pNsDef->prefix;
const xmlChar* pNsHref = pNsDef->href;
if (pNsDef->prefix == NULL)
{
pAttributeList->AddAttribute(
rtl::OUString(RTL_UTF8_USTRINGPARAM( STRXMLNS )),
rtl::OUString(RTL_UTF8_USTRINGPARAM( (sal_Char*)pNsHref )));
}
else
{
pAttributeList->AddAttribute(
rtl::OUString(RTL_UTF8_USTRINGPARAM( STRXMLNS ))
+rtl::OUString(RTL_UTF8_USTRINGPARAM( ":" ))
+rtl::OUString(RTL_UTF8_USTRINGPARAM( (sal_Char*)pNsPrefix )),
rtl::OUString(RTL_UTF8_USTRINGPARAM( (sal_Char*)pNsHref )));
}
pNsDef = pNsDef->next;
}
xmlAttrPtr pAttr = pNode->properties;
while (pAttr != NULL)
{
const xmlChar* pAttrName = pAttr->name;
xmlNsPtr pAttrNs = pAttr->ns;
rtl::OUString ouAttrName;
if (pAttrNs == NULL)
{
ouAttrName = rtl::OUString(RTL_UTF8_USTRINGPARAM( (sal_Char*)pAttrName ));
}
else
{
ouAttrName = rtl::OUString(RTL_UTF8_USTRINGPARAM( (sal_Char*)pAttrNs->prefix))
+rtl::OUString(RTL_UTF8_USTRINGPARAM( (sal_Char*)":" ))
+rtl::OUString(RTL_UTF8_USTRINGPARAM( (sal_Char*)pAttrName ));
}
pAttributeList->AddAttribute(
ouAttrName,
rtl::OUString(RTL_UTF8_USTRINGPARAM( (sal_Char*)(pAttr->children->content))));
pAttr = pAttr->next;
}
rtl::OString sNodeName = getNodeQName(pNode);
if (xHandler.is())
{
xHandler->startElement(
rtl::OUString(RTL_UTF8_USTRINGPARAM ( ((sal_Char*)(sNodeName.getStr())) )),
xAttrList);
}
xHandler2->startElement(
rtl::OUString(RTL_UTF8_USTRINGPARAM ( ((sal_Char*)(sNodeName.getStr())) )),
xAttrList);
}
void XMLDocumentWrapper_XmlSecImpl::sendEndElement(
const cssu::Reference< cssxs::XDocumentHandler >& xHandler,
const cssu::Reference< cssxs::XDocumentHandler >& xHandler2,
const xmlNodePtr pNode) const
throw (cssxs::SAXException)
/****** XMLDocumentWrapper_XmlSecImpl/sendEndElement **************************
*
* NAME
* sendEndElement -- Constructs a endElement SAX event
*
* SYNOPSIS
* sendEndElement(xHandler, xHandler2, pNode);
*
* FUNCTION
* Used when converting the document into SAX event stream.
* This method constructs a endElement SAX event for a particular
* element, then calls the endElement methods of the XDocumentHandlers.
*
* INPUTS
* xHandler - the first XDocumentHandler interface to receive the
* endElement SAX event. It can be NULL.
* xHandler2 - the second XDocumentHandler interface to receive the
* endElement SAX event. It can't be NULL.
* pNode - the node on which the endElement should be generated.
* This node must be a element type.
*
* RESULT
* empty
*
* HISTORY
* 05.01.2004 - implemented
*
* AUTHOR
* Michael Mi
* Email: michael.mi@sun.com
******************************************************************************/
{
rtl::OString sNodeName = getNodeQName(pNode);
if (xHandler.is())
{
xHandler->endElement(rtl::OUString(RTL_UTF8_USTRINGPARAM ( ((sal_Char*)(sNodeName.getStr())) )));
}
xHandler2->endElement(rtl::OUString(RTL_UTF8_USTRINGPARAM ( ((sal_Char*)(sNodeName.getStr())) )));
}
void XMLDocumentWrapper_XmlSecImpl::sendNode(
const cssu::Reference< cssxs::XDocumentHandler >& xHandler,
const cssu::Reference< cssxs::XDocumentHandler >& xHandler2,
const xmlNodePtr pNode) const
throw (cssxs::SAXException)
/****** XMLDocumentWrapper_XmlSecImpl/sendNode ********************************
*
* NAME
* sendNode -- Constructs a characters SAX event or a
* processingInstruction SAX event
*
* SYNOPSIS
* sendNode(xHandler, xHandler2, pNode);
*
* FUNCTION
* Used when converting the document into SAX event stream.
* This method constructs a characters SAX event or a
* processingInstructionfor SAX event based on the type of a particular
* element, then calls the corresponding methods of the XDocumentHandlers.
*
* INPUTS
* xHandler - the first XDocumentHandler interface to receive the
* SAX event. It can be NULL.
* xHandler2 - the second XDocumentHandler interface to receive the
* SAX event. It can't be NULL.
* pNode - the node on which the endElement should be generated.
* If it is a text node, then a characters SAX event is
* generated; if it is a PI node, then a
* processingInstructionfor SAX event is generated.
*
* RESULT
* empty
*
* HISTORY
* 05.01.2004 - implemented
*
* AUTHOR
* Michael Mi
* Email: michael.mi@sun.com
******************************************************************************/
{
xmlElementType type = pNode->type;
if (type == XML_TEXT_NODE)
{
if (xHandler.is())
{
xHandler->characters(rtl::OUString(RTL_UTF8_USTRINGPARAM ( ((sal_Char*)(pNode->content)) )));
}
xHandler2->characters(rtl::OUString(RTL_UTF8_USTRINGPARAM ( ((sal_Char*)(pNode->content)) )));
}
else if (type == XML_PI_NODE)
{
if (xHandler.is())
{
xHandler->processingInstruction(
rtl::OUString(RTL_UTF8_USTRINGPARAM ( ((sal_Char*)(pNode->name)) )),
rtl::OUString(RTL_UTF8_USTRINGPARAM ( ((sal_Char*)(pNode->content)) )));
}
xHandler2->processingInstruction(
rtl::OUString(RTL_UTF8_USTRINGPARAM ( ((sal_Char*)(pNode->name)) )),
rtl::OUString(RTL_UTF8_USTRINGPARAM ( ((sal_Char*)(pNode->content)) )));
}
}
rtl::OString XMLDocumentWrapper_XmlSecImpl::getNodeQName(const xmlNodePtr pNode) const
/****** XMLDocumentWrapper_XmlSecImpl/getNodeQName ****************************
*
* NAME
* getNodeQName -- Retrives the qualified name of a node
*
* SYNOPSIS
* name = getNodeQName(pNode);
*
* FUNCTION
* see NAME
*
* INPUTS
* pNode - the node whose name will be retrived
*
* RESULT
* name - the node's qualified name
*
* HISTORY
* 05.01.2004 - implemented
*
* AUTHOR
* Michael Mi
* Email: michael.mi@sun.com
******************************************************************************/
{
rtl::OString sNodeName((const sal_Char*)pNode->name);
if (pNode->ns != NULL)
{
xmlNsPtr pNs = pNode->ns;
if (pNs->prefix != NULL)
{
rtl::OString sPrefix((const sal_Char*)pNs->prefix);
sNodeName = sPrefix+rtl::OString(":")+sNodeName;
}
}
return sNodeName;
}
xmlNodePtr XMLDocumentWrapper_XmlSecImpl::checkElement( const cssu::Reference< cssxw::XXMLElementWrapper >& xXMLElement) const
/****** XMLDocumentWrapper_XmlSecImpl/checkElement ****************************
*
* NAME
* checkElement -- Retrives the node wrapped by an XXMLElementWrapper
* interface
*
* SYNOPSIS
* node = checkElement(xXMLElement);
*
* FUNCTION
* see NAME
*
* INPUTS
* xXMLElement - the XXMLElementWrapper interface wraping a node
*
* RESULT
* node - the node wrapped in the XXMLElementWrapper interface
*
* HISTORY
* 05.01.2004 - implemented
*
* AUTHOR
* Michael Mi
* Email: michael.mi@sun.com
******************************************************************************/
{
xmlNodePtr rc = NULL;
if (xXMLElement.is())
{
cssu::Reference< cssl::XUnoTunnel > xNodTunnel( xXMLElement, cssu::UNO_QUERY ) ;
if( !xNodTunnel.is() )
{
throw cssu::RuntimeException() ;
}
XMLElementWrapper_XmlSecImpl* pElement
= reinterpret_cast<XMLElementWrapper_XmlSecImpl*>(
sal::static_int_cast<sal_uIntPtr>(
xNodTunnel->getSomething(
XMLElementWrapper_XmlSecImpl::getUnoTunnelImplementationId() ))) ;
if( pElement == NULL ) {
throw cssu::RuntimeException() ;
}
rc = pElement->getNativeElement();
}
return rc;
}
sal_Int32 XMLDocumentWrapper_XmlSecImpl::recursiveDelete(
const xmlNodePtr pNode)
/****** XMLDocumentWrapper_XmlSecImpl/recursiveDelete *************************
*
* NAME
* recursiveDelete -- Deletes a paticular node with its branch.
*
* SYNOPSIS
* result = recursiveDelete(pNode);
*
* FUNCTION
* Deletes a paticular node with its branch, while reserving the nodes
* (and their brance) listed in the m_aReservedNodes.
* The deletion process is preformed in the tree order, that is, a node
* is deleted after its previous sibling node is deleted, a parent node
* is deleted after its branch is deleted.
* During the deletion process when the m_pStopAtNode is reached, the
* progress is interrupted at once.
*
* INPUTS
* pNode - the node to be deleted
*
* RESULT
* result - the result of the deletion process, can be one of following
* values:
* NODE_STOPED - the process is interrupted by meeting the
* m_pStopAtNode
* NODE_NOTREMOVED - the pNode is not completely removed
* because there is its descendant in the
* m_aReservedNodes list
* NODE_REMOVED - the pNode and its branch are completely
* removed
*
* NOTES
* The node in the m_aReservedNodes list must be in the tree order, otherwise
* the result is unpredictable.
*
* HISTORY
* 05.01.2004 - implemented
*
* AUTHOR
* Michael Mi
* Email: michael.mi@sun.com
******************************************************************************/
{
if (pNode == m_pStopAtNode)
{
return NODE_STOPED;
}
if (pNode != m_pCurrentReservedNode)
{
xmlNodePtr pChild = pNode->children;
xmlNodePtr pNextSibling;
bool bIsRemoved = true;
sal_Int32 nResult;
while( pChild != NULL )
{
pNextSibling = pChild->next;
nResult = recursiveDelete(pChild);
switch (nResult)
{
case NODE_STOPED:
return NODE_STOPED;
case NODE_NOTREMOVED:
bIsRemoved = false;
break;
case NODE_REMOVED:
removeNode(pChild);
break;
default:
throw cssu::RuntimeException();
}
pChild = pNextSibling;
}
if (pNode == m_pCurrentElement)
{
bIsRemoved = false;
}
return bIsRemoved?NODE_REMOVED:NODE_NOTREMOVED;
}
else
{
getNextReservedNode();
return NODE_NOTREMOVED;
}
}
void XMLDocumentWrapper_XmlSecImpl::getNextReservedNode()
/****** XMLDocumentWrapper_XmlSecImpl/getNextReservedNode *********************
*
* NAME
* getNextReservedNode -- Highlights the next reserved node in the
* reserved node list
*
* SYNOPSIS
* getNextReservedNode();
*
* FUNCTION
* The m_aReservedNodes array holds a node list, while the
* m_pCurrentReservedNode points to the one currently highlighted.
* This method is used to highlight the next node in the node list.
* This method is called at the time when the current highlighted node
* has been already processed, and the next node should be ready.
*
* INPUTS
* empty
*
* RESULT
* empty
*
* HISTORY
* 05.01.2004 - implemented
*
* AUTHOR
* Michael Mi
* Email: michael.mi@sun.com
******************************************************************************/
{
if (m_nReservedNodeIndex < m_aReservedNodes.getLength())
{
m_pCurrentReservedNode = checkElement( m_aReservedNodes[m_nReservedNodeIndex] );
m_nReservedNodeIndex ++;
}
else
{
m_pCurrentReservedNode = NULL;
}
}
void XMLDocumentWrapper_XmlSecImpl::removeNode(const xmlNodePtr pNode) const
/****** XMLDocumentWrapper_XmlSecImpl/removeNode ******************************
*
* NAME
* removeNode -- Deletes a node with its branch unconditionaly
*
* SYNOPSIS
* removeNode( pNode );
*
* FUNCTION
* Delete the node along with its branch from the document.
*
* INPUTS
* pNode - the node to be deleted
*
* RESULT
* empty
*
* HISTORY
* 05.01.2004 - implemented
*
* AUTHOR
* Michael Mi
* Email: michael.mi@sun.com
******************************************************************************/
{
/* you can't remove the current node */
OSL_ASSERT( m_pCurrentElement != pNode );
xmlAttrPtr pAttr = pNode->properties;
while (pAttr != NULL)
{
if (!stricmp((sal_Char*)pAttr->name,"id"))
{
xmlRemoveID(m_pDocument, pAttr);
}
pAttr = pAttr->next;
}
xmlUnlinkNode(pNode);
xmlFreeNode(pNode);
}
void XMLDocumentWrapper_XmlSecImpl::buildIDAttr(xmlNodePtr pNode) const
/****** XMLDocumentWrapper_XmlSecImpl/buildIDAttr *****************************
*
* NAME
* buildIDAttr -- build the ID attribute of a node
*
* SYNOPSIS
* buildIDAttr( pNode );
*
* FUNCTION
* see NAME
*
* INPUTS
* pNode - the node whose id attribute will be built
*
* RESULT
* empty
*
* HISTORY
* 14.06.2004 - implemented
*
* AUTHOR
* Michael Mi
* Email: michael.mi@sun.com
******************************************************************************/
{
xmlAttrPtr idAttr = xmlHasProp( pNode, (const unsigned char *)"id" );
if (idAttr == NULL)
{
idAttr = xmlHasProp( pNode, (const unsigned char *)"Id" );
}
if (idAttr != NULL)
{
xmlChar* idValue = xmlNodeListGetString( m_pDocument, idAttr->children, 1 ) ;
xmlAddID( NULL, m_pDocument, idValue, idAttr );
}
}
void XMLDocumentWrapper_XmlSecImpl::rebuildIDLink(xmlNodePtr pNode) const
/****** XMLDocumentWrapper_XmlSecImpl/rebuildIDLink ***************************
*
* NAME
* rebuildIDLink -- rebuild the ID link for the branch
*
* SYNOPSIS
* rebuildIDLink( pNode );
*
* FUNCTION
* see NAME
*
* INPUTS
* pNode - the node, from which the branch will be rebuilt
*
* RESULT
* empty
*
* HISTORY
* 14.06.2004 - implemented
*
* AUTHOR
* Michael Mi
* Email: michael.mi@sun.com
******************************************************************************/
{
if (pNode != NULL && pNode->type == XML_ELEMENT_NODE)
{
buildIDAttr( pNode );
xmlNodePtr child = pNode->children;
while (child != NULL)
{
rebuildIDLink(child);
child = child->next;
}
}
}
/* XXMLDocumentWrapper */
cssu::Reference< cssxw::XXMLElementWrapper > SAL_CALL XMLDocumentWrapper_XmlSecImpl::getCurrentElement( )
throw (cssu::RuntimeException)
{
XMLElementWrapper_XmlSecImpl* pElement = new XMLElementWrapper_XmlSecImpl(m_pCurrentElement);
return (cssu::Reference< cssxw::XXMLElementWrapper >)pElement;
}
void SAL_CALL XMLDocumentWrapper_XmlSecImpl::setCurrentElement( const cssu::Reference< cssxw::XXMLElementWrapper >& element )
throw (cssu::RuntimeException)
{
m_pCurrentElement = checkElement( element );
saxHelper.setCurrentNode( m_pCurrentElement );
}
void SAL_CALL XMLDocumentWrapper_XmlSecImpl::removeCurrentElement( )
throw (cssu::RuntimeException)
{
OSL_ASSERT( m_pCurrentElement != NULL );
xmlNodePtr pOldCurrentElement = m_pCurrentElement;
/*
* pop the top node in the parser context's
* nodeTab stack, then the parent of that node will
* automatically become the new stack top, and
* the current node as well.
*/
saxHelper.endElement(
rtl::OUString(
RTL_UTF8_USTRINGPARAM (
(sal_Char*)(pOldCurrentElement->name)
)));
m_pCurrentElement = saxHelper.getCurrentNode();
/*
* remove the node
*/
removeNode(pOldCurrentElement);
}
sal_Bool SAL_CALL XMLDocumentWrapper_XmlSecImpl::isCurrent( const cssu::Reference< cssxw::XXMLElementWrapper >& node )
throw (cssu::RuntimeException)
{
xmlNodePtr pNode = checkElement(node);
return (pNode == m_pCurrentElement);
}
sal_Bool SAL_CALL XMLDocumentWrapper_XmlSecImpl::isCurrentElementEmpty( )
throw (cssu::RuntimeException)
{
sal_Bool rc = sal_False;
if (m_pCurrentElement->children == NULL)
{
rc = sal_True;
}
return rc;
}
rtl::OUString SAL_CALL XMLDocumentWrapper_XmlSecImpl::getNodeName( const cssu::Reference< cssxw::XXMLElementWrapper >& node )
throw (cssu::RuntimeException)
{
xmlNodePtr pNode = checkElement(node);
return rtl::OUString(RTL_UTF8_USTRINGPARAM ( (sal_Char*)pNode->name ));
}
void SAL_CALL XMLDocumentWrapper_XmlSecImpl::clearUselessData(
const cssu::Reference< cssxw::XXMLElementWrapper >& node,
const cssu::Sequence< cssu::Reference< cssxw::XXMLElementWrapper > >& reservedDescendants,
const cssu::Reference< cssxw::XXMLElementWrapper >& stopAtNode )
throw (cssu::RuntimeException)
{
xmlNodePtr pTargetNode = checkElement(node);
m_pStopAtNode = checkElement(stopAtNode);
m_aReservedNodes = reservedDescendants;
m_nReservedNodeIndex = 0;
getNextReservedNode();
recursiveDelete(pTargetNode);
}
void SAL_CALL XMLDocumentWrapper_XmlSecImpl::collapse( const cssu::Reference< cssxw::XXMLElementWrapper >& node )
throw (cssu::RuntimeException)
{
xmlNodePtr pTargetNode = checkElement(node);
xmlNodePtr pParent;
while (pTargetNode != NULL)
{
if (pTargetNode->children != NULL || pTargetNode == m_pCurrentElement)
{
break;
}
pParent = pTargetNode->parent;
removeNode(pTargetNode);
pTargetNode = pParent;
}
}
void SAL_CALL XMLDocumentWrapper_XmlSecImpl::getTree( const cssu::Reference< cssxs::XDocumentHandler >& handler )
throw (cssxs::SAXException, cssu::RuntimeException)
{
if (m_pRootElement != NULL)
{
xmlNodePtr pTempCurrentElement = m_pCurrentElement;
sal_Int32 nTempCurrentPosition = m_nCurrentPosition;
m_pCurrentElement = m_pRootElement;
m_nCurrentPosition = NODEPOSITION_STARTELEMENT;
cssu::Reference< cssxs::XDocumentHandler > xHandler = handler;
while(true)
{
switch (m_nCurrentPosition)
{
case NODEPOSITION_STARTELEMENT:
sendStartElement(NULL, xHandler, m_pCurrentElement);
break;
case NODEPOSITION_ENDELEMENT:
sendEndElement(NULL, xHandler, m_pCurrentElement);
break;
case NODEPOSITION_NORMAL:
sendNode(NULL, xHandler, m_pCurrentElement);
break;
}
if ( (m_pCurrentElement == m_pRootElement) && (m_nCurrentPosition == NODEPOSITION_ENDELEMENT ))
{
break;
}
getNextSAXEvent();
}
m_pCurrentElement = pTempCurrentElement;
m_nCurrentPosition = nTempCurrentPosition;
}
}
void SAL_CALL XMLDocumentWrapper_XmlSecImpl::generateSAXEvents(
const cssu::Reference< cssxs::XDocumentHandler >& handler,
const cssu::Reference< cssxs::XDocumentHandler >& xEventKeeperHandler,
const cssu::Reference< cssxw::XXMLElementWrapper >& startNode,
const cssu::Reference< cssxw::XXMLElementWrapper >& endNode )
throw (cssxs::SAXException, cssu::RuntimeException)
{
/*
* The first SAX event is the startElement of the startNode
* element.
*/
bool bHasCurrentElementChild = (m_pCurrentElement->children != NULL);
xmlNodePtr pTempCurrentElement = m_pCurrentElement;
m_pCurrentElement = checkElement(startNode);
if (m_pCurrentElement->type == XML_ELEMENT_NODE)
{
m_nCurrentPosition = NODEPOSITION_STARTELEMENT;
}
else
{
m_nCurrentPosition = NODEPOSITION_NORMAL;
}
xmlNodePtr pEndNode = checkElement(endNode);
cssu::Reference < cssxc::sax::XSAXEventKeeper > xSAXEventKeeper( xEventKeeperHandler, cssu::UNO_QUERY );
cssu::Reference< cssxs::XDocumentHandler > xHandler = handler;
while(true)
{
switch (m_nCurrentPosition)
{
case NODEPOSITION_STARTELEMENT:
sendStartElement(xHandler, xEventKeeperHandler, m_pCurrentElement);
break;
case NODEPOSITION_ENDELEMENT:
sendEndElement(xHandler, xEventKeeperHandler, m_pCurrentElement);
break;
case NODEPOSITION_NORMAL:
sendNode(xHandler, xEventKeeperHandler, m_pCurrentElement);
break;
default:
throw cssu::RuntimeException();
}
if (xSAXEventKeeper->isBlocking())
{
xHandler = NULL;
}
if (pEndNode == NULL &&
((bHasCurrentElementChild && m_pCurrentElement == xmlGetLastChild(pTempCurrentElement) && m_nCurrentPosition != NODEPOSITION_STARTELEMENT) ||
(!bHasCurrentElementChild && m_pCurrentElement == pTempCurrentElement && m_nCurrentPosition == NODEPOSITION_STARTELEMENT)))
{
break;
}
getNextSAXEvent();
/*
* If there is an end point specified, then check whether
* the current node equals to the end point. If so, stop
* generating.
*/
if (pEndNode != NULL && m_pCurrentElement == pEndNode)
{
break;
}
}
m_pCurrentElement = pTempCurrentElement;
}
void SAL_CALL XMLDocumentWrapper_XmlSecImpl::rebuildIDLink(
const com::sun::star::uno::Reference< com::sun::star::xml::wrapper::XXMLElementWrapper >& node )
throw (com::sun::star::uno::RuntimeException)
{
xmlNodePtr pNode = checkElement( node );
rebuildIDLink(pNode);
}
/* cssxs::XDocumentHandler */
void SAL_CALL XMLDocumentWrapper_XmlSecImpl::startDocument( )
throw (cssxs::SAXException, cssu::RuntimeException)
{
}
void SAL_CALL XMLDocumentWrapper_XmlSecImpl::endDocument( )
throw (cssxs::SAXException, cssu::RuntimeException)
{
}
void SAL_CALL XMLDocumentWrapper_XmlSecImpl::startElement( const rtl::OUString& aName, const cssu::Reference< cssxs::XAttributeList >& xAttribs )
throw (cssxs::SAXException, cssu::RuntimeException)
{
sal_Int32 nLength = xAttribs->getLength();
cssu::Sequence< cssxcsax::XMLAttribute > aAttributes (nLength);
for (int i = 0; i < nLength; ++i)
{
aAttributes[i].sName = xAttribs->getNameByIndex((short)i);
aAttributes[i].sValue =xAttribs->getValueByIndex((short)i);
}
_startElement(aName, aAttributes);
}
void SAL_CALL XMLDocumentWrapper_XmlSecImpl::endElement( const rtl::OUString& aName )
throw (cssxs::SAXException, cssu::RuntimeException)
{
saxHelper.endElement(aName);
m_pCurrentElement = saxHelper.getCurrentNode();
}
void SAL_CALL XMLDocumentWrapper_XmlSecImpl::characters( const rtl::OUString& aChars )
throw (cssxs::SAXException, cssu::RuntimeException)
{
saxHelper.characters(aChars);
}
void SAL_CALL XMLDocumentWrapper_XmlSecImpl::ignorableWhitespace( const rtl::OUString& aWhitespaces )
throw (cssxs::SAXException, cssu::RuntimeException)
{
saxHelper.ignorableWhitespace(aWhitespaces);
}
void SAL_CALL XMLDocumentWrapper_XmlSecImpl::processingInstruction( const rtl::OUString& aTarget, const rtl::OUString& aData )
throw (cssxs::SAXException, cssu::RuntimeException)
{
saxHelper.processingInstruction(aTarget, aData);
}
void SAL_CALL XMLDocumentWrapper_XmlSecImpl::setDocumentLocator( const cssu::Reference< cssxs::XLocator >& xLocator )
throw (cssxs::SAXException, cssu::RuntimeException)
{
saxHelper.setDocumentLocator(xLocator);
}
/* XCompressedDocumentHandler */
void SAL_CALL XMLDocumentWrapper_XmlSecImpl::_startDocument( )
throw (cssxs::SAXException, cssu::RuntimeException)
{
}
void SAL_CALL XMLDocumentWrapper_XmlSecImpl::_endDocument( )
throw (cssxs::SAXException, cssu::RuntimeException)
{
}
void SAL_CALL XMLDocumentWrapper_XmlSecImpl::_startElement( const rtl::OUString& aName, const cssu::Sequence< cssxcsax::XMLAttribute >& aAttributes )
throw (cssxs::SAXException, cssu::RuntimeException)
{
saxHelper.startElement(aName, aAttributes);
m_pCurrentElement = saxHelper.getCurrentNode();
buildIDAttr( m_pCurrentElement );
}
void SAL_CALL XMLDocumentWrapper_XmlSecImpl::_endElement( const rtl::OUString& aName )
throw (cssxs::SAXException, cssu::RuntimeException)
{
endElement( aName );
}
void SAL_CALL XMLDocumentWrapper_XmlSecImpl::_characters( const rtl::OUString& aChars )
throw (cssxs::SAXException, cssu::RuntimeException)
{
characters( aChars );
}
void SAL_CALL XMLDocumentWrapper_XmlSecImpl::_ignorableWhitespace( const rtl::OUString& aWhitespaces )
throw (cssxs::SAXException, cssu::RuntimeException)
{
ignorableWhitespace( aWhitespaces );
}
void SAL_CALL XMLDocumentWrapper_XmlSecImpl::_processingInstruction( const rtl::OUString& aTarget, const rtl::OUString& aData )
throw (cssxs::SAXException, cssu::RuntimeException)
{
processingInstruction( aTarget, aData );
}
void SAL_CALL XMLDocumentWrapper_XmlSecImpl::_setDocumentLocator( sal_Int32 /*columnNumber*/, sal_Int32 /*lineNumber*/, const rtl::OUString& /*publicId*/, const rtl::OUString& /*systemId*/ )
throw (cssxs::SAXException, cssu::RuntimeException)
{
}
rtl::OUString XMLDocumentWrapper_XmlSecImpl_getImplementationName ()
throw (cssu::RuntimeException)
{
return rtl::OUString ( RTL_ASCII_USTRINGPARAM ( IMPLEMENTATION_NAME ) );
}
sal_Bool SAL_CALL XMLDocumentWrapper_XmlSecImpl_supportsService( const rtl::OUString& ServiceName )
throw (cssu::RuntimeException)
{
return ServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM ( SERVICE_NAME ));
}
cssu::Sequence< rtl::OUString > SAL_CALL XMLDocumentWrapper_XmlSecImpl_getSupportedServiceNames( )
throw (cssu::RuntimeException)
{
cssu::Sequence < rtl::OUString > aRet(1);
rtl::OUString* pArray = aRet.getArray();
pArray[0] = rtl::OUString ( RTL_ASCII_USTRINGPARAM ( SERVICE_NAME ) );
return aRet;
}
#undef SERVICE_NAME
cssu::Reference< cssu::XInterface > SAL_CALL XMLDocumentWrapper_XmlSecImpl_createInstance(
const cssu::Reference< cssl::XMultiServiceFactory > &)
throw( cssu::Exception )
{
return (cppu::OWeakObject*) new XMLDocumentWrapper_XmlSecImpl( );
}
/* XServiceInfo */
rtl::OUString SAL_CALL XMLDocumentWrapper_XmlSecImpl::getImplementationName( )
throw (cssu::RuntimeException)
{
return XMLDocumentWrapper_XmlSecImpl_getImplementationName();
}
sal_Bool SAL_CALL XMLDocumentWrapper_XmlSecImpl::supportsService( const rtl::OUString& rServiceName )
throw (cssu::RuntimeException)
{
return XMLDocumentWrapper_XmlSecImpl_supportsService( rServiceName );
}
cssu::Sequence< rtl::OUString > SAL_CALL XMLDocumentWrapper_XmlSecImpl::getSupportedServiceNames( )
throw (cssu::RuntimeException)
{
return XMLDocumentWrapper_XmlSecImpl_getSupportedServiceNames();
}