projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[LWIP] Fix src/core/init.c a bit (#1620)
[reactos.git] / sdk / lib / 3rdparty / libxml2 / xinclude.c
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
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 LIBXML_ATTR_FORMAT(4,0)
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 LIBXML_ATTR_FORMAT(4,0)
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 *
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
1264 xmlXIncludeMergeEntity(void *payload, void *vdata,
1265 const xmlChar *name ATTRIBUTE_UNUSED) {
1266 xmlEntityPtr ent = (xmlEntityPtr) payload;
1267 xmlXIncludeMergeDataPtr data = (xmlXIncludeMergeDataPtr) vdata;
1268 xmlEntityPtr ret, prev;
1269 xmlDocPtr doc;
1270 xmlXIncludeCtxtPtr ctxt;
1271
1272 if ((ent == NULL) || (data == NULL))
1273 return;
1274 ctxt = data->ctxt;
1275 doc = data->doc;
1276 if ((ctxt == NULL) || (doc == NULL))
1277 return;
1278 switch (ent->etype) {
1279 case XML_INTERNAL_PARAMETER_ENTITY:
1280 case XML_EXTERNAL_PARAMETER_ENTITY:
1281 case XML_INTERNAL_PREDEFINED_ENTITY:
1282 return;
1283 case XML_INTERNAL_GENERAL_ENTITY:
1284 case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
1285 case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
1286 break;
1287 }
1288 ret = xmlAddDocEntity(doc, ent->name, ent->etype, ent->ExternalID,
1289 ent->SystemID, ent->content);
1290 if (ret != NULL) {
1291 if (ent->URI != NULL)
1292 ret->URI = xmlStrdup(ent->URI);
1293 } else {
1294 prev = xmlGetDocEntity(doc, ent->name);
1295 if (prev != NULL) {
1296 if (ent->etype != prev->etype)
1297 goto error;
1298
1299 if ((ent->SystemID != NULL) && (prev->SystemID != NULL)) {
1300 if (!xmlStrEqual(ent->SystemID, prev->SystemID))
1301 goto error;
1302 } else if ((ent->ExternalID != NULL) &&
1303 (prev->ExternalID != NULL)) {
1304 if (!xmlStrEqual(ent->ExternalID, prev->ExternalID))
1305 goto error;
1306 } else if ((ent->content != NULL) && (prev->content != NULL)) {
1307 if (!xmlStrEqual(ent->content, prev->content))
1308 goto error;
1309 } else {
1310 goto error;
1311 }
1312
1313 }
1314 }
1315 return;
1316 error:
1317 switch (ent->etype) {
1318 case XML_INTERNAL_PARAMETER_ENTITY:
1319 case XML_EXTERNAL_PARAMETER_ENTITY:
1320 case XML_INTERNAL_PREDEFINED_ENTITY:
1321 case XML_INTERNAL_GENERAL_ENTITY:
1322 case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
1323 return;
1324 case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
1325 break;
1326 }
1327 xmlXIncludeErr(ctxt, (xmlNodePtr) ent, XML_XINCLUDE_ENTITY_DEF_MISMATCH,
1328 "mismatch in redefinition of entity %s\n",
1329 ent->name);
1330 }
1331
1332 /**
1333 * xmlXIncludeMergeEntities:
1334 * @ctxt: an XInclude context
1335 * @doc: the including doc
1336 * @from: the included doc
1337 *
1338 * Inplements the entity merge
1339 *
1340 * Returns 0 if merge succeeded, -1 if some processing failed
1341 */
1342 static int
1343 xmlXIncludeMergeEntities(xmlXIncludeCtxtPtr ctxt, xmlDocPtr doc,
1344 xmlDocPtr from) {
1345 xmlNodePtr cur;
1346 xmlDtdPtr target, source;
1347
1348 if (ctxt == NULL)
1349 return(-1);
1350
1351 if ((from == NULL) || (from->intSubset == NULL))
1352 return(0);
1353
1354 target = doc->intSubset;
1355 if (target == NULL) {
1356 cur = xmlDocGetRootElement(doc);
1357 if (cur == NULL)
1358 return(-1);
1359 target = xmlCreateIntSubset(doc, cur->name, NULL, NULL);
1360 if (target == NULL)
1361 return(-1);
1362 }
1363
1364 source = from->intSubset;
1365 if ((source != NULL) && (source->entities != NULL)) {
1366 xmlXIncludeMergeData data;
1367
1368 data.ctxt = ctxt;
1369 data.doc = doc;
1370
1371 xmlHashScan((xmlHashTablePtr) source->entities,
1372 xmlXIncludeMergeEntity, &data);
1373 }
1374 source = from->extSubset;
1375 if ((source != NULL) && (source->entities != NULL)) {
1376 xmlXIncludeMergeData data;
1377
1378 data.ctxt = ctxt;
1379 data.doc = doc;
1380
1381 /*
1382 * don't duplicate existing stuff when external subsets are the same
1383 */
1384 if ((!xmlStrEqual(target->ExternalID, source->ExternalID)) &&
1385 (!xmlStrEqual(target->SystemID, source->SystemID))) {
1386 xmlHashScan((xmlHashTablePtr) source->entities,
1387 xmlXIncludeMergeEntity, &data);
1388 }
1389 }
1390 return(0);
1391 }
1392
1393 /**
1394 * xmlXIncludeLoadDoc:
1395 * @ctxt: the XInclude context
1396 * @url: the associated URL
1397 * @nr: the xinclude node number
1398 *
1399 * Load the document, and store the result in the XInclude context
1400 *
1401 * Returns 0 in case of success, -1 in case of failure
1402 */
1403 static int
1404 xmlXIncludeLoadDoc(xmlXIncludeCtxtPtr ctxt, const xmlChar *url, int nr) {
1405 xmlDocPtr doc;
1406 xmlURIPtr uri;
1407 xmlChar *URL;
1408 xmlChar *fragment = NULL;
1409 int i = 0;
1410 #ifdef LIBXML_XPTR_ENABLED
1411 int saveFlags;
1412 #endif
1413
1414 #ifdef DEBUG_XINCLUDE
1415 xmlGenericError(xmlGenericErrorContext, "Loading doc %s:%d\n", url, nr);
1416 #endif
1417 /*
1418 * Check the URL and remove any fragment identifier
1419 */
1420 uri = xmlParseURI((const char *)url);
1421 if (uri == NULL) {
1422 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1423 XML_XINCLUDE_HREF_URI,
1424 "invalid value URI %s\n", url);
1425 return(-1);
1426 }
1427 if (uri->fragment != NULL) {
1428 fragment = (xmlChar *) uri->fragment;
1429 uri->fragment = NULL;
1430 }
1431 if ((ctxt->incTab != NULL) && (ctxt->incTab[nr] != NULL) &&
1432 (ctxt->incTab[nr]->fragment != NULL)) {
1433 if (fragment != NULL) xmlFree(fragment);
1434 fragment = xmlStrdup(ctxt->incTab[nr]->fragment);
1435 }
1436 URL = xmlSaveUri(uri);
1437 xmlFreeURI(uri);
1438 if (URL == NULL) {
1439 if (ctxt->incTab != NULL)
1440 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1441 XML_XINCLUDE_HREF_URI,
1442 "invalid value URI %s\n", url);
1443 else
1444 xmlXIncludeErr(ctxt, NULL,
1445 XML_XINCLUDE_HREF_URI,
1446 "invalid value URI %s\n", url);
1447 if (fragment != NULL)
1448 xmlFree(fragment);
1449 return(-1);
1450 }
1451
1452 /*
1453 * Handling of references to the local document are done
1454 * directly through ctxt->doc.
1455 */
1456 if ((URL[0] == 0) || (URL[0] == '#') ||
1457 ((ctxt->doc != NULL) && (xmlStrEqual(URL, ctxt->doc->URL)))) {
1458 doc = NULL;
1459 goto loaded;
1460 }
1461
1462 /*
1463 * Prevent reloading twice the document.
1464 */
1465 for (i = 0; i < ctxt->incNr; i++) {
1466 if ((xmlStrEqual(URL, ctxt->incTab[i]->URI)) &&
1467 (ctxt->incTab[i]->doc != NULL)) {
1468 doc = ctxt->incTab[i]->doc;
1469 #ifdef DEBUG_XINCLUDE
1470 printf("Already loaded %s\n", URL);
1471 #endif
1472 goto loaded;
1473 }
1474 }
1475
1476 /*
1477 * Load it.
1478 */
1479 #ifdef DEBUG_XINCLUDE
1480 printf("loading %s\n", URL);
1481 #endif
1482 #ifdef LIBXML_XPTR_ENABLED
1483 /*
1484 * If this is an XPointer evaluation, we want to assure that
1485 * all entities have been resolved prior to processing the
1486 * referenced document
1487 */
1488 saveFlags = ctxt->parseFlags;
1489 if (fragment != NULL) { /* if this is an XPointer eval */
1490 ctxt->parseFlags |= XML_PARSE_NOENT;
1491 }
1492 #endif
1493
1494 doc = xmlXIncludeParseFile(ctxt, (const char *)URL);
1495 #ifdef LIBXML_XPTR_ENABLED
1496 ctxt->parseFlags = saveFlags;
1497 #endif
1498 if (doc == NULL) {
1499 xmlFree(URL);
1500 if (fragment != NULL)
1501 xmlFree(fragment);
1502 return(-1);
1503 }
1504 ctxt->incTab[nr]->doc = doc;
1505 /*
1506 * It's possible that the requested URL has been mapped to a
1507 * completely different location (e.g. through a catalog entry).
1508 * To check for this, we compare the URL with that of the doc
1509 * and change it if they disagree (bug 146988).
1510 */
1511 if (!xmlStrEqual(URL, doc->URL)) {
1512 xmlFree(URL);
1513 URL = xmlStrdup(doc->URL);
1514 }
1515 for (i = nr + 1; i < ctxt->incNr; i++) {
1516 if (xmlStrEqual(URL, ctxt->incTab[i]->URI)) {
1517 ctxt->incTab[nr]->count++;
1518 #ifdef DEBUG_XINCLUDE
1519 printf("Increasing %s count since reused\n", URL);
1520 #endif
1521 break;
1522 }
1523 }
1524
1525 /*
1526 * Make sure we have all entities fixed up
1527 */
1528 xmlXIncludeMergeEntities(ctxt, ctxt->doc, doc);
1529
1530 /*
1531 * We don't need the DTD anymore, free up space
1532 if (doc->intSubset != NULL) {
1533 xmlUnlinkNode((xmlNodePtr) doc->intSubset);
1534 xmlFreeNode((xmlNodePtr) doc->intSubset);
1535 doc->intSubset = NULL;
1536 }
1537 if (doc->extSubset != NULL) {
1538 xmlUnlinkNode((xmlNodePtr) doc->extSubset);
1539 xmlFreeNode((xmlNodePtr) doc->extSubset);
1540 doc->extSubset = NULL;
1541 }
1542 */
1543 xmlXIncludeRecurseDoc(ctxt, doc, URL);
1544
1545 loaded:
1546 if (fragment == NULL) {
1547 /*
1548 * Add the top children list as the replacement copy.
1549 */
1550 if (doc == NULL)
1551 {
1552 /* Hopefully a DTD declaration won't be copied from
1553 * the same document */
1554 ctxt->incTab[nr]->inc = xmlCopyNodeList(ctxt->doc->children);
1555 } else {
1556 ctxt->incTab[nr]->inc = xmlXIncludeCopyNodeList(ctxt, ctxt->doc,
1557 doc, doc->children);
1558 }
1559 }
1560 #ifdef LIBXML_XPTR_ENABLED
1561 else {
1562 /*
1563 * Computes the XPointer expression and make a copy used
1564 * as the replacement copy.
1565 */
1566 xmlXPathObjectPtr xptr;
1567 xmlXPathContextPtr xptrctxt;
1568 xmlNodeSetPtr set;
1569
1570 if (doc == NULL) {
1571 xptrctxt = xmlXPtrNewContext(ctxt->doc, ctxt->incTab[nr]->ref,
1572 NULL);
1573 } else {
1574 xptrctxt = xmlXPtrNewContext(doc, NULL, NULL);
1575 }
1576 if (xptrctxt == NULL) {
1577 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1578 XML_XINCLUDE_XPTR_FAILED,
1579 "could not create XPointer context\n", NULL);
1580 xmlFree(URL);
1581 xmlFree(fragment);
1582 return(-1);
1583 }
1584 xptr = xmlXPtrEval(fragment, xptrctxt);
1585 if (xptr == NULL) {
1586 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1587 XML_XINCLUDE_XPTR_FAILED,
1588 "XPointer evaluation failed: #%s\n",
1589 fragment);
1590 xmlXPathFreeContext(xptrctxt);
1591 xmlFree(URL);
1592 xmlFree(fragment);
1593 return(-1);
1594 }
1595 switch (xptr->type) {
1596 case XPATH_UNDEFINED:
1597 case XPATH_BOOLEAN:
1598 case XPATH_NUMBER:
1599 case XPATH_STRING:
1600 case XPATH_POINT:
1601 case XPATH_USERS:
1602 case XPATH_XSLT_TREE:
1603 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1604 XML_XINCLUDE_XPTR_RESULT,
1605 "XPointer is not a range: #%s\n",
1606 fragment);
1607 xmlXPathFreeContext(xptrctxt);
1608 xmlFree(URL);
1609 xmlFree(fragment);
1610 return(-1);
1611 case XPATH_NODESET:
1612 if ((xptr->nodesetval == NULL) ||
1613 (xptr->nodesetval->nodeNr <= 0)) {
1614 xmlXPathFreeContext(xptrctxt);
1615 xmlFree(URL);
1616 xmlFree(fragment);
1617 return(-1);
1618 }
1619
1620 case XPATH_RANGE:
1621 case XPATH_LOCATIONSET:
1622 break;
1623 }
1624 set = xptr->nodesetval;
1625 if (set != NULL) {
1626 for (i = 0;i < set->nodeNr;i++) {
1627 if (set->nodeTab[i] == NULL)
1628 continue;
1629 switch (set->nodeTab[i]->type) {
1630 case XML_ELEMENT_NODE:
1631 case XML_TEXT_NODE:
1632 case XML_CDATA_SECTION_NODE:
1633 case XML_ENTITY_REF_NODE:
1634 case XML_ENTITY_NODE:
1635 case XML_PI_NODE:
1636 case XML_COMMENT_NODE:
1637 case XML_DOCUMENT_NODE:
1638 case XML_HTML_DOCUMENT_NODE:
1639 #ifdef LIBXML_DOCB_ENABLED
1640 case XML_DOCB_DOCUMENT_NODE:
1641 #endif
1642 continue;
1643
1644 case XML_ATTRIBUTE_NODE:
1645 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1646 XML_XINCLUDE_XPTR_RESULT,
1647 "XPointer selects an attribute: #%s\n",
1648 fragment);
1649 set->nodeTab[i] = NULL;
1650 continue;
1651 case XML_NAMESPACE_DECL:
1652 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1653 XML_XINCLUDE_XPTR_RESULT,
1654 "XPointer selects a namespace: #%s\n",
1655 fragment);
1656 set->nodeTab[i] = NULL;
1657 continue;
1658 case XML_DOCUMENT_TYPE_NODE:
1659 case XML_DOCUMENT_FRAG_NODE:
1660 case XML_NOTATION_NODE:
1661 case XML_DTD_NODE:
1662 case XML_ELEMENT_DECL:
1663 case XML_ATTRIBUTE_DECL:
1664 case XML_ENTITY_DECL:
1665 case XML_XINCLUDE_START:
1666 case XML_XINCLUDE_END:
1667 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1668 XML_XINCLUDE_XPTR_RESULT,
1669 "XPointer selects unexpected nodes: #%s\n",
1670 fragment);
1671 set->nodeTab[i] = NULL;
1672 set->nodeTab[i] = NULL;
1673 continue; /* for */
1674 }
1675 }
1676 }
1677 if (doc == NULL) {
1678 ctxt->incTab[nr]->xptr = xptr;
1679 ctxt->incTab[nr]->inc = NULL;
1680 } else {
1681 ctxt->incTab[nr]->inc =
1682 xmlXIncludeCopyXPointer(ctxt, ctxt->doc, doc, xptr);
1683 xmlXPathFreeObject(xptr);
1684 }
1685 xmlXPathFreeContext(xptrctxt);
1686 xmlFree(fragment);
1687 }
1688 #endif
1689
1690 /*
1691 * Do the xml:base fixup if needed
1692 */
1693 if ((doc != NULL) && (URL != NULL) &&
1694 (!(ctxt->parseFlags & XML_PARSE_NOBASEFIX)) &&
1695 (!(doc->parseFlags & XML_PARSE_NOBASEFIX))) {
1696 xmlNodePtr node;
1697 xmlChar *base;
1698 xmlChar *curBase;
1699
1700 /*
1701 * The base is only adjusted if "necessary", i.e. if the xinclude node
1702 * has a base specified, or the URL is relative
1703 */
1704 base = xmlGetNsProp(ctxt->incTab[nr]->ref, BAD_CAST "base",
1705 XML_XML_NAMESPACE);
1706 if (base == NULL) {
1707 /*
1708 * No xml:base on the xinclude node, so we check whether the
1709 * URI base is different than (relative to) the context base
1710 */
1711 curBase = xmlBuildRelativeURI(URL, ctxt->base);
1712 if (curBase == NULL) { /* Error return */
1713 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1714 XML_XINCLUDE_HREF_URI,
1715 "trying to build relative URI from %s\n", URL);
1716 } else {
1717 /* If the URI doesn't contain a slash, it's not relative */
1718 if (!xmlStrchr(curBase, (xmlChar) '/'))
1719 xmlFree(curBase);
1720 else
1721 base = curBase;
1722 }
1723 }
1724 if (base != NULL) { /* Adjustment may be needed */
1725 node = ctxt->incTab[nr]->inc;
1726 while (node != NULL) {
1727 /* Only work on element nodes */
1728 if (node->type == XML_ELEMENT_NODE) {
1729 curBase = xmlNodeGetBase(node->doc, node);
1730 /* If no current base, set it */
1731 if (curBase == NULL) {
1732 xmlNodeSetBase(node, base);
1733 } else {
1734 /*
1735 * If the current base is the same as the
1736 * URL of the document, then reset it to be
1737 * the specified xml:base or the relative URI
1738 */
1739 if (xmlStrEqual(curBase, node->doc->URL)) {
1740 xmlNodeSetBase(node, base);
1741 } else {
1742 /*
1743 * If the element already has an xml:base
1744 * set, then relativise it if necessary
1745 */
1746 xmlChar *xmlBase;
1747 xmlBase = xmlGetNsProp(node,
1748 BAD_CAST "base",
1749 XML_XML_NAMESPACE);
1750 if (xmlBase != NULL) {
1751 xmlChar *relBase;
1752 relBase = xmlBuildURI(xmlBase, base);
1753 if (relBase == NULL) { /* error */
1754 xmlXIncludeErr(ctxt,
1755 ctxt->incTab[nr]->ref,
1756 XML_XINCLUDE_HREF_URI,
1757 "trying to rebuild base from %s\n",
1758 xmlBase);
1759 } else {
1760 xmlNodeSetBase(node, relBase);
1761 xmlFree(relBase);
1762 }
1763 xmlFree(xmlBase);
1764 }
1765 }
1766 xmlFree(curBase);
1767 }
1768 }
1769 node = node->next;
1770 }
1771 xmlFree(base);
1772 }
1773 }
1774 if ((nr < ctxt->incNr) && (ctxt->incTab[nr]->doc != NULL) &&
1775 (ctxt->incTab[nr]->count <= 1)) {
1776 #ifdef DEBUG_XINCLUDE
1777 printf("freeing %s\n", ctxt->incTab[nr]->doc->URL);
1778 #endif
1779 xmlFreeDoc(ctxt->incTab[nr]->doc);
1780 ctxt->incTab[nr]->doc = NULL;
1781 }
1782 xmlFree(URL);
1783 return(0);
1784 }
1785
1786 /**
1787 * xmlXIncludeLoadTxt:
1788 * @ctxt: the XInclude context
1789 * @url: the associated URL
1790 * @nr: the xinclude node number
1791 *
1792 * Load the content, and store the result in the XInclude context
1793 *
1794 * Returns 0 in case of success, -1 in case of failure
1795 */
1796 static int
1797 xmlXIncludeLoadTxt(xmlXIncludeCtxtPtr ctxt, const xmlChar *url, int nr) {
1798 xmlParserInputBufferPtr buf;
1799 xmlNodePtr node;
1800 xmlURIPtr uri;
1801 xmlChar *URL;
1802 int i;
1803 xmlChar *encoding = NULL;
1804 xmlCharEncoding enc = (xmlCharEncoding) 0;
1805 xmlParserCtxtPtr pctxt;
1806 xmlParserInputPtr inputStream;
1807 int xinclude_multibyte_fallback_used = 0;
1808
1809 /*
1810 * Check the URL and remove any fragment identifier
1811 */
1812 uri = xmlParseURI((const char *)url);
1813 if (uri == NULL) {
1814 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, XML_XINCLUDE_HREF_URI,
1815 "invalid value URI %s\n", url);
1816 return(-1);
1817 }
1818 if (uri->fragment != NULL) {
1819 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, XML_XINCLUDE_TEXT_FRAGMENT,
1820 "fragment identifier forbidden for text: %s\n",
1821 (const xmlChar *) uri->fragment);
1822 xmlFreeURI(uri);
1823 return(-1);
1824 }
1825 URL = xmlSaveUri(uri);
1826 xmlFreeURI(uri);
1827 if (URL == NULL) {
1828 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, XML_XINCLUDE_HREF_URI,
1829 "invalid value URI %s\n", url);
1830 return(-1);
1831 }
1832
1833 /*
1834 * Handling of references to the local document are done
1835 * directly through ctxt->doc.
1836 */
1837 if (URL[0] == 0) {
1838 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1839 XML_XINCLUDE_TEXT_DOCUMENT,
1840 "text serialization of document not available\n", NULL);
1841 xmlFree(URL);
1842 return(-1);
1843 }
1844
1845 /*
1846 * Prevent reloading twice the document.
1847 */
1848 for (i = 0; i < ctxt->txtNr; i++) {
1849 if (xmlStrEqual(URL, ctxt->txturlTab[i])) {
1850 node = xmlCopyNode(ctxt->txtTab[i], 1);
1851 goto loaded;
1852 }
1853 }
1854 /*
1855 * Try to get the encoding if available
1856 */
1857 if ((ctxt->incTab[nr] != NULL) && (ctxt->incTab[nr]->ref != NULL)) {
1858 encoding = xmlGetProp(ctxt->incTab[nr]->ref, XINCLUDE_PARSE_ENCODING);
1859 }
1860 if (encoding != NULL) {
1861 /*
1862 * TODO: we should not have to remap to the xmlCharEncoding
1863 * predefined set, a better interface than
1864 * xmlParserInputBufferCreateFilename should allow any
1865 * encoding supported by iconv
1866 */
1867 enc = xmlParseCharEncoding((const char *) encoding);
1868 if (enc == XML_CHAR_ENCODING_ERROR) {
1869 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1870 XML_XINCLUDE_UNKNOWN_ENCODING,
1871 "encoding %s not supported\n", encoding);
1872 xmlFree(encoding);
1873 xmlFree(URL);
1874 return(-1);
1875 }
1876 xmlFree(encoding);
1877 }
1878
1879 /*
1880 * Load it.
1881 */
1882 pctxt = xmlNewParserCtxt();
1883 inputStream = xmlLoadExternalEntity((const char*)URL, NULL, pctxt);
1884 if(inputStream == NULL) {
1885 xmlFreeParserCtxt(pctxt);
1886 xmlFree(URL);
1887 return(-1);
1888 }
1889 buf = inputStream->buf;
1890 if (buf == NULL) {
1891 xmlFreeInputStream (inputStream);
1892 xmlFreeParserCtxt(pctxt);
1893 xmlFree(URL);
1894 return(-1);
1895 }
1896 if (buf->encoder)
1897 xmlCharEncCloseFunc(buf->encoder);
1898 buf->encoder = xmlGetCharEncodingHandler(enc);
1899 node = xmlNewText(NULL);
1900
1901 /*
1902 * Scan all chars from the resource and add the to the node
1903 */
1904 xinclude_multibyte_fallback:
1905 while (xmlParserInputBufferRead(buf, 128) > 0) {
1906 int len;
1907 const xmlChar *content;
1908
1909 content = xmlBufContent(buf->buffer);
1910 len = xmlBufLength(buf->buffer);
1911 for (i = 0;i < len;) {
1912 int cur;
1913 int l;
1914
1915 cur = xmlStringCurrentChar(NULL, &content[i], &l);
1916 if (!IS_CHAR(cur)) {
1917 /* Handle splitted multibyte char at buffer boundary */
1918 if (((len - i) < 4) && (!xinclude_multibyte_fallback_used)) {
1919 xinclude_multibyte_fallback_used = 1;
1920 xmlBufShrink(buf->buffer, i);
1921 goto xinclude_multibyte_fallback;
1922 } else {
1923 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1924 XML_XINCLUDE_INVALID_CHAR,
1925 "%s contains invalid char\n", URL);
1926 xmlFreeParserInputBuffer(buf);
1927 xmlFree(URL);
1928 return(-1);
1929 }
1930 } else {
1931 xinclude_multibyte_fallback_used = 0;
1932 xmlNodeAddContentLen(node, &content[i], l);
1933 }
1934 i += l;
1935 }
1936 xmlBufShrink(buf->buffer, len);
1937 }
1938 xmlFreeParserCtxt(pctxt);
1939 xmlXIncludeAddTxt(ctxt, node, URL);
1940 xmlFreeInputStream(inputStream);
1941
1942 loaded:
1943 /*
1944 * Add the element as the replacement copy.
1945 */
1946 ctxt->incTab[nr]->inc = node;
1947 xmlFree(URL);
1948 return(0);
1949 }
1950
1951 /**
1952 * xmlXIncludeLoadFallback:
1953 * @ctxt: the XInclude context
1954 * @fallback: the fallback node
1955 * @nr: the xinclude node number
1956 *
1957 * Load the content of the fallback node, and store the result
1958 * in the XInclude context
1959 *
1960 * Returns 0 in case of success, -1 in case of failure
1961 */
1962 static int
1963 xmlXIncludeLoadFallback(xmlXIncludeCtxtPtr ctxt, xmlNodePtr fallback, int nr) {
1964 xmlXIncludeCtxtPtr newctxt;
1965 int ret = 0;
1966
1967 if ((fallback == NULL) || (fallback->type == XML_NAMESPACE_DECL) ||
1968 (ctxt == NULL))
1969 return(-1);
1970 if (fallback->children != NULL) {
1971 /*
1972 * It's possible that the fallback also has 'includes'
1973 * (Bug 129969), so we re-process the fallback just in case
1974 */
1975 newctxt = xmlXIncludeNewContext(ctxt->doc);
1976 if (newctxt == NULL)
1977 return (-1);
1978 newctxt->_private = ctxt->_private;
1979 newctxt->base = xmlStrdup(ctxt->base); /* Inherit the base from the existing context */
1980 xmlXIncludeSetFlags(newctxt, ctxt->parseFlags);
1981 ret = xmlXIncludeDoProcess(newctxt, ctxt->doc, fallback->children);
1982 if (ctxt->nbErrors > 0)
1983 ret = -1;
1984 else if (ret > 0)
1985 ret = 0; /* xmlXIncludeDoProcess can return +ve number */
1986 xmlXIncludeFreeContext(newctxt);
1987
1988 ctxt->incTab[nr]->inc = xmlDocCopyNodeList(ctxt->doc,
1989 fallback->children);
1990 } else {
1991 ctxt->incTab[nr]->inc = NULL;
1992 ctxt->incTab[nr]->emptyFb = 1; /* flag empty callback */
1993 }
1994 return(ret);
1995 }
1996
1997 /************************************************************************
1998 * *
1999 * XInclude Processing *
2000 * *
2001 ************************************************************************/
2002
2003 /**
2004 * xmlXIncludePreProcessNode:
2005 * @ctxt: an XInclude context
2006 * @node: an XInclude node
2007 *
2008 * Implement the XInclude preprocessing, currently just adding the element
2009 * for further processing.
2010 *
2011 * Returns the result list or NULL in case of error
2012 */
2013 static xmlNodePtr
2014 xmlXIncludePreProcessNode(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node) {
2015 xmlXIncludeAddNode(ctxt, node);
2016 return(NULL);
2017 }
2018
2019 /**
2020 * xmlXIncludeLoadNode:
2021 * @ctxt: an XInclude context
2022 * @nr: the node number
2023 *
2024 * Find and load the infoset replacement for the given node.
2025 *
2026 * Returns 0 if substitution succeeded, -1 if some processing failed
2027 */
2028 static int
2029 xmlXIncludeLoadNode(xmlXIncludeCtxtPtr ctxt, int nr) {
2030 xmlNodePtr cur;
2031 xmlChar *href;
2032 xmlChar *parse;
2033 xmlChar *base;
2034 xmlChar *oldBase;
2035 xmlChar *URI;
2036 int xml = 1; /* default Issue 64 */
2037 int ret;
2038
2039 if (ctxt == NULL)
2040 return(-1);
2041 if ((nr < 0) || (nr >= ctxt->incNr))
2042 return(-1);
2043 cur = ctxt->incTab[nr]->ref;
2044 if (cur == NULL)
2045 return(-1);
2046
2047 /*
2048 * read the attributes
2049 */
2050 href = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_HREF);
2051 if (href == NULL) {
2052 href = xmlStrdup(BAD_CAST ""); /* @@@@ href is now optional */
2053 if (href == NULL)
2054 return(-1);
2055 }
2056 parse = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_PARSE);
2057 if (parse != NULL) {
2058 if (xmlStrEqual(parse, XINCLUDE_PARSE_XML))
2059 xml = 1;
2060 else if (xmlStrEqual(parse, XINCLUDE_PARSE_TEXT))
2061 xml = 0;
2062 else {
2063 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
2064 XML_XINCLUDE_PARSE_VALUE,
2065 "invalid value %s for 'parse'\n", parse);
2066 if (href != NULL)
2067 xmlFree(href);
2068 if (parse != NULL)
2069 xmlFree(parse);
2070 return(-1);
2071 }
2072 }
2073
2074 /*
2075 * compute the URI
2076 */
2077 base = xmlNodeGetBase(ctxt->doc, cur);
2078 if (base == NULL) {
2079 URI = xmlBuildURI(href, ctxt->doc->URL);
2080 } else {
2081 URI = xmlBuildURI(href, base);
2082 }
2083 if (URI == NULL) {
2084 xmlChar *escbase;
2085 xmlChar *eschref;
2086 /*
2087 * Some escaping may be needed
2088 */
2089 escbase = xmlURIEscape(base);
2090 eschref = xmlURIEscape(href);
2091 URI = xmlBuildURI(eschref, escbase);
2092 if (escbase != NULL)
2093 xmlFree(escbase);
2094 if (eschref != NULL)
2095 xmlFree(eschref);
2096 }
2097 if (URI == NULL) {
2098 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
2099 XML_XINCLUDE_HREF_URI, "failed build URL\n", NULL);
2100 if (parse != NULL)
2101 xmlFree(parse);
2102 if (href != NULL)
2103 xmlFree(href);
2104 if (base != NULL)
2105 xmlFree(base);
2106 return(-1);
2107 }
2108 #ifdef DEBUG_XINCLUDE
2109 xmlGenericError(xmlGenericErrorContext, "parse: %s\n",
2110 xml ? "xml": "text");
2111 xmlGenericError(xmlGenericErrorContext, "URI: %s\n", URI);
2112 #endif
2113
2114 /*
2115 * Save the base for this include (saving the current one)
2116 */
2117 oldBase = ctxt->base;
2118 ctxt->base = base;
2119
2120 if (xml) {
2121 ret = xmlXIncludeLoadDoc(ctxt, URI, nr);
2122 /* xmlXIncludeGetFragment(ctxt, cur, URI); */
2123 } else {
2124 ret = xmlXIncludeLoadTxt(ctxt, URI, nr);
2125 }
2126
2127 /*
2128 * Restore the original base before checking for fallback
2129 */
2130 ctxt->base = oldBase;
2131
2132 if (ret < 0) {
2133 xmlNodePtr children;
2134
2135 /*
2136 * Time to try a fallback if availble
2137 */
2138 #ifdef DEBUG_XINCLUDE
2139 xmlGenericError(xmlGenericErrorContext, "error looking for fallback\n");
2140 #endif
2141 children = cur->children;
2142 while (children != NULL) {
2143 if ((children->type == XML_ELEMENT_NODE) &&
2144 (children->ns != NULL) &&
2145 (xmlStrEqual(children->name, XINCLUDE_FALLBACK)) &&
2146 ((xmlStrEqual(children->ns->href, XINCLUDE_NS)) ||
2147 (xmlStrEqual(children->ns->href, XINCLUDE_OLD_NS)))) {
2148 ret = xmlXIncludeLoadFallback(ctxt, children, nr);
2149 if (ret == 0)
2150 break;
2151 }
2152 children = children->next;
2153 }
2154 }
2155 if (ret < 0) {
2156 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
2157 XML_XINCLUDE_NO_FALLBACK,
2158 "could not load %s, and no fallback was found\n",
2159 URI);
2160 }
2161
2162 /*
2163 * Cleanup
2164 */
2165 if (URI != NULL)
2166 xmlFree(URI);
2167 if (parse != NULL)
2168 xmlFree(parse);
2169 if (href != NULL)
2170 xmlFree(href);
2171 if (base != NULL)
2172 xmlFree(base);
2173 return(0);
2174 }
2175
2176 /**
2177 * xmlXIncludeIncludeNode:
2178 * @ctxt: an XInclude context
2179 * @nr: the node number
2180 *
2181 * Inplement the infoset replacement for the given node
2182 *
2183 * Returns 0 if substitution succeeded, -1 if some processing failed
2184 */
2185 static int
2186 xmlXIncludeIncludeNode(xmlXIncludeCtxtPtr ctxt, int nr) {
2187 xmlNodePtr cur, end, list, tmp;
2188
2189 if (ctxt == NULL)
2190 return(-1);
2191 if ((nr < 0) || (nr >= ctxt->incNr))
2192 return(-1);
2193 cur = ctxt->incTab[nr]->ref;
2194 if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL))
2195 return(-1);
2196
2197 /*
2198 * If we stored an XPointer a late computation may be needed
2199 */
2200 if ((ctxt->incTab[nr]->inc == NULL) &&
2201 (ctxt->incTab[nr]->xptr != NULL)) {
2202 ctxt->incTab[nr]->inc =
2203 xmlXIncludeCopyXPointer(ctxt, ctxt->doc, ctxt->doc,
2204 ctxt->incTab[nr]->xptr);
2205 xmlXPathFreeObject(ctxt->incTab[nr]->xptr);
2206 ctxt->incTab[nr]->xptr = NULL;
2207 }
2208 list = ctxt->incTab[nr]->inc;
2209 ctxt->incTab[nr]->inc = NULL;
2210
2211 /*
2212 * Check against the risk of generating a multi-rooted document
2213 */
2214 if ((cur->parent != NULL) &&
2215 (cur->parent->type != XML_ELEMENT_NODE)) {
2216 int nb_elem = 0;
2217
2218 tmp = list;
2219 while (tmp != NULL) {
2220 if (tmp->type == XML_ELEMENT_NODE)
2221 nb_elem++;
2222 tmp = tmp->next;
2223 }
2224 if (nb_elem > 1) {
2225 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
2226 XML_XINCLUDE_MULTIPLE_ROOT,
2227 "XInclude error: would result in multiple root nodes\n",
2228 NULL);
2229 return(-1);
2230 }
2231 }
2232
2233 if (ctxt->parseFlags & XML_PARSE_NOXINCNODE) {
2234 /*
2235 * Add the list of nodes
2236 */
2237 while (list != NULL) {
2238 end = list;
2239 list = list->next;
2240
2241 xmlAddPrevSibling(cur, end);
2242 }
2243 xmlUnlinkNode(cur);
2244 xmlFreeNode(cur);
2245 } else {
2246 /*
2247 * Change the current node as an XInclude start one, and add an
2248 * XInclude end one
2249 */
2250 cur->type = XML_XINCLUDE_START;
2251 end = xmlNewDocNode(cur->doc, cur->ns, cur->name, NULL);
2252 if (end == NULL) {
2253 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
2254 XML_XINCLUDE_BUILD_FAILED,
2255 "failed to build node\n", NULL);
2256 return(-1);
2257 }
2258 end->type = XML_XINCLUDE_END;
2259 xmlAddNextSibling(cur, end);
2260
2261 /*
2262 * Add the list of nodes
2263 */
2264 while (list != NULL) {
2265 cur = list;
2266 list = list->next;
2267
2268 xmlAddPrevSibling(end, cur);
2269 }
2270 }
2271
2272
2273 return(0);
2274 }
2275
2276 /**
2277 * xmlXIncludeTestNode:
2278 * @ctxt: the XInclude processing context
2279 * @node: an XInclude node
2280 *
2281 * test if the node is an XInclude node
2282 *
2283 * Returns 1 true, 0 otherwise
2284 */
2285 static int
2286 xmlXIncludeTestNode(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node) {
2287 if (node == NULL)
2288 return(0);
2289 if (node->type != XML_ELEMENT_NODE)
2290 return(0);
2291 if (node->ns == NULL)
2292 return(0);
2293 if ((xmlStrEqual(node->ns->href, XINCLUDE_NS)) ||
2294 (xmlStrEqual(node->ns->href, XINCLUDE_OLD_NS))) {
2295 if (xmlStrEqual(node->ns->href, XINCLUDE_OLD_NS)) {
2296 if (ctxt->legacy == 0) {
2297 #if 0 /* wait for the XML Core Working Group to get something stable ! */
2298 xmlXIncludeWarn(ctxt, node, XML_XINCLUDE_DEPRECATED_NS,
2299 "Deprecated XInclude namespace found, use %s",
2300 XINCLUDE_NS);
2301 #endif
2302 ctxt->legacy = 1;
2303 }
2304 }
2305 if (xmlStrEqual(node->name, XINCLUDE_NODE)) {
2306 xmlNodePtr child = node->children;
2307 int nb_fallback = 0;
2308
2309 while (child != NULL) {
2310 if ((child->type == XML_ELEMENT_NODE) &&
2311 (child->ns != NULL) &&
2312 ((xmlStrEqual(child->ns->href, XINCLUDE_NS)) ||
2313 (xmlStrEqual(child->ns->href, XINCLUDE_OLD_NS)))) {
2314 if (xmlStrEqual(child->name, XINCLUDE_NODE)) {
2315 xmlXIncludeErr(ctxt, node,
2316 XML_XINCLUDE_INCLUDE_IN_INCLUDE,
2317 "%s has an 'include' child\n",
2318 XINCLUDE_NODE);
2319 return(0);
2320 }
2321 if (xmlStrEqual(child->name, XINCLUDE_FALLBACK)) {
2322 nb_fallback++;
2323 }
2324 }
2325 child = child->next;
2326 }
2327 if (nb_fallback > 1) {
2328 xmlXIncludeErr(ctxt, node, XML_XINCLUDE_FALLBACKS_IN_INCLUDE,
2329 "%s has multiple fallback children\n",
2330 XINCLUDE_NODE);
2331 return(0);
2332 }
2333 return(1);
2334 }
2335 if (xmlStrEqual(node->name, XINCLUDE_FALLBACK)) {
2336 if ((node->parent == NULL) ||
2337 (node->parent->type != XML_ELEMENT_NODE) ||
2338 (node->parent->ns == NULL) ||
2339 ((!xmlStrEqual(node->parent->ns->href, XINCLUDE_NS)) &&
2340 (!xmlStrEqual(node->parent->ns->href, XINCLUDE_OLD_NS))) ||
2341 (!xmlStrEqual(node->parent->name, XINCLUDE_NODE))) {
2342 xmlXIncludeErr(ctxt, node,
2343 XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE,
2344 "%s is not the child of an 'include'\n",
2345 XINCLUDE_FALLBACK);
2346 }
2347 }
2348 }
2349 return(0);
2350 }
2351
2352 /**
2353 * xmlXIncludeDoProcess:
2354 * @ctxt: the XInclude processing context
2355 * @doc: an XML document
2356 * @tree: the top of the tree to process
2357 *
2358 * Implement the XInclude substitution on the XML document @doc
2359 *
2360 * Returns 0 if no substitution were done, -1 if some processing failed
2361 * or the number of substitutions done.
2362 */
2363 static int
2364 xmlXIncludeDoProcess(xmlXIncludeCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr tree) {
2365 xmlNodePtr cur;
2366 int ret = 0;
2367 int i, start;
2368
2369 if ((doc == NULL) || (tree == NULL) || (tree->type == XML_NAMESPACE_DECL))
2370 return(-1);
2371 if (ctxt == NULL)
2372 return(-1);
2373
2374 if (doc->URL != NULL) {
2375 ret = xmlXIncludeURLPush(ctxt, doc->URL);
2376 if (ret < 0)
2377 return(-1);
2378 }
2379 start = ctxt->incNr;
2380
2381 /*
2382 * First phase: lookup the elements in the document
2383 */
2384 cur = tree;
2385 if (xmlXIncludeTestNode(ctxt, cur) == 1)
2386 xmlXIncludePreProcessNode(ctxt, cur);
2387 while ((cur != NULL) && (cur != tree->parent)) {
2388 /* TODO: need to work on entities -> stack */
2389 if ((cur->children != NULL) &&
2390 (cur->children->type != XML_ENTITY_DECL) &&
2391 (cur->children->type != XML_XINCLUDE_START) &&
2392 (cur->children->type != XML_XINCLUDE_END)) {
2393 cur = cur->children;
2394 if (xmlXIncludeTestNode(ctxt, cur))
2395 xmlXIncludePreProcessNode(ctxt, cur);
2396 } else if (cur->next != NULL) {
2397 cur = cur->next;
2398 if (xmlXIncludeTestNode(ctxt, cur))
2399 xmlXIncludePreProcessNode(ctxt, cur);
2400 } else {
2401 if (cur == tree)
2402 break;
2403 do {
2404 cur = cur->parent;
2405 if ((cur == NULL) || (cur == tree->parent))
2406 break; /* do */
2407 if (cur->next != NULL) {
2408 cur = cur->next;
2409 if (xmlXIncludeTestNode(ctxt, cur))
2410 xmlXIncludePreProcessNode(ctxt, cur);
2411 break; /* do */
2412 }
2413 } while (cur != NULL);
2414 }
2415 }
2416
2417 /*
2418 * Second Phase : collect the infosets fragments
2419 */
2420 for (i = start;i < ctxt->incNr; i++) {
2421 xmlXIncludeLoadNode(ctxt, i);
2422 ret++;
2423 }
2424
2425 /*
2426 * Third phase: extend the original document infoset.
2427 *
2428 * Originally we bypassed the inclusion if there were any errors
2429 * encountered on any of the XIncludes. A bug was raised (bug
2430 * 132588) requesting that we output the XIncludes without error,
2431 * so the check for inc!=NULL || xptr!=NULL was put in. This may
2432 * give some other problems in the future, but for now it seems to
2433 * work ok.
2434 *
2435 */
2436 for (i = ctxt->incBase;i < ctxt->incNr; i++) {
2437 if ((ctxt->incTab[i]->inc != NULL) ||
2438 (ctxt->incTab[i]->xptr != NULL) ||
2439 (ctxt->incTab[i]->emptyFb != 0)) /* (empty fallback) */
2440 xmlXIncludeIncludeNode(ctxt, i);
2441 }
2442
2443 if (doc->URL != NULL)
2444 xmlXIncludeURLPop(ctxt);
2445 return(ret);
2446 }
2447
2448 /**
2449 * xmlXIncludeSetFlags:
2450 * @ctxt: an XInclude processing context
2451 * @flags: a set of xmlParserOption used for parsing XML includes
2452 *
2453 * Set the flags used for further processing of XML resources.
2454 *
2455 * Returns 0 in case of success and -1 in case of error.
2456 */
2457 int
2458 xmlXIncludeSetFlags(xmlXIncludeCtxtPtr ctxt, int flags) {
2459 if (ctxt == NULL)
2460 return(-1);
2461 ctxt->parseFlags = flags;
2462 return(0);
2463 }
2464
2465 /**
2466 * xmlXIncludeProcessTreeFlagsData:
2467 * @tree: an XML node
2468 * @flags: a set of xmlParserOption used for parsing XML includes
2469 * @data: application data that will be passed to the parser context
2470 * in the _private field of the parser context(s)
2471 *
2472 * Implement the XInclude substitution on the XML node @tree
2473 *
2474 * Returns 0 if no substitution were done, -1 if some processing failed
2475 * or the number of substitutions done.
2476 */
2477
2478 int
2479 xmlXIncludeProcessTreeFlagsData(xmlNodePtr tree, int flags, void *data) {
2480 xmlXIncludeCtxtPtr ctxt;
2481 int ret = 0;
2482
2483 if ((tree == NULL) || (tree->type == XML_NAMESPACE_DECL) ||
2484 (tree->doc == NULL))
2485 return(-1);
2486
2487 ctxt = xmlXIncludeNewContext(tree->doc);
2488 if (ctxt == NULL)
2489 return(-1);
2490 ctxt->_private = data;
2491 ctxt->base = xmlStrdup((xmlChar *)tree->doc->URL);
2492 xmlXIncludeSetFlags(ctxt, flags);
2493 ret = xmlXIncludeDoProcess(ctxt, tree->doc, tree);
2494 if ((ret >= 0) && (ctxt->nbErrors > 0))
2495 ret = -1;
2496
2497 xmlXIncludeFreeContext(ctxt);
2498 return(ret);
2499 }
2500
2501 /**
2502 * xmlXIncludeProcessFlagsData:
2503 * @doc: an XML document
2504 * @flags: a set of xmlParserOption used for parsing XML includes
2505 * @data: application data that will be passed to the parser context
2506 * in the _private field of the parser context(s)
2507 *
2508 * Implement the XInclude substitution on the XML document @doc
2509 *
2510 * Returns 0 if no substitution were done, -1 if some processing failed
2511 * or the number of substitutions done.
2512 */
2513 int
2514 xmlXIncludeProcessFlagsData(xmlDocPtr doc, int flags, void *data) {
2515 xmlNodePtr tree;
2516
2517 if (doc == NULL)
2518 return(-1);
2519 tree = xmlDocGetRootElement(doc);
2520 if (tree == NULL)
2521 return(-1);
2522 return(xmlXIncludeProcessTreeFlagsData(tree, flags, data));
2523 }
2524
2525 /**
2526 * xmlXIncludeProcessFlags:
2527 * @doc: an XML document
2528 * @flags: a set of xmlParserOption used for parsing XML includes
2529 *
2530 * Implement the XInclude substitution on the XML document @doc
2531 *
2532 * Returns 0 if no substitution were done, -1 if some processing failed
2533 * or the number of substitutions done.
2534 */
2535 int
2536 xmlXIncludeProcessFlags(xmlDocPtr doc, int flags) {
2537 return xmlXIncludeProcessFlagsData(doc, flags, NULL);
2538 }
2539
2540 /**
2541 * xmlXIncludeProcess:
2542 * @doc: an XML document
2543 *
2544 * Implement the XInclude substitution on the XML document @doc
2545 *
2546 * Returns 0 if no substitution were done, -1 if some processing failed
2547 * or the number of substitutions done.
2548 */
2549 int
2550 xmlXIncludeProcess(xmlDocPtr doc) {
2551 return(xmlXIncludeProcessFlags(doc, 0));
2552 }
2553
2554 /**
2555 * xmlXIncludeProcessTreeFlags:
2556 * @tree: a node in an XML document
2557 * @flags: a set of xmlParserOption used for parsing XML includes
2558 *
2559 * Implement the XInclude substitution for the given subtree
2560 *
2561 * Returns 0 if no substitution were done, -1 if some processing failed
2562 * or the number of substitutions done.
2563 */
2564 int
2565 xmlXIncludeProcessTreeFlags(xmlNodePtr tree, int flags) {
2566 xmlXIncludeCtxtPtr ctxt;
2567 int ret = 0;
2568
2569 if ((tree == NULL) || (tree->type == XML_NAMESPACE_DECL) ||
2570 (tree->doc == NULL))
2571 return(-1);
2572 ctxt = xmlXIncludeNewContext(tree->doc);
2573 if (ctxt == NULL)
2574 return(-1);
2575 ctxt->base = xmlNodeGetBase(tree->doc, tree);
2576 xmlXIncludeSetFlags(ctxt, flags);
2577 ret = xmlXIncludeDoProcess(ctxt, tree->doc, tree);
2578 if ((ret >= 0) && (ctxt->nbErrors > 0))
2579 ret = -1;
2580
2581 xmlXIncludeFreeContext(ctxt);
2582 return(ret);
2583 }
2584
2585 /**
2586 * xmlXIncludeProcessTree:
2587 * @tree: a node in an XML document
2588 *
2589 * Implement the XInclude substitution for the given subtree
2590 *
2591 * Returns 0 if no substitution were done, -1 if some processing failed
2592 * or the number of substitutions done.
2593 */
2594 int
2595 xmlXIncludeProcessTree(xmlNodePtr tree) {
2596 return(xmlXIncludeProcessTreeFlags(tree, 0));
2597 }
2598
2599 /**
2600 * xmlXIncludeProcessNode:
2601 * @ctxt: an existing XInclude context
2602 * @node: a node in an XML document
2603 *
2604 * Implement the XInclude substitution for the given subtree reusing
2605 * the informations and data coming from the given context.
2606 *
2607 * Returns 0 if no substitution were done, -1 if some processing failed
2608 * or the number of substitutions done.
2609 */
2610 int
2611 xmlXIncludeProcessNode(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node) {
2612 int ret = 0;
2613
2614 if ((node == NULL) || (node->type == XML_NAMESPACE_DECL) ||
2615 (node->doc == NULL) || (ctxt == NULL))
2616 return(-1);
2617 ret = xmlXIncludeDoProcess(ctxt, node->doc, node);
2618 if ((ret >= 0) && (ctxt->nbErrors > 0))
2619 ret = -1;
2620 return(ret);
2621 }
2622
2623 #else /* !LIBXML_XINCLUDE_ENABLED */
2624 #endif
2625 #define bottom_xinclude
2626 #include "elfgcchack.h"
A free Windows-compatible Operating System