LCOV - code coverage report
Current view: top level - xmlsecurity/source/xmlsec - xmldocumentwrapper_xmlsecimpl.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 2 317 0.6 %
Date: 2014-11-03 Functions: 1 47 2.1 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <sal/config.h>
      21             : 
      22             : #include <com/sun/star/uno/XComponentContext.hpp>
      23             : #include <cppuhelper/supportsservice.hxx>
      24             : #include "xmldocumentwrapper_xmlsecimpl.hxx"
      25             : 
      26             : #include <xmloff/attrlist.hxx>
      27             : #include "xmlelementwrapper_xmlsecimpl.hxx"
      28             : 
      29             : #include <stdio.h>
      30             : #include <stdlib.h>
      31             : #include <string.h>
      32             : 
      33             : #include <sys/types.h>
      34             : #include <sys/stat.h>
      35             : 
      36             : #include <vector>
      37             : 
      38             : #ifdef UNX
      39             : #define stricmp strcasecmp
      40             : #endif
      41             : 
      42             : namespace cssu = com::sun::star::uno;
      43             : namespace cssl = com::sun::star::lang;
      44             : namespace cssxc = com::sun::star::xml::crypto;
      45             : namespace cssxcsax = com::sun::star::xml::csax;
      46             : namespace cssxs = com::sun::star::xml::sax;
      47             : namespace cssxw = com::sun::star::xml::wrapper;
      48             : 
      49             : #define IMPLEMENTATION_NAME "com.sun.star.xml.security.bridge.xmlsec.XMLDocumentWrapper_XmlSecImpl"
      50             : 
      51             : #define STRXMLNS "xmlns"
      52             : 
      53             : #define C2U( asciiStr ) asciiStr, strlen( asciiStr ), RTL_TEXTENCODING_UTF8
      54             : 
      55             : /* used by the recursiveDelete method */
      56             : #define NODE_REMOVED    0
      57             : #define NODE_NOTREMOVED 1
      58             : #define NODE_STOPED     2
      59             : 
      60           0 : XMLDocumentWrapper_XmlSecImpl::XMLDocumentWrapper_XmlSecImpl()
      61             :     : m_nCurrentPosition(0)
      62             :     , m_pStopAtNode(0)
      63             :     , m_pCurrentReservedNode(0)
      64           0 :     , m_nReservedNodeIndex(0)
      65             : {
      66           0 :     saxHelper.startDocument();
      67           0 :     m_pDocument = saxHelper.getDocument();
      68             : 
      69             :     /*
      70             :      * creates the virtual root element
      71             :      */
      72           0 :     saxHelper.startElement(OUString(C2U( "root" )), cssu::Sequence<cssxcsax::XMLAttribute>());
      73             : 
      74           0 :     m_pRootElement = saxHelper.getCurrentNode();
      75           0 :     m_pCurrentElement = m_pRootElement;
      76           0 : }
      77             : 
      78           0 : XMLDocumentWrapper_XmlSecImpl::~XMLDocumentWrapper_XmlSecImpl()
      79             : {
      80           0 :     saxHelper.endDocument();
      81           0 :     xmlFreeDoc(m_pDocument);
      82           0 : }
      83             : 
      84           0 : void XMLDocumentWrapper_XmlSecImpl::getNextSAXEvent()
      85             : /****** XMLDocumentWrapper_XmlSecImpl/getNextSAXEvent *************************
      86             :  *
      87             :  *   NAME
      88             :  *  getNextSAXEvent -- Prepares the next SAX event to be manipulate
      89             :  *
      90             :  *   SYNOPSIS
      91             :  *  getNextSAXEvent();
      92             :  *
      93             :  *   FUNCTION
      94             :  *  When converting the document into SAX events, this method is used to
      95             :  *  decide the next SAX event to be generated.
      96             :  *  Two member variables are checked to make the decision, the
      97             :  *  m_pCurrentElement and the m_nCurrentPosition.
      98             :  *  The m_pCurrentElement represents the node which have been covered, and
      99             :  *  the m_nCurrentPosition represents the event which have been sent.
     100             :  *  For example, suppose that the m_pCurrentElement
     101             :  *  points to element A, and the m_nCurrentPosition equals to
     102             :  *  NODEPOSITION_STARTELEMENT, then the next SAX event should be the
     103             :  *  endElement for element A if A has no child, or startElement for the
     104             :  *  first child element of element A otherwise.
     105             :  *  The m_nCurrentPosition can be one of following values:
     106             :  *  NODEPOSITION_STARTELEMENT for startElement;
     107             :  *  NODEPOSITION_ENDELEMENT for endElement;
     108             :  *  NODEPOSITION_NORMAL for other SAX events;
     109             :  *
     110             :  *   INPUTS
     111             :  *  empty
     112             :  *
     113             :  *   RESULT
     114             :  *  empty
     115             :  *
     116             :  *   AUTHOR
     117             :  *  Michael Mi
     118             :  *  Email: michael.mi@sun.com
     119             :  ******************************************************************************/
     120             : {
     121             :     OSL_ASSERT( m_pCurrentElement != NULL );
     122             : 
     123             :         /*
     124             :          * Get the next event through tree order.
     125             :          *
     126             :          * if the current event is a startElement, then the next
     127             :          * event depends on whether or not the current node has
     128             :          * children.
     129             :          */
     130           0 :     if (m_nCurrentPosition == NODEPOSITION_STARTELEMENT)
     131             :     {
     132             :             /*
     133             :              * If the current node has children, then its first child
     134             :              * should be next current node, and the next event will be
     135             :              * startElement or charaters(PI) based on that child's node
     136             :              * type. Otherwise, the endElement of current node is the
     137             :              * next event.
     138             :              */
     139           0 :         if (m_pCurrentElement->children != NULL)
     140             :         {
     141           0 :             m_pCurrentElement = m_pCurrentElement->children;
     142             :             m_nCurrentPosition
     143           0 :                 = (m_pCurrentElement->type == XML_ELEMENT_NODE)?
     144           0 :                     NODEPOSITION_STARTELEMENT:NODEPOSITION_NORMAL;
     145             :         }
     146             :         else
     147             :         {
     148           0 :             m_nCurrentPosition = NODEPOSITION_ENDELEMENT;
     149             :         }
     150             :     }
     151             :         /*
     152             :          * if the current event is a not startElement, then the next
     153             :          * event depends on whether or not the current node has
     154             :          * following sibling.
     155             :          */
     156           0 :     else if (m_nCurrentPosition == NODEPOSITION_ENDELEMENT || m_nCurrentPosition == NODEPOSITION_NORMAL)
     157             :     {
     158           0 :         xmlNodePtr pNextSibling = m_pCurrentElement->next;
     159             : 
     160             :             /*
     161             :              * If the current node has following sibling, that sibling
     162             :              * should be next current node, and the next event will be
     163             :              * startElement or charaters(PI) based on that sibling's node
     164             :              * type. Otherwise, the endElement of current node's parent
     165             :              * becomes the next event.
     166             :              */
     167           0 :         if (pNextSibling != NULL)
     168             :         {
     169           0 :             m_pCurrentElement = pNextSibling;
     170             :             m_nCurrentPosition
     171           0 :                 = (m_pCurrentElement->type == XML_ELEMENT_NODE)?
     172           0 :                     NODEPOSITION_STARTELEMENT:NODEPOSITION_NORMAL;
     173             :         }
     174             :         else
     175             :         {
     176           0 :             m_pCurrentElement = m_pCurrentElement->parent;
     177           0 :             m_nCurrentPosition = NODEPOSITION_ENDELEMENT;
     178             :         }
     179             :     }
     180           0 : }
     181             : 
     182           0 : void XMLDocumentWrapper_XmlSecImpl::sendStartElement(
     183             :     const cssu::Reference< cssxs::XDocumentHandler >& xHandler,
     184             :     const cssu::Reference< cssxs::XDocumentHandler >& xHandler2,
     185             :     const xmlNodePtr pNode) const
     186             :     throw (cssxs::SAXException)
     187             : /****** XMLDocumentWrapper_XmlSecImpl/sendStartElement ************************
     188             :  *
     189             :  *   NAME
     190             :  *  sendStartElement -- Constructs a startElement SAX event
     191             :  *
     192             :  *   SYNOPSIS
     193             :  *  sendStartElement(xHandler, xHandler2, pNode);
     194             :  *
     195             :  *   FUNCTION
     196             :  *  Used when converting the document into SAX event stream.
     197             :  *  This method constructs a startElement SAX event for a particular
     198             :  *  element, then calls the startElement methods of the XDocumentHandlers.
     199             :  *
     200             :  *   INPUTS
     201             :  *  xHandler -  the first XDocumentHandler interface to receive the
     202             :  *          startElement SAX event. It can be NULL.
     203             :  *  xHandler2 - the second XDocumentHandler interface to receive the
     204             :  *          startElement SAX event. It can't be NULL.
     205             :  *  pNode -     the node on which the startElement should be generated.
     206             :  *          This node must be a element type.
     207             :  *
     208             :  *   RESULT
     209             :  *  empty
     210             :  *
     211             :  *   AUTHOR
     212             :  *  Michael Mi
     213             :  *  Email: michael.mi@sun.com
     214             :  ******************************************************************************/
     215             : {
     216           0 :     SvXMLAttributeList* pAttributeList = new SvXMLAttributeList();
     217           0 :     cssu::Reference < cssxs::XAttributeList > xAttrList = cssu::Reference< cssxs::XAttributeList > (pAttributeList);
     218             : 
     219           0 :     xmlNsPtr pNsDef = pNode->nsDef;
     220             : 
     221           0 :     while (pNsDef != NULL)
     222             :     {
     223           0 :         const xmlChar* pNsPrefix = pNsDef->prefix;
     224           0 :         const xmlChar* pNsHref = pNsDef->href;
     225             : 
     226           0 :         if (pNsDef->prefix == NULL)
     227             :         {
     228             :             pAttributeList->AddAttribute(
     229             :                 OUString(C2U( STRXMLNS )),
     230           0 :                 OUString(C2U( (sal_Char*)pNsHref )));
     231             :         }
     232             :         else
     233             :         {
     234             :             pAttributeList->AddAttribute(
     235             :                 OUString(C2U( STRXMLNS ))
     236           0 :                 +OUString(C2U( ":" ))
     237           0 :                 +OUString(C2U( (sal_Char*)pNsPrefix )),
     238           0 :                 OUString(C2U( (sal_Char*)pNsHref )));
     239             :         }
     240             : 
     241           0 :         pNsDef = pNsDef->next;
     242             :     }
     243             : 
     244           0 :     xmlAttrPtr pAttr = pNode->properties;
     245             : 
     246           0 :     while (pAttr != NULL)
     247             :     {
     248           0 :         const xmlChar* pAttrName = pAttr->name;
     249           0 :         xmlNsPtr pAttrNs = pAttr->ns;
     250             : 
     251           0 :         OUString ouAttrName;
     252           0 :         if (pAttrNs == NULL)
     253             :         {
     254           0 :             ouAttrName = OUString(C2U( (sal_Char*)pAttrName ));
     255             :         }
     256             :         else
     257             :         {
     258           0 :             ouAttrName = OUString(C2U( (sal_Char*)pAttrNs->prefix))
     259           0 :                 +OUString(":")
     260           0 :                 +OUString(C2U( (sal_Char*)pAttrName ));
     261             :         }
     262             : 
     263             :         pAttributeList->AddAttribute(
     264             :             ouAttrName,
     265           0 :             OUString(C2U( (sal_Char*)(pAttr->children->content))));
     266           0 :         pAttr = pAttr->next;
     267           0 :     }
     268             : 
     269           0 :     OString sNodeName = getNodeQName(pNode);
     270             : 
     271           0 :     if (xHandler.is())
     272             :     {
     273           0 :         xHandler->startElement(
     274           0 :             OUString(C2U ( ((sal_Char*)(sNodeName.getStr())) )),
     275           0 :             xAttrList);
     276             :     }
     277             : 
     278           0 :     xHandler2->startElement(
     279           0 :         OUString(C2U ( ((sal_Char*)(sNodeName.getStr())) )),
     280           0 :         xAttrList);
     281           0 : }
     282             : 
     283           0 : void XMLDocumentWrapper_XmlSecImpl::sendEndElement(
     284             :     const cssu::Reference< cssxs::XDocumentHandler >& xHandler,
     285             :     const cssu::Reference< cssxs::XDocumentHandler >& xHandler2,
     286             :     const xmlNodePtr pNode) const
     287             :     throw (cssxs::SAXException)
     288             : /****** XMLDocumentWrapper_XmlSecImpl/sendEndElement **************************
     289             :  *
     290             :  *   NAME
     291             :  *  sendEndElement -- Constructs a endElement SAX event
     292             :  *
     293             :  *   SYNOPSIS
     294             :  *  sendEndElement(xHandler, xHandler2, pNode);
     295             :  *
     296             :  *   FUNCTION
     297             :  *  Used when converting the document into SAX event stream.
     298             :  *  This method constructs a endElement SAX event for a particular
     299             :  *  element, then calls the endElement methods of the XDocumentHandlers.
     300             :  *
     301             :  *   INPUTS
     302             :  *  xHandler -  the first XDocumentHandler interface to receive the
     303             :  *          endElement SAX event. It can be NULL.
     304             :  *  xHandler2 - the second XDocumentHandler interface to receive the
     305             :  *          endElement SAX event. It can't be NULL.
     306             :  *  pNode -     the node on which the endElement should be generated.
     307             :  *          This node must be a element type.
     308             :  *
     309             :  *   RESULT
     310             :  *  empty
     311             :  *
     312             :  *   AUTHOR
     313             :  *  Michael Mi
     314             :  *  Email: michael.mi@sun.com
     315             :  ******************************************************************************/
     316             : {
     317           0 :     OString sNodeName = getNodeQName(pNode);
     318             : 
     319           0 :     if (xHandler.is())
     320             :     {
     321           0 :         xHandler->endElement(OUString(C2U ( ((sal_Char*)(sNodeName.getStr())) )));
     322             :     }
     323             : 
     324           0 :     xHandler2->endElement(OUString(C2U ( ((sal_Char*)(sNodeName.getStr())) )));
     325           0 : }
     326             : 
     327           0 : void XMLDocumentWrapper_XmlSecImpl::sendNode(
     328             :     const cssu::Reference< cssxs::XDocumentHandler >& xHandler,
     329             :     const cssu::Reference< cssxs::XDocumentHandler >& xHandler2,
     330             :     const xmlNodePtr pNode) const
     331             :     throw (cssxs::SAXException)
     332             : /****** XMLDocumentWrapper_XmlSecImpl/sendNode ********************************
     333             :  *
     334             :  *   NAME
     335             :  *  sendNode -- Constructs a characters SAX event or a
     336             :  *  processingInstruction SAX event
     337             :  *
     338             :  *   SYNOPSIS
     339             :  *  sendNode(xHandler, xHandler2, pNode);
     340             :  *
     341             :  *   FUNCTION
     342             :  *  Used when converting the document into SAX event stream.
     343             :  *  This method constructs a characters SAX event or a
     344             :  *  processingInstructionfor SAX event based on the type of a particular
     345             :  *  element, then calls the corresponding methods of the XDocumentHandlers.
     346             :  *
     347             :  *   INPUTS
     348             :  *  xHandler -  the first XDocumentHandler interface to receive the
     349             :  *          SAX event. It can be NULL.
     350             :  *  xHandler2 - the second XDocumentHandler interface to receive the
     351             :  *          SAX event. It can't be NULL.
     352             :  *  pNode -     the node on which the endElement should be generated.
     353             :  *          If it is a text node, then a characters SAX event is
     354             :  *          generated; if it is a PI node, then a
     355             :  *          processingInstructionfor SAX event is generated.
     356             :  *
     357             :  *   RESULT
     358             :  *  empty
     359             :  *
     360             :  *   AUTHOR
     361             :  *  Michael Mi
     362             :  *  Email: michael.mi@sun.com
     363             :  ******************************************************************************/
     364             : {
     365           0 :     xmlElementType type = pNode->type;
     366             : 
     367           0 :     if (type == XML_TEXT_NODE)
     368             :     {
     369           0 :         if (xHandler.is())
     370             :         {
     371           0 :             xHandler->characters(OUString(C2U ( ((sal_Char*)(pNode->content)) )));
     372             :         }
     373             : 
     374           0 :         xHandler2->characters(OUString(C2U ( ((sal_Char*)(pNode->content)) )));
     375             :     }
     376           0 :     else if (type == XML_PI_NODE)
     377             :     {
     378           0 :         if (xHandler.is())
     379             :         {
     380           0 :             xHandler->processingInstruction(
     381           0 :                 OUString(C2U ( ((sal_Char*)(pNode->name)) )),
     382           0 :                 OUString(C2U ( ((sal_Char*)(pNode->content)) )));
     383             :         }
     384             : 
     385           0 :         xHandler2->processingInstruction(
     386           0 :             OUString(C2U ( ((sal_Char*)(pNode->name)) )),
     387           0 :             OUString(C2U ( ((sal_Char*)(pNode->content)) )));
     388             :     }
     389           0 : }
     390             : 
     391           0 : OString XMLDocumentWrapper_XmlSecImpl::getNodeQName(const xmlNodePtr pNode) const
     392             : /****** XMLDocumentWrapper_XmlSecImpl/getNodeQName ****************************
     393             :  *
     394             :  *   NAME
     395             :  *  getNodeQName -- Retrieves the qualified name of a node
     396             :  *
     397             :  *   SYNOPSIS
     398             :  *  name = getNodeQName(pNode);
     399             :  *
     400             :  *   FUNCTION
     401             :  *  see NAME
     402             :  *
     403             :  *   INPUTS
     404             :  *  pNode - the node whose name will be retrieved
     405             :  *
     406             :  *   RESULT
     407             :  *  name - the node's qualified name
     408             :  *
     409             :  *   AUTHOR
     410             :  *  Michael Mi
     411             :  *  Email: michael.mi@sun.com
     412             :  ******************************************************************************/
     413             : {
     414           0 :     OString sNodeName((const sal_Char*)pNode->name);
     415           0 :     if (pNode->ns != NULL)
     416             :     {
     417           0 :         xmlNsPtr pNs = pNode->ns;
     418             : 
     419           0 :         if (pNs->prefix != NULL)
     420             :         {
     421           0 :             OString sPrefix((const sal_Char*)pNs->prefix);
     422           0 :             sNodeName = sPrefix+OString(":")+sNodeName;
     423             :         }
     424             :     }
     425             : 
     426           0 :     return sNodeName;
     427             : }
     428             : 
     429           0 : xmlNodePtr XMLDocumentWrapper_XmlSecImpl::checkElement( const cssu::Reference< cssxw::XXMLElementWrapper >& xXMLElement) const
     430             : /****** XMLDocumentWrapper_XmlSecImpl/checkElement ****************************
     431             :  *
     432             :  *   NAME
     433             :  *  checkElement -- Retrieves the node wrapped by an XXMLElementWrapper
     434             :  *  interface
     435             :  *
     436             :  *   SYNOPSIS
     437             :  *  node = checkElement(xXMLElement);
     438             :  *
     439             :  *   FUNCTION
     440             :  *  see NAME
     441             :  *
     442             :  *   INPUTS
     443             :  *  xXMLElement -   the XXMLElementWrapper interface wraping a node
     444             :  *
     445             :  *   RESULT
     446             :  *  node - the node wrapped in the XXMLElementWrapper interface
     447             :  *
     448             :  *   AUTHOR
     449             :  *  Michael Mi
     450             :  *  Email: michael.mi@sun.com
     451             :  ******************************************************************************/
     452             : {
     453           0 :     xmlNodePtr rc = NULL;
     454             : 
     455           0 :     if (xXMLElement.is())
     456             :     {
     457           0 :         cssu::Reference< cssl::XUnoTunnel > xNodTunnel( xXMLElement, cssu::UNO_QUERY ) ;
     458           0 :         if( !xNodTunnel.is() )
     459             :         {
     460           0 :             throw cssu::RuntimeException() ;
     461             :         }
     462             : 
     463             :         XMLElementWrapper_XmlSecImpl* pElement
     464             :             = reinterpret_cast<XMLElementWrapper_XmlSecImpl*>(
     465             :                 sal::static_int_cast<sal_uIntPtr>(
     466           0 :                     xNodTunnel->getSomething(
     467           0 :                         XMLElementWrapper_XmlSecImpl::getUnoTunnelImplementationId() ))) ;
     468             : 
     469           0 :         if( pElement == NULL ) {
     470           0 :             throw cssu::RuntimeException() ;
     471             :         }
     472             : 
     473           0 :         rc = pElement->getNativeElement();
     474             :     }
     475             : 
     476           0 :     return rc;
     477             : }
     478             : 
     479           0 : sal_Int32 XMLDocumentWrapper_XmlSecImpl::recursiveDelete(
     480             :     const xmlNodePtr pNode)
     481             : /****** XMLDocumentWrapper_XmlSecImpl/recursiveDelete *************************
     482             :  *
     483             :  *   NAME
     484             :  *  recursiveDelete -- Deletes a paticular node with its branch.
     485             :  *
     486             :  *   SYNOPSIS
     487             :  *  result = recursiveDelete(pNode);
     488             :  *
     489             :  *   FUNCTION
     490             :  *  Deletes a paticular node with its branch, while reserving the nodes
     491             :  *  (and their brance) listed in the m_aReservedNodes.
     492             :  *  The deletion process is preformed in the tree order, that is, a node
     493             :  *  is deleted after its previous sibling node is deleted, a parent node
     494             :  *  is deleted after its branch is deleted.
     495             :  *  During the deletion process when the m_pStopAtNode is reached, the
     496             :  *  progress is interrupted at once.
     497             :  *
     498             :  *   INPUTS
     499             :  *  pNode - the node to be deleted
     500             :  *
     501             :  *   RESULT
     502             :  *  result -    the result of the deletion process, can be one of following
     503             :  *          values:
     504             :  *          NODE_STOPED - the process is interrupted by meeting the
     505             :  *              m_pStopAtNode
     506             :  *          NODE_NOTREMOVED - the pNode is not completely removed
     507             :  *              because there is its descendant in the
     508             :  *              m_aReservedNodes list
     509             :  *          NODE_REMOVED - the pNode and its branch are completely
     510             :  *              removed
     511             :  *
     512             :  *   NOTES
     513             :  *  The node in the m_aReservedNodes list must be in the tree order, otherwise
     514             :  *  the result is unpredictable.
     515             :  *
     516             :  *   AUTHOR
     517             :  *  Michael Mi
     518             :  *  Email: michael.mi@sun.com
     519             :  ******************************************************************************/
     520             : {
     521           0 :     if (pNode == m_pStopAtNode)
     522             :     {
     523           0 :         return NODE_STOPED;
     524             :     }
     525             : 
     526           0 :     if (pNode != m_pCurrentReservedNode)
     527             :     {
     528           0 :         xmlNodePtr pChild = pNode->children;
     529             : 
     530             :         xmlNodePtr pNextSibling;
     531           0 :         bool bIsRemoved = true;
     532             :         sal_Int32 nResult;
     533             : 
     534           0 :         while( pChild != NULL )
     535             :         {
     536           0 :             pNextSibling = pChild->next;
     537           0 :             nResult = recursiveDelete(pChild);
     538             : 
     539           0 :             switch (nResult)
     540             :             {
     541             :             case NODE_STOPED:
     542           0 :                 return NODE_STOPED;
     543             :             case NODE_NOTREMOVED:
     544           0 :                 bIsRemoved = false;
     545           0 :                 break;
     546             :             case NODE_REMOVED:
     547           0 :                 removeNode(pChild);
     548           0 :                 break;
     549             :             default:
     550           0 :                 throw cssu::RuntimeException();
     551             :             }
     552             : 
     553           0 :             pChild = pNextSibling;
     554             :         }
     555             : 
     556           0 :         if (pNode == m_pCurrentElement)
     557             :         {
     558           0 :             bIsRemoved = false;
     559             :         }
     560             : 
     561           0 :         return bIsRemoved?NODE_REMOVED:NODE_NOTREMOVED;
     562             :     }
     563             :     else
     564             :     {
     565           0 :         getNextReservedNode();
     566           0 :         return NODE_NOTREMOVED;
     567             :     }
     568             : }
     569             : 
     570           0 : void XMLDocumentWrapper_XmlSecImpl::getNextReservedNode()
     571             : /****** XMLDocumentWrapper_XmlSecImpl/getNextReservedNode *********************
     572             :  *
     573             :  *   NAME
     574             :  *  getNextReservedNode -- Highlights the next reserved node in the
     575             :  *  reserved node list
     576             :  *
     577             :  *   SYNOPSIS
     578             :  *  getNextReservedNode();
     579             :  *
     580             :  *   FUNCTION
     581             :  *  The m_aReservedNodes array holds a node list, while the
     582             :  *  m_pCurrentReservedNode points to the one currently highlighted.
     583             :  *  This method is used to highlight the next node in the node list.
     584             :  *  This method is called at the time when the current highlighted node
     585             :  *  has been already processed, and the next node should be ready.
     586             :  *
     587             :  *   INPUTS
     588             :  *  empty
     589             :  *
     590             :  *   RESULT
     591             :  *  empty
     592             :  *
     593             :  *   AUTHOR
     594             :  *  Michael Mi
     595             :  *  Email: michael.mi@sun.com
     596             :  ******************************************************************************/
     597             : {
     598           0 :     if (m_nReservedNodeIndex < m_aReservedNodes.getLength())
     599             :     {
     600           0 :         m_pCurrentReservedNode = checkElement( m_aReservedNodes[m_nReservedNodeIndex] );
     601           0 :         m_nReservedNodeIndex ++;
     602             :     }
     603             :     else
     604             :     {
     605           0 :         m_pCurrentReservedNode = NULL;
     606             :     }
     607           0 : }
     608             : 
     609           0 : void XMLDocumentWrapper_XmlSecImpl::removeNode(const xmlNodePtr pNode) const
     610             : /****** XMLDocumentWrapper_XmlSecImpl/removeNode ******************************
     611             :  *
     612             :  *   NAME
     613             :  *  removeNode -- Deletes a node with its branch unconditionaly
     614             :  *
     615             :  *   SYNOPSIS
     616             :  *  removeNode( pNode );
     617             :  *
     618             :  *   FUNCTION
     619             :  *  Delete the node along with its branch from the document.
     620             :  *
     621             :  *   INPUTS
     622             :  *  pNode - the node to be deleted
     623             :  *
     624             :  *   RESULT
     625             :  *  empty
     626             :  *
     627             :  *   AUTHOR
     628             :  *  Michael Mi
     629             :  *  Email: michael.mi@sun.com
     630             :  ******************************************************************************/
     631             : {
     632             :     /* you can't remove the current node */
     633             :     OSL_ASSERT( m_pCurrentElement != pNode );
     634             : 
     635           0 :     xmlAttrPtr pAttr = pNode->properties;
     636             : 
     637           0 :     while (pAttr != NULL)
     638             :     {
     639           0 :         if (!stricmp((sal_Char*)pAttr->name,"id"))
     640             :         {
     641           0 :             xmlRemoveID(m_pDocument, pAttr);
     642             :         }
     643             : 
     644           0 :         pAttr = pAttr->next;
     645             :     }
     646             : 
     647           0 :     xmlUnlinkNode(pNode);
     648           0 :     xmlFreeNode(pNode);
     649           0 : }
     650             : 
     651           0 : void XMLDocumentWrapper_XmlSecImpl::buildIDAttr(xmlNodePtr pNode) const
     652             : /****** XMLDocumentWrapper_XmlSecImpl/buildIDAttr *****************************
     653             :  *
     654             :  *   NAME
     655             :  *  buildIDAttr -- build the ID attribute of a node
     656             :  *
     657             :  *   SYNOPSIS
     658             :  *  buildIDAttr( pNode );
     659             :  *
     660             :  *   FUNCTION
     661             :  *  see NAME
     662             :  *
     663             :  *   INPUTS
     664             :  *  pNode - the node whose id attribute will be built
     665             :  *
     666             :  *   RESULT
     667             :  *  empty
     668             :  *
     669             :  *   AUTHOR
     670             :  *  Michael Mi
     671             :  *  Email: michael.mi@sun.com
     672             :  ******************************************************************************/
     673             : {
     674           0 :     xmlAttrPtr idAttr = xmlHasProp( pNode, (const unsigned char *)"id" );
     675           0 :     if (idAttr == NULL)
     676             :     {
     677           0 :         idAttr = xmlHasProp( pNode, (const unsigned char *)"Id" );
     678             :     }
     679             : 
     680           0 :     if (idAttr != NULL)
     681             :     {
     682           0 :         xmlChar* idValue = xmlNodeListGetString( m_pDocument, idAttr->children, 1 ) ;
     683           0 :         xmlAddID( NULL, m_pDocument, idValue, idAttr );
     684             :     }
     685           0 : }
     686             : 
     687           0 : void XMLDocumentWrapper_XmlSecImpl::rebuildIDLink(xmlNodePtr pNode) const
     688             : /****** XMLDocumentWrapper_XmlSecImpl/rebuildIDLink ***************************
     689             :  *
     690             :  *   NAME
     691             :  *  rebuildIDLink -- rebuild the ID link for the branch
     692             :  *
     693             :  *   SYNOPSIS
     694             :  *  rebuildIDLink( pNode );
     695             :  *
     696             :  *   FUNCTION
     697             :  *  see NAME
     698             :  *
     699             :  *   INPUTS
     700             :  *  pNode - the node, from which the branch will be rebuilt
     701             :  *
     702             :  *   RESULT
     703             :  *  empty
     704             :  *
     705             :  *   AUTHOR
     706             :  *  Michael Mi
     707             :  *  Email: michael.mi@sun.com
     708             :  ******************************************************************************/
     709             : {
     710           0 :     if (pNode != NULL && pNode->type == XML_ELEMENT_NODE)
     711             :     {
     712           0 :         buildIDAttr( pNode );
     713             : 
     714           0 :         xmlNodePtr child = pNode->children;
     715           0 :         while (child != NULL)
     716             :         {
     717           0 :             rebuildIDLink(child);
     718           0 :             child = child->next;
     719             :         }
     720             :     }
     721           0 : }
     722             : 
     723             : /* XXMLDocumentWrapper */
     724           0 : cssu::Reference< cssxw::XXMLElementWrapper > SAL_CALL XMLDocumentWrapper_XmlSecImpl::getCurrentElement(  )
     725             :     throw (cssu::RuntimeException, std::exception)
     726             : {
     727           0 :     XMLElementWrapper_XmlSecImpl* pElement = new XMLElementWrapper_XmlSecImpl(m_pCurrentElement);
     728           0 :     return cssu::Reference< cssxw::XXMLElementWrapper >(pElement);
     729             : }
     730             : 
     731           0 : void SAL_CALL XMLDocumentWrapper_XmlSecImpl::setCurrentElement( const cssu::Reference< cssxw::XXMLElementWrapper >& element )
     732             :     throw (cssu::RuntimeException, std::exception)
     733             : {
     734           0 :     m_pCurrentElement = checkElement( element );
     735           0 :     saxHelper.setCurrentNode( m_pCurrentElement );
     736           0 : }
     737             : 
     738           0 : void SAL_CALL XMLDocumentWrapper_XmlSecImpl::removeCurrentElement(  )
     739             :     throw (cssu::RuntimeException, std::exception)
     740             : {
     741             :     OSL_ASSERT( m_pCurrentElement != NULL );
     742             : 
     743           0 :     xmlNodePtr pOldCurrentElement = m_pCurrentElement;
     744             : 
     745             :     /*
     746             :      * pop the top node in the parser context's
     747             :      * nodeTab stack, then the parent of that node will
     748             :      * automatically become the new stack top, and
     749             :      * the current node as well.
     750             :      */
     751             :     saxHelper.endElement(
     752             :         OUString(
     753           0 :             C2U (
     754             :                 (sal_Char*)(pOldCurrentElement->name)
     755           0 :             )));
     756           0 :     m_pCurrentElement = saxHelper.getCurrentNode();
     757             : 
     758             :     /*
     759             :      * remove the node
     760             :      */
     761           0 :     removeNode(pOldCurrentElement);
     762           0 : }
     763             : 
     764           0 : sal_Bool SAL_CALL XMLDocumentWrapper_XmlSecImpl::isCurrent( const cssu::Reference< cssxw::XXMLElementWrapper >& node )
     765             :     throw (cssu::RuntimeException, std::exception)
     766             : {
     767           0 :     xmlNodePtr pNode = checkElement(node);
     768           0 :     return (pNode == m_pCurrentElement);
     769             : }
     770             : 
     771           0 : sal_Bool SAL_CALL XMLDocumentWrapper_XmlSecImpl::isCurrentElementEmpty(  )
     772             :     throw (cssu::RuntimeException, std::exception)
     773             : {
     774           0 :     bool rc = false;
     775             : 
     776           0 :     if (m_pCurrentElement->children == NULL)
     777             :     {
     778           0 :         rc = true;
     779             :     }
     780             : 
     781           0 :     return rc;
     782             : }
     783             : 
     784           0 : OUString SAL_CALL XMLDocumentWrapper_XmlSecImpl::getNodeName( const cssu::Reference< cssxw::XXMLElementWrapper >& node )
     785             :     throw (cssu::RuntimeException, std::exception)
     786             : {
     787           0 :     xmlNodePtr pNode = checkElement(node);
     788           0 :     return OUString(C2U ( (sal_Char*)pNode->name ));
     789             : }
     790             : 
     791           0 : void SAL_CALL XMLDocumentWrapper_XmlSecImpl::clearUselessData(
     792             :     const cssu::Reference< cssxw::XXMLElementWrapper >& node,
     793             :     const cssu::Sequence< cssu::Reference< cssxw::XXMLElementWrapper > >& reservedDescendants,
     794             :     const cssu::Reference< cssxw::XXMLElementWrapper >& stopAtNode )
     795             :     throw (cssu::RuntimeException, std::exception)
     796             : {
     797           0 :     xmlNodePtr pTargetNode = checkElement(node);
     798             : 
     799           0 :     m_pStopAtNode = checkElement(stopAtNode);
     800           0 :     m_aReservedNodes = reservedDescendants;
     801           0 :     m_nReservedNodeIndex = 0;
     802             : 
     803           0 :     getNextReservedNode();
     804             : 
     805           0 :     recursiveDelete(pTargetNode);
     806           0 : }
     807             : 
     808           0 : void SAL_CALL XMLDocumentWrapper_XmlSecImpl::collapse( const cssu::Reference< cssxw::XXMLElementWrapper >& node )
     809             :     throw (cssu::RuntimeException, std::exception)
     810             : {
     811           0 :     xmlNodePtr pTargetNode = checkElement(node);
     812             :     xmlNodePtr pParent;
     813             : 
     814           0 :     while (pTargetNode != NULL)
     815             :     {
     816           0 :         if (pTargetNode->children != NULL || pTargetNode == m_pCurrentElement)
     817             :         {
     818             :             break;
     819             :         }
     820             : 
     821           0 :         pParent = pTargetNode->parent;
     822           0 :         removeNode(pTargetNode);
     823           0 :         pTargetNode = pParent;
     824             :     }
     825           0 : }
     826             : 
     827           0 : void SAL_CALL XMLDocumentWrapper_XmlSecImpl::getTree( const cssu::Reference< cssxs::XDocumentHandler >& handler )
     828             :     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
     829             : {
     830           0 :     if (m_pRootElement != NULL)
     831             :     {
     832           0 :         xmlNodePtr pTempCurrentElement = m_pCurrentElement;
     833           0 :         sal_Int32 nTempCurrentPosition = m_nCurrentPosition;
     834             : 
     835           0 :         m_pCurrentElement = m_pRootElement;
     836             : 
     837           0 :         m_nCurrentPosition = NODEPOSITION_STARTELEMENT;
     838           0 :         cssu::Reference< cssxs::XDocumentHandler > xHandler = handler;
     839             : 
     840             :         while(true)
     841             :         {
     842           0 :             switch (m_nCurrentPosition)
     843             :             {
     844             :             case NODEPOSITION_STARTELEMENT:
     845           0 :                 sendStartElement(NULL, xHandler, m_pCurrentElement);
     846           0 :                 break;
     847             :             case NODEPOSITION_ENDELEMENT:
     848           0 :                 sendEndElement(NULL, xHandler, m_pCurrentElement);
     849           0 :                 break;
     850             :             case NODEPOSITION_NORMAL:
     851           0 :                 sendNode(NULL, xHandler, m_pCurrentElement);
     852           0 :                 break;
     853             :             }
     854             : 
     855           0 :             if ( (m_pCurrentElement == m_pRootElement) && (m_nCurrentPosition == NODEPOSITION_ENDELEMENT ))
     856             :             {
     857           0 :                 break;
     858             :             }
     859             : 
     860           0 :             getNextSAXEvent();
     861             :         }
     862             : 
     863           0 :         m_pCurrentElement = pTempCurrentElement;
     864           0 :         m_nCurrentPosition = nTempCurrentPosition;
     865             :     }
     866           0 : }
     867             : 
     868           0 : void SAL_CALL XMLDocumentWrapper_XmlSecImpl::generateSAXEvents(
     869             :     const cssu::Reference< cssxs::XDocumentHandler >& handler,
     870             :     const cssu::Reference< cssxs::XDocumentHandler >& xEventKeeperHandler,
     871             :     const cssu::Reference< cssxw::XXMLElementWrapper >& startNode,
     872             :     const cssu::Reference< cssxw::XXMLElementWrapper >& endNode )
     873             :     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
     874             : {
     875             :         /*
     876             :          * The first SAX event is the startElement of the startNode
     877             :          * element.
     878             :          */
     879           0 :     bool bHasCurrentElementChild = (m_pCurrentElement->children != NULL);
     880             : 
     881           0 :     xmlNodePtr pTempCurrentElement = m_pCurrentElement;
     882             : 
     883           0 :     m_pCurrentElement = checkElement(startNode);
     884             : 
     885           0 :     if (m_pCurrentElement->type == XML_ELEMENT_NODE)
     886             :     {
     887           0 :         m_nCurrentPosition = NODEPOSITION_STARTELEMENT;
     888             :     }
     889             :     else
     890             :     {
     891           0 :         m_nCurrentPosition = NODEPOSITION_NORMAL;
     892             :     }
     893             : 
     894           0 :     xmlNodePtr pEndNode = checkElement(endNode);
     895             : 
     896           0 :     cssu::Reference < cssxc::sax::XSAXEventKeeper > xSAXEventKeeper( xEventKeeperHandler, cssu::UNO_QUERY );
     897             : 
     898           0 :     cssu::Reference< cssxs::XDocumentHandler > xHandler = handler;
     899             : 
     900             :     while(true)
     901             :     {
     902           0 :         switch (m_nCurrentPosition)
     903             :         {
     904             :         case NODEPOSITION_STARTELEMENT:
     905           0 :             sendStartElement(xHandler, xEventKeeperHandler, m_pCurrentElement);
     906           0 :             break;
     907             :         case NODEPOSITION_ENDELEMENT:
     908           0 :             sendEndElement(xHandler, xEventKeeperHandler, m_pCurrentElement);
     909           0 :             break;
     910             :         case NODEPOSITION_NORMAL:
     911           0 :             sendNode(xHandler, xEventKeeperHandler, m_pCurrentElement);
     912           0 :             break;
     913             :         default:
     914           0 :             throw cssu::RuntimeException();
     915             :         }
     916             : 
     917           0 :         if (xSAXEventKeeper->isBlocking())
     918             :         {
     919           0 :             xHandler = NULL;
     920             :         }
     921             : 
     922           0 :         if (pEndNode == NULL &&
     923           0 :             ((bHasCurrentElementChild && m_pCurrentElement == xmlGetLastChild(pTempCurrentElement) && m_nCurrentPosition != NODEPOSITION_STARTELEMENT) ||
     924           0 :              (!bHasCurrentElementChild && m_pCurrentElement == pTempCurrentElement && m_nCurrentPosition == NODEPOSITION_STARTELEMENT)))
     925             :         {
     926           0 :             break;
     927             :         }
     928             : 
     929           0 :         getNextSAXEvent();
     930             : 
     931             :             /*
     932             :              * If there is an end point specified, then check whether
     933             :              * the current node equals to the end point. If so, stop
     934             :              * generating.
     935             :              */
     936           0 :         if (pEndNode != NULL && m_pCurrentElement == pEndNode)
     937             :         {
     938           0 :             break;
     939             :         }
     940             :     }
     941             : 
     942           0 :     m_pCurrentElement = pTempCurrentElement;
     943           0 : }
     944             : 
     945           0 : void SAL_CALL XMLDocumentWrapper_XmlSecImpl::rebuildIDLink(
     946             :     const com::sun::star::uno::Reference< com::sun::star::xml::wrapper::XXMLElementWrapper >& node )
     947             :     throw (com::sun::star::uno::RuntimeException, std::exception)
     948             : {
     949           0 :     xmlNodePtr pNode = checkElement( node );
     950           0 :     rebuildIDLink(pNode);
     951           0 : }
     952             : 
     953             : 
     954             : /* cssxs::XDocumentHandler */
     955           0 : void SAL_CALL XMLDocumentWrapper_XmlSecImpl::startDocument(  )
     956             :     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
     957             : {
     958           0 : }
     959             : 
     960           0 : void SAL_CALL XMLDocumentWrapper_XmlSecImpl::endDocument(  )
     961             :     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
     962             : {
     963           0 : }
     964             : 
     965           0 : void SAL_CALL XMLDocumentWrapper_XmlSecImpl::startElement( const OUString& aName, const cssu::Reference< cssxs::XAttributeList >& xAttribs )
     966             :     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
     967             : {
     968           0 :     sal_Int32 nLength = xAttribs->getLength();
     969           0 :     cssu::Sequence< cssxcsax::XMLAttribute > aAttributes (nLength);
     970             : 
     971           0 :     for (int i = 0; i < nLength; ++i)
     972             :     {
     973           0 :         aAttributes[i].sName = xAttribs->getNameByIndex((short)i);
     974           0 :         aAttributes[i].sValue =xAttribs->getValueByIndex((short)i);
     975             :     }
     976             : 
     977           0 :     compressedStartElement(aName, aAttributes);
     978           0 : }
     979             : 
     980           0 : void SAL_CALL XMLDocumentWrapper_XmlSecImpl::endElement( const OUString& aName )
     981             :     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
     982             : {
     983           0 :     saxHelper.endElement(aName);
     984           0 :     m_pCurrentElement = saxHelper.getCurrentNode();
     985           0 : }
     986             : 
     987           0 : void SAL_CALL XMLDocumentWrapper_XmlSecImpl::characters( const OUString& aChars )
     988             :     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
     989             : {
     990           0 :     saxHelper.characters(aChars);
     991           0 : }
     992             : 
     993           0 : void SAL_CALL XMLDocumentWrapper_XmlSecImpl::ignorableWhitespace( const OUString& aWhitespaces )
     994             :     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
     995             : {
     996           0 :     saxHelper.ignorableWhitespace(aWhitespaces);
     997           0 : }
     998             : 
     999           0 : void SAL_CALL XMLDocumentWrapper_XmlSecImpl::processingInstruction( const OUString& aTarget, const OUString& aData )
    1000             :     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
    1001             : {
    1002           0 :     saxHelper.processingInstruction(aTarget, aData);
    1003           0 : }
    1004             : 
    1005           0 : void SAL_CALL XMLDocumentWrapper_XmlSecImpl::setDocumentLocator( const cssu::Reference< cssxs::XLocator >& xLocator )
    1006             :     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
    1007             : {
    1008           0 :     saxHelper.setDocumentLocator(xLocator);
    1009           0 : }
    1010             : 
    1011             : /* XCompressedDocumentHandler */
    1012           0 : void SAL_CALL XMLDocumentWrapper_XmlSecImpl::compressedStartDocument(  )
    1013             :     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
    1014             : {
    1015           0 : }
    1016             : 
    1017           0 : void SAL_CALL XMLDocumentWrapper_XmlSecImpl::compressedEndDocument(  )
    1018             :     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
    1019             : {
    1020           0 : }
    1021             : 
    1022           0 : void SAL_CALL XMLDocumentWrapper_XmlSecImpl::compressedStartElement( const OUString& aName, const cssu::Sequence< cssxcsax::XMLAttribute >& aAttributes )
    1023             :     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
    1024             : {
    1025           0 :     saxHelper.startElement(aName, aAttributes);
    1026           0 :     m_pCurrentElement = saxHelper.getCurrentNode();
    1027             : 
    1028           0 :     buildIDAttr( m_pCurrentElement );
    1029           0 : }
    1030             : 
    1031           0 : void SAL_CALL XMLDocumentWrapper_XmlSecImpl::compressedEndElement( const OUString& aName )
    1032             :     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
    1033             : {
    1034           0 :     endElement( aName );
    1035           0 : }
    1036             : 
    1037           0 : void SAL_CALL XMLDocumentWrapper_XmlSecImpl::compressedCharacters( const OUString& aChars )
    1038             :     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
    1039             : {
    1040           0 :     characters( aChars );
    1041           0 : }
    1042             : 
    1043           0 : void SAL_CALL XMLDocumentWrapper_XmlSecImpl::compressedIgnorableWhitespace( const OUString& aWhitespaces )
    1044             :     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
    1045             : {
    1046           0 :     ignorableWhitespace( aWhitespaces );
    1047           0 : }
    1048             : 
    1049           0 : void SAL_CALL XMLDocumentWrapper_XmlSecImpl::compressedProcessingInstruction( const OUString& aTarget, const OUString& aData )
    1050             :     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
    1051             : {
    1052           0 :     processingInstruction( aTarget, aData );
    1053           0 : }
    1054             : 
    1055           0 : void SAL_CALL XMLDocumentWrapper_XmlSecImpl::compressedSetDocumentLocator( sal_Int32 /*columnNumber*/, sal_Int32 /*lineNumber*/, const OUString& /*publicId*/, const OUString& /*systemId*/ )
    1056             :     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
    1057             : {
    1058           0 : }
    1059             : 
    1060          14 : OUString XMLDocumentWrapper_XmlSecImpl_getImplementationName ()
    1061             :     throw (cssu::RuntimeException)
    1062             : {
    1063          14 :     return OUString ( IMPLEMENTATION_NAME );
    1064             : }
    1065             : 
    1066           0 : cssu::Sequence< OUString > SAL_CALL XMLDocumentWrapper_XmlSecImpl_getSupportedServiceNames(  )
    1067             :     throw (cssu::RuntimeException)
    1068             : {
    1069           0 :     cssu::Sequence < OUString > aRet(1);
    1070           0 :     OUString* pArray = aRet.getArray();
    1071           0 :     pArray[0] = "com.sun.star.xml.wrapper.XMLDocumentWrapper";
    1072           0 :     return aRet;
    1073             : }
    1074             : 
    1075           0 : cssu::Reference< cssu::XInterface > SAL_CALL XMLDocumentWrapper_XmlSecImpl_createInstance(
    1076             :     const cssu::Reference< cssu::XComponentContext > &)
    1077             :     throw( cssu::Exception )
    1078             : {
    1079           0 :     return (cppu::OWeakObject*) new XMLDocumentWrapper_XmlSecImpl( );
    1080             : }
    1081             : 
    1082             : /* XServiceInfo */
    1083           0 : OUString SAL_CALL XMLDocumentWrapper_XmlSecImpl::getImplementationName(  )
    1084             :     throw (cssu::RuntimeException, std::exception)
    1085             : {
    1086           0 :     return XMLDocumentWrapper_XmlSecImpl_getImplementationName();
    1087             : }
    1088           0 : sal_Bool SAL_CALL XMLDocumentWrapper_XmlSecImpl::supportsService( const OUString& rServiceName )
    1089             :     throw (cssu::RuntimeException, std::exception)
    1090             : {
    1091           0 :     return cppu::supportsService( this, rServiceName );
    1092             : }
    1093           0 : cssu::Sequence< OUString > SAL_CALL XMLDocumentWrapper_XmlSecImpl::getSupportedServiceNames(  )
    1094             :     throw (cssu::RuntimeException, std::exception)
    1095             : {
    1096           0 :     return XMLDocumentWrapper_XmlSecImpl_getSupportedServiceNames();
    1097             : }
    1098             : 
    1099             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10