unoxml/source/xpath/xpathapi.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 "xpathapi.hxx"
  21
  22 #include <stdarg.h>
  23 #include <string.h>
  24
  25 #include <libxml/tree.h>
  26 #include <libxml/xmlerror.h>
  27 #include <libxml/xpath.h>
  28 #include <libxml/xpathInternals.h>
  29
  30 #include <com/sun/star/xml/xpath/XPathException.hpp>
  31
  32 #include <rtl/ustrbuf.hxx>
  33 #include <sal/log.hxx>
  34
  35 #include "xpathobject.hxx"
  36
  37 #include <node.hxx>
  38 #include "../dom/document.hxx"
  39
  40 #include <comphelper/servicehelper.hxx>
  41 #include <cppuhelper/supportsservice.hxx>
  42
  43 using namespace css::io;
  44 using namespace css::uno;
  45 using namespace css::xml::dom;
  46 using namespace css::xml::xpath;
  47
  48 namespace XPath
  49 {
  50     // ctor
  51     CXPathAPI::CXPathAPI(const Reference< XComponentContext >& rxContext)
  52         : m_xContext(rxContext)
  53     {
  54     }
  55
  56     Sequence< OUString > SAL_CALL CXPathAPI::getSupportedServiceNames()
  57     {
  58         return { "com.sun.star.xml.xpath.XPathAPI" };
  59     }
  60
  61     OUString SAL_CALL CXPathAPI::getImplementationName()
  62     {
  63         return "com.sun.star.comp.xml.xpath.XPathAPI";
  64     }
  65
  66     sal_Bool SAL_CALL CXPathAPI::supportsService(const OUString& aServiceName)
  67     {
  68         return cppu::supportsService(this, aServiceName);
  69     }
  70
  71     void SAL_CALL CXPathAPI::registerNS(
  72             const OUString& aPrefix,
  73             const OUString& aURI)
  74     {
  75         std::scoped_lock const g(m_Mutex);
  76
  77         m_nsmap.emplace(aPrefix, aURI);
  78     }
  79
  80     void SAL_CALL CXPathAPI::unregisterNS(
  81             const OUString& aPrefix,
  82             const OUString& aURI)
  83     {
  84         std::scoped_lock const g(m_Mutex);
  85
  86         if ((m_nsmap.find(aPrefix))->second == aURI) {
  87             m_nsmap.erase(aPrefix);
  88         }
  89     }
  90
  91     // register all namespaces stored in the namespace list for this object
  92     // with the current xpath evaluation context
  93     static void lcl_registerNamespaces(
  94             xmlXPathContextPtr ctx,
  95             const nsmap_t& nsmap)
  96     {
  97         OString oprefix, ouri;
  98         for (const auto& rEntry : nsmap)
  99         {
 100             oprefix = OUStringToOString(rEntry.first,  RTL_TEXTENCODING_UTF8);
 101             ouri    = OUStringToOString(rEntry.second, RTL_TEXTENCODING_UTF8);
 102             xmlChar const *p = reinterpret_cast<xmlChar const *>(oprefix.getStr());
 103             xmlChar const *u = reinterpret_cast<xmlChar const *>(ouri.getStr());
 104             (void)xmlXPathRegisterNs(ctx, p, u);
 105         }
 106     }
 107
 108     // get all ns decls on a node (and parent nodes, if any)
 109     static void lcl_collectNamespaces(
 110             nsmap_t & rNamespaces, Reference< XNode > const& xNamespaceNode)
 111     {
 112         DOM::CNode *const pCNode(comphelper::getFromUnoTunnel<DOM::CNode>(xNamespaceNode));
 113         if (!pCNode) { throw RuntimeException(); }
 114
 115         ::osl::MutexGuard const g(pCNode->GetOwnerDocument().GetMutex());
 116
 117         xmlNodePtr pNode = pCNode->GetNodePtr();
 118         while (pNode != nullptr) {
 119             xmlNsPtr curDef = pNode->nsDef;
 120             while (curDef != nullptr) {
 121                 const xmlChar* pHref = curDef->href;
 122                 OUString aURI(reinterpret_cast<char const *>(pHref), strlen(reinterpret_cast<char const *>(pHref)), RTL_TEXTENCODING_UTF8);
 123                 const xmlChar* pPre = curDef->prefix;
 124                 OUString aPrefix(reinterpret_cast<char const *>(pPre), strlen(reinterpret_cast<char const *>(pPre)), RTL_TEXTENCODING_UTF8);
 125                 // we could already have this prefix from a child node
 126                 rNamespaces.emplace(aPrefix, aURI);
 127                 curDef = curDef->next;
 128             }
 129             pNode = pNode->parent;
 130         }
 131     }
 132
 133     static void lcl_collectRegisterNamespaces(
 134             CXPathAPI & rAPI, Reference< XNode > const& xNamespaceNode)
 135     {
 136         nsmap_t namespaces;
 137         lcl_collectNamespaces(namespaces, xNamespaceNode);
 138         for (const auto& rEntry : namespaces)
 139         {
 140             rAPI.registerNS(rEntry.first, rEntry.second);
 141         }
 142     }
 143
 144     // register function and variable lookup functions with the current
 145     // xpath evaluation context
 146     static void lcl_registerExtensions(
 147             xmlXPathContextPtr ctx,
 148             const extensions_t& extensions)
 149     {
 150         for (const auto& rExtensionRef : extensions)
 151         {
 152             Libxml2ExtensionHandle aHandle = rExtensionRef->getLibxml2ExtensionHandle();
 153             if ( aHandle.functionLookupFunction != 0 )
 154             {
 155                 xmlXPathRegisterFuncLookup(ctx,
 156                     reinterpret_cast<xmlXPathFuncLookupFunc>(
 157                         sal::static_int_cast<sal_IntPtr>(aHandle.functionLookupFunction)),
 158                     reinterpret_cast<void*>(
 159                         sal::static_int_cast<sal_IntPtr>(aHandle.functionData)));
 160             }
 161             if ( aHandle.variableLookupFunction != 0 )
 162             {
 163                 xmlXPathRegisterVariableLookup(ctx,
 164                     reinterpret_cast<xmlXPathVariableLookupFunc>(
 165                         sal::static_int_cast<sal_IntPtr>(aHandle.variableLookupFunction)),
 166                     reinterpret_cast<void*>(
 167                         sal::static_int_cast<sal_IntPtr>(aHandle.variableData)));
 168             }
 169         }
 170     }
 171
 172     /**
 173      * Use an XPath string to select a nodelist.
 174      */
 175     Reference< XNodeList > SAL_CALL CXPathAPI::selectNodeList(
 176             const Reference< XNode >& contextNode,
 177             const OUString& expr)
 178     {
 179         Reference< XXPathObject > xobj = eval(contextNode, expr);
 180         return xobj->getNodeList();
 181     }
 182
 183     /**
 184      * same as selectNodeList but registers all name space declarations found on namespaceNode
 185      */
 186     Reference< XNodeList > SAL_CALL CXPathAPI::selectNodeListNS(
 187             const Reference< XNode >&  contextNode,
 188             const OUString& expr,
 189             const Reference< XNode >&  namespaceNode)
 190     {
 191         lcl_collectRegisterNamespaces(*this, namespaceNode);
 192         return selectNodeList(contextNode, expr);
 193     }
 194
 195     /**
 196      * Same as selectNodeList but returns the first node (if any)
 197      */
 198     Reference< XNode > SAL_CALL CXPathAPI::selectSingleNode(
 199             const Reference< XNode >& contextNode,
 200             const OUString& expr)
 201     {
 202         Reference< XNodeList > aList = selectNodeList(contextNode, expr);
 203         Reference< XNode > aNode = aList->item(0);
 204         return aNode;
 205     }
 206
 207     /**
 208      * Same as selectSingleNode but registers all namespaces declared on
 209      * namespaceNode
 210      */
 211     Reference< XNode > SAL_CALL CXPathAPI::selectSingleNodeNS(
 212             const Reference< XNode >& contextNode,
 213             const OUString& expr,
 214             const Reference< XNode >&  namespaceNode )
 215     {
 216         lcl_collectRegisterNamespaces(*this, namespaceNode);
 217         return selectSingleNode(contextNode, expr);
 218     }
 219
 220     static OUString make_error_message(xmlErrorPtr pError)
 221     {
 222         OUStringBuffer buf;
 223         if (pError) {
 224             if (pError->message) {
 225                 buf.appendAscii(pError->message);
 226             }
 227             int line = pError->line;
 228             if (line) {
 229                 buf.append("Line: ");
 230                 buf.append(static_cast<sal_Int32>(line));
 231                 buf.append("\n");
 232             }
 233             int column = pError->int2;
 234             if (column) {
 235                 buf.append("Column: ");
 236                 buf.append(static_cast<sal_Int32>(column));
 237                 buf.append("\n");
 238             }
 239         } else {
 240             buf.append("no error argument!");
 241         }
 242         OUString msg = buf.makeStringAndClear();
 243         return msg;
 244     }
 245
 246     extern "C" {
 247
 248 #if defined __GNUC__
 249         __attribute__ ((format (printf, 2, 3)))
 250 #endif
 251         static void generic_error_func(void *, const char *format, ...)
 252         {
 253             char str[1000];
 254             va_list args;
 255
 256             va_start(args, format);
 257 #ifdef _WIN32
 258 #define vsnprintf _vsnprintf
 259 #endif
 260             vsnprintf(str, sizeof(str), format, args);
 261             va_end(args);
 262
 263             SAL_WARN("unoxml", "libxml2 error: " << str);
 264         }
 265
 266         static void structured_error_func(void *, xmlErrorPtr error)
 267         {
 268             SAL_WARN("unoxml", "libxml2 error: " << make_error_message(error));
 269         }
 270
 271     } // extern "C"
 272
 273     /**
 274      * evaluates an XPath string. relative XPath expressions are evaluated relative to
 275      * the context Node
 276      */
 277     Reference< XXPathObject > SAL_CALL CXPathAPI::eval(
 278             Reference< XNode > const& xContextNode,
 279             const OUString& expr)
 280     {
 281         if (!xContextNode.is()) { throw RuntimeException(); }
 282
 283         nsmap_t nsmap;
 284         extensions_t extensions;
 285
 286         {
 287             std::scoped_lock const g(m_Mutex);
 288             nsmap = m_nsmap;
 289             extensions = m_extensions;
 290         }
 291
 292         // get the node and document
 293         ::rtl::Reference<DOM::CDocument> const pCDoc(
 294                 dynamic_cast<DOM::CDocument*>( comphelper::getFromUnoTunnel<DOM::CNode>(
 295                         xContextNode->getOwnerDocument())));
 296         if (!pCDoc.is()) { throw RuntimeException(); }
 297
 298         DOM::CNode *const pCNode = comphelper::getFromUnoTunnel<DOM::CNode>(xContextNode);
 299         if (!pCNode) { throw RuntimeException(); }
 300
 301         ::osl::MutexGuard const g(pCDoc->GetMutex()); // lock the document!
 302
 303         xmlNodePtr const pNode = pCNode->GetNodePtr();
 304         if (!pNode) { throw RuntimeException(); }
 305         xmlDocPtr pDoc = pNode->doc;
 306
 307         /* NB: workaround for #i87252#:
 308            libxml < 2.6.17 considers it an error if the context
 309            node is the empty document (i.e. its xpathCtx->doc has no
 310            children). libxml 2.6.17 does not consider it an error.
 311            Unfortunately, old libxml prints an error message to stderr,
 312            which (afaik) cannot be turned off in this case, so we handle it.
 313         */
 314         if (!pDoc->children) {
 315             throw XPathException();
 316         }
 317
 318         /* Create xpath evaluation context */
 319         std::shared_ptr<xmlXPathContext> const xpathCtx(
 320                 xmlXPathNewContext(pDoc), xmlXPathFreeContext);
 321         if (xpathCtx == nullptr) { throw XPathException(); }
 322
 323         // set context node
 324         xpathCtx->node = pNode;
 325         // error handling
 326         xpathCtx->error = structured_error_func;
 327         xmlSetGenericErrorFunc(nullptr, generic_error_func);
 328
 329         // register namespaces and extension
 330         lcl_registerNamespaces(xpathCtx.get(), nsmap);
 331         lcl_registerExtensions(xpathCtx.get(), extensions);
 332
 333         /* run the query */
 334         OString o1 = OUStringToOString(expr, RTL_TEXTENCODING_UTF8);
 335         xmlChar const *pStr = reinterpret_cast<xmlChar const *>(o1.getStr());
 336         std::shared_ptr<xmlXPathObject> const xpathObj(
 337                 xmlXPathEval(pStr, xpathCtx.get()), xmlXPathFreeObject);
 338         xmlSetGenericErrorFunc(nullptr, nullptr);
 339         if (nullptr == xpathObj) {
 340             // OSL_ENSURE(xpathCtx->lastError == NULL, xpathCtx->lastError->message);
 341             throw XPathException();
 342         }
 343         Reference<XXPathObject> const xObj(
 344                 new CXPathObject(pCDoc, pCDoc->GetMutex(), xpathObj));
 345         return xObj;
 346     }
 347
 348     /**
 349      * same as eval but registers all namespace declarations found on namespaceNode
 350      */
 351     Reference< XXPathObject > SAL_CALL CXPathAPI::evalNS(
 352             const Reference< XNode >& contextNode,
 353             const OUString& expr,
 354             const Reference< XNode >& namespaceNode)
 355     {
 356         lcl_collectRegisterNamespaces(*this, namespaceNode);
 357         return eval(contextNode, expr);
 358     }
 359
 360     /**
 361      * uses the service manager to create an instance of the service denoted by aName.
 362      * If the returned object implements the XXPathExtension interface, it is added to the list
 363      * of extensions that are used when evaluating XPath strings with this XPathAPI instance
 364      */
 365     void SAL_CALL CXPathAPI::registerExtension(
 366             const OUString& aName)
 367     {
 368         std::scoped_lock const g(m_Mutex);
 369
 370         // get extension from service manager
 371         Reference< XXPathExtension > const xExtension(
 372                 m_xContext->getServiceManager()->createInstanceWithContext(aName, m_xContext), UNO_QUERY_THROW);
 373         m_extensions.push_back(xExtension);
 374     }
 375
 376     /**
 377      * registers the given extension instance to be used by XPath evaluations performed through this
 378      * XPathAPI instance
 379      */
 380     void SAL_CALL CXPathAPI::registerExtensionInstance(
 381             Reference< XXPathExtension> const& xExtension)
 382     {
 383         if (!xExtension.is()) {
 384             throw RuntimeException();
 385         }
 386         std::scoped_lock const g(m_Mutex);
 387         m_extensions.push_back( xExtension );
 388     }
 389 }
 390
 391 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 392 unoxml_CXPathAPI_get_implementation(
 393     css::uno::XComponentContext* context , css::uno::Sequence<css::uno::Any> const&)
 394 {
 395     return cppu::acquire(new XPath::CXPathAPI(context));
 396 }
 397
 398 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */