unoxml/source/dom/documentbuilder.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 "documentbuilder.hxx"
  21
  22 #include <string.h>
  23
  24 #include <libxml/xmlerror.h>
  25 #include <libxml/parser.h>
  26
  27 #include <memory>
  28
  29 #include <sal/log.hxx>
  30 #include <comphelper/diagnose_ex.hxx>
  31
  32 #include <comphelper/processfactory.hxx>
  33 #include <cppuhelper/implbase.hxx>
  34 #include <cppuhelper/supportsservice.hxx>
  35
  36 #include <com/sun/star/xml/sax/SAXParseException.hpp>
  37 #include <com/sun/star/ucb/XCommandEnvironment.hpp>
  38 #include <com/sun/star/task/XInteractionHandler.hpp>
  39 #include <com/sun/star/ucb/SimpleFileAccess.hpp>
  40
  41 #include <ucbhelper/content.hxx>
  42 #include <ucbhelper/commandenvironment.hxx>
  43
  44 #include "document.hxx"
  45
  46 using namespace css::io;
  47 using namespace css::lang;
  48 using namespace css::ucb;
  49 using namespace css::uno;
  50 using namespace css::xml::dom;
  51 using namespace css::xml::sax;
  52 using namespace ucbhelper;
  53 using css::task::XInteractionHandler;
  54 using css::xml::sax::InputSource;
  55
  56
  57 namespace DOM
  58 {
  59     namespace {
  60
  61     class CDefaultEntityResolver : public cppu::WeakImplHelper< XEntityResolver >
  62     {
  63     public:
  64         virtual InputSource SAL_CALL resolveEntity( const OUString& sPublicId, const OUString& sSystemId ) override
  65         {
  66             InputSource is;
  67             is.sPublicId = sPublicId;
  68             is.sSystemId = sSystemId;
  69             is.sEncoding.clear();
  70
  71             try {
  72                 Reference< XCommandEnvironment > aEnvironment(
  73                     new CommandEnvironment(Reference< XInteractionHandler >(),
  74                                            Reference< XProgressHandler >() ));
  75                 Content aContent(sSystemId, aEnvironment, comphelper::getProcessComponentContext());
  76
  77                 is.aInputStream = aContent.openStream();
  78             } catch (const css::uno::Exception&) {
  79                 TOOLS_WARN_EXCEPTION( "unoxml", "exception in default entity resolver");
  80                 is.aInputStream.clear();
  81             }
  82             return is;
  83         }
  84
  85     };
  86
  87     }
  88
  89     CDocumentBuilder::CDocumentBuilder()
  90         : m_xEntityResolver(new CDefaultEntityResolver)
  91     {
  92         // init libxml. libxml will protect itself against multiple
  93         // initializations so there is no problem here if this gets
  94         // called multiple times.
  95         xmlInitParser();
  96     }
  97
  98     Sequence< OUString > SAL_CALL CDocumentBuilder::getSupportedServiceNames()
  99     {
 100         return { "com.sun.star.xml.dom.DocumentBuilder" };
 101     }
 102
 103     OUString SAL_CALL CDocumentBuilder::getImplementationName()
 104     {
 105         return "com.sun.star.comp.xml.dom.DocumentBuilder";
 106     }
 107
 108     sal_Bool SAL_CALL CDocumentBuilder::supportsService(const OUString& aServiceName)
 109     {
 110         return cppu::supportsService(this, aServiceName);
 111     }
 112
 113     Reference< XDOMImplementation > SAL_CALL CDocumentBuilder::getDOMImplementation()
 114     {
 115
 116         return Reference< XDOMImplementation >();
 117     }
 118
 119     sal_Bool SAL_CALL CDocumentBuilder::isNamespaceAware()
 120     {
 121         return true;
 122     }
 123
 124     sal_Bool SAL_CALL CDocumentBuilder::isValidating()
 125     {
 126         return false;
 127     }
 128
 129     Reference< XDocument > SAL_CALL CDocumentBuilder::newDocument()
 130     {
 131         std::scoped_lock const g(m_Mutex);
 132
 133         // create a new document
 134         xmlDocPtr pDocument = xmlNewDoc(reinterpret_cast<const xmlChar*>("1.0"));
 135         return CDocument::CreateCDocument(pDocument);
 136     }
 137
 138     static OUString make_error_message(xmlParserCtxtPtr ctxt)
 139     {
 140         return OUString(ctxt->lastError.message, strlen(ctxt->lastError.message), RTL_TEXTENCODING_ASCII_US) +
 141                "Line: " +
 142                OUString::number(static_cast<sal_Int32>(ctxt->lastError.line)) +
 143                "\nColumn: " +
 144                OUString::number(static_cast<sal_Int32>(ctxt->lastError.int2));
 145     }
 146
 147     // -- callbacks and context struct for parsing from stream
 148     // -- c-linkage, so the callbacks can be used by libxml
 149     extern "C" {
 150
 151     namespace {
 152
 153     // context struct passed to IO functions
 154     typedef struct context {
 155         Reference< XInputStream > rInputStream;
 156         bool close;
 157         bool freeOnClose;
 158     } context_t;
 159
 160     }
 161
 162     static int xmlIO_read_func( void *context, char *buffer, int len)
 163     {
 164         // get the context...
 165         context_t *pctx = static_cast<context_t*>(context);
 166         if (!pctx->rInputStream.is())
 167             return -1;
 168         try {
 169             // try to read the requested number of bytes
 170             Sequence< sal_Int8 > chunk(len);
 171             int nread = pctx->rInputStream->readBytes(chunk, len);
 172
 173             // copy bytes to the provided buffer
 174             memcpy(buffer, chunk.getConstArray(), nread);
 175             return nread;
 176         } catch (const css::uno::Exception&) {
 177             TOOLS_WARN_EXCEPTION( "unoxml", "");
 178             return -1;
 179         }
 180     }
 181
 182     static int xmlIO_close_func(void* context)
 183     {
 184         // get the context...
 185         context_t *pctx = static_cast<context_t*>(context);
 186         if (!pctx->rInputStream.is())
 187             return 0;
 188         try
 189         {
 190             if (pctx->close)
 191                 pctx->rInputStream->closeInput();
 192             if (pctx->freeOnClose)
 193                 delete pctx;
 194             return 0;
 195         } catch (const css::uno::Exception&) {
 196             TOOLS_WARN_EXCEPTION( "unoxml", "");
 197             return -1;
 198         }
 199     }
 200
 201     static xmlParserInputPtr resolve_func(void *ctx,
 202                                 const xmlChar *publicId,
 203                                 const xmlChar *systemId)
 204     {
 205         // get the CDocumentBuilder object
 206         xmlParserCtxtPtr ctxt = static_cast<xmlParserCtxtPtr>(ctx);
 207         CDocumentBuilder *builder = static_cast< CDocumentBuilder* >(ctxt->_private);
 208         Reference< XEntityResolver > resolver = builder->getEntityResolver();
 209         OUString sysid;
 210         if (systemId != nullptr)
 211             sysid = OUString(reinterpret_cast<char const *>(systemId), strlen(reinterpret_cast<char const *>(systemId)), RTL_TEXTENCODING_UTF8);
 212         OUString pubid;
 213         if (publicId != nullptr)
 214             pubid = OUString(reinterpret_cast<char const *>(publicId), strlen(reinterpret_cast<char const *>(publicId)), RTL_TEXTENCODING_UTF8);
 215
 216         // resolve the entity
 217         InputSource src = resolver->resolveEntity(pubid, sysid);
 218
 219         // create IO context on heap because this call will no longer be on the stack
 220         // when IO is actually performed through the callbacks. The close function must
 221         // free the memory which is indicated by the freeOnClose field in the context struct
 222         context_t *c = new context_t;
 223         c->rInputStream = src.aInputStream;
 224         c->close = true;
 225         c->freeOnClose = true;
 226
 227         // set up the inputBuffer and inputPtr for libxml
 228         xmlParserInputBufferPtr pBuffer =
 229             xmlParserInputBufferCreateIO(xmlIO_read_func, xmlIO_close_func, c, XML_CHAR_ENCODING_NONE);
 230         xmlParserInputPtr pInput =
 231                     xmlNewIOInputStream(ctxt, pBuffer, XML_CHAR_ENCODING_NONE);
 232         return pInput;
 233     }
 234
 235 #if 0
 236     static xmlParserInputPtr external_entity_loader(const char *URL, const char * /*ID*/, xmlParserCtxtPtr ctxt)
 237     {
 238         // just call our resolver function using the URL as systemId
 239         return resolve_func(ctxt, 0, (const xmlChar*)URL);
 240     }
 241 #endif
 242
 243     // default warning handler does not trigger assertion
 244     static void warning_func(void * ctx, const char * /*msg*/, ...)
 245     {
 246         try
 247         {
 248             xmlParserCtxtPtr const pctx = static_cast<xmlParserCtxtPtr>(ctx);
 249
 250             SAL_INFO(
 251                 "unoxml",
 252                 "libxml2 warning: "
 253                 << make_error_message(pctx));
 254
 255             CDocumentBuilder * const pDocBuilder = static_cast<CDocumentBuilder*>(pctx->_private);
 256
 257             if (pDocBuilder->getErrorHandler().is())   // if custom error handler is set (using setErrorHandler ())
 258             {
 259                 // Prepare SAXParseException to be passed to custom XErrorHandler::warning function
 260                 css::xml::sax::SAXParseException saxex(make_error_message(pctx), {}, {}, {}, {},
 261                                                        pctx->lastError.line, pctx->lastError.int2);
 262
 263                 // Call custom warning function
 264                 pDocBuilder->getErrorHandler()->warning(::css::uno::Any(saxex));
 265             }
 266         }
 267         catch (const css::uno::Exception &)
 268         {
 269             // Protect lib2xml from UNO Exception
 270             TOOLS_WARN_EXCEPTION("unoxml", "DOM::warning_func");
 271         }
 272     }
 273
 274     // default error handler triggers assertion
 275     static void error_func(void * ctx, const char * /*msg*/, ...)
 276     {
 277         try
 278         {
 279             xmlParserCtxtPtr const pctx = static_cast<xmlParserCtxtPtr>(ctx);
 280             SAL_WARN(
 281                 "unoxml",
 282                 "libxml2 error: "
 283                 << make_error_message(pctx));
 284
 285             CDocumentBuilder * const pDocBuilder = static_cast<CDocumentBuilder*>(pctx->_private);
 286
 287             if (pDocBuilder->getErrorHandler().is())   // if custom error handler is set (using setErrorHandler ())
 288             {
 289                 // Prepare SAXParseException to be passed to custom XErrorHandler::error function
 290                 css::xml::sax::SAXParseException saxex(make_error_message(pctx), {}, {}, {}, {},
 291                                                        pctx->lastError.line, pctx->lastError.int2);
 292
 293                 // Call custom warning function
 294                 pDocBuilder->getErrorHandler()->error(::css::uno::Any(saxex));
 295             }
 296         }
 297         catch (const css::uno::Exception &)
 298         {
 299             // Protect lib2xml from UNO Exception
 300             TOOLS_WARN_EXCEPTION("unoxml", "DOM::error_func");
 301         }
 302     }
 303     } // extern "C"
 304
 305     static void throwEx(xmlParserCtxtPtr ctxt)
 306     {
 307         css::xml::sax::SAXParseException saxex(make_error_message(ctxt), {}, {}, {}, {},
 308                                                ctxt->lastError.line, ctxt->lastError.int2);
 309         throw saxex;
 310     }
 311
 312     namespace {
 313
 314     struct XmlFreeParserCtxt {
 315         void operator ()(xmlParserCtxt * p) const { xmlFreeParserCtxt(p); }
 316     };
 317
 318     }
 319
 320     Reference< XDocument > SAL_CALL CDocumentBuilder::parse(const Reference< XInputStream >& is)
 321     {
 322         if (!is.is()) {
 323             throw RuntimeException();
 324         }
 325
 326         std::scoped_lock const g(m_Mutex);
 327
 328         // IO context struct.  Must outlive pContext, as destroying that via
 329         // xmlFreeParserCtxt may still access this context_t
 330         context_t c;
 331         c.rInputStream = is;
 332         // we did not open the stream, thus we do not close it.
 333         c.close = false;
 334         c.freeOnClose = false;
 335
 336         std::unique_ptr<xmlParserCtxt, XmlFreeParserCtxt> const pContext(
 337                 xmlNewParserCtxt());
 338
 339         // register error functions to prevent errors being printed
 340         // on the console
 341         pContext->_private = this;
 342         pContext->sax->error = error_func;
 343         pContext->sax->warning = warning_func;
 344         pContext->sax->resolveEntity = resolve_func;
 345
 346         xmlDocPtr const pDoc = xmlCtxtReadIO(pContext.get(),
 347                 xmlIO_read_func, xmlIO_close_func, &c, nullptr, nullptr, 0);
 348
 349         if (pDoc == nullptr) {
 350             throwEx(pContext.get());
 351         }
 352         return CDocument::CreateCDocument(pDoc);
 353     }
 354
 355     Reference< XDocument > SAL_CALL CDocumentBuilder::parseURI(const OUString& sUri)
 356     {
 357         std::scoped_lock const g(m_Mutex);
 358
 359         std::unique_ptr<xmlParserCtxt, XmlFreeParserCtxt> const pContext(
 360                 xmlNewParserCtxt());
 361         pContext->_private = this;
 362         pContext->sax->error = error_func;
 363         pContext->sax->warning = warning_func;
 364         pContext->sax->resolveEntity = resolve_func;
 365         // xmlSetExternalEntityLoader(external_entity_loader);
 366         OString oUri = OUStringToOString(sUri, RTL_TEXTENCODING_UTF8);
 367         char *uri = const_cast<char*>(oUri.getStr());
 368         xmlDocPtr pDoc = xmlCtxtReadFile(pContext.get(), uri, nullptr, 0);
 369
 370         Reference< XDocument > xRet;
 371
 372         // if we failed to parse the URI as a simple file, lets try via a ucb stream.
 373         // For Android file:///assets/ URLs which must go via the osl/ file API.
 374         if (pDoc == nullptr) {
 375             Reference < XSimpleFileAccess3 > xStreamAccess(
 376                 SimpleFileAccess::create( comphelper::getProcessComponentContext() ) );
 377             Reference< XInputStream > xInStream = xStreamAccess->openFileRead( sUri );
 378             if (!xInStream.is())
 379                 throwEx(pContext.get());
 380
 381             // loop over every layout entry in current file
 382             xRet = parse( xInStream );
 383
 384             xInStream->closeInput();
 385             xInStream.clear();
 386
 387         } else
 388             xRet = CDocument::CreateCDocument(pDoc).get();
 389
 390         return xRet;
 391     }
 392
 393     void SAL_CALL
 394     CDocumentBuilder::setEntityResolver(Reference< XEntityResolver > const& xER)
 395     {
 396         std::scoped_lock const g(m_Mutex);
 397
 398         m_xEntityResolver = xER;
 399     }
 400
 401     Reference< XEntityResolver > CDocumentBuilder::getEntityResolver()
 402     {
 403         std::scoped_lock const g(m_Mutex);
 404
 405         return m_xEntityResolver;
 406     }
 407
 408     void SAL_CALL
 409     CDocumentBuilder::setErrorHandler(Reference< XErrorHandler > const& xEH)
 410     {
 411         std::scoped_lock const g(m_Mutex);
 412
 413         m_xErrorHandler = xEH;
 414     }
 415 }
 416
 417 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 418 unoxml_CDocumentBuilder_get_implementation(
 419     css::uno::XComponentContext* , css::uno::Sequence<css::uno::Any> const&)
 420 {
 421     return cppu::acquire(new DOM::CDocumentBuilder());
 422 }
 423
 424 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */