1 /*
2  * xinclude.c : Code to implement XInclude processing
3  *
4  * World Wide Web Consortium W3C Last Call Working Draft 10 November 2003
5  * http://www.w3.org/TR/2003/WD-xinclude-20031110
6  *
7  * See Copyright for the status of this software.
8  *
9  * daniel@veillard.com
10  */
11 
12 #define IN_LIBXML
13 #include "libxml.h"
14 
15 #include <string.h>
16 #include <libxml/xmlmemory.h>
17 #include <libxml/tree.h>
18 #include <libxml/parser.h>
19 #include <libxml/uri.h>
20 #include <libxml/xpath.h>
21 #include <libxml/xpointer.h>
22 #include <libxml/parserInternals.h>
23 #include <libxml/xmlerror.h>
24 #include <libxml/encoding.h>
25 #include <libxml/globals.h>
26 
27 #ifdef LIBXML_XINCLUDE_ENABLED
28 #include <libxml/xinclude.h>
29 
30 #include "buf.h"
31 
32 #define XINCLUDE_MAX_DEPTH 40
33 
34 /* #define DEBUG_XINCLUDE */
35 #ifdef DEBUG_XINCLUDE
36 #ifdef LIBXML_DEBUG_ENABLED
37 #include <libxml/debugXML.h>
38 #endif
39 #endif
40 
41 /************************************************************************
42  *									*
43  *			XInclude context handling			*
44  *									*
45  ************************************************************************/
46 
47 /*
48  * An XInclude context
49  */
50 typedef xmlChar *xmlURL;
51 
52 typedef struct _xmlXIncludeRef xmlXIncludeRef;
53 typedef xmlXIncludeRef *xmlXIncludeRefPtr;
54 struct _xmlXIncludeRef {
55     xmlChar              *URI; /* the fully resolved resource URL */
56     xmlChar         *fragment; /* the fragment in the URI */
57     xmlDocPtr		  doc; /* the parsed document */
58     xmlNodePtr            ref; /* the node making the reference in the source */
59     xmlNodePtr            inc; /* the included copy */
60     int                   xml; /* xml or txt */
61     int                 count; /* how many refs use that specific doc */
62     xmlXPathObjectPtr    xptr; /* the xpointer if needed */
63     int		      emptyFb; /* flag to show fallback empty */
64 };
65 
66 struct _xmlXIncludeCtxt {
67     xmlDocPtr             doc; /* the source document */
68     int               incBase; /* the first include for this document */
69     int                 incNr; /* number of includes */
70     int                incMax; /* size of includes tab */
71     xmlXIncludeRefPtr *incTab; /* array of included references */
72 
73     int                 txtNr; /* number of unparsed documents */
74     int                txtMax; /* size of unparsed documents tab */
75     xmlNodePtr        *txtTab; /* array of unparsed text nodes */
76     xmlURL         *txturlTab; /* array of unparsed text URLs */
77 
78     xmlChar *             url; /* the current URL processed */
79     int                 urlNr; /* number of URLs stacked */
80     int                urlMax; /* size of URL stack */
81     xmlChar *         *urlTab; /* URL stack */
82 
83     int              nbErrors; /* the number of errors detected */
84     int                legacy; /* using XINCLUDE_OLD_NS */
85     int            parseFlags; /* the flags used for parsing XML documents */
86     xmlChar *		 base; /* the current xml:base */
87 
88     void            *_private; /* application data */
89 };
90 
91 static int
92 xmlXIncludeDoProcess(xmlXIncludeCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr tree);
93 
94 
95 /************************************************************************
96  *									*
97  *			XInclude error handler				*
98  *									*
99  ************************************************************************/
100 
101 /**
102  * xmlXIncludeErrMemory:
103  * @extra:  extra information
104  *
105  * Handle an out of memory condition
106  */
107 static void
xmlXIncludeErrMemory(xmlXIncludeCtxtPtr ctxt,xmlNodePtr node,const char * extra)108 xmlXIncludeErrMemory(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node,
109                      const char *extra)
110 {
111     if (ctxt != NULL)
112 	ctxt->nbErrors++;
113     __xmlRaiseError(NULL, NULL, NULL, ctxt, node, XML_FROM_XINCLUDE,
114                     XML_ERR_NO_MEMORY, XML_ERR_ERROR, NULL, 0,
115 		    extra, NULL, NULL, 0, 0,
116 		    "Memory allocation failed : %s\n", extra);
117 }
118 
119 /**
120  * xmlXIncludeErr:
121  * @ctxt: the XInclude context
122  * @node: the context node
123  * @msg:  the error message
124  * @extra:  extra information
125  *
126  * Handle an XInclude error
127  */
128 static void
xmlXIncludeErr(xmlXIncludeCtxtPtr ctxt,xmlNodePtr node,int error,const char * msg,const xmlChar * extra)129 xmlXIncludeErr(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node, int error,
130                const char *msg, const xmlChar *extra)
131 {
132     if (ctxt != NULL)
133 	ctxt->nbErrors++;
134     __xmlRaiseError(NULL, NULL, NULL, ctxt, node, XML_FROM_XINCLUDE,
135                     error, XML_ERR_ERROR, NULL, 0,
136 		    (const char *) extra, NULL, NULL, 0, 0,
137 		    msg, (const char *) extra);
138 }
139 
140 #if 0
141 /**
142  * xmlXIncludeWarn:
143  * @ctxt: the XInclude context
144  * @node: the context node
145  * @msg:  the error message
146  * @extra:  extra information
147  *
148  * Emit an XInclude warning.
149  */
150 static void
151 xmlXIncludeWarn(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node, int error,
152                const char *msg, const xmlChar *extra)
153 {
154     __xmlRaiseError(NULL, NULL, NULL, ctxt, node, XML_FROM_XINCLUDE,
155                     error, XML_ERR_WARNING, NULL, 0,
156 		    (const char *) extra, NULL, NULL, 0, 0,
157 		    msg, (const char *) extra);
158 }
159 #endif
160 
161 /**
162  * xmlXIncludeGetProp:
163  * @ctxt:  the XInclude context
164  * @cur:  the node
165  * @name:  the attribute name
166  *
167  * Get an XInclude attribute
168  *
169  * Returns the value (to be freed) or NULL if not found
170  */
171 static xmlChar *
xmlXIncludeGetProp(xmlXIncludeCtxtPtr ctxt,xmlNodePtr cur,const xmlChar * name)172 xmlXIncludeGetProp(xmlXIncludeCtxtPtr ctxt, xmlNodePtr cur,
173                    const xmlChar *name) {
174     xmlChar *ret;
175 
176     ret = xmlGetNsProp(cur, XINCLUDE_NS, name);
177     if (ret != NULL)
178         return(ret);
179     if (ctxt->legacy != 0) {
180 	ret = xmlGetNsProp(cur, XINCLUDE_OLD_NS, name);
181 	if (ret != NULL)
182 	    return(ret);
183     }
184     ret = xmlGetProp(cur, name);
185     return(ret);
186 }
187 /**
188  * xmlXIncludeFreeRef:
189  * @ref: the XInclude reference
190  *
191  * Free an XInclude reference
192  */
193 static void
xmlXIncludeFreeRef(xmlXIncludeRefPtr ref)194 xmlXIncludeFreeRef(xmlXIncludeRefPtr ref) {
195     if (ref == NULL)
196 	return;
197 #ifdef DEBUG_XINCLUDE
198     xmlGenericError(xmlGenericErrorContext, "Freeing ref\n");
199 #endif
200     if (ref->doc != NULL) {
201 #ifdef DEBUG_XINCLUDE
202 	xmlGenericError(xmlGenericErrorContext, "Freeing doc %s\n", ref->URI);
203 #endif
204 	xmlFreeDoc(ref->doc);
205     }
206     if (ref->URI != NULL)
207 	xmlFree(ref->URI);
208     if (ref->fragment != NULL)
209 	xmlFree(ref->fragment);
210     if (ref->xptr != NULL)
211 	xmlXPathFreeObject(ref->xptr);
212     xmlFree(ref);
213 }
214 
215 /**
216  * xmlXIncludeNewRef:
217  * @ctxt: the XInclude context
218  * @URI:  the resource URI
219  *
220  * Creates a new reference within an XInclude context
221  *
222  * Returns the new set
223  */
224 static xmlXIncludeRefPtr
xmlXIncludeNewRef(xmlXIncludeCtxtPtr ctxt,const xmlChar * URI,xmlNodePtr ref)225 xmlXIncludeNewRef(xmlXIncludeCtxtPtr ctxt, const xmlChar *URI,
226 	          xmlNodePtr ref) {
227     xmlXIncludeRefPtr ret;
228 
229 #ifdef DEBUG_XINCLUDE
230     xmlGenericError(xmlGenericErrorContext, "New ref %s\n", URI);
231 #endif
232     ret = (xmlXIncludeRefPtr) xmlMalloc(sizeof(xmlXIncludeRef));
233     if (ret == NULL) {
234         xmlXIncludeErrMemory(ctxt, ref, "growing XInclude context");
235 	return(NULL);
236     }
237     memset(ret, 0, sizeof(xmlXIncludeRef));
238     if (URI == NULL)
239 	ret->URI = NULL;
240     else
241 	ret->URI = xmlStrdup(URI);
242     ret->fragment = NULL;
243     ret->ref = ref;
244     ret->doc = NULL;
245     ret->count = 0;
246     ret->xml = 0;
247     ret->inc = NULL;
248     if (ctxt->incMax == 0) {
249 	ctxt->incMax = 4;
250         ctxt->incTab = (xmlXIncludeRefPtr *) xmlMalloc(ctxt->incMax *
251 					      sizeof(ctxt->incTab[0]));
252         if (ctxt->incTab == NULL) {
253 	    xmlXIncludeErrMemory(ctxt, ref, "growing XInclude context");
254 	    xmlXIncludeFreeRef(ret);
255 	    return(NULL);
256 	}
257     }
258     if (ctxt->incNr >= ctxt->incMax) {
259 	ctxt->incMax *= 2;
260         ctxt->incTab = (xmlXIncludeRefPtr *) xmlRealloc(ctxt->incTab,
261 	             ctxt->incMax * sizeof(ctxt->incTab[0]));
262         if (ctxt->incTab == NULL) {
263 	    xmlXIncludeErrMemory(ctxt, ref, "growing XInclude context");
264 	    xmlXIncludeFreeRef(ret);
265 	    return(NULL);
266 	}
267     }
268     ctxt->incTab[ctxt->incNr++] = ret;
269     return(ret);
270 }
271 
272 /**
273  * xmlXIncludeNewContext:
274  * @doc:  an XML Document
275  *
276  * Creates a new XInclude context
277  *
278  * Returns the new set
279  */
280 xmlXIncludeCtxtPtr
xmlXIncludeNewContext(xmlDocPtr doc)281 xmlXIncludeNewContext(xmlDocPtr doc) {
282     xmlXIncludeCtxtPtr ret;
283 
284 #ifdef DEBUG_XINCLUDE
285     xmlGenericError(xmlGenericErrorContext, "New context\n");
286 #endif
287     if (doc == NULL)
288 	return(NULL);
289     ret = (xmlXIncludeCtxtPtr) xmlMalloc(sizeof(xmlXIncludeCtxt));
290     if (ret == NULL) {
291 	xmlXIncludeErrMemory(NULL, (xmlNodePtr) doc,
292 	                     "creating XInclude context");
293 	return(NULL);
294     }
295     memset(ret, 0, sizeof(xmlXIncludeCtxt));
296     ret->doc = doc;
297     ret->incNr = 0;
298     ret->incBase = 0;
299     ret->incMax = 0;
300     ret->incTab = NULL;
301     ret->nbErrors = 0;
302     return(ret);
303 }
304 
305 /**
306  * xmlXIncludeURLPush:
307  * @ctxt:  the parser context
308  * @value:  the url
309  *
310  * Pushes a new url on top of the url stack
311  *
312  * Returns -1 in case of error, the index in the stack otherwise
313  */
314 static int
xmlXIncludeURLPush(xmlXIncludeCtxtPtr ctxt,const xmlChar * value)315 xmlXIncludeURLPush(xmlXIncludeCtxtPtr ctxt,
316 	           const xmlChar *value)
317 {
318     if (ctxt->urlNr > XINCLUDE_MAX_DEPTH) {
319 	xmlXIncludeErr(ctxt, NULL, XML_XINCLUDE_RECURSION,
320 	               "detected a recursion in %s\n", value);
321 	return(-1);
322     }
323     if (ctxt->urlTab == NULL) {
324 	ctxt->urlMax = 4;
325 	ctxt->urlNr = 0;
326 	ctxt->urlTab = (xmlChar * *) xmlMalloc(
327 		        ctxt->urlMax * sizeof(ctxt->urlTab[0]));
328         if (ctxt->urlTab == NULL) {
329 	    xmlXIncludeErrMemory(ctxt, NULL, "adding URL");
330             return (-1);
331         }
332     }
333     if (ctxt->urlNr >= ctxt->urlMax) {
334         ctxt->urlMax *= 2;
335         ctxt->urlTab =
336             (xmlChar * *) xmlRealloc(ctxt->urlTab,
337                                       ctxt->urlMax *
338                                       sizeof(ctxt->urlTab[0]));
339         if (ctxt->urlTab == NULL) {
340 	    xmlXIncludeErrMemory(ctxt, NULL, "adding URL");
341             return (-1);
342         }
343     }
344     ctxt->url = ctxt->urlTab[ctxt->urlNr] = xmlStrdup(value);
345     return (ctxt->urlNr++);
346 }
347 
348 /**
349  * xmlXIncludeURLPop:
350  * @ctxt: the parser context
351  *
352  * Pops the top URL from the URL stack
353  */
354 static void
xmlXIncludeURLPop(xmlXIncludeCtxtPtr ctxt)355 xmlXIncludeURLPop(xmlXIncludeCtxtPtr ctxt)
356 {
357     xmlChar * ret;
358 
359     if (ctxt->urlNr <= 0)
360         return;
361     ctxt->urlNr--;
362     if (ctxt->urlNr > 0)
363         ctxt->url = ctxt->urlTab[ctxt->urlNr - 1];
364     else
365         ctxt->url = NULL;
366     ret = ctxt->urlTab[ctxt->urlNr];
367     ctxt->urlTab[ctxt->urlNr] = NULL;
368     if (ret != NULL)
369 	xmlFree(ret);
370 }
371 
372 /**
373  * xmlXIncludeFreeContext:
374  * @ctxt: the XInclude context
375  *
376  * Free an XInclude context
377  */
378 void
xmlXIncludeFreeContext(xmlXIncludeCtxtPtr ctxt)379 xmlXIncludeFreeContext(xmlXIncludeCtxtPtr ctxt) {
380     int i;
381 
382 #ifdef DEBUG_XINCLUDE
383     xmlGenericError(xmlGenericErrorContext, "Freeing context\n");
384 #endif
385     if (ctxt == NULL)
386 	return;
387     while (ctxt->urlNr > 0)
388 	xmlXIncludeURLPop(ctxt);
389     if (ctxt->urlTab != NULL)
390 	xmlFree(ctxt->urlTab);
391     for (i = 0;i < ctxt->incNr;i++) {
392 	if (ctxt->incTab[i] != NULL)
393 	    xmlXIncludeFreeRef(ctxt->incTab[i]);
394     }
395     if (ctxt->txturlTab != NULL) {
396 	for (i = 0;i < ctxt->txtNr;i++) {
397 	    if (ctxt->txturlTab[i] != NULL)
398 		xmlFree(ctxt->txturlTab[i]);
399 	}
400     }
401     if (ctxt->incTab != NULL)
402 	xmlFree(ctxt->incTab);
403     if (ctxt->txtTab != NULL)
404 	xmlFree(ctxt->txtTab);
405     if (ctxt->txturlTab != NULL)
406 	xmlFree(ctxt->txturlTab);
407     if (ctxt->base != NULL) {
408         xmlFree(ctxt->base);
409     }
410     xmlFree(ctxt);
411 }
412 
413 /**
414  * xmlXIncludeParseFile:
415  * @ctxt:  the XInclude context
416  * @URL:  the URL or file path
417  *
418  * parse a document for XInclude
419  */
420 static xmlDocPtr
xmlXIncludeParseFile(xmlXIncludeCtxtPtr ctxt,const char * URL)421 xmlXIncludeParseFile(xmlXIncludeCtxtPtr ctxt, const char *URL) {
422     xmlDocPtr ret;
423     xmlParserCtxtPtr pctxt;
424     xmlParserInputPtr inputStream;
425 
426     xmlInitParser();
427 
428     pctxt = xmlNewParserCtxt();
429     if (pctxt == NULL) {
430 	xmlXIncludeErrMemory(ctxt, NULL, "cannot allocate parser context");
431 	return(NULL);
432     }
433 
434     /*
435      * pass in the application data to the parser context.
436      */
437     pctxt->_private = ctxt->_private;
438 
439     /*
440      * try to ensure that new documents included are actually
441      * built with the same dictionary as the including document.
442      */
443     if ((ctxt->doc != NULL) && (ctxt->doc->dict != NULL)) {
444        if (pctxt->dict != NULL)
445             xmlDictFree(pctxt->dict);
446 	pctxt->dict = ctxt->doc->dict;
447 	xmlDictReference(pctxt->dict);
448     }
449 
450     xmlCtxtUseOptions(pctxt, ctxt->parseFlags | XML_PARSE_DTDLOAD);
451 
452     inputStream = xmlLoadExternalEntity(URL, NULL, pctxt);
453     if (inputStream == NULL) {
454 	xmlFreeParserCtxt(pctxt);
455 	return(NULL);
456     }
457 
458     inputPush(pctxt, inputStream);
459 
460     if (pctxt->directory == NULL)
461         pctxt->directory = xmlParserGetDirectory(URL);
462 
463     pctxt->loadsubset |= XML_DETECT_IDS;
464 
465     xmlParseDocument(pctxt);
466 
467     if (pctxt->wellFormed) {
468         ret = pctxt->myDoc;
469     }
470     else {
471         ret = NULL;
472 	if (pctxt->myDoc != NULL)
473 	    xmlFreeDoc(pctxt->myDoc);
474         pctxt->myDoc = NULL;
475     }
476     xmlFreeParserCtxt(pctxt);
477 
478     return(ret);
479 }
480 
481 /**
482  * xmlXIncludeAddNode:
483  * @ctxt:  the XInclude context
484  * @cur:  the new node
485  *
486  * Add a new node to process to an XInclude context
487  */
488 static int
xmlXIncludeAddNode(xmlXIncludeCtxtPtr ctxt,xmlNodePtr cur)489 xmlXIncludeAddNode(xmlXIncludeCtxtPtr ctxt, xmlNodePtr cur) {
490     xmlXIncludeRefPtr ref;
491     xmlURIPtr uri;
492     xmlChar *URL;
493     xmlChar *fragment = NULL;
494     xmlChar *href;
495     xmlChar *parse;
496     xmlChar *base;
497     xmlChar *URI;
498     int xml = 1, i; /* default Issue 64 */
499     int local = 0;
500 
501 
502     if (ctxt == NULL)
503 	return(-1);
504     if (cur == NULL)
505 	return(-1);
506 
507 #ifdef DEBUG_XINCLUDE
508     xmlGenericError(xmlGenericErrorContext, "Add node\n");
509 #endif
510     /*
511      * read the attributes
512      */
513     href = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_HREF);
514     if (href == NULL) {
515 	href = xmlStrdup(BAD_CAST ""); /* @@@@ href is now optional */
516 	if (href == NULL)
517 	    return(-1);
518     }
519     if ((href[0] == '#') || (href[0] == 0))
520 	local = 1;
521     parse = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_PARSE);
522     if (parse != NULL) {
523 	if (xmlStrEqual(parse, XINCLUDE_PARSE_XML))
524 	    xml = 1;
525 	else if (xmlStrEqual(parse, XINCLUDE_PARSE_TEXT))
526 	    xml = 0;
527 	else {
528 	    xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_PARSE_VALUE,
529 	                   "invalid value %s for 'parse'\n", parse);
530 	    if (href != NULL)
531 		xmlFree(href);
532 	    if (parse != NULL)
533 		xmlFree(parse);
534 	    return(-1);
535 	}
536     }
537 
538     /*
539      * compute the URI
540      */
541     base = xmlNodeGetBase(ctxt->doc, cur);
542     if (base == NULL) {
543 	URI = xmlBuildURI(href, ctxt->doc->URL);
544     } else {
545 	URI = xmlBuildURI(href, base);
546     }
547     if (URI == NULL) {
548 	xmlChar *escbase;
549 	xmlChar *eschref;
550 	/*
551 	 * Some escaping may be needed
552 	 */
553 	escbase = xmlURIEscape(base);
554 	eschref = xmlURIEscape(href);
555 	URI = xmlBuildURI(eschref, escbase);
556 	if (escbase != NULL)
557 	    xmlFree(escbase);
558 	if (eschref != NULL)
559 	    xmlFree(eschref);
560     }
561     if (parse != NULL)
562 	xmlFree(parse);
563     if (href != NULL)
564 	xmlFree(href);
565     if (base != NULL)
566 	xmlFree(base);
567     if (URI == NULL) {
568 	xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_HREF_URI,
569 	               "failed build URL\n", NULL);
570 	return(-1);
571     }
572     fragment = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_PARSE_XPOINTER);
573 
574     /*
575      * Check the URL and remove any fragment identifier
576      */
577     uri = xmlParseURI((const char *)URI);
578     if (uri == NULL) {
579 	xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_HREF_URI,
580 	               "invalid value URI %s\n", URI);
581 	if (fragment != NULL)
582 	    xmlFree(fragment);
583 	xmlFree(URI);
584 	return(-1);
585     }
586 
587     if (uri->fragment != NULL) {
588         if (ctxt->legacy != 0) {
589 	    if (fragment == NULL) {
590 		fragment = (xmlChar *) uri->fragment;
591 	    } else {
592 		xmlFree(uri->fragment);
593 	    }
594 	} else {
595 	    xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_FRAGMENT_ID,
596        "Invalid fragment identifier in URI %s use the xpointer attribute\n",
597                            URI);
598 	    if (fragment != NULL)
599 	        xmlFree(fragment);
600 	    xmlFreeURI(uri);
601 	    xmlFree(URI);
602 	    return(-1);
603 	}
604 	uri->fragment = NULL;
605     }
606     URL = xmlSaveUri(uri);
607     xmlFreeURI(uri);
608     xmlFree(URI);
609     if (URL == NULL) {
610 	xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_HREF_URI,
611 	               "invalid value URI %s\n", URI);
612 	if (fragment != NULL)
613 	    xmlFree(fragment);
614 	return(-1);
615     }
616 
617     /*
618      * If local and xml then we need a fragment
619      */
620     if ((local == 1) && (xml == 1) &&
621         ((fragment == NULL) || (fragment[0] == 0))) {
622 	xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_RECURSION,
623 	               "detected a local recursion with no xpointer in %s\n",
624 		       URL);
625 	if (fragment != NULL)
626 	    xmlFree(fragment);
627 	return(-1);
628     }
629 
630     /*
631      * Check the URL against the stack for recursions
632      */
633     if ((!local) && (xml == 1)) {
634 	for (i = 0;i < ctxt->urlNr;i++) {
635 	    if (xmlStrEqual(URL, ctxt->urlTab[i])) {
636 		xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_RECURSION,
637 		               "detected a recursion in %s\n", URL);
638 		return(-1);
639 	    }
640 	}
641     }
642 
643     ref = xmlXIncludeNewRef(ctxt, URL, cur);
644     if (ref == NULL) {
645 	return(-1);
646     }
647     ref->fragment = fragment;
648     ref->doc = NULL;
649     ref->xml = xml;
650     ref->count = 1;
651     xmlFree(URL);
652     return(0);
653 }
654 
655 /**
656  * xmlXIncludeRecurseDoc:
657  * @ctxt:  the XInclude context
658  * @doc:  the new document
659  * @url:  the associated URL
660  *
661  * The XInclude recursive nature is handled at this point.
662  */
663 static void
xmlXIncludeRecurseDoc(xmlXIncludeCtxtPtr ctxt,xmlDocPtr doc,const xmlURL url ATTRIBUTE_UNUSED)664 xmlXIncludeRecurseDoc(xmlXIncludeCtxtPtr ctxt, xmlDocPtr doc,
665 	              const xmlURL url ATTRIBUTE_UNUSED) {
666     xmlXIncludeCtxtPtr newctxt;
667     int i;
668 
669     /*
670      * Avoid recursion in already substitued resources
671     for (i = 0;i < ctxt->urlNr;i++) {
672 	if (xmlStrEqual(doc->URL, ctxt->urlTab[i]))
673 	    return;
674     }
675      */
676 
677 #ifdef DEBUG_XINCLUDE
678     xmlGenericError(xmlGenericErrorContext, "Recursing in doc %s\n", doc->URL);
679 #endif
680     /*
681      * Handle recursion here.
682      */
683 
684     newctxt = xmlXIncludeNewContext(doc);
685     if (newctxt != NULL) {
686 	/*
687 	 * Copy the private user data
688 	 */
689 	newctxt->_private = ctxt->_private;
690 	/*
691 	 * Copy the existing document set
692 	 */
693 	newctxt->incMax = ctxt->incMax;
694 	newctxt->incNr = ctxt->incNr;
695         newctxt->incTab = (xmlXIncludeRefPtr *) xmlMalloc(newctxt->incMax *
696 		                          sizeof(newctxt->incTab[0]));
697         if (newctxt->incTab == NULL) {
698 	    xmlXIncludeErrMemory(ctxt, (xmlNodePtr) doc, "processing doc");
699 	    xmlFree(newctxt);
700 	    return;
701 	}
702 	/*
703 	 * copy the urlTab
704 	 */
705 	newctxt->urlMax = ctxt->urlMax;
706 	newctxt->urlNr = ctxt->urlNr;
707 	newctxt->urlTab = ctxt->urlTab;
708 
709 	/*
710 	 * Inherit the existing base
711 	 */
712 	newctxt->base = xmlStrdup(ctxt->base);
713 
714 	/*
715 	 * Inherit the documents already in use by other includes
716 	 */
717 	newctxt->incBase = ctxt->incNr;
718 	for (i = 0;i < ctxt->incNr;i++) {
719 	    newctxt->incTab[i] = ctxt->incTab[i];
720 	    newctxt->incTab[i]->count++; /* prevent the recursion from
721 					    freeing it */
722 	}
723 	/*
724 	 * The new context should also inherit the Parse Flags
725 	 * (bug 132597)
726 	 */
727 	newctxt->parseFlags = ctxt->parseFlags;
728 	xmlXIncludeDoProcess(newctxt, doc, xmlDocGetRootElement(doc));
729 	for (i = 0;i < ctxt->incNr;i++) {
730 	    newctxt->incTab[i]->count--;
731 	    newctxt->incTab[i] = NULL;
732 	}
733 
734 	/* urlTab may have been reallocated */
735 	ctxt->urlTab = newctxt->urlTab;
736 	ctxt->urlMax = newctxt->urlMax;
737 
738 	newctxt->urlMax = 0;
739 	newctxt->urlNr = 0;
740 	newctxt->urlTab = NULL;
741 
742 	xmlXIncludeFreeContext(newctxt);
743     }
744 #ifdef DEBUG_XINCLUDE
745     xmlGenericError(xmlGenericErrorContext, "Done recursing in doc %s\n", url);
746 #endif
747 }
748 
749 /**
750  * xmlXIncludeAddTxt:
751  * @ctxt:  the XInclude context
752  * @txt:  the new text node
753  * @url:  the associated URL
754  *
755  * Add a new txtument to the list
756  */
757 static void
xmlXIncludeAddTxt(xmlXIncludeCtxtPtr ctxt,xmlNodePtr txt,const xmlURL url)758 xmlXIncludeAddTxt(xmlXIncludeCtxtPtr ctxt, xmlNodePtr txt, const xmlURL url) {
759 #ifdef DEBUG_XINCLUDE
760     xmlGenericError(xmlGenericErrorContext, "Adding text %s\n", url);
761 #endif
762     if (ctxt->txtMax == 0) {
763 	ctxt->txtMax = 4;
764         ctxt->txtTab = (xmlNodePtr *) xmlMalloc(ctxt->txtMax *
765 		                          sizeof(ctxt->txtTab[0]));
766         if (ctxt->txtTab == NULL) {
767 	    xmlXIncludeErrMemory(ctxt, NULL, "processing text");
768 	    return;
769 	}
770         ctxt->txturlTab = (xmlURL *) xmlMalloc(ctxt->txtMax *
771 		                          sizeof(ctxt->txturlTab[0]));
772         if (ctxt->txturlTab == NULL) {
773 	    xmlXIncludeErrMemory(ctxt, NULL, "processing text");
774 	    return;
775 	}
776     }
777     if (ctxt->txtNr >= ctxt->txtMax) {
778 	ctxt->txtMax *= 2;
779         ctxt->txtTab = (xmlNodePtr *) xmlRealloc(ctxt->txtTab,
780 	             ctxt->txtMax * sizeof(ctxt->txtTab[0]));
781         if (ctxt->txtTab == NULL) {
782 	    xmlXIncludeErrMemory(ctxt, NULL, "processing text");
783 	    return;
784 	}
785         ctxt->txturlTab = (xmlURL *) xmlRealloc(ctxt->txturlTab,
786 	             ctxt->txtMax * sizeof(ctxt->txturlTab[0]));
787         if (ctxt->txturlTab == NULL) {
788 	    xmlXIncludeErrMemory(ctxt, NULL, "processing text");
789 	    return;
790 	}
791     }
792     ctxt->txtTab[ctxt->txtNr] = txt;
793     ctxt->txturlTab[ctxt->txtNr] = xmlStrdup(url);
794     ctxt->txtNr++;
795 }
796 
797 /************************************************************************
798  *									*
799  *			Node copy with specific semantic		*
800  *									*
801  ************************************************************************/
802 
803 static xmlNodePtr
804 xmlXIncludeCopyNodeList(xmlXIncludeCtxtPtr ctxt, xmlDocPtr target,
805 	                xmlDocPtr source, xmlNodePtr elem);
806 
807 /**
808  * xmlXIncludeCopyNode:
809  * @ctxt:  the XInclude context
810  * @target:  the document target
811  * @source:  the document source
812  * @elem:  the element
813  *
814  * Make a copy of the node while preserving the XInclude semantic
815  * of the Infoset copy
816  */
817 static xmlNodePtr
xmlXIncludeCopyNode(xmlXIncludeCtxtPtr ctxt,xmlDocPtr target,xmlDocPtr source,xmlNodePtr elem)818 xmlXIncludeCopyNode(xmlXIncludeCtxtPtr ctxt, xmlDocPtr target,
819 	            xmlDocPtr source, xmlNodePtr elem) {
820     xmlNodePtr result = NULL;
821 
822     if ((ctxt == NULL) || (target == NULL) || (source == NULL) ||
823 	(elem == NULL))
824 	return(NULL);
825     if (elem->type == XML_DTD_NODE)
826 	return(NULL);
827     if (elem->type == XML_DOCUMENT_NODE)
828 	result = xmlXIncludeCopyNodeList(ctxt, target, source, elem->children);
829     else
830         result = xmlDocCopyNode(elem, target, 1);
831     return(result);
832 }
833 
834 /**
835  * xmlXIncludeCopyNodeList:
836  * @ctxt:  the XInclude context
837  * @target:  the document target
838  * @source:  the document source
839  * @elem:  the element list
840  *
841  * Make a copy of the node list while preserving the XInclude semantic
842  * of the Infoset copy
843  */
844 static xmlNodePtr
xmlXIncludeCopyNodeList(xmlXIncludeCtxtPtr ctxt,xmlDocPtr target,xmlDocPtr source,xmlNodePtr elem)845 xmlXIncludeCopyNodeList(xmlXIncludeCtxtPtr ctxt, xmlDocPtr target,
846 	                xmlDocPtr source, xmlNodePtr elem) {
847     xmlNodePtr cur, res, result = NULL, last = NULL;
848 
849     if ((ctxt == NULL) || (target == NULL) || (source == NULL) ||
850 	(elem == NULL))
851 	return(NULL);
852     cur = elem;
853     while (cur != NULL) {
854 	res = xmlXIncludeCopyNode(ctxt, target, source, cur);
855 	if (res != NULL) {
856 	    if (result == NULL) {
857 		result = last = res;
858 	    } else {
859 		last->next = res;
860 		res->prev = last;
861 		last = res;
862 	    }
863 	}
864 	cur = cur->next;
865     }
866     return(result);
867 }
868 
869 /**
870  * xmlXIncludeGetNthChild:
871  * @cur:  the node
872  * @no:  the child number
873  *
874  * Returns the @n'th element child of @cur or NULL
875  */
876 static xmlNodePtr
xmlXIncludeGetNthChild(xmlNodePtr cur,int no)877 xmlXIncludeGetNthChild(xmlNodePtr cur, int no) {
878     int i;
879     if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL))
880         return(NULL);
881     cur = cur->children;
882     for (i = 0;i <= no;cur = cur->next) {
883 	if (cur == NULL)
884 	    return(cur);
885 	if ((cur->type == XML_ELEMENT_NODE) ||
886 	    (cur->type == XML_DOCUMENT_NODE) ||
887 	    (cur->type == XML_HTML_DOCUMENT_NODE)) {
888 	    i++;
889 	    if (i == no)
890 		break;
891 	}
892     }
893     return(cur);
894 }
895 
896 xmlNodePtr xmlXPtrAdvanceNode(xmlNodePtr cur, int *level); /* in xpointer.c */
897 /**
898  * xmlXIncludeCopyRange:
899  * @ctxt:  the XInclude context
900  * @target:  the document target
901  * @source:  the document source
902  * @obj:  the XPointer result from the evaluation.
903  *
904  * Build a node list tree copy of the XPointer result.
905  *
906  * Returns an xmlNodePtr list or NULL.
907  *         The caller has to free the node tree.
908  */
909 static xmlNodePtr
xmlXIncludeCopyRange(xmlXIncludeCtxtPtr ctxt,xmlDocPtr target,xmlDocPtr source,xmlXPathObjectPtr range)910 xmlXIncludeCopyRange(xmlXIncludeCtxtPtr ctxt, xmlDocPtr target,
911 	                xmlDocPtr source, xmlXPathObjectPtr range) {
912     /* pointers to generated nodes */
913     xmlNodePtr list = NULL, last = NULL, listParent = NULL;
914     xmlNodePtr tmp, tmp2;
915     /* pointers to traversal nodes */
916     xmlNodePtr start, cur, end;
917     int index1, index2;
918     int level = 0, lastLevel = 0, endLevel = 0, endFlag = 0;
919 
920     if ((ctxt == NULL) || (target == NULL) || (source == NULL) ||
921 	(range == NULL))
922 	return(NULL);
923     if (range->type != XPATH_RANGE)
924 	return(NULL);
925     start = (xmlNodePtr) range->user;
926 
927     if ((start == NULL) || (start->type == XML_NAMESPACE_DECL))
928 	return(NULL);
929     end = range->user2;
930     if (end == NULL)
931 	return(xmlDocCopyNode(start, target, 1));
932     if (end->type == XML_NAMESPACE_DECL)
933         return(NULL);
934 
935     cur = start;
936     index1 = range->index;
937     index2 = range->index2;
938     /*
939      * level is depth of the current node under consideration
940      * list is the pointer to the root of the output tree
941      * listParent is a pointer to the parent of output tree (within
942        the included file) in case we need to add another level
943      * last is a pointer to the last node added to the output tree
944      * lastLevel is the depth of last (relative to the root)
945      */
946     while (cur != NULL) {
947 	/*
948 	 * Check if our output tree needs a parent
949 	 */
950 	if (level < 0) {
951 	    while (level < 0) {
952 	        /* copy must include namespaces and properties */
953 	        tmp2 = xmlDocCopyNode(listParent, target, 2);
954 	        xmlAddChild(tmp2, list);
955 	        list = tmp2;
956 	        listParent = listParent->parent;
957 	        level++;
958 	    }
959 	    last = list;
960 	    lastLevel = 0;
961 	}
962 	/*
963 	 * Check whether we need to change our insertion point
964 	 */
965 	while (level < lastLevel) {
966 	    last = last->parent;
967 	    lastLevel --;
968 	}
969 	if (cur == end) {	/* Are we at the end of the range? */
970 	    if (cur->type == XML_TEXT_NODE) {
971 		const xmlChar *content = cur->content;
972 		int len;
973 
974 		if (content == NULL) {
975 		    tmp = xmlNewTextLen(NULL, 0);
976 		} else {
977 		    len = index2;
978 		    if ((cur == start) && (index1 > 1)) {
979 			content += (index1 - 1);
980 			len -= (index1 - 1);
981 		    } else {
982 			len = index2;
983 		    }
984 		    tmp = xmlNewTextLen(content, len);
985 		}
986 		/* single sub text node selection */
987 		if (list == NULL)
988 		    return(tmp);
989 		/* prune and return full set */
990 		if (level == lastLevel)
991 		    xmlAddNextSibling(last, tmp);
992 		else
993 		    xmlAddChild(last, tmp);
994 		return(list);
995 	    } else {	/* ending node not a text node */
996 	        endLevel = level;	/* remember the level of the end node */
997 		endFlag = 1;
998 		/* last node - need to take care of properties + namespaces */
999 		tmp = xmlDocCopyNode(cur, target, 2);
1000 		if (list == NULL) {
1001 		    list = tmp;
1002 		    listParent = cur->parent;
1003 		} else {
1004 		    if (level == lastLevel)
1005 			xmlAddNextSibling(last, tmp);
1006 		    else {
1007 			xmlAddChild(last, tmp);
1008 			lastLevel = level;
1009 		    }
1010 		}
1011 		last = tmp;
1012 
1013 		if (index2 > 1) {
1014 		    end = xmlXIncludeGetNthChild(cur, index2 - 1);
1015 		    index2 = 0;
1016 		}
1017 		if ((cur == start) && (index1 > 1)) {
1018 		    cur = xmlXIncludeGetNthChild(cur, index1 - 1);
1019 		    index1 = 0;
1020 		}  else {
1021 		    cur = cur->children;
1022 		}
1023 		level++;	/* increment level to show change */
1024 		/*
1025 		 * Now gather the remaining nodes from cur to end
1026 		 */
1027 		continue;	/* while */
1028 	    }
1029 	} else if (cur == start) {	/* Not at the end, are we at start? */
1030 	    if ((cur->type == XML_TEXT_NODE) ||
1031 		(cur->type == XML_CDATA_SECTION_NODE)) {
1032 		const xmlChar *content = cur->content;
1033 
1034 		if (content == NULL) {
1035 		    tmp = xmlNewTextLen(NULL, 0);
1036 		} else {
1037 		    if (index1 > 1) {
1038 			content += (index1 - 1);
1039 			index1 = 0;
1040 		    }
1041 		    tmp = xmlNewText(content);
1042 		}
1043 		last = list = tmp;
1044 		listParent = cur->parent;
1045 	    } else {		/* Not text node */
1046 	        /*
1047 		 * start of the range - need to take care of
1048 		 * properties and namespaces
1049 		 */
1050 		tmp = xmlDocCopyNode(cur, target, 2);
1051 		list = last = tmp;
1052 		listParent = cur->parent;
1053 		if (index1 > 1) {	/* Do we need to position? */
1054 		    cur = xmlXIncludeGetNthChild(cur, index1 - 1);
1055 		    level = lastLevel = 1;
1056 		    index1 = 0;
1057 		    /*
1058 		     * Now gather the remaining nodes from cur to end
1059 		     */
1060 		    continue; /* while */
1061 		}
1062 	    }
1063 	} else {
1064 	    tmp = NULL;
1065 	    switch (cur->type) {
1066 		case XML_DTD_NODE:
1067 		case XML_ELEMENT_DECL:
1068 		case XML_ATTRIBUTE_DECL:
1069 		case XML_ENTITY_NODE:
1070 		    /* Do not copy DTD informations */
1071 		    break;
1072 		case XML_ENTITY_DECL:
1073 		    /* handle crossing entities -> stack needed */
1074 		    break;
1075 		case XML_XINCLUDE_START:
1076 		case XML_XINCLUDE_END:
1077 		    /* don't consider it part of the tree content */
1078 		    break;
1079 		case XML_ATTRIBUTE_NODE:
1080 		    /* Humm, should not happen ! */
1081 		    break;
1082 		default:
1083 		    /*
1084 		     * Middle of the range - need to take care of
1085 		     * properties and namespaces
1086 		     */
1087 		    tmp = xmlDocCopyNode(cur, target, 2);
1088 		    break;
1089 	    }
1090 	    if (tmp != NULL) {
1091 		if (level == lastLevel)
1092 		    xmlAddNextSibling(last, tmp);
1093 		else {
1094 		    xmlAddChild(last, tmp);
1095 		    lastLevel = level;
1096 		}
1097 		last = tmp;
1098 	    }
1099 	}
1100 	/*
1101 	 * Skip to next node in document order
1102 	 */
1103 	cur = xmlXPtrAdvanceNode(cur, &level);
1104 	if (endFlag && (level >= endLevel))
1105 	    break;
1106     }
1107     return(list);
1108 }
1109 
1110 /**
1111  * xmlXIncludeBuildNodeList:
1112  * @ctxt:  the XInclude context
1113  * @target:  the document target
1114  * @source:  the document source
1115  * @obj:  the XPointer result from the evaluation.
1116  *
1117  * Build a node list tree copy of the XPointer result.
1118  * This will drop Attributes and Namespace declarations.
1119  *
1120  * Returns an xmlNodePtr list or NULL.
1121  *         the caller has to free the node tree.
1122  */
1123 static xmlNodePtr
xmlXIncludeCopyXPointer(xmlXIncludeCtxtPtr ctxt,xmlDocPtr target,xmlDocPtr source,xmlXPathObjectPtr obj)1124 xmlXIncludeCopyXPointer(xmlXIncludeCtxtPtr ctxt, xmlDocPtr target,
1125 	                xmlDocPtr source, xmlXPathObjectPtr obj) {
1126     xmlNodePtr list = NULL, last = NULL;
1127     int i;
1128 
1129     if (source == NULL)
1130 	source = ctxt->doc;
1131     if ((ctxt == NULL) || (target == NULL) || (source == NULL) ||
1132 	(obj == NULL))
1133 	return(NULL);
1134     switch (obj->type) {
1135         case XPATH_NODESET: {
1136 	    xmlNodeSetPtr set = obj->nodesetval;
1137 	    if (set == NULL)
1138 		return(NULL);
1139 	    for (i = 0;i < set->nodeNr;i++) {
1140 		if (set->nodeTab[i] == NULL)
1141 		    continue;
1142 		switch (set->nodeTab[i]->type) {
1143 		    case XML_TEXT_NODE:
1144 		    case XML_CDATA_SECTION_NODE:
1145 		    case XML_ELEMENT_NODE:
1146 		    case XML_ENTITY_REF_NODE:
1147 		    case XML_ENTITY_NODE:
1148 		    case XML_PI_NODE:
1149 		    case XML_COMMENT_NODE:
1150 		    case XML_DOCUMENT_NODE:
1151 		    case XML_HTML_DOCUMENT_NODE:
1152 #ifdef LIBXML_DOCB_ENABLED
1153 		    case XML_DOCB_DOCUMENT_NODE:
1154 #endif
1155 		    case XML_XINCLUDE_END:
1156 			break;
1157 		    case XML_XINCLUDE_START: {
1158 	                xmlNodePtr tmp, cur = set->nodeTab[i];
1159 
1160 			cur = cur->next;
1161 			while (cur != NULL) {
1162 			    switch(cur->type) {
1163 				case XML_TEXT_NODE:
1164 				case XML_CDATA_SECTION_NODE:
1165 				case XML_ELEMENT_NODE:
1166 				case XML_ENTITY_REF_NODE:
1167 				case XML_ENTITY_NODE:
1168 				case XML_PI_NODE:
1169 				case XML_COMMENT_NODE:
1170 				    tmp = xmlXIncludeCopyNode(ctxt, target,
1171 							      source, cur);
1172 				    if (last == NULL) {
1173 					list = last = tmp;
1174 				    } else {
1175 					xmlAddNextSibling(last, tmp);
1176 					last = tmp;
1177 				    }
1178 				    cur = cur->next;
1179 				    continue;
1180 				default:
1181 				    break;
1182 			    }
1183 			    break;
1184 			}
1185 			continue;
1186 		    }
1187 		    case XML_ATTRIBUTE_NODE:
1188 		    case XML_NAMESPACE_DECL:
1189 		    case XML_DOCUMENT_TYPE_NODE:
1190 		    case XML_DOCUMENT_FRAG_NODE:
1191 		    case XML_NOTATION_NODE:
1192 		    case XML_DTD_NODE:
1193 		    case XML_ELEMENT_DECL:
1194 		    case XML_ATTRIBUTE_DECL:
1195 		    case XML_ENTITY_DECL:
1196 			continue; /* for */
1197 		}
1198 		if (last == NULL)
1199 		    list = last = xmlXIncludeCopyNode(ctxt, target, source,
1200 			                              set->nodeTab[i]);
1201 		else {
1202 		    xmlAddNextSibling(last,
1203 			    xmlXIncludeCopyNode(ctxt, target, source,
1204 				                set->nodeTab[i]));
1205 		    if (last->next != NULL)
1206 			last = last->next;
1207 		}
1208 	    }
1209 	    break;
1210 	}
1211 #ifdef LIBXML_XPTR_ENABLED
1212 	case XPATH_LOCATIONSET: {
1213 	    xmlLocationSetPtr set = (xmlLocationSetPtr) obj->user;
1214 	    if (set == NULL)
1215 		return(NULL);
1216 	    for (i = 0;i < set->locNr;i++) {
1217 		if (last == NULL)
1218 		    list = last = xmlXIncludeCopyXPointer(ctxt, target, source,
1219 			                                  set->locTab[i]);
1220 		else
1221 		    xmlAddNextSibling(last,
1222 			    xmlXIncludeCopyXPointer(ctxt, target, source,
1223 				                    set->locTab[i]));
1224 		if (last != NULL) {
1225 		    while (last->next != NULL)
1226 			last = last->next;
1227 		}
1228 	    }
1229 	    break;
1230 	}
1231 	case XPATH_RANGE:
1232 	    return(xmlXIncludeCopyRange(ctxt, target, source, obj));
1233 #endif
1234 	case XPATH_POINT:
1235 	    /* points are ignored in XInclude */
1236 	    break;
1237 	default:
1238 	    break;
1239     }
1240     return(list);
1241 }
1242 /************************************************************************
1243  *									*
1244  *			XInclude I/O handling				*
1245  *									*
1246  ************************************************************************/
1247 
1248 typedef struct _xmlXIncludeMergeData xmlXIncludeMergeData;
1249 typedef xmlXIncludeMergeData *xmlXIncludeMergeDataPtr;
1250 struct _xmlXIncludeMergeData {
1251     xmlDocPtr doc;
1252     xmlXIncludeCtxtPtr ctxt;
1253 };
1254 
1255 /**
1256  * xmlXIncludeMergeOneEntity:
1257  * @ent: the entity
1258  * @doc:  the including doc
1259  * @nr: the entity name
1260  *
1261  * Inplements the merge of one entity
1262  */
1263 static void
xmlXIncludeMergeEntity(xmlEntityPtr ent,xmlXIncludeMergeDataPtr data,xmlChar * name ATTRIBUTE_UNUSED)1264 xmlXIncludeMergeEntity(xmlEntityPtr ent, xmlXIncludeMergeDataPtr data,
1265 	               xmlChar *name ATTRIBUTE_UNUSED) {
1266     xmlEntityPtr ret, prev;
1267     xmlDocPtr doc;
1268     xmlXIncludeCtxtPtr ctxt;
1269 
1270     if ((ent == NULL) || (data == NULL))
1271 	return;
1272     ctxt = data->ctxt;
1273     doc = data->doc;
1274     if ((ctxt == NULL) || (doc == NULL))
1275 	return;
1276     switch (ent->etype) {
1277         case XML_INTERNAL_PARAMETER_ENTITY:
1278         case XML_EXTERNAL_PARAMETER_ENTITY:
1279         case XML_INTERNAL_PREDEFINED_ENTITY:
1280 	    return;
1281         case XML_INTERNAL_GENERAL_ENTITY:
1282         case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
1283         case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
1284 	    break;
1285     }
1286     ret = xmlAddDocEntity(doc, ent->name, ent->etype, ent->ExternalID,
1287 			  ent->SystemID, ent->content);
1288     if (ret != NULL) {
1289 	if (ent->URI != NULL)
1290 	    ret->URI = xmlStrdup(ent->URI);
1291     } else {
1292 	prev = xmlGetDocEntity(doc, ent->name);
1293 	if (prev != NULL) {
1294 	    if (ent->etype != prev->etype)
1295 		goto error;
1296 
1297 	    if ((ent->SystemID != NULL) && (prev->SystemID != NULL)) {
1298 		if (!xmlStrEqual(ent->SystemID, prev->SystemID))
1299 		    goto error;
1300 	    } else if ((ent->ExternalID != NULL) &&
1301 		       (prev->ExternalID != NULL)) {
1302 		if (!xmlStrEqual(ent->ExternalID, prev->ExternalID))
1303 		    goto error;
1304 	    } else if ((ent->content != NULL) && (prev->content != NULL)) {
1305 		if (!xmlStrEqual(ent->content, prev->content))
1306 		    goto error;
1307 	    } else {
1308 		goto error;
1309 	    }
1310 
1311 	}
1312     }
1313     return;
1314 error:
1315     switch (ent->etype) {
1316         case XML_INTERNAL_PARAMETER_ENTITY:
1317         case XML_EXTERNAL_PARAMETER_ENTITY:
1318         case XML_INTERNAL_PREDEFINED_ENTITY:
1319         case XML_INTERNAL_GENERAL_ENTITY:
1320         case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
1321 	    return;
1322         case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
1323 	    break;
1324     }
1325     xmlXIncludeErr(ctxt, (xmlNodePtr) ent, XML_XINCLUDE_ENTITY_DEF_MISMATCH,
1326                    "mismatch in redefinition of entity %s\n",
1327 		   ent->name);
1328 }
1329 
1330 /**
1331  * xmlXIncludeMergeEntities:
1332  * @ctxt: an XInclude context
1333  * @doc:  the including doc
1334  * @from:  the included doc
1335  *
1336  * Inplements the entity merge
1337  *
1338  * Returns 0 if merge succeeded, -1 if some processing failed
1339  */
1340 static int
xmlXIncludeMergeEntities(xmlXIncludeCtxtPtr ctxt,xmlDocPtr doc,xmlDocPtr from)1341 xmlXIncludeMergeEntities(xmlXIncludeCtxtPtr ctxt, xmlDocPtr doc,
1342 	                 xmlDocPtr from) {
1343     xmlNodePtr cur;
1344     xmlDtdPtr target, source;
1345 
1346     if (ctxt == NULL)
1347 	return(-1);
1348 
1349     if ((from == NULL) || (from->intSubset == NULL))
1350 	return(0);
1351 
1352     target = doc->intSubset;
1353     if (target == NULL) {
1354 	cur = xmlDocGetRootElement(doc);
1355 	if (cur == NULL)
1356 	    return(-1);
1357         target = xmlCreateIntSubset(doc, cur->name, NULL, NULL);
1358 	if (target == NULL)
1359 	    return(-1);
1360     }
1361 
1362     source = from->intSubset;
1363     if ((source != NULL) && (source->entities != NULL)) {
1364 	xmlXIncludeMergeData data;
1365 
1366 	data.ctxt = ctxt;
1367 	data.doc = doc;
1368 
1369 	xmlHashScan((xmlHashTablePtr) source->entities,
1370 		    (xmlHashScanner) xmlXIncludeMergeEntity, &data);
1371     }
1372     source = from->extSubset;
1373     if ((source != NULL) && (source->entities != NULL)) {
1374 	xmlXIncludeMergeData data;
1375 
1376 	data.ctxt = ctxt;
1377 	data.doc = doc;
1378 
1379 	/*
1380 	 * don't duplicate existing stuff when external subsets are the same
1381 	 */
1382 	if ((!xmlStrEqual(target->ExternalID, source->ExternalID)) &&
1383 	    (!xmlStrEqual(target->SystemID, source->SystemID))) {
1384 	    xmlHashScan((xmlHashTablePtr) source->entities,
1385 			(xmlHashScanner) xmlXIncludeMergeEntity, &data);
1386 	}
1387     }
1388     return(0);
1389 }
1390 
1391 /**
1392  * xmlXIncludeLoadDoc:
1393  * @ctxt:  the XInclude context
1394  * @url:  the associated URL
1395  * @nr:  the xinclude node number
1396  *
1397  * Load the document, and store the result in the XInclude context
1398  *
1399  * Returns 0 in case of success, -1 in case of failure
1400  */
1401 static int
xmlXIncludeLoadDoc(xmlXIncludeCtxtPtr ctxt,const xmlChar * url,int nr)1402 xmlXIncludeLoadDoc(xmlXIncludeCtxtPtr ctxt, const xmlChar *url, int nr) {
1403     xmlDocPtr doc;
1404     xmlURIPtr uri;
1405     xmlChar *URL;
1406     xmlChar *fragment = NULL;
1407     int i = 0;
1408 #ifdef LIBXML_XPTR_ENABLED
1409     int saveFlags;
1410 #endif
1411 
1412 #ifdef DEBUG_XINCLUDE
1413     xmlGenericError(xmlGenericErrorContext, "Loading doc %s:%d\n", url, nr);
1414 #endif
1415     /*
1416      * Check the URL and remove any fragment identifier
1417      */
1418     uri = xmlParseURI((const char *)url);
1419     if (uri == NULL) {
1420 	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1421 	               XML_XINCLUDE_HREF_URI,
1422 		       "invalid value URI %s\n", url);
1423 	return(-1);
1424     }
1425     if (uri->fragment != NULL) {
1426 	fragment = (xmlChar *) uri->fragment;
1427 	uri->fragment = NULL;
1428     }
1429     if ((ctxt->incTab != NULL) && (ctxt->incTab[nr] != NULL) &&
1430         (ctxt->incTab[nr]->fragment != NULL)) {
1431 	if (fragment != NULL) xmlFree(fragment);
1432 	fragment = xmlStrdup(ctxt->incTab[nr]->fragment);
1433     }
1434     URL = xmlSaveUri(uri);
1435     xmlFreeURI(uri);
1436     if (URL == NULL) {
1437         if (ctxt->incTab != NULL)
1438 	    xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1439 			   XML_XINCLUDE_HREF_URI,
1440 			   "invalid value URI %s\n", url);
1441 	else
1442 	    xmlXIncludeErr(ctxt, NULL,
1443 			   XML_XINCLUDE_HREF_URI,
1444 			   "invalid value URI %s\n", url);
1445 	if (fragment != NULL)
1446 	    xmlFree(fragment);
1447 	return(-1);
1448     }
1449 
1450     /*
1451      * Handling of references to the local document are done
1452      * directly through ctxt->doc.
1453      */
1454     if ((URL[0] == 0) || (URL[0] == '#') ||
1455 	((ctxt->doc != NULL) && (xmlStrEqual(URL, ctxt->doc->URL)))) {
1456 	doc = NULL;
1457         goto loaded;
1458     }
1459 
1460     /*
1461      * Prevent reloading twice the document.
1462      */
1463     for (i = 0; i < ctxt->incNr; i++) {
1464 	if ((xmlStrEqual(URL, ctxt->incTab[i]->URI)) &&
1465 	    (ctxt->incTab[i]->doc != NULL)) {
1466 	    doc = ctxt->incTab[i]->doc;
1467 #ifdef DEBUG_XINCLUDE
1468 	    printf("Already loaded %s\n", URL);
1469 #endif
1470 	    goto loaded;
1471 	}
1472     }
1473 
1474     /*
1475      * Load it.
1476      */
1477 #ifdef DEBUG_XINCLUDE
1478     printf("loading %s\n", URL);
1479 #endif
1480 #ifdef LIBXML_XPTR_ENABLED
1481     /*
1482      * If this is an XPointer evaluation, we want to assure that
1483      * all entities have been resolved prior to processing the
1484      * referenced document
1485      */
1486     saveFlags = ctxt->parseFlags;
1487     if (fragment != NULL) {	/* if this is an XPointer eval */
1488 	ctxt->parseFlags |= XML_PARSE_NOENT;
1489     }
1490 #endif
1491 
1492     doc = xmlXIncludeParseFile(ctxt, (const char *)URL);
1493 #ifdef LIBXML_XPTR_ENABLED
1494     ctxt->parseFlags = saveFlags;
1495 #endif
1496     if (doc == NULL) {
1497 	xmlFree(URL);
1498 	if (fragment != NULL)
1499 	    xmlFree(fragment);
1500 	return(-1);
1501     }
1502     ctxt->incTab[nr]->doc = doc;
1503     /*
1504      * It's possible that the requested URL has been mapped to a
1505      * completely different location (e.g. through a catalog entry).
1506      * To check for this, we compare the URL with that of the doc
1507      * and change it if they disagree (bug 146988).
1508      */
1509    if (!xmlStrEqual(URL, doc->URL)) {
1510        xmlFree(URL);
1511        URL = xmlStrdup(doc->URL);
1512    }
1513     for (i = nr + 1; i < ctxt->incNr; i++) {
1514 	if (xmlStrEqual(URL, ctxt->incTab[i]->URI)) {
1515 	    ctxt->incTab[nr]->count++;
1516 #ifdef DEBUG_XINCLUDE
1517 	    printf("Increasing %s count since reused\n", URL);
1518 #endif
1519             break;
1520 	}
1521     }
1522 
1523     /*
1524      * Make sure we have all entities fixed up
1525      */
1526     xmlXIncludeMergeEntities(ctxt, ctxt->doc, doc);
1527 
1528     /*
1529      * We don't need the DTD anymore, free up space
1530     if (doc->intSubset != NULL) {
1531 	xmlUnlinkNode((xmlNodePtr) doc->intSubset);
1532 	xmlFreeNode((xmlNodePtr) doc->intSubset);
1533 	doc->intSubset = NULL;
1534     }
1535     if (doc->extSubset != NULL) {
1536 	xmlUnlinkNode((xmlNodePtr) doc->extSubset);
1537 	xmlFreeNode((xmlNodePtr) doc->extSubset);
1538 	doc->extSubset = NULL;
1539     }
1540      */
1541     xmlXIncludeRecurseDoc(ctxt, doc, URL);
1542 
1543 loaded:
1544     if (fragment == NULL) {
1545 	/*
1546 	 * Add the top children list as the replacement copy.
1547 	 */
1548 	if (doc == NULL)
1549 	{
1550 	    /* Hopefully a DTD declaration won't be copied from
1551 	     * the same document */
1552 	    ctxt->incTab[nr]->inc = xmlCopyNodeList(ctxt->doc->children);
1553 	} else {
1554 	    ctxt->incTab[nr]->inc = xmlXIncludeCopyNodeList(ctxt, ctxt->doc,
1555 		                                       doc, doc->children);
1556 	}
1557     }
1558 #ifdef LIBXML_XPTR_ENABLED
1559     else {
1560 	/*
1561 	 * Computes the XPointer expression and make a copy used
1562 	 * as the replacement copy.
1563 	 */
1564 	xmlXPathObjectPtr xptr;
1565 	xmlXPathContextPtr xptrctxt;
1566 	xmlNodeSetPtr set;
1567 
1568 	if (doc == NULL) {
1569 	    xptrctxt = xmlXPtrNewContext(ctxt->doc, ctxt->incTab[nr]->ref,
1570 		                         NULL);
1571 	} else {
1572 	    xptrctxt = xmlXPtrNewContext(doc, NULL, NULL);
1573 	}
1574 	if (xptrctxt == NULL) {
1575 	    xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1576 	                   XML_XINCLUDE_XPTR_FAILED,
1577 			   "could not create XPointer context\n", NULL);
1578 	    xmlFree(URL);
1579 	    xmlFree(fragment);
1580 	    return(-1);
1581 	}
1582 	xptr = xmlXPtrEval(fragment, xptrctxt);
1583 	if (xptr == NULL) {
1584 	    xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1585 	                   XML_XINCLUDE_XPTR_FAILED,
1586 			   "XPointer evaluation failed: #%s\n",
1587 			   fragment);
1588 	    xmlXPathFreeContext(xptrctxt);
1589 	    xmlFree(URL);
1590 	    xmlFree(fragment);
1591 	    return(-1);
1592 	}
1593 	switch (xptr->type) {
1594 	    case XPATH_UNDEFINED:
1595 	    case XPATH_BOOLEAN:
1596 	    case XPATH_NUMBER:
1597 	    case XPATH_STRING:
1598 	    case XPATH_POINT:
1599 	    case XPATH_USERS:
1600 	    case XPATH_XSLT_TREE:
1601 		xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1602 		               XML_XINCLUDE_XPTR_RESULT,
1603 			       "XPointer is not a range: #%s\n",
1604 			       fragment);
1605 		xmlXPathFreeContext(xptrctxt);
1606 		xmlFree(URL);
1607 		xmlFree(fragment);
1608 		return(-1);
1609 	    case XPATH_NODESET:
1610 	        if ((xptr->nodesetval == NULL) ||
1611 		    (xptr->nodesetval->nodeNr <= 0)) {
1612 		    xmlXPathFreeContext(xptrctxt);
1613 		    xmlFree(URL);
1614 		    xmlFree(fragment);
1615 		    return(-1);
1616 		}
1617 
1618 	    case XPATH_RANGE:
1619 	    case XPATH_LOCATIONSET:
1620 		break;
1621 	}
1622 	set = xptr->nodesetval;
1623 	if (set != NULL) {
1624 	    for (i = 0;i < set->nodeNr;i++) {
1625 		if (set->nodeTab[i] == NULL)
1626 		    continue;
1627 		switch (set->nodeTab[i]->type) {
1628 		    case XML_ELEMENT_NODE:
1629 		    case XML_TEXT_NODE:
1630 		    case XML_CDATA_SECTION_NODE:
1631 		    case XML_ENTITY_REF_NODE:
1632 		    case XML_ENTITY_NODE:
1633 		    case XML_PI_NODE:
1634 		    case XML_COMMENT_NODE:
1635 		    case XML_DOCUMENT_NODE:
1636 		    case XML_HTML_DOCUMENT_NODE:
1637 #ifdef LIBXML_DOCB_ENABLED
1638 		    case XML_DOCB_DOCUMENT_NODE:
1639 #endif
1640 			continue;
1641 
1642 		    case XML_ATTRIBUTE_NODE:
1643 			xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1644 			               XML_XINCLUDE_XPTR_RESULT,
1645 				       "XPointer selects an attribute: #%s\n",
1646 				       fragment);
1647 			set->nodeTab[i] = NULL;
1648 			continue;
1649 		    case XML_NAMESPACE_DECL:
1650 			xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1651 			               XML_XINCLUDE_XPTR_RESULT,
1652 				       "XPointer selects a namespace: #%s\n",
1653 				       fragment);
1654 			set->nodeTab[i] = NULL;
1655 			continue;
1656 		    case XML_DOCUMENT_TYPE_NODE:
1657 		    case XML_DOCUMENT_FRAG_NODE:
1658 		    case XML_NOTATION_NODE:
1659 		    case XML_DTD_NODE:
1660 		    case XML_ELEMENT_DECL:
1661 		    case XML_ATTRIBUTE_DECL:
1662 		    case XML_ENTITY_DECL:
1663 		    case XML_XINCLUDE_START:
1664 		    case XML_XINCLUDE_END:
1665 			xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1666 			               XML_XINCLUDE_XPTR_RESULT,
1667 				   "XPointer selects unexpected nodes: #%s\n",
1668 				       fragment);
1669 			set->nodeTab[i] = NULL;
1670 			set->nodeTab[i] = NULL;
1671 			continue; /* for */
1672 		}
1673 	    }
1674 	}
1675 	if (doc == NULL) {
1676 	    ctxt->incTab[nr]->xptr = xptr;
1677 	    ctxt->incTab[nr]->inc = NULL;
1678 	} else {
1679 	    ctxt->incTab[nr]->inc =
1680 		xmlXIncludeCopyXPointer(ctxt, ctxt->doc, doc, xptr);
1681 	    xmlXPathFreeObject(xptr);
1682 	}
1683 	xmlXPathFreeContext(xptrctxt);
1684 	xmlFree(fragment);
1685     }
1686 #endif
1687 
1688     /*
1689      * Do the xml:base fixup if needed
1690      */
1691     if ((doc != NULL) && (URL != NULL) &&
1692         (!(ctxt->parseFlags & XML_PARSE_NOBASEFIX)) &&
1693 	(!(doc->parseFlags & XML_PARSE_NOBASEFIX))) {
1694 	xmlNodePtr node;
1695 	xmlChar *base;
1696 	xmlChar *curBase;
1697 
1698 	/*
1699 	 * The base is only adjusted if "necessary", i.e. if the xinclude node
1700 	 * has a base specified, or the URL is relative
1701 	 */
1702 	base = xmlGetNsProp(ctxt->incTab[nr]->ref, BAD_CAST "base",
1703 			XML_XML_NAMESPACE);
1704 	if (base == NULL) {
1705 	    /*
1706 	     * No xml:base on the xinclude node, so we check whether the
1707 	     * URI base is different than (relative to) the context base
1708 	     */
1709 	    curBase = xmlBuildRelativeURI(URL, ctxt->base);
1710 	    if (curBase == NULL) {	/* Error return */
1711 	        xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1712 	               XML_XINCLUDE_HREF_URI,
1713 		       "trying to build relative URI from %s\n", URL);
1714 	    } else {
1715 		/* If the URI doesn't contain a slash, it's not relative */
1716 	        if (!xmlStrchr(curBase, (xmlChar) '/'))
1717 		    xmlFree(curBase);
1718 		else
1719 		    base = curBase;
1720 	    }
1721 	}
1722 	if (base != NULL) {	/* Adjustment may be needed */
1723 	    node = ctxt->incTab[nr]->inc;
1724 	    while (node != NULL) {
1725 		/* Only work on element nodes */
1726 		if (node->type == XML_ELEMENT_NODE) {
1727 		    curBase = xmlNodeGetBase(node->doc, node);
1728 		    /* If no current base, set it */
1729 		    if (curBase == NULL) {
1730 			xmlNodeSetBase(node, base);
1731 		    } else {
1732 			/*
1733 			 * If the current base is the same as the
1734 			 * URL of the document, then reset it to be
1735 			 * the specified xml:base or the relative URI
1736 			 */
1737 			if (xmlStrEqual(curBase, node->doc->URL)) {
1738 			    xmlNodeSetBase(node, base);
1739 			} else {
1740 			    /*
1741 			     * If the element already has an xml:base
1742 			     * set, then relativise it if necessary
1743 			     */
1744 			    xmlChar *xmlBase;
1745 			    xmlBase = xmlGetNsProp(node,
1746 					    BAD_CAST "base",
1747 					    XML_XML_NAMESPACE);
1748 			    if (xmlBase != NULL) {
1749 				xmlChar *relBase;
1750 				relBase = xmlBuildURI(xmlBase, base);
1751 				if (relBase == NULL) { /* error */
1752 				    xmlXIncludeErr(ctxt,
1753 						ctxt->incTab[nr]->ref,
1754 						XML_XINCLUDE_HREF_URI,
1755 					"trying to rebuild base from %s\n",
1756 						xmlBase);
1757 				} else {
1758 				    xmlNodeSetBase(node, relBase);
1759 				    xmlFree(relBase);
1760 				}
1761 				xmlFree(xmlBase);
1762 			    }
1763 			}
1764 			xmlFree(curBase);
1765 		    }
1766 		}
1767 	        node = node->next;
1768 	    }
1769 	    xmlFree(base);
1770 	}
1771     }
1772     if ((nr < ctxt->incNr) && (ctxt->incTab[nr]->doc != NULL) &&
1773 	(ctxt->incTab[nr]->count <= 1)) {
1774 #ifdef DEBUG_XINCLUDE
1775         printf("freeing %s\n", ctxt->incTab[nr]->doc->URL);
1776 #endif
1777 	xmlFreeDoc(ctxt->incTab[nr]->doc);
1778 	ctxt->incTab[nr]->doc = NULL;
1779     }
1780     xmlFree(URL);
1781     return(0);
1782 }
1783 
1784 /**
1785  * xmlXIncludeLoadTxt:
1786  * @ctxt:  the XInclude context
1787  * @url:  the associated URL
1788  * @nr:  the xinclude node number
1789  *
1790  * Load the content, and store the result in the XInclude context
1791  *
1792  * Returns 0 in case of success, -1 in case of failure
1793  */
1794 static int
xmlXIncludeLoadTxt(xmlXIncludeCtxtPtr ctxt,const xmlChar * url,int nr)1795 xmlXIncludeLoadTxt(xmlXIncludeCtxtPtr ctxt, const xmlChar *url, int nr) {
1796     xmlParserInputBufferPtr buf;
1797     xmlNodePtr node;
1798     xmlURIPtr uri;
1799     xmlChar *URL;
1800     int i;
1801     xmlChar *encoding = NULL;
1802     xmlCharEncoding enc = (xmlCharEncoding) 0;
1803     xmlParserCtxtPtr pctxt;
1804     xmlParserInputPtr inputStream;
1805     int xinclude_multibyte_fallback_used = 0;
1806 
1807     /*
1808      * Check the URL and remove any fragment identifier
1809      */
1810     uri = xmlParseURI((const char *)url);
1811     if (uri == NULL) {
1812 	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, XML_XINCLUDE_HREF_URI,
1813 	               "invalid value URI %s\n", url);
1814 	return(-1);
1815     }
1816     if (uri->fragment != NULL) {
1817 	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, XML_XINCLUDE_TEXT_FRAGMENT,
1818 	               "fragment identifier forbidden for text: %s\n",
1819 		       (const xmlChar *) uri->fragment);
1820 	xmlFreeURI(uri);
1821 	return(-1);
1822     }
1823     URL = xmlSaveUri(uri);
1824     xmlFreeURI(uri);
1825     if (URL == NULL) {
1826 	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, XML_XINCLUDE_HREF_URI,
1827 	               "invalid value URI %s\n", url);
1828 	return(-1);
1829     }
1830 
1831     /*
1832      * Handling of references to the local document are done
1833      * directly through ctxt->doc.
1834      */
1835     if (URL[0] == 0) {
1836 	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1837 	               XML_XINCLUDE_TEXT_DOCUMENT,
1838 		       "text serialization of document not available\n", NULL);
1839 	xmlFree(URL);
1840 	return(-1);
1841     }
1842 
1843     /*
1844      * Prevent reloading twice the document.
1845      */
1846     for (i = 0; i < ctxt->txtNr; i++) {
1847 	if (xmlStrEqual(URL, ctxt->txturlTab[i])) {
1848 	    node = xmlCopyNode(ctxt->txtTab[i], 1);
1849 	    goto loaded;
1850 	}
1851     }
1852     /*
1853      * Try to get the encoding if available
1854      */
1855     if ((ctxt->incTab[nr] != NULL) && (ctxt->incTab[nr]->ref != NULL)) {
1856 	encoding = xmlGetProp(ctxt->incTab[nr]->ref, XINCLUDE_PARSE_ENCODING);
1857     }
1858     if (encoding != NULL) {
1859 	/*
1860 	 * TODO: we should not have to remap to the xmlCharEncoding
1861 	 *       predefined set, a better interface than
1862 	 *       xmlParserInputBufferCreateFilename should allow any
1863 	 *       encoding supported by iconv
1864 	 */
1865         enc = xmlParseCharEncoding((const char *) encoding);
1866 	if (enc == XML_CHAR_ENCODING_ERROR) {
1867 	    xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1868 	                   XML_XINCLUDE_UNKNOWN_ENCODING,
1869 			   "encoding %s not supported\n", encoding);
1870 	    xmlFree(encoding);
1871 	    xmlFree(URL);
1872 	    return(-1);
1873 	}
1874 	xmlFree(encoding);
1875     }
1876 
1877     /*
1878      * Load it.
1879      */
1880     pctxt = xmlNewParserCtxt();
1881     inputStream = xmlLoadExternalEntity((const char*)URL, NULL, pctxt);
1882     if(inputStream == NULL) {
1883 	xmlFreeParserCtxt(pctxt);
1884 	xmlFree(URL);
1885 	return(-1);
1886     }
1887     buf = inputStream->buf;
1888     if (buf == NULL) {
1889 	xmlFreeInputStream (inputStream);
1890 	xmlFreeParserCtxt(pctxt);
1891 	xmlFree(URL);
1892 	return(-1);
1893     }
1894     if (buf->encoder)
1895 	xmlCharEncCloseFunc(buf->encoder);
1896     buf->encoder = xmlGetCharEncodingHandler(enc);
1897     node = xmlNewText(NULL);
1898 
1899     /*
1900      * Scan all chars from the resource and add the to the node
1901      */
1902 xinclude_multibyte_fallback:
1903     while (xmlParserInputBufferRead(buf, 128) > 0) {
1904 	int len;
1905 	const xmlChar *content;
1906 
1907 	content = xmlBufContent(buf->buffer);
1908 	len = xmlBufLength(buf->buffer);
1909 	for (i = 0;i < len;) {
1910 	    int cur;
1911 	    int l;
1912 
1913 	    cur = xmlStringCurrentChar(NULL, &content[i], &l);
1914 	    if (!IS_CHAR(cur)) {
1915 		/* Handle splitted multibyte char at buffer boundary */
1916 		if (((len - i) < 4) && (!xinclude_multibyte_fallback_used)) {
1917 		    xinclude_multibyte_fallback_used = 1;
1918 		    xmlBufShrink(buf->buffer, i);
1919 		    goto xinclude_multibyte_fallback;
1920 		} else {
1921 		    xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1922 				   XML_XINCLUDE_INVALID_CHAR,
1923 				   "%s contains invalid char\n", URL);
1924 		    xmlFreeParserInputBuffer(buf);
1925 		    xmlFree(URL);
1926 		    return(-1);
1927 		}
1928 	    } else {
1929 		xinclude_multibyte_fallback_used = 0;
1930 		xmlNodeAddContentLen(node, &content[i], l);
1931 	    }
1932 	    i += l;
1933 	}
1934 	xmlBufShrink(buf->buffer, len);
1935     }
1936     xmlFreeParserCtxt(pctxt);
1937     xmlXIncludeAddTxt(ctxt, node, URL);
1938     xmlFreeInputStream(inputStream);
1939 
1940 loaded:
1941     /*
1942      * Add the element as the replacement copy.
1943      */
1944     ctxt->incTab[nr]->inc = node;
1945     xmlFree(URL);
1946     return(0);
1947 }
1948 
1949 /**
1950  * xmlXIncludeLoadFallback:
1951  * @ctxt:  the XInclude context
1952  * @fallback:  the fallback node
1953  * @nr:  the xinclude node number
1954  *
1955  * Load the content of the fallback node, and store the result
1956  * in the XInclude context
1957  *
1958  * Returns 0 in case of success, -1 in case of failure
1959  */
1960 static int
xmlXIncludeLoadFallback(xmlXIncludeCtxtPtr ctxt,xmlNodePtr fallback,int nr)1961 xmlXIncludeLoadFallback(xmlXIncludeCtxtPtr ctxt, xmlNodePtr fallback, int nr) {
1962     xmlXIncludeCtxtPtr newctxt;
1963     int ret = 0;
1964 
1965     if ((fallback == NULL) || (fallback->type == XML_NAMESPACE_DECL) ||
1966         (ctxt == NULL))
1967 	return(-1);
1968     if (fallback->children != NULL) {
1969 	/*
1970 	 * It's possible that the fallback also has 'includes'
1971 	 * (Bug 129969), so we re-process the fallback just in case
1972 	 */
1973 	newctxt = xmlXIncludeNewContext(ctxt->doc);
1974 	if (newctxt == NULL)
1975 	    return (-1);
1976 	newctxt->_private = ctxt->_private;
1977 	newctxt->base = xmlStrdup(ctxt->base);	/* Inherit the base from the existing context */
1978 	xmlXIncludeSetFlags(newctxt, ctxt->parseFlags);
1979 	ret = xmlXIncludeDoProcess(newctxt, ctxt->doc, fallback->children);
1980 	if (ctxt->nbErrors > 0)
1981 	    ret = -1;
1982 	else if (ret > 0)
1983 	    ret = 0;	/* xmlXIncludeDoProcess can return +ve number */
1984 	xmlXIncludeFreeContext(newctxt);
1985 
1986 	ctxt->incTab[nr]->inc = xmlDocCopyNodeList(ctxt->doc,
1987 	                                           fallback->children);
1988     } else {
1989         ctxt->incTab[nr]->inc = NULL;
1990 	ctxt->incTab[nr]->emptyFb = 1;	/* flag empty callback */
1991     }
1992     return(ret);
1993 }
1994 
1995 /************************************************************************
1996  *									*
1997  *			XInclude Processing				*
1998  *									*
1999  ************************************************************************/
2000 
2001 /**
2002  * xmlXIncludePreProcessNode:
2003  * @ctxt: an XInclude context
2004  * @node: an XInclude node
2005  *
2006  * Implement the XInclude preprocessing, currently just adding the element
2007  * for further processing.
2008  *
2009  * Returns the result list or NULL in case of error
2010  */
2011 static xmlNodePtr
xmlXIncludePreProcessNode(xmlXIncludeCtxtPtr ctxt,xmlNodePtr node)2012 xmlXIncludePreProcessNode(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node) {
2013     xmlXIncludeAddNode(ctxt, node);
2014     return(NULL);
2015 }
2016 
2017 /**
2018  * xmlXIncludeLoadNode:
2019  * @ctxt: an XInclude context
2020  * @nr: the node number
2021  *
2022  * Find and load the infoset replacement for the given node.
2023  *
2024  * Returns 0 if substitution succeeded, -1 if some processing failed
2025  */
2026 static int
xmlXIncludeLoadNode(xmlXIncludeCtxtPtr ctxt,int nr)2027 xmlXIncludeLoadNode(xmlXIncludeCtxtPtr ctxt, int nr) {
2028     xmlNodePtr cur;
2029     xmlChar *href;
2030     xmlChar *parse;
2031     xmlChar *base;
2032     xmlChar *oldBase;
2033     xmlChar *URI;
2034     int xml = 1; /* default Issue 64 */
2035     int ret;
2036 
2037     if (ctxt == NULL)
2038 	return(-1);
2039     if ((nr < 0) || (nr >= ctxt->incNr))
2040 	return(-1);
2041     cur = ctxt->incTab[nr]->ref;
2042     if (cur == NULL)
2043 	return(-1);
2044 
2045     /*
2046      * read the attributes
2047      */
2048     href = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_HREF);
2049     if (href == NULL) {
2050 	href = xmlStrdup(BAD_CAST ""); /* @@@@ href is now optional */
2051 	if (href == NULL)
2052 	    return(-1);
2053     }
2054     parse = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_PARSE);
2055     if (parse != NULL) {
2056 	if (xmlStrEqual(parse, XINCLUDE_PARSE_XML))
2057 	    xml = 1;
2058 	else if (xmlStrEqual(parse, XINCLUDE_PARSE_TEXT))
2059 	    xml = 0;
2060 	else {
2061 	    xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
2062 	                   XML_XINCLUDE_PARSE_VALUE,
2063 			   "invalid value %s for 'parse'\n", parse);
2064 	    if (href != NULL)
2065 		xmlFree(href);
2066 	    if (parse != NULL)
2067 		xmlFree(parse);
2068 	    return(-1);
2069 	}
2070     }
2071 
2072     /*
2073      * compute the URI
2074      */
2075     base = xmlNodeGetBase(ctxt->doc, cur);
2076     if (base == NULL) {
2077 	URI = xmlBuildURI(href, ctxt->doc->URL);
2078     } else {
2079 	URI = xmlBuildURI(href, base);
2080     }
2081     if (URI == NULL) {
2082 	xmlChar *escbase;
2083 	xmlChar *eschref;
2084 	/*
2085 	 * Some escaping may be needed
2086 	 */
2087 	escbase = xmlURIEscape(base);
2088 	eschref = xmlURIEscape(href);
2089 	URI = xmlBuildURI(eschref, escbase);
2090 	if (escbase != NULL)
2091 	    xmlFree(escbase);
2092 	if (eschref != NULL)
2093 	    xmlFree(eschref);
2094     }
2095     if (URI == NULL) {
2096 	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
2097 	               XML_XINCLUDE_HREF_URI, "failed build URL\n", NULL);
2098 	if (parse != NULL)
2099 	    xmlFree(parse);
2100 	if (href != NULL)
2101 	    xmlFree(href);
2102 	if (base != NULL)
2103 	    xmlFree(base);
2104 	return(-1);
2105     }
2106 #ifdef DEBUG_XINCLUDE
2107     xmlGenericError(xmlGenericErrorContext, "parse: %s\n",
2108 	    xml ? "xml": "text");
2109     xmlGenericError(xmlGenericErrorContext, "URI: %s\n", URI);
2110 #endif
2111 
2112     /*
2113      * Save the base for this include (saving the current one)
2114      */
2115     oldBase = ctxt->base;
2116     ctxt->base = base;
2117 
2118     if (xml) {
2119 	ret = xmlXIncludeLoadDoc(ctxt, URI, nr);
2120 	/* xmlXIncludeGetFragment(ctxt, cur, URI); */
2121     } else {
2122 	ret = xmlXIncludeLoadTxt(ctxt, URI, nr);
2123     }
2124 
2125     /*
2126      * Restore the original base before checking for fallback
2127      */
2128     ctxt->base = oldBase;
2129 
2130     if (ret < 0) {
2131 	xmlNodePtr children;
2132 
2133 	/*
2134 	 * Time to try a fallback if availble
2135 	 */
2136 #ifdef DEBUG_XINCLUDE
2137 	xmlGenericError(xmlGenericErrorContext, "error looking for fallback\n");
2138 #endif
2139 	children = cur->children;
2140 	while (children != NULL) {
2141 	    if ((children->type == XML_ELEMENT_NODE) &&
2142 		(children->ns != NULL) &&
2143 		(xmlStrEqual(children->name, XINCLUDE_FALLBACK)) &&
2144 		((xmlStrEqual(children->ns->href, XINCLUDE_NS)) ||
2145 		 (xmlStrEqual(children->ns->href, XINCLUDE_OLD_NS)))) {
2146 		ret = xmlXIncludeLoadFallback(ctxt, children, nr);
2147 		if (ret == 0)
2148 		    break;
2149 	    }
2150 	    children = children->next;
2151 	}
2152     }
2153     if (ret < 0) {
2154 	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
2155 	               XML_XINCLUDE_NO_FALLBACK,
2156 		       "could not load %s, and no fallback was found\n",
2157 		       URI);
2158     }
2159 
2160     /*
2161      * Cleanup
2162      */
2163     if (URI != NULL)
2164 	xmlFree(URI);
2165     if (parse != NULL)
2166 	xmlFree(parse);
2167     if (href != NULL)
2168 	xmlFree(href);
2169     if (base != NULL)
2170 	xmlFree(base);
2171     return(0);
2172 }
2173 
2174 /**
2175  * xmlXIncludeIncludeNode:
2176  * @ctxt: an XInclude context
2177  * @nr: the node number
2178  *
2179  * Inplement the infoset replacement for the given node
2180  *
2181  * Returns 0 if substitution succeeded, -1 if some processing failed
2182  */
2183 static int
xmlXIncludeIncludeNode(xmlXIncludeCtxtPtr ctxt,int nr)2184 xmlXIncludeIncludeNode(xmlXIncludeCtxtPtr ctxt, int nr) {
2185     xmlNodePtr cur, end, list, tmp;
2186 
2187     if (ctxt == NULL)
2188 	return(-1);
2189     if ((nr < 0) || (nr >= ctxt->incNr))
2190 	return(-1);
2191     cur = ctxt->incTab[nr]->ref;
2192     if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL))
2193 	return(-1);
2194 
2195     /*
2196      * If we stored an XPointer a late computation may be needed
2197      */
2198     if ((ctxt->incTab[nr]->inc == NULL) &&
2199 	(ctxt->incTab[nr]->xptr != NULL)) {
2200 	ctxt->incTab[nr]->inc =
2201 	    xmlXIncludeCopyXPointer(ctxt, ctxt->doc, ctxt->doc,
2202 		                    ctxt->incTab[nr]->xptr);
2203 	xmlXPathFreeObject(ctxt->incTab[nr]->xptr);
2204 	ctxt->incTab[nr]->xptr = NULL;
2205     }
2206     list = ctxt->incTab[nr]->inc;
2207     ctxt->incTab[nr]->inc = NULL;
2208 
2209     /*
2210      * Check against the risk of generating a multi-rooted document
2211      */
2212     if ((cur->parent != NULL) &&
2213 	(cur->parent->type != XML_ELEMENT_NODE)) {
2214 	int nb_elem = 0;
2215 
2216 	tmp = list;
2217 	while (tmp != NULL) {
2218 	    if (tmp->type == XML_ELEMENT_NODE)
2219 		nb_elem++;
2220 	    tmp = tmp->next;
2221 	}
2222 	if (nb_elem > 1) {
2223 	    xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
2224 	                   XML_XINCLUDE_MULTIPLE_ROOT,
2225 		       "XInclude error: would result in multiple root nodes\n",
2226 			   NULL);
2227 	    return(-1);
2228 	}
2229     }
2230 
2231     if (ctxt->parseFlags & XML_PARSE_NOXINCNODE) {
2232 	/*
2233 	 * Add the list of nodes
2234 	 */
2235 	while (list != NULL) {
2236 	    end = list;
2237 	    list = list->next;
2238 
2239 	    xmlAddPrevSibling(cur, end);
2240 	}
2241 	xmlUnlinkNode(cur);
2242 	xmlFreeNode(cur);
2243     } else {
2244 	/*
2245 	 * Change the current node as an XInclude start one, and add an
2246 	 * XInclude end one
2247 	 */
2248 	cur->type = XML_XINCLUDE_START;
2249 	end = xmlNewDocNode(cur->doc, cur->ns, cur->name, NULL);
2250 	if (end == NULL) {
2251 	    xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
2252 	                   XML_XINCLUDE_BUILD_FAILED,
2253 			   "failed to build node\n", NULL);
2254 	    return(-1);
2255 	}
2256 	end->type = XML_XINCLUDE_END;
2257 	xmlAddNextSibling(cur, end);
2258 
2259 	/*
2260 	 * Add the list of nodes
2261 	 */
2262 	while (list != NULL) {
2263 	    cur = list;
2264 	    list = list->next;
2265 
2266 	    xmlAddPrevSibling(end, cur);
2267 	}
2268     }
2269 
2270 
2271     return(0);
2272 }
2273 
2274 /**
2275  * xmlXIncludeTestNode:
2276  * @ctxt: the XInclude processing context
2277  * @node: an XInclude node
2278  *
2279  * test if the node is an XInclude node
2280  *
2281  * Returns 1 true, 0 otherwise
2282  */
2283 static int
xmlXIncludeTestNode(xmlXIncludeCtxtPtr ctxt,xmlNodePtr node)2284 xmlXIncludeTestNode(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node) {
2285     if (node == NULL)
2286 	return(0);
2287     if (node->type != XML_ELEMENT_NODE)
2288 	return(0);
2289     if (node->ns == NULL)
2290 	return(0);
2291     if ((xmlStrEqual(node->ns->href, XINCLUDE_NS)) ||
2292         (xmlStrEqual(node->ns->href, XINCLUDE_OLD_NS))) {
2293 	if (xmlStrEqual(node->ns->href, XINCLUDE_OLD_NS)) {
2294 	    if (ctxt->legacy == 0) {
2295 #if 0 /* wait for the XML Core Working Group to get something stable ! */
2296 		xmlXIncludeWarn(ctxt, node, XML_XINCLUDE_DEPRECATED_NS,
2297 	               "Deprecated XInclude namespace found, use %s",
2298 		                XINCLUDE_NS);
2299 #endif
2300 	        ctxt->legacy = 1;
2301 	    }
2302 	}
2303 	if (xmlStrEqual(node->name, XINCLUDE_NODE)) {
2304 	    xmlNodePtr child = node->children;
2305 	    int nb_fallback = 0;
2306 
2307 	    while (child != NULL) {
2308 		if ((child->type == XML_ELEMENT_NODE) &&
2309 		    (child->ns != NULL) &&
2310 		    ((xmlStrEqual(child->ns->href, XINCLUDE_NS)) ||
2311 		     (xmlStrEqual(child->ns->href, XINCLUDE_OLD_NS)))) {
2312 		    if (xmlStrEqual(child->name, XINCLUDE_NODE)) {
2313 			xmlXIncludeErr(ctxt, node,
2314 			               XML_XINCLUDE_INCLUDE_IN_INCLUDE,
2315 				       "%s has an 'include' child\n",
2316 				       XINCLUDE_NODE);
2317 			return(0);
2318 		    }
2319 		    if (xmlStrEqual(child->name, XINCLUDE_FALLBACK)) {
2320 			nb_fallback++;
2321 		    }
2322 		}
2323 		child = child->next;
2324 	    }
2325 	    if (nb_fallback > 1) {
2326 		xmlXIncludeErr(ctxt, node, XML_XINCLUDE_FALLBACKS_IN_INCLUDE,
2327 			       "%s has multiple fallback children\n",
2328 		               XINCLUDE_NODE);
2329 		return(0);
2330 	    }
2331 	    return(1);
2332 	}
2333 	if (xmlStrEqual(node->name, XINCLUDE_FALLBACK)) {
2334 	    if ((node->parent == NULL) ||
2335 		(node->parent->type != XML_ELEMENT_NODE) ||
2336 		(node->parent->ns == NULL) ||
2337 		((!xmlStrEqual(node->parent->ns->href, XINCLUDE_NS)) &&
2338 		 (!xmlStrEqual(node->parent->ns->href, XINCLUDE_OLD_NS))) ||
2339 		(!xmlStrEqual(node->parent->name, XINCLUDE_NODE))) {
2340 		xmlXIncludeErr(ctxt, node,
2341 		               XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE,
2342 			       "%s is not the child of an 'include'\n",
2343 			       XINCLUDE_FALLBACK);
2344 	    }
2345 	}
2346     }
2347     return(0);
2348 }
2349 
2350 /**
2351  * xmlXIncludeDoProcess:
2352  * @ctxt: the XInclude processing context
2353  * @doc: an XML document
2354  * @tree: the top of the tree to process
2355  *
2356  * Implement the XInclude substitution on the XML document @doc
2357  *
2358  * Returns 0 if no substitution were done, -1 if some processing failed
2359  *    or the number of substitutions done.
2360  */
2361 static int
xmlXIncludeDoProcess(xmlXIncludeCtxtPtr ctxt,xmlDocPtr doc,xmlNodePtr tree)2362 xmlXIncludeDoProcess(xmlXIncludeCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr tree) {
2363     xmlNodePtr cur;
2364     int ret = 0;
2365     int i, start;
2366 
2367     if ((doc == NULL) || (tree == NULL) || (tree->type == XML_NAMESPACE_DECL))
2368 	return(-1);
2369     if (ctxt == NULL)
2370 	return(-1);
2371 
2372     if (doc->URL != NULL) {
2373 	ret = xmlXIncludeURLPush(ctxt, doc->URL);
2374 	if (ret < 0)
2375 	    return(-1);
2376     }
2377     start = ctxt->incNr;
2378 
2379     /*
2380      * First phase: lookup the elements in the document
2381      */
2382     cur = tree;
2383     if (xmlXIncludeTestNode(ctxt, cur) == 1)
2384 	xmlXIncludePreProcessNode(ctxt, cur);
2385     while ((cur != NULL) && (cur != tree->parent)) {
2386 	/* TODO: need to work on entities -> stack */
2387 	if ((cur->children != NULL) &&
2388 	    (cur->children->type != XML_ENTITY_DECL) &&
2389 	    (cur->children->type != XML_XINCLUDE_START) &&
2390 	    (cur->children->type != XML_XINCLUDE_END)) {
2391 	    cur = cur->children;
2392 	    if (xmlXIncludeTestNode(ctxt, cur))
2393 		xmlXIncludePreProcessNode(ctxt, cur);
2394 	} else if (cur->next != NULL) {
2395 	    cur = cur->next;
2396 	    if (xmlXIncludeTestNode(ctxt, cur))
2397 		xmlXIncludePreProcessNode(ctxt, cur);
2398 	} else {
2399 	    if (cur == tree)
2400 	        break;
2401 	    do {
2402 		cur = cur->parent;
2403 		if ((cur == NULL) || (cur == tree->parent))
2404 		    break; /* do */
2405 		if (cur->next != NULL) {
2406 		    cur = cur->next;
2407 		    if (xmlXIncludeTestNode(ctxt, cur))
2408 			xmlXIncludePreProcessNode(ctxt, cur);
2409 		    break; /* do */
2410 		}
2411 	    } while (cur != NULL);
2412 	}
2413     }
2414 
2415     /*
2416      * Second Phase : collect the infosets fragments
2417      */
2418     for (i = start;i < ctxt->incNr; i++) {
2419         xmlXIncludeLoadNode(ctxt, i);
2420 	ret++;
2421     }
2422 
2423     /*
2424      * Third phase: extend the original document infoset.
2425      *
2426      * Originally we bypassed the inclusion if there were any errors
2427      * encountered on any of the XIncludes.  A bug was raised (bug
2428      * 132588) requesting that we output the XIncludes without error,
2429      * so the check for inc!=NULL || xptr!=NULL was put in.  This may
2430      * give some other problems in the future, but for now it seems to
2431      * work ok.
2432      *
2433      */
2434     for (i = ctxt->incBase;i < ctxt->incNr; i++) {
2435 	if ((ctxt->incTab[i]->inc != NULL) ||
2436 		(ctxt->incTab[i]->xptr != NULL) ||
2437 		(ctxt->incTab[i]->emptyFb != 0))	/* (empty fallback) */
2438 	    xmlXIncludeIncludeNode(ctxt, i);
2439     }
2440 
2441     if (doc->URL != NULL)
2442 	xmlXIncludeURLPop(ctxt);
2443     return(ret);
2444 }
2445 
2446 /**
2447  * xmlXIncludeSetFlags:
2448  * @ctxt:  an XInclude processing context
2449  * @flags: a set of xmlParserOption used for parsing XML includes
2450  *
2451  * Set the flags used for further processing of XML resources.
2452  *
2453  * Returns 0 in case of success and -1 in case of error.
2454  */
2455 int
xmlXIncludeSetFlags(xmlXIncludeCtxtPtr ctxt,int flags)2456 xmlXIncludeSetFlags(xmlXIncludeCtxtPtr ctxt, int flags) {
2457     if (ctxt == NULL)
2458         return(-1);
2459     ctxt->parseFlags = flags;
2460     return(0);
2461 }
2462 
2463 /**
2464  * xmlXIncludeProcessTreeFlagsData:
2465  * @tree: an XML node
2466  * @flags: a set of xmlParserOption used for parsing XML includes
2467  * @data: application data that will be passed to the parser context
2468  *        in the _private field of the parser context(s)
2469  *
2470  * Implement the XInclude substitution on the XML node @tree
2471  *
2472  * Returns 0 if no substitution were done, -1 if some processing failed
2473  *    or the number of substitutions done.
2474  */
2475 
2476 int
xmlXIncludeProcessTreeFlagsData(xmlNodePtr tree,int flags,void * data)2477 xmlXIncludeProcessTreeFlagsData(xmlNodePtr tree, int flags, void *data) {
2478     xmlXIncludeCtxtPtr ctxt;
2479     int ret = 0;
2480 
2481     if ((tree == NULL) || (tree->type == XML_NAMESPACE_DECL) ||
2482         (tree->doc == NULL))
2483         return(-1);
2484 
2485     ctxt = xmlXIncludeNewContext(tree->doc);
2486     if (ctxt == NULL)
2487         return(-1);
2488     ctxt->_private = data;
2489     ctxt->base = xmlStrdup((xmlChar *)tree->doc->URL);
2490     xmlXIncludeSetFlags(ctxt, flags);
2491     ret = xmlXIncludeDoProcess(ctxt, tree->doc, tree);
2492     if ((ret >= 0) && (ctxt->nbErrors > 0))
2493         ret = -1;
2494 
2495     xmlXIncludeFreeContext(ctxt);
2496     return(ret);
2497 }
2498 
2499 /**
2500  * xmlXIncludeProcessFlagsData:
2501  * @doc: an XML document
2502  * @flags: a set of xmlParserOption used for parsing XML includes
2503  * @data: application data that will be passed to the parser context
2504  *        in the _private field of the parser context(s)
2505  *
2506  * Implement the XInclude substitution on the XML document @doc
2507  *
2508  * Returns 0 if no substitution were done, -1 if some processing failed
2509  *    or the number of substitutions done.
2510  */
2511 int
xmlXIncludeProcessFlagsData(xmlDocPtr doc,int flags,void * data)2512 xmlXIncludeProcessFlagsData(xmlDocPtr doc, int flags, void *data) {
2513     xmlNodePtr tree;
2514 
2515     if (doc == NULL)
2516 	return(-1);
2517     tree = xmlDocGetRootElement(doc);
2518     if (tree == NULL)
2519 	return(-1);
2520     return(xmlXIncludeProcessTreeFlagsData(tree, flags, data));
2521 }
2522 
2523 /**
2524  * xmlXIncludeProcessFlags:
2525  * @doc: an XML document
2526  * @flags: a set of xmlParserOption used for parsing XML includes
2527  *
2528  * Implement the XInclude substitution on the XML document @doc
2529  *
2530  * Returns 0 if no substitution were done, -1 if some processing failed
2531  *    or the number of substitutions done.
2532  */
2533 int
xmlXIncludeProcessFlags(xmlDocPtr doc,int flags)2534 xmlXIncludeProcessFlags(xmlDocPtr doc, int flags) {
2535     return xmlXIncludeProcessFlagsData(doc, flags, NULL);
2536 }
2537 
2538 /**
2539  * xmlXIncludeProcess:
2540  * @doc: an XML document
2541  *
2542  * Implement the XInclude substitution on the XML document @doc
2543  *
2544  * Returns 0 if no substitution were done, -1 if some processing failed
2545  *    or the number of substitutions done.
2546  */
2547 int
xmlXIncludeProcess(xmlDocPtr doc)2548 xmlXIncludeProcess(xmlDocPtr doc) {
2549     return(xmlXIncludeProcessFlags(doc, 0));
2550 }
2551 
2552 /**
2553  * xmlXIncludeProcessTreeFlags:
2554  * @tree: a node in an XML document
2555  * @flags: a set of xmlParserOption used for parsing XML includes
2556  *
2557  * Implement the XInclude substitution for the given subtree
2558  *
2559  * Returns 0 if no substitution were done, -1 if some processing failed
2560  *    or the number of substitutions done.
2561  */
2562 int
xmlXIncludeProcessTreeFlags(xmlNodePtr tree,int flags)2563 xmlXIncludeProcessTreeFlags(xmlNodePtr tree, int flags) {
2564     xmlXIncludeCtxtPtr ctxt;
2565     int ret = 0;
2566 
2567     if ((tree == NULL) || (tree->type == XML_NAMESPACE_DECL) ||
2568         (tree->doc == NULL))
2569 	return(-1);
2570     ctxt = xmlXIncludeNewContext(tree->doc);
2571     if (ctxt == NULL)
2572 	return(-1);
2573     ctxt->base = xmlNodeGetBase(tree->doc, tree);
2574     xmlXIncludeSetFlags(ctxt, flags);
2575     ret = xmlXIncludeDoProcess(ctxt, tree->doc, tree);
2576     if ((ret >= 0) && (ctxt->nbErrors > 0))
2577 	ret = -1;
2578 
2579     xmlXIncludeFreeContext(ctxt);
2580     return(ret);
2581 }
2582 
2583 /**
2584  * xmlXIncludeProcessTree:
2585  * @tree: a node in an XML document
2586  *
2587  * Implement the XInclude substitution for the given subtree
2588  *
2589  * Returns 0 if no substitution were done, -1 if some processing failed
2590  *    or the number of substitutions done.
2591  */
2592 int
xmlXIncludeProcessTree(xmlNodePtr tree)2593 xmlXIncludeProcessTree(xmlNodePtr tree) {
2594     return(xmlXIncludeProcessTreeFlags(tree, 0));
2595 }
2596 
2597 /**
2598  * xmlXIncludeProcessNode:
2599  * @ctxt: an existing XInclude context
2600  * @node: a node in an XML document
2601  *
2602  * Implement the XInclude substitution for the given subtree reusing
2603  * the informations and data coming from the given context.
2604  *
2605  * Returns 0 if no substitution were done, -1 if some processing failed
2606  *    or the number of substitutions done.
2607  */
2608 int
xmlXIncludeProcessNode(xmlXIncludeCtxtPtr ctxt,xmlNodePtr node)2609 xmlXIncludeProcessNode(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node) {
2610     int ret = 0;
2611 
2612     if ((node == NULL) || (node->type == XML_NAMESPACE_DECL) ||
2613         (node->doc == NULL) || (ctxt == NULL))
2614 	return(-1);
2615     ret = xmlXIncludeDoProcess(ctxt, node->doc, node);
2616     if ((ret >= 0) && (ctxt->nbErrors > 0))
2617 	ret = -1;
2618     return(ret);
2619 }
2620 
2621 #else /* !LIBXML_XINCLUDE_ENABLED */
2622 #endif
2623 #define bottom_xinclude
2624 #include "elfgcchack.h"
2625