Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxml/src/uri.c

 /**
- * uri.c: set of generic URI related routines 
+ * uri.c: set of generic URI related routines
  *
  * Reference: RFCs 3986, 2732 and 2373
  *
  * 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/uri.h>
 #include <libxml/globals.h>
 #include <libxml/xmlerror.h>
 
+/**
+ * MAX_URI_LENGTH:
+ *
+ * The definition of the URI regexp in the above RFC has no size limit
+ * In practice they are usually relativey short except for the
+ * data URI scheme as defined in RFC 2397. Even for data URI the usual
+ * maximum size before hitting random practical limits is around 64 KB
+ * and 4KB is usually a maximum admitted limit for proper operations.
+ * The value below is more a security limit than anything else and
+ * really should never be hit by 'normal' operations
+ * Set to 1 MByte in 2012, this is only enforced on output
+ */
+#define MAX_URI_LENGTH 1024 * 1024
+
+static void
+xmlURIErrMemory(const char *extra)
+{
+    if (extra)
+        __xmlRaiseError(NULL, NULL, NULL,
+                        NULL, NULL, XML_FROM_URI,
+                        XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0,
+                        extra, NULL, NULL, 0, 0,
+                        "Memory allocation failed : %s\n", extra);
+    else
+        __xmlRaiseError(NULL, NULL, NULL,
+                        NULL, NULL, XML_FROM_URI,
+                        XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0,
+                        NULL, NULL, NULL, 0, 0,
+                        "Memory allocation failed\n");
+}
+
 static void xmlCleanURI(xmlURIPtr uri);
 
 /*
  * Old rule from 2396 used in legacy handling code
  * alpha    = lowalpha | upalpha
  */
 #define IS_ALPHA(x) (IS_LOWALPHA(x) || IS_UPALPHA(x))
 
 
 /*
@@ skipping 89 matching lines @@
         ((*(p) >= 'A') && (*(p) <= 'F')))
 
 /*
  *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
  *                     / "*" / "+" / "," / ";" / "="
  */
 #define ISA_SUB_DELIM(p)                                                \
       (((*(p) == '!')) || ((*(p) == '$')) || ((*(p) == '&')) ||         \
        ((*(p) == '(')) || ((*(p) == ')')) || ((*(p) == '*')) ||         \
        ((*(p) == '+')) || ((*(p) == ',')) || ((*(p) == ';')) ||         \
-       ((*(p) == '=')))
+       ((*(p) == '=')) || ((*(p) == '\'')))
 
 /*
  *    gen-delims    = ":" / "/" / "?" / "#" / "[" / "]" / "@"
  */
 #define ISA_GEN_DELIM(p)                                                \
       (((*(p) == ':')) || ((*(p) == '/')) || ((*(p) == '?')) ||         \
        ((*(p) == '#')) || ((*(p) == '[')) || ((*(p) == ']')) ||         \
        ((*(p) == '@')))
 
 /*
@@ skipping 580 matching lines @@
 {
     const char *cur;
     int ret;
 
     cur = *str;
 
     if ((*cur == '/') && (*(cur + 1) == '/')) {
         cur += 2;
         ret = xmlParse3986Authority(uri, &cur);
         if (ret != 0) return(ret);
+        if (uri->server == NULL)
+            uri->port = -1;
         ret = xmlParse3986PathAbEmpty(uri, &cur);
         if (ret != 0) return(ret);
         *str = cur;
         return(0);
     } else if (*cur == '/') {
         ret = xmlParse3986PathAbsolute(uri, &cur);
         if (ret != 0) return(ret);
     } else if (ISA_PCHAR(cur)) {
         ret = xmlParse3986PathRootless(uri, &cur);
         if (ret != 0) return(ret);
@@ skipping 232 matching lines @@
  * Simply creates an empty xmlURI
  *
  * Returns the new structure or NULL in case of error
  */
 xmlURIPtr
 xmlCreateURI(void) {
     xmlURIPtr ret;
 
     ret = (xmlURIPtr) xmlMalloc(sizeof(xmlURI));
     if (ret == NULL) {
-        xmlGenericError(xmlGenericErrorContext,
-                "xmlCreateURI: out of memory\n");
+        xmlURIErrMemory("creating URI structure\n");
         return(NULL);
     }
     memset(ret, 0, sizeof(xmlURI));
     return(ret);
 }
 
 /**
+ * xmlSaveUriRealloc:
+ *
+ * Function to handle properly a reallocation when saving an URI
+ * Also imposes some limit on the length of an URI string output
+ */
+static xmlChar *
+xmlSaveUriRealloc(xmlChar *ret, int *max) {
+    xmlChar *temp;
+    int tmp;
+
+    if (*max > MAX_URI_LENGTH) {
+        xmlURIErrMemory("reaching arbitrary MAX_URI_LENGTH limit\n");
+        return(NULL);
+    }
+    tmp = *max * 2;
+    temp = (xmlChar *) xmlRealloc(ret, (tmp + 1));
+    if (temp == NULL) {
+        xmlURIErrMemory("saving URI\n");
+        return(NULL);
+    }
+    *max = tmp;
+    return(temp);
+}
+
+/**
  * xmlSaveUri:
  * @uri:  pointer to an xmlURI
  *
  * Save the URI as an escaped string
  *
  * Returns a new string (to be deallocated by caller)
  */
 xmlChar *
 xmlSaveUri(xmlURIPtr uri) {
     xmlChar *ret = NULL;
     xmlChar *temp;
     const char *p;
     int len;
     int max;
 
     if (uri == NULL) return(NULL);
 
 
     max = 80;
     ret = (xmlChar *) xmlMallocAtomic((max + 1) * sizeof(xmlChar));
     if (ret == NULL) {
-        xmlGenericError(xmlGenericErrorContext,
-                "xmlSaveUri: out of memory\n");
+        xmlURIErrMemory("saving URI\n");
         return(NULL);
     }
     len = 0;
 
     if (uri->scheme != NULL) {
         p = uri->scheme;
         while (*p != 0) {
             if (len >= max) {
-                max *= 2;
-                temp = (xmlChar *) xmlRealloc(ret, (max + 1) * sizeof(xmlChar));
-                if (temp == NULL) {
-                    xmlGenericError(xmlGenericErrorContext,
-                            "xmlSaveUri: out of memory\n");
-                    xmlFree(ret);
-                    return(NULL);
-                }
+                temp = xmlSaveUriRealloc(ret, &max);
+                if (temp == NULL) goto mem_error;
                 ret = temp;
             }
             ret[len++] = *p++;
         }
         if (len >= max) {
-            max *= 2;
-            temp = (xmlChar *) xmlRealloc(ret, (max + 1) * sizeof(xmlChar));
-            if (temp == NULL) {
-                xmlGenericError(xmlGenericErrorContext,
-                        "xmlSaveUri: out of memory\n");
-                xmlFree(ret);
-                return(NULL);
-            }
-            ret = temp;
+            temp = xmlSaveUriRealloc(ret, &max);
+            if (temp == NULL) goto mem_error;
+            ret = temp;
         }
         ret[len++] = ':';
     }
     if (uri->opaque != NULL) {
         p = uri->opaque;
         while (*p != 0) {
             if (len + 3 >= max) {
-                max *= 2;
-                temp = (xmlChar *) xmlRealloc(ret, (max + 1) * sizeof(xmlChar));
-                if (temp == NULL) {
-                    xmlGenericError(xmlGenericErrorContext,
-                            "xmlSaveUri: out of memory\n");
-                    xmlFree(ret);
-                    return(NULL);
-                }
-                ret = temp;
+                temp = xmlSaveUriRealloc(ret, &max);
+                if (temp == NULL) goto mem_error;
+                ret = temp;
             }
             if (IS_RESERVED(*(p)) || IS_UNRESERVED(*(p)))
                 ret[len++] = *p++;
             else {
                 int val = *(unsigned char *)p++;
                 int hi = val / 0x10, lo = val % 0x10;
                 ret[len++] = '%';
                 ret[len++] = hi + (hi > 9? 'A'-10 : '0');
                 ret[len++] = lo + (lo > 9? 'A'-10 : '0');
             }
         }
     } else {
-        if (uri->server != NULL) {
+        if ((uri->server != NULL) || (uri->port == -1)) {
             if (len + 3 >= max) {
-                max *= 2;
-                temp = (xmlChar *) xmlRealloc(ret, (max + 1) * sizeof(xmlChar));
-                if (temp == NULL) {
-                    xmlGenericError(xmlGenericErrorContext,
-                            "xmlSaveUri: out of memory\n");
-                  xmlFree(ret);  
-                    return(NULL);
-                }
-                ret = temp;
+                temp = xmlSaveUriRealloc(ret, &max);
+                if (temp == NULL) goto mem_error;
+                ret = temp;
             }
             ret[len++] = '/';
             ret[len++] = '/';
             if (uri->user != NULL) {
                 p = uri->user;
                 while (*p != 0) {
                     if (len + 3 >= max) {
-                        max *= 2;
-                        temp = (xmlChar *) xmlRealloc(ret,
-                                (max + 1) * sizeof(xmlChar));
-                        if (temp == NULL) {
-                            xmlGenericError(xmlGenericErrorContext,
-                                    "xmlSaveUri: out of memory\n");
-                            xmlFree(ret);
-                            return(NULL);
-                        }
-                        ret = temp;
+                        temp = xmlSaveUriRealloc(ret, &max);
+                        if (temp == NULL) goto mem_error;
+                        ret = temp;
                     }
                     if ((IS_UNRESERVED(*(p))) ||
                         ((*(p) == ';')) || ((*(p) == ':')) ||
                         ((*(p) == '&')) || ((*(p) == '=')) ||
                         ((*(p) == '+')) || ((*(p) == '$')) ||
                         ((*(p) == ',')))
                         ret[len++] = *p++;
                     else {
                         int val = *(unsigned char *)p++;
                         int hi = val / 0x10, lo = val % 0x10;
                         ret[len++] = '%';
                         ret[len++] = hi + (hi > 9? 'A'-10 : '0');
                         ret[len++] = lo + (lo > 9? 'A'-10 : '0');
                     }
                 }
                 if (len + 3 >= max) {
-                    max *= 2;
-                    temp = (xmlChar *) xmlRealloc(ret,
-                            (max + 1) * sizeof(xmlChar));
-                    if (temp == NULL) {
-                        xmlGenericError(xmlGenericErrorContext,
-                                "xmlSaveUri: out of memory\n");
-                        xmlFree(ret);
-                        return(NULL);
-                    }
-                    ret = temp;
+                    temp = xmlSaveUriRealloc(ret, &max);
+                    if (temp == NULL) goto mem_error;
+                    ret = temp;
                 }
                 ret[len++] = '@';
             }
-            p = uri->server;
-            while (*p != 0) {
-                if (len >= max) {
-                    max *= 2;
-                    temp = (xmlChar *) xmlRealloc(ret,
-                            (max + 1) * sizeof(xmlChar));
-                    if (temp == NULL) {
-                        xmlGenericError(xmlGenericErrorContext,
-                                "xmlSaveUri: out of memory\n");
-                        xmlFree(ret);
-                        return(NULL);
+            if (uri->server != NULL) {
+                p = uri->server;
+                while (*p != 0) {
+                    if (len >= max) {
+                        temp = xmlSaveUriRealloc(ret, &max);
+                        if (temp == NULL) goto mem_error;
+                        ret = temp;
                     }
-                    ret = temp;
+                    ret[len++] = *p++;
                 }
-                ret[len++] = *p++;
-            }
-            if (uri->port > 0) {
-                if (len + 10 >= max) {
-                    max *= 2;
-                    temp = (xmlChar *) xmlRealloc(ret,
-                            (max + 1) * sizeof(xmlChar));
-                    if (temp == NULL) {
-                        xmlGenericError(xmlGenericErrorContext,
-                                "xmlSaveUri: out of memory\n");
-                     xmlFree(ret);
-                        return(NULL);
+                if (uri->port > 0) {
+                    if (len + 10 >= max) {
+                        temp = xmlSaveUriRealloc(ret, &max);
+                        if (temp == NULL) goto mem_error;
+                        ret = temp;
                     }
-                    ret = temp;
+                    len += snprintf((char *) &ret[len], max - len, ":%d", uri->port);
                 }
-                len += snprintf((char *) &ret[len], max - len, ":%d", uri->port);
             }
         } else if (uri->authority != NULL) {
             if (len + 3 >= max) {
-                max *= 2;
-                temp = (xmlChar *) xmlRealloc(ret,
-                        (max + 1) * sizeof(xmlChar));
-                if (temp == NULL) {
-                        xmlGenericError(xmlGenericErrorContext,
-                                "xmlSaveUri: out of memory\n");
-                     xmlFree(ret);
-                        return(NULL);
-                    }
-                    ret = temp;
+                temp = xmlSaveUriRealloc(ret, &max);
+                if (temp == NULL) goto mem_error;
+                ret = temp;
             }
             ret[len++] = '/';
             ret[len++] = '/';
             p = uri->authority;
             while (*p != 0) {
                 if (len + 3 >= max) {
-                    max *= 2;
-                    temp = (xmlChar *) xmlRealloc(ret,
-                            (max + 1) * sizeof(xmlChar));
-                    if (temp == NULL) {
-                        xmlGenericError(xmlGenericErrorContext,
-                                "xmlSaveUri: out of memory\n");
-                     xmlFree(ret);
-                        return(NULL);
-                    }
-                    ret = temp;
+                    temp = xmlSaveUriRealloc(ret, &max);
+                    if (temp == NULL) goto mem_error;
+                    ret = temp;
                 }
                 if ((IS_UNRESERVED(*(p))) ||
                     ((*(p) == '$')) || ((*(p) == ',')) || ((*(p) == ';')) ||
                     ((*(p) == ':')) || ((*(p) == '@')) || ((*(p) == '&')) ||
                     ((*(p) == '=')) || ((*(p) == '+')))
                     ret[len++] = *p++;
                 else {
                     int val = *(unsigned char *)p++;
                     int hi = val / 0x10, lo = val % 0x10;
                     ret[len++] = '%';
                     ret[len++] = hi + (hi > 9? 'A'-10 : '0');
                     ret[len++] = lo + (lo > 9? 'A'-10 : '0');
                 }
             }
         } else if (uri->scheme != NULL) {
             if (len + 3 >= max) {
-                max *= 2;
-                temp = (xmlChar *) xmlRealloc(ret,
-                        (max + 1) * sizeof(xmlChar));
-                if (temp == NULL) {
-                        xmlGenericError(xmlGenericErrorContext,
-                                "xmlSaveUri: out of memory\n");
-                     xmlFree(ret);
-                        return(NULL);
-                    }
-                    ret = temp;
+                temp = xmlSaveUriRealloc(ret, &max);
+                if (temp == NULL) goto mem_error;
+                ret = temp;
             }
-            ret[len++] = '/';
-            ret[len++] = '/';
         }
         if (uri->path != NULL) {
             p = uri->path;
             /*
              * the colon in file:///d: should not be escaped or
              * Windows accesses fail later.
              */
             if ((uri->scheme != NULL) &&
                 (p[0] == '/') &&
                 (((p[1] >= 'a') && (p[1] <= 'z')) ||
                  ((p[1] >= 'A') && (p[1] <= 'Z'))) &&
                 (p[2] == ':') &&
                 (xmlStrEqual(BAD_CAST uri->scheme, BAD_CAST "file"))) {
                 if (len + 3 >= max) {
-                    max *= 2;
-                    ret = (xmlChar *) xmlRealloc(ret,
-                            (max + 1) * sizeof(xmlChar));
-                    if (ret == NULL) {
-                        xmlGenericError(xmlGenericErrorContext,
-                                "xmlSaveUri: out of memory\n");
-                        return(NULL);
-                    }
+                    temp = xmlSaveUriRealloc(ret, &max);
+                    if (temp == NULL) goto mem_error;
+                    ret = temp;
                 }
                 ret[len++] = *p++;
                 ret[len++] = *p++;
                 ret[len++] = *p++;
             }
             while (*p != 0) {
                 if (len + 3 >= max) {
-                    max *= 2;
-                    temp = (xmlChar *) xmlRealloc(ret,
-                            (max + 1) * sizeof(xmlChar));
-                    if (temp == NULL) {
-                        xmlGenericError(xmlGenericErrorContext,
-                                "xmlSaveUri: out of memory\n");
-                     xmlFree(ret);
-                        return(NULL);
-                    }
-                    ret = temp;
+                    temp = xmlSaveUriRealloc(ret, &max);
+                    if (temp == NULL) goto mem_error;
+                    ret = temp;
                 }
                 if ((IS_UNRESERVED(*(p))) || ((*(p) == '/')) ||
                     ((*(p) == ';')) || ((*(p) == '@')) || ((*(p) == '&')) ||
                     ((*(p) == '=')) || ((*(p) == '+')) || ((*(p) == '$')) ||
                     ((*(p) == ',')))
                     ret[len++] = *p++;
                 else {
                     int val = *(unsigned char *)p++;
                     int hi = val / 0x10, lo = val % 0x10;
                     ret[len++] = '%';
                     ret[len++] = hi + (hi > 9? 'A'-10 : '0');
                     ret[len++] = lo + (lo > 9? 'A'-10 : '0');
                 }
             }
         }
         if (uri->query_raw != NULL) {
             if (len + 1 >= max) {
-                max *= 2;
-                temp = (xmlChar *) xmlRealloc(ret,
-                        (max + 1) * sizeof(xmlChar));
-                if (temp == NULL) {
-                        xmlGenericError(xmlGenericErrorContext,
-                                "xmlSaveUri: out of memory\n");
-                     xmlFree(ret);
-                        return(NULL);
-                    }
-                    ret = temp;
+                temp = xmlSaveUriRealloc(ret, &max);
+                if (temp == NULL) goto mem_error;
+                ret = temp;
             }
             ret[len++] = '?';
             p = uri->query_raw;
             while (*p != 0) {
                 if (len + 1 >= max) {
-                    max *= 2;
-                    temp = (xmlChar *) xmlRealloc(ret,
-                            (max + 1) * sizeof(xmlChar));
-                    if (temp == NULL) {
-                        xmlGenericError(xmlGenericErrorContext,
-                                "xmlSaveUri: out of memory\n");
-                     xmlFree(ret);
-                        return(NULL);
-                    }
-                    ret = temp;
+                    temp = xmlSaveUriRealloc(ret, &max);
+                    if (temp == NULL) goto mem_error;
+                    ret = temp;
                 }
                 ret[len++] = *p++;
             }
         } else if (uri->query != NULL) {
             if (len + 3 >= max) {
-                max *= 2;
-                temp = (xmlChar *) xmlRealloc(ret,
-                        (max + 1) * sizeof(xmlChar));
-                if (temp == NULL) {
-                        xmlGenericError(xmlGenericErrorContext,
-                                "xmlSaveUri: out of memory\n");
-                     xmlFree(ret);
-                        return(NULL);
-                    }
-                    ret = temp;
+                temp = xmlSaveUriRealloc(ret, &max);
+                if (temp == NULL) goto mem_error;
+                ret = temp;
             }
             ret[len++] = '?';
             p = uri->query;
             while (*p != 0) {
                 if (len + 3 >= max) {
-                    max *= 2;
-                    temp = (xmlChar *) xmlRealloc(ret,
-                            (max + 1) * sizeof(xmlChar));
-                    if (temp == NULL) {
-                        xmlGenericError(xmlGenericErrorContext,
-                                "xmlSaveUri: out of memory\n");
-                     xmlFree(ret);
-                        return(NULL);
-                    }
-                    ret = temp;
+                    temp = xmlSaveUriRealloc(ret, &max);
+                    if (temp == NULL) goto mem_error;
+                    ret = temp;
                 }
-                if ((IS_UNRESERVED(*(p))) || (IS_RESERVED(*(p)))) 
+                if ((IS_UNRESERVED(*(p))) || (IS_RESERVED(*(p))))
                     ret[len++] = *p++;
                 else {
                     int val = *(unsigned char *)p++;
                     int hi = val / 0x10, lo = val % 0x10;
                     ret[len++] = '%';
                     ret[len++] = hi + (hi > 9? 'A'-10 : '0');
                     ret[len++] = lo + (lo > 9? 'A'-10 : '0');
                 }
             }
         }
     }
     if (uri->fragment != NULL) {
         if (len + 3 >= max) {
-            max *= 2;
-            temp = (xmlChar *) xmlRealloc(ret,
-                    (max + 1) * sizeof(xmlChar));
-            if (temp == NULL) {
-                        xmlGenericError(xmlGenericErrorContext,
-                                "xmlSaveUri: out of memory\n");
-                     xmlFree(ret);
-                        return(NULL);
-                    }
-                    ret = temp;
+            temp = xmlSaveUriRealloc(ret, &max);
+            if (temp == NULL) goto mem_error;
+            ret = temp;
         }
         ret[len++] = '#';
         p = uri->fragment;
         while (*p != 0) {
             if (len + 3 >= max) {
-                max *= 2;
-                temp = (xmlChar *) xmlRealloc(ret,
-                        (max + 1) * sizeof(xmlChar));
-                if (temp == NULL) {
-                        xmlGenericError(xmlGenericErrorContext,
-                                "xmlSaveUri: out of memory\n");
-                     xmlFree(ret);
-                        return(NULL);
-                    }
-                    ret = temp;
+                temp = xmlSaveUriRealloc(ret, &max);
+                if (temp == NULL) goto mem_error;
+                ret = temp;
             }
-            if ((IS_UNRESERVED(*(p))) || (IS_RESERVED(*(p)))) 
+            if ((IS_UNRESERVED(*(p))) || (IS_RESERVED(*(p))))
                 ret[len++] = *p++;
             else {
                 int val = *(unsigned char *)p++;
                 int hi = val / 0x10, lo = val % 0x10;
                 ret[len++] = '%';
                 ret[len++] = hi + (hi > 9? 'A'-10 : '0');
                 ret[len++] = lo + (lo > 9? 'A'-10 : '0');
             }
         }
     }
     if (len >= max) {
-        max *= 2;
-        temp = (xmlChar *) xmlRealloc(ret, (max + 1) * sizeof(xmlChar));
-        if (temp == NULL) {
-                        xmlGenericError(xmlGenericErrorContext,
-                                "xmlSaveUri: out of memory\n");
-                     xmlFree(ret);
-                        return(NULL);
-                    }
-                    ret = temp;
+        temp = xmlSaveUriRealloc(ret, &max);
+        if (temp == NULL) goto mem_error;
+        ret = temp;
     }
     ret[len] = 0;
     return(ret);
+
+mem_error:
+    xmlFree(ret);
+    return(NULL);
 }
 
 /**
  * xmlPrintURI:
  * @stream:  a FILE* for the output
  * @uri:  pointer to an xmlURI
  *
  * Prints the URI in the stream @stream.
  */
 void
@@ skipping 193 matching lines @@
          * while maintaining two pointers into the buffer, so just compact
          * the whole buffer now.
          */
 
         /* If this is the end of the buffer, we're done.  */
         if (segp[2] == '\0') {
           cur[0] = '\0';
           break;
         }
         /* Valgrind complained, strcpy(cur, segp + 3); */
-        /* string will overlap, do not use strcpy */
-        tmp = cur;
-        segp += 3;
-        while ((*tmp++ = *segp++) != 0);
+        /* string will overlap, do not use strcpy */
+        tmp = cur;
+        segp += 3;
+        while ((*tmp++ = *segp++) != 0)
+          ;
 
         /* If there are no previous segments, then keep going from here.  */
         segp = cur;
         while ((segp > path) && ((--segp)[0] == '/'))
           ;
         if (segp == path)
           continue;
 
         /* "segp" is pointing to the end of a previous segment; find it's
          * start.  We need to back up to the previous segment and start
@@ skipping 64 matching lines @@
     const char *in;
 
     if (str == NULL)
         return(NULL);
     if (len <= 0) len = strlen(str);
     if (len < 0) return(NULL);
 
     if (target == NULL) {
         ret = (char *) xmlMallocAtomic(len + 1);
         if (ret == NULL) {
-            xmlGenericError(xmlGenericErrorContext,
-                    "xmlURIUnescapeString: out of memory\n");
+            xmlURIErrMemory("unescaping URI value\n");
             return(NULL);
         }
     } else
         ret = target;
     in = str;
     out = ret;
     while(len > 0) {
         if ((len > 2) && (*in == '%') && (is_hex(in[1])) && (is_hex(in[2]))) {
             in++;
-            if ((*in >= '0') && (*in <= '9')) 
+            if ((*in >= '0') && (*in <= '9'))
                 *out = (*in - '0');
             else if ((*in >= 'a') && (*in <= 'f'))
                 *out = (*in - 'a') + 10;
             else if ((*in >= 'A') && (*in <= 'F'))
                 *out = (*in - 'A') + 10;
             in++;
-            if ((*in >= '0') && (*in <= '9')) 
+            if ((*in >= '0') && (*in <= '9'))
                 *out = *out * 16 + (*in - '0');
             else if ((*in >= 'a') && (*in <= 'f'))
                 *out = *out * 16 + (*in - 'a') + 10;
             else if ((*in >= 'A') && (*in <= 'F'))
                 *out = *out * 16 + (*in - 'A') + 10;
             in++;
             len -= 3;
             out++;
         } else {
             *out++ = *in++;
@@ skipping 12 matching lines @@
  * This routine escapes a string to hex, ignoring reserved characters (a-z)
  * and the characters in the exception list.
  *
  * Returns a new escaped string or NULL in case of error.
  */
 xmlChar *
 xmlURIEscapeStr(const xmlChar *str, const xmlChar *list) {
     xmlChar *ret, ch;
     xmlChar *temp;
     const xmlChar *in;
-
-    unsigned int len, out;
+    int len, out;
 
     if (str == NULL)
         return(NULL);
     if (str[0] == 0)
         return(xmlStrdup(str));
     len = xmlStrlen(str);
     if (!(len > 0)) return(NULL);
 
     len += 20;
     ret = (xmlChar *) xmlMallocAtomic(len);
     if (ret == NULL) {
-        xmlGenericError(xmlGenericErrorContext,
-                "xmlURIEscapeStr: out of memory\n");
+        xmlURIErrMemory("escaping URI value\n");
         return(NULL);
     }
     in = (const xmlChar *) str;
     out = 0;
     while(*in != 0) {
         if (len - out <= 3) {
-            len += 20;
-            temp = (xmlChar *) xmlRealloc(ret, len);
+            temp = xmlSaveUriRealloc(ret, &len);
             if (temp == NULL) {
-                xmlGenericError(xmlGenericErrorContext,
-                        "xmlURIEscapeStr: out of memory\n");
+                xmlURIErrMemory("escaping URI value\n");
                 xmlFree(ret);
                 return(NULL);
             }
             ret = temp;
         }
 
         ch = *in;
 
         if ((ch != '@') && (!IS_UNRESERVED(ch)) && (!xmlStrchr(list, ch))) {
             unsigned char val;
@@ skipping 34 matching lines @@
  *   - Carl Douglas
  */
 xmlChar *
 xmlURIEscape(const xmlChar * str)
 {
     xmlChar *ret, *segment = NULL;
     xmlURIPtr uri;
     int ret2;
 
 #define NULLCHK(p) if(!p) { \
-                   xmlGenericError(xmlGenericErrorContext, \
-                        "xmlURIEscape: out of memory\n"); \
-                        xmlFreeURI(uri); \
-                        return NULL; } \
+         xmlURIErrMemory("escaping URI value\n"); \
+         xmlFreeURI(uri); \
+         return NULL; } \
 
     if (str == NULL)
         return (NULL);
 
     uri = xmlCreateURI();
     if (uri != NULL) {
         /*
          * Allow escaping errors in the unescaped form
          */
         uri->cleanup = 1;
@@ skipping 22 matching lines @@
             xmlURIEscapeStr(BAD_CAST uri->authority, BAD_CAST "/?;:@");
         NULLCHK(segment)
         ret = xmlStrcat(ret, BAD_CAST "//");
         ret = xmlStrcat(ret, segment);
         xmlFree(segment);
     }
 
     if (uri->user) {
         segment = xmlURIEscapeStr(BAD_CAST uri->user, BAD_CAST ";:&=+$,");
         NULLCHK(segment)
-                ret = xmlStrcat(ret,BAD_CAST "//");     
+                ret = xmlStrcat(ret,BAD_CAST "//");
         ret = xmlStrcat(ret, segment);
         ret = xmlStrcat(ret, BAD_CAST "@");
         xmlFree(segment);
     }
 
     if (uri->server) {
         segment = xmlURIEscapeStr(BAD_CAST uri->server, BAD_CAST "/?;:@");
         NULLCHK(segment)
                 if (uri->user == NULL)
                 ret = xmlStrcat(ret, BAD_CAST "//");
@@ skipping 57 matching lines @@
  *                                                                      *
  ************************************************************************/
 
 /**
  * xmlBuildURI:
  * @URI:  the URI instance found in the document
  * @base:  the base value
  *
  * Computes he final URI of the reference done by checking that
  * the given URI is valid, and building the final URI using the
- * base URI. This is processed according to section 5.2 of the 
+ * base URI. This is processed according to section 5.2 of the
  * RFC 2396
  *
  * 5.2. Resolving Relative References to Absolute Form
  *
  * Returns a new URI string (to be freed by the caller) or NULL in case
  *         of error.
  */
 xmlChar *
 xmlBuildURI(const xmlChar *URI, const xmlChar *base) {
     xmlChar *val = NULL;
     int ret, len, indx, cur, out;
     xmlURIPtr ref = NULL;
     xmlURIPtr bas = NULL;
     xmlURIPtr res = NULL;
 
     /*
      * 1) The URI reference is parsed into the potential four components and
      *    fragment identifier, as described in Section 4.3.
      *
      *    NOTE that a completely empty URI is treated by modern browsers
      *    as a reference to "." rather than as a synonym for the current
      *    URI.  Should we do that here?
      */
-    if (URI == NULL) 
+    if (URI == NULL)
         ret = -1;
     else {
         if (*URI) {
             ref = xmlCreateURI();
             if (ref == NULL)
                 goto done;
             ret = xmlParseURIReference(ref, (const char *) URI);
         }
         else
             ret = 0;
@@ skipping 50 matching lines @@
     if ((ref->scheme == NULL) && (ref->path == NULL) &&
         ((ref->authority == NULL) && (ref->server == NULL))) {
         if (bas->scheme != NULL)
             res->scheme = xmlMemStrdup(bas->scheme);
         if (bas->authority != NULL)
             res->authority = xmlMemStrdup(bas->authority);
         else if (bas->server != NULL) {
             res->server = xmlMemStrdup(bas->server);
             if (bas->user != NULL)
                 res->user = xmlMemStrdup(bas->user);
-            res->port = bas->port;              
+            res->port = bas->port;
         }
         if (bas->path != NULL)
             res->path = xmlMemStrdup(bas->path);
         if (ref->query_raw != NULL)
             res->query_raw = xmlMemStrdup (ref->query_raw);
         else if (ref->query != NULL)
             res->query = xmlMemStrdup(ref->query);
         else if (bas->query_raw != NULL)
             res->query_raw = xmlMemStrdup(bas->query_raw);
         else if (bas->query != NULL)
             res->query = xmlMemStrdup(bas->query);
         if (ref->fragment != NULL)
             res->fragment = xmlMemStrdup(ref->fragment);
         goto step_7;
     }
 
     /*
      * 3) If the scheme component is defined, indicating that the reference
      *    starts with a scheme name, then the reference is interpreted as an
      *    absolute URI and we are done.  Otherwise, the reference URI's
      *    scheme is inherited from the base URI's scheme component.
      */
     if (ref->scheme != NULL) {
         val = xmlSaveUri(ref);
         goto done;
     }
     if (bas->scheme != NULL)
         res->scheme = xmlMemStrdup(bas->scheme);
- 
+
     if (ref->query_raw != NULL)
         res->query_raw = xmlMemStrdup(ref->query_raw);
     else if (ref->query != NULL)
         res->query = xmlMemStrdup(ref->query);
     if (ref->fragment != NULL)
         res->fragment = xmlMemStrdup(ref->fragment);
 
     /*
      * 4) If the authority component is defined, then the reference is a
      *    network-path and we skip to step 7.  Otherwise, the reference
      *    URI's authority is inherited from the base URI's authority
      *    component, which will also be undefined if the URI scheme does not
      *    use an authority component.
      */
     if ((ref->authority != NULL) || (ref->server != NULL)) {
         if (ref->authority != NULL)
             res->authority = xmlMemStrdup(ref->authority);
         else {
             res->server = xmlMemStrdup(ref->server);
             if (ref->user != NULL)
                 res->user = xmlMemStrdup(ref->user);
-            res->port = ref->port;              
+            res->port = ref->port;
         }
         if (ref->path != NULL)
             res->path = xmlMemStrdup(ref->path);
         goto step_7;
     }
     if (bas->authority != NULL)
         res->authority = xmlMemStrdup(bas->authority);
     else if (bas->server != NULL) {
         res->server = xmlMemStrdup(bas->server);
         if (bas->user != NULL)
             res->user = xmlMemStrdup(bas->user);
-        res->port = bas->port;          
+        res->port = bas->port;
     }
 
     /*
      * 5) If the path component begins with a slash character ("/"), then
      *    the reference is an absolute-path and we skip to step 7.
      */
     if ((ref->path != NULL) && (ref->path[0] == '/')) {
         res->path = xmlMemStrdup(ref->path);
         goto step_7;
     }
 
 
     /*
      * 6) If this step is reached, then we are resolving a relative-path
      *    reference.  The relative path needs to be merged with the base
      *    URI's path.  Although there are many ways to do this, we will
      *    describe a simple method using a separate string buffer.
      *
      * Allocate a buffer large enough for the result string.
      */
     len = 2; /* extra / and 0 */
     if (ref->path != NULL)
         len += strlen(ref->path);
     if (bas->path != NULL)
         len += strlen(bas->path);
     res->path = (char *) xmlMallocAtomic(len);
     if (res->path == NULL) {
-        xmlGenericError(xmlGenericErrorContext,
-                "xmlBuildURI: out of memory\n");
+        xmlURIErrMemory("resolving URI against base\n");
         goto done;
     }
     res->path[0] = 0;
 
     /*
      * a) All but the last segment of the base URI's path component is
      *    copied to the buffer.  In other words, any characters after the
      *    last (right-most) slash character, if any, are excluded.
      */
     cur = 0;
@@ skipping 225 matching lines @@
          * In base, count the number of '/' from the differing point
          */
         if (bptr[pos] != ref->path[pos]) {/* check for trivial URI == base */
             for (; bptr[ix] != 0; ix++) {
                 if (bptr[ix] == '/')
                     nbslash++;
             }
         }
         len = xmlStrlen (uptr) + 1;
     }
-    
+
     if (nbslash == 0) {
         if (uptr != NULL)
             /* exception characters from xmlSaveUri */
             val = xmlURIEscapeStr(uptr, BAD_CAST "/;&=+$,");
         goto done;
     }
 
     /*
      * Allocate just enough space for the returned string -
      * length of the remainder of the URI, plus enough space
      * for the "../" groups, plus one for the terminator
      */
     val = (xmlChar *) xmlMalloc (len + 3 * nbslash);
     if (val == NULL) {
-        xmlGenericError(xmlGenericErrorContext,
-                "xmlBuildRelativeURI: out of memory\n");
+        xmlURIErrMemory("building relative URI\n");
         goto done;
     }
     vptr = val;
     /*
      * Put in as many "../" as needed
      */
     for (; nbslash>0; nbslash--) {
         *vptr++ = '.';
         *vptr++ = '.';
         *vptr++ = '/';
@@ skipping 31 matching lines @@
     if (bas != NULL)
         xmlFreeURI (bas);
 
     return val;
 }
 
 /**
  * xmlCanonicPath:
  * @path:  the resource locator in a filesystem notation
  *
- * Constructs a canonic path from the specified path. 
+ * Constructs a canonic path from the specified path.
  *
- * Returns a new canonic path, or a duplicate of the path parameter if the 
+ * Returns a new canonic path, or a duplicate of the path parameter if the
  * construction fails. The caller is responsible for freeing the memory occupied
- * by the returned string. If there is insufficient memory available, or the 
+ * by the returned string. If there is insufficient memory available, or the
  * argument is NULL, the function returns NULL.
  */
-#define IS_WINDOWS_PATH(p)                                      \
+#define IS_WINDOWS_PATH(p)                                      \
         ((p != NULL) &&                                         \
          (((p[0] >= 'a') && (p[0] <= 'z')) ||                   \
           ((p[0] >= 'A') && (p[0] <= 'Z'))) &&                  \
          (p[1] == ':') && ((p[2] == '/') || (p[2] == '\\')))
 xmlChar *
 xmlCanonicPath(const xmlChar *path)
 {
 /*
  * For Windows implementations, additional work needs to be done to
  * replace backslashes in pathnames with "forward slashes"
  */
-#if defined(_WIN32) && !defined(__CYGWIN__)    
+#if defined(_WIN32) && !defined(__CYGWIN__)
     int len = 0;
     int i = 0;
     xmlChar *p = NULL;
 #endif
     xmlURIPtr uri;
     xmlChar *ret;
     const xmlChar *absuri;
 
     if (path == NULL)
         return(NULL);
 
-    /* sanitize filename starting with // so it can be used as URI */
+#if defined(_WIN32)
+    /*
+     * We must not change the backslashes to slashes if the the path
+     * starts with \\?\
+     * Those paths can be up to 32k characters long.
+     * Was added specifically for OpenOffice, those paths can't be converted
+     * to URIs anyway.
+     */
+    if ((path[0] == '\\') && (path[1] == '\\') && (path[2] == '?') &&
+        (path[3] == '\\') )
+        return xmlStrdup((const xmlChar *) path);
+#endif
+
+        /* sanitize filename starting with // so it can be used as URI */
     if ((path[0] == '/') && (path[1] == '/') && (path[2] != '/'))
         path++;
 
     if ((uri = xmlParseURI((const char *) path)) != NULL) {
         xmlFreeURI(uri);
         return xmlStrdup(path);
     }
 
     /* Check if this is an "absolute uri" */
     absuri = xmlStrstr(path, BAD_CAST "://");
@@ skipping 26 matching lines @@
             /* If successful, return the escaped string */
             if (uri != NULL) {
                 xmlFreeURI(uri);
                 return escURI;
             }
         }
     }
 
 path_processing:
 /* For Windows implementations, replace backslashes with 'forward slashes' */
-#if defined(_WIN32) && !defined(__CYGWIN__)    
+#if defined(_WIN32) && !defined(__CYGWIN__)
     /*
      * Create a URI structure
      */
     uri = xmlCreateURI();
     if (uri == NULL) {          /* Guard against 'out of memory' */
         return(NULL);
     }
 
     len = xmlStrlen(path);
     if ((len > 2) && IS_WINDOWS_PATH(path)) {
@@ skipping 36 matching lines @@
 #endif
     return(ret);
 }
 
 /**
  * xmlPathToURI:
  * @path:  the resource locator in a filesystem notation
  *
  * Constructs an URI expressing the existing path
  *
- * Returns a new URI, or a duplicate of the path parameter if the 
+ * Returns a new URI, or a duplicate of the path parameter if the
  * construction fails. The caller is responsible for freeing the memory
  * occupied by the returned string. If there is insufficient memory available,
  * or the argument is NULL, the function returns NULL.
  */
 xmlChar *
 xmlPathToURI(const xmlChar *path)
 {
     xmlURIPtr uri;
     xmlURI temp;
     xmlChar *ret, *cal;
 
     if (path == NULL)
         return(NULL);
 
     if ((uri = xmlParseURI((const char *) path)) != NULL) {
         xmlFreeURI(uri);
         return xmlStrdup(path);
     }
     cal = xmlCanonicPath(path);
     if (cal == NULL)
         return(NULL);
 #if defined(_WIN32) && !defined(__CYGWIN__)
-    /* xmlCanonicPath can return an URI on Windows (is that the intended behaviour?) 
+    /* xmlCanonicPath can return an URI on Windows (is that the intended behaviour?)
        If 'cal' is a valid URI allready then we are done here, as continuing would make
        it invalid. */
     if ((uri = xmlParseURI((const char *) cal)) != NULL) {
         xmlFreeURI(uri);
         return cal;
     }
     /* 'cal' can contain a relative path with backslashes. If that is processed
        by xmlSaveURI, they will be escaped and the external entity loader machinery
        will fail. So convert them to slashes. Misuse 'ret' for walking. */
     ret = cal;
     while (*ret != '\0') {
         if (*ret == '\\')
             *ret = '/';
         ret++;
     }
 #endif
     memset(&temp, 0, sizeof(temp));
     temp.path = (char *) cal;
     ret = xmlSaveUri(&temp);
     xmlFree(cal);
     return(ret);
 }
 #define bottom_uri
 #include "elfgcchack.h"