Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxml/src/xinclude.c

 /*
  * xinclude.c : Code to implement XInclude processing
  *
  * World Wide Web Consortium W3C Last Call Working Draft 10 November 2003
  * http://www.w3.org/TR/2003/WD-xinclude-20031110
  *
  * See Copyright for the status of this software.
  *
  * daniel@veillard.com
  */
 
 #define IN_LIBXML
 #include "libxml.h"
 
 #include <string.h>
 #include <libxml/xmlmemory.h>
 #include <libxml/tree.h>
 #include <libxml/parser.h>
 #include <libxml/uri.h>
+#include <libxml/xpath.h>
 #include <libxml/xpointer.h>
 #include <libxml/parserInternals.h>
 #include <libxml/xmlerror.h>
 #include <libxml/encoding.h>
 #include <libxml/globals.h>
 
 #ifdef LIBXML_XINCLUDE_ENABLED
 #include <libxml/xinclude.h>
 
+#include "buf.h"
 
 #define XINCLUDE_MAX_DEPTH 40
 
 /* #define DEBUG_XINCLUDE */
 #ifdef DEBUG_XINCLUDE
 #ifdef LIBXML_DEBUG_ENABLED
 #include <libxml/debugXML.h>
 #endif
 #endif
 
@@ skipping 46 matching lines @@
 
     void            *_private; /* application data */
 };
 
 static int
 xmlXIncludeDoProcess(xmlXIncludeCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr tree);
 
 
 /************************************************************************
  *                                                                      *
- *                      XInclude error handler                          *
+ *                      XInclude error handler                          *
  *                                                                      *
  ************************************************************************/
 
 /**
  * xmlXIncludeErrMemory:
  * @extra:  extra information
  *
  * Handle an out of memory condition
  */
 static void
@@ skipping 299 matching lines @@
     if (ctxt->base != NULL) {
         xmlFree(ctxt->base);
     }
     xmlFree(ctxt);
 }
 
 /**
  * xmlXIncludeParseFile:
  * @ctxt:  the XInclude context
  * @URL:  the URL or file path
- * 
+ *
  * parse a document for XInclude
  */
 static xmlDocPtr
 xmlXIncludeParseFile(xmlXIncludeCtxtPtr ctxt, const char *URL) {
     xmlDocPtr ret;
     xmlParserCtxtPtr pctxt;
     xmlParserInputPtr inputStream;
 
     xmlInitParser();
 
     pctxt = xmlNewParserCtxt();
     if (pctxt == NULL) {
         xmlXIncludeErrMemory(ctxt, NULL, "cannot allocate parser context");
         return(NULL);
     }
 
     /*
      * pass in the application data to the parser context.
      */
     pctxt->_private = ctxt->_private;
-    
+
     /*
      * try to ensure that new documents included are actually
      * built with the same dictionary as the including document.
      */
     if ((ctxt->doc != NULL) && (ctxt->doc->dict != NULL)) {
        if (pctxt->dict != NULL)
             xmlDictFree(pctxt->dict);
         pctxt->dict = ctxt->doc->dict;
         xmlDictReference(pctxt->dict);
     }
 
     xmlCtxtUseOptions(pctxt, ctxt->parseFlags | XML_PARSE_DTDLOAD);
-    
+
     inputStream = xmlLoadExternalEntity(URL, NULL, pctxt);
     if (inputStream == NULL) {
         xmlFreeParserCtxt(pctxt);
         return(NULL);
     }
 
     inputPush(pctxt, inputStream);
 
     if (pctxt->directory == NULL)
         pctxt->directory = xmlParserGetDirectory(URL);
 
     pctxt->loadsubset |= XML_DETECT_IDS;
 
     xmlParseDocument(pctxt);
 
     if (pctxt->wellFormed) {
         ret = pctxt->myDoc;
     }
     else {
         ret = NULL;
         if (pctxt->myDoc != NULL)
             xmlFreeDoc(pctxt->myDoc);
         pctxt->myDoc = NULL;
     }
     xmlFreeParserCtxt(pctxt);
-    
+
     return(ret);
 }
 
 /**
  * xmlXIncludeAddNode:
  * @ctxt:  the XInclude context
  * @cur:  the new node
- * 
+ *
  * Add a new node to process to an XInclude context
  */
 static int
 xmlXIncludeAddNode(xmlXIncludeCtxtPtr ctxt, xmlNodePtr cur) {
     xmlXIncludeRefPtr ref;
     xmlURIPtr uri;
     xmlChar *URL;
     xmlChar *fragment = NULL;
     xmlChar *href;
     xmlChar *parse;
@@ skipping 10 matching lines @@
 
 #ifdef DEBUG_XINCLUDE
     xmlGenericError(xmlGenericErrorContext, "Add node\n");
 #endif
     /*
      * read the attributes
      */
     href = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_HREF);
     if (href == NULL) {
         href = xmlStrdup(BAD_CAST ""); /* @@@@ href is now optional */
-        if (href == NULL) 
+        if (href == NULL)
             return(-1);
     }
     if ((href[0] == '#') || (href[0] == 0))
         local = 1;
     parse = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_PARSE);
     if (parse != NULL) {
         if (xmlStrEqual(parse, XINCLUDE_PARSE_XML))
             xml = 1;
         else if (xmlStrEqual(parse, XINCLUDE_PARSE_TEXT))
             xml = 0;
@@ skipping 123 matching lines @@
     ref->count = 1;
     xmlFree(URL);
     return(0);
 }
 
 /**
  * xmlXIncludeRecurseDoc:
  * @ctxt:  the XInclude context
  * @doc:  the new document
  * @url:  the associated URL
- * 
+ *
  * The XInclude recursive nature is handled at this point.
  */
 static void
 xmlXIncludeRecurseDoc(xmlXIncludeCtxtPtr ctxt, xmlDocPtr doc,
                       const xmlURL url ATTRIBUTE_UNUSED) {
     xmlXIncludeCtxtPtr newctxt;
     int i;
 
     /*
      * Avoid recursion in already substitued resources
     for (i = 0;i < ctxt->urlNr;i++) {
         if (xmlStrEqual(doc->URL, ctxt->urlTab[i]))
             return;
     }
      */
 
 #ifdef DEBUG_XINCLUDE
     xmlGenericError(xmlGenericErrorContext, "Recursing in doc %s\n", doc->URL);
 #endif
     /*
      * Handle recursion here.
      */
 
     newctxt = xmlXIncludeNewContext(doc);
     if (newctxt != NULL) {
         /*
          * Copy the private user data
          */
-        newctxt->_private = ctxt->_private;     
+        newctxt->_private = ctxt->_private;
         /*
          * Copy the existing document set
          */
         newctxt->incMax = ctxt->incMax;
         newctxt->incNr = ctxt->incNr;
         newctxt->incTab = (xmlXIncludeRefPtr *) xmlMalloc(newctxt->incMax *
                                           sizeof(newctxt->incTab[0]));
         if (newctxt->incTab == NULL) {
             xmlXIncludeErrMemory(ctxt, (xmlNodePtr) doc, "processing doc");
             xmlFree(newctxt);
@@ skipping 44 matching lines @@
 #ifdef DEBUG_XINCLUDE
     xmlGenericError(xmlGenericErrorContext, "Done recursing in doc %s\n", url);
 #endif
 }
 
 /**
  * xmlXIncludeAddTxt:
  * @ctxt:  the XInclude context
  * @txt:  the new text node
  * @url:  the associated URL
- * 
+ *
  * Add a new txtument to the list
  */
 static void
 xmlXIncludeAddTxt(xmlXIncludeCtxtPtr ctxt, xmlNodePtr txt, const xmlURL url) {
 #ifdef DEBUG_XINCLUDE
     xmlGenericError(xmlGenericErrorContext, "Adding text %s\n", url);
 #endif
     if (ctxt->txtMax == 0) {
         ctxt->txtMax = 4;
         ctxt->txtTab = (xmlNodePtr *) xmlMalloc(ctxt->txtMax *
@@ skipping 38 matching lines @@
 static xmlNodePtr
 xmlXIncludeCopyNodeList(xmlXIncludeCtxtPtr ctxt, xmlDocPtr target,
                         xmlDocPtr source, xmlNodePtr elem);
 
 /**
  * xmlXIncludeCopyNode:
  * @ctxt:  the XInclude context
  * @target:  the document target
  * @source:  the document source
  * @elem:  the element
- * 
+ *
  * Make a copy of the node while preserving the XInclude semantic
  * of the Infoset copy
  */
 static xmlNodePtr
 xmlXIncludeCopyNode(xmlXIncludeCtxtPtr ctxt, xmlDocPtr target,
                     xmlDocPtr source, xmlNodePtr elem) {
     xmlNodePtr result = NULL;
 
     if ((ctxt == NULL) || (target == NULL) || (source == NULL) ||
         (elem == NULL))
         return(NULL);
     if (elem->type == XML_DTD_NODE)
         return(NULL);
     if (elem->type == XML_DOCUMENT_NODE)
         result = xmlXIncludeCopyNodeList(ctxt, target, source, elem->children);
     else
         result = xmlDocCopyNode(elem, target, 1);
     return(result);
 }
 
 /**
  * xmlXIncludeCopyNodeList:
  * @ctxt:  the XInclude context
  * @target:  the document target
  * @source:  the document source
  * @elem:  the element list
- * 
+ *
  * Make a copy of the node list while preserving the XInclude semantic
  * of the Infoset copy
  */
 static xmlNodePtr
 xmlXIncludeCopyNodeList(xmlXIncludeCtxtPtr ctxt, xmlDocPtr target,
                         xmlDocPtr source, xmlNodePtr elem) {
     xmlNodePtr cur, res, result = NULL, last = NULL;
 
     if ((ctxt == NULL) || (target == NULL) || (source == NULL) ||
         (elem == NULL))
@@ skipping 18 matching lines @@
 /**
  * xmlXIncludeGetNthChild:
  * @cur:  the node
  * @no:  the child number
  *
  * Returns the @n'th element child of @cur or NULL
  */
 static xmlNodePtr
 xmlXIncludeGetNthChild(xmlNodePtr cur, int no) {
     int i;
-    if (cur == NULL) 
-        return(cur);
+    if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL))
+        return(NULL);
     cur = cur->children;
     for (i = 0;i <= no;cur = cur->next) {
-        if (cur == NULL) 
+        if (cur == NULL)
             return(cur);
         if ((cur->type == XML_ELEMENT_NODE) ||
             (cur->type == XML_DOCUMENT_NODE) ||
             (cur->type == XML_HTML_DOCUMENT_NODE)) {
             i++;
             if (i == no)
                 break;
         }
     }
     return(cur);
@@ skipping 23 matching lines @@
     int index1, index2;
     int level = 0, lastLevel = 0, endLevel = 0, endFlag = 0;
 
     if ((ctxt == NULL) || (target == NULL) || (source == NULL) ||
         (range == NULL))
         return(NULL);
     if (range->type != XPATH_RANGE)
         return(NULL);
     start = (xmlNodePtr) range->user;
 
-    if (start == NULL)
+    if ((start == NULL) || (start->type == XML_NAMESPACE_DECL))
         return(NULL);
     end = range->user2;
     if (end == NULL)
         return(xmlDocCopyNode(start, target, 1));
+    if (end->type == XML_NAMESPACE_DECL)
+        return(NULL);
 
     cur = start;
     index1 = range->index;
     index2 = range->index2;
     /*
      * level is depth of the current node under consideration
      * list is the pointer to the root of the output tree
      * listParent is a pointer to the parent of output tree (within
        the included file) in case we need to add another level
      * last is a pointer to the last node added to the output tree
@@ skipping 38 matching lines @@
                         len = index2;
                     }
                     tmp = xmlNewTextLen(content, len);
                 }
                 /* single sub text node selection */
                 if (list == NULL)
                     return(tmp);
                 /* prune and return full set */
                 if (level == lastLevel)
                     xmlAddNextSibling(last, tmp);
-                else 
+                else
                     xmlAddChild(last, tmp);
                 return(list);
             } else {    /* ending node not a text node */
                 endLevel = level;       /* remember the level of the end node */
                 endFlag = 1;
                 /* last node - need to take care of properties + namespaces */
                 tmp = xmlDocCopyNode(cur, target, 2);
                 if (list == NULL) {
                     list = tmp;
                     listParent = cur->parent;
@@ skipping 198 matching lines @@
                 else {
                     xmlAddNextSibling(last,
                             xmlXIncludeCopyNode(ctxt, target, source,
                                                 set->nodeTab[i]));
                     if (last->next != NULL)
                         last = last->next;
                 }
             }
             break;
         }
+#ifdef LIBXML_XPTR_ENABLED
         case XPATH_LOCATIONSET: {
             xmlLocationSetPtr set = (xmlLocationSetPtr) obj->user;
             if (set == NULL)
                 return(NULL);
             for (i = 0;i < set->locNr;i++) {
                 if (last == NULL)
                     list = last = xmlXIncludeCopyXPointer(ctxt, target, source,
                                                           set->locTab[i]);
                 else
                     xmlAddNextSibling(last,
                             xmlXIncludeCopyXPointer(ctxt, target, source,
                                                     set->locTab[i]));
                 if (last != NULL) {
                     while (last->next != NULL)
                         last = last->next;
                 }
             }
             break;
         }
-#ifdef LIBXML_XPTR_ENABLED
         case XPATH_RANGE:
             return(xmlXIncludeCopyRange(ctxt, target, source, obj));
 #endif
         case XPATH_POINT:
             /* points are ignored in XInclude */
             break;
         default:
             break;
     }
     return(list);
@@ skipping 45 matching lines @@
     ret = xmlAddDocEntity(doc, ent->name, ent->etype, ent->ExternalID,
                           ent->SystemID, ent->content);
     if (ret != NULL) {
         if (ent->URI != NULL)
             ret->URI = xmlStrdup(ent->URI);
     } else {
         prev = xmlGetDocEntity(doc, ent->name);
         if (prev != NULL) {
             if (ent->etype != prev->etype)
                 goto error;
-        
+
             if ((ent->SystemID != NULL) && (prev->SystemID != NULL)) {
                 if (!xmlStrEqual(ent->SystemID, prev->SystemID))
                     goto error;
             } else if ((ent->ExternalID != NULL) &&
                        (prev->ExternalID != NULL)) {
                 if (!xmlStrEqual(ent->ExternalID, prev->ExternalID))
                     goto error;
             } else if ((ent->content != NULL) && (prev->content != NULL)) {
                 if (!xmlStrEqual(ent->content, prev->content))
                     goto error;
@@ skipping 79 matching lines @@
         }
     }
     return(0);
 }
 
 /**
  * xmlXIncludeLoadDoc:
  * @ctxt:  the XInclude context
  * @url:  the associated URL
  * @nr:  the xinclude node number
- * 
+ *
  * Load the document, and store the result in the XInclude context
  *
  * Returns 0 in case of success, -1 in case of failure
  */
 static int
 xmlXIncludeLoadDoc(xmlXIncludeCtxtPtr ctxt, const xmlChar *url, int nr) {
     xmlDocPtr doc;
     xmlURIPtr uri;
     xmlChar *URL;
     xmlChar *fragment = NULL;
     int i = 0;
 #ifdef LIBXML_XPTR_ENABLED
     int saveFlags;
 #endif
 
 #ifdef DEBUG_XINCLUDE
     xmlGenericError(xmlGenericErrorContext, "Loading doc %s:%d\n", url, nr);
 #endif
     /*
      * Check the URL and remove any fragment identifier
      */
     uri = xmlParseURI((const char *)url);
     if (uri == NULL) {
-        xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, 
+        xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
                        XML_XINCLUDE_HREF_URI,
                        "invalid value URI %s\n", url);
         return(-1);
     }
     if (uri->fragment != NULL) {
         fragment = (xmlChar *) uri->fragment;
         uri->fragment = NULL;
     }
     if ((ctxt->incTab != NULL) && (ctxt->incTab[nr] != NULL) &&
         (ctxt->incTab[nr]->fragment != NULL)) {
         if (fragment != NULL) xmlFree(fragment);
         fragment = xmlStrdup(ctxt->incTab[nr]->fragment);
     }
     URL = xmlSaveUri(uri);
     xmlFreeURI(uri);
     if (URL == NULL) {
         if (ctxt->incTab != NULL)
-            xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, 
+            xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
                            XML_XINCLUDE_HREF_URI,
                            "invalid value URI %s\n", url);
         else
             xmlXIncludeErr(ctxt, NULL,
                            XML_XINCLUDE_HREF_URI,
                            "invalid value URI %s\n", url);
         if (fragment != NULL)
             xmlFree(fragment);
         return(-1);
     }
@@ skipping 98 matching lines @@
          */
         if (doc == NULL)
         {
             /* Hopefully a DTD declaration won't be copied from
              * the same document */
             ctxt->incTab[nr]->inc = xmlCopyNodeList(ctxt->doc->children);
         } else {
             ctxt->incTab[nr]->inc = xmlXIncludeCopyNodeList(ctxt, ctxt->doc,
                                                        doc, doc->children);
         }
-    } 
+    }
 #ifdef LIBXML_XPTR_ENABLED
     else {
         /*
          * Computes the XPointer expression and make a copy used
          * as the replacement copy.
          */
         xmlXPathObjectPtr xptr;
         xmlXPathContextPtr xptrctxt;
         xmlNodeSetPtr set;
 
         if (doc == NULL) {
             xptrctxt = xmlXPtrNewContext(ctxt->doc, ctxt->incTab[nr]->ref,
                                          NULL);
         } else {
             xptrctxt = xmlXPtrNewContext(doc, NULL, NULL);
         }
         if (xptrctxt == NULL) {
-            xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, 
+            xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
                            XML_XINCLUDE_XPTR_FAILED,
                            "could not create XPointer context\n", NULL);
             xmlFree(URL);
             xmlFree(fragment);
             return(-1);
         }
         xptr = xmlXPtrEval(fragment, xptrctxt);
         if (xptr == NULL) {
             xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
                            XML_XINCLUDE_XPTR_FAILED,
                            "XPointer evaluation failed: #%s\n",
                            fragment);
             xmlXPathFreeContext(xptrctxt);
             xmlFree(URL);
             xmlFree(fragment);
             return(-1);
         }
         switch (xptr->type) {
             case XPATH_UNDEFINED:
             case XPATH_BOOLEAN:
             case XPATH_NUMBER:
             case XPATH_STRING:
             case XPATH_POINT:
             case XPATH_USERS:
             case XPATH_XSLT_TREE:
-                xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, 
+                xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
                                XML_XINCLUDE_XPTR_RESULT,
                                "XPointer is not a range: #%s\n",
                                fragment);
                 xmlXPathFreeContext(xptrctxt);
                 xmlFree(URL);
                 xmlFree(fragment);
                 return(-1);
             case XPATH_NODESET:
                 if ((xptr->nodesetval == NULL) ||
                     (xptr->nodesetval->nodeNr <= 0)) {
@@ skipping 21 matching lines @@
                     case XML_PI_NODE:
                     case XML_COMMENT_NODE:
                     case XML_DOCUMENT_NODE:
                     case XML_HTML_DOCUMENT_NODE:
 #ifdef LIBXML_DOCB_ENABLED
                     case XML_DOCB_DOCUMENT_NODE:
 #endif
                         continue;
 
                     case XML_ATTRIBUTE_NODE:
-                        xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, 
+                        xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
                                        XML_XINCLUDE_XPTR_RESULT,
                                        "XPointer selects an attribute: #%s\n",
                                        fragment);
                         set->nodeTab[i] = NULL;
                         continue;
                     case XML_NAMESPACE_DECL:
-                        xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, 
+                        xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
                                        XML_XINCLUDE_XPTR_RESULT,
                                        "XPointer selects a namespace: #%s\n",
                                        fragment);
                         set->nodeTab[i] = NULL;
                         continue;
                     case XML_DOCUMENT_TYPE_NODE:
                     case XML_DOCUMENT_FRAG_NODE:
                     case XML_NOTATION_NODE:
                     case XML_DTD_NODE:
                     case XML_ELEMENT_DECL:
                     case XML_ATTRIBUTE_DECL:
                     case XML_ENTITY_DECL:
                     case XML_XINCLUDE_START:
                     case XML_XINCLUDE_END:
-                        xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, 
+                        xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
                                        XML_XINCLUDE_XPTR_RESULT,
                                    "XPointer selects unexpected nodes: #%s\n",
                                        fragment);
                         set->nodeTab[i] = NULL;
                         set->nodeTab[i] = NULL;
                         continue; /* for */
                 }
             }
         }
         if (doc == NULL) {
             ctxt->incTab[nr]->xptr = xptr;
             ctxt->incTab[nr]->inc = NULL;
         } else {
             ctxt->incTab[nr]->inc =
                 xmlXIncludeCopyXPointer(ctxt, ctxt->doc, doc, xptr);
             xmlXPathFreeObject(xptr);
         }
         xmlXPathFreeContext(xptrctxt);
         xmlFree(fragment);
     }
 #endif
 
     /*
      * Do the xml:base fixup if needed
      */
-    if ((doc != NULL) && (URL != NULL) && (xmlStrchr(URL, (xmlChar) '/')) &&
+    if ((doc != NULL) && (URL != NULL) &&
         (!(ctxt->parseFlags & XML_PARSE_NOBASEFIX)) &&
         (!(doc->parseFlags & XML_PARSE_NOBASEFIX))) {
         xmlNodePtr node;
         xmlChar *base;
         xmlChar *curBase;
 
         /*
          * The base is only adjusted if "necessary", i.e. if the xinclude node
          * has a base specified, or the URL is relative
          */
         base = xmlGetNsProp(ctxt->incTab[nr]->ref, BAD_CAST "base",
                         XML_XML_NAMESPACE);
         if (base == NULL) {
             /*
              * No xml:base on the xinclude node, so we check whether the
              * URI base is different than (relative to) the context base
              */
             curBase = xmlBuildRelativeURI(URL, ctxt->base);
             if (curBase == NULL) {      /* Error return */
-                xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, 
+                xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
                        XML_XINCLUDE_HREF_URI,
                        "trying to build relative URI from %s\n", URL);
             } else {
                 /* If the URI doesn't contain a slash, it's not relative */
                 if (!xmlStrchr(curBase, (xmlChar) '/'))
                     xmlFree(curBase);
                 else
                     base = curBase;
             }
         }
@@ skipping 20 matching lines @@
                              * set, then relativise it if necessary
                              */
                             xmlChar *xmlBase;
                             xmlBase = xmlGetNsProp(node,
                                             BAD_CAST "base",
                                             XML_XML_NAMESPACE);
                             if (xmlBase != NULL) {
                                 xmlChar *relBase;
                                 relBase = xmlBuildURI(xmlBase, base);
                                 if (relBase == NULL) { /* error */
-                                    xmlXIncludeErr(ctxt, 
+                                    xmlXIncludeErr(ctxt,
                                                 ctxt->incTab[nr]->ref,
                                                 XML_XINCLUDE_HREF_URI,
                                         "trying to rebuild base from %s\n",
                                                 xmlBase);
                                 } else {
                                     xmlNodeSetBase(node, relBase);
                                     xmlFree(relBase);
                                 }
                                 xmlFree(xmlBase);
                             }
@@ skipping 16 matching lines @@
     }
     xmlFree(URL);
     return(0);
 }
 
 /**
  * xmlXIncludeLoadTxt:
  * @ctxt:  the XInclude context
  * @url:  the associated URL
  * @nr:  the xinclude node number
- * 
+ *
  * Load the content, and store the result in the XInclude context
  *
  * Returns 0 in case of success, -1 in case of failure
  */
 static int
 xmlXIncludeLoadTxt(xmlXIncludeCtxtPtr ctxt, const xmlChar *url, int nr) {
     xmlParserInputBufferPtr buf;
     xmlNodePtr node;
     xmlURIPtr uri;
     xmlChar *URL;
     int i;
     xmlChar *encoding = NULL;
     xmlCharEncoding enc = (xmlCharEncoding) 0;
+    xmlParserCtxtPtr pctxt;
+    xmlParserInputPtr inputStream;
+    int xinclude_multibyte_fallback_used = 0;
 
     /*
      * Check the URL and remove any fragment identifier
      */
     uri = xmlParseURI((const char *)url);
     if (uri == NULL) {
         xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, XML_XINCLUDE_HREF_URI,
                        "invalid value URI %s\n", url);
         return(-1);
     }
@@ skipping 10 matching lines @@
         xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, XML_XINCLUDE_HREF_URI,
                        "invalid value URI %s\n", url);
         return(-1);
     }
 
     /*
      * Handling of references to the local document are done
      * directly through ctxt->doc.
      */
     if (URL[0] == 0) {
-        xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, 
+        xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
                        XML_XINCLUDE_TEXT_DOCUMENT,
                        "text serialization of document not available\n", NULL);
         xmlFree(URL);
         return(-1);
     }
 
     /*
      * Prevent reloading twice the document.
      */
     for (i = 0; i < ctxt->txtNr; i++) {
@@ skipping 23 matching lines @@
             xmlFree(encoding);
             xmlFree(URL);
             return(-1);
         }
         xmlFree(encoding);
     }
 
     /*
      * Load it.
      */
-    buf = xmlParserInputBufferCreateFilename((const char *)URL, enc);
-    if (buf == NULL) {
+    pctxt = xmlNewParserCtxt();
+    inputStream = xmlLoadExternalEntity((const char*)URL, NULL, pctxt);
+    if(inputStream == NULL) {
+        xmlFreeParserCtxt(pctxt);
         xmlFree(URL);
         return(-1);
     }
+    buf = inputStream->buf;
+    if (buf == NULL) {
+        xmlFreeInputStream (inputStream);
+        xmlFreeParserCtxt(pctxt);
+        xmlFree(URL);
+        return(-1);
+    }
+    if (buf->encoder)
+        xmlCharEncCloseFunc(buf->encoder);
+    buf->encoder = xmlGetCharEncodingHandler(enc);
     node = xmlNewText(NULL);
 
     /*
      * Scan all chars from the resource and add the to the node
      */
+xinclude_multibyte_fallback:
     while (xmlParserInputBufferRead(buf, 128) > 0) {
         int len;
         const xmlChar *content;
 
-        content = xmlBufferContent(buf->buffer);
-        len = xmlBufferLength(buf->buffer);
+        content = xmlBufContent(buf->buffer);
+        len = xmlBufLength(buf->buffer);
         for (i = 0;i < len;) {
             int cur;
             int l;
 
             cur = xmlStringCurrentChar(NULL, &content[i], &l);
             if (!IS_CHAR(cur)) {
-                xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
-                               XML_XINCLUDE_INVALID_CHAR,
-                               "%s contains invalid char\n", URL);
-                xmlFreeParserInputBuffer(buf);
-                xmlFree(URL);
-                return(-1);
+                /* Handle splitted multibyte char at buffer boundary */
+                if (((len - i) < 4) && (!xinclude_multibyte_fallback_used)) {
+                    xinclude_multibyte_fallback_used = 1;
+                    xmlBufShrink(buf->buffer, i);
+                    goto xinclude_multibyte_fallback;
+                } else {
+                    xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
+                                   XML_XINCLUDE_INVALID_CHAR,
+                                   "%s contains invalid char\n", URL);
+                    xmlFreeParserInputBuffer(buf);
+                    xmlFree(URL);
+                    return(-1);
+                }
             } else {
+                xinclude_multibyte_fallback_used = 0;
                 xmlNodeAddContentLen(node, &content[i], l);
             }
             i += l;
         }
-        xmlBufferShrink(buf->buffer, len);
+        xmlBufShrink(buf->buffer, len);
     }
-    xmlFreeParserInputBuffer(buf);
+    xmlFreeParserCtxt(pctxt);
     xmlXIncludeAddTxt(ctxt, node, URL);
+    xmlFreeInputStream(inputStream);
 
 loaded:
     /*
      * Add the element as the replacement copy.
      */
     ctxt->incTab[nr]->inc = node;
     xmlFree(URL);
     return(0);
 }
 
 /**
  * xmlXIncludeLoadFallback:
  * @ctxt:  the XInclude context
  * @fallback:  the fallback node
  * @nr:  the xinclude node number
- * 
+ *
  * Load the content of the fallback node, and store the result
  * in the XInclude context
  *
  * Returns 0 in case of success, -1 in case of failure
  */
 static int
 xmlXIncludeLoadFallback(xmlXIncludeCtxtPtr ctxt, xmlNodePtr fallback, int nr) {
     xmlXIncludeCtxtPtr newctxt;
     int ret = 0;
-    
-    if ((fallback == NULL) || (ctxt == NULL))
+
+    if ((fallback == NULL) || (fallback->type == XML_NAMESPACE_DECL) ||
+        (ctxt == NULL))
         return(-1);
     if (fallback->children != NULL) {
         /*
          * It's possible that the fallback also has 'includes'
          * (Bug 129969), so we re-process the fallback just in case
          */
         newctxt = xmlXIncludeNewContext(ctxt->doc);
         if (newctxt == NULL)
             return (-1);
         newctxt->_private = ctxt->_private;
@@ skipping 64 matching lines @@
     cur = ctxt->incTab[nr]->ref;
     if (cur == NULL)
         return(-1);
 
     /*
      * read the attributes
      */
     href = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_HREF);
     if (href == NULL) {
         href = xmlStrdup(BAD_CAST ""); /* @@@@ href is now optional */
-        if (href == NULL) 
+        if (href == NULL)
             return(-1);
     }
     parse = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_PARSE);
     if (parse != NULL) {
         if (xmlStrEqual(parse, XINCLUDE_PARSE_XML))
             xml = 1;
         else if (xmlStrEqual(parse, XINCLUDE_PARSE_TEXT))
             xml = 0;
         else {
             xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
@@ skipping 24 matching lines @@
          */
         escbase = xmlURIEscape(base);
         eschref = xmlURIEscape(href);
         URI = xmlBuildURI(eschref, escbase);
         if (escbase != NULL)
             xmlFree(escbase);
         if (eschref != NULL)
             xmlFree(eschref);
     }
     if (URI == NULL) {
-        xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, 
+        xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
                        XML_XINCLUDE_HREF_URI, "failed build URL\n", NULL);
         if (parse != NULL)
             xmlFree(parse);
         if (href != NULL)
             xmlFree(href);
         if (base != NULL)
             xmlFree(base);
         return(-1);
     }
 #ifdef DEBUG_XINCLUDE
@@ skipping 12 matching lines @@
         ret = xmlXIncludeLoadDoc(ctxt, URI, nr);
         /* xmlXIncludeGetFragment(ctxt, cur, URI); */
     } else {
         ret = xmlXIncludeLoadTxt(ctxt, URI, nr);
     }
 
     /*
      * Restore the original base before checking for fallback
      */
     ctxt->base = oldBase;
-    
+
     if (ret < 0) {
         xmlNodePtr children;
 
         /*
          * Time to try a fallback if availble
          */
 #ifdef DEBUG_XINCLUDE
         xmlGenericError(xmlGenericErrorContext, "error looking for fallback\n");
 #endif
         children = cur->children;
         while (children != NULL) {
             if ((children->type == XML_ELEMENT_NODE) &&
                 (children->ns != NULL) &&
                 (xmlStrEqual(children->name, XINCLUDE_FALLBACK)) &&
                 ((xmlStrEqual(children->ns->href, XINCLUDE_NS)) ||
                  (xmlStrEqual(children->ns->href, XINCLUDE_OLD_NS)))) {
                 ret = xmlXIncludeLoadFallback(ctxt, children, nr);
-                if (ret == 0) 
+                if (ret == 0)
                     break;
             }
             children = children->next;
         }
     }
     if (ret < 0) {
-        xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, 
+        xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
                        XML_XINCLUDE_NO_FALLBACK,
                        "could not load %s, and no fallback was found\n",
                        URI);
     }
 
     /*
      * Cleanup
      */
     if (URI != NULL)
         xmlFree(URI);
@@ skipping 17 matching lines @@
  */
 static int
 xmlXIncludeIncludeNode(xmlXIncludeCtxtPtr ctxt, int nr) {
     xmlNodePtr cur, end, list, tmp;
 
     if (ctxt == NULL)
         return(-1);
     if ((nr < 0) || (nr >= ctxt->incNr))
         return(-1);
     cur = ctxt->incTab[nr]->ref;
-    if (cur == NULL)
+    if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL))
         return(-1);
 
     /*
      * If we stored an XPointer a late computation may be needed
      */
     if ((ctxt->incTab[nr]->inc == NULL) &&
         (ctxt->incTab[nr]->xptr != NULL)) {
         ctxt->incTab[nr]->inc =
             xmlXIncludeCopyXPointer(ctxt, ctxt->doc, ctxt->doc,
                                     ctxt->incTab[nr]->xptr);
@@ skipping 10 matching lines @@
         (cur->parent->type != XML_ELEMENT_NODE)) {
         int nb_elem = 0;
 
         tmp = list;
         while (tmp != NULL) {
             if (tmp->type == XML_ELEMENT_NODE)
                 nb_elem++;
             tmp = tmp->next;
         }
         if (nb_elem > 1) {
-            xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, 
+            xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
                            XML_XINCLUDE_MULTIPLE_ROOT,
                        "XInclude error: would result in multiple root nodes\n",
                            NULL);
             return(-1);
         }
     }
 
     if (ctxt->parseFlags & XML_PARSE_NOXINCNODE) {
         /*
          * Add the list of nodes
@@ skipping 26 matching lines @@
          * Add the list of nodes
          */
         while (list != NULL) {
             cur = list;
             list = list->next;
 
             xmlAddPrevSibling(end, cur);
         }
     }
 
-    
+
     return(0);
 }
 
 /**
  * xmlXIncludeTestNode:
  * @ctxt: the XInclude processing context
  * @node: an XInclude node
  *
  * test if the node is an XInclude node
  *
@@ skipping 76 matching lines @@
  *
  * Returns 0 if no substitution were done, -1 if some processing failed
  *    or the number of substitutions done.
  */
 static int
 xmlXIncludeDoProcess(xmlXIncludeCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr tree) {
     xmlNodePtr cur;
     int ret = 0;
     int i, start;
 
-    if ((doc == NULL) || (tree == NULL))
+    if ((doc == NULL) || (tree == NULL) || (tree->type == XML_NAMESPACE_DECL))
         return(-1);
     if (ctxt == NULL)
         return(-1);
 
     if (doc->URL != NULL) {
         ret = xmlXIncludeURLPush(ctxt, doc->URL);
         if (ret < 0)
             return(-1);
     }
     start = ctxt->incNr;
@@ skipping 93 matching lines @@
  *
  * Returns 0 if no substitution were done, -1 if some processing failed
  *    or the number of substitutions done.
  */
 
 int
 xmlXIncludeProcessTreeFlagsData(xmlNodePtr tree, int flags, void *data) {
     xmlXIncludeCtxtPtr ctxt;
     int ret = 0;
 
-    if ((tree == NULL) || (tree->doc == NULL))
+    if ((tree == NULL) || (tree->type == XML_NAMESPACE_DECL) ||
+        (tree->doc == NULL))
         return(-1);
 
     ctxt = xmlXIncludeNewContext(tree->doc);
     if (ctxt == NULL)
         return(-1);
     ctxt->_private = data;
     ctxt->base = xmlStrdup((xmlChar *)tree->doc->URL);
     xmlXIncludeSetFlags(ctxt, flags);
     ret = xmlXIncludeDoProcess(ctxt, tree->doc, tree);
     if ((ret >= 0) && (ctxt->nbErrors > 0))
@@ skipping 64 matching lines @@
  * Implement the XInclude substitution for the given subtree
  *
  * Returns 0 if no substitution were done, -1 if some processing failed
  *    or the number of substitutions done.
  */
 int
 xmlXIncludeProcessTreeFlags(xmlNodePtr tree, int flags) {
     xmlXIncludeCtxtPtr ctxt;
     int ret = 0;
 
-    if ((tree == NULL) || (tree->doc == NULL))
+    if ((tree == NULL) || (tree->type == XML_NAMESPACE_DECL) ||
+        (tree->doc == NULL))
         return(-1);
     ctxt = xmlXIncludeNewContext(tree->doc);
     if (ctxt == NULL)
         return(-1);
     ctxt->base = xmlNodeGetBase(tree->doc, tree);
     xmlXIncludeSetFlags(ctxt, flags);
     ret = xmlXIncludeDoProcess(ctxt, tree->doc, tree);
     if ((ret >= 0) && (ctxt->nbErrors > 0))
         ret = -1;
 
@@ skipping 23 matching lines @@
  * Implement the XInclude substitution for the given subtree reusing
  * the informations and data coming from the given context.
  *
  * Returns 0 if no substitution were done, -1 if some processing failed
  *    or the number of substitutions done.
  */
 int
 xmlXIncludeProcessNode(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node) {
     int ret = 0;
 
-    if ((node == NULL) || (node->doc == NULL) || (ctxt == NULL))
+    if ((node == NULL) || (node->type == XML_NAMESPACE_DECL) ||
+        (node->doc == NULL) || (ctxt == NULL))
         return(-1);
     ret = xmlXIncludeDoProcess(ctxt, node->doc, node);
     if ((ret >= 0) && (ctxt->nbErrors > 0))
         ret = -1;
     return(ret);
 }
 
 #else /* !LIBXML_XINCLUDE_ENABLED */
 #endif
 #define bottom_xinclude
 #include "elfgcchack.h"