Home | History | Annotate | Download | only in xml 
      1 /*
      2  * This file is part of the XSL implementation.
      3  *
      4  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple, Inc. All rights reserved.
      5  * Copyright (C) 2005, 2006 Alexey Proskuryakov <ap (at) webkit.org>
      6  *
      7  * This library is free software; you can redistribute it and/or
      8  * modify it under the terms of the GNU Library General Public
      9  * License as published by the Free Software Foundation; either
     10  * version 2 of the License, or (at your option) any later version.
     11  *
     12  * This library is distributed in the hope that it will be useful,
     13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
     14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     15  * Library General Public License for more details.
     16  *
     17  * You should have received a copy of the GNU Library General Public License
     18  * along with this library; see the file COPYING.LIB.  If not, write to
     19  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     20  * Boston, MA 02110-1301, USA.
     21  */
     22 
     23 #include "config.h"
     24 
     25 #if ENABLE(XSLT)
     26 
     27 #include "XSLTProcessor.h"
     28 
     29 #include "Console.h"
     30 #include "DOMWindow.h"
     31 #include "CachedResourceLoader.h"
     32 #include "Frame.h"
     33 #include "ResourceError.h"
     34 #include "ResourceHandle.h"
     35 #include "ResourceRequest.h"
     36 #include "ResourceResponse.h"
     37 #include "TransformSource.h"
     38 #include "XMLDocumentParser.h"
     39 #include "XSLStyleSheet.h"
     40 #include "XSLTExtensions.h"
     41 #include "XSLTUnicodeSort.h"
     42 #include "markup.h"
     43 #include <libxslt/imports.h>
     44 #include <libxslt/security.h>
     45 #include <libxslt/variables.h>
     46 #include <libxslt/xsltutils.h>
     47 #include <wtf/Assertions.h>
     48 #include <wtf/Vector.h>
     49 #include <wtf/text/CString.h>
     50 #include <wtf/text/StringBuffer.h>
     51 #include <wtf/unicode/UTF8.h>
     52 
     53 #if PLATFORM(MAC)
     54 #include "SoftLinking.h"
     55 
     56 SOFT_LINK_LIBRARY(libxslt);
     57 SOFT_LINK(libxslt, xsltFreeStylesheet, void, (xsltStylesheetPtr sheet), (sheet))
     58 SOFT_LINK(libxslt, xsltFreeTransformContext, void, (xsltTransformContextPtr ctxt), (ctxt))
     59 SOFT_LINK(libxslt, xsltNewTransformContext, xsltTransformContextPtr, (xsltStylesheetPtr style, xmlDocPtr doc), (style, doc))
     60 SOFT_LINK(libxslt, xsltApplyStylesheetUser, xmlDocPtr, (xsltStylesheetPtr style, xmlDocPtr doc, const char** params, const char* output, FILE* profile, xsltTransformContextPtr userCtxt), (style, doc, params, output, profile, userCtxt))
     61 SOFT_LINK(libxslt, xsltQuoteUserParams, int, (xsltTransformContextPtr ctxt, const char** params), (ctxt, params))
     62 SOFT_LINK(libxslt, xsltSetCtxtSortFunc, void, (xsltTransformContextPtr ctxt, xsltSortFunc handler), (ctxt, handler))
     63 SOFT_LINK(libxslt, xsltSetLoaderFunc, void, (xsltDocLoaderFunc f), (f))
     64 SOFT_LINK(libxslt, xsltSaveResultTo, int, (xmlOutputBufferPtr buf, xmlDocPtr result, xsltStylesheetPtr style), (buf, result, style))
     65 SOFT_LINK(libxslt, xsltNextImport, xsltStylesheetPtr, (xsltStylesheetPtr style), (style))
     66 SOFT_LINK(libxslt, xsltNewSecurityPrefs, xsltSecurityPrefsPtr, (), ())
     67 SOFT_LINK(libxslt, xsltFreeSecurityPrefs, void, (xsltSecurityPrefsPtr sec), (sec))
     68 SOFT_LINK(libxslt, xsltSetSecurityPrefs, int, (xsltSecurityPrefsPtr sec, xsltSecurityOption option, xsltSecurityCheck func), (sec, option, func))
     69 SOFT_LINK(libxslt, xsltSetCtxtSecurityPrefs, int, (xsltSecurityPrefsPtr sec, xsltTransformContextPtr ctxt), (sec, ctxt))
     70 SOFT_LINK(libxslt, xsltSecurityForbid, int, (xsltSecurityPrefsPtr sec, xsltTransformContextPtr ctxt, const char* value), (sec, ctxt, value))
     71 
     72 #endif
     73 
     74 namespace WebCore {
     75 
     76 void XSLTProcessor::genericErrorFunc(void*, const char*, ...)
     77 {
     78     // It would be nice to do something with this error message.
     79 }
     80 
     81 void XSLTProcessor::parseErrorFunc(void* userData, xmlError* error)
     82 {
     83     Console* console = static_cast<Console*>(userData);
     84     if (!console)
     85         return;
     86 
     87     MessageLevel level;
     88     switch (error->level) {
     89     case XML_ERR_NONE:
     90         level = TipMessageLevel;
     91         break;
     92     case XML_ERR_WARNING:
     93         level = WarningMessageLevel;
     94         break;
     95     case XML_ERR_ERROR:
     96     case XML_ERR_FATAL:
     97     default:
     98         level = ErrorMessageLevel;
     99         break;
    100     }
    101 
    102     console->addMessage(XMLMessageSource, LogMessageType, level, error->message, error->line, error->file);
    103 }
    104 
    105 // FIXME: There seems to be no way to control the ctxt pointer for loading here, thus we have globals.
    106 static XSLTProcessor* globalProcessor = 0;
    107 static CachedResourceLoader* globalCachedResourceLoader = 0;
    108 static xmlDocPtr docLoaderFunc(const xmlChar* uri,
    109                                xmlDictPtr,
    110                                int options,
    111                                void* ctxt,
    112                                xsltLoadType type)
    113 {
    114     if (!globalProcessor)
    115         return 0;
    116 
    117     switch (type) {
    118     case XSLT_LOAD_DOCUMENT: {
    119         xsltTransformContextPtr context = (xsltTransformContextPtr)ctxt;
    120         xmlChar* base = xmlNodeGetBase(context->document->doc, context->node);
    121         KURL url(KURL(ParsedURLString, reinterpret_cast<const char*>(base)), reinterpret_cast<const char*>(uri));
    122         xmlFree(base);
    123         ResourceError error;
    124         ResourceResponse response;
    125 
    126         Vector<char> data;
    127 
    128         bool requestAllowed = globalCachedResourceLoader->frame() && globalCachedResourceLoader->document()->securityOrigin()->canRequest(url);
    129         if (requestAllowed) {
    130             globalCachedResourceLoader->frame()->loader()->loadResourceSynchronously(url, AllowStoredCredentials, error, response, data);
    131             requestAllowed = globalCachedResourceLoader->document()->securityOrigin()->canRequest(response.url());
    132         }
    133         if (!requestAllowed) {
    134             data.clear();
    135             globalCachedResourceLoader->printAccessDeniedMessage(url);
    136         }
    137 
    138         Console* console = 0;
    139         if (Frame* frame = globalProcessor->xslStylesheet()->ownerDocument()->frame())
    140             console = frame->domWindow()->console();
    141         xmlSetStructuredErrorFunc(console, XSLTProcessor::parseErrorFunc);
    142         xmlSetGenericErrorFunc(console, XSLTProcessor::genericErrorFunc);
    143 
    144         // We don't specify an encoding here. Neither Gecko nor WinIE respects
    145         // the encoding specified in the HTTP headers.
    146         xmlDocPtr doc = xmlReadMemory(data.data(), data.size(), (const char*)uri, 0, options);
    147 
    148         xmlSetStructuredErrorFunc(0, 0);
    149         xmlSetGenericErrorFunc(0, 0);
    150 
    151         return doc;
    152     }
    153     case XSLT_LOAD_STYLESHEET:
    154         return globalProcessor->xslStylesheet()->locateStylesheetSubResource(((xsltStylesheetPtr)ctxt)->doc, uri);
    155     default:
    156         break;
    157     }
    158 
    159     return 0;
    160 }
    161 
    162 static inline void setXSLTLoadCallBack(xsltDocLoaderFunc func, XSLTProcessor* processor, CachedResourceLoader* cachedResourceLoader)
    163 {
    164     xsltSetLoaderFunc(func);
    165     globalProcessor = processor;
    166     globalCachedResourceLoader = cachedResourceLoader;
    167 }
    168 
    169 static int writeToVector(void* context, const char* buffer, int len)
    170 {
    171     Vector<UChar>& resultOutput = *static_cast<Vector<UChar>*>(context);
    172 
    173     if (!len)
    174         return 0;
    175 
    176     StringBuffer stringBuffer(len);
    177     UChar* bufferUChar = stringBuffer.characters();
    178     UChar* bufferUCharEnd = bufferUChar + len;
    179 
    180     const char* stringCurrent = buffer;
    181     WTF::Unicode::ConversionResult result = WTF::Unicode::convertUTF8ToUTF16(&stringCurrent, buffer + len, &bufferUChar, bufferUCharEnd);
    182     if (result != WTF::Unicode::conversionOK && result != WTF::Unicode::sourceExhausted) {
    183         ASSERT_NOT_REACHED();
    184         return -1;
    185     }
    186 
    187     int utf16Length = bufferUChar - stringBuffer.characters();
    188     resultOutput.append(stringBuffer.characters(), utf16Length);
    189     return stringCurrent - buffer;
    190 }
    191 
    192 static bool saveResultToString(xmlDocPtr resultDoc, xsltStylesheetPtr sheet, String& resultString)
    193 {
    194     xmlOutputBufferPtr outputBuf = xmlAllocOutputBuffer(0);
    195     if (!outputBuf)
    196         return false;
    197 
    198     Vector<UChar> resultVector;
    199     outputBuf->context = &resultVector;
    200     outputBuf->writecallback = writeToVector;
    201 
    202     int retval = xsltSaveResultTo(outputBuf, resultDoc, sheet);
    203     xmlOutputBufferClose(outputBuf);
    204     if (retval < 0)
    205         return false;
    206 
    207     // Workaround for <http://bugzilla.gnome.org/show_bug.cgi?id=495668>: libxslt appends an extra line feed to the result.
    208     if (resultVector.size() > 0 && resultVector[resultVector.size() - 1] == '\n')
    209         resultVector.removeLast();
    210 
    211     resultString = String::adopt(resultVector);
    212 
    213     return true;
    214 }
    215 
    216 static const char** xsltParamArrayFromParameterMap(XSLTProcessor::ParameterMap& parameters)
    217 {
    218     if (parameters.isEmpty())
    219         return 0;
    220 
    221     const char** parameterArray = (const char**)fastMalloc(((parameters.size() * 2) + 1) * sizeof(char*));
    222 
    223     XSLTProcessor::ParameterMap::iterator end = parameters.end();
    224     unsigned index = 0;
    225     for (XSLTProcessor::ParameterMap::iterator it = parameters.begin(); it != end; ++it) {
    226         parameterArray[index++] = fastStrDup(it->first.utf8().data());
    227         parameterArray[index++] = fastStrDup(it->second.utf8().data());
    228     }
    229     parameterArray[index] = 0;
    230 
    231     return parameterArray;
    232 }
    233 
    234 static void freeXsltParamArray(const char** params)
    235 {
    236     const char** temp = params;
    237     if (!params)
    238         return;
    239 
    240     while (*temp) {
    241         fastFree((void*)*(temp++));
    242         fastFree((void*)*(temp++));
    243     }
    244     fastFree(params);
    245 }
    246 
    247 static xsltStylesheetPtr xsltStylesheetPointer(RefPtr<XSLStyleSheet>& cachedStylesheet, Node* stylesheetRootNode)
    248 {
    249     if (!cachedStylesheet && stylesheetRootNode) {
    250         cachedStylesheet = XSLStyleSheet::createForXSLTProcessor(stylesheetRootNode->parentNode() ? stylesheetRootNode->parentNode() : stylesheetRootNode,
    251             stylesheetRootNode->document()->url().string(),
    252             stylesheetRootNode->document()->url()); // FIXME: Should we use baseURL here?
    253 
    254         // According to Mozilla documentation, the node must be a Document node, an xsl:stylesheet or xsl:transform element.
    255         // But we just use text content regardless of node type.
    256         cachedStylesheet->parseString(createMarkup(stylesheetRootNode));
    257     }
    258 
    259     if (!cachedStylesheet || !cachedStylesheet->document())
    260         return 0;
    261 
    262     return cachedStylesheet->compileStyleSheet();
    263 }
    264 
    265 static inline xmlDocPtr xmlDocPtrFromNode(Node* sourceNode, bool& shouldDelete)
    266 {
    267     RefPtr<Document> ownerDocument = sourceNode->document();
    268     bool sourceIsDocument = (sourceNode == ownerDocument.get());
    269 
    270     xmlDocPtr sourceDoc = 0;
    271     if (sourceIsDocument && ownerDocument->transformSource())
    272         sourceDoc = (xmlDocPtr)ownerDocument->transformSource()->platformSource();
    273     if (!sourceDoc) {
    274         sourceDoc = (xmlDocPtr)xmlDocPtrForString(ownerDocument->cachedResourceLoader(), createMarkup(sourceNode),
    275             sourceIsDocument ? ownerDocument->url().string() : String());
    276         shouldDelete = sourceDoc;
    277     }
    278     return sourceDoc;
    279 }
    280 
    281 static inline String resultMIMEType(xmlDocPtr resultDoc, xsltStylesheetPtr sheet)
    282 {
    283     // There are three types of output we need to be able to deal with:
    284     // HTML (create an HTML document), XML (create an XML document),
    285     // and text (wrap in a <pre> and create an XML document).
    286 
    287     const xmlChar* resultType = 0;
    288     XSLT_GET_IMPORT_PTR(resultType, sheet, method);
    289     if (!resultType && resultDoc->type == XML_HTML_DOCUMENT_NODE)
    290         resultType = (const xmlChar*)"html";
    291 
    292     if (xmlStrEqual(resultType, (const xmlChar*)"html"))
    293         return "text/html";
    294     if (xmlStrEqual(resultType, (const xmlChar*)"text"))
    295         return "text/plain";
    296 
    297     return "application/xml";
    298 }
    299 
    300 bool XSLTProcessor::transformToString(Node* sourceNode, String& mimeType, String& resultString, String& resultEncoding)
    301 {
    302     RefPtr<Document> ownerDocument = sourceNode->document();
    303 
    304     setXSLTLoadCallBack(docLoaderFunc, this, ownerDocument->cachedResourceLoader());
    305     xsltStylesheetPtr sheet = xsltStylesheetPointer(m_stylesheet, m_stylesheetRootNode.get());
    306     if (!sheet) {
    307         setXSLTLoadCallBack(0, 0, 0);
    308         return false;
    309     }
    310     m_stylesheet->clearDocuments();
    311 
    312     xmlChar* origMethod = sheet->method;
    313     if (!origMethod && mimeType == "text/html")
    314         sheet->method = (xmlChar*)"html";
    315 
    316     bool success = false;
    317     bool shouldFreeSourceDoc = false;
    318     if (xmlDocPtr sourceDoc = xmlDocPtrFromNode(sourceNode, shouldFreeSourceDoc)) {
    319         // The XML declaration would prevent parsing the result as a fragment, and it's not needed even for documents,
    320         // as the result of this function is always immediately parsed.
    321         sheet->omitXmlDeclaration = true;
    322 
    323         xsltTransformContextPtr transformContext = xsltNewTransformContext(sheet, sourceDoc);
    324         registerXSLTExtensions(transformContext);
    325 
    326         xsltSecurityPrefsPtr securityPrefs = xsltNewSecurityPrefs();
    327         // Read permissions are checked by docLoaderFunc.
    328         if (0 != xsltSetSecurityPrefs(securityPrefs, XSLT_SECPREF_WRITE_FILE, xsltSecurityForbid))
    329             CRASH();
    330         if (0 != xsltSetSecurityPrefs(securityPrefs, XSLT_SECPREF_CREATE_DIRECTORY, xsltSecurityForbid))
    331             CRASH();
    332         if (0 != xsltSetSecurityPrefs(securityPrefs, XSLT_SECPREF_WRITE_NETWORK, xsltSecurityForbid))
    333             CRASH();
    334         if (0 != xsltSetCtxtSecurityPrefs(securityPrefs, transformContext))
    335             CRASH();
    336 
    337         // <http://bugs.webkit.org/show_bug.cgi?id=16077>: XSLT processor <xsl:sort> algorithm only compares by code point.
    338         xsltSetCtxtSortFunc(transformContext, xsltUnicodeSortFunction);
    339 
    340         // This is a workaround for a bug in libxslt.
    341         // The bug has been fixed in version 1.1.13, so once we ship that this can be removed.
    342         if (!transformContext->globalVars)
    343            transformContext->globalVars = xmlHashCreate(20);
    344 
    345         const char** params = xsltParamArrayFromParameterMap(m_parameters);
    346         xsltQuoteUserParams(transformContext, params);
    347         xmlDocPtr resultDoc = xsltApplyStylesheetUser(sheet, sourceDoc, 0, 0, 0, transformContext);
    348 
    349         xsltFreeTransformContext(transformContext);
    350         xsltFreeSecurityPrefs(securityPrefs);
    351         freeXsltParamArray(params);
    352 
    353         if (shouldFreeSourceDoc)
    354             xmlFreeDoc(sourceDoc);
    355 
    356         if ((success = saveResultToString(resultDoc, sheet, resultString))) {
    357             mimeType = resultMIMEType(resultDoc, sheet);
    358             resultEncoding = (char*)resultDoc->encoding;
    359         }
    360         xmlFreeDoc(resultDoc);
    361     }
    362 
    363     sheet->method = origMethod;
    364     setXSLTLoadCallBack(0, 0, 0);
    365     xsltFreeStylesheet(sheet);
    366     m_stylesheet = 0;
    367 
    368     return success;
    369 }
    370 
    371 } // namespace WebCore
    372 
    373 #endif // ENABLE(XSLT)
    374