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