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