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