Home | History | Annotate | Download | only in libxslt 
      1 /*
      2  * documents.c: Implementation of the documents handling
      3  *
      4  * See Copyright for the status of this software.
      5  *
      6  * daniel (at) 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 
    435