xmlsecurity/source/xmlsec/saxhelper.cxx

   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 xmlChar* ous_to_xmlstr( const OUString& oustr )
  39 {
  40     OString ostr = OUStringToOString( oustr , RTL_TEXTENCODING_UTF8 ) ;
  41     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 xmlChar* ous_to_nxmlstr( const OUString& oustr, int& length )
  49 {
  50     OString ostr = OUStringToOString( oustr , RTL_TEXTENCODING_UTF8 ) ;
  51     length = ostr.getLength();
  52
  53     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 const xmlChar** attrlist_to_nxmlstr( const cssu::Sequence< cssxcsax::XMLAttribute >& aAttributes )
  61 {
  62     xmlChar* attname = NULL ;
  63     xmlChar* attvalue = NULL ;
  64     const xmlChar** attrs = NULL ;
  65
  66     sal_Int32 nLength = aAttributes.getLength();
  67
  68     if( nLength != 0 )
  69     {
  70         attrs = ( const xmlChar** )xmlMalloc( ( nLength * 2 + 2 ) * sizeof( xmlChar* ) ) ;
  71     }
  72     else
  73     {
  74         return NULL ;
  75     }
  76
  77     for( int i = 0 , j = 0 ; j < nLength ; ++j )
  78     {
  79         attname = ous_to_xmlstr( aAttributes[j].sName ) ;
  80         attvalue = ous_to_xmlstr( aAttributes[j].sValue ) ;
  81
  82         if( attname != NULL && attvalue != NULL )
  83         {
  84             attrs[i++] = attname ;
  85             attrs[i++] = attvalue ;
  86             attrs[i] = NULL ;
  87             attrs[i+1] = NULL ;
  88         }
  89         else
  90         {
  91             if( attname != NULL )
  92                 xmlFree( attname ) ;
  93             if( attvalue != NULL )
  94                 xmlFree( attvalue ) ;
  95         }
  96     }
  97
  98     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 SAXHelper::SAXHelper( )
 108     : m_pParserCtxt( NULL ),
 109       m_pSaxHandler( NULL )
 110 {
 111     xmlInitParser() ;
 112     LIBXML_TEST_VERSION ;
 113
 114     /*
 115      * compile error:
 116      * xmlLoadExtDtdDefaultValue = XML_DETECT_IDS | XML_COMPLETE_ATTRS ;
 117      */
 118     xmlSubstituteEntitiesDefault( 1 ) ;
 119
 120 #ifndef XMLSEC_NO_XSLT
 121     xmlIndentTreeOutput = 1 ;
 122 #endif /* XMLSEC_NO_XSLT */
 123
 124     m_pParserCtxt = xmlNewParserCtxt() ;
 125
 126     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         throw cssu::RuntimeException() ;
 135     }
 136     else
 137     {
 138         xmlSAXVersion(m_pParserCtxt->sax, 1);
 139
 140         if( m_pParserCtxt->inputTab[0] != NULL )
 141         {
 142             m_pParserCtxt->inputTab[0] = NULL ;
 143         }
 144
 145         if( m_pParserCtxt->sax == NULL )
 146         {
 147             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             m_pParserCtxt = NULL ;
 156             throw cssu::RuntimeException() ;
 157         }
 158         else
 159         {
 160             m_pSaxHandler = m_pParserCtxt->sax ;
 161
 162             //Adjust the context
 163             m_pParserCtxt->recovery = 1 ;
 164         }
 165     }
 166 }
 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 SAXHelper::~SAXHelper() {
 177     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         if( m_pSaxHandler == m_pParserCtxt->sax )
 184         {
 185             m_pSaxHandler = NULL ;
 186         }
 187
 188         xmlFreeParserCtxt( m_pParserCtxt ) ;
 189         m_pParserCtxt = NULL ;
 190     }
 191
 192     if( m_pSaxHandler != NULL )
 193     {
 194         xmlFree( m_pSaxHandler ) ;
 195         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 }
 201
 202 xmlNodePtr SAXHelper::getCurrentNode()
 203 {
 204     return m_pParserCtxt->node;
 205 }
 206
 207 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     m_pParserCtxt->nodeTab[m_pParserCtxt->nodeNr - 1]
 216         = m_pParserCtxt->node
 217             = pNode;
 218 }
 219
 220 xmlDocPtr SAXHelper::getDocument()
 221 {
 222     return m_pParserCtxt->myDoc;
 223 }
 224
 225 /**
 226  * XDocumentHandler -- start an xml document
 227  */
 228 void SAXHelper::startDocument( void )
 229     throw( cssxs::SAXException , cssu::RuntimeException )
 230 {
 231     if( m_pParserCtxt == NULL)
 232     {
 233         throw cssu::RuntimeException() ;
 234     }
 235     /*
 236      * Adjust inputTab
 237      */
 238     xmlParserInputPtr pInput = xmlNewInputStream( m_pParserCtxt ) ;
 239
 240     if( m_pParserCtxt->inputTab != NULL && m_pParserCtxt->inputMax != 0 )
 241     {
 242         m_pParserCtxt->inputTab[0] = pInput ;
 243         m_pParserCtxt->input = pInput ;
 244     }
 245
 246     m_pSaxHandler->startDocument( m_pParserCtxt ) ;
 247
 248     if( m_pParserCtxt->myDoc == NULL )
 249     {
 250         throw cssu::RuntimeException() ;
 251     }
 252 }
 253
 254 /**
 255  * XDocumentHandler -- end an xml document
 256  */
 257 void SAXHelper::endDocument( void )
 258     throw( cssxs::SAXException , cssu::RuntimeException )
 259 {
 260     m_pSaxHandler->endDocument( m_pParserCtxt ) ;
 261 }
 262
 263 /**
 264  * XDocumentHandler -- start an xml element
 265  */
 266 void SAXHelper::startElement(
 267     const OUString& aName,
 268     const cssu::Sequence< cssxcsax::XMLAttribute >& aAttributes )
 269     throw( cssxs::SAXException , cssu::RuntimeException )
 270 {
 271     const xmlChar* fullName = NULL ;
 272     const xmlChar** attrs = NULL ;
 273
 274     fullName = ous_to_xmlstr( aName ) ;
 275     attrs = attrlist_to_nxmlstr( aAttributes ) ;
 276
 277     if( fullName != NULL || attrs != NULL )
 278     {
 279         m_pSaxHandler->startElement( m_pParserCtxt , fullName , attrs ) ;
 280     }
 281
 282     if( fullName != NULL )
 283     {
 284         xmlFree( ( xmlChar* )fullName ) ;
 285         fullName = NULL ;
 286     }
 287
 288     if( attrs != NULL )
 289     {
 290         for( int i = 0 ; attrs[i] != NULL ; ++i )
 291         {
 292             xmlFree( ( xmlChar* )attrs[i] ) ;
 293             attrs[i] = NULL ;
 294         }
 295
 296         xmlFree( ( void* ) attrs ) ;
 297         attrs = NULL ;
 298     }
 299 }
 300
 301 /**
 302  * XDocumentHandler -- end an xml element
 303  */
 304 void SAXHelper::endElement( const OUString& aName )
 305     throw( cssxs::SAXException , cssu::RuntimeException )
 306 {
 307     xmlChar* fullname = NULL ;
 308
 309     fullname = ous_to_xmlstr( aName ) ;
 310     m_pSaxHandler->endElement( m_pParserCtxt , fullname ) ;
 311
 312     if( fullname != NULL )
 313     {
 314         xmlFree( ( xmlChar* )fullname ) ;
 315         fullname = NULL ;
 316     }
 317 }
 318
 319 /**
 320  * XDocumentHandler -- an xml element or cdata characters
 321  */
 322 void SAXHelper::characters( const OUString& aChars )
 323     throw( cssxs::SAXException , cssu::RuntimeException )
 324 {
 325     const xmlChar* chars = NULL ;
 326     int length = 0 ;
 327
 328     chars = ous_to_nxmlstr( aChars, length ) ;
 329     m_pSaxHandler->characters( m_pParserCtxt , chars , length ) ;
 330
 331     if( chars != NULL )
 332     {
 333         xmlFree( ( xmlChar* )chars ) ;
 334     }
 335 }
 336
 337 /**
 338  * XDocumentHandler -- ignorable xml white space
 339  */
 340 void SAXHelper::ignorableWhitespace( const OUString& aWhitespaces )
 341     throw( cssxs::SAXException , cssu::RuntimeException )
 342 {
 343     const xmlChar* chars = NULL ;
 344     int length = 0 ;
 345
 346     chars = ous_to_nxmlstr( aWhitespaces, length ) ;
 347     m_pSaxHandler->ignorableWhitespace( m_pParserCtxt , chars , length ) ;
 348
 349     if( chars != NULL )
 350     {
 351         xmlFree( ( xmlChar* )chars ) ;
 352     }
 353 }
 354
 355 /**
 356  * XDocumentHandler -- preaorocessing instruction
 357  */
 358 void SAXHelper::processingInstruction(
 359     const OUString& aTarget,
 360     const OUString& aData )
 361     throw( cssxs::SAXException , cssu::RuntimeException )
 362 {
 363     xmlChar* target = NULL ;
 364     xmlChar* data = NULL ;
 365
 366     target = ous_to_xmlstr( aTarget ) ;
 367     data = ous_to_xmlstr( aData ) ;
 368
 369     m_pSaxHandler->processingInstruction( m_pParserCtxt , target , data ) ;
 370
 371     if( target != NULL )
 372     {
 373         xmlFree( ( xmlChar* )target ) ;
 374         target = NULL ;
 375     }
 376
 377     if( data != NULL )
 378     {
 379         xmlFree( ( xmlChar* )data ) ;
 380         data = NULL ;
 381     }
 382 }
 383
 384 /**
 385  * XDocumentHandler -- set document locator
 386  * In this case, locator is useless.
 387  */
 388 void SAXHelper::setDocumentLocator(
 389     const cssu::Reference< cssxs::XLocator > &)
 390     throw( cssxs::SAXException , cssu::RuntimeException )
 391 {
 392 }
 393
 394 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */