blob: 107ac0356f5f6b3013d0ac8d9e4c8cd4a4180817 [file] [log] [blame]
Owen Taylor3473f882001-02-23 17:55:21 +00001/*
2 * xinclude.c : Code to implement XInclude processing
3 *
Daniel Veillarde74d2e12003-12-09 11:35:37 +00004 * World Wide Web Consortium W3C Last Call Working Draft 10 November 2003
5 * http://www.w3.org/TR/2003/WD-xinclude-20031110
Owen Taylor3473f882001-02-23 17:55:21 +00006 *
7 * See Copyright for the status of this software.
8 *
Daniel Veillardc5d64342001-06-24 12:13:24 +00009 * daniel@veillard.com
Owen Taylor3473f882001-02-23 17:55:21 +000010 */
11
Daniel Veillard34ce8be2002-03-18 19:37:11 +000012#define IN_LIBXML
Bjorn Reese70a9da52001-04-21 16:57:29 +000013#include "libxml.h"
Owen Taylor3473f882001-02-23 17:55:21 +000014
Owen Taylor3473f882001-02-23 17:55:21 +000015#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>
Owen Taylor3473f882001-02-23 17:55:21 +000022#include <libxml/xmlerror.h>
Daniel Veillardd076a202002-11-20 13:28:31 +000023#include <libxml/encoding.h>
Daniel Veillard3c01b1d2001-10-17 15:58:35 +000024#include <libxml/globals.h>
Owen Taylor3473f882001-02-23 17:55:21 +000025
26#ifdef LIBXML_XINCLUDE_ENABLED
27#include <libxml/xinclude.h>
28
Daniel Veillard345ee8b2012-07-16 14:40:37 +080029#include "buf.h"
Owen Taylor3473f882001-02-23 17:55:21 +000030
Daniel Veillardf4b4f982003-02-13 11:02:08 +000031#define XINCLUDE_MAX_DEPTH 40
32
Daniel Veillard98485322003-08-14 15:44:40 +000033/* #define DEBUG_XINCLUDE */
Daniel Veillard017b1082001-06-21 11:20:21 +000034#ifdef DEBUG_XINCLUDE
35#ifdef LIBXML_DEBUG_ENABLED
36#include <libxml/debugXML.h>
37#endif
38#endif
Owen Taylor3473f882001-02-23 17:55:21 +000039
40/************************************************************************
41 * *
William M. Brack72ee48d2003-12-30 08:30:19 +000042 * XInclude context handling *
Owen Taylor3473f882001-02-23 17:55:21 +000043 * *
44 ************************************************************************/
45
46/*
47 * An XInclude context
48 */
Daniel Veillardedac3c92001-02-26 01:36:19 +000049typedef xmlChar *xmlURL;
Daniel Veillardbbc72c32002-09-05 10:52:10 +000050
51typedef struct _xmlXIncludeRef xmlXIncludeRef;
52typedef xmlXIncludeRef *xmlXIncludeRefPtr;
53struct _xmlXIncludeRef {
William M. Brack72ee48d2003-12-30 08:30:19 +000054 xmlChar *URI; /* the fully resolved resource URL */
Daniel Veillardbbc72c32002-09-05 10:52:10 +000055 xmlChar *fragment; /* the fragment in the URI */
56 xmlDocPtr doc; /* the parsed document */
57 xmlNodePtr ref; /* the node making the reference in the source */
58 xmlNodePtr inc; /* the included copy */
59 int xml; /* xml or txt */
60 int count; /* how many refs use that specific doc */
Daniel Veillardf4b4f982003-02-13 11:02:08 +000061 xmlXPathObjectPtr xptr; /* the xpointer if needed */
William M. Brack95af5942004-02-08 04:12:49 +000062 int emptyFb; /* flag to show fallback empty */
Daniel Veillardbbc72c32002-09-05 10:52:10 +000063};
64
Owen Taylor3473f882001-02-23 17:55:21 +000065struct _xmlXIncludeCtxt {
66 xmlDocPtr doc; /* the source document */
Daniel Veillardbbc72c32002-09-05 10:52:10 +000067 int incBase; /* the first include for this document */
Owen Taylor3473f882001-02-23 17:55:21 +000068 int incNr; /* number of includes */
69 int incMax; /* size of includes tab */
Daniel Veillardbbc72c32002-09-05 10:52:10 +000070 xmlXIncludeRefPtr *incTab; /* array of included references */
71
Owen Taylor3473f882001-02-23 17:55:21 +000072 int txtNr; /* number of unparsed documents */
73 int txtMax; /* size of unparsed documents tab */
74 xmlNodePtr *txtTab; /* array of unparsed text nodes */
William M. Brack72ee48d2003-12-30 08:30:19 +000075 xmlURL *txturlTab; /* array of unparsed text URLs */
Daniel Veillardd581b7e2003-02-11 18:03:05 +000076
Daniel Veillardf4b4f982003-02-13 11:02:08 +000077 xmlChar * url; /* the current URL processed */
William M. Brack72ee48d2003-12-30 08:30:19 +000078 int urlNr; /* number of URLs stacked */
79 int urlMax; /* size of URL stack */
80 xmlChar * *urlTab; /* URL stack */
Daniel Veillardf4b4f982003-02-13 11:02:08 +000081
Daniel Veillardd581b7e2003-02-11 18:03:05 +000082 int nbErrors; /* the number of errors detected */
Daniel Veillardb5fa0202003-12-08 17:41:29 +000083 int legacy; /* using XINCLUDE_OLD_NS */
Daniel Veillarde74d2e12003-12-09 11:35:37 +000084 int parseFlags; /* the flags used for parsing XML documents */
William M. Brackf7789b12004-06-07 08:57:27 +000085 xmlChar * base; /* the current xml:base */
Daniel Veillard681e9042006-09-29 09:16:00 +000086
87 void *_private; /* application data */
Owen Taylor3473f882001-02-23 17:55:21 +000088};
89
Daniel Veillardd16df9f2001-05-23 13:44:21 +000090static int
Daniel Veillard8edf1c52003-07-22 20:52:14 +000091xmlXIncludeDoProcess(xmlXIncludeCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr tree);
Owen Taylor3473f882001-02-23 17:55:21 +000092
Daniel Veillard98485322003-08-14 15:44:40 +000093
Daniel Veillardcd6ff282003-10-08 22:38:13 +000094/************************************************************************
95 * *
Daniel Veillardf8e3db02012-09-11 13:26:36 +080096 * XInclude error handler *
Daniel Veillardcd6ff282003-10-08 22:38:13 +000097 * *
98 ************************************************************************/
99
Daniel Veillard98485322003-08-14 15:44:40 +0000100/**
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000101 * xmlXIncludeErrMemory:
William M. Brack72ee48d2003-12-30 08:30:19 +0000102 * @extra: extra information
Daniel Veillard98485322003-08-14 15:44:40 +0000103 *
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000104 * Handle an out of memory condition
Daniel Veillard98485322003-08-14 15:44:40 +0000105 */
106static void
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000107xmlXIncludeErrMemory(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node,
108 const char *extra)
Daniel Veillard98485322003-08-14 15:44:40 +0000109{
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000110 if (ctxt != NULL)
111 ctxt->nbErrors++;
Daniel Veillard659e71e2003-10-10 14:10:40 +0000112 __xmlRaiseError(NULL, NULL, NULL, ctxt, node, XML_FROM_XINCLUDE,
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000113 XML_ERR_NO_MEMORY, XML_ERR_ERROR, NULL, 0,
114 extra, NULL, NULL, 0, 0,
115 "Memory allocation failed : %s\n", extra);
116}
Daniel Veillard98485322003-08-14 15:44:40 +0000117
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000118/**
119 * xmlXIncludeErr:
120 * @ctxt: the XInclude context
121 * @node: the context node
122 * @msg: the error message
William M. Brack72ee48d2003-12-30 08:30:19 +0000123 * @extra: extra information
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000124 *
Daniel Veillardb5fa0202003-12-08 17:41:29 +0000125 * Handle an XInclude error
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000126 */
127static void
128xmlXIncludeErr(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node, int error,
129 const char *msg, const xmlChar *extra)
130{
131 if (ctxt != NULL)
132 ctxt->nbErrors++;
Daniel Veillard659e71e2003-10-10 14:10:40 +0000133 __xmlRaiseError(NULL, NULL, NULL, ctxt, node, XML_FROM_XINCLUDE,
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000134 error, XML_ERR_ERROR, NULL, 0,
135 (const char *) extra, NULL, NULL, 0, 0,
136 msg, (const char *) extra);
Daniel Veillard98485322003-08-14 15:44:40 +0000137}
138
Daniel Veillardf54cd532004-02-25 11:52:31 +0000139#if 0
Owen Taylor3473f882001-02-23 17:55:21 +0000140/**
Daniel Veillardb5fa0202003-12-08 17:41:29 +0000141 * xmlXIncludeWarn:
142 * @ctxt: the XInclude context
143 * @node: the context node
144 * @msg: the error message
William M. Brack72ee48d2003-12-30 08:30:19 +0000145 * @extra: extra information
Daniel Veillardb5fa0202003-12-08 17:41:29 +0000146 *
147 * Emit an XInclude warning.
148 */
149static void
150xmlXIncludeWarn(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node, int error,
151 const char *msg, const xmlChar *extra)
152{
153 __xmlRaiseError(NULL, NULL, NULL, ctxt, node, XML_FROM_XINCLUDE,
154 error, XML_ERR_WARNING, NULL, 0,
155 (const char *) extra, NULL, NULL, 0, 0,
156 msg, (const char *) extra);
157}
Daniel Veillardf54cd532004-02-25 11:52:31 +0000158#endif
Daniel Veillardb5fa0202003-12-08 17:41:29 +0000159
160/**
161 * xmlXIncludeGetProp:
162 * @ctxt: the XInclude context
163 * @cur: the node
164 * @name: the attribute name
165 *
166 * Get an XInclude attribute
167 *
168 * Returns the value (to be freed) or NULL if not found
169 */
170static xmlChar *
171xmlXIncludeGetProp(xmlXIncludeCtxtPtr ctxt, xmlNodePtr cur,
172 const xmlChar *name) {
173 xmlChar *ret;
174
175 ret = xmlGetNsProp(cur, XINCLUDE_NS, name);
176 if (ret != NULL)
177 return(ret);
178 if (ctxt->legacy != 0) {
179 ret = xmlGetNsProp(cur, XINCLUDE_OLD_NS, name);
180 if (ret != NULL)
181 return(ret);
182 }
183 ret = xmlGetProp(cur, name);
184 return(ret);
185}
186/**
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000187 * xmlXIncludeFreeRef:
188 * @ref: the XInclude reference
189 *
190 * Free an XInclude reference
191 */
192static void
193xmlXIncludeFreeRef(xmlXIncludeRefPtr ref) {
194 if (ref == NULL)
195 return;
196#ifdef DEBUG_XINCLUDE
197 xmlGenericError(xmlGenericErrorContext, "Freeing ref\n");
198#endif
199 if (ref->doc != NULL) {
200#ifdef DEBUG_XINCLUDE
201 xmlGenericError(xmlGenericErrorContext, "Freeing doc %s\n", ref->URI);
202#endif
203 xmlFreeDoc(ref->doc);
204 }
205 if (ref->URI != NULL)
206 xmlFree(ref->URI);
207 if (ref->fragment != NULL)
208 xmlFree(ref->fragment);
Daniel Veillardf4b4f982003-02-13 11:02:08 +0000209 if (ref->xptr != NULL)
210 xmlXPathFreeObject(ref->xptr);
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000211 xmlFree(ref);
212}
213
214/**
215 * xmlXIncludeNewRef:
216 * @ctxt: the XInclude context
217 * @URI: the resource URI
218 *
219 * Creates a new reference within an XInclude context
220 *
221 * Returns the new set
222 */
223static xmlXIncludeRefPtr
224xmlXIncludeNewRef(xmlXIncludeCtxtPtr ctxt, const xmlChar *URI,
225 xmlNodePtr ref) {
226 xmlXIncludeRefPtr ret;
227
228#ifdef DEBUG_XINCLUDE
229 xmlGenericError(xmlGenericErrorContext, "New ref %s\n", URI);
230#endif
231 ret = (xmlXIncludeRefPtr) xmlMalloc(sizeof(xmlXIncludeRef));
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000232 if (ret == NULL) {
233 xmlXIncludeErrMemory(ctxt, ref, "growing XInclude context");
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000234 return(NULL);
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000235 }
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000236 memset(ret, 0, sizeof(xmlXIncludeRef));
237 if (URI == NULL)
238 ret->URI = NULL;
239 else
240 ret->URI = xmlStrdup(URI);
241 ret->fragment = NULL;
242 ret->ref = ref;
Daniel Veillard24505b02005-07-28 23:49:35 +0000243 ret->doc = NULL;
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000244 ret->count = 0;
245 ret->xml = 0;
246 ret->inc = NULL;
247 if (ctxt->incMax == 0) {
248 ctxt->incMax = 4;
249 ctxt->incTab = (xmlXIncludeRefPtr *) xmlMalloc(ctxt->incMax *
250 sizeof(ctxt->incTab[0]));
251 if (ctxt->incTab == NULL) {
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000252 xmlXIncludeErrMemory(ctxt, ref, "growing XInclude context");
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000253 xmlXIncludeFreeRef(ret);
254 return(NULL);
255 }
256 }
257 if (ctxt->incNr >= ctxt->incMax) {
258 ctxt->incMax *= 2;
259 ctxt->incTab = (xmlXIncludeRefPtr *) xmlRealloc(ctxt->incTab,
260 ctxt->incMax * sizeof(ctxt->incTab[0]));
261 if (ctxt->incTab == NULL) {
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000262 xmlXIncludeErrMemory(ctxt, ref, "growing XInclude context");
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000263 xmlXIncludeFreeRef(ret);
264 return(NULL);
265 }
266 }
267 ctxt->incTab[ctxt->incNr++] = ret;
268 return(ret);
269}
270
271/**
Owen Taylor3473f882001-02-23 17:55:21 +0000272 * xmlXIncludeNewContext:
273 * @doc: an XML Document
274 *
275 * Creates a new XInclude context
276 *
277 * Returns the new set
278 */
Daniel Veillard7899c5c2003-11-03 12:31:38 +0000279xmlXIncludeCtxtPtr
Owen Taylor3473f882001-02-23 17:55:21 +0000280xmlXIncludeNewContext(xmlDocPtr doc) {
281 xmlXIncludeCtxtPtr ret;
282
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000283#ifdef DEBUG_XINCLUDE
284 xmlGenericError(xmlGenericErrorContext, "New context\n");
285#endif
Owen Taylor3473f882001-02-23 17:55:21 +0000286 if (doc == NULL)
287 return(NULL);
288 ret = (xmlXIncludeCtxtPtr) xmlMalloc(sizeof(xmlXIncludeCtxt));
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000289 if (ret == NULL) {
290 xmlXIncludeErrMemory(NULL, (xmlNodePtr) doc,
291 "creating XInclude context");
Owen Taylor3473f882001-02-23 17:55:21 +0000292 return(NULL);
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000293 }
Owen Taylor3473f882001-02-23 17:55:21 +0000294 memset(ret, 0, sizeof(xmlXIncludeCtxt));
295 ret->doc = doc;
296 ret->incNr = 0;
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000297 ret->incBase = 0;
Owen Taylor3473f882001-02-23 17:55:21 +0000298 ret->incMax = 0;
299 ret->incTab = NULL;
Daniel Veillardd581b7e2003-02-11 18:03:05 +0000300 ret->nbErrors = 0;
Owen Taylor3473f882001-02-23 17:55:21 +0000301 return(ret);
302}
303
304/**
Daniel Veillardf4b4f982003-02-13 11:02:08 +0000305 * xmlXIncludeURLPush:
306 * @ctxt: the parser context
307 * @value: the url
308 *
309 * Pushes a new url on top of the url stack
310 *
311 * Returns -1 in case of error, the index in the stack otherwise
312 */
313static int
314xmlXIncludeURLPush(xmlXIncludeCtxtPtr ctxt,
315 const xmlChar *value)
316{
317 if (ctxt->urlNr > XINCLUDE_MAX_DEPTH) {
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000318 xmlXIncludeErr(ctxt, NULL, XML_XINCLUDE_RECURSION,
319 "detected a recursion in %s\n", value);
Daniel Veillardf4b4f982003-02-13 11:02:08 +0000320 return(-1);
321 }
322 if (ctxt->urlTab == NULL) {
323 ctxt->urlMax = 4;
324 ctxt->urlNr = 0;
325 ctxt->urlTab = (xmlChar * *) xmlMalloc(
326 ctxt->urlMax * sizeof(ctxt->urlTab[0]));
327 if (ctxt->urlTab == NULL) {
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000328 xmlXIncludeErrMemory(ctxt, NULL, "adding URL");
Daniel Veillardf4b4f982003-02-13 11:02:08 +0000329 return (-1);
330 }
331 }
332 if (ctxt->urlNr >= ctxt->urlMax) {
333 ctxt->urlMax *= 2;
334 ctxt->urlTab =
335 (xmlChar * *) xmlRealloc(ctxt->urlTab,
336 ctxt->urlMax *
337 sizeof(ctxt->urlTab[0]));
338 if (ctxt->urlTab == NULL) {
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000339 xmlXIncludeErrMemory(ctxt, NULL, "adding URL");
Daniel Veillardf4b4f982003-02-13 11:02:08 +0000340 return (-1);
341 }
342 }
343 ctxt->url = ctxt->urlTab[ctxt->urlNr] = xmlStrdup(value);
344 return (ctxt->urlNr++);
345}
346
347/**
348 * xmlXIncludeURLPop:
349 * @ctxt: the parser context
350 *
William M. Brack72ee48d2003-12-30 08:30:19 +0000351 * Pops the top URL from the URL stack
Daniel Veillardf4b4f982003-02-13 11:02:08 +0000352 */
353static void
354xmlXIncludeURLPop(xmlXIncludeCtxtPtr ctxt)
355{
356 xmlChar * ret;
357
358 if (ctxt->urlNr <= 0)
359 return;
360 ctxt->urlNr--;
361 if (ctxt->urlNr > 0)
362 ctxt->url = ctxt->urlTab[ctxt->urlNr - 1];
363 else
364 ctxt->url = NULL;
365 ret = ctxt->urlTab[ctxt->urlNr];
Daniel Veillard24505b02005-07-28 23:49:35 +0000366 ctxt->urlTab[ctxt->urlNr] = NULL;
Daniel Veillardf4b4f982003-02-13 11:02:08 +0000367 if (ret != NULL)
368 xmlFree(ret);
369}
370
371/**
Owen Taylor3473f882001-02-23 17:55:21 +0000372 * xmlXIncludeFreeContext:
373 * @ctxt: the XInclude context
374 *
375 * Free an XInclude context
376 */
Daniel Veillard7899c5c2003-11-03 12:31:38 +0000377void
Owen Taylor3473f882001-02-23 17:55:21 +0000378xmlXIncludeFreeContext(xmlXIncludeCtxtPtr ctxt) {
379 int i;
380
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000381#ifdef DEBUG_XINCLUDE
382 xmlGenericError(xmlGenericErrorContext, "Freeing context\n");
383#endif
Owen Taylor3473f882001-02-23 17:55:21 +0000384 if (ctxt == NULL)
385 return;
Daniel Veillardf4b4f982003-02-13 11:02:08 +0000386 while (ctxt->urlNr > 0)
387 xmlXIncludeURLPop(ctxt);
388 if (ctxt->urlTab != NULL)
389 xmlFree(ctxt->urlTab);
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000390 for (i = 0;i < ctxt->incNr;i++) {
391 if (ctxt->incTab[i] != NULL)
392 xmlXIncludeFreeRef(ctxt->incTab[i]);
Owen Taylor3473f882001-02-23 17:55:21 +0000393 }
Daniel Veillard11ce4002006-03-10 00:36:23 +0000394 if (ctxt->txturlTab != NULL) {
395 for (i = 0;i < ctxt->txtNr;i++) {
396 if (ctxt->txturlTab[i] != NULL)
397 xmlFree(ctxt->txturlTab[i]);
398 }
Owen Taylor3473f882001-02-23 17:55:21 +0000399 }
400 if (ctxt->incTab != NULL)
401 xmlFree(ctxt->incTab);
Owen Taylor3473f882001-02-23 17:55:21 +0000402 if (ctxt->txtTab != NULL)
403 xmlFree(ctxt->txtTab);
404 if (ctxt->txturlTab != NULL)
405 xmlFree(ctxt->txturlTab);
Daniel Veillardce244ad2004-11-05 10:03:46 +0000406 if (ctxt->base != NULL) {
407 xmlFree(ctxt->base);
408 }
Owen Taylor3473f882001-02-23 17:55:21 +0000409 xmlFree(ctxt);
410}
411
Daniel Veillardd16df9f2001-05-23 13:44:21 +0000412/**
Daniel Veillard98485322003-08-14 15:44:40 +0000413 * xmlXIncludeParseFile:
414 * @ctxt: the XInclude context
415 * @URL: the URL or file path
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800416 *
William M. Brack72ee48d2003-12-30 08:30:19 +0000417 * parse a document for XInclude
Daniel Veillard98485322003-08-14 15:44:40 +0000418 */
419static xmlDocPtr
Daniel Veillarde74d2e12003-12-09 11:35:37 +0000420xmlXIncludeParseFile(xmlXIncludeCtxtPtr ctxt, const char *URL) {
Daniel Veillard98485322003-08-14 15:44:40 +0000421 xmlDocPtr ret;
422 xmlParserCtxtPtr pctxt;
Daniel Veillarde74d2e12003-12-09 11:35:37 +0000423 xmlParserInputPtr inputStream;
Daniel Veillard98485322003-08-14 15:44:40 +0000424
425 xmlInitParser();
426
Daniel Veillarde74d2e12003-12-09 11:35:37 +0000427 pctxt = xmlNewParserCtxt();
Daniel Veillard98485322003-08-14 15:44:40 +0000428 if (pctxt == NULL) {
Daniel Veillarde74d2e12003-12-09 11:35:37 +0000429 xmlXIncludeErrMemory(ctxt, NULL, "cannot allocate parser context");
Daniel Veillard98485322003-08-14 15:44:40 +0000430 return(NULL);
431 }
Daniel Veillard681e9042006-09-29 09:16:00 +0000432
433 /*
434 * pass in the application data to the parser context.
435 */
436 pctxt->_private = ctxt->_private;
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800437
Daniel Veillarde74d2e12003-12-09 11:35:37 +0000438 /*
William M. Brack72ee48d2003-12-30 08:30:19 +0000439 * try to ensure that new documents included are actually
Daniel Veillarde74d2e12003-12-09 11:35:37 +0000440 * built with the same dictionary as the including document.
441 */
Daniel Veillardcb6f5252009-08-25 19:24:15 +0200442 if ((ctxt->doc != NULL) && (ctxt->doc->dict != NULL)) {
443 if (pctxt->dict != NULL)
444 xmlDictFree(pctxt->dict);
Daniel Veillarde74d2e12003-12-09 11:35:37 +0000445 pctxt->dict = ctxt->doc->dict;
446 xmlDictReference(pctxt->dict);
447 }
448
449 xmlCtxtUseOptions(pctxt, ctxt->parseFlags | XML_PARSE_DTDLOAD);
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800450
Daniel Veillarde74d2e12003-12-09 11:35:37 +0000451 inputStream = xmlLoadExternalEntity(URL, NULL, pctxt);
452 if (inputStream == NULL) {
453 xmlFreeParserCtxt(pctxt);
454 return(NULL);
455 }
456
457 inputPush(pctxt, inputStream);
Daniel Veillard98485322003-08-14 15:44:40 +0000458
Daniel Veillard37d2d162008-03-14 10:54:00 +0000459 if (pctxt->directory == NULL)
460 pctxt->directory = xmlParserGetDirectory(URL);
Daniel Veillard98485322003-08-14 15:44:40 +0000461
William M. Bracka22da292005-02-12 01:08:22 +0000462 pctxt->loadsubset |= XML_DETECT_IDS;
Daniel Veillard98485322003-08-14 15:44:40 +0000463
464 xmlParseDocument(pctxt);
465
William M. Brack1ff42132003-12-31 14:05:15 +0000466 if (pctxt->wellFormed) {
Daniel Veillard98485322003-08-14 15:44:40 +0000467 ret = pctxt->myDoc;
William M. Brack1ff42132003-12-31 14:05:15 +0000468 }
Daniel Veillard98485322003-08-14 15:44:40 +0000469 else {
470 ret = NULL;
Daniel Veillard500a1de2004-03-22 15:22:58 +0000471 if (pctxt->myDoc != NULL)
Daniel Veillard4773df22004-01-23 13:15:13 +0000472 xmlFreeDoc(pctxt->myDoc);
Daniel Veillard98485322003-08-14 15:44:40 +0000473 pctxt->myDoc = NULL;
474 }
475 xmlFreeParserCtxt(pctxt);
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800476
Daniel Veillard98485322003-08-14 15:44:40 +0000477 return(ret);
478}
479
480/**
Daniel Veillardd16df9f2001-05-23 13:44:21 +0000481 * xmlXIncludeAddNode:
482 * @ctxt: the XInclude context
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000483 * @cur: the new node
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800484 *
Daniel Veillardd16df9f2001-05-23 13:44:21 +0000485 * Add a new node to process to an XInclude context
486 */
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000487static int
488xmlXIncludeAddNode(xmlXIncludeCtxtPtr ctxt, xmlNodePtr cur) {
489 xmlXIncludeRefPtr ref;
490 xmlURIPtr uri;
491 xmlChar *URL;
492 xmlChar *fragment = NULL;
493 xmlChar *href;
494 xmlChar *parse;
495 xmlChar *base;
496 xmlChar *URI;
Daniel Veillardf4b4f982003-02-13 11:02:08 +0000497 int xml = 1, i; /* default Issue 64 */
498 int local = 0;
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000499
500
501 if (ctxt == NULL)
502 return(-1);
503 if (cur == NULL)
504 return(-1);
505
506#ifdef DEBUG_XINCLUDE
507 xmlGenericError(xmlGenericErrorContext, "Add node\n");
508#endif
509 /*
510 * read the attributes
511 */
Daniel Veillardb5fa0202003-12-08 17:41:29 +0000512 href = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_HREF);
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000513 if (href == NULL) {
Daniel Veillardb5fa0202003-12-08 17:41:29 +0000514 href = xmlStrdup(BAD_CAST ""); /* @@@@ href is now optional */
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800515 if (href == NULL)
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000516 return(-1);
Daniel Veillardd16df9f2001-05-23 13:44:21 +0000517 }
Daniel Veillardb242b082008-02-08 09:56:31 +0000518 if ((href[0] == '#') || (href[0] == 0))
Daniel Veillardf4b4f982003-02-13 11:02:08 +0000519 local = 1;
Daniel Veillardb5fa0202003-12-08 17:41:29 +0000520 parse = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_PARSE);
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000521 if (parse != NULL) {
522 if (xmlStrEqual(parse, XINCLUDE_PARSE_XML))
523 xml = 1;
524 else if (xmlStrEqual(parse, XINCLUDE_PARSE_TEXT))
525 xml = 0;
526 else {
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000527 xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_PARSE_VALUE,
528 "invalid value %s for 'parse'\n", parse);
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000529 if (href != NULL)
530 xmlFree(href);
531 if (parse != NULL)
532 xmlFree(parse);
533 return(-1);
Daniel Veillardd16df9f2001-05-23 13:44:21 +0000534 }
535 }
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000536
537 /*
538 * compute the URI
539 */
540 base = xmlNodeGetBase(ctxt->doc, cur);
541 if (base == NULL) {
542 URI = xmlBuildURI(href, ctxt->doc->URL);
543 } else {
544 URI = xmlBuildURI(href, base);
545 }
546 if (URI == NULL) {
547 xmlChar *escbase;
548 xmlChar *eschref;
549 /*
550 * Some escaping may be needed
551 */
552 escbase = xmlURIEscape(base);
553 eschref = xmlURIEscape(href);
554 URI = xmlBuildURI(eschref, escbase);
555 if (escbase != NULL)
556 xmlFree(escbase);
557 if (eschref != NULL)
558 xmlFree(eschref);
559 }
560 if (parse != NULL)
561 xmlFree(parse);
562 if (href != NULL)
563 xmlFree(href);
564 if (base != NULL)
565 xmlFree(base);
566 if (URI == NULL) {
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000567 xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_HREF_URI,
568 "failed build URL\n", NULL);
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000569 return(-1);
570 }
Daniel Veillarde74d2e12003-12-09 11:35:37 +0000571 fragment = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_PARSE_XPOINTER);
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000572
573 /*
574 * Check the URL and remove any fragment identifier
575 */
576 uri = xmlParseURI((const char *)URI);
577 if (uri == NULL) {
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000578 xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_HREF_URI,
579 "invalid value URI %s\n", URI);
Daniel Veillarde74d2e12003-12-09 11:35:37 +0000580 if (fragment != NULL)
581 xmlFree(fragment);
582 xmlFree(URI);
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000583 return(-1);
584 }
Daniel Veillarde74d2e12003-12-09 11:35:37 +0000585
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000586 if (uri->fragment != NULL) {
Daniel Veillarde74d2e12003-12-09 11:35:37 +0000587 if (ctxt->legacy != 0) {
588 if (fragment == NULL) {
589 fragment = (xmlChar *) uri->fragment;
590 } else {
591 xmlFree(uri->fragment);
592 }
593 } else {
594 xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_FRAGMENT_ID,
595 "Invalid fragment identifier in URI %s use the xpointer attribute\n",
596 URI);
597 if (fragment != NULL)
598 xmlFree(fragment);
599 xmlFreeURI(uri);
600 xmlFree(URI);
601 return(-1);
602 }
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000603 uri->fragment = NULL;
604 }
605 URL = xmlSaveUri(uri);
606 xmlFreeURI(uri);
607 xmlFree(URI);
608 if (URL == NULL) {
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000609 xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_HREF_URI,
610 "invalid value URI %s\n", URI);
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000611 if (fragment != NULL)
612 xmlFree(fragment);
613 return(-1);
614 }
615
Daniel Veillardf4b4f982003-02-13 11:02:08 +0000616 /*
Daniel Veillardb242b082008-02-08 09:56:31 +0000617 * If local and xml then we need a fragment
618 */
619 if ((local == 1) && (xml == 1) &&
620 ((fragment == NULL) || (fragment[0] == 0))) {
621 xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_RECURSION,
622 "detected a local recursion with no xpointer in %s\n",
623 URL);
624 if (fragment != NULL)
625 xmlFree(fragment);
626 return(-1);
627 }
628
629 /*
Daniel Veillardf4b4f982003-02-13 11:02:08 +0000630 * Check the URL against the stack for recursions
631 */
Daniel Veillardbf630c02006-06-06 08:21:41 +0000632 if ((!local) && (xml == 1)) {
Daniel Veillardf4b4f982003-02-13 11:02:08 +0000633 for (i = 0;i < ctxt->urlNr;i++) {
634 if (xmlStrEqual(URL, ctxt->urlTab[i])) {
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000635 xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_RECURSION,
636 "detected a recursion in %s\n", URL);
Daniel Veillardf4b4f982003-02-13 11:02:08 +0000637 return(-1);
638 }
639 }
640 }
641
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000642 ref = xmlXIncludeNewRef(ctxt, URL, cur);
643 if (ref == NULL) {
644 return(-1);
645 }
646 ref->fragment = fragment;
647 ref->doc = NULL;
648 ref->xml = xml;
649 ref->count = 1;
650 xmlFree(URL);
651 return(0);
Daniel Veillardd16df9f2001-05-23 13:44:21 +0000652}
653
654/**
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000655 * xmlXIncludeRecurseDoc:
Daniel Veillardd16df9f2001-05-23 13:44:21 +0000656 * @ctxt: the XInclude context
657 * @doc: the new document
658 * @url: the associated URL
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800659 *
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000660 * The XInclude recursive nature is handled at this point.
Daniel Veillardd16df9f2001-05-23 13:44:21 +0000661 */
662static void
Daniel Veillard118aed72002-09-24 14:13:13 +0000663xmlXIncludeRecurseDoc(xmlXIncludeCtxtPtr ctxt, xmlDocPtr doc,
Daniel Veillarddda8f1b2002-09-26 09:47:36 +0000664 const xmlURL url ATTRIBUTE_UNUSED) {
Daniel Veillardd16df9f2001-05-23 13:44:21 +0000665 xmlXIncludeCtxtPtr newctxt;
666 int i;
667
Daniel Veillardf4b4f982003-02-13 11:02:08 +0000668 /*
669 * Avoid recursion in already substitued resources
670 for (i = 0;i < ctxt->urlNr;i++) {
671 if (xmlStrEqual(doc->URL, ctxt->urlTab[i]))
672 return;
673 }
674 */
675
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000676#ifdef DEBUG_XINCLUDE
677 xmlGenericError(xmlGenericErrorContext, "Recursing in doc %s\n", doc->URL);
678#endif
Daniel Veillardd16df9f2001-05-23 13:44:21 +0000679 /*
680 * Handle recursion here.
681 */
682
683 newctxt = xmlXIncludeNewContext(doc);
684 if (newctxt != NULL) {
685 /*
Daniel Veillarda6585822006-12-04 09:21:28 +0000686 * Copy the private user data
687 */
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800688 newctxt->_private = ctxt->_private;
Daniel Veillarda6585822006-12-04 09:21:28 +0000689 /*
Daniel Veillardd16df9f2001-05-23 13:44:21 +0000690 * Copy the existing document set
691 */
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000692 newctxt->incMax = ctxt->incMax;
693 newctxt->incNr = ctxt->incNr;
694 newctxt->incTab = (xmlXIncludeRefPtr *) xmlMalloc(newctxt->incMax *
695 sizeof(newctxt->incTab[0]));
696 if (newctxt->incTab == NULL) {
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000697 xmlXIncludeErrMemory(ctxt, (xmlNodePtr) doc, "processing doc");
Daniel Veillardd16df9f2001-05-23 13:44:21 +0000698 xmlFree(newctxt);
699 return;
700 }
Daniel Veillardf4b4f982003-02-13 11:02:08 +0000701 /*
702 * copy the urlTab
703 */
704 newctxt->urlMax = ctxt->urlMax;
705 newctxt->urlNr = ctxt->urlNr;
706 newctxt->urlTab = ctxt->urlTab;
Daniel Veillardd16df9f2001-05-23 13:44:21 +0000707
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000708 /*
William M. Brackf7789b12004-06-07 08:57:27 +0000709 * Inherit the existing base
710 */
Daniel Veillardce244ad2004-11-05 10:03:46 +0000711 newctxt->base = xmlStrdup(ctxt->base);
William M. Brackf7789b12004-06-07 08:57:27 +0000712
713 /*
William M. Brack72ee48d2003-12-30 08:30:19 +0000714 * Inherit the documents already in use by other includes
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000715 */
716 newctxt->incBase = ctxt->incNr;
717 for (i = 0;i < ctxt->incNr;i++) {
718 newctxt->incTab[i] = ctxt->incTab[i];
719 newctxt->incTab[i]->count++; /* prevent the recursion from
720 freeing it */
Daniel Veillardd16df9f2001-05-23 13:44:21 +0000721 }
William M. Bracka11e4832004-03-07 11:03:43 +0000722 /*
723 * The new context should also inherit the Parse Flags
724 * (bug 132597)
725 */
726 newctxt->parseFlags = ctxt->parseFlags;
Daniel Veillard8edf1c52003-07-22 20:52:14 +0000727 xmlXIncludeDoProcess(newctxt, doc, xmlDocGetRootElement(doc));
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000728 for (i = 0;i < ctxt->incNr;i++) {
729 newctxt->incTab[i]->count--;
730 newctxt->incTab[i] = NULL;
Daniel Veillardd16df9f2001-05-23 13:44:21 +0000731 }
Daniel Veillardd9b72832003-03-27 14:24:00 +0000732
733 /* urlTab may have been reallocated */
734 ctxt->urlTab = newctxt->urlTab;
735 ctxt->urlMax = newctxt->urlMax;
736
Daniel Veillardf4b4f982003-02-13 11:02:08 +0000737 newctxt->urlMax = 0;
738 newctxt->urlNr = 0;
739 newctxt->urlTab = NULL;
740
Daniel Veillardd16df9f2001-05-23 13:44:21 +0000741 xmlXIncludeFreeContext(newctxt);
742 }
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000743#ifdef DEBUG_XINCLUDE
744 xmlGenericError(xmlGenericErrorContext, "Done recursing in doc %s\n", url);
745#endif
Daniel Veillardd16df9f2001-05-23 13:44:21 +0000746}
747
748/**
749 * xmlXIncludeAddTxt:
750 * @ctxt: the XInclude context
751 * @txt: the new text node
752 * @url: the associated URL
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800753 *
Daniel Veillardd16df9f2001-05-23 13:44:21 +0000754 * Add a new txtument to the list
755 */
756static void
757xmlXIncludeAddTxt(xmlXIncludeCtxtPtr ctxt, xmlNodePtr txt, const xmlURL url) {
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000758#ifdef DEBUG_XINCLUDE
759 xmlGenericError(xmlGenericErrorContext, "Adding text %s\n", url);
760#endif
Daniel Veillardd16df9f2001-05-23 13:44:21 +0000761 if (ctxt->txtMax == 0) {
762 ctxt->txtMax = 4;
763 ctxt->txtTab = (xmlNodePtr *) xmlMalloc(ctxt->txtMax *
764 sizeof(ctxt->txtTab[0]));
765 if (ctxt->txtTab == NULL) {
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000766 xmlXIncludeErrMemory(ctxt, NULL, "processing text");
Daniel Veillardd16df9f2001-05-23 13:44:21 +0000767 return;
768 }
769 ctxt->txturlTab = (xmlURL *) xmlMalloc(ctxt->txtMax *
770 sizeof(ctxt->txturlTab[0]));
771 if (ctxt->txturlTab == NULL) {
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000772 xmlXIncludeErrMemory(ctxt, NULL, "processing text");
Daniel Veillardd16df9f2001-05-23 13:44:21 +0000773 return;
774 }
775 }
776 if (ctxt->txtNr >= ctxt->txtMax) {
777 ctxt->txtMax *= 2;
778 ctxt->txtTab = (xmlNodePtr *) xmlRealloc(ctxt->txtTab,
779 ctxt->txtMax * sizeof(ctxt->txtTab[0]));
780 if (ctxt->txtTab == NULL) {
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000781 xmlXIncludeErrMemory(ctxt, NULL, "processing text");
Daniel Veillardd16df9f2001-05-23 13:44:21 +0000782 return;
783 }
784 ctxt->txturlTab = (xmlURL *) xmlRealloc(ctxt->txturlTab,
Daniel Veillardbbc72c32002-09-05 10:52:10 +0000785 ctxt->txtMax * sizeof(ctxt->txturlTab[0]));
Daniel Veillardd16df9f2001-05-23 13:44:21 +0000786 if (ctxt->txturlTab == NULL) {
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000787 xmlXIncludeErrMemory(ctxt, NULL, "processing text");
Daniel Veillardd16df9f2001-05-23 13:44:21 +0000788 return;
789 }
790 }
791 ctxt->txtTab[ctxt->txtNr] = txt;
792 ctxt->txturlTab[ctxt->txtNr] = xmlStrdup(url);
793 ctxt->txtNr++;
794}
795
Owen Taylor3473f882001-02-23 17:55:21 +0000796/************************************************************************
797 * *
Daniel Veillardc5f05ad2002-02-10 11:57:22 +0000798 * Node copy with specific semantic *
799 * *
800 ************************************************************************/
801
Daniel Veillardcb6f5252009-08-25 19:24:15 +0200802static xmlNodePtr
803xmlXIncludeCopyNodeList(xmlXIncludeCtxtPtr ctxt, xmlDocPtr target,
804 xmlDocPtr source, xmlNodePtr elem);
805
Daniel Veillardc5f05ad2002-02-10 11:57:22 +0000806/**
807 * xmlXIncludeCopyNode:
808 * @ctxt: the XInclude context
809 * @target: the document target
810 * @source: the document source
811 * @elem: the element
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800812 *
Daniel Veillardc5f05ad2002-02-10 11:57:22 +0000813 * Make a copy of the node while preserving the XInclude semantic
814 * of the Infoset copy
815 */
816static xmlNodePtr
817xmlXIncludeCopyNode(xmlXIncludeCtxtPtr ctxt, xmlDocPtr target,
818 xmlDocPtr source, xmlNodePtr elem) {
819 xmlNodePtr result = NULL;
820
821 if ((ctxt == NULL) || (target == NULL) || (source == NULL) ||
822 (elem == NULL))
823 return(NULL);
824 if (elem->type == XML_DTD_NODE)
825 return(NULL);
Daniel Veillardcb6f5252009-08-25 19:24:15 +0200826 if (elem->type == XML_DOCUMENT_NODE)
827 result = xmlXIncludeCopyNodeList(ctxt, target, source, elem->children);
828 else
829 result = xmlDocCopyNode(elem, target, 1);
Daniel Veillardc5f05ad2002-02-10 11:57:22 +0000830 return(result);
831}
832
833/**
834 * xmlXIncludeCopyNodeList:
835 * @ctxt: the XInclude context
836 * @target: the document target
837 * @source: the document source
838 * @elem: the element list
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800839 *
Daniel Veillardc5f05ad2002-02-10 11:57:22 +0000840 * Make a copy of the node list while preserving the XInclude semantic
841 * of the Infoset copy
842 */
843static xmlNodePtr
844xmlXIncludeCopyNodeList(xmlXIncludeCtxtPtr ctxt, xmlDocPtr target,
845 xmlDocPtr source, xmlNodePtr elem) {
846 xmlNodePtr cur, res, result = NULL, last = NULL;
847
848 if ((ctxt == NULL) || (target == NULL) || (source == NULL) ||
849 (elem == NULL))
850 return(NULL);
851 cur = elem;
852 while (cur != NULL) {
853 res = xmlXIncludeCopyNode(ctxt, target, source, cur);
854 if (res != NULL) {
855 if (result == NULL) {
856 result = last = res;
857 } else {
858 last->next = res;
859 res->prev = last;
860 last = res;
861 }
862 }
863 cur = cur->next;
864 }
865 return(result);
866}
867
868/**
William M. Brack72ee48d2003-12-30 08:30:19 +0000869 * xmlXIncludeGetNthChild:
Daniel Veillardc5f05ad2002-02-10 11:57:22 +0000870 * @cur: the node
871 * @no: the child number
872 *
William M. Brack72ee48d2003-12-30 08:30:19 +0000873 * Returns the @n'th element child of @cur or NULL
Daniel Veillardc5f05ad2002-02-10 11:57:22 +0000874 */
875static xmlNodePtr
876xmlXIncludeGetNthChild(xmlNodePtr cur, int no) {
877 int i;
Daniel Veillard3e62adb2012-08-09 14:24:02 +0800878 if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL))
879 return(NULL);
Daniel Veillardc5f05ad2002-02-10 11:57:22 +0000880 cur = cur->children;
881 for (i = 0;i <= no;cur = cur->next) {
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800882 if (cur == NULL)
Daniel Veillardc5f05ad2002-02-10 11:57:22 +0000883 return(cur);
884 if ((cur->type == XML_ELEMENT_NODE) ||
885 (cur->type == XML_DOCUMENT_NODE) ||
886 (cur->type == XML_HTML_DOCUMENT_NODE)) {
887 i++;
888 if (i == no)
889 break;
890 }
891 }
892 return(cur);
893}
894
William M. Brackf7eb7942003-12-31 07:59:17 +0000895xmlNodePtr xmlXPtrAdvanceNode(xmlNodePtr cur, int *level); /* in xpointer.c */
Daniel Veillardc5f05ad2002-02-10 11:57:22 +0000896/**
897 * xmlXIncludeCopyRange:
898 * @ctxt: the XInclude context
899 * @target: the document target
900 * @source: the document source
901 * @obj: the XPointer result from the evaluation.
902 *
903 * Build a node list tree copy of the XPointer result.
904 *
905 * Returns an xmlNodePtr list or NULL.
William M. Brack72ee48d2003-12-30 08:30:19 +0000906 * The caller has to free the node tree.
Daniel Veillardc5f05ad2002-02-10 11:57:22 +0000907 */
908static xmlNodePtr
909xmlXIncludeCopyRange(xmlXIncludeCtxtPtr ctxt, xmlDocPtr target,
910 xmlDocPtr source, xmlXPathObjectPtr range) {
911 /* pointers to generated nodes */
William M. Brackf7eb7942003-12-31 07:59:17 +0000912 xmlNodePtr list = NULL, last = NULL, listParent = NULL;
913 xmlNodePtr tmp, tmp2;
Daniel Veillardc5f05ad2002-02-10 11:57:22 +0000914 /* pointers to traversal nodes */
915 xmlNodePtr start, cur, end;
916 int index1, index2;
William M. Brack6bdacd72004-02-07 08:53:23 +0000917 int level = 0, lastLevel = 0, endLevel = 0, endFlag = 0;
Daniel Veillardc5f05ad2002-02-10 11:57:22 +0000918
919 if ((ctxt == NULL) || (target == NULL) || (source == NULL) ||
920 (range == NULL))
921 return(NULL);
922 if (range->type != XPATH_RANGE)
923 return(NULL);
924 start = (xmlNodePtr) range->user;
925
Daniel Veillard3e62adb2012-08-09 14:24:02 +0800926 if ((start == NULL) || (start->type == XML_NAMESPACE_DECL))
Daniel Veillardc5f05ad2002-02-10 11:57:22 +0000927 return(NULL);
928 end = range->user2;
929 if (end == NULL)
930 return(xmlDocCopyNode(start, target, 1));
Daniel Veillard3e62adb2012-08-09 14:24:02 +0800931 if (end->type == XML_NAMESPACE_DECL)
932 return(NULL);
Daniel Veillardc5f05ad2002-02-10 11:57:22 +0000933
934 cur = start;
935 index1 = range->index;
936 index2 = range->index2;
William M. Brackf7eb7942003-12-31 07:59:17 +0000937 /*
938 * level is depth of the current node under consideration
939 * list is the pointer to the root of the output tree
940 * listParent is a pointer to the parent of output tree (within
941 the included file) in case we need to add another level
942 * last is a pointer to the last node added to the output tree
943 * lastLevel is the depth of last (relative to the root)
944 */
Daniel Veillardc5f05ad2002-02-10 11:57:22 +0000945 while (cur != NULL) {
William M. Brackf7eb7942003-12-31 07:59:17 +0000946 /*
947 * Check if our output tree needs a parent
948 */
949 if (level < 0) {
950 while (level < 0) {
William M. Brack57e9e912004-03-09 16:19:02 +0000951 /* copy must include namespaces and properties */
952 tmp2 = xmlDocCopyNode(listParent, target, 2);
William M. Brackf7eb7942003-12-31 07:59:17 +0000953 xmlAddChild(tmp2, list);
954 list = tmp2;
955 listParent = listParent->parent;
956 level++;
957 }
958 last = list;
959 lastLevel = 0;
960 }
961 /*
962 * Check whether we need to change our insertion point
963 */
964 while (level < lastLevel) {
965 last = last->parent;
966 lastLevel --;
967 }
William M. Brack72ee48d2003-12-30 08:30:19 +0000968 if (cur == end) { /* Are we at the end of the range? */
Daniel Veillardc5f05ad2002-02-10 11:57:22 +0000969 if (cur->type == XML_TEXT_NODE) {
970 const xmlChar *content = cur->content;
971 int len;
972
973 if (content == NULL) {
974 tmp = xmlNewTextLen(NULL, 0);
975 } else {
976 len = index2;
977 if ((cur == start) && (index1 > 1)) {
978 content += (index1 - 1);
979 len -= (index1 - 1);
Daniel Veillardc5f05ad2002-02-10 11:57:22 +0000980 } else {
981 len = index2;
982 }
983 tmp = xmlNewTextLen(content, len);
984 }
985 /* single sub text node selection */
986 if (list == NULL)
987 return(tmp);
988 /* prune and return full set */
William M. Brackf7eb7942003-12-31 07:59:17 +0000989 if (level == lastLevel)
Daniel Veillardc5f05ad2002-02-10 11:57:22 +0000990 xmlAddNextSibling(last, tmp);
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800991 else
William M. Brackf7eb7942003-12-31 07:59:17 +0000992 xmlAddChild(last, tmp);
Daniel Veillardc5f05ad2002-02-10 11:57:22 +0000993 return(list);
William M. Brack72ee48d2003-12-30 08:30:19 +0000994 } else { /* ending node not a text node */
William M. Brack6bdacd72004-02-07 08:53:23 +0000995 endLevel = level; /* remember the level of the end node */
996 endFlag = 1;
William M. Brack57e9e912004-03-09 16:19:02 +0000997 /* last node - need to take care of properties + namespaces */
998 tmp = xmlDocCopyNode(cur, target, 2);
William M. Brackf7eb7942003-12-31 07:59:17 +0000999 if (list == NULL) {
Daniel Veillardc5f05ad2002-02-10 11:57:22 +00001000 list = tmp;
William M. Brackf7eb7942003-12-31 07:59:17 +00001001 listParent = cur->parent;
1002 } else {
1003 if (level == lastLevel)
Daniel Veillardc5f05ad2002-02-10 11:57:22 +00001004 xmlAddNextSibling(last, tmp);
William M. Brackf7eb7942003-12-31 07:59:17 +00001005 else {
1006 xmlAddChild(last, tmp);
1007 lastLevel = level;
1008 }
Daniel Veillardc5f05ad2002-02-10 11:57:22 +00001009 }
William M. Brackf7eb7942003-12-31 07:59:17 +00001010 last = tmp;
Daniel Veillardc5f05ad2002-02-10 11:57:22 +00001011
1012 if (index2 > 1) {
1013 end = xmlXIncludeGetNthChild(cur, index2 - 1);
1014 index2 = 0;
1015 }
1016 if ((cur == start) && (index1 > 1)) {
1017 cur = xmlXIncludeGetNthChild(cur, index1 - 1);
1018 index1 = 0;
William M. Brack6bdacd72004-02-07 08:53:23 +00001019 } else {
Daniel Veillardc5f05ad2002-02-10 11:57:22 +00001020 cur = cur->children;
1021 }
William M. Brack6bdacd72004-02-07 08:53:23 +00001022 level++; /* increment level to show change */
Daniel Veillardc5f05ad2002-02-10 11:57:22 +00001023 /*
1024 * Now gather the remaining nodes from cur to end
1025 */
William M. Brack6bdacd72004-02-07 08:53:23 +00001026 continue; /* while */
Daniel Veillardc5f05ad2002-02-10 11:57:22 +00001027 }
William M. Brackf7eb7942003-12-31 07:59:17 +00001028 } else if (cur == start) { /* Not at the end, are we at start? */
Daniel Veillardc5f05ad2002-02-10 11:57:22 +00001029 if ((cur->type == XML_TEXT_NODE) ||
1030 (cur->type == XML_CDATA_SECTION_NODE)) {
1031 const xmlChar *content = cur->content;
1032
1033 if (content == NULL) {
1034 tmp = xmlNewTextLen(NULL, 0);
1035 } else {
1036 if (index1 > 1) {
1037 content += (index1 - 1);
William M. Brack72ee48d2003-12-30 08:30:19 +00001038 index1 = 0;
Daniel Veillardc5f05ad2002-02-10 11:57:22 +00001039 }
1040 tmp = xmlNewText(content);
1041 }
1042 last = list = tmp;
William M. Brackf7eb7942003-12-31 07:59:17 +00001043 listParent = cur->parent;
William M. Brack72ee48d2003-12-30 08:30:19 +00001044 } else { /* Not text node */
William M. Brack57e9e912004-03-09 16:19:02 +00001045 /*
1046 * start of the range - need to take care of
1047 * properties and namespaces
1048 */
1049 tmp = xmlDocCopyNode(cur, target, 2);
William M. Brackf7eb7942003-12-31 07:59:17 +00001050 list = last = tmp;
1051 listParent = cur->parent;
William M. Brack72ee48d2003-12-30 08:30:19 +00001052 if (index1 > 1) { /* Do we need to position? */
Daniel Veillardc5f05ad2002-02-10 11:57:22 +00001053 cur = xmlXIncludeGetNthChild(cur, index1 - 1);
William M. Brackf7eb7942003-12-31 07:59:17 +00001054 level = lastLevel = 1;
Daniel Veillardc5f05ad2002-02-10 11:57:22 +00001055 index1 = 0;
1056 /*
1057 * Now gather the remaining nodes from cur to end
1058 */
1059 continue; /* while */
1060 }
Daniel Veillardc5f05ad2002-02-10 11:57:22 +00001061 }
1062 } else {
1063 tmp = NULL;
1064 switch (cur->type) {
1065 case XML_DTD_NODE:
1066 case XML_ELEMENT_DECL:
1067 case XML_ATTRIBUTE_DECL:
1068 case XML_ENTITY_NODE:
1069 /* Do not copy DTD informations */
1070 break;
1071 case XML_ENTITY_DECL:
1072 /* handle crossing entities -> stack needed */
1073 break;
1074 case XML_XINCLUDE_START:
1075 case XML_XINCLUDE_END:
1076 /* don't consider it part of the tree content */
1077 break;
1078 case XML_ATTRIBUTE_NODE:
1079 /* Humm, should not happen ! */
1080 break;
1081 default:
William M. Brack57e9e912004-03-09 16:19:02 +00001082 /*
1083 * Middle of the range - need to take care of
1084 * properties and namespaces
1085 */
1086 tmp = xmlDocCopyNode(cur, target, 2);
Daniel Veillardc5f05ad2002-02-10 11:57:22 +00001087 break;
1088 }
1089 if (tmp != NULL) {
William M. Brackf7eb7942003-12-31 07:59:17 +00001090 if (level == lastLevel)
Daniel Veillardc5f05ad2002-02-10 11:57:22 +00001091 xmlAddNextSibling(last, tmp);
1092 else {
William M. Brackf7eb7942003-12-31 07:59:17 +00001093 xmlAddChild(last, tmp);
1094 lastLevel = level;
Daniel Veillardc5f05ad2002-02-10 11:57:22 +00001095 }
William M. Brackf7eb7942003-12-31 07:59:17 +00001096 last = tmp;
Daniel Veillardc5f05ad2002-02-10 11:57:22 +00001097 }
1098 }
1099 /*
1100 * Skip to next node in document order
1101 */
William M. Brackf7eb7942003-12-31 07:59:17 +00001102 cur = xmlXPtrAdvanceNode(cur, &level);
William M. Brack6bdacd72004-02-07 08:53:23 +00001103 if (endFlag && (level >= endLevel))
1104 break;
Daniel Veillardc5f05ad2002-02-10 11:57:22 +00001105 }
1106 return(list);
1107}
1108
1109/**
1110 * xmlXIncludeBuildNodeList:
1111 * @ctxt: the XInclude context
1112 * @target: the document target
1113 * @source: the document source
1114 * @obj: the XPointer result from the evaluation.
1115 *
1116 * Build a node list tree copy of the XPointer result.
1117 * This will drop Attributes and Namespace declarations.
1118 *
1119 * Returns an xmlNodePtr list or NULL.
1120 * the caller has to free the node tree.
1121 */
1122static xmlNodePtr
1123xmlXIncludeCopyXPointer(xmlXIncludeCtxtPtr ctxt, xmlDocPtr target,
1124 xmlDocPtr source, xmlXPathObjectPtr obj) {
1125 xmlNodePtr list = NULL, last = NULL;
1126 int i;
1127
Daniel Veillardf4b4f982003-02-13 11:02:08 +00001128 if (source == NULL)
1129 source = ctxt->doc;
Daniel Veillardc5f05ad2002-02-10 11:57:22 +00001130 if ((ctxt == NULL) || (target == NULL) || (source == NULL) ||
1131 (obj == NULL))
1132 return(NULL);
1133 switch (obj->type) {
1134 case XPATH_NODESET: {
1135 xmlNodeSetPtr set = obj->nodesetval;
1136 if (set == NULL)
1137 return(NULL);
1138 for (i = 0;i < set->nodeNr;i++) {
1139 if (set->nodeTab[i] == NULL)
1140 continue;
1141 switch (set->nodeTab[i]->type) {
1142 case XML_TEXT_NODE:
1143 case XML_CDATA_SECTION_NODE:
1144 case XML_ELEMENT_NODE:
1145 case XML_ENTITY_REF_NODE:
1146 case XML_ENTITY_NODE:
1147 case XML_PI_NODE:
1148 case XML_COMMENT_NODE:
1149 case XML_DOCUMENT_NODE:
1150 case XML_HTML_DOCUMENT_NODE:
1151#ifdef LIBXML_DOCB_ENABLED
1152 case XML_DOCB_DOCUMENT_NODE:
1153#endif
Daniel Veillardc5f05ad2002-02-10 11:57:22 +00001154 case XML_XINCLUDE_END:
1155 break;
Daniel Veillardf4b4f982003-02-13 11:02:08 +00001156 case XML_XINCLUDE_START: {
1157 xmlNodePtr tmp, cur = set->nodeTab[i];
1158
1159 cur = cur->next;
1160 while (cur != NULL) {
1161 switch(cur->type) {
1162 case XML_TEXT_NODE:
1163 case XML_CDATA_SECTION_NODE:
1164 case XML_ELEMENT_NODE:
1165 case XML_ENTITY_REF_NODE:
1166 case XML_ENTITY_NODE:
1167 case XML_PI_NODE:
1168 case XML_COMMENT_NODE:
1169 tmp = xmlXIncludeCopyNode(ctxt, target,
1170 source, cur);
1171 if (last == NULL) {
1172 list = last = tmp;
1173 } else {
1174 xmlAddNextSibling(last, tmp);
1175 last = tmp;
1176 }
1177 cur = cur->next;
1178 continue;
1179 default:
1180 break;
1181 }
1182 break;
1183 }
1184 continue;
1185 }
Daniel Veillardc5f05ad2002-02-10 11:57:22 +00001186 case XML_ATTRIBUTE_NODE:
1187 case XML_NAMESPACE_DECL:
1188 case XML_DOCUMENT_TYPE_NODE:
1189 case XML_DOCUMENT_FRAG_NODE:
1190 case XML_NOTATION_NODE:
1191 case XML_DTD_NODE:
1192 case XML_ELEMENT_DECL:
1193 case XML_ATTRIBUTE_DECL:
1194 case XML_ENTITY_DECL:
1195 continue; /* for */
1196 }
1197 if (last == NULL)
1198 list = last = xmlXIncludeCopyNode(ctxt, target, source,
1199 set->nodeTab[i]);
1200 else {
1201 xmlAddNextSibling(last,
1202 xmlXIncludeCopyNode(ctxt, target, source,
1203 set->nodeTab[i]));
1204 if (last->next != NULL)
1205 last = last->next;
1206 }
1207 }
1208 break;
1209 }
1210 case XPATH_LOCATIONSET: {
1211 xmlLocationSetPtr set = (xmlLocationSetPtr) obj->user;
1212 if (set == NULL)
1213 return(NULL);
1214 for (i = 0;i < set->locNr;i++) {
1215 if (last == NULL)
1216 list = last = xmlXIncludeCopyXPointer(ctxt, target, source,
1217 set->locTab[i]);
1218 else
1219 xmlAddNextSibling(last,
1220 xmlXIncludeCopyXPointer(ctxt, target, source,
1221 set->locTab[i]));
1222 if (last != NULL) {
1223 while (last->next != NULL)
1224 last = last->next;
1225 }
1226 }
1227 break;
1228 }
Daniel Veillard10acc2f2003-09-01 20:59:40 +00001229#ifdef LIBXML_XPTR_ENABLED
Daniel Veillardc5f05ad2002-02-10 11:57:22 +00001230 case XPATH_RANGE:
1231 return(xmlXIncludeCopyRange(ctxt, target, source, obj));
Daniel Veillard10acc2f2003-09-01 20:59:40 +00001232#endif
Daniel Veillardc5f05ad2002-02-10 11:57:22 +00001233 case XPATH_POINT:
1234 /* points are ignored in XInclude */
1235 break;
1236 default:
1237 break;
1238 }
1239 return(list);
1240}
1241/************************************************************************
1242 * *
Owen Taylor3473f882001-02-23 17:55:21 +00001243 * XInclude I/O handling *
1244 * *
1245 ************************************************************************/
1246
Daniel Veillardf4b4f982003-02-13 11:02:08 +00001247typedef struct _xmlXIncludeMergeData xmlXIncludeMergeData;
1248typedef xmlXIncludeMergeData *xmlXIncludeMergeDataPtr;
1249struct _xmlXIncludeMergeData {
1250 xmlDocPtr doc;
1251 xmlXIncludeCtxtPtr ctxt;
1252};
1253
Owen Taylor3473f882001-02-23 17:55:21 +00001254/**
Daniel Veillard4287c572003-02-04 22:48:53 +00001255 * xmlXIncludeMergeOneEntity:
1256 * @ent: the entity
1257 * @doc: the including doc
1258 * @nr: the entity name
1259 *
1260 * Inplements the merge of one entity
1261 */
1262static void
Daniel Veillardf4b4f982003-02-13 11:02:08 +00001263xmlXIncludeMergeEntity(xmlEntityPtr ent, xmlXIncludeMergeDataPtr data,
Daniel Veillard4287c572003-02-04 22:48:53 +00001264 xmlChar *name ATTRIBUTE_UNUSED) {
Daniel Veillardf4b4f982003-02-13 11:02:08 +00001265 xmlEntityPtr ret, prev;
1266 xmlDocPtr doc;
1267 xmlXIncludeCtxtPtr ctxt;
Daniel Veillard4287c572003-02-04 22:48:53 +00001268
Daniel Veillardf4b4f982003-02-13 11:02:08 +00001269 if ((ent == NULL) || (data == NULL))
Daniel Veillard4287c572003-02-04 22:48:53 +00001270 return;
Daniel Veillardf4b4f982003-02-13 11:02:08 +00001271 ctxt = data->ctxt;
1272 doc = data->doc;
1273 if ((ctxt == NULL) || (doc == NULL))
1274 return;
1275 switch (ent->etype) {
1276 case XML_INTERNAL_PARAMETER_ENTITY:
1277 case XML_EXTERNAL_PARAMETER_ENTITY:
1278 case XML_INTERNAL_PREDEFINED_ENTITY:
1279 return;
1280 case XML_INTERNAL_GENERAL_ENTITY:
1281 case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
1282 case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
1283 break;
1284 }
Daniel Veillard4287c572003-02-04 22:48:53 +00001285 ret = xmlAddDocEntity(doc, ent->name, ent->etype, ent->ExternalID,
1286 ent->SystemID, ent->content);
1287 if (ret != NULL) {
1288 if (ent->URI != NULL)
1289 ret->URI = xmlStrdup(ent->URI);
Daniel Veillardf4b4f982003-02-13 11:02:08 +00001290 } else {
1291 prev = xmlGetDocEntity(doc, ent->name);
1292 if (prev != NULL) {
1293 if (ent->etype != prev->etype)
1294 goto error;
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001295
Daniel Veillardf4b4f982003-02-13 11:02:08 +00001296 if ((ent->SystemID != NULL) && (prev->SystemID != NULL)) {
1297 if (!xmlStrEqual(ent->SystemID, prev->SystemID))
1298 goto error;
Daniel Veillardb6c7f412003-03-29 16:41:55 +00001299 } else if ((ent->ExternalID != NULL) &&
1300 (prev->ExternalID != NULL)) {
Daniel Veillardf4b4f982003-02-13 11:02:08 +00001301 if (!xmlStrEqual(ent->ExternalID, prev->ExternalID))
1302 goto error;
Daniel Veillard2406abd2003-02-24 18:16:47 +00001303 } else if ((ent->content != NULL) && (prev->content != NULL)) {
1304 if (!xmlStrEqual(ent->content, prev->content))
1305 goto error;
Daniel Veillardf4b4f982003-02-13 11:02:08 +00001306 } else {
1307 goto error;
1308 }
1309
1310 }
Daniel Veillard4287c572003-02-04 22:48:53 +00001311 }
Daniel Veillardf4b4f982003-02-13 11:02:08 +00001312 return;
1313error:
Daniel Veillarda507fbf2003-03-31 16:09:37 +00001314 switch (ent->etype) {
1315 case XML_INTERNAL_PARAMETER_ENTITY:
1316 case XML_EXTERNAL_PARAMETER_ENTITY:
1317 case XML_INTERNAL_PREDEFINED_ENTITY:
1318 case XML_INTERNAL_GENERAL_ENTITY:
1319 case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
1320 return;
1321 case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
1322 break;
1323 }
Daniel Veillardcd6ff282003-10-08 22:38:13 +00001324 xmlXIncludeErr(ctxt, (xmlNodePtr) ent, XML_XINCLUDE_ENTITY_DEF_MISMATCH,
1325 "mismatch in redefinition of entity %s\n",
1326 ent->name);
Daniel Veillard4287c572003-02-04 22:48:53 +00001327}
1328
1329/**
1330 * xmlXIncludeMergeEntities:
1331 * @ctxt: an XInclude context
1332 * @doc: the including doc
1333 * @from: the included doc
1334 *
1335 * Inplements the entity merge
1336 *
1337 * Returns 0 if merge succeeded, -1 if some processing failed
1338 */
1339static int
1340xmlXIncludeMergeEntities(xmlXIncludeCtxtPtr ctxt, xmlDocPtr doc,
1341 xmlDocPtr from) {
1342 xmlNodePtr cur;
1343 xmlDtdPtr target, source;
1344
1345 if (ctxt == NULL)
1346 return(-1);
1347
1348 if ((from == NULL) || (from->intSubset == NULL))
1349 return(0);
1350
1351 target = doc->intSubset;
1352 if (target == NULL) {
1353 cur = xmlDocGetRootElement(doc);
1354 if (cur == NULL)
1355 return(-1);
1356 target = xmlCreateIntSubset(doc, cur->name, NULL, NULL);
1357 if (target == NULL)
1358 return(-1);
1359 }
1360
1361 source = from->intSubset;
1362 if ((source != NULL) && (source->entities != NULL)) {
Daniel Veillardf4b4f982003-02-13 11:02:08 +00001363 xmlXIncludeMergeData data;
1364
1365 data.ctxt = ctxt;
1366 data.doc = doc;
1367
Daniel Veillard4287c572003-02-04 22:48:53 +00001368 xmlHashScan((xmlHashTablePtr) source->entities,
Daniel Veillardf4b4f982003-02-13 11:02:08 +00001369 (xmlHashScanner) xmlXIncludeMergeEntity, &data);
Daniel Veillard4287c572003-02-04 22:48:53 +00001370 }
1371 source = from->extSubset;
1372 if ((source != NULL) && (source->entities != NULL)) {
Daniel Veillardf4b4f982003-02-13 11:02:08 +00001373 xmlXIncludeMergeData data;
1374
1375 data.ctxt = ctxt;
1376 data.doc = doc;
1377
Daniel Veillard4287c572003-02-04 22:48:53 +00001378 /*
1379 * don't duplicate existing stuff when external subsets are the same
1380 */
1381 if ((!xmlStrEqual(target->ExternalID, source->ExternalID)) &&
1382 (!xmlStrEqual(target->SystemID, source->SystemID))) {
1383 xmlHashScan((xmlHashTablePtr) source->entities,
Daniel Veillardf4b4f982003-02-13 11:02:08 +00001384 (xmlHashScanner) xmlXIncludeMergeEntity, &data);
Daniel Veillard4287c572003-02-04 22:48:53 +00001385 }
1386 }
1387 return(0);
1388}
1389
1390/**
Owen Taylor3473f882001-02-23 17:55:21 +00001391 * xmlXIncludeLoadDoc:
1392 * @ctxt: the XInclude context
1393 * @url: the associated URL
1394 * @nr: the xinclude node number
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001395 *
Owen Taylor3473f882001-02-23 17:55:21 +00001396 * Load the document, and store the result in the XInclude context
Daniel Veillarde3b7d9a2002-08-14 14:11:30 +00001397 *
1398 * Returns 0 in case of success, -1 in case of failure
Owen Taylor3473f882001-02-23 17:55:21 +00001399 */
Daniel Veillarde3b7d9a2002-08-14 14:11:30 +00001400static int
Owen Taylor3473f882001-02-23 17:55:21 +00001401xmlXIncludeLoadDoc(xmlXIncludeCtxtPtr ctxt, const xmlChar *url, int nr) {
1402 xmlDocPtr doc;
1403 xmlURIPtr uri;
1404 xmlChar *URL;
1405 xmlChar *fragment = NULL;
Daniel Veillardbbc72c32002-09-05 10:52:10 +00001406 int i = 0;
William M. Brack4d59e222004-03-08 14:42:31 +00001407#ifdef LIBXML_XPTR_ENABLED
1408 int saveFlags;
1409#endif
Daniel Veillardbbc72c32002-09-05 10:52:10 +00001410
1411#ifdef DEBUG_XINCLUDE
1412 xmlGenericError(xmlGenericErrorContext, "Loading doc %s:%d\n", url, nr);
1413#endif
Owen Taylor3473f882001-02-23 17:55:21 +00001414 /*
1415 * Check the URL and remove any fragment identifier
1416 */
1417 uri = xmlParseURI((const char *)url);
1418 if (uri == NULL) {
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001419 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
Daniel Veillardcd6ff282003-10-08 22:38:13 +00001420 XML_XINCLUDE_HREF_URI,
1421 "invalid value URI %s\n", url);
Daniel Veillarde3b7d9a2002-08-14 14:11:30 +00001422 return(-1);
Owen Taylor3473f882001-02-23 17:55:21 +00001423 }
1424 if (uri->fragment != NULL) {
1425 fragment = (xmlChar *) uri->fragment;
1426 uri->fragment = NULL;
1427 }
Daniel Veillardb98d0822003-12-24 11:06:25 +00001428 if ((ctxt->incTab != NULL) && (ctxt->incTab[nr] != NULL) &&
1429 (ctxt->incTab[nr]->fragment != NULL)) {
1430 if (fragment != NULL) xmlFree(fragment);
1431 fragment = xmlStrdup(ctxt->incTab[nr]->fragment);
1432 }
Owen Taylor3473f882001-02-23 17:55:21 +00001433 URL = xmlSaveUri(uri);
1434 xmlFreeURI(uri);
1435 if (URL == NULL) {
Daniel Veillard11ce4002006-03-10 00:36:23 +00001436 if (ctxt->incTab != NULL)
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001437 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
Daniel Veillard11ce4002006-03-10 00:36:23 +00001438 XML_XINCLUDE_HREF_URI,
1439 "invalid value URI %s\n", url);
1440 else
1441 xmlXIncludeErr(ctxt, NULL,
1442 XML_XINCLUDE_HREF_URI,
1443 "invalid value URI %s\n", url);
Owen Taylor3473f882001-02-23 17:55:21 +00001444 if (fragment != NULL)
1445 xmlFree(fragment);
Daniel Veillarde3b7d9a2002-08-14 14:11:30 +00001446 return(-1);
Owen Taylor3473f882001-02-23 17:55:21 +00001447 }
1448
1449 /*
1450 * Handling of references to the local document are done
1451 * directly through ctxt->doc.
1452 */
Daniel Veillardf4b4f982003-02-13 11:02:08 +00001453 if ((URL[0] == 0) || (URL[0] == '#') ||
1454 ((ctxt->doc != NULL) && (xmlStrEqual(URL, ctxt->doc->URL)))) {
Owen Taylor3473f882001-02-23 17:55:21 +00001455 doc = NULL;
1456 goto loaded;
1457 }
1458
1459 /*
1460 * Prevent reloading twice the document.
1461 */
Daniel Veillardbbc72c32002-09-05 10:52:10 +00001462 for (i = 0; i < ctxt->incNr; i++) {
1463 if ((xmlStrEqual(URL, ctxt->incTab[i]->URI)) &&
1464 (ctxt->incTab[i]->doc != NULL)) {
1465 doc = ctxt->incTab[i]->doc;
1466#ifdef DEBUG_XINCLUDE
1467 printf("Already loaded %s\n", URL);
1468#endif
Owen Taylor3473f882001-02-23 17:55:21 +00001469 goto loaded;
1470 }
1471 }
Daniel Veillardbbc72c32002-09-05 10:52:10 +00001472
Owen Taylor3473f882001-02-23 17:55:21 +00001473 /*
1474 * Load it.
1475 */
Daniel Veillardbbc72c32002-09-05 10:52:10 +00001476#ifdef DEBUG_XINCLUDE
1477 printf("loading %s\n", URL);
1478#endif
William M. Brack4d59e222004-03-08 14:42:31 +00001479#ifdef LIBXML_XPTR_ENABLED
1480 /*
1481 * If this is an XPointer evaluation, we want to assure that
1482 * all entities have been resolved prior to processing the
1483 * referenced document
1484 */
1485 saveFlags = ctxt->parseFlags;
1486 if (fragment != NULL) { /* if this is an XPointer eval */
1487 ctxt->parseFlags |= XML_PARSE_NOENT;
1488 }
1489#endif
1490
Daniel Veillard98485322003-08-14 15:44:40 +00001491 doc = xmlXIncludeParseFile(ctxt, (const char *)URL);
William M. Brack4d59e222004-03-08 14:42:31 +00001492#ifdef LIBXML_XPTR_ENABLED
1493 ctxt->parseFlags = saveFlags;
1494#endif
Owen Taylor3473f882001-02-23 17:55:21 +00001495 if (doc == NULL) {
Owen Taylor3473f882001-02-23 17:55:21 +00001496 xmlFree(URL);
1497 if (fragment != NULL)
1498 xmlFree(fragment);
Daniel Veillarde3b7d9a2002-08-14 14:11:30 +00001499 return(-1);
Owen Taylor3473f882001-02-23 17:55:21 +00001500 }
Daniel Veillardbbc72c32002-09-05 10:52:10 +00001501 ctxt->incTab[nr]->doc = doc;
William M. Brackb85c9202004-07-26 00:20:13 +00001502 /*
1503 * It's possible that the requested URL has been mapped to a
1504 * completely different location (e.g. through a catalog entry).
1505 * To check for this, we compare the URL with that of the doc
1506 * and change it if they disagree (bug 146988).
1507 */
1508 if (!xmlStrEqual(URL, doc->URL)) {
1509 xmlFree(URL);
1510 URL = xmlStrdup(doc->URL);
1511 }
Daniel Veillard98485322003-08-14 15:44:40 +00001512 for (i = nr + 1; i < ctxt->incNr; i++) {
1513 if (xmlStrEqual(URL, ctxt->incTab[i]->URI)) {
1514 ctxt->incTab[nr]->count++;
1515#ifdef DEBUG_XINCLUDE
1516 printf("Increasing %s count since reused\n", URL);
1517#endif
1518 break;
1519 }
1520 }
Daniel Veillardbbc72c32002-09-05 10:52:10 +00001521
1522 /*
Daniel Veillard4287c572003-02-04 22:48:53 +00001523 * Make sure we have all entities fixed up
Daniel Veillardbbc72c32002-09-05 10:52:10 +00001524 */
Daniel Veillard4287c572003-02-04 22:48:53 +00001525 xmlXIncludeMergeEntities(ctxt, ctxt->doc, doc);
Daniel Veillardbbc72c32002-09-05 10:52:10 +00001526
1527 /*
1528 * We don't need the DTD anymore, free up space
1529 if (doc->intSubset != NULL) {
1530 xmlUnlinkNode((xmlNodePtr) doc->intSubset);
1531 xmlFreeNode((xmlNodePtr) doc->intSubset);
1532 doc->intSubset = NULL;
1533 }
1534 if (doc->extSubset != NULL) {
1535 xmlUnlinkNode((xmlNodePtr) doc->extSubset);
1536 xmlFreeNode((xmlNodePtr) doc->extSubset);
1537 doc->extSubset = NULL;
1538 }
1539 */
1540 xmlXIncludeRecurseDoc(ctxt, doc, URL);
Owen Taylor3473f882001-02-23 17:55:21 +00001541
1542loaded:
1543 if (fragment == NULL) {
1544 /*
1545 * Add the top children list as the replacement copy.
Owen Taylor3473f882001-02-23 17:55:21 +00001546 */
1547 if (doc == NULL)
Daniel Veillard4497e692001-06-09 14:19:02 +00001548 {
1549 /* Hopefully a DTD declaration won't be copied from
1550 * the same document */
Daniel Veillardbbc72c32002-09-05 10:52:10 +00001551 ctxt->incTab[nr]->inc = xmlCopyNodeList(ctxt->doc->children);
Daniel Veillard4497e692001-06-09 14:19:02 +00001552 } else {
Daniel Veillardbbc72c32002-09-05 10:52:10 +00001553 ctxt->incTab[nr]->inc = xmlXIncludeCopyNodeList(ctxt, ctxt->doc,
Daniel Veillardc5f05ad2002-02-10 11:57:22 +00001554 doc, doc->children);
Daniel Veillard4497e692001-06-09 14:19:02 +00001555 }
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001556 }
Daniel Veillard10acc2f2003-09-01 20:59:40 +00001557#ifdef LIBXML_XPTR_ENABLED
1558 else {
Owen Taylor3473f882001-02-23 17:55:21 +00001559 /*
1560 * Computes the XPointer expression and make a copy used
1561 * as the replacement copy.
1562 */
1563 xmlXPathObjectPtr xptr;
1564 xmlXPathContextPtr xptrctxt;
Daniel Veillard39196eb2001-06-19 18:09:42 +00001565 xmlNodeSetPtr set;
Owen Taylor3473f882001-02-23 17:55:21 +00001566
1567 if (doc == NULL) {
Daniel Veillardbbc72c32002-09-05 10:52:10 +00001568 xptrctxt = xmlXPtrNewContext(ctxt->doc, ctxt->incTab[nr]->ref,
1569 NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00001570 } else {
1571 xptrctxt = xmlXPtrNewContext(doc, NULL, NULL);
1572 }
1573 if (xptrctxt == NULL) {
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001574 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
Daniel Veillardcd6ff282003-10-08 22:38:13 +00001575 XML_XINCLUDE_XPTR_FAILED,
Daniel Veillarda152c4d2003-11-19 16:24:26 +00001576 "could not create XPointer context\n", NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00001577 xmlFree(URL);
1578 xmlFree(fragment);
Daniel Veillarde3b7d9a2002-08-14 14:11:30 +00001579 return(-1);
Owen Taylor3473f882001-02-23 17:55:21 +00001580 }
1581 xptr = xmlXPtrEval(fragment, xptrctxt);
1582 if (xptr == NULL) {
Daniel Veillardcd6ff282003-10-08 22:38:13 +00001583 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1584 XML_XINCLUDE_XPTR_FAILED,
1585 "XPointer evaluation failed: #%s\n",
1586 fragment);
Owen Taylor3473f882001-02-23 17:55:21 +00001587 xmlXPathFreeContext(xptrctxt);
1588 xmlFree(URL);
1589 xmlFree(fragment);
Daniel Veillarde3b7d9a2002-08-14 14:11:30 +00001590 return(-1);
Owen Taylor3473f882001-02-23 17:55:21 +00001591 }
Daniel Veillard39196eb2001-06-19 18:09:42 +00001592 switch (xptr->type) {
1593 case XPATH_UNDEFINED:
1594 case XPATH_BOOLEAN:
1595 case XPATH_NUMBER:
1596 case XPATH_STRING:
1597 case XPATH_POINT:
1598 case XPATH_USERS:
1599 case XPATH_XSLT_TREE:
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001600 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
Daniel Veillardcd6ff282003-10-08 22:38:13 +00001601 XML_XINCLUDE_XPTR_RESULT,
1602 "XPointer is not a range: #%s\n",
1603 fragment);
Daniel Veillard39196eb2001-06-19 18:09:42 +00001604 xmlXPathFreeContext(xptrctxt);
1605 xmlFree(URL);
1606 xmlFree(fragment);
Daniel Veillarde3b7d9a2002-08-14 14:11:30 +00001607 return(-1);
Daniel Veillard39196eb2001-06-19 18:09:42 +00001608 case XPATH_NODESET:
Daniel Veillard798ae542003-11-03 17:13:52 +00001609 if ((xptr->nodesetval == NULL) ||
1610 (xptr->nodesetval->nodeNr <= 0)) {
1611 xmlXPathFreeContext(xptrctxt);
1612 xmlFree(URL);
1613 xmlFree(fragment);
1614 return(-1);
1615 }
William M. Brackabf598b2004-06-08 02:01:28 +00001616
Daniel Veillard39196eb2001-06-19 18:09:42 +00001617 case XPATH_RANGE:
1618 case XPATH_LOCATIONSET:
1619 break;
1620 }
1621 set = xptr->nodesetval;
1622 if (set != NULL) {
1623 for (i = 0;i < set->nodeNr;i++) {
1624 if (set->nodeTab[i] == NULL)
1625 continue;
1626 switch (set->nodeTab[i]->type) {
William M. Brackb0a94e82007-07-18 18:04:55 +00001627 case XML_ELEMENT_NODE:
Daniel Veillard39196eb2001-06-19 18:09:42 +00001628 case XML_TEXT_NODE:
1629 case XML_CDATA_SECTION_NODE:
Daniel Veillard39196eb2001-06-19 18:09:42 +00001630 case XML_ENTITY_REF_NODE:
1631 case XML_ENTITY_NODE:
1632 case XML_PI_NODE:
1633 case XML_COMMENT_NODE:
1634 case XML_DOCUMENT_NODE:
1635 case XML_HTML_DOCUMENT_NODE:
1636#ifdef LIBXML_DOCB_ENABLED
1637 case XML_DOCB_DOCUMENT_NODE:
1638#endif
1639 continue;
William M. Brackabf598b2004-06-08 02:01:28 +00001640
Daniel Veillard39196eb2001-06-19 18:09:42 +00001641 case XML_ATTRIBUTE_NODE:
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001642 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
Daniel Veillardcd6ff282003-10-08 22:38:13 +00001643 XML_XINCLUDE_XPTR_RESULT,
1644 "XPointer selects an attribute: #%s\n",
1645 fragment);
Daniel Veillard39196eb2001-06-19 18:09:42 +00001646 set->nodeTab[i] = NULL;
1647 continue;
1648 case XML_NAMESPACE_DECL:
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001649 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
Daniel Veillardcd6ff282003-10-08 22:38:13 +00001650 XML_XINCLUDE_XPTR_RESULT,
1651 "XPointer selects a namespace: #%s\n",
1652 fragment);
Daniel Veillard39196eb2001-06-19 18:09:42 +00001653 set->nodeTab[i] = NULL;
1654 continue;
1655 case XML_DOCUMENT_TYPE_NODE:
1656 case XML_DOCUMENT_FRAG_NODE:
1657 case XML_NOTATION_NODE:
1658 case XML_DTD_NODE:
1659 case XML_ELEMENT_DECL:
1660 case XML_ATTRIBUTE_DECL:
1661 case XML_ENTITY_DECL:
1662 case XML_XINCLUDE_START:
1663 case XML_XINCLUDE_END:
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001664 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
Daniel Veillardcd6ff282003-10-08 22:38:13 +00001665 XML_XINCLUDE_XPTR_RESULT,
1666 "XPointer selects unexpected nodes: #%s\n",
1667 fragment);
Daniel Veillard39196eb2001-06-19 18:09:42 +00001668 set->nodeTab[i] = NULL;
1669 set->nodeTab[i] = NULL;
1670 continue; /* for */
1671 }
1672 }
1673 }
Daniel Veillardf4b4f982003-02-13 11:02:08 +00001674 if (doc == NULL) {
1675 ctxt->incTab[nr]->xptr = xptr;
1676 ctxt->incTab[nr]->inc = NULL;
1677 } else {
1678 ctxt->incTab[nr]->inc =
1679 xmlXIncludeCopyXPointer(ctxt, ctxt->doc, doc, xptr);
1680 xmlXPathFreeObject(xptr);
1681 }
Owen Taylor3473f882001-02-23 17:55:21 +00001682 xmlXPathFreeContext(xptrctxt);
1683 xmlFree(fragment);
1684 }
Daniel Veillard10acc2f2003-09-01 20:59:40 +00001685#endif
Daniel Veillardc4bad4a2002-08-14 14:45:25 +00001686
1687 /*
1688 * Do the xml:base fixup if needed
1689 */
Alexey Neyman0b865372013-05-06 10:20:18 +08001690 if ((doc != NULL) && (URL != NULL) &&
Daniel Veillard54bd29b2008-08-26 07:26:55 +00001691 (!(ctxt->parseFlags & XML_PARSE_NOBASEFIX)) &&
1692 (!(doc->parseFlags & XML_PARSE_NOBASEFIX))) {
Daniel Veillardc4bad4a2002-08-14 14:45:25 +00001693 xmlNodePtr node;
William M. Brack0b13a092005-06-01 03:37:59 +00001694 xmlChar *base;
William M. Brackabf598b2004-06-08 02:01:28 +00001695 xmlChar *curBase;
Daniel Veillardc4bad4a2002-08-14 14:45:25 +00001696
William M. Brackf7789b12004-06-07 08:57:27 +00001697 /*
William M. Brack0b13a092005-06-01 03:37:59 +00001698 * The base is only adjusted if "necessary", i.e. if the xinclude node
1699 * has a base specified, or the URL is relative
William M. Brackf7789b12004-06-07 08:57:27 +00001700 */
William M. Brack0b13a092005-06-01 03:37:59 +00001701 base = xmlGetNsProp(ctxt->incTab[nr]->ref, BAD_CAST "base",
1702 XML_XML_NAMESPACE);
1703 if (base == NULL) {
1704 /*
1705 * No xml:base on the xinclude node, so we check whether the
1706 * URI base is different than (relative to) the context base
1707 */
1708 curBase = xmlBuildRelativeURI(URL, ctxt->base);
1709 if (curBase == NULL) { /* Error return */
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001710 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
William M. Brackf7789b12004-06-07 08:57:27 +00001711 XML_XINCLUDE_HREF_URI,
1712 "trying to build relative URI from %s\n", URL);
William M. Brack0b13a092005-06-01 03:37:59 +00001713 } else {
1714 /* If the URI doesn't contain a slash, it's not relative */
1715 if (!xmlStrchr(curBase, (xmlChar) '/'))
1716 xmlFree(curBase);
1717 else
1718 base = curBase;
William M. Brackf7789b12004-06-07 08:57:27 +00001719 }
William M. Brack0b13a092005-06-01 03:37:59 +00001720 }
1721 if (base != NULL) { /* Adjustment may be needed */
1722 node = ctxt->incTab[nr]->inc;
1723 while (node != NULL) {
1724 /* Only work on element nodes */
1725 if (node->type == XML_ELEMENT_NODE) {
1726 curBase = xmlNodeGetBase(node->doc, node);
1727 /* If no current base, set it */
1728 if (curBase == NULL) {
1729 xmlNodeSetBase(node, base);
1730 } else {
1731 /*
1732 * If the current base is the same as the
1733 * URL of the document, then reset it to be
1734 * the specified xml:base or the relative URI
1735 */
1736 if (xmlStrEqual(curBase, node->doc->URL)) {
1737 xmlNodeSetBase(node, base);
1738 } else {
1739 /*
1740 * If the element already has an xml:base
1741 * set, then relativise it if necessary
1742 */
1743 xmlChar *xmlBase;
1744 xmlBase = xmlGetNsProp(node,
1745 BAD_CAST "base",
1746 XML_XML_NAMESPACE);
1747 if (xmlBase != NULL) {
1748 xmlChar *relBase;
1749 relBase = xmlBuildURI(xmlBase, base);
1750 if (relBase == NULL) { /* error */
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001751 xmlXIncludeErr(ctxt,
William M. Brack0b13a092005-06-01 03:37:59 +00001752 ctxt->incTab[nr]->ref,
1753 XML_XINCLUDE_HREF_URI,
1754 "trying to rebuild base from %s\n",
1755 xmlBase);
1756 } else {
1757 xmlNodeSetBase(node, relBase);
1758 xmlFree(relBase);
1759 }
1760 xmlFree(xmlBase);
1761 }
1762 }
1763 xmlFree(curBase);
1764 }
1765 }
1766 node = node->next;
1767 }
1768 xmlFree(base);
Daniel Veillardc4bad4a2002-08-14 14:45:25 +00001769 }
1770 }
Daniel Veillardbbc72c32002-09-05 10:52:10 +00001771 if ((nr < ctxt->incNr) && (ctxt->incTab[nr]->doc != NULL) &&
1772 (ctxt->incTab[nr]->count <= 1)) {
1773#ifdef DEBUG_XINCLUDE
1774 printf("freeing %s\n", ctxt->incTab[nr]->doc->URL);
1775#endif
1776 xmlFreeDoc(ctxt->incTab[nr]->doc);
1777 ctxt->incTab[nr]->doc = NULL;
1778 }
Owen Taylor3473f882001-02-23 17:55:21 +00001779 xmlFree(URL);
Daniel Veillarde3b7d9a2002-08-14 14:11:30 +00001780 return(0);
Owen Taylor3473f882001-02-23 17:55:21 +00001781}
1782
1783/**
1784 * xmlXIncludeLoadTxt:
1785 * @ctxt: the XInclude context
1786 * @url: the associated URL
1787 * @nr: the xinclude node number
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001788 *
Owen Taylor3473f882001-02-23 17:55:21 +00001789 * Load the content, and store the result in the XInclude context
Daniel Veillarde3b7d9a2002-08-14 14:11:30 +00001790 *
1791 * Returns 0 in case of success, -1 in case of failure
Owen Taylor3473f882001-02-23 17:55:21 +00001792 */
Daniel Veillarde3b7d9a2002-08-14 14:11:30 +00001793static int
Owen Taylor3473f882001-02-23 17:55:21 +00001794xmlXIncludeLoadTxt(xmlXIncludeCtxtPtr ctxt, const xmlChar *url, int nr) {
1795 xmlParserInputBufferPtr buf;
1796 xmlNodePtr node;
1797 xmlURIPtr uri;
1798 xmlChar *URL;
1799 int i;
Daniel Veillardd076a202002-11-20 13:28:31 +00001800 xmlChar *encoding = NULL;
William M. Brack78637da2003-07-31 14:47:38 +00001801 xmlCharEncoding enc = (xmlCharEncoding) 0;
Shaun McCance4cf73252012-05-10 20:59:33 +08001802 xmlParserCtxtPtr pctxt;
1803 xmlParserInputPtr inputStream;
Vitaly Ostanindce1c8b2012-08-17 20:42:52 +08001804 int xinclude_multibyte_fallback_used = 0;
Daniel Veillardd076a202002-11-20 13:28:31 +00001805
Owen Taylor3473f882001-02-23 17:55:21 +00001806 /*
1807 * Check the URL and remove any fragment identifier
1808 */
1809 uri = xmlParseURI((const char *)url);
1810 if (uri == NULL) {
Daniel Veillardcd6ff282003-10-08 22:38:13 +00001811 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, XML_XINCLUDE_HREF_URI,
1812 "invalid value URI %s\n", url);
Daniel Veillarde3b7d9a2002-08-14 14:11:30 +00001813 return(-1);
Owen Taylor3473f882001-02-23 17:55:21 +00001814 }
1815 if (uri->fragment != NULL) {
Daniel Veillardcd6ff282003-10-08 22:38:13 +00001816 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, XML_XINCLUDE_TEXT_FRAGMENT,
1817 "fragment identifier forbidden for text: %s\n",
1818 (const xmlChar *) uri->fragment);
Owen Taylor3473f882001-02-23 17:55:21 +00001819 xmlFreeURI(uri);
Daniel Veillarde3b7d9a2002-08-14 14:11:30 +00001820 return(-1);
Owen Taylor3473f882001-02-23 17:55:21 +00001821 }
1822 URL = xmlSaveUri(uri);
1823 xmlFreeURI(uri);
1824 if (URL == NULL) {
Daniel Veillardcd6ff282003-10-08 22:38:13 +00001825 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, XML_XINCLUDE_HREF_URI,
1826 "invalid value URI %s\n", url);
Daniel Veillarde3b7d9a2002-08-14 14:11:30 +00001827 return(-1);
Owen Taylor3473f882001-02-23 17:55:21 +00001828 }
1829
1830 /*
1831 * Handling of references to the local document are done
1832 * directly through ctxt->doc.
1833 */
1834 if (URL[0] == 0) {
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001835 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
Daniel Veillardcd6ff282003-10-08 22:38:13 +00001836 XML_XINCLUDE_TEXT_DOCUMENT,
1837 "text serialization of document not available\n", NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00001838 xmlFree(URL);
Daniel Veillarde3b7d9a2002-08-14 14:11:30 +00001839 return(-1);
Owen Taylor3473f882001-02-23 17:55:21 +00001840 }
1841
1842 /*
1843 * Prevent reloading twice the document.
1844 */
1845 for (i = 0; i < ctxt->txtNr; i++) {
1846 if (xmlStrEqual(URL, ctxt->txturlTab[i])) {
1847 node = xmlCopyNode(ctxt->txtTab[i], 1);
1848 goto loaded;
1849 }
1850 }
1851 /*
Daniel Veillardd076a202002-11-20 13:28:31 +00001852 * Try to get the encoding if available
Owen Taylor3473f882001-02-23 17:55:21 +00001853 */
Daniel Veillardd076a202002-11-20 13:28:31 +00001854 if ((ctxt->incTab[nr] != NULL) && (ctxt->incTab[nr]->ref != NULL)) {
1855 encoding = xmlGetProp(ctxt->incTab[nr]->ref, XINCLUDE_PARSE_ENCODING);
1856 }
1857 if (encoding != NULL) {
1858 /*
1859 * TODO: we should not have to remap to the xmlCharEncoding
1860 * predefined set, a better interface than
1861 * xmlParserInputBufferCreateFilename should allow any
1862 * encoding supported by iconv
1863 */
1864 enc = xmlParseCharEncoding((const char *) encoding);
1865 if (enc == XML_CHAR_ENCODING_ERROR) {
Daniel Veillardcd6ff282003-10-08 22:38:13 +00001866 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1867 XML_XINCLUDE_UNKNOWN_ENCODING,
1868 "encoding %s not supported\n", encoding);
Daniel Veillardd076a202002-11-20 13:28:31 +00001869 xmlFree(encoding);
1870 xmlFree(URL);
1871 return(-1);
1872 }
1873 xmlFree(encoding);
1874 }
1875
1876 /*
1877 * Load it.
1878 */
Shaun McCance4cf73252012-05-10 20:59:33 +08001879 pctxt = xmlNewParserCtxt();
1880 inputStream = xmlLoadExternalEntity((const char*)URL, NULL, pctxt);
1881 if(inputStream == NULL) {
1882 xmlFreeParserCtxt(pctxt);
Owen Taylor3473f882001-02-23 17:55:21 +00001883 xmlFree(URL);
Daniel Veillarde3b7d9a2002-08-14 14:11:30 +00001884 return(-1);
Owen Taylor3473f882001-02-23 17:55:21 +00001885 }
Shaun McCance4cf73252012-05-10 20:59:33 +08001886 buf = inputStream->buf;
1887 if (buf == NULL) {
1888 xmlFreeInputStream (inputStream);
1889 xmlFreeParserCtxt(pctxt);
1890 xmlFree(URL);
1891 return(-1);
1892 }
1893 if (buf->encoder)
1894 xmlCharEncCloseFunc(buf->encoder);
1895 buf->encoder = xmlGetCharEncodingHandler(enc);
Owen Taylor3473f882001-02-23 17:55:21 +00001896 node = xmlNewText(NULL);
1897
1898 /*
1899 * Scan all chars from the resource and add the to the node
1900 */
Vitaly Ostanindce1c8b2012-08-17 20:42:52 +08001901xinclude_multibyte_fallback:
Owen Taylor3473f882001-02-23 17:55:21 +00001902 while (xmlParserInputBufferRead(buf, 128) > 0) {
1903 int len;
1904 const xmlChar *content;
1905
Daniel Veillard345ee8b2012-07-16 14:40:37 +08001906 content = xmlBufContent(buf->buffer);
1907 len = xmlBufLength(buf->buffer);
Daniel Veillardd076a202002-11-20 13:28:31 +00001908 for (i = 0;i < len;) {
1909 int cur;
1910 int l;
1911
1912 cur = xmlStringCurrentChar(NULL, &content[i], &l);
1913 if (!IS_CHAR(cur)) {
Vitaly Ostanindce1c8b2012-08-17 20:42:52 +08001914 /* Handle splitted multibyte char at buffer boundary */
1915 if (((len - i) < 4) && (!xinclude_multibyte_fallback_used)) {
1916 xinclude_multibyte_fallback_used = 1;
1917 xmlBufShrink(buf->buffer, i);
1918 goto xinclude_multibyte_fallback;
1919 } else {
1920 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
1921 XML_XINCLUDE_INVALID_CHAR,
1922 "%s contains invalid char\n", URL);
1923 xmlFreeParserInputBuffer(buf);
1924 xmlFree(URL);
1925 return(-1);
1926 }
Owen Taylor3473f882001-02-23 17:55:21 +00001927 } else {
Vitaly Ostanindce1c8b2012-08-17 20:42:52 +08001928 xinclude_multibyte_fallback_used = 0;
Daniel Veillardd076a202002-11-20 13:28:31 +00001929 xmlNodeAddContentLen(node, &content[i], l);
Owen Taylor3473f882001-02-23 17:55:21 +00001930 }
Daniel Veillardd076a202002-11-20 13:28:31 +00001931 i += l;
Owen Taylor3473f882001-02-23 17:55:21 +00001932 }
Daniel Veillard345ee8b2012-07-16 14:40:37 +08001933 xmlBufShrink(buf->buffer, len);
Owen Taylor3473f882001-02-23 17:55:21 +00001934 }
Shaun McCance4cf73252012-05-10 20:59:33 +08001935 xmlFreeParserCtxt(pctxt);
Owen Taylor3473f882001-02-23 17:55:21 +00001936 xmlXIncludeAddTxt(ctxt, node, URL);
Shaun McCance4cf73252012-05-10 20:59:33 +08001937 xmlFreeInputStream(inputStream);
Owen Taylor3473f882001-02-23 17:55:21 +00001938
1939loaded:
1940 /*
1941 * Add the element as the replacement copy.
1942 */
Daniel Veillardbbc72c32002-09-05 10:52:10 +00001943 ctxt->incTab[nr]->inc = node;
Owen Taylor3473f882001-02-23 17:55:21 +00001944 xmlFree(URL);
Daniel Veillarde3b7d9a2002-08-14 14:11:30 +00001945 return(0);
1946}
1947
1948/**
1949 * xmlXIncludeLoadFallback:
1950 * @ctxt: the XInclude context
1951 * @fallback: the fallback node
1952 * @nr: the xinclude node number
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001953 *
Daniel Veillardbbc72c32002-09-05 10:52:10 +00001954 * Load the content of the fallback node, and store the result
Daniel Veillarde3b7d9a2002-08-14 14:11:30 +00001955 * in the XInclude context
1956 *
1957 * Returns 0 in case of success, -1 in case of failure
1958 */
1959static int
1960xmlXIncludeLoadFallback(xmlXIncludeCtxtPtr ctxt, xmlNodePtr fallback, int nr) {
William M. Brackaae10522004-01-02 14:59:41 +00001961 xmlXIncludeCtxtPtr newctxt;
1962 int ret = 0;
Daniel Veillard3e62adb2012-08-09 14:24:02 +08001963
1964 if ((fallback == NULL) || (fallback->type == XML_NAMESPACE_DECL) ||
1965 (ctxt == NULL))
Daniel Veillarde3b7d9a2002-08-14 14:11:30 +00001966 return(-1);
William M. Brackef245fd2004-02-06 09:33:59 +00001967 if (fallback->children != NULL) {
1968 /*
1969 * It's possible that the fallback also has 'includes'
1970 * (Bug 129969), so we re-process the fallback just in case
1971 */
1972 newctxt = xmlXIncludeNewContext(ctxt->doc);
1973 if (newctxt == NULL)
1974 return (-1);
Daniel Veillarda6585822006-12-04 09:21:28 +00001975 newctxt->_private = ctxt->_private;
Daniel Veillardce244ad2004-11-05 10:03:46 +00001976 newctxt->base = xmlStrdup(ctxt->base); /* Inherit the base from the existing context */
William M. Brackef245fd2004-02-06 09:33:59 +00001977 xmlXIncludeSetFlags(newctxt, ctxt->parseFlags);
1978 ret = xmlXIncludeDoProcess(newctxt, ctxt->doc, fallback->children);
William M. Brack87640d52004-04-17 14:58:15 +00001979 if (ctxt->nbErrors > 0)
William M. Brackef245fd2004-02-06 09:33:59 +00001980 ret = -1;
William M. Brack87640d52004-04-17 14:58:15 +00001981 else if (ret > 0)
1982 ret = 0; /* xmlXIncludeDoProcess can return +ve number */
William M. Brackef245fd2004-02-06 09:33:59 +00001983 xmlXIncludeFreeContext(newctxt);
Daniel Veillarde3b7d9a2002-08-14 14:11:30 +00001984
Daniel Veillard03a53c32004-10-26 16:06:51 +00001985 ctxt->incTab[nr]->inc = xmlDocCopyNodeList(ctxt->doc,
1986 fallback->children);
William M. Brackef245fd2004-02-06 09:33:59 +00001987 } else {
1988 ctxt->incTab[nr]->inc = NULL;
William M. Brack95af5942004-02-08 04:12:49 +00001989 ctxt->incTab[nr]->emptyFb = 1; /* flag empty callback */
William M. Brackef245fd2004-02-06 09:33:59 +00001990 }
William M. Brackaae10522004-01-02 14:59:41 +00001991 return(ret);
Owen Taylor3473f882001-02-23 17:55:21 +00001992}
1993
1994/************************************************************************
1995 * *
1996 * XInclude Processing *
1997 * *
1998 ************************************************************************/
1999
2000/**
2001 * xmlXIncludePreProcessNode:
2002 * @ctxt: an XInclude context
2003 * @node: an XInclude node
2004 *
Daniel Veillardd16df9f2001-05-23 13:44:21 +00002005 * Implement the XInclude preprocessing, currently just adding the element
2006 * for further processing.
Owen Taylor3473f882001-02-23 17:55:21 +00002007 *
2008 * Returns the result list or NULL in case of error
2009 */
Daniel Veillard56a4cb82001-03-24 17:00:36 +00002010static xmlNodePtr
Owen Taylor3473f882001-02-23 17:55:21 +00002011xmlXIncludePreProcessNode(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node) {
2012 xmlXIncludeAddNode(ctxt, node);
Daniel Veillard24505b02005-07-28 23:49:35 +00002013 return(NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00002014}
2015
Daniel Veillardbbc72c32002-09-05 10:52:10 +00002016/**
Owen Taylor3473f882001-02-23 17:55:21 +00002017 * xmlXIncludeLoadNode:
2018 * @ctxt: an XInclude context
2019 * @nr: the node number
2020 *
2021 * Find and load the infoset replacement for the given node.
2022 *
Daniel Veillardcbaf3992001-12-31 16:16:02 +00002023 * Returns 0 if substitution succeeded, -1 if some processing failed
Owen Taylor3473f882001-02-23 17:55:21 +00002024 */
Daniel Veillard56a4cb82001-03-24 17:00:36 +00002025static int
Owen Taylor3473f882001-02-23 17:55:21 +00002026xmlXIncludeLoadNode(xmlXIncludeCtxtPtr ctxt, int nr) {
2027 xmlNodePtr cur;
2028 xmlChar *href;
2029 xmlChar *parse;
2030 xmlChar *base;
William M. Brackf7789b12004-06-07 08:57:27 +00002031 xmlChar *oldBase;
Owen Taylor3473f882001-02-23 17:55:21 +00002032 xmlChar *URI;
2033 int xml = 1; /* default Issue 64 */
Daniel Veillarde3b7d9a2002-08-14 14:11:30 +00002034 int ret;
Owen Taylor3473f882001-02-23 17:55:21 +00002035
2036 if (ctxt == NULL)
2037 return(-1);
2038 if ((nr < 0) || (nr >= ctxt->incNr))
2039 return(-1);
Daniel Veillardbbc72c32002-09-05 10:52:10 +00002040 cur = ctxt->incTab[nr]->ref;
Owen Taylor3473f882001-02-23 17:55:21 +00002041 if (cur == NULL)
2042 return(-1);
2043
Owen Taylor3473f882001-02-23 17:55:21 +00002044 /*
2045 * read the attributes
2046 */
Daniel Veillardb5fa0202003-12-08 17:41:29 +00002047 href = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_HREF);
Owen Taylor3473f882001-02-23 17:55:21 +00002048 if (href == NULL) {
Daniel Veillard03c2f0a2004-01-25 19:54:59 +00002049 href = xmlStrdup(BAD_CAST ""); /* @@@@ href is now optional */
Daniel Veillardf8e3db02012-09-11 13:26:36 +08002050 if (href == NULL)
Daniel Veillard03c2f0a2004-01-25 19:54:59 +00002051 return(-1);
Owen Taylor3473f882001-02-23 17:55:21 +00002052 }
Daniel Veillardb5fa0202003-12-08 17:41:29 +00002053 parse = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_PARSE);
Owen Taylor3473f882001-02-23 17:55:21 +00002054 if (parse != NULL) {
2055 if (xmlStrEqual(parse, XINCLUDE_PARSE_XML))
2056 xml = 1;
2057 else if (xmlStrEqual(parse, XINCLUDE_PARSE_TEXT))
2058 xml = 0;
2059 else {
Daniel Veillardcd6ff282003-10-08 22:38:13 +00002060 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
2061 XML_XINCLUDE_PARSE_VALUE,
2062 "invalid value %s for 'parse'\n", parse);
Owen Taylor3473f882001-02-23 17:55:21 +00002063 if (href != NULL)
2064 xmlFree(href);
2065 if (parse != NULL)
2066 xmlFree(parse);
2067 return(-1);
2068 }
2069 }
2070
2071 /*
2072 * compute the URI
2073 */
2074 base = xmlNodeGetBase(ctxt->doc, cur);
2075 if (base == NULL) {
2076 URI = xmlBuildURI(href, ctxt->doc->URL);
2077 } else {
2078 URI = xmlBuildURI(href, base);
2079 }
2080 if (URI == NULL) {
2081 xmlChar *escbase;
2082 xmlChar *eschref;
2083 /*
Daniel Veillardcbaf3992001-12-31 16:16:02 +00002084 * Some escaping may be needed
Owen Taylor3473f882001-02-23 17:55:21 +00002085 */
2086 escbase = xmlURIEscape(base);
2087 eschref = xmlURIEscape(href);
2088 URI = xmlBuildURI(eschref, escbase);
2089 if (escbase != NULL)
2090 xmlFree(escbase);
2091 if (eschref != NULL)
2092 xmlFree(eschref);
2093 }
2094 if (URI == NULL) {
Daniel Veillardf8e3db02012-09-11 13:26:36 +08002095 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
Daniel Veillardcd6ff282003-10-08 22:38:13 +00002096 XML_XINCLUDE_HREF_URI, "failed build URL\n", NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00002097 if (parse != NULL)
2098 xmlFree(parse);
2099 if (href != NULL)
2100 xmlFree(href);
2101 if (base != NULL)
2102 xmlFree(base);
2103 return(-1);
2104 }
2105#ifdef DEBUG_XINCLUDE
2106 xmlGenericError(xmlGenericErrorContext, "parse: %s\n",
2107 xml ? "xml": "text");
2108 xmlGenericError(xmlGenericErrorContext, "URI: %s\n", URI);
2109#endif
2110
2111 /*
William M. Brackf7789b12004-06-07 08:57:27 +00002112 * Save the base for this include (saving the current one)
Owen Taylor3473f882001-02-23 17:55:21 +00002113 */
William M. Brackf7789b12004-06-07 08:57:27 +00002114 oldBase = ctxt->base;
2115 ctxt->base = base;
2116
Owen Taylor3473f882001-02-23 17:55:21 +00002117 if (xml) {
Daniel Veillarde3b7d9a2002-08-14 14:11:30 +00002118 ret = xmlXIncludeLoadDoc(ctxt, URI, nr);
Owen Taylor3473f882001-02-23 17:55:21 +00002119 /* xmlXIncludeGetFragment(ctxt, cur, URI); */
2120 } else {
Daniel Veillarde3b7d9a2002-08-14 14:11:30 +00002121 ret = xmlXIncludeLoadTxt(ctxt, URI, nr);
2122 }
William M. Brackf7789b12004-06-07 08:57:27 +00002123
2124 /*
2125 * Restore the original base before checking for fallback
2126 */
2127 ctxt->base = oldBase;
Daniel Veillardf8e3db02012-09-11 13:26:36 +08002128
Daniel Veillarde3b7d9a2002-08-14 14:11:30 +00002129 if (ret < 0) {
2130 xmlNodePtr children;
2131
2132 /*
2133 * Time to try a fallback if availble
2134 */
2135#ifdef DEBUG_XINCLUDE
2136 xmlGenericError(xmlGenericErrorContext, "error looking for fallback\n");
2137#endif
2138 children = cur->children;
2139 while (children != NULL) {
2140 if ((children->type == XML_ELEMENT_NODE) &&
2141 (children->ns != NULL) &&
2142 (xmlStrEqual(children->name, XINCLUDE_FALLBACK)) &&
Daniel Veillardb5fa0202003-12-08 17:41:29 +00002143 ((xmlStrEqual(children->ns->href, XINCLUDE_NS)) ||
2144 (xmlStrEqual(children->ns->href, XINCLUDE_OLD_NS)))) {
Daniel Veillarde3b7d9a2002-08-14 14:11:30 +00002145 ret = xmlXIncludeLoadFallback(ctxt, children, nr);
Daniel Veillardf8e3db02012-09-11 13:26:36 +08002146 if (ret == 0)
Daniel Veillarde3b7d9a2002-08-14 14:11:30 +00002147 break;
2148 }
2149 children = children->next;
2150 }
2151 }
2152 if (ret < 0) {
Daniel Veillardf8e3db02012-09-11 13:26:36 +08002153 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
Daniel Veillardcd6ff282003-10-08 22:38:13 +00002154 XML_XINCLUDE_NO_FALLBACK,
2155 "could not load %s, and no fallback was found\n",
2156 URI);
Owen Taylor3473f882001-02-23 17:55:21 +00002157 }
2158
2159 /*
2160 * Cleanup
2161 */
2162 if (URI != NULL)
2163 xmlFree(URI);
2164 if (parse != NULL)
2165 xmlFree(parse);
2166 if (href != NULL)
2167 xmlFree(href);
2168 if (base != NULL)
2169 xmlFree(base);
2170 return(0);
2171}
2172
2173/**
2174 * xmlXIncludeIncludeNode:
2175 * @ctxt: an XInclude context
2176 * @nr: the node number
2177 *
2178 * Inplement the infoset replacement for the given node
2179 *
Daniel Veillardcbaf3992001-12-31 16:16:02 +00002180 * Returns 0 if substitution succeeded, -1 if some processing failed
Owen Taylor3473f882001-02-23 17:55:21 +00002181 */
Daniel Veillard56a4cb82001-03-24 17:00:36 +00002182static int
Owen Taylor3473f882001-02-23 17:55:21 +00002183xmlXIncludeIncludeNode(xmlXIncludeCtxtPtr ctxt, int nr) {
Daniel Veillardf4b4f982003-02-13 11:02:08 +00002184 xmlNodePtr cur, end, list, tmp;
Owen Taylor3473f882001-02-23 17:55:21 +00002185
2186 if (ctxt == NULL)
2187 return(-1);
2188 if ((nr < 0) || (nr >= ctxt->incNr))
2189 return(-1);
Daniel Veillardbbc72c32002-09-05 10:52:10 +00002190 cur = ctxt->incTab[nr]->ref;
Daniel Veillard3e62adb2012-08-09 14:24:02 +08002191 if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL))
Owen Taylor3473f882001-02-23 17:55:21 +00002192 return(-1);
2193
2194 /*
Daniel Veillardf4b4f982003-02-13 11:02:08 +00002195 * If we stored an XPointer a late computation may be needed
2196 */
2197 if ((ctxt->incTab[nr]->inc == NULL) &&
2198 (ctxt->incTab[nr]->xptr != NULL)) {
2199 ctxt->incTab[nr]->inc =
2200 xmlXIncludeCopyXPointer(ctxt, ctxt->doc, ctxt->doc,
2201 ctxt->incTab[nr]->xptr);
2202 xmlXPathFreeObject(ctxt->incTab[nr]->xptr);
2203 ctxt->incTab[nr]->xptr = NULL;
2204 }
2205 list = ctxt->incTab[nr]->inc;
2206 ctxt->incTab[nr]->inc = NULL;
2207
2208 /*
2209 * Check against the risk of generating a multi-rooted document
2210 */
2211 if ((cur->parent != NULL) &&
2212 (cur->parent->type != XML_ELEMENT_NODE)) {
2213 int nb_elem = 0;
2214
2215 tmp = list;
2216 while (tmp != NULL) {
2217 if (tmp->type == XML_ELEMENT_NODE)
2218 nb_elem++;
2219 tmp = tmp->next;
2220 }
2221 if (nb_elem > 1) {
Daniel Veillardf8e3db02012-09-11 13:26:36 +08002222 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
Daniel Veillardcd6ff282003-10-08 22:38:13 +00002223 XML_XINCLUDE_MULTIPLE_ROOT,
2224 "XInclude error: would result in multiple root nodes\n",
2225 NULL);
Daniel Veillardf4b4f982003-02-13 11:02:08 +00002226 return(-1);
2227 }
2228 }
2229
Daniel Veillardc14c3892004-08-16 12:34:50 +00002230 if (ctxt->parseFlags & XML_PARSE_NOXINCNODE) {
2231 /*
2232 * Add the list of nodes
2233 */
2234 while (list != NULL) {
2235 end = list;
2236 list = list->next;
Owen Taylor3473f882001-02-23 17:55:21 +00002237
Daniel Veillardc14c3892004-08-16 12:34:50 +00002238 xmlAddPrevSibling(cur, end);
2239 }
2240 xmlUnlinkNode(cur);
2241 xmlFreeNode(cur);
2242 } else {
2243 /*
2244 * Change the current node as an XInclude start one, and add an
2245 * XInclude end one
2246 */
2247 cur->type = XML_XINCLUDE_START;
Daniel Veillard03a53c32004-10-26 16:06:51 +00002248 end = xmlNewDocNode(cur->doc, cur->ns, cur->name, NULL);
Daniel Veillardc14c3892004-08-16 12:34:50 +00002249 if (end == NULL) {
2250 xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
2251 XML_XINCLUDE_BUILD_FAILED,
2252 "failed to build node\n", NULL);
2253 return(-1);
2254 }
2255 end->type = XML_XINCLUDE_END;
2256 xmlAddNextSibling(cur, end);
Owen Taylor3473f882001-02-23 17:55:21 +00002257
Daniel Veillardc14c3892004-08-16 12:34:50 +00002258 /*
2259 * Add the list of nodes
2260 */
2261 while (list != NULL) {
2262 cur = list;
2263 list = list->next;
2264
2265 xmlAddPrevSibling(end, cur);
2266 }
Owen Taylor3473f882001-02-23 17:55:21 +00002267 }
Daniel Veillardc5f05ad2002-02-10 11:57:22 +00002268
Daniel Veillardf8e3db02012-09-11 13:26:36 +08002269
Owen Taylor3473f882001-02-23 17:55:21 +00002270 return(0);
2271}
2272
2273/**
2274 * xmlXIncludeTestNode:
Daniel Veillardf4b4f982003-02-13 11:02:08 +00002275 * @ctxt: the XInclude processing context
Owen Taylor3473f882001-02-23 17:55:21 +00002276 * @node: an XInclude node
2277 *
2278 * test if the node is an XInclude node
2279 *
2280 * Returns 1 true, 0 otherwise
2281 */
Daniel Veillard56a4cb82001-03-24 17:00:36 +00002282static int
Daniel Veillardf4b4f982003-02-13 11:02:08 +00002283xmlXIncludeTestNode(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node) {
Owen Taylor3473f882001-02-23 17:55:21 +00002284 if (node == NULL)
2285 return(0);
Daniel Veillardffe4f5e2003-07-06 17:35:43 +00002286 if (node->type != XML_ELEMENT_NODE)
2287 return(0);
Owen Taylor3473f882001-02-23 17:55:21 +00002288 if (node->ns == NULL)
2289 return(0);
Daniel Veillardb5fa0202003-12-08 17:41:29 +00002290 if ((xmlStrEqual(node->ns->href, XINCLUDE_NS)) ||
2291 (xmlStrEqual(node->ns->href, XINCLUDE_OLD_NS))) {
2292 if (xmlStrEqual(node->ns->href, XINCLUDE_OLD_NS)) {
2293 if (ctxt->legacy == 0) {
Daniel Veillard5bb9ccd2004-02-09 12:39:02 +00002294#if 0 /* wait for the XML Core Working Group to get something stable ! */
Daniel Veillardb5fa0202003-12-08 17:41:29 +00002295 xmlXIncludeWarn(ctxt, node, XML_XINCLUDE_DEPRECATED_NS,
2296 "Deprecated XInclude namespace found, use %s",
2297 XINCLUDE_NS);
Daniel Veillard5bb9ccd2004-02-09 12:39:02 +00002298#endif
Daniel Veillarde74d2e12003-12-09 11:35:37 +00002299 ctxt->legacy = 1;
Daniel Veillardb5fa0202003-12-08 17:41:29 +00002300 }
2301 }
Daniel Veillardf4b4f982003-02-13 11:02:08 +00002302 if (xmlStrEqual(node->name, XINCLUDE_NODE)) {
2303 xmlNodePtr child = node->children;
2304 int nb_fallback = 0;
2305
2306 while (child != NULL) {
2307 if ((child->type == XML_ELEMENT_NODE) &&
2308 (child->ns != NULL) &&
Daniel Veillardb5fa0202003-12-08 17:41:29 +00002309 ((xmlStrEqual(child->ns->href, XINCLUDE_NS)) ||
2310 (xmlStrEqual(child->ns->href, XINCLUDE_OLD_NS)))) {
Daniel Veillardf4b4f982003-02-13 11:02:08 +00002311 if (xmlStrEqual(child->name, XINCLUDE_NODE)) {
Daniel Veillardcd6ff282003-10-08 22:38:13 +00002312 xmlXIncludeErr(ctxt, node,
2313 XML_XINCLUDE_INCLUDE_IN_INCLUDE,
2314 "%s has an 'include' child\n",
2315 XINCLUDE_NODE);
Daniel Veillardf4b4f982003-02-13 11:02:08 +00002316 return(0);
2317 }
2318 if (xmlStrEqual(child->name, XINCLUDE_FALLBACK)) {
2319 nb_fallback++;
2320 }
2321 }
2322 child = child->next;
2323 }
2324 if (nb_fallback > 1) {
Daniel Veillardcd6ff282003-10-08 22:38:13 +00002325 xmlXIncludeErr(ctxt, node, XML_XINCLUDE_FALLBACKS_IN_INCLUDE,
2326 "%s has multiple fallback children\n",
2327 XINCLUDE_NODE);
Daniel Veillardf4b4f982003-02-13 11:02:08 +00002328 return(0);
2329 }
2330 return(1);
2331 }
2332 if (xmlStrEqual(node->name, XINCLUDE_FALLBACK)) {
2333 if ((node->parent == NULL) ||
2334 (node->parent->type != XML_ELEMENT_NODE) ||
2335 (node->parent->ns == NULL) ||
Daniel Veillardb5fa0202003-12-08 17:41:29 +00002336 ((!xmlStrEqual(node->parent->ns->href, XINCLUDE_NS)) &&
2337 (!xmlStrEqual(node->parent->ns->href, XINCLUDE_OLD_NS))) ||
Daniel Veillardf4b4f982003-02-13 11:02:08 +00002338 (!xmlStrEqual(node->parent->name, XINCLUDE_NODE))) {
Daniel Veillardcd6ff282003-10-08 22:38:13 +00002339 xmlXIncludeErr(ctxt, node,
2340 XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE,
2341 "%s is not the child of an 'include'\n",
2342 XINCLUDE_FALLBACK);
Daniel Veillardf4b4f982003-02-13 11:02:08 +00002343 }
2344 }
2345 }
Owen Taylor3473f882001-02-23 17:55:21 +00002346 return(0);
2347}
2348
2349/**
Daniel Veillardd16df9f2001-05-23 13:44:21 +00002350 * xmlXIncludeDoProcess:
Daniel Veillardf4b4f982003-02-13 11:02:08 +00002351 * @ctxt: the XInclude processing context
Owen Taylor3473f882001-02-23 17:55:21 +00002352 * @doc: an XML document
Daniel Veillard8edf1c52003-07-22 20:52:14 +00002353 * @tree: the top of the tree to process
Owen Taylor3473f882001-02-23 17:55:21 +00002354 *
2355 * Implement the XInclude substitution on the XML document @doc
2356 *
Daniel Veillardcbaf3992001-12-31 16:16:02 +00002357 * Returns 0 if no substitution were done, -1 if some processing failed
Owen Taylor3473f882001-02-23 17:55:21 +00002358 * or the number of substitutions done.
2359 */
Daniel Veillardd16df9f2001-05-23 13:44:21 +00002360static int
Daniel Veillard8edf1c52003-07-22 20:52:14 +00002361xmlXIncludeDoProcess(xmlXIncludeCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr tree) {
Owen Taylor3473f882001-02-23 17:55:21 +00002362 xmlNodePtr cur;
2363 int ret = 0;
Daniel Veillarde0fd93f2005-08-10 13:39:10 +00002364 int i, start;
Owen Taylor3473f882001-02-23 17:55:21 +00002365
Daniel Veillard3e62adb2012-08-09 14:24:02 +08002366 if ((doc == NULL) || (tree == NULL) || (tree->type == XML_NAMESPACE_DECL))
Owen Taylor3473f882001-02-23 17:55:21 +00002367 return(-1);
Owen Taylor3473f882001-02-23 17:55:21 +00002368 if (ctxt == NULL)
2369 return(-1);
2370
Daniel Veillardf4b4f982003-02-13 11:02:08 +00002371 if (doc->URL != NULL) {
2372 ret = xmlXIncludeURLPush(ctxt, doc->URL);
2373 if (ret < 0)
2374 return(-1);
2375 }
Daniel Veillard11ce4002006-03-10 00:36:23 +00002376 start = ctxt->incNr;
Daniel Veillardf4b4f982003-02-13 11:02:08 +00002377
Owen Taylor3473f882001-02-23 17:55:21 +00002378 /*
2379 * First phase: lookup the elements in the document
2380 */
Daniel Veillard8edf1c52003-07-22 20:52:14 +00002381 cur = tree;
Daniel Veillardf4b4f982003-02-13 11:02:08 +00002382 if (xmlXIncludeTestNode(ctxt, cur) == 1)
Owen Taylor3473f882001-02-23 17:55:21 +00002383 xmlXIncludePreProcessNode(ctxt, cur);
William M. Brack7b0e2762004-05-12 09:33:23 +00002384 while ((cur != NULL) && (cur != tree->parent)) {
Owen Taylor3473f882001-02-23 17:55:21 +00002385 /* TODO: need to work on entities -> stack */
2386 if ((cur->children != NULL) &&
Daniel Veillardffe4f5e2003-07-06 17:35:43 +00002387 (cur->children->type != XML_ENTITY_DECL) &&
2388 (cur->children->type != XML_XINCLUDE_START) &&
2389 (cur->children->type != XML_XINCLUDE_END)) {
Owen Taylor3473f882001-02-23 17:55:21 +00002390 cur = cur->children;
Daniel Veillardf4b4f982003-02-13 11:02:08 +00002391 if (xmlXIncludeTestNode(ctxt, cur))
Owen Taylor3473f882001-02-23 17:55:21 +00002392 xmlXIncludePreProcessNode(ctxt, cur);
2393 } else if (cur->next != NULL) {
2394 cur = cur->next;
Daniel Veillardf4b4f982003-02-13 11:02:08 +00002395 if (xmlXIncludeTestNode(ctxt, cur))
Owen Taylor3473f882001-02-23 17:55:21 +00002396 xmlXIncludePreProcessNode(ctxt, cur);
2397 } else {
William M. Brack5d8d10b2004-04-16 08:11:26 +00002398 if (cur == tree)
2399 break;
Owen Taylor3473f882001-02-23 17:55:21 +00002400 do {
2401 cur = cur->parent;
William M. Brack7b0e2762004-05-12 09:33:23 +00002402 if ((cur == NULL) || (cur == tree->parent))
2403 break; /* do */
Owen Taylor3473f882001-02-23 17:55:21 +00002404 if (cur->next != NULL) {
2405 cur = cur->next;
Daniel Veillardf4b4f982003-02-13 11:02:08 +00002406 if (xmlXIncludeTestNode(ctxt, cur))
Owen Taylor3473f882001-02-23 17:55:21 +00002407 xmlXIncludePreProcessNode(ctxt, cur);
2408 break; /* do */
2409 }
2410 } while (cur != NULL);
2411 }
2412 }
2413
2414 /*
2415 * Second Phase : collect the infosets fragments
2416 */
Daniel Veillarde0fd93f2005-08-10 13:39:10 +00002417 for (i = start;i < ctxt->incNr; i++) {
Owen Taylor3473f882001-02-23 17:55:21 +00002418 xmlXIncludeLoadNode(ctxt, i);
Daniel Veillard97fd5672003-02-07 13:01:54 +00002419 ret++;
Owen Taylor3473f882001-02-23 17:55:21 +00002420 }
2421
2422 /*
2423 * Third phase: extend the original document infoset.
William M. Brack6b1a28d2004-02-06 11:24:44 +00002424 *
2425 * Originally we bypassed the inclusion if there were any errors
2426 * encountered on any of the XIncludes. A bug was raised (bug
2427 * 132588) requesting that we output the XIncludes without error,
2428 * so the check for inc!=NULL || xptr!=NULL was put in. This may
2429 * give some other problems in the future, but for now it seems to
2430 * work ok.
2431 *
Owen Taylor3473f882001-02-23 17:55:21 +00002432 */
William M. Brack6b1a28d2004-02-06 11:24:44 +00002433 for (i = ctxt->incBase;i < ctxt->incNr; i++) {
William M. Brack95af5942004-02-08 04:12:49 +00002434 if ((ctxt->incTab[i]->inc != NULL) ||
2435 (ctxt->incTab[i]->xptr != NULL) ||
2436 (ctxt->incTab[i]->emptyFb != 0)) /* (empty fallback) */
Daniel Veillardf4b4f982003-02-13 11:02:08 +00002437 xmlXIncludeIncludeNode(ctxt, i);
Owen Taylor3473f882001-02-23 17:55:21 +00002438 }
2439
Daniel Veillardf4b4f982003-02-13 11:02:08 +00002440 if (doc->URL != NULL)
2441 xmlXIncludeURLPop(ctxt);
Daniel Veillardd16df9f2001-05-23 13:44:21 +00002442 return(ret);
2443}
2444
2445/**
Daniel Veillarde74d2e12003-12-09 11:35:37 +00002446 * xmlXIncludeSetFlags:
2447 * @ctxt: an XInclude processing context
2448 * @flags: a set of xmlParserOption used for parsing XML includes
2449 *
2450 * Set the flags used for further processing of XML resources.
2451 *
2452 * Returns 0 in case of success and -1 in case of error.
2453 */
2454int
2455xmlXIncludeSetFlags(xmlXIncludeCtxtPtr ctxt, int flags) {
2456 if (ctxt == NULL)
2457 return(-1);
2458 ctxt->parseFlags = flags;
2459 return(0);
2460}
Stefan Behnelb9590e92009-08-24 19:45:54 +02002461
2462/**
2463 * xmlXIncludeProcessTreeFlagsData:
2464 * @tree: an XML node
2465 * @flags: a set of xmlParserOption used for parsing XML includes
2466 * @data: application data that will be passed to the parser context
2467 * in the _private field of the parser context(s)
2468 *
2469 * Implement the XInclude substitution on the XML node @tree
2470 *
2471 * Returns 0 if no substitution were done, -1 if some processing failed
2472 * or the number of substitutions done.
2473 */
2474
2475int
2476xmlXIncludeProcessTreeFlagsData(xmlNodePtr tree, int flags, void *data) {
2477 xmlXIncludeCtxtPtr ctxt;
2478 int ret = 0;
2479
Daniel Veillard3e62adb2012-08-09 14:24:02 +08002480 if ((tree == NULL) || (tree->type == XML_NAMESPACE_DECL) ||
2481 (tree->doc == NULL))
Stefan Behnelb9590e92009-08-24 19:45:54 +02002482 return(-1);
2483
2484 ctxt = xmlXIncludeNewContext(tree->doc);
2485 if (ctxt == NULL)
2486 return(-1);
2487 ctxt->_private = data;
2488 ctxt->base = xmlStrdup((xmlChar *)tree->doc->URL);
2489 xmlXIncludeSetFlags(ctxt, flags);
2490 ret = xmlXIncludeDoProcess(ctxt, tree->doc, tree);
2491 if ((ret >= 0) && (ctxt->nbErrors > 0))
2492 ret = -1;
2493
2494 xmlXIncludeFreeContext(ctxt);
2495 return(ret);
2496}
2497
Daniel Veillarde74d2e12003-12-09 11:35:37 +00002498/**
Daniel Veillard681e9042006-09-29 09:16:00 +00002499 * xmlXIncludeProcessFlagsData:
Daniel Veillardd16df9f2001-05-23 13:44:21 +00002500 * @doc: an XML document
Daniel Veillarde74d2e12003-12-09 11:35:37 +00002501 * @flags: a set of xmlParserOption used for parsing XML includes
Daniel Veillard681e9042006-09-29 09:16:00 +00002502 * @data: application data that will be passed to the parser context
2503 * in the _private field of the parser context(s)
Daniel Veillardd16df9f2001-05-23 13:44:21 +00002504 *
2505 * Implement the XInclude substitution on the XML document @doc
2506 *
Daniel Veillardcbaf3992001-12-31 16:16:02 +00002507 * Returns 0 if no substitution were done, -1 if some processing failed
Daniel Veillardd16df9f2001-05-23 13:44:21 +00002508 * or the number of substitutions done.
2509 */
2510int
Daniel Veillard681e9042006-09-29 09:16:00 +00002511xmlXIncludeProcessFlagsData(xmlDocPtr doc, int flags, void *data) {
Daniel Veillard8edf1c52003-07-22 20:52:14 +00002512 xmlNodePtr tree;
Daniel Veillardd16df9f2001-05-23 13:44:21 +00002513
2514 if (doc == NULL)
2515 return(-1);
Daniel Veillard8edf1c52003-07-22 20:52:14 +00002516 tree = xmlDocGetRootElement(doc);
2517 if (tree == NULL)
2518 return(-1);
Stefan Behnelb9590e92009-08-24 19:45:54 +02002519 return(xmlXIncludeProcessTreeFlagsData(tree, flags, data));
Daniel Veillard8edf1c52003-07-22 20:52:14 +00002520}
2521
2522/**
Daniel Veillard681e9042006-09-29 09:16:00 +00002523 * xmlXIncludeProcessFlags:
2524 * @doc: an XML document
2525 * @flags: a set of xmlParserOption used for parsing XML includes
2526 *
2527 * Implement the XInclude substitution on the XML document @doc
2528 *
2529 * Returns 0 if no substitution were done, -1 if some processing failed
2530 * or the number of substitutions done.
2531 */
2532int
2533xmlXIncludeProcessFlags(xmlDocPtr doc, int flags) {
2534 return xmlXIncludeProcessFlagsData(doc, flags, NULL);
2535}
2536
2537/**
Daniel Veillarde74d2e12003-12-09 11:35:37 +00002538 * xmlXIncludeProcess:
2539 * @doc: an XML document
2540 *
2541 * Implement the XInclude substitution on the XML document @doc
2542 *
2543 * Returns 0 if no substitution were done, -1 if some processing failed
2544 * or the number of substitutions done.
2545 */
2546int
2547xmlXIncludeProcess(xmlDocPtr doc) {
2548 return(xmlXIncludeProcessFlags(doc, 0));
2549}
2550
2551/**
2552 * xmlXIncludeProcessTreeFlags:
2553 * @tree: a node in an XML document
2554 * @flags: a set of xmlParserOption used for parsing XML includes
2555 *
2556 * Implement the XInclude substitution for the given subtree
2557 *
2558 * Returns 0 if no substitution were done, -1 if some processing failed
2559 * or the number of substitutions done.
2560 */
2561int
2562xmlXIncludeProcessTreeFlags(xmlNodePtr tree, int flags) {
2563 xmlXIncludeCtxtPtr ctxt;
2564 int ret = 0;
2565
Daniel Veillard3e62adb2012-08-09 14:24:02 +08002566 if ((tree == NULL) || (tree->type == XML_NAMESPACE_DECL) ||
2567 (tree->doc == NULL))
Daniel Veillarde74d2e12003-12-09 11:35:37 +00002568 return(-1);
2569 ctxt = xmlXIncludeNewContext(tree->doc);
2570 if (ctxt == NULL)
2571 return(-1);
William M. Brackf7789b12004-06-07 08:57:27 +00002572 ctxt->base = xmlNodeGetBase(tree->doc, tree);
Daniel Veillarde74d2e12003-12-09 11:35:37 +00002573 xmlXIncludeSetFlags(ctxt, flags);
2574 ret = xmlXIncludeDoProcess(ctxt, tree->doc, tree);
2575 if ((ret >= 0) && (ctxt->nbErrors > 0))
2576 ret = -1;
2577
2578 xmlXIncludeFreeContext(ctxt);
2579 return(ret);
2580}
2581
2582/**
Daniel Veillard8edf1c52003-07-22 20:52:14 +00002583 * xmlXIncludeProcessTree:
2584 * @tree: a node in an XML document
2585 *
2586 * Implement the XInclude substitution for the given subtree
2587 *
2588 * Returns 0 if no substitution were done, -1 if some processing failed
2589 * or the number of substitutions done.
2590 */
2591int
2592xmlXIncludeProcessTree(xmlNodePtr tree) {
Daniel Veillarde74d2e12003-12-09 11:35:37 +00002593 return(xmlXIncludeProcessTreeFlags(tree, 0));
Owen Taylor3473f882001-02-23 17:55:21 +00002594}
2595
Daniel Veillard7899c5c2003-11-03 12:31:38 +00002596/**
2597 * xmlXIncludeProcessNode:
2598 * @ctxt: an existing XInclude context
2599 * @node: a node in an XML document
2600 *
2601 * Implement the XInclude substitution for the given subtree reusing
2602 * the informations and data coming from the given context.
2603 *
2604 * Returns 0 if no substitution were done, -1 if some processing failed
2605 * or the number of substitutions done.
2606 */
2607int
2608xmlXIncludeProcessNode(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node) {
2609 int ret = 0;
2610
Daniel Veillard3e62adb2012-08-09 14:24:02 +08002611 if ((node == NULL) || (node->type == XML_NAMESPACE_DECL) ||
2612 (node->doc == NULL) || (ctxt == NULL))
Daniel Veillard7899c5c2003-11-03 12:31:38 +00002613 return(-1);
2614 ret = xmlXIncludeDoProcess(ctxt, node->doc, node);
2615 if ((ret >= 0) && (ctxt->nbErrors > 0))
2616 ret = -1;
2617 return(ret);
2618}
2619
Owen Taylor3473f882001-02-23 17:55:21 +00002620#else /* !LIBXML_XINCLUDE_ENABLED */
2621#endif
Daniel Veillard5d4644e2005-04-01 13:11:58 +00002622#define bottom_xinclude
2623#include "elfgcchack.h"