Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxml/src/xmlIO.c

 /*
  * xmlIO.c : implementation of the I/O interfaces used by the parser
  *
  * See Copyright for the status of this software.
  *
  * daniel@veillard.com
  *
  * 14 Nov 2000 ht - for VMS, truncated name of long functions to under 32 char
  */
 
@@ skipping 17 matching lines @@
 #endif
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 #ifdef HAVE_STDLIB_H
 #include <stdlib.h>
 #endif
 #ifdef HAVE_ZLIB_H
 #include <zlib.h>
 #endif
+#ifdef HAVE_LZMA_H
+#include <lzma.h>
+#endif
 
 #if defined(WIN32) || defined(_WIN32)
 #include <windows.h>
 #endif
 
 #if defined(_WIN32_WCE)
 #include <winnls.h> /* for CP_UTF8 */
 #endif
 
 /* Figure a portable way to know if a file is a directory. */
@@ skipping 30 matching lines @@
 #      endif
 #    endif
 #  endif
 #endif
 
 #include <libxml/xmlmemory.h>
 #include <libxml/parser.h>
 #include <libxml/parserInternals.h>
 #include <libxml/xmlIO.h>
 #include <libxml/uri.h>
+#include <libxml/nanohttp.h>
+#include <libxml/nanoftp.h>
 #include <libxml/xmlerror.h>
 #ifdef LIBXML_CATALOG_ENABLED
 #include <libxml/catalog.h>
 #endif
 #include <libxml/globals.h>
 
+#include "buf.h"
+#include "enc.h"
+
 /* #define VERBOSE_FAILURE */
 /* #define DEBUG_EXTERNAL_ENTITIES */
 /* #define DEBUG_INPUT */
 
 #ifdef DEBUG_INPUT
 #define MINLEN 40
 #else
 #define MINLEN 4000
 #endif
 
@@ skipping 652 matching lines @@
  * returns 1.  if stat fails, returns 0 (if calling
  * stat on the filename fails, it can't be right).
  * if stat succeeds and the file is a directory,
  * returns 2.  otherwise returns 1.
  */
 
 int
 xmlCheckFilename (const char *path)
 {
 #ifdef HAVE_STAT
-        struct stat stat_buffer;
+    struct stat stat_buffer;
 #endif
-        if (path == NULL)
-                return(0);
+    if (path == NULL)
+        return(0);
 
 #ifdef HAVE_STAT
 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
+    /*
+     * On Windows stat and wstat do not work with long pathname,
+     * which start with '\\?\'
+     */
+    if ((path[0] == '\\') && (path[1] == '\\') && (path[2] == '?') &&
+        (path[3] == '\\') )
+            return 1;
+
     if (xmlWrapStat(path, &stat_buffer) == -1)
         return 0;
 #else
     if (stat(path, &stat_buffer) == -1)
         return 0;
 #endif
 #ifdef S_ISDIR
     if (S_ISDIR(stat_buffer.st_mode))
         return 2;
 #endif
 #endif /* HAVE_STAT */
     return 1;
 }
 
-static int
+/**
+ * xmlNop:
+ *
+ * No Operation function, does nothing, no input
+ *
+ * Returns zero
+ */
+int
 xmlNop(void) {
     return(0);
 }
 
 /**
  * xmlFdRead:
  * @context:  the I/O context
  * @buffer:  where to drop data
  * @len:  number of bytes to read
  *
@@ skipping 66 matching lines @@
  * xmlFileOpen_real:
  * @filename:  the URI for matching
  *
  * input from FILE *, supports compressed input
  * if @filename is " " then the standard input is used
  *
  * Returns an I/O context or NULL in case of error
  */
 static void *
 xmlFileOpen_real (const char *filename) {
-    const char *path = NULL;
+    const char *path = filename;
     FILE *fd;
 
     if (filename == NULL)
         return(NULL);
 
     if (!strcmp(filename, "-")) {
         fd = stdin;
         return((void *) fd);
     }
 
     if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file://localhost/", 17)) {
 #if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
         path = &filename[17];
 #else
         path = &filename[16];
 #endif
     } else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:///", 8)) {
 #if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
         path = &filename[8];
 #else
         path = &filename[7];
 #endif
     } else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:/", 6)) {
         /* lots of generators seems to lazy to read RFC 1738 */
 #if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
         path = &filename[6];
 #else
         path = &filename[5];
 #endif
-    } else
-        path = filename;
+    }
 
-    if (path == NULL)
-        return(NULL);
     if (!xmlCheckFilename(path))
         return(NULL);
 
 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
     fd = xmlWrapOpen(path, 0);
 #else
     fd = fopen(path, "r");
 #endif /* WIN32 */
     if (fd == NULL) xmlIOErr(0, path);
     return((void *) fd);
@@ skipping 59 matching lines @@
 #endif
     } else
         path = filename;
 
     if (path == NULL)
         return(NULL);
 
 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
     fd = xmlWrapOpen(path, 1);
 #else
-           fd = fopen(path, "wb");
+           fd = fopen(path, "wb");
 #endif /* WIN32 */
 
          if (fd == NULL) xmlIOErr(0, path);
     return((void *) fd);
 }
 #endif /* LIBXML_OUTPUT_ENABLED */
 
 /**
  * xmlFileRead:
  * @context:  the I/O context
@@ skipping 137 matching lines @@
  * if @filename is " " then the standard input is used
  *
  * Returns an I/O context or NULL in case of error
  */
 static void *
 xmlGzfileOpen_real (const char *filename) {
     const char *path = NULL;
     gzFile fd;
 
     if (!strcmp(filename, "-")) {
-        fd = gzdopen(dup(0), "rb");
+        int duped_fd = dup(fileno(stdin));
+        fd = gzdopen(duped_fd, "rb");
+        if (fd == Z_NULL && duped_fd >= 0) {
+            close(duped_fd);  /* gzdOpen() does not close on failure */
+        }
+
         return((void *) fd);
     }
 
     if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file://localhost/", 17))
 #if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
         path = &filename[17];
 #else
         path = &filename[16];
 #endif
     else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:///", 8)) {
@@ skipping 53 matching lines @@
  * Returns an I/O context or NULL in case of error
  */
 static void *
 xmlGzfileOpenW (const char *filename, int compression) {
     const char *path = NULL;
     char mode[15];
     gzFile fd;
 
     snprintf(mode, sizeof(mode), "wb%d", compression);
     if (!strcmp(filename, "-")) {
-        fd = gzdopen(dup(1), mode);
+        int duped_fd = dup(fileno(stdout));
+        fd = gzdopen(duped_fd, "rb");
+        if (fd == Z_NULL && duped_fd >= 0) {
+            close(duped_fd);  /* gzdOpen() does not close on failure */
+        }
+
         return((void *) fd);
     }
 
     if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file://localhost/", 17))
 #if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
         path = &filename[17];
 #else
         path = &filename[16];
 #endif
     else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:///", 8)) {
@@ skipping 66 matching lines @@
 static int
 xmlGzfileClose (void * context) {
     int ret;
 
     ret =  (gzclose((gzFile) context) == Z_OK ) ? 0 : -1;
     if (ret < 0) xmlIOErr(0, "gzclose()");
     return(ret);
 }
 #endif /* HAVE_ZLIB_H */
 
+#ifdef HAVE_LZMA_H
+/************************************************************************
+ *                                                                      *
+ *              I/O for compressed file accesses                        *
+ *                                                                      *
+ ************************************************************************/
+#include "xzlib.h"
+/**
+ * xmlXzfileMatch:
+ * @filename:  the URI for matching
+ *
+ * input from compressed file test
+ *
+ * Returns 1 if matches, 0 otherwise
+ */
+static int
+xmlXzfileMatch (const char *filename ATTRIBUTE_UNUSED) {
+    return(1);
+}
+
+/**
+ * xmlXzFileOpen_real:
+ * @filename:  the URI for matching
+ *
+ * input from compressed file open
+ * if @filename is " " then the standard input is used
+ *
+ * Returns an I/O context or NULL in case of error
+ */
+static void *
+xmlXzfileOpen_real (const char *filename) {
+    const char *path = NULL;
+    xzFile fd;
+
+    if (!strcmp(filename, "-")) {
+        fd = __libxml2_xzdopen(dup(fileno(stdin)), "rb");
+        return((void *) fd);
+    }
+
+    if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file://localhost/", 17)) {
+        path = &filename[16];
+    } else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:///", 8)) {
+        path = &filename[7];
+    } else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:/", 6)) {
+        /* lots of generators seems to lazy to read RFC 1738 */
+        path = &filename[5];
+    } else
+        path = filename;
+
+    if (path == NULL)
+        return(NULL);
+    if (!xmlCheckFilename(path))
+        return(NULL);
+
+    fd = __libxml2_xzopen(path, "rb");
+    return((void *) fd);
+}
+
+/**
+ * xmlXzfileOpen:
+ * @filename:  the URI for matching
+ *
+ * Wrapper around xmlXzfileOpen_real that try it with an unescaped
+ * version of @filename, if this fails fallback to @filename
+ *
+ * Returns a handler or NULL in case or failure
+ */
+static void *
+xmlXzfileOpen (const char *filename) {
+    char *unescaped;
+    void *retval;
+
+    retval = xmlXzfileOpen_real(filename);
+    if (retval == NULL) {
+        unescaped = xmlURIUnescapeString(filename, 0, NULL);
+        if (unescaped != NULL) {
+            retval = xmlXzfileOpen_real(unescaped);
+        }
+        xmlFree(unescaped);
+    }
+
+    return retval;
+}
+
+/**
+ * xmlXzfileRead:
+ * @context:  the I/O context
+ * @buffer:  where to drop data
+ * @len:  number of bytes to write
+ *
+ * Read @len bytes to @buffer from the compressed I/O channel.
+ *
+ * Returns the number of bytes written
+ */
+static int
+xmlXzfileRead (void * context, char * buffer, int len) {
+    int ret;
+
+    ret = __libxml2_xzread((xzFile) context, &buffer[0], len);
+    if (ret < 0) xmlIOErr(0, "xzread()");
+    return(ret);
+}
+
+/**
+ * xmlXzfileClose:
+ * @context:  the I/O context
+ *
+ * Close a compressed I/O channel
+ */
+static int
+xmlXzfileClose (void * context) {
+    int ret;
+
+    ret =  (__libxml2_xzclose((xzFile) context) == LZMA_OK ) ? 0 : -1;
+    if (ret < 0) xmlIOErr(0, "xzclose()");
+    return(ret);
+}
+#endif /* HAVE_LZMA_H */
+
 #ifdef LIBXML_HTTP_ENABLED
 /************************************************************************
  *                                                                      *
  *                      I/O for HTTP file accesses                      *
  *                                                                      *
  ************************************************************************/
 
 #ifdef LIBXML_OUTPUT_ENABLED
 typedef struct xmlIOHTTPWriteCtxt_
 {
@@ skipping 588 matching lines @@
     if ( ctxt->compression > 0 ) {
         content_lgth = xmlZMemBuffGetContent( ctxt->doc_buff, &http_content );
         content_encoding = (char *) "Content-Encoding: gzip";
     }
     else
 #endif
     {
         /*  Pull the data out of the memory output buffer  */
 
         xmlOutputBufferPtr      dctxt = ctxt->doc_buff;
-        http_content = (char *)dctxt->buffer->content;
-        content_lgth = dctxt->buffer->use;
+        http_content = (char *) xmlBufContent(dctxt->buffer);
+        content_lgth = xmlBufUse(dctxt->buffer);
     }
 
     if ( http_content == NULL ) {
         xmlChar msg[500];
         xmlStrPrintf(msg, 500,
                      (const xmlChar *) "xmlIOHTTPCloseWrite:  %s '%s' %s '%s'.\n",
                      "Error retrieving content.\nUnable to",
                      http_mthd, "data to URI", ctxt->uri );
         xmlIOErr(XML_IO_WRITE, (const char *) msg);
     }
@@ skipping 245 matching lines @@
 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
     xmlInitPlatformSpecificIo();
 #endif
 
     xmlRegisterInputCallbacks(xmlFileMatch, xmlFileOpen,
                               xmlFileRead, xmlFileClose);
 #ifdef HAVE_ZLIB_H
     xmlRegisterInputCallbacks(xmlGzfileMatch, xmlGzfileOpen,
                               xmlGzfileRead, xmlGzfileClose);
 #endif /* HAVE_ZLIB_H */
+#ifdef HAVE_LZMA_H
+    xmlRegisterInputCallbacks(xmlXzfileMatch, xmlXzfileOpen,
+                              xmlXzfileRead, xmlXzfileClose);
+#endif /* HAVE_ZLIB_H */
 
 #ifdef LIBXML_HTTP_ENABLED
     xmlRegisterInputCallbacks(xmlIOHTTPMatch, xmlIOHTTPOpen,
                               xmlIOHTTPRead, xmlIOHTTPClose);
 #endif /* LIBXML_HTTP_ENABLED */
 
 #ifdef LIBXML_FTP_ENABLED
     xmlRegisterInputCallbacks(xmlIOFTPMatch, xmlIOFTPOpen,
                               xmlIOFTPRead, xmlIOFTPClose);
 #endif /* LIBXML_FTP_ENABLED */
@@ skipping 77 matching lines @@
 xmlParserInputBufferPtr
 xmlAllocParserInputBuffer(xmlCharEncoding enc) {
     xmlParserInputBufferPtr ret;
 
     ret = (xmlParserInputBufferPtr) xmlMalloc(sizeof(xmlParserInputBuffer));
     if (ret == NULL) {
         xmlIOErrMemory("creating input buffer");
         return(NULL);
     }
     memset(ret, 0, (size_t) sizeof(xmlParserInputBuffer));
-    ret->buffer = xmlBufferCreateSize(2 * xmlDefaultBufferSize);
+    ret->buffer = xmlBufCreateSize(2 * xmlDefaultBufferSize);
     if (ret->buffer == NULL) {
         xmlFree(ret);
         return(NULL);
     }
-    ret->buffer->alloc = XML_BUFFER_ALLOC_DOUBLEIT;
+    xmlBufSetAllocationScheme(ret->buffer, XML_BUFFER_ALLOC_DOUBLEIT);
     ret->encoder = xmlGetCharEncodingHandler(enc);
     if (ret->encoder != NULL)
-        ret->raw = xmlBufferCreateSize(2 * xmlDefaultBufferSize);
+        ret->raw = xmlBufCreateSize(2 * xmlDefaultBufferSize);
     else
         ret->raw = NULL;
     ret->readcallback = NULL;
     ret->closecallback = NULL;
     ret->context = NULL;
     ret->compressed = -1;
     ret->rawconsumed = 0;
 
     return(ret);
 }
@@ skipping 10 matching lines @@
 xmlOutputBufferPtr
 xmlAllocOutputBuffer(xmlCharEncodingHandlerPtr encoder) {
     xmlOutputBufferPtr ret;
 
     ret = (xmlOutputBufferPtr) xmlMalloc(sizeof(xmlOutputBuffer));
     if (ret == NULL) {
         xmlIOErrMemory("creating output buffer");
         return(NULL);
     }
     memset(ret, 0, (size_t) sizeof(xmlOutputBuffer));
-    ret->buffer = xmlBufferCreate();
+    ret->buffer = xmlBufCreate();
     if (ret->buffer == NULL) {
         xmlFree(ret);
         return(NULL);
     }
 
     /* try to avoid a performance problem with Windows realloc() */
-    if (ret->buffer->alloc == XML_BUFFER_ALLOC_EXACT)
-        ret->buffer->alloc = XML_BUFFER_ALLOC_DOUBLEIT;
+    if (xmlBufGetAllocationScheme(ret->buffer) == XML_BUFFER_ALLOC_EXACT)
+        xmlBufSetAllocationScheme(ret->buffer, XML_BUFFER_ALLOC_DOUBLEIT);
 
     ret->encoder = encoder;
     if (encoder != NULL) {
-        ret->conv = xmlBufferCreateSize(4000);
+        ret->conv = xmlBufCreateSize(4000);
         if (ret->conv == NULL) {
             xmlFree(ret);
             return(NULL);
         }
 
         /*
          * This call is designed to initiate the encoder state
          */
-        xmlCharEncOutFunc(encoder, ret->conv, NULL);
+        xmlCharEncOutput(ret, 1);
     } else
         ret->conv = NULL;
     ret->writecallback = NULL;
     ret->closecallback = NULL;
     ret->context = NULL;
     ret->written = 0;
 
     return(ret);
 }
 
 /**
  * xmlAllocOutputBufferInternal:
  * @encoder:  the encoding converter or NULL
  *
  * Create a buffered parser output
  *
  * Returns the new parser output or NULL
  */
 xmlOutputBufferPtr
 xmlAllocOutputBufferInternal(xmlCharEncodingHandlerPtr encoder) {
     xmlOutputBufferPtr ret;
 
     ret = (xmlOutputBufferPtr) xmlMalloc(sizeof(xmlOutputBuffer));
     if (ret == NULL) {
         xmlIOErrMemory("creating output buffer");
         return(NULL);
     }
     memset(ret, 0, (size_t) sizeof(xmlOutputBuffer));
-    ret->buffer = xmlBufferCreate();
+    ret->buffer = xmlBufCreate();
     if (ret->buffer == NULL) {
         xmlFree(ret);
         return(NULL);
     }
 
 
     /*
      * For conversion buffers we use the special IO handling
-     * We don't do that from the exported API to avoid confusing
-     * user's code.
      */
-    ret->buffer->alloc = XML_BUFFER_ALLOC_IO;
-    ret->buffer->contentIO = ret->buffer->content;
+    xmlBufSetAllocationScheme(ret->buffer, XML_BUFFER_ALLOC_IO);
 
     ret->encoder = encoder;
     if (encoder != NULL) {
-        ret->conv = xmlBufferCreateSize(4000);
+        ret->conv = xmlBufCreateSize(4000);
         if (ret->conv == NULL) {
             xmlFree(ret);
             return(NULL);
         }
 
         /*
          * This call is designed to initiate the encoder state
          */
-        xmlCharEncOutFunc(encoder, ret->conv, NULL);
+        xmlCharEncOutput(ret, 1);
     } else
         ret->conv = NULL;
     ret->writecallback = NULL;
     ret->closecallback = NULL;
     ret->context = NULL;
     ret->written = 0;
 
     return(ret);
 }
 
 #endif /* LIBXML_OUTPUT_ENABLED */
 
 /**
  * xmlFreeParserInputBuffer:
  * @in:  a buffered parser input
  *
  * Free up the memory used by a buffered parser input
  */
 void
 xmlFreeParserInputBuffer(xmlParserInputBufferPtr in) {
     if (in == NULL) return;
 
     if (in->raw) {
-        xmlBufferFree(in->raw);
+        xmlBufFree(in->raw);
         in->raw = NULL;
     }
     if (in->encoder != NULL) {
         xmlCharEncCloseFunc(in->encoder);
     }
     if (in->closecallback != NULL) {
         in->closecallback(in->context);
     }
     if (in->buffer != NULL) {
-        xmlBufferFree(in->buffer);
+        xmlBufFree(in->buffer);
         in->buffer = NULL;
     }
 
     xmlFree(in);
 }
 
 #ifdef LIBXML_OUTPUT_ENABLED
 /**
  * xmlOutputBufferClose:
  * @out:  a buffered output
@@ skipping 11 matching lines @@
 
     if (out == NULL)
         return (-1);
     if (out->writecallback != NULL)
         xmlOutputBufferFlush(out);
     if (out->closecallback != NULL) {
         err_rc = out->closecallback(out->context);
     }
     written = out->written;
     if (out->conv) {
-        xmlBufferFree(out->conv);
+        xmlBufFree(out->conv);
         out->conv = NULL;
     }
     if (out->encoder != NULL) {
         xmlCharEncCloseFunc(out->encoder);
     }
     if (out->buffer != NULL) {
-        xmlBufferFree(out->buffer);
+        xmlBufFree(out->buffer);
         out->buffer = NULL;
     }
 
     if (out->error)
         err_rc = -1;
     xmlFree(out);
     return ((err_rc == 0) ? written : err_rc);
 }
 #endif /* LIBXML_OUTPUT_ENABLED */
 
@@ skipping 48 matching lines @@
                     if (strncmp(buff4, cptr, 4) == 0)
                         ret->compressed = 0;
                     else
                         ret->compressed = 1;
                     gzrewind(context);
                 }
             }
 #endif
         }
 #endif
+#ifdef HAVE_LZMA_H
+        if ((xmlInputCallbackTable[i].opencallback == xmlXzfileOpen) &&
+                (strcmp(URI, "-") != 0)) {
+            ret->compressed = __libxml2_xzcompressed(context);
+        }
+#endif
     }
     else
       xmlInputCallbackTable[i].closecallback (context);
 
     return(ret);
 }
 
 /**
  * xmlParserInputBufferCreateFilename:
  * @URI:  a C string containing the URI or filename
@@ skipping 241 matching lines @@
     if (buffer == NULL) return(NULL);
 
     ret = xmlOutputBufferCreateIO((xmlOutputWriteCallback)
                                   xmlBufferWrite,
                                   (xmlOutputCloseCallback)
                                   NULL, (void *) buffer, encoder);
 
     return(ret);
 }
 
+/**
+ * xmlOutputBufferGetContent:
+ * @out:  an xmlOutputBufferPtr
+ *
+ * Gives a pointer to the data currently held in the output buffer
+ *
+ * Returns a pointer to the data or NULL in case of error
+ */
+const xmlChar *
+xmlOutputBufferGetContent(xmlOutputBufferPtr out) {
+    if ((out == NULL) || (out->buffer == NULL))
+        return(NULL);
+
+    return(xmlBufContent(out->buffer));
+}
+
+/**
+ * xmlOutputBufferGetSize:
+ * @out:  an xmlOutputBufferPtr
+ *
+ * Gives the length of the data currently held in the output buffer
+ *
+ * Returns 0 in case or error or no data is held, the size otherwise
+ */
+size_t
+xmlOutputBufferGetSize(xmlOutputBufferPtr out) {
+    if ((out == NULL) || (out->buffer == NULL))
+        return(0);
+
+    return(xmlBufUse(out->buffer));
+}
+
+
 #endif /* LIBXML_OUTPUT_ENABLED */
 
 /**
  * xmlParserInputBufferCreateFd:
  * @fd:  a file descriptor number
  * @enc:  the charset encoding if known
  *
  * Create a buffered parser input for the progressive parsing for the input
  * from a file descriptor
  *
@@ skipping 32 matching lines @@
     int errcode;
 
     if (size <= 0) return(NULL);
     if (mem == NULL) return(NULL);
 
     ret = xmlAllocParserInputBuffer(enc);
     if (ret != NULL) {
         ret->context = (void *) mem;
         ret->readcallback = (xmlInputReadCallback) xmlNop;
         ret->closecallback = NULL;
-        errcode = xmlBufferAdd(ret->buffer, (const xmlChar *) mem, size);
+        errcode = xmlBufAdd(ret->buffer, (const xmlChar *) mem, size);
         if (errcode != 0) {
             xmlFree(ret);
             return(NULL);
         }
     }
 
     return(ret);
 }
 
 /**
@@ skipping 16 matching lines @@
 
     if (size <= 0) return(NULL);
     if (mem == NULL) return(NULL);
 
     ret = (xmlParserInputBufferPtr) xmlMalloc(sizeof(xmlParserInputBuffer));
     if (ret == NULL) {
         xmlIOErrMemory("creating input buffer");
         return(NULL);
     }
     memset(ret, 0, (size_t) sizeof(xmlParserInputBuffer));
-    ret->buffer = xmlBufferCreateStatic((void *)mem, (size_t) size);
+    ret->buffer = xmlBufCreateStatic((void *)mem, (size_t) size);
     if (ret->buffer == NULL) {
         xmlFree(ret);
         return(NULL);
     }
     ret->encoder = xmlGetCharEncodingHandler(enc);
     if (ret->encoder != NULL)
-        ret->raw = xmlBufferCreateSize(2 * xmlDefaultBufferSize);
+        ret->raw = xmlBufCreateSize(2 * xmlDefaultBufferSize);
     else
         ret->raw = NULL;
     ret->compressed = -1;
     ret->context = (void *) mem;
     ret->readcallback = NULL;
     ret->closecallback = NULL;
 
     return(ret);
 }
 
@@ skipping 148 matching lines @@
 
     if (len < 0) return(0);
     if ((in == NULL) || (in->error)) return(-1);
     if (in->encoder != NULL) {
         unsigned int use;
 
         /*
          * Store the data in the incoming raw buffer
          */
         if (in->raw == NULL) {
-            in->raw = xmlBufferCreate();
+            in->raw = xmlBufCreate();
         }
-        ret = xmlBufferAdd(in->raw, (const xmlChar *) buf, len);
+        ret = xmlBufAdd(in->raw, (const xmlChar *) buf, len);
         if (ret != 0)
             return(-1);
 
         /*
          * convert as much as possible to the parser reading buffer.
          */
-        use = in->raw->use;
-        nbchars = xmlCharEncInFunc(in->encoder, in->buffer, in->raw);
+        use = xmlBufUse(in->raw);
+        nbchars = xmlCharEncInput(in, 1);
         if (nbchars < 0) {
             xmlIOErr(XML_IO_ENCODER, NULL);
             in->error = XML_IO_ENCODER;
             return(-1);
         }
-        in->rawconsumed += (use - in->raw->use);
+        in->rawconsumed += (use - xmlBufUse(in->raw));
     } else {
         nbchars = len;
-        ret = xmlBufferAdd(in->buffer, (xmlChar *) buf, nbchars);
+        ret = xmlBufAdd(in->buffer, (xmlChar *) buf, nbchars);
         if (ret != 0)
             return(-1);
     }
 #ifdef DEBUG_INPUT
     xmlGenericError(xmlGenericErrorContext,
             "I/O: pushed %d chars, buffer %d/%d\n",
-            nbchars, in->buffer->use, in->buffer->size);
+            nbchars, xmlBufUse(in->buffer), xmlBufLength(in->buffer));
 #endif
     return(nbchars);
 }
 
 /**
  * endOfInput:
  *
  * When reading from an Input channel indicated end of file or error
  * don't reread from it again.
  */
@@ skipping 17 matching lines @@
  *       onto in->buffer or in->raw
  *
  * Returns the number of chars read and stored in the buffer, or -1
  *         in case of error.
  */
 int
 xmlParserInputBufferGrow(xmlParserInputBufferPtr in, int len) {
     char *buffer = NULL;
     int res = 0;
     int nbchars = 0;
-    int buffree;
-    unsigned int needSize;
 
     if ((in == NULL) || (in->error)) return(-1);
     if ((len <= MINLEN) && (len != 4))
         len = MINLEN;
 
-    buffree = in->buffer->size - in->buffer->use;
-    if (buffree <= 0) {
+    if (xmlBufAvail(in->buffer) <= 0) {
         xmlIOErr(XML_IO_BUFFER_FULL, NULL);
         in->error = XML_IO_BUFFER_FULL;
         return(-1);
     }
 
-    needSize = in->buffer->use + len + 1;
-    if (needSize > in->buffer->size){
-        if (!xmlBufferResize(in->buffer, needSize)){
-            xmlIOErrMemory("growing input buffer");
-            in->error = XML_ERR_NO_MEMORY;
-            return(-1);
-        }
+    if (xmlBufGrow(in->buffer, len + 1) < 0) {
+        xmlIOErrMemory("growing input buffer");
+        in->error = XML_ERR_NO_MEMORY;
+        return(-1);
     }
-    buffer = (char *)&in->buffer->content[in->buffer->use];
+    buffer = (char *)xmlBufEnd(in->buffer);
 
     /*
      * Call the read method for this I/O type.
      */
     if (in->readcallback != NULL) {
         res = in->readcallback(in->context, &buffer[0], len);
         if (res <= 0)
             in->readcallback = endOfInput;
     } else {
         xmlIOErr(XML_IO_NO_INPUT, NULL);
         in->error = XML_IO_NO_INPUT;
         return(-1);
     }
     if (res < 0) {
         return(-1);
     }
+
+    /*
+     * try to establish compressed status of input if not done already
+     */
+    if (in->compressed == -1) {
+#ifdef HAVE_LZMA_H
+        if (in->readcallback == xmlXzfileRead)
+            in->compressed = __libxml2_xzcompressed(in->context);
+#endif
+    }
+
     len = res;
     if (in->encoder != NULL) {
         unsigned int use;
 
         /*
          * Store the data in the incoming raw buffer
          */
         if (in->raw == NULL) {
-            in->raw = xmlBufferCreate();
+            in->raw = xmlBufCreate();
         }
-        res = xmlBufferAdd(in->raw, (const xmlChar *) buffer, len);
+        res = xmlBufAdd(in->raw, (const xmlChar *) buffer, len);
         if (res != 0)
             return(-1);
 
         /*
          * convert as much as possible to the parser reading buffer.
          */
-        use = in->raw->use;
-        nbchars = xmlCharEncInFunc(in->encoder, in->buffer, in->raw);
+        use = xmlBufUse(in->raw);
+        nbchars = xmlCharEncInput(in, 1);
         if (nbchars < 0) {
             xmlIOErr(XML_IO_ENCODER, NULL);
             in->error = XML_IO_ENCODER;
             return(-1);
         }
-        in->rawconsumed += (use - in->raw->use);
+        in->rawconsumed += (use - xmlBufUse(in->raw));
     } else {
         nbchars = len;
-        in->buffer->use += nbchars;
-        buffer[nbchars] = 0;
+        xmlBufAddLen(in->buffer, nbchars);
     }
 #ifdef DEBUG_INPUT
     xmlGenericError(xmlGenericErrorContext,
-            "I/O: read %d chars, buffer %d/%d\n",
-            nbchars, in->buffer->use, in->buffer->size);
+            "I/O: read %d chars, buffer %d\n",
+            nbchars, xmlBufUse(in->buffer));
 #endif
     return(nbchars);
 }
 
 /**
  * xmlParserInputBufferRead:
  * @in:  a buffered parser input
  * @len:  indicative value of the amount of chars to read
  *
  * Refresh the content of the input buffer, the old data are considered
  * consumed
  * This routine handle the I18N transcoding to internal UTF-8
  *
  * Returns the number of chars read and stored in the buffer, or -1
  *         in case of error.
  */
 int
 xmlParserInputBufferRead(xmlParserInputBufferPtr in, int len) {
     if ((in == NULL) || (in->error)) return(-1);
     if (in->readcallback != NULL)
         return(xmlParserInputBufferGrow(in, len));
-    else if ((in->buffer != NULL) &&
-             (in->buffer->alloc == XML_BUFFER_ALLOC_IMMUTABLE))
+    else if (xmlBufGetAllocationScheme(in->buffer) == XML_BUFFER_ALLOC_IMMUTABLE)
         return(0);
     else
         return(-1);
 }
 
 #ifdef LIBXML_OUTPUT_ENABLED
 /**
  * xmlOutputBufferWrite:
  * @out:  a buffered parser output
  * @len:  the size in bytes of the array.
@@ skipping 24 matching lines @@
             chunk = 4 * MINLEN;
 
         /*
          * first handle encoding stuff.
          */
         if (out->encoder != NULL) {
             /*
              * Store the data in the incoming raw buffer
              */
             if (out->conv == NULL) {
-                out->conv = xmlBufferCreate();
+                out->conv = xmlBufCreate();
             }
-            ret = xmlBufferAdd(out->buffer, (const xmlChar *) buf, chunk);
+            ret = xmlBufAdd(out->buffer, (const xmlChar *) buf, chunk);
             if (ret != 0)
                 return(-1);
 
-            if ((out->buffer->use < MINLEN) && (chunk == len))
+            if ((xmlBufUse(out->buffer) < MINLEN) && (chunk == len))
                 goto done;
 
             /*
              * convert as much as possible to the parser reading buffer.
              */
-            ret = xmlCharEncOutFunc(out->encoder, out->conv, out->buffer);
+            ret = xmlCharEncOutput(out, 0);
             if ((ret < 0) && (ret != -3)) {
                 xmlIOErr(XML_IO_ENCODER, NULL);
                 out->error = XML_IO_ENCODER;
                 return(-1);
             }
-            nbchars = out->conv->use;
+            nbchars = xmlBufUse(out->conv);
         } else {
-            ret = xmlBufferAdd(out->buffer, (const xmlChar *) buf, chunk);
+            ret = xmlBufAdd(out->buffer, (const xmlChar *) buf, chunk);
             if (ret != 0)
                 return(-1);
-            nbchars = out->buffer->use;
+            nbchars = xmlBufUse(out->buffer);
         }
         buf += chunk;
         len -= chunk;
 
         if ((nbchars < MINLEN) && (len <= 0))
             goto done;
 
         if (out->writecallback) {
             /*
              * second write the stuff to the I/O channel
              */
             if (out->encoder != NULL) {
                 ret = out->writecallback(out->context,
-                                 (const char *)out->conv->content, nbchars);
+                           (const char *)xmlBufContent(out->conv), nbchars);
                 if (ret >= 0)
-                    xmlBufferShrink(out->conv, ret);
+                    xmlBufShrink(out->conv, ret);
             } else {
                 ret = out->writecallback(out->context,
-                                 (const char *)out->buffer->content, nbchars);
+                           (const char *)xmlBufContent(out->buffer), nbchars);
                 if (ret >= 0)
-                    xmlBufferShrink(out->buffer, ret);
+                    xmlBufShrink(out->buffer, ret);
             }
             if (ret < 0) {
                 xmlIOErr(XML_IO_WRITE, NULL);
                 out->error = XML_IO_WRITE;
                 return(ret);
             }
             out->written += ret;
         }
         written += nbchars;
     } while (len > 0);
@@ skipping 23 matching lines @@
 xmlEscapeContent(unsigned char* out, int *outlen,
                  const xmlChar* in, int *inlen) {
     unsigned char* outstart = out;
     const unsigned char* base = in;
     unsigned char* outend = out + *outlen;
     const unsigned char* inend;
 
     inend = in + (*inlen);
 
     while ((in < inend) && (out < outend)) {
-        if (*in == '<') {
+        if (*in == '<') {
             if (outend - out < 4) break;
             *out++ = '&';
             *out++ = 'l';
             *out++ = 't';
             *out++ = ';';
         } else if (*in == '>') {
             if (outend - out < 4) break;
             *out++ = '&';
             *out++ = 'g';
             *out++ = 't';
@@ skipping 43 matching lines @@
     int nbchars = 0; /* number of chars to output to I/O */
     int ret;         /* return from function call */
     int written = 0; /* number of char written to I/O so far */
     int oldwritten=0;/* loop guard */
     int chunk;       /* number of byte currently processed from str */
     int len;         /* number of bytes in str */
     int cons;        /* byte from str consumed */
 
     if ((out == NULL) || (out->error) || (str == NULL) ||
         (out->buffer == NULL) ||
-        (out->buffer->alloc == XML_BUFFER_ALLOC_IMMUTABLE)) return(-1);
+        (xmlBufGetAllocationScheme(out->buffer) == XML_BUFFER_ALLOC_IMMUTABLE))
+        return(-1);
     len = strlen((const char *)str);
     if (len < 0) return(0);
     if (out->error) return(-1);
     if (escaping == NULL) escaping = xmlEscapeContent;
 
     do {
         oldwritten = written;
 
         /*
          * how many bytes to consume and how many bytes to store.
          */
         cons = len;
-        chunk = (out->buffer->size - out->buffer->use) - 1;
+        chunk = xmlBufAvail(out->buffer) - 1;
 
         /*
          * make sure we have enough room to save first, if this is
          * not the case force a flush, but make sure we stay in the loop
          */
         if (chunk < 40) {
-            if (xmlBufferGrow(out->buffer, out->buffer->size + 100) < 0)
+            if (xmlBufGrow(out->buffer, 100) < 0)
                 return(-1);
             oldwritten = -1;
             continue;
         }
 
         /*
          * first handle encoding stuff.
          */
         if (out->encoder != NULL) {
             /*
              * Store the data in the incoming raw buffer
              */
             if (out->conv == NULL) {
-                out->conv = xmlBufferCreate();
+                out->conv = xmlBufCreate();
             }
-            ret = escaping(out->buffer->content + out->buffer->use ,
+            ret = escaping(xmlBufEnd(out->buffer) ,
                            &chunk, str, &cons);
             if ((ret < 0) || (chunk == 0)) /* chunk==0 => nothing done */
                 return(-1);
-            out->buffer->use += chunk;
-            out->buffer->content[out->buffer->use] = 0;
+            xmlBufAddLen(out->buffer, chunk);
 
-            if ((out->buffer->use < MINLEN) && (cons == len))
+            if ((xmlBufUse(out->buffer) < MINLEN) && (cons == len))
                 goto done;
 
             /*
              * convert as much as possible to the output buffer.
              */
-            ret = xmlCharEncOutFunc(out->encoder, out->conv, out->buffer);
+            ret = xmlCharEncOutput(out, 0);
             if ((ret < 0) && (ret != -3)) {
                 xmlIOErr(XML_IO_ENCODER, NULL);
                 out->error = XML_IO_ENCODER;
                 return(-1);
             }
-            nbchars = out->conv->use;
+            nbchars = xmlBufUse(out->conv);
         } else {
-            ret = escaping(out->buffer->content + out->buffer->use ,
-                           &chunk, str, &cons);
+            ret = escaping(xmlBufEnd(out->buffer), &chunk, str, &cons);
             if ((ret < 0) || (chunk == 0)) /* chunk==0 => nothing done */
                 return(-1);
-            out->buffer->use += chunk;
-            out->buffer->content[out->buffer->use] = 0;
-            nbchars = out->buffer->use;
+            xmlBufAddLen(out->buffer, chunk);
+            nbchars = xmlBufUse(out->buffer);
         }
         str += cons;
         len -= cons;
 
         if ((nbchars < MINLEN) && (len <= 0))
             goto done;
 
         if (out->writecallback) {
             /*
              * second write the stuff to the I/O channel
              */
             if (out->encoder != NULL) {
                 ret = out->writecallback(out->context,
-                                 (const char *)out->conv->content, nbchars);
+                           (const char *)xmlBufContent(out->conv), nbchars);
                 if (ret >= 0)
-                    xmlBufferShrink(out->conv, ret);
+                    xmlBufShrink(out->conv, ret);
             } else {
                 ret = out->writecallback(out->context,
-                                 (const char *)out->buffer->content, nbchars);
+                           (const char *)xmlBufContent(out->buffer), nbchars);
                 if (ret >= 0)
-                    xmlBufferShrink(out->buffer, ret);
+                    xmlBufShrink(out->buffer, ret);
             }
             if (ret < 0) {
                 xmlIOErr(XML_IO_WRITE, NULL);
                 out->error = XML_IO_WRITE;
                 return(ret);
             }
             out->written += ret;
-        } else if (out->buffer->size - out->buffer->use < MINLEN) {
-            xmlBufferResize(out->buffer, out->buffer->size + MINLEN);
+        } else if (xmlBufAvail(out->buffer) < MINLEN) {
+            xmlBufGrow(out->buffer, MINLEN);
         }
         written += nbchars;
     } while ((len > 0) && (oldwritten != written));
 
 done:
 #ifdef DEBUG_INPUT
     xmlGenericError(xmlGenericErrorContext,
             "I/O: wrote %d chars\n", written);
 #endif
     return(written);
@@ skipping 37 matching lines @@
 int
 xmlOutputBufferFlush(xmlOutputBufferPtr out) {
     int nbchars = 0, ret = 0;
 
     if ((out == NULL) || (out->error)) return(-1);
     /*
      * first handle encoding stuff.
      */
     if ((out->conv != NULL) && (out->encoder != NULL)) {
         /*
-         * convert as much as possible to the parser reading buffer.
+         * convert as much as possible to the parser output buffer.
          */
-        nbchars = xmlCharEncOutFunc(out->encoder, out->conv, out->buffer);
-        if (nbchars < 0) {
-            xmlIOErr(XML_IO_ENCODER, NULL);
-            out->error = XML_IO_ENCODER;
-            return(-1);
-        }
+        do {
+            nbchars = xmlCharEncOutput(out, 0);
+            if (nbchars < 0) {
+                xmlIOErr(XML_IO_ENCODER, NULL);
+                out->error = XML_IO_ENCODER;
+                return(-1);
+            }
+        } while (nbchars);
     }
 
     /*
      * second flush the stuff to the I/O channel
      */
     if ((out->conv != NULL) && (out->encoder != NULL) &&
         (out->writecallback != NULL)) {
         ret = out->writecallback(out->context,
-                   (const char *)out->conv->content, out->conv->use);
+                                 (const char *)xmlBufContent(out->conv),
+                                 xmlBufUse(out->conv));
         if (ret >= 0)
-            xmlBufferShrink(out->conv, ret);
+            xmlBufShrink(out->conv, ret);
     } else if (out->writecallback != NULL) {
         ret = out->writecallback(out->context,
-                   (const char *)out->buffer->content, out->buffer->use);
+                                 (const char *)xmlBufContent(out->buffer),
+                                 xmlBufUse(out->buffer));
         if (ret >= 0)
-            xmlBufferShrink(out->buffer, ret);
+            xmlBufShrink(out->buffer, ret);
     }
     if (ret < 0) {
         xmlIOErr(XML_IO_FLUSH, NULL);
         out->error = XML_IO_FLUSH;
         return(ret);
     }
     out->written += ret;
 
 #ifdef DEBUG_INPUT
     xmlGenericError(xmlGenericErrorContext,
@@ skipping 380 matching lines @@
         }
     }
     input = xmlDefaultExternalEntityLoader((const char *) resource, ID, ctxt);
     if (resource != (xmlChar *) URL)
         xmlFree(resource);
     return(input);
 }
 
 #define bottom_xmlIO
 #include "elfgcchack.h"