dll/3rdparty/libxslt/documents.c

   1 /*
   2  * documents.c: Implementation of the documents handling
   3  *
   4  * See Copyright for the status of this software.
   5  *
   6  * daniel@veillard.com
   7  */
   8
   9 #define IN_LIBXSLT
  10 #include "libxslt.h"
  11
  12 #include <string.h>
  13
  14 #include <libxml/xmlmemory.h>
  15 #include <libxml/tree.h>
  16 #include <libxml/hash.h>
  17 #include <libxml/parser.h>
  18 #include <libxml/parserInternals.h>
  19 #include "xslt.h"
  20 #include "xsltInternals.h"
  21 #include "xsltutils.h"
  22 #include "documents.h"
  23 #include "transform.h"
  24 #include "imports.h"
  25 #include "keys.h"
  26 #include "security.h"
  27
  28 #ifdef LIBXML_XINCLUDE_ENABLED
  29 #include <libxml/xinclude.h>
  30 #endif
  31
  32 #define WITH_XSLT_DEBUG_DOCUMENTS
  33
  34 #ifdef WITH_XSLT_DEBUG
  35 #define WITH_XSLT_DEBUG_DOCUMENTS
  36 #endif
  37
  38 /************************************************************************
  39  *                                                                      *
  40  *              Hooks for the document loader                           *
  41  *                                                                      *
  42  ************************************************************************/
  43
  44 /**
  45  * xsltDocDefaultLoaderFunc:
  46  * @URI: the URI of the document to load
  47  * @dict: the dictionary to use when parsing that document
  48  * @options: parsing options, a set of xmlParserOption
  49  * @ctxt: the context, either a stylesheet or a transformation context
  50  * @type: the xsltLoadType indicating the kind of loading required
  51  *
  52  * Default function to load document not provided by the compilation or
  53  * transformation API themselve, for example when an xsl:import,
  54  * xsl:include is found at compilation time or when a document()
  55  * call is made at runtime.
  56  *
  57  * Returns the pointer to the document (which will be modified and
  58  * freed by the engine later), or NULL in case of error.
  59  */
  60 static xmlDocPtr
  61 xsltDocDefaultLoaderFunc(const xmlChar * URI, xmlDictPtr dict, int options,
  62                          void *ctxt ATTRIBUTE_UNUSED,
  63                          xsltLoadType type ATTRIBUTE_UNUSED)
  64 {
  65     xmlParserCtxtPtr pctxt;
  66     xmlParserInputPtr inputStream;
  67     xmlDocPtr doc;
  68
  69     pctxt = xmlNewParserCtxt();
  70     if (pctxt == NULL)
  71         return(NULL);
  72     if ((dict != NULL) && (pctxt->dict != NULL)) {
  73         xmlDictFree(pctxt->dict);
  74         pctxt->dict = NULL;
  75     }
  76     if (dict != NULL) {
  77         pctxt->dict = dict;
  78         xmlDictReference(pctxt->dict);
  79 #ifdef WITH_XSLT_DEBUG
  80         xsltGenericDebug(xsltGenericDebugContext,
  81                      "Reusing dictionary for document\n");
  82 #endif
  83     }
  84     xmlCtxtUseOptions(pctxt, options);
  85     inputStream = xmlLoadExternalEntity((const char *) URI, NULL, pctxt);
  86     if (inputStream == NULL) {
  87         xmlFreeParserCtxt(pctxt);
  88         return(NULL);
  89     }
  90     inputPush(pctxt, inputStream);
  91     if (pctxt->directory == NULL)
  92         pctxt->directory = xmlParserGetDirectory((const char *) URI);
  93
  94     xmlParseDocument(pctxt);
  95
  96     if (pctxt->wellFormed) {
  97         doc = pctxt->myDoc;
  98     }
  99     else {
 100         doc = NULL;
 101         xmlFreeDoc(pctxt->myDoc);
 102         pctxt->myDoc = NULL;
 103     }
 104     xmlFreeParserCtxt(pctxt);
 105
 106     return(doc);
 107 }
 108
 109
 110 xsltDocLoaderFunc xsltDocDefaultLoader = xsltDocDefaultLoaderFunc;
 111
 112 /**
 113  * xsltSetLoaderFunc:
 114  * @f: the new function to handle document loading.
 115  *
 116  * Set the new function to load document, if NULL it resets it to the
 117  * default function.
 118  */
 119
 120 void
 121 xsltSetLoaderFunc(xsltDocLoaderFunc f) {
 122     if (f == NULL)
 123         xsltDocDefaultLoader = xsltDocDefaultLoaderFunc;
 124     else
 125         xsltDocDefaultLoader = f;
 126 }
 127
 128 /************************************************************************
 129  *                                                                      *
 130  *                      Module interfaces                               *
 131  *                                                                      *
 132  ************************************************************************/
 133
 134 /**
 135  * xsltNewDocument:
 136  * @ctxt: an XSLT transformation context (or NULL)
 137  * @doc:  a parsed XML document
 138  *
 139  * Register a new document, apply key computations
 140  *
 141  * Returns a handler to the document
 142  */
 143 xsltDocumentPtr
 144 xsltNewDocument(xsltTransformContextPtr ctxt, xmlDocPtr doc) {
 145     xsltDocumentPtr cur;
 146
 147     cur = (xsltDocumentPtr) xmlMalloc(sizeof(xsltDocument));
 148     if (cur == NULL) {
 149         xsltTransformError(ctxt, NULL, (xmlNodePtr) doc,
 150                 "xsltNewDocument : malloc failed\n");
 151         return(NULL);
 152     }
 153     memset(cur, 0, sizeof(xsltDocument));
 154     cur->doc = doc;
 155     if (ctxt != NULL) {
 156         if (! XSLT_IS_RES_TREE_FRAG(doc)) {
 157             cur->next = ctxt->docList;
 158             ctxt->docList = cur;
 159         }
 160         /*
 161         * A key with a specific name for a specific document
 162         * will only be computed if there's a call to the key()
 163         * function using that specific name for that specific
 164         * document. I.e. computation of keys will be done in
 165         * xsltGetKey() (keys.c) on an on-demand basis.
 166         *
 167         * xsltInitCtxtKeys(ctxt, cur); not called here anymore
 168         */
 169     }
 170     return(cur);
 171 }
 172
 173 /**
 174  * xsltNewStyleDocument:
 175  * @style: an XSLT style sheet
 176  * @doc:  a parsed XML document
 177  *
 178  * Register a new document, apply key computations
 179  *
 180  * Returns a handler to the document
 181  */
 182 xsltDocumentPtr
 183 xsltNewStyleDocument(xsltStylesheetPtr style, xmlDocPtr doc) {
 184     xsltDocumentPtr cur;
 185
 186     cur = (xsltDocumentPtr) xmlMalloc(sizeof(xsltDocument));
 187     if (cur == NULL) {
 188         xsltTransformError(NULL, style, (xmlNodePtr) doc,
 189                 "xsltNewStyleDocument : malloc failed\n");
 190         return(NULL);
 191     }
 192     memset(cur, 0, sizeof(xsltDocument));
 193     cur->doc = doc;
 194     if (style != NULL) {
 195         cur->next = style->docList;
 196         style->docList = cur;
 197     }
 198     return(cur);
 199 }
 200
 201 /**
 202  * xsltFreeStyleDocuments:
 203  * @style: an XSLT stylesheet (representing a stylesheet-level)
 204  *
 205  * Frees the node-trees (and xsltDocument structures) of all
 206  * stylesheet-modules of the stylesheet-level represented by
 207  * the given @style.
 208  */
 209 void
 210 xsltFreeStyleDocuments(xsltStylesheetPtr style) {
 211     xsltDocumentPtr doc, cur;
 212 #ifdef XSLT_REFACTORED_XSLT_NSCOMP
 213     xsltNsMapPtr nsMap;
 214 #endif
 215
 216     if (style == NULL)
 217         return;
 218
 219 #ifdef XSLT_REFACTORED_XSLT_NSCOMP
 220     if (XSLT_HAS_INTERNAL_NSMAP(style))
 221         nsMap = XSLT_GET_INTERNAL_NSMAP(style);
 222     else
 223         nsMap = NULL;
 224 #endif
 225
 226     cur = style->docList;
 227     while (cur != NULL) {
 228         doc = cur;
 229         cur = cur->next;
 230 #ifdef XSLT_REFACTORED_XSLT_NSCOMP
 231         /*
 232         * Restore all changed namespace URIs of ns-decls.
 233         */
 234         if (nsMap)
 235             xsltRestoreDocumentNamespaces(nsMap, doc->doc);
 236 #endif
 237         xsltFreeDocumentKeys(doc);
 238         if (!doc->main)
 239             xmlFreeDoc(doc->doc);
 240         xmlFree(doc);
 241     }
 242 }
 243
 244 /**
 245  * xsltFreeDocuments:
 246  * @ctxt: an XSLT transformation context
 247  *
 248  * Free up all the space used by the loaded documents
 249  */
 250 void
 251 xsltFreeDocuments(xsltTransformContextPtr ctxt) {
 252     xsltDocumentPtr doc, cur;
 253
 254     cur = ctxt->docList;
 255     while (cur != NULL) {
 256         doc = cur;
 257         cur = cur->next;
 258         xsltFreeDocumentKeys(doc);
 259         if (!doc->main)
 260             xmlFreeDoc(doc->doc);
 261         xmlFree(doc);
 262     }
 263     cur = ctxt->styleList;
 264     while (cur != NULL) {
 265         doc = cur;
 266         cur = cur->next;
 267         xsltFreeDocumentKeys(doc);
 268         if (!doc->main)
 269             xmlFreeDoc(doc->doc);
 270         xmlFree(doc);
 271     }
 272 }
 273
 274 /**
 275  * xsltLoadDocument:
 276  * @ctxt: an XSLT transformation context
 277  * @URI:  the computed URI of the document
 278  *
 279  * Try to load a document (not a stylesheet)
 280  * within the XSLT transformation context
 281  *
 282  * Returns the new xsltDocumentPtr or NULL in case of error
 283  */
 284 xsltDocumentPtr
 285 xsltLoadDocument(xsltTransformContextPtr ctxt, const xmlChar *URI) {
 286     xsltDocumentPtr ret;
 287     xmlDocPtr doc;
 288
 289     if ((ctxt == NULL) || (URI == NULL))
 290         return(NULL);
 291
 292     /*
 293      * Security framework check
 294      */
 295     if (ctxt->sec != NULL) {
 296         int res;
 297
 298         res = xsltCheckRead(ctxt->sec, ctxt, URI);
 299         if (res == 0) {
 300             xsltTransformError(ctxt, NULL, NULL,
 301                  "xsltLoadDocument: read rights for %s denied\n",
 302                              URI);
 303             return(NULL);
 304         }
 305     }
 306
 307     /*
 308      * Walk the context list to find the document if preparsed
 309      */
 310     ret = ctxt->docList;
 311     while (ret != NULL) {
 312         if ((ret->doc != NULL) && (ret->doc->URL != NULL) &&
 313             (xmlStrEqual(ret->doc->URL, URI)))
 314             return(ret);
 315         ret = ret->next;
 316     }
 317
 318     doc = xsltDocDefaultLoader(URI, ctxt->dict, ctxt->parserOptions,
 319                                (void *) ctxt, XSLT_LOAD_DOCUMENT);
 320
 321     if (doc == NULL)
 322         return(NULL);
 323
 324     if (ctxt->xinclude != 0) {
 325 #ifdef LIBXML_XINCLUDE_ENABLED
 326 #if LIBXML_VERSION >= 20603
 327         xmlXIncludeProcessFlags(doc, ctxt->parserOptions);
 328 #else
 329         xmlXIncludeProcess(doc);
 330 #endif
 331 #else
 332         xsltTransformError(ctxt, NULL, NULL,
 333             "xsltLoadDocument(%s) : XInclude processing not compiled in\n",
 334                          URI);
 335 #endif
 336     }
 337     /*
 338      * Apply white-space stripping if asked for
 339      */
 340     if (xsltNeedElemSpaceHandling(ctxt))
 341         xsltApplyStripSpaces(ctxt, xmlDocGetRootElement(doc));
 342     if (ctxt->debugStatus == XSLT_DEBUG_NONE)
 343         xmlXPathOrderDocElems(doc);
 344
 345     ret = xsltNewDocument(ctxt, doc);
 346     return(ret);
 347 }
 348
 349 /**
 350  * xsltLoadStyleDocument:
 351  * @style: an XSLT style sheet
 352  * @URI:  the computed URI of the document
 353  *
 354  * Try to load a stylesheet document within the XSLT transformation context
 355  *
 356  * Returns the new xsltDocumentPtr or NULL in case of error
 357  */
 358 xsltDocumentPtr
 359 xsltLoadStyleDocument(xsltStylesheetPtr style, const xmlChar *URI) {
 360     xsltDocumentPtr ret;
 361     xmlDocPtr doc;
 362     xsltSecurityPrefsPtr sec;
 363
 364     if ((style == NULL) || (URI == NULL))
 365         return(NULL);
 366
 367     /*
 368      * Security framework check
 369      */
 370     sec = xsltGetDefaultSecurityPrefs();
 371     if (sec != NULL) {
 372         int res;
 373
 374         res = xsltCheckRead(sec, NULL, URI);
 375         if (res == 0) {
 376             xsltTransformError(NULL, NULL, NULL,
 377                  "xsltLoadStyleDocument: read rights for %s denied\n",
 378                              URI);
 379             return(NULL);
 380         }
 381     }
 382
 383     /*
 384      * Walk the context list to find the document if preparsed
 385      */
 386     ret = style->docList;
 387     while (ret != NULL) {
 388         if ((ret->doc != NULL) && (ret->doc->URL != NULL) &&
 389             (xmlStrEqual(ret->doc->URL, URI)))
 390             return(ret);
 391         ret = ret->next;
 392     }
 393
 394     doc = xsltDocDefaultLoader(URI, style->dict, XSLT_PARSE_OPTIONS,
 395                                (void *) style, XSLT_LOAD_STYLESHEET);
 396     if (doc == NULL)
 397         return(NULL);
 398
 399     ret = xsltNewStyleDocument(style, doc);
 400     return(ret);
 401 }
 402
 403 /**
 404  * xsltFindDocument:
 405  * @ctxt: an XSLT transformation context
 406  * @doc: a parsed XML document
 407  *
 408  * Try to find a document within the XSLT transformation context.
 409  * This will not find document infos for temporary
 410  * Result Tree Fragments.
 411  *
 412  * Returns the desired xsltDocumentPtr or NULL in case of error
 413  */
 414 xsltDocumentPtr
 415 xsltFindDocument (xsltTransformContextPtr ctxt, xmlDocPtr doc) {
 416     xsltDocumentPtr ret;
 417
 418     if ((ctxt == NULL) || (doc == NULL))
 419         return(NULL);
 420
 421     /*
 422      * Walk the context list to find the document
 423      */
 424     ret = ctxt->docList;
 425     while (ret != NULL) {
 426         if (ret->doc == doc)
 427             return(ret);
 428         ret = ret->next;
 429     }
 430     if (doc == ctxt->style->doc)
 431         return(ctxt->document);
 432     return(NULL);
 433 }
 434