LCOV - code coverage report
Current view: top level - xmlsecurity/source/xmlsec - saxhelper.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 134 0.0 %
Date: 2014-04-14 Functions: 0 17 0.0 %
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             : 
      21             : #include <rtl/ustring.hxx>
      22             : 
      23             : #include "saxhelper.hxx"
      24             : #include "libxml/parserInternals.h"
      25             : 
      26             : #ifndef XMLSEC_NO_XSLT
      27             : #include "libxslt/xslt.h"
      28             : #endif
      29             : 
      30             : namespace cssu = com::sun::star::uno;
      31             : namespace cssxs = com::sun::star::xml::sax;
      32             : namespace cssxcsax = com::sun::star::xml::csax;
      33             : 
      34             : /**
      35             :  * The return value is NULL terminated. The application has the responsibilty to
      36             :  * deallocte the return value.
      37             :  */
      38           0 : xmlChar* ous_to_xmlstr( const OUString& oustr )
      39             : {
      40           0 :     OString ostr = OUStringToOString( oustr , RTL_TEXTENCODING_UTF8 ) ;
      41           0 :     return xmlStrndup( ( xmlChar* )ostr.getStr(), ( int )ostr.getLength() ) ;
      42             : }
      43             : 
      44             : /**
      45             :  * The return value is NULL terminated. The application has the responsibilty to
      46             :  * deallocte the return value.
      47             :  */
      48           0 : xmlChar* ous_to_nxmlstr( const OUString& oustr, int& length )
      49             : {
      50           0 :     OString ostr = OUStringToOString( oustr , RTL_TEXTENCODING_UTF8 ) ;
      51           0 :     length = ostr.getLength();
      52             : 
      53           0 :     return xmlStrndup( ( xmlChar* )ostr.getStr(), length ) ;
      54             : }
      55             : 
      56             : /**
      57             :  * The return value and the referenced value must be NULL terminated.
      58             :  * The application has the responsibilty to deallocte the return value.
      59             :  */
      60           0 : const xmlChar** attrlist_to_nxmlstr( const cssu::Sequence< cssxcsax::XMLAttribute >& aAttributes )
      61             : {
      62           0 :     xmlChar* attname = NULL ;
      63           0 :     xmlChar* attvalue = NULL ;
      64           0 :     const xmlChar** attrs = NULL ;
      65             : 
      66           0 :     sal_Int32 nLength = aAttributes.getLength();
      67             : 
      68           0 :     if( nLength != 0 )
      69             :     {
      70           0 :         attrs = ( const xmlChar** )xmlMalloc( ( nLength * 2 + 2 ) * sizeof( xmlChar* ) ) ;
      71             :     }
      72             :     else
      73             :     {
      74           0 :         return NULL ;
      75             :     }
      76             : 
      77           0 :     for( int i = 0 , j = 0 ; j < nLength ; ++j )
      78             :     {
      79           0 :         attname = ous_to_xmlstr( aAttributes[j].sName ) ;
      80           0 :         attvalue = ous_to_xmlstr( aAttributes[j].sValue ) ;
      81             : 
      82           0 :         if( attname != NULL && attvalue != NULL )
      83             :         {
      84           0 :             attrs[i++] = attname ;
      85           0 :             attrs[i++] = attvalue ;
      86           0 :             attrs[i] = NULL ;
      87           0 :             attrs[i+1] = NULL ;
      88             :         }
      89             :         else
      90             :         {
      91           0 :             if( attname != NULL )
      92           0 :                 xmlFree( attname ) ;
      93           0 :             if( attvalue != NULL )
      94           0 :                 xmlFree( attvalue ) ;
      95             :         }
      96             :     }
      97             : 
      98           0 :     return attrs ;
      99             : }
     100             : 
     101             : /**
     102             :  * Constructor
     103             :  *
     104             :  * In this constructor, a libxml sax parser context is initialized. a libxml
     105             :  * default sax handler is initialized with the context.
     106             :  */
     107           0 : SAXHelper::SAXHelper( )
     108             :     : m_pParserCtxt( NULL ),
     109           0 :       m_pSaxHandler( NULL )
     110             : {
     111           0 :     xmlInitParser() ;
     112           0 :     LIBXML_TEST_VERSION ;
     113             : 
     114             :     /*
     115             :      * compile error:
     116             :      * xmlLoadExtDtdDefaultValue = XML_DETECT_IDS | XML_COMPLETE_ATTRS ;
     117             :      */
     118           0 :     xmlSubstituteEntitiesDefault( 1 ) ;
     119             : 
     120             : #ifndef XMLSEC_NO_XSLT
     121             :     xmlIndentTreeOutput = 1 ;
     122             : #endif /* XMLSEC_NO_XSLT */
     123             : 
     124           0 :     m_pParserCtxt = xmlNewParserCtxt() ;
     125             : 
     126           0 :     if( m_pParserCtxt == NULL )
     127             :     {
     128             : #ifndef XMLSEC_NO_XSLT
     129             :         xsltCleanupGlobals() ;
     130             : #endif
     131             : //      see issue i74334, we cannot call xmlCleanupParser when libxml is still used
     132             : //      in other parts of the office.
     133             : //      xmlCleanupParser() ;
     134           0 :         throw cssu::RuntimeException() ;
     135             :     }
     136             :     else
     137             :     {
     138           0 :         xmlSAXVersion(m_pParserCtxt->sax, 1);
     139             : 
     140           0 :         if( m_pParserCtxt->inputTab[0] != NULL )
     141             :         {
     142           0 :             m_pParserCtxt->inputTab[0] = NULL ;
     143             :         }
     144             : 
     145           0 :         if( m_pParserCtxt->sax == NULL )
     146             :         {
     147           0 :             xmlFreeParserCtxt( m_pParserCtxt ) ;
     148             : 
     149             : #ifndef XMLSEC_NO_XSLT
     150             :             xsltCleanupGlobals() ;
     151             : #endif
     152             : //      see issue i74334, we cannot call xmlCleanupParser when libxml is still used
     153             : //      in other parts of the office.
     154             : //      xmlCleanupParser() ;
     155           0 :             m_pParserCtxt = NULL ;
     156           0 :             throw cssu::RuntimeException() ;
     157             :         }
     158             :         else
     159             :         {
     160           0 :             m_pSaxHandler = m_pParserCtxt->sax ;
     161             : 
     162             :             //Adjust the context
     163           0 :             m_pParserCtxt->recovery = 1 ;
     164             :         }
     165             :     }
     166           0 : }
     167             : 
     168             : /**
     169             :  * Destructor
     170             :  *
     171             :  * In this destructor, a libxml sax parser context is desturcted. The XML tree
     172             :  * in the context is not deallocated because the tree is bind with a document
     173             :  * model by the setTargetDocument method, which delegate the target document to
     174             :  * destruct the xml tree.
     175             :  */
     176           0 : SAXHelper::~SAXHelper() {
     177           0 :     if( m_pParserCtxt != NULL )
     178             :     {
     179             :         /*
     180             :          * In the situation that no object refer the Document, this destructor
     181             :          * must deallocate the Document memory
     182             :          */
     183           0 :         if( m_pSaxHandler == m_pParserCtxt->sax )
     184             :         {
     185           0 :             m_pSaxHandler = NULL ;
     186             :         }
     187             : 
     188           0 :         xmlFreeParserCtxt( m_pParserCtxt ) ;
     189           0 :         m_pParserCtxt = NULL ;
     190             :     }
     191             : 
     192           0 :     if( m_pSaxHandler != NULL )
     193             :     {
     194           0 :         xmlFree( m_pSaxHandler ) ;
     195           0 :         m_pSaxHandler = NULL ;
     196             :     }
     197             : //      see issue i74334, we cannot call xmlCleanupParser when libxml is still used
     198             : //      in other parts of the office.
     199             : //  xmlCleanupParser() ;
     200           0 : }
     201             : 
     202           0 : xmlNodePtr SAXHelper::getCurrentNode()
     203             : {
     204           0 :     return m_pParserCtxt->node;
     205             : }
     206             : 
     207           0 : void SAXHelper::setCurrentNode(const xmlNodePtr pNode)
     208             : {
     209             :     /*
     210             :      * This is really a black trick.
     211             :      * When the current node is replaced, the nodeTab
     212             :      * stack's top has to been replaced with the same
     213             :      * node, in order to make compatibility.
     214             :      */
     215           0 :     m_pParserCtxt->nodeTab[m_pParserCtxt->nodeNr - 1]
     216             :         = m_pParserCtxt->node
     217           0 :             = pNode;
     218           0 : }
     219             : 
     220           0 : xmlDocPtr SAXHelper::getDocument()
     221             : {
     222           0 :     return m_pParserCtxt->myDoc;
     223             : }
     224             : 
     225             : /**
     226             :  * XDocumentHandler -- start an xml document
     227             :  */
     228           0 : void SAXHelper::startDocument( void )
     229             :     throw( cssxs::SAXException , cssu::RuntimeException )
     230             : {
     231           0 :     if( m_pParserCtxt == NULL)
     232             :     {
     233           0 :         throw cssu::RuntimeException() ;
     234             :     }
     235             :     /*
     236             :      * Adjust inputTab
     237             :      */
     238           0 :     xmlParserInputPtr pInput = xmlNewInputStream( m_pParserCtxt ) ;
     239             : 
     240           0 :     if( m_pParserCtxt->inputTab != NULL && m_pParserCtxt->inputMax != 0 )
     241             :     {
     242           0 :         m_pParserCtxt->inputTab[0] = pInput ;
     243           0 :         m_pParserCtxt->input = pInput ;
     244             :     }
     245             : 
     246           0 :     m_pSaxHandler->startDocument( m_pParserCtxt ) ;
     247             : 
     248           0 :     if( m_pParserCtxt->myDoc == NULL )
     249             :     {
     250           0 :         throw cssu::RuntimeException() ;
     251             :     }
     252           0 : }
     253             : 
     254             : /**
     255             :  * XDocumentHandler -- end an xml document
     256             :  */
     257           0 : void SAXHelper::endDocument( void )
     258             :     throw( cssxs::SAXException , cssu::RuntimeException )
     259             : {
     260           0 :     m_pSaxHandler->endDocument( m_pParserCtxt ) ;
     261           0 : }
     262             : 
     263             : /**
     264             :  * XDocumentHandler -- start an xml element
     265             :  */
     266           0 : void SAXHelper::startElement(
     267             :     const OUString& aName,
     268             :     const cssu::Sequence< cssxcsax::XMLAttribute >& aAttributes )
     269             :     throw( cssxs::SAXException , cssu::RuntimeException )
     270             : {
     271           0 :     const xmlChar* fullName = NULL ;
     272           0 :     const xmlChar** attrs = NULL ;
     273             : 
     274           0 :     fullName = ous_to_xmlstr( aName ) ;
     275           0 :     attrs = attrlist_to_nxmlstr( aAttributes ) ;
     276             : 
     277           0 :     if( fullName != NULL || attrs != NULL )
     278             :     {
     279           0 :         m_pSaxHandler->startElement( m_pParserCtxt , fullName , attrs ) ;
     280             :     }
     281             : 
     282           0 :     if( fullName != NULL )
     283             :     {
     284           0 :         xmlFree( ( xmlChar* )fullName ) ;
     285           0 :         fullName = NULL ;
     286             :     }
     287             : 
     288           0 :     if( attrs != NULL )
     289             :     {
     290           0 :         for( int i = 0 ; attrs[i] != NULL ; ++i )
     291             :         {
     292           0 :             xmlFree( ( xmlChar* )attrs[i] ) ;
     293           0 :             attrs[i] = NULL ;
     294             :         }
     295             : 
     296           0 :         xmlFree( ( void* ) attrs ) ;
     297           0 :         attrs = NULL ;
     298             :     }
     299           0 : }
     300             : 
     301             : /**
     302             :  * XDocumentHandler -- end an xml element
     303             :  */
     304           0 : void SAXHelper::endElement( const OUString& aName )
     305             :     throw( cssxs::SAXException , cssu::RuntimeException )
     306             : {
     307           0 :     xmlChar* fullname = NULL ;
     308             : 
     309           0 :     fullname = ous_to_xmlstr( aName ) ;
     310           0 :     m_pSaxHandler->endElement( m_pParserCtxt , fullname ) ;
     311             : 
     312           0 :     if( fullname != NULL )
     313             :     {
     314           0 :         xmlFree( ( xmlChar* )fullname ) ;
     315           0 :         fullname = NULL ;
     316             :     }
     317           0 : }
     318             : 
     319             : /**
     320             :  * XDocumentHandler -- an xml element or cdata characters
     321             :  */
     322           0 : void SAXHelper::characters( const OUString& aChars )
     323             :     throw( cssxs::SAXException , cssu::RuntimeException )
     324             : {
     325           0 :     const xmlChar* chars = NULL ;
     326           0 :     int length = 0 ;
     327             : 
     328           0 :     chars = ous_to_nxmlstr( aChars, length ) ;
     329           0 :     m_pSaxHandler->characters( m_pParserCtxt , chars , length ) ;
     330             : 
     331           0 :     if( chars != NULL )
     332             :     {
     333           0 :         xmlFree( ( xmlChar* )chars ) ;
     334             :     }
     335           0 : }
     336             : 
     337             : /**
     338             :  * XDocumentHandler -- ignorable xml white space
     339             :  */
     340           0 : void SAXHelper::ignorableWhitespace( const OUString& aWhitespaces )
     341             :     throw( cssxs::SAXException , cssu::RuntimeException )
     342             : {
     343           0 :     const xmlChar* chars = NULL ;
     344           0 :     int length = 0 ;
     345             : 
     346           0 :     chars = ous_to_nxmlstr( aWhitespaces, length ) ;
     347           0 :     m_pSaxHandler->ignorableWhitespace( m_pParserCtxt , chars , length ) ;
     348             : 
     349           0 :     if( chars != NULL )
     350             :     {
     351           0 :         xmlFree( ( xmlChar* )chars ) ;
     352             :     }
     353           0 : }
     354             : 
     355             : /**
     356             :  * XDocumentHandler -- preaorocessing instruction
     357             :  */
     358           0 : void SAXHelper::processingInstruction(
     359             :     const OUString& aTarget,
     360             :     const OUString& aData )
     361             :     throw( cssxs::SAXException , cssu::RuntimeException )
     362             : {
     363           0 :     xmlChar* target = NULL ;
     364           0 :     xmlChar* data = NULL ;
     365             : 
     366           0 :     target = ous_to_xmlstr( aTarget ) ;
     367           0 :     data = ous_to_xmlstr( aData ) ;
     368             : 
     369           0 :     m_pSaxHandler->processingInstruction( m_pParserCtxt , target , data ) ;
     370             : 
     371           0 :     if( target != NULL )
     372             :     {
     373           0 :         xmlFree( ( xmlChar* )target ) ;
     374           0 :         target = NULL ;
     375             :     }
     376             : 
     377           0 :     if( data != NULL )
     378             :     {
     379           0 :         xmlFree( ( xmlChar* )data ) ;
     380           0 :         data = NULL ;
     381             :     }
     382           0 : }
     383             : 
     384             : /**
     385             :  * XDocumentHandler -- set document locator
     386             :  * In this case, locator is useless.
     387             :  */
     388           0 : void SAXHelper::setDocumentLocator(
     389             :     const cssu::Reference< cssxs::XLocator > &)
     390             :     throw( cssxs::SAXException , cssu::RuntimeException )
     391             : {
     392           0 : }
     393             : 
     394             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10