unoxml/source/dom/documentbuilder.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: documentbuilder.cxx,v $
  10  * $Revision: 1.7 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include "documentbuilder.hxx"
  32 #include "node.hxx"
  33 #include "document.hxx"
  34
  35 #include <rtl/alloc.h>
  36 #include <rtl/memory.h>
  37 #include <rtl/ustrbuf.hxx>
  38
  39 #include <cppuhelper/implbase1.hxx>
  40
  41 #include <libxml/xmlerror.h>
  42
  43 #include <com/sun/star/xml/sax/SAXParseException.hpp>
  44 #include <com/sun/star/ucb/XCommandEnvironment.hpp>
  45 #include <com/sun/star/task/XInteractionHandler.hpp>
  46 #include <ucbhelper/content.hxx>
  47 #include <ucbhelper/commandenvironment.hxx>
  48
  49 #include <string.h>
  50 #include <stdio.h>
  51 #include <stdarg.h>
  52
  53
  54 using ::rtl::OUStringBuffer;
  55 using ::rtl::OString;
  56 using ::com::sun::star::xml::sax::InputSource;
  57 using namespace ucbhelper;
  58 using namespace ::com::sun::star::ucb;
  59 using ::com::sun::star::task::XInteractionHandler;
  60
  61
  62 namespace DOM
  63 {
  64     extern "C" {
  65         //char *strdup(const char *s);
  66         /*
  67         static char* strdupfunc(const char* s)
  68         {
  69             sal_Int32 len = 0;
  70             while (s[len] != '\0') len++;
  71             char *newStr = (char*)rtl_allocateMemory(len+1);
  72             if (newStr != NULL)
  73                 rtl_copyMemory(newStr, s, len+1);
  74             return newStr;
  75         }
  76         */
  77     }
  78
  79
  80     class CDefaultEntityResolver : public cppu::WeakImplHelper1< XEntityResolver >
  81     {
  82     public:
  83         virtual InputSource SAL_CALL resolveEntity( const OUString& sPublicId, const OUString& sSystemId )
  84             throw (::com::sun::star::uno::RuntimeException)
  85         {
  86             InputSource is;
  87             is.sPublicId = sPublicId;
  88             is.sSystemId = sSystemId;
  89             is.sEncoding = OUString();
  90
  91             try {
  92                 Reference< XCommandEnvironment > aEnvironment(
  93                     new CommandEnvironment(Reference< XInteractionHandler >(),
  94                                            Reference< XProgressHandler >() ));
  95                 Content aContent(sSystemId, aEnvironment);
  96
  97                 is.aInputStream = aContent.openStream();
  98             } catch (com::sun::star::uno::Exception) {
  99                 OSL_ENSURE(sal_False, "exception in default entity resolver");
 100                 is.aInputStream = Reference< XInputStream >();
 101             }
 102             return is;
 103         }
 104
 105     };
 106
 107     CDocumentBuilder::CDocumentBuilder(const Reference< XMultiServiceFactory >& xFactory)
 108         : m_aFactory(xFactory)
 109         , m_aEntityResolver(Reference< XEntityResolver > (new CDefaultEntityResolver()))
 110     {
 111         // init libxml. libxml will protect itself against multiple
 112         // initializations so there is no problem here if this gets
 113         // called multiple times.
 114         xmlInitParser();
 115     }
 116
 117     Reference< XInterface > CDocumentBuilder::_getInstance(const Reference< XMultiServiceFactory >& rSMgr)
 118     {
 119         // XXX
 120         return static_cast< XDocumentBuilder* >(new CDocumentBuilder(rSMgr));
 121     }
 122
 123     const char* CDocumentBuilder::aImplementationName = "com.sun.star.comp.xml.dom.DocumentBuilder";
 124     const char* CDocumentBuilder::aSupportedServiceNames[] = {
 125         "com.sun.star.xml.dom.DocumentBuilder",
 126         NULL
 127     };
 128
 129     OUString CDocumentBuilder::_getImplementationName()
 130     {
 131         return OUString::createFromAscii(aImplementationName);
 132     }
 133     Sequence<OUString> CDocumentBuilder::_getSupportedServiceNames()
 134     {
 135         Sequence<OUString> aSequence;
 136         for (int i=0; aSupportedServiceNames[i]!=NULL; i++) {
 137             aSequence.realloc(i+1);
 138             aSequence[i]=(OUString::createFromAscii(aSupportedServiceNames[i]));
 139         }
 140         return aSequence;
 141     }
 142
 143     Sequence< OUString > SAL_CALL CDocumentBuilder::getSupportedServiceNames()
 144         throw (RuntimeException)
 145     {
 146         return CDocumentBuilder::_getSupportedServiceNames();
 147     }
 148
 149     OUString SAL_CALL CDocumentBuilder::getImplementationName()
 150         throw (RuntimeException)
 151     {
 152         return CDocumentBuilder::_getImplementationName();
 153     }
 154
 155     sal_Bool SAL_CALL CDocumentBuilder::supportsService(const OUString& aServiceName)
 156         throw (RuntimeException)
 157     {
 158         Sequence< OUString > supported = CDocumentBuilder::_getSupportedServiceNames();
 159         for (sal_Int32 i=0; i<supported.getLength(); i++)
 160         {
 161             if (supported[i] == aServiceName) return sal_True;
 162         }
 163         return sal_False;
 164     }
 165
 166     Reference< XDOMImplementation > SAL_CALL CDocumentBuilder::getDOMImplementation()
 167         throw (RuntimeException)
 168     {
 169
 170         return Reference< XDOMImplementation >();
 171     }
 172
 173     sal_Bool SAL_CALL CDocumentBuilder::isNamespaceAware()
 174         throw (RuntimeException)
 175     {
 176         return sal_True;
 177     }
 178
 179     sal_Bool SAL_CALL CDocumentBuilder::isValidating()
 180         throw (RuntimeException)
 181     {
 182         return sal_False;
 183     }
 184
 185     Reference< XDocument > SAL_CALL CDocumentBuilder::newDocument()
 186         throw (RuntimeException)
 187     {
 188         // create a new document
 189         xmlDocPtr pDocument = xmlNewDoc((const xmlChar*)"1.0");
 190         return Reference< XDocument >(static_cast< CDocument* >(CNode::get((xmlNodePtr)pDocument)));
 191     }
 192
 193     static OUString make_error_message(xmlParserCtxtPtr ctxt)
 194     {
 195         OUStringBuffer buf;
 196         buf.appendAscii(ctxt->lastError.message);
 197         buf.appendAscii("Line: ");
 198         buf.append(static_cast<sal_Int32>(ctxt->lastError.line));
 199         buf.appendAscii("\nColumn: ");
 200         buf.append(static_cast<sal_Int32>(ctxt->lastError.int2));
 201         OUString msg = buf.makeStringAndClear();
 202         return msg;
 203     }
 204
 205     // -- callbacks and context struct for parsing from stream
 206     // -- c-linkage, so the callbacks can be used by libxml
 207     extern "C" {
 208
 209     // context struct passed to IO functions
 210     typedef struct context {
 211         CDocumentBuilder *pBuilder;
 212         Reference< XInputStream > rInputStream;
 213         bool close;
 214         bool freeOnClose;
 215     } context_t;
 216
 217     static int xmlIO_read_func( void *context, char *buffer, int len)
 218     {
 219         // get the context...
 220         context_t *pctx = static_cast<context_t*>(context);
 221         if (!pctx->rInputStream.is())
 222             return -1;
 223         try {
 224             // try to read the requested number of bytes
 225             Sequence< sal_Int8 > chunk(len);
 226             int nread = pctx->rInputStream->readBytes(chunk, len);
 227
 228             // copy bytes to the provided buffer
 229             rtl_copyMemory(buffer, chunk.getConstArray(), nread);
 230             return nread;
 231         } catch (com::sun::star::uno::Exception& ex) {
 232             (void) ex;
 233             OSL_ENSURE(sal_False, OUStringToOString(ex.Message, RTL_TEXTENCODING_UTF8).getStr());
 234             return -1;
 235         }
 236     }
 237
 238     static int xmlIO_close_func(void* context)
 239     {
 240         // get the context...
 241         context_t *pctx = static_cast<context_t*>(context);
 242         if (!pctx->rInputStream.is())
 243             return 0;
 244         try
 245         {
 246             if (pctx->close)
 247                 pctx->rInputStream->closeInput();
 248             if (pctx->freeOnClose)
 249                 delete pctx;
 250             return 0;
 251         } catch (com::sun::star::uno::Exception& ex) {
 252             (void) ex;
 253             OSL_ENSURE(sal_False, OUStringToOString(ex.Message, RTL_TEXTENCODING_UTF8).getStr());
 254             return -1;
 255         }
 256     }
 257
 258     static xmlParserInputPtr resolve_func(void *ctx,
 259                                 const xmlChar *publicId,
 260                                 const xmlChar *systemId)
 261     {
 262         // get the CDocumentBuilder object
 263         xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr)ctx;
 264         CDocumentBuilder *builder = static_cast< CDocumentBuilder* >(ctxt->_private);
 265         Reference< XEntityResolver > resolver = builder->getEntityResolver();
 266         OUString sysid;
 267         if (systemId != 0)
 268             sysid = OUString((sal_Char*)systemId, strlen((char*)systemId), RTL_TEXTENCODING_UTF8);
 269         OUString pubid;
 270         if (publicId != 0)
 271             pubid = OUString((sal_Char*)publicId, strlen((char*)publicId), RTL_TEXTENCODING_UTF8);
 272
 273         // resolve the entity
 274         InputSource src = resolver->resolveEntity(pubid, sysid);
 275
 276         // create IO context on heap because this call will no longer be on the stack
 277         // when IO is actually performed through the callbacks. The close function must
 278         // free the memory which is indicated by the freeOnClose field in the context struct
 279         context_t *c = new context_t;
 280         c->pBuilder = builder;
 281         c->rInputStream = src.aInputStream;
 282         c->close = true;
 283         c->freeOnClose = true;
 284
 285         // set up the inputBuffer and inputPtr for libxml
 286         xmlParserInputBufferPtr pBuffer =
 287             xmlParserInputBufferCreateIO(xmlIO_read_func, xmlIO_close_func, c, XML_CHAR_ENCODING_NONE);
 288         xmlParserInputPtr pInput =
 289                     xmlNewIOInputStream(ctxt, pBuffer, XML_CHAR_ENCODING_NONE);
 290         return pInput;
 291     }
 292
 293     static xmlParserInputPtr external_entity_loader(const char *URL, const char * /*ID*/, xmlParserCtxtPtr ctxt)
 294     {
 295         // just call our resolver function using the URL as systemId
 296         return resolve_func(ctxt, 0, (const xmlChar*)URL);
 297     }
 298
 299     // default warning handler triggers assertion
 300     static void warning_func(void * ctx, const char * /*msg*/, ...)
 301     {
 302         OUStringBuffer buf(OUString::createFromAscii("libxml2 warning\n"));
 303         buf.append(make_error_message(static_cast< xmlParserCtxtPtr >(ctx)));
 304         OString msg = OUStringToOString(buf.makeStringAndClear(), RTL_TEXTENCODING_ASCII_US);
 305         OSL_ENSURE(sal_False, msg.getStr());
 306     }
 307
 308     // default error handler triggers assertion
 309     static void error_func(void * ctx, const char * /*msg*/, ...)
 310     {
 311         OUStringBuffer buf(OUString::createFromAscii("libxml2 error\n"));
 312         buf.append(make_error_message(static_cast< xmlParserCtxtPtr >(ctx)));
 313         OString msg = OUStringToOString(buf.makeStringAndClear(), RTL_TEXTENCODING_ASCII_US);
 314         OSL_ENSURE(sal_False, msg.getStr());
 315     }
 316
 317     } // extern "C"
 318
 319     void throwEx(xmlParserCtxtPtr ctxt) {
 320         OUString msg = make_error_message(ctxt);
 321         xmlFreeParserCtxt(ctxt);
 322         com::sun::star::xml::sax::SAXParseException saxex;
 323         saxex.Message = msg;
 324         saxex.LineNumber = static_cast<sal_Int32>(ctxt->lastError.line);
 325         saxex.ColumnNumber = static_cast<sal_Int32>(ctxt->lastError.int2);
 326         throw saxex;
 327     }
 328
 329     Reference< XDocument > SAL_CALL CDocumentBuilder::parse(const Reference< XInputStream >& is)
 330         throw (RuntimeException, SAXParseException, IOException)
 331     {
 332
 333         // encoding...
 334         /*
 335         xmlChar *encstr = (xmlChar*) OUStringToOString(src.sEncoding, RTL_TEXTENCODING_UTF8).getStr();
 336         xmlCharEncoding enc = xmlParseCharEncoding(encstr);
 337         */
 338
 339         xmlParserCtxtPtr ctxt = xmlNewParserCtxt();
 340
 341         // register error functions to prevent errors being printed
 342         // on the console
 343         ctxt->_private = this;
 344         ctxt->sax->error = error_func;
 345         ctxt->sax->warning = warning_func;
 346         ctxt->sax->resolveEntity = resolve_func;
 347
 348         // IO context struct
 349         context_t c;
 350         c.pBuilder = this;
 351         c.rInputStream = is;
 352         // we did not open the stream, thus we do not close it.
 353         c.close = false;
 354         c.freeOnClose = false;
 355         xmlDocPtr pDoc = xmlCtxtReadIO(ctxt, xmlIO_read_func, xmlIO_close_func, &c,
 356                      0, 0, 0);
 357
 358         if (pDoc == 0) {
 359             throwEx(ctxt);
 360         }
 361         xmlFreeParserCtxt(ctxt);
 362         return Reference< XDocument >(static_cast< CDocument* >(CNode::get((xmlNodePtr)pDoc)));
 363     }
 364
 365     Reference< XDocument > SAL_CALL CDocumentBuilder::parseSource(const InputSource& is)
 366         throw (RuntimeException, SAXParseException, IOException)
 367     {
 368         // if there is an encoding specified in the input source, use it
 369         xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
 370         if (is.sEncoding.getLength() > 0) {
 371             OString oEncstr = OUStringToOString(is.sEncoding, RTL_TEXTENCODING_UTF8);
 372             char *encstr = (char*) oEncstr.getStr();
 373             enc = xmlParseCharEncoding(encstr);
 374         }
 375
 376         // set up parser context
 377         xmlParserCtxtPtr ctxt = xmlNewParserCtxt();
 378         // register error functions to prevent errors being printed
 379         // on the console
 380         ctxt->_private = this;
 381         ctxt->sax->error = error_func;
 382         ctxt->sax->warning = warning_func;
 383
 384         // setup entity resolver binding(s)
 385         ctxt->sax->resolveEntity = resolve_func;
 386         xmlSetExternalEntityLoader(external_entity_loader);
 387
 388         // if an input stream is provided, use it
 389
 390         // use the systemID
 391
 392         return Reference< XDocument >();
 393     }
 394
 395     Reference< XDocument > SAL_CALL CDocumentBuilder::parseURI(const OUString& sUri)
 396         throw (RuntimeException, SAXParseException, IOException)
 397     {
 398         xmlParserCtxtPtr ctxt = xmlNewParserCtxt();
 399         ctxt->_private = this;
 400         ctxt->sax->error = error_func;
 401         ctxt->sax->warning = warning_func;
 402         ctxt->sax->resolveEntity = resolve_func;
 403         // xmlSetExternalEntityLoader(external_entity_loader);
 404         OString oUri = OUStringToOString(sUri, RTL_TEXTENCODING_UTF8);
 405         char *uri = (char*) oUri.getStr();
 406         xmlDocPtr pDoc = xmlCtxtReadFile(ctxt, uri, 0, 0);
 407         if (pDoc == 0) {
 408             throwEx(ctxt);
 409         }
 410         xmlFreeParserCtxt(ctxt);
 411         return Reference< XDocument >(static_cast< CDocument* >(CNode::get((xmlNodePtr)pDoc)));
 412     }
 413
 414     void SAL_CALL CDocumentBuilder::setEntityResolver(const Reference< XEntityResolver >& er)
 415         throw (RuntimeException)
 416     {
 417         m_aEntityResolver = er;
 418     }
 419
 420     Reference< XEntityResolver > SAL_CALL CDocumentBuilder::getEntityResolver()
 421         throw (RuntimeException)
 422     {
 423         return m_aEntityResolver;
 424     }
 425
 426
 427     void SAL_CALL CDocumentBuilder::setErrorHandler(const Reference< XErrorHandler >& eh)
 428         throw (RuntimeException)
 429     {
 430         m_aErrorHandler = eh;
 431     }
 432 }