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