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 rtl::OUString& oustr )
  39 {
  40     rtl::OString ostr = rtl::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 rtl::OUString& oustr, int& length )
  49 {
  50     rtl::OString ostr = rtl::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     /*
 127      * i41748
 128      *
 129      * mmi : re-initialize the SAX handler to version 1
 130      */
 131
 132     xmlSAXVersion(m_pParserCtxt->sax, 1);
 133
 134     /* end */
 135
 136     if( m_pParserCtxt->inputTab[0] != NULL )
 137     {
 138         m_pParserCtxt->inputTab[0] = NULL ;
 139     }
 140
 141     if( m_pParserCtxt == NULL )
 142     {
 143 #ifndef XMLSEC_NO_XSLT
 144         xsltCleanupGlobals() ;
 145 #endif
 146 //      see issue i74334, we cannot call xmlCleanupParser when libxml is still used
 147 //      in other parts of the office.
 148 //      xmlCleanupParser() ;
 149         throw cssu::RuntimeException() ;
 150     }
 151     else if( m_pParserCtxt->sax == NULL )
 152     {
 153         xmlFreeParserCtxt( m_pParserCtxt ) ;
 154
 155 #ifndef XMLSEC_NO_XSLT
 156         xsltCleanupGlobals() ;
 157 #endif
 158 //      see issue i74334, we cannot call xmlCleanupParser when libxml is still used
 159 //      in other parts of the office.
 160 //      xmlCleanupParser() ;
 161         m_pParserCtxt = NULL ;
 162         throw cssu::RuntimeException() ;
 163     }
 164     else
 165     {
 166         m_pSaxHandler = m_pParserCtxt->sax ;
 167
 168         //Adjust the context
 169         m_pParserCtxt->recovery = 1 ;
 170     }
 171 }
 172
 173 /**
 174  * Destructor
 175  *
 176  * In this destructor, a libxml sax parser context is desturcted. The XML tree
 177  * in the context is not deallocated because the tree is bind with a document
 178  * model by the setTargetDocument method, which delegate the target document to
 179  * destruct the xml tree.
 180  */
 181 SAXHelper::~SAXHelper() {
 182     if( m_pParserCtxt != NULL )
 183     {
 184         /*
 185          * In the situation that no object refer the Document, this destructor
 186          * must deallocate the Document memory
 187          */
 188         if( m_pSaxHandler == m_pParserCtxt->sax )
 189         {
 190             m_pSaxHandler = NULL ;
 191         }
 192
 193         xmlFreeParserCtxt( m_pParserCtxt ) ;
 194         m_pParserCtxt = NULL ;
 195     }
 196
 197     if( m_pSaxHandler != NULL )
 198     {
 199         xmlFree( m_pSaxHandler ) ;
 200         m_pSaxHandler = NULL ;
 201     }
 202 //      see issue i74334, we cannot call xmlCleanupParser when libxml is still used
 203 //      in other parts of the office.
 204 //  xmlCleanupParser() ;
 205 }
 206
 207 xmlNodePtr SAXHelper::getCurrentNode()
 208 {
 209     return m_pParserCtxt->node;
 210 }
 211
 212 void SAXHelper::setCurrentNode(const xmlNodePtr pNode)
 213 {
 214     /*
 215      * This is really a black trick.
 216      * When the current node is replaced, the nodeTab
 217      * stack's top has to been replaced with the same
 218      * node, in order to make compatibility.
 219      */
 220     m_pParserCtxt->nodeTab[m_pParserCtxt->nodeNr - 1]
 221         = m_pParserCtxt->node
 222             = pNode;
 223 }
 224
 225 xmlDocPtr SAXHelper::getDocument()
 226 {
 227     return m_pParserCtxt->myDoc;
 228 }
 229
 230 /**
 231  * XDocumentHandler -- start an xml document
 232  */
 233 void SAXHelper::startDocument( void )
 234     throw( cssxs::SAXException , cssu::RuntimeException )
 235 {
 236     /*
 237      * Adjust inputTab
 238      */
 239     xmlParserInputPtr pInput = xmlNewInputStream( m_pParserCtxt ) ;
 240
 241     if( m_pParserCtxt->inputTab != NULL && m_pParserCtxt->inputMax != 0 )
 242     {
 243         m_pParserCtxt->inputTab[0] = pInput ;
 244         m_pParserCtxt->input = pInput ;
 245     }
 246
 247     m_pSaxHandler->startDocument( m_pParserCtxt ) ;
 248
 249     if( m_pParserCtxt == NULL || m_pParserCtxt->myDoc == NULL )
 250     {
 251         throw cssu::RuntimeException() ;
 252     }
 253 }
 254
 255 /**
 256  * XDocumentHandler -- end an xml document
 257  */
 258 void SAXHelper::endDocument( void )
 259     throw( cssxs::SAXException , cssu::RuntimeException )
 260 {
 261     m_pSaxHandler->endDocument( m_pParserCtxt ) ;
 262 }
 263
 264 /**
 265  * XDocumentHandler -- start an xml element
 266  */
 267 void SAXHelper::startElement(
 268     const rtl::OUString& aName,
 269     const cssu::Sequence< cssxcsax::XMLAttribute >& aAttributes )
 270     throw( cssxs::SAXException , cssu::RuntimeException )
 271 {
 272     const xmlChar* fullName = NULL ;
 273     const xmlChar** attrs = NULL ;
 274
 275     fullName = ous_to_xmlstr( aName ) ;
 276     attrs = attrlist_to_nxmlstr( aAttributes ) ;
 277
 278     if( fullName != NULL || attrs != NULL )
 279     {
 280         m_pSaxHandler->startElement( m_pParserCtxt , fullName , attrs ) ;
 281     }
 282
 283     if( fullName != NULL )
 284     {
 285         xmlFree( ( xmlChar* )fullName ) ;
 286         fullName = NULL ;
 287     }
 288
 289     if( attrs != NULL )
 290     {
 291         for( int i = 0 ; attrs[i] != NULL ; ++i )
 292         {
 293             xmlFree( ( xmlChar* )attrs[i] ) ;
 294             attrs[i] = NULL ;
 295         }
 296
 297         xmlFree( ( void* ) attrs ) ;
 298         attrs = NULL ;
 299     }
 300 }
 301
 302 /**
 303  * XDocumentHandler -- end an xml element
 304  */
 305 void SAXHelper::endElement( const rtl::OUString& aName )
 306     throw( cssxs::SAXException , cssu::RuntimeException )
 307 {
 308     xmlChar* fullname = NULL ;
 309
 310     fullname = ous_to_xmlstr( aName ) ;
 311     m_pSaxHandler->endElement( m_pParserCtxt , fullname ) ;
 312
 313     if( fullname != NULL )
 314     {
 315         xmlFree( ( xmlChar* )fullname ) ;
 316         fullname = NULL ;
 317     }
 318 }
 319
 320 /**
 321  * XDocumentHandler -- an xml element or cdata characters
 322  */
 323 void SAXHelper::characters( const rtl::OUString& aChars )
 324     throw( cssxs::SAXException , cssu::RuntimeException )
 325 {
 326     const xmlChar* chars = NULL ;
 327     int length = 0 ;
 328
 329     chars = ous_to_nxmlstr( aChars, length ) ;
 330     m_pSaxHandler->characters( m_pParserCtxt , chars , length ) ;
 331
 332     if( chars != NULL )
 333     {
 334         xmlFree( ( xmlChar* )chars ) ;
 335     }
 336 }
 337
 338 /**
 339  * XDocumentHandler -- ignorable xml white space
 340  */
 341 void SAXHelper::ignorableWhitespace( const rtl::OUString& aWhitespaces )
 342     throw( cssxs::SAXException , cssu::RuntimeException )
 343 {
 344     const xmlChar* chars = NULL ;
 345     int length = 0 ;
 346
 347     chars = ous_to_nxmlstr( aWhitespaces, length ) ;
 348     m_pSaxHandler->ignorableWhitespace( m_pParserCtxt , chars , length ) ;
 349
 350     if( chars != NULL )
 351     {
 352         xmlFree( ( xmlChar* )chars ) ;
 353     }
 354 }
 355
 356 /**
 357  * XDocumentHandler -- preaorocessing instruction
 358  */
 359 void SAXHelper::processingInstruction(
 360     const rtl::OUString& aTarget,
 361     const rtl::OUString& aData )
 362     throw( cssxs::SAXException , cssu::RuntimeException )
 363 {
 364     xmlChar* target = NULL ;
 365     xmlChar* data = NULL ;
 366
 367     target = ous_to_xmlstr( aTarget ) ;
 368     data = ous_to_xmlstr( aData ) ;
 369
 370     m_pSaxHandler->processingInstruction( m_pParserCtxt , target , data ) ;
 371
 372     if( target != NULL )
 373     {
 374         xmlFree( ( xmlChar* )target ) ;
 375         target = NULL ;
 376     }
 377
 378     if( data != NULL )
 379     {
 380         xmlFree( ( xmlChar* )data ) ;
 381         data = NULL ;
 382     }
 383 }
 384
 385 /**
 386  * XDocumentHandler -- set document locator
 387  * In this case, locator is useless.
 388  */
 389 void SAXHelper::setDocumentLocator(
 390     const cssu::Reference< cssxs::XLocator > &)
 391     throw( cssxs::SAXException , cssu::RuntimeException )
 392 {
 393 }
 394
 395 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */