filter/source/xsltfilter/LibXSLTTransformer.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2
   3 /*
   4  * This file is part of the LibreOffice project.
   5  *
   6  * This Source Code Form is subject to the terms of the Mozilla Public
   7  * License, v. 2.0. If a copy of the MPL was not distributed with this
   8  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   9  */
  10
  11
  12 #include <cstdio>
  13 #include <cstring>
  14 #include <list>
  15 #include <map>
  16 #include <vector>
  17 #include <iostream>
  18 #include <libxml/parser.h>
  19 #include <libxml/tree.h>
  20 #include <libxml/xmlIO.h>
  21 #include <libxml/xpath.h>
  22 #include <libxml/xpathInternals.h>
  23 #include <libxml/xmlstring.h>
  24 #include <libxslt/transform.h>
  25 #include <libxslt/xsltutils.h>
  26 #include <libxslt/variables.h>
  27 #include <libxslt/extensions.h>
  28 #include <libexslt/exslt.h>
  29
  30 #include <cppuhelper/factory.hxx>
  31 #include <cppuhelper/implbase4.hxx>
  32 #include <cppuhelper/implbase.hxx>
  33
  34 #include <osl/module.h>
  35 #include <osl/file.hxx>
  36 #include <osl/process.h>
  37 #include <com/sun/star/lang/XComponent.hpp>
  38 #include <com/sun/star/lang/XInitialization.hpp>
  39 #include <com/sun/star/uno/Any.hxx>
  40 #include <com/sun/star/beans/NamedValue.hpp>
  41 #include <com/sun/star/io/XInputStream.hpp>
  42 #include <com/sun/star/io/XOutputStream.hpp>
  43 #include <com/sun/star/io/XActiveDataSource.hpp>
  44 #include <com/sun/star/io/XActiveDataSink.hpp>
  45 #include <com/sun/star/io/XActiveDataControl.hpp>
  46 #include <com/sun/star/io/XStreamListener.hpp>
  47
  48 #include <LibXSLTTransformer.hxx>
  49 #include <OleHandler.hxx>
  50
  51 using namespace ::rtl;
  52 using namespace ::cppu;
  53 using namespace ::osl;
  54 using namespace ::com::sun::star::beans;
  55 using namespace ::com::sun::star::io;
  56 using namespace ::com::sun::star::uno;
  57 using namespace ::com::sun::star::lang;
  58 using namespace ::com::sun::star::registry;
  59 using ::std::list;
  60 using ::std::map;
  61 using ::std::pair;
  62
  63 #define _INPUT_BUFFER_SIZE 4096
  64 #define _OUTPUT_BUFFER_SIZE 4096
  65
  66 namespace XSLT
  67 {
  68     const char* const LibXSLTTransformer::PARAM_SOURCE_URL = "sourceURL";
  69     const char* const LibXSLTTransformer::PARAM_SOURCE_BASE_URL =
  70             "sourceBaseURL";
  71     const char* const LibXSLTTransformer::PARAM_TARGET_URL = "targetURL";
  72     const char* const LibXSLTTransformer::PARAM_TARGET_BASE_URL =
  73             "targetBaseURL";
  74     const char* const LibXSLTTransformer::PARAM_DOCTYPE_PUBLIC = "publicType";
  75
  76     const sal_Int32 Reader::OUTPUT_BUFFER_SIZE = _OUTPUT_BUFFER_SIZE;
  77
  78     const sal_Int32 Reader::INPUT_BUFFER_SIZE = _INPUT_BUFFER_SIZE;
  79
  80     /**
  81      * ParserInputBufferCallback forwards IO call-backs to libxml stream IO.
  82      */
  83     struct ParserInputBufferCallback
  84     {
  85         static int
  86         on_read(void * context, char * buffer, int len)
  87         {
  88             Reader * tmp = static_cast<Reader*> (context);
  89             return tmp->read(buffer, len);
  90         }
  91         static int
  92         on_close(void * context)
  93         {
  94             Reader * tmp = static_cast<Reader*> (context);
  95             return tmp->closeInput();
  96         }
  97     };
  98     /**
  99      * ParserOutputBufferCallback forwards IO call-backs to libxml stream IO.
 100      */
 101     struct ParserOutputBufferCallback
 102     {
 103         static int
 104         on_write(void * context, const char * buffer, int len)
 105         {
 106             Reader * tmp = static_cast<Reader*> (context);
 107             return tmp->write(buffer, len);
 108         }
 109         static int
 110         on_close(void * context)
 111         {
 112             Reader * tmp = static_cast<Reader*> (context);
 113             return tmp->closeOutput();
 114         }
 115     };
 116     /**
 117      * ExtFuncOleCB forwards XPath extension function calls registered with libxslt to the OleHandler instance that actually
 118      * provides the implementation for those functions.
 119      *
 120      * The OLE extension module currently supplies two functions
 121      * insertByName: registers an OLE object to be later inserted into the output tree.
 122      * getByName: reads a previously registered OLE object and returns a base64 encoded string representation.
 123      */
 124     struct ExtFuncOleCB
 125     {
 126         static void *
 127         init(xsltTransformContextPtr, const xmlChar*)
 128         {
 129             return NULL;
 130         }
 131         static void
 132         insertByName(xmlXPathParserContextPtr ctxt, int nargs)
 133         {
 134             xsltTransformContextPtr tctxt;
 135             void *data;
 136             if (nargs != 2) {
 137                 xsltGenericError(xsltGenericErrorContext,
 138                     "insertByName: requires exactly 2 arguments\n");
 139                 return;
 140             }
 141             tctxt = xsltXPathGetTransformContext(ctxt);
 142             if (tctxt == NULL) {
 143                 xsltGenericError(xsltGenericErrorContext,
 144                     "xsltExtFunctionTest: failed to get the transformation context\n");
 145                 return;
 146             }
 147             // XXX: someone with better knowledge of libxslt might come up with a better
 148             // idea to pass the OleHandler than by attaching it to tctxt->_private. See also
 149             // below.
 150             data = tctxt->_private;
 151             if (data == NULL) {
 152                 xsltGenericError(xsltGenericErrorContext,
 153                     "xsltExtFunctionTest: failed to get module data\n");
 154                 return;
 155             }
 156             OleHandler * oh = static_cast<OleHandler*> (data);
 157
 158             xmlXPathObjectPtr value = valuePop(ctxt);
 159             value = ensureStringValue(value, ctxt);
 160             xmlXPathObjectPtr streamName = valuePop(ctxt);
 161             streamName = ensureStringValue(streamName, ctxt);
 162
 163             oh->insertByName(OUString::createFromAscii((sal_Char*) streamName->stringval), OString((sal_Char*) value->stringval));
 164             valuePush(ctxt, xmlXPathNewCString(""));
 165         }
 166
 167         static xmlXPathObjectPtr ensureStringValue(xmlXPathObjectPtr obj, const xmlXPathParserContextPtr ctxt)
 168         {
 169             if (obj->type != XPATH_STRING) {
 170                 valuePush(ctxt, obj);
 171                 xmlXPathStringFunction(ctxt, 1);
 172                 obj = valuePop(ctxt);
 173             }
 174             return obj;
 175         }
 176
 177         static void getByName(xmlXPathParserContextPtr ctxt, int nargs)
 178         {
 179             xsltTransformContextPtr tctxt;
 180             void *data;
 181             if (nargs != 1) {
 182                 xsltGenericError(xsltGenericErrorContext,
 183                     "getByName: requires exactly 1 argument\n");
 184                 return;
 185             }
 186
 187             tctxt = xsltXPathGetTransformContext(ctxt);
 188             if (tctxt == NULL) {
 189                 xsltGenericError(xsltGenericErrorContext,
 190                     "xsltExtFunctionTest: failed to get the transformation context\n");
 191                 return;
 192             }
 193             // XXX: someone with better knowledge of libxslt might come up with a better
 194             // idea to pass the OleHandler than by attaching it to tctxt->_private
 195             data = tctxt->_private;
 196             if (data == NULL) {
 197                 xsltGenericError(xsltGenericErrorContext,
 198                     "xsltExtFunctionTest: failed to get module data\n");
 199                 return;
 200             }
 201             OleHandler * oh = static_cast<OleHandler*> (data);
 202             xmlXPathObjectPtr streamName = valuePop(ctxt);
 203             streamName = ensureStringValue(streamName, ctxt);
 204             const OString content = oh->getByName(OUString::createFromAscii((sal_Char*) streamName->stringval));
 205             valuePush(ctxt, xmlXPathNewCString(content.getStr()));
 206             xmlXPathFreeObject(streamName);
 207         }
 208     };
 209
 210     Reader::Reader(LibXSLTTransformer* transformer) :
 211         Thread("LibXSLTTransformer"), m_transformer(transformer),
 212         m_readBuf(INPUT_BUFFER_SIZE), m_writeBuf(OUTPUT_BUFFER_SIZE)
 213     {
 214         LIBXML_TEST_VERSION;
 215     }
 216     ;
 217
 218     int
 219     Reader::read(char * buffer, int len)
 220     {
 221         //        const char *ptr = (const char *) context;
 222         if (buffer == NULL || len < 0)
 223             return (-1);
 224         sal_Int32 n;
 225         css::uno::Reference<XInputStream> xis = this->m_transformer->getInputStream();
 226         n = xis.get()->readBytes(m_readBuf, len);
 227         if (n > 0)
 228             {
 229                 memcpy(buffer, m_readBuf.getArray(), n);
 230             }
 231         return n;
 232     }
 233
 234     int
 235     Reader::write(const char * buffer, int len)
 236     {
 237         if (buffer == NULL || len < 0)
 238             return -1;
 239         if (len > 0)
 240             {
 241                 css::uno::Reference<XOutputStream> xos = m_transformer->getOutputStream();
 242                 sal_Int32 writeLen = len;
 243                 sal_Int32 bufLen = ::std::min(writeLen,
 244                         this->OUTPUT_BUFFER_SIZE);
 245                 const sal_uInt8* memPtr =
 246                         reinterpret_cast<const sal_uInt8*> (buffer);
 247                 while (writeLen > 0)
 248                     {
 249                         sal_Int32 n = ::std::min(writeLen, bufLen);
 250                         m_writeBuf.realloc(n);
 251                         memcpy(m_writeBuf.getArray(), memPtr,
 252                                 static_cast<size_t> (n));
 253                         xos.get()->writeBytes(m_writeBuf);
 254                         memPtr += n;
 255                         writeLen -= n;
 256                     }
 257             }
 258         return len;
 259     }
 260
 261     int
 262     Reader::closeInput()
 263     {
 264         return 0;
 265     }
 266
 267     int
 268     Reader::closeOutput()
 269     {
 270         css::uno::Reference<XOutputStream> xos = m_transformer->getOutputStream();
 271         if (xos.is())
 272             {
 273                 xos.get()->flush();
 274                 xos.get()->closeOutput();
 275             }
 276         m_transformer->done();
 277         return 0;
 278     }
 279
 280     void
 281     Reader::execute()
 282     {
 283         OSL_ASSERT(m_transformer != NULL);
 284         OSL_ASSERT(m_transformer->getInputStream().is());
 285         OSL_ASSERT(m_transformer->getOutputStream().is());
 286         OSL_ASSERT(!m_transformer->getStyleSheetURL().isEmpty());
 287         ::std::map<const char*, OString>::iterator pit;
 288         ::std::map<const char*, OString> pmap = m_transformer->getParameters();
 289         ::std::vector< const char* > params( pmap.size() * 2 + 1 ); // build parameters
 290         int paramIndex = 0;
 291         for (pit = pmap.begin(); pit != pmap.end(); ++pit)
 292         {
 293             params[paramIndex++] = (*pit).first;
 294             params[paramIndex++] = (*pit).second.getStr();
 295         }
 296         params[paramIndex] = NULL;
 297         xmlDocPtr doc = xmlReadIO(&ParserInputBufferCallback::on_read,
 298                 &ParserInputBufferCallback::on_close,
 299                 static_cast<void*> (this), NULL, NULL, 0);
 300         xsltStylesheetPtr styleSheet = xsltParseStylesheetFile(
 301                 (const xmlChar *) m_transformer->getStyleSheetURL().getStr());
 302         xmlDocPtr result = NULL;
 303         xsltTransformContextPtr tcontext = NULL;
 304         exsltRegisterAll();
 305         registerExtensionModule();
 306 #if OSL_DEBUG_LEVEL > 1
 307         xsltSetGenericDebugFunc(stderr, NULL);
 308         xsltDebugDumpExtensions(NULL);
 309 #endif
 310         OleHandler* oh = new OleHandler(m_transformer->getServiceFactory());
 311         if (styleSheet)
 312             {
 313                 tcontext = xsltNewTransformContext(styleSheet, doc);
 314                 tcontext->_private = static_cast<void *> (oh);
 315                 xsltQuoteUserParams(tcontext, &params[0]);
 316                 result = xsltApplyStylesheetUser(styleSheet, doc, 0, 0, 0,
 317                         tcontext);
 318             }
 319
 320         if (result)
 321             {
 322                 xmlCharEncodingHandlerPtr encoder = xmlGetCharEncodingHandler(
 323                         XML_CHAR_ENCODING_UTF8);
 324                 xmlOutputBufferPtr outBuf = xmlAllocOutputBuffer(encoder);
 325                 outBuf->context = static_cast<void *> (this);
 326                 outBuf->writecallback = &ParserOutputBufferCallback::on_write;
 327                 outBuf->closecallback = &ParserOutputBufferCallback::on_close;
 328                 xsltSaveResultTo(outBuf, result, styleSheet);
 329             }
 330         else
 331             {
 332                 xmlErrorPtr lastErr = xmlGetLastError();
 333                 OUString msg;
 334                 if (lastErr)
 335                     msg = OUString::createFromAscii(lastErr->message);
 336                 else
 337                     msg = OUString::createFromAscii(
 338                             "Unknown XSLT transformation error");
 339
 340                 m_transformer->error(msg);
 341             }
 342         closeOutput();
 343         delete(oh);
 344         xsltFreeStylesheet(styleSheet);
 345         xsltFreeTransformContext(tcontext);
 346         xmlFreeDoc(doc);
 347         xmlFreeDoc(result);
 348     }
 349
 350     void
 351     Reader::registerExtensionModule()
 352     {
 353         const xmlChar* oleModuleURI = (const xmlChar *) EXT_MODULE_OLE_URI;
 354         xsltRegisterExtModule(oleModuleURI, &ExtFuncOleCB::init, NULL);
 355         xsltRegisterExtModuleFunction(
 356                                  (const xmlChar*) "insertByName",
 357                                  oleModuleURI,
 358                                  &ExtFuncOleCB::insertByName);
 359         xsltRegisterExtModuleFunction(
 360                                 (const xmlChar*) "getByName",
 361                                 oleModuleURI,
 362                                  &ExtFuncOleCB::getByName);
 363
 364     }
 365
 366     Reader::~Reader()
 367     {
 368     }
 369
 370     LibXSLTTransformer::LibXSLTTransformer(
 371             const css::uno::Reference<XMultiServiceFactory> &r) :
 372         m_rServiceFactory(r)
 373     {
 374     }
 375
 376     void
 377     LibXSLTTransformer::setInputStream(
 378             const css::uno::Reference<XInputStream>& inputStream)
 379             throw (RuntimeException)
 380     {
 381         m_rInputStream = inputStream;
 382     }
 383
 384     css::uno::Reference<XInputStream>
 385     LibXSLTTransformer::getInputStream() throw (RuntimeException)
 386     {
 387         return m_rInputStream;
 388     }
 389
 390     void
 391     LibXSLTTransformer::setOutputStream(
 392             const css::uno::Reference<XOutputStream>& outputStream)
 393             throw (RuntimeException)
 394     {
 395         m_rOutputStream = outputStream;
 396     }
 397
 398     css::uno::Reference<XOutputStream>
 399     LibXSLTTransformer::getOutputStream() throw (RuntimeException)
 400     {
 401         return m_rOutputStream;
 402     }
 403
 404     void
 405     LibXSLTTransformer::addListener(const css::uno::Reference<XStreamListener>& listener)
 406             throw (RuntimeException)
 407     {
 408         m_listeners.insert(m_listeners.begin(), listener);
 409     }
 410
 411     void
 412     LibXSLTTransformer::removeListener(
 413             const css::uno::Reference<XStreamListener>& listener)
 414             throw (RuntimeException)
 415     {
 416         m_listeners.remove(listener);
 417     }
 418
 419     void
 420     LibXSLTTransformer::start() throw (RuntimeException)
 421     {
 422         ListenerList::iterator it;
 423         ListenerList* l = &m_listeners;
 424         for (it = l->begin(); it != l->end(); ++it)
 425             {
 426                 css::uno::Reference<XStreamListener> xl = *it;
 427                 xl.get()->started();
 428             }
 429         OSL_ENSURE(!m_Reader.is(), "Somebody forgot to call terminate *and* holds a reference to this LibXSLTTransformer instance");
 430         m_Reader = new Reader(this);
 431         m_Reader->launch();
 432     }
 433
 434     void
 435     LibXSLTTransformer::error(const OUString& msg)
 436     {
 437         ListenerList* l = &m_listeners;
 438         Any arg;
 439         arg <<= Exception(msg, *this);
 440         for (ListenerList::iterator it = l->begin(); it != l->end(); ++it)
 441             {
 442                 css::uno::Reference<XStreamListener> xl = *it;
 443                 if (xl.is())
 444                     {
 445                         xl.get()->error(arg);
 446                     }
 447             }
 448     }
 449
 450     void
 451     LibXSLTTransformer::done()
 452     {
 453         ListenerList* l = &m_listeners;
 454         for (ListenerList::iterator it = l->begin(); it != l->end(); ++it)
 455             {
 456                 css::uno::Reference<XStreamListener> xl = *it;
 457                 if (xl.is())
 458                     {
 459                         xl.get()->closed();
 460                     }
 461             }
 462     }
 463
 464     void
 465     LibXSLTTransformer::terminate() throw (RuntimeException)
 466     {
 467         m_Reader->terminate();
 468         m_Reader->join();
 469         m_Reader.clear();
 470         m_parameters.clear();
 471     }
 472
 473     void
 474     LibXSLTTransformer::initialize(const Sequence<Any>& args)
 475             throw (RuntimeException)
 476     {
 477         Sequence<Any> params;
 478         if (!(args[0] >>= params))
 479         {   // backward compatibility for old clients using createInstance
 480             params = args;
 481         }
 482         xmlSubstituteEntitiesDefault(0);
 483         m_parameters.clear();
 484         for (int i = 0; i < params.getLength(); i++)
 485             {
 486                 NamedValue nv;
 487                 params[i] >>= nv;
 488                 OString nameUTF8 = OUStringToOString(nv.Name,
 489                         RTL_TEXTENCODING_UTF8);
 490                 OUString value;
 491                 OString valueUTF8;
 492                 if (nv.Value >>= value)
 493                     {
 494                         valueUTF8 = OUStringToOString(value,
 495                                 RTL_TEXTENCODING_UTF8);
 496                     }
 497                 else
 498                     {
 499                         // ignore non-string parameters
 500                         continue;
 501                     }
 502                 if (nameUTF8.equals("StylesheetURL"))
 503                     {
 504                         m_styleSheetURL = valueUTF8;
 505                     }
 506                 else if (nameUTF8.equals("SourceURL"))
 507                     {
 508                         m_parameters.insert(pair<const char*, OString> (
 509                                 PARAM_SOURCE_URL, valueUTF8));
 510                     }
 511                 else if (nameUTF8.equals("SourceBaseURL"))
 512                     {
 513                         m_parameters.insert(pair<const char*, OString> (
 514                                 PARAM_SOURCE_BASE_URL, valueUTF8));
 515                     }
 516                 else if (nameUTF8.equals("TargetURL"))
 517                     {
 518                         m_parameters.insert(pair<const char*, OString> (
 519                                 PARAM_TARGET_URL, valueUTF8));
 520                     }
 521                 else if (nameUTF8.equals("TargetBaseURL"))
 522                     {
 523                         m_parameters.insert(pair<const char*, OString> (
 524                                 PARAM_TARGET_BASE_URL, valueUTF8));
 525                     }
 526                 else if (nameUTF8.equals("DoctypePublic"))
 527                     {
 528                         m_parameters.insert(pair<const char*, OString> (
 529                                 PARAM_DOCTYPE_PUBLIC, valueUTF8));
 530                     }
 531             }
 532     }
 533
 534     const OString
 535     LibXSLTTransformer::getStyleSheetURL()
 536     {
 537         return m_styleSheetURL;
 538     }
 539
 540     ::std::map<const char*, OString>
 541     LibXSLTTransformer::getParameters()
 542     {
 543         return m_parameters;
 544     }
 545 }
 546 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
 547