Update libxml to 2.7.7.

third_party/libxml/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 117 matching lines @@
     xmlOutputOpenCallback opencallback;
     xmlOutputWriteCallback writecallback;
     xmlOutputCloseCallback closecallback;
 } xmlOutputCallback;
 
 #define MAX_OUTPUT_CALLBACK 15
 
 static xmlOutputCallback xmlOutputCallbackTable[MAX_OUTPUT_CALLBACK];
 static int xmlOutputCallbackNr = 0;
 static int xmlOutputCallbackInitialized = 0;
+
+xmlOutputBufferPtr
+xmlAllocOutputBufferInternal(xmlCharEncodingHandlerPtr encoder);
 #endif /* LIBXML_OUTPUT_ENABLED */
 
 /************************************************************************
  *                                                                      *
- *              Tree memory error handler                               *
+ *              Tree memory error handler                               *
  *                                                                      *
  ************************************************************************/
 
 static const char *IOerr[] = {
     "Unknown IO error",         /* UNKNOWN */
     "Permission denied",        /* EACCES */
     "Resource temporarily unavailable",/* EAGAIN */
     "Bad file descriptor",      /* EBADF */
     "Bad message",              /* EBADMSG */
     "Resource busy",            /* EBUSY */
@@ skipping 262 matching lines @@
 #endif
 #ifdef EAFNOSUPPORT
         else if (errno == EAFNOSUPPORT) code = XML_IO_EAFNOSUPPORT;
 #endif
         else code = XML_IO_UNKNOWN;
 #endif /* HAVE_ERRNO_H */
     }
     idx = 0;
     if (code >= XML_IO_UNKNOWN) idx = code - XML_IO_UNKNOWN;
     if (idx >= (sizeof(IOerr) / sizeof(IOerr[0]))) idx = 0;
-    
+
     __xmlSimpleError(domain, code, NULL, IOerr[idx], extra);
 }
 
 /**
  * xmlIOErr:
  * @code:  the error number
  * @extra:  extra informations
  *
  * Handle an I/O error
  */
@@ skipping 31 matching lines @@
             level = XML_ERR_WARNING;
         }
         if (ctxt->sax->initialized == XML_SAX2_MAGIC)
             schannel = ctxt->sax->serror;
         data = ctxt->userData;
     }
     __xmlRaiseError(schannel, channel, data, ctxt, NULL, XML_FROM_IO,
                     XML_IO_LOAD_ERROR, level, NULL, 0,
                     filename, NULL, NULL, 0, 0,
                     msg, filename);
-                    
+
 }
 
 /************************************************************************
  *                                                                      *
- *              Tree memory error handler                               *
+ *              Tree memory error handler                               *
  *                                                                      *
  ************************************************************************/
 /**
  * xmlNormalizeWindowsPath:
  * @path: the input file path
  *
  * This function is obsolete. Please see xmlURIFromPath in uri.c for
  * a better solution.
  *
  * Returns a canonicalized version of the path
  */
 xmlChar *
 xmlNormalizeWindowsPath(const xmlChar *path)
 {
     return xmlCanonicPath(path);
 }
 
 /**
  * xmlCleanupInputCallbacks:
  *
  * clears the entire input callback table. this includes the
- * compiled-in I/O. 
+ * compiled-in I/O.
  */
 void
 xmlCleanupInputCallbacks(void)
 {
     int i;
 
     if (!xmlInputCallbackInitialized)
         return;
 
     for (i = xmlInputCallbackNr - 1; i >= 0; i--) {
         xmlInputCallbackTable[i].matchcallback = NULL;
         xmlInputCallbackTable[i].opencallback = NULL;
         xmlInputCallbackTable[i].readcallback = NULL;
         xmlInputCallbackTable[i].closecallback = NULL;
     }
 
     xmlInputCallbackNr = 0;
     xmlInputCallbackInitialized = 0;
 }
 
 /**
  * xmlPopInputCallbacks:
  *
  * Clear the top input callback from the input stack. this includes the
- * compiled-in I/O. 
+ * compiled-in I/O.
  *
  * Returns the number of input callback registered or -1 in case of error.
  */
 int
 xmlPopInputCallbacks(void)
 {
     if (!xmlInputCallbackInitialized)
         return(-1);
 
     if (xmlInputCallbackNr <= 0)
         return(-1);
-        
+
     xmlInputCallbackNr--;
     xmlInputCallbackTable[xmlInputCallbackNr].matchcallback = NULL;
     xmlInputCallbackTable[xmlInputCallbackNr].opencallback = NULL;
     xmlInputCallbackTable[xmlInputCallbackNr].readcallback = NULL;
     xmlInputCallbackTable[xmlInputCallbackNr].closecallback = NULL;
 
     return(xmlInputCallbackNr);
 }
 
 #ifdef LIBXML_OUTPUT_ENABLED
 /**
  * xmlCleanupOutputCallbacks:
  *
  * clears the entire output callback table. this includes the
- * compiled-in I/O callbacks. 
+ * compiled-in I/O callbacks.
  */
 void
 xmlCleanupOutputCallbacks(void)
 {
     int i;
 
     if (!xmlOutputCallbackInitialized)
         return;
 
     for (i = xmlOutputCallbackNr - 1; i >= 0; i--) {
@@ skipping 36 matching lines @@
        fd = _wfopen(wPath, mode ? L"wb" : L"rb");
        xmlFree(wPath);
     }
     /* maybe path in native encoding */
     if(fd == NULL)
        fd = fopen(path, mode ? "wb" : "rb");
 
     return fd;
 }
 
+#ifdef HAVE_ZLIB_H
+static gzFile
+xmlWrapGzOpenUtf8(const char *path, const char *mode)
+{
+    gzFile fd;
+    wchar_t *wPath;
+
+    fd = gzopen (path, mode);
+    if (fd)
+        return fd;
+
+    wPath = __xmlIOWin32UTF8ToWChar(path);
+    if(wPath)
+    {
+        int d, m = (strstr(mode, "r") ? O_RDONLY : O_RDWR);
+#ifdef _O_BINARY
+        m |= (strstr(mode, "b") ? _O_BINARY : 0);
+#endif
+        d = _wopen(wPath, m);
+        if (d >= 0)
+            fd = gzdopen(d, mode);
+        xmlFree(wPath);
+    }
+
+    return fd;
+}
+#endif
+
 /**
  *  xmlWrapStatUtf8:
  * @path:  the path in utf-8 encoding
  * @info:  structure that stores results
  *
  * function obtains information about the file or directory
  *
  */
 static int
 xmlWrapStatUtf8(const char *path,struct stat *info)
@@ skipping 46 matching lines @@
     return stat(path,info);
 #else
     return -1;
 #endif
 }
 
 typedef int (* xmlWrapStatFunc) (const char *f, struct stat *s);
 static xmlWrapStatFunc xmlWrapStat = xmlWrapStatNative;
 typedef FILE* (* xmlWrapOpenFunc)(const char *f,int mode);
 static xmlWrapOpenFunc xmlWrapOpen = xmlWrapOpenNative;
-
+#ifdef HAVE_ZLIB_H
+typedef gzFile (* xmlWrapGzOpenFunc) (const char *f, const char *mode);
+static xmlWrapGzOpenFunc xmlWrapGzOpen = gzopen;
+#endif
 /**
  * xmlInitPlatformSpecificIo:
  *
  * Initialize platform specific features.
  */
 static void
 xmlInitPlatformSpecificIo(void)
 {
     static int xmlPlatformIoInitialized = 0;
     OSVERSIONINFO osvi;
 
     if(xmlPlatformIoInitialized)
       return;
 
     osvi.dwOSVersionInfoSize = sizeof(osvi);
 
     if(GetVersionEx(&osvi) && (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT)) {
       xmlWrapStat = xmlWrapStatUtf8;
       xmlWrapOpen = xmlWrapOpenUtf8;
+#ifdef HAVE_ZLIB_H
+      xmlWrapGzOpen = xmlWrapGzOpenUtf8;
+#endif
     } else {
       xmlWrapStat = xmlWrapStatNative;
       xmlWrapOpen = xmlWrapOpenNative;
+#ifdef HAVE_ZLIB_H
+      xmlWrapGzOpen = gzopen;
+#endif
     }
 
     xmlPlatformIoInitialized = 1;
     return;
 }
 
 #endif
 
 /**
  * xmlCheckFilename:
@@ skipping 144 matching lines @@
 #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 
+    } 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
@@ skipping 54 matching lines @@
         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 
+    } 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
  * @buffer:  where to drop data
  * @len:  number of bytes to write
  *
  * Read @len bytes to @buffer from the I/O channel.
  *
  * Returns the number of bytes written or < 0 in case of failure
  */
 int
 xmlFileRead (void * context, char * buffer, int len) {
     int ret;
-    if ((context == NULL) || (buffer == NULL)) 
+    if ((context == NULL) || (buffer == NULL))
         return(-1);
     ret = fread(&buffer[0], 1,  len, (FILE *) context);
     if (ret < 0) xmlIOErr(0, "fread()");
     return(ret);
 }
 
 #ifdef LIBXML_OUTPUT_ENABLED
 /**
  * xmlFileWrite:
  * @context:  the I/O context
  * @buffer:  where to drop data
  * @len:  number of bytes to write
  *
  * Write @len bytes from @buffer to the I/O channel.
  *
  * Returns the number of bytes written
  */
 static int
 xmlFileWrite (void * context, const char * buffer, int len) {
     int items;
 
-    if ((context == NULL) || (buffer == NULL)) 
+    if ((context == NULL) || (buffer == NULL))
         return(-1);
     items = fwrite(&buffer[0], len, 1, (FILE *) context);
     if ((items == 0) && (ferror((FILE *) context))) {
         xmlIOErr(0, "fwrite()");
         return(-1);
     }
     return(items * len);
 }
 #endif /* LIBXML_OUTPUT_ENABLED */
 
@@ skipping 110 matching lines @@
         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 
+    } else
         path = filename;
 
     if (path == NULL)
         return(NULL);
     if (!xmlCheckFilename(path))
         return(NULL);
 
+#if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
+    fd = xmlWrapGzOpen(path, "rb");
+#else
     fd = gzopen(path, "rb");
+#endif
     return((void *) fd);
 }
 
 /**
  * xmlGzfileOpen:
  * @filename:  the URI for matching
  *
  * Wrapper around xmlGzfileOpen if the open fais, it will
  * try to unescape @filename
  */
@@ skipping 41 matching lines @@
         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 
+    } else
         path = filename;
 
     if (path == NULL)
         return(NULL);
 
+#if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
+    fd = xmlWrapGzOpen(path, mode);
+#else
     fd = gzopen(path, mode);
+#endif
     return((void *) fd);
 }
 #endif /* LIBXML_OUTPUT_ENABLED */
 
 /**
  * xmlGzfileRead:
  * @context:  the I/O context
  * @buffer:  where to drop data
  * @len:  number of bytes to write
  *
@@ skipping 101 matching lines @@
 static void
 append_reverse_ulong( xmlZMemBuff * buff, unsigned long data ) {
 
     int         idx;
 
     if ( buff == NULL )
         return;
 
     /*
     **  This is plagiarized from putLong in gzio.c (zlib source) where
-    **  the number "4" is hardcoded.  If zlib is ever patched to 
+    **  the number "4" is hardcoded.  If zlib is ever patched to
     **  support 64 bit file sizes, this code would need to be patched
     **  as well.
     */
 
     for ( idx = 0; idx < 4; idx++ ) {
         *buff->zctrl.next_out = ( data & 0xff );
         data >>= 8;
         buff->zctrl.next_out++;
     }
 
@@ skipping 31 matching lines @@
     xmlFree( buff );
     return;
 }
 
 /**
  * xmlCreateZMemBuff
  *@compression: Compression value to use
  *
  * Create a memory buffer to hold the compressed XML document.  The
  * compressed document in memory will end up being identical to what
- * would be created if gzopen/gzwrite/gzclose were being used to 
+ * would be created if gzopen/gzwrite/gzclose were being used to
  * write the document to disk.  The code for the header/trailer data to
  * the compression is plagiarized from the zlib source files.
  */
 static void *
 xmlCreateZMemBuff( int compression ) {
 
     int                 z_err;
     int                 hdr_lgth;
     xmlZMemBuffPtr      buff = NULL;
 
@@ skipping 28 matching lines @@
                     "Error initializing compression context.  ZLIB error:",
                     z_err );
         xmlIOErr(XML_IO_WRITE, (const char *) msg);
         return ( NULL );
     }
 
     /*  Set the header data.  The CRC will be needed for the trailer  */
     buff->crc = crc32( 0L, NULL, 0 );
     hdr_lgth = snprintf( (char *)buff->zbuff, buff->size,
                         "%c%c%c%c%c%c%c%c%c%c",
-                        GZ_MAGIC1, GZ_MAGIC2, Z_DEFLATED, 
+                        GZ_MAGIC1, GZ_MAGIC2, Z_DEFLATED,
                         0, 0, 0, 0, 0, 0, LXML_ZLIB_OS_CODE );
     buff->zctrl.next_out  = buff->zbuff + hdr_lgth;
     buff->zctrl.avail_out = buff->size - hdr_lgth;
 
     return ( buff );
 }
 
 /**
  * xmlZMemBuffExtend
  * @buff:  Buffer used to compress and consolidate data.
@@ skipping 17 matching lines @@
     if ( buff == NULL )
         return ( -1 );
 
     else if ( ext_amt == 0 )
         return ( 0 );
 
     cur_used = buff->zctrl.next_out - buff->zbuff;
     new_size = buff->size + ext_amt;
 
 #ifdef DEBUG_HTTP
-    if ( cur_used > new_size ) 
+    if ( cur_used > new_size )
         xmlGenericError( xmlGenericErrorContext,
                         "xmlZMemBuffExtend:  %s\n%s %d bytes.\n",
                         "Buffer overwrite detected during compressed memory",
-                        "buffer extension.  Overflowed by", 
+                        "buffer extension.  Overflowed by",
                         (cur_used - new_size ) );
 #endif
 
     tmp_ptr = xmlRealloc( buff->zbuff, new_size );
     if ( tmp_ptr != NULL ) {
         rc = 0;
         buff->size  = new_size;
         buff->zbuff = tmp_ptr;
         buff->zctrl.next_out  = tmp_ptr + cur_used;
         buff->zctrl.avail_out = new_size - cur_used;
@@ skipping 117 matching lines @@
         *data_ref = (char *)buff->zbuff;
     }
 
     else {
         xmlChar msg[500];
         xmlStrPrintf(msg, 500,
                     (const xmlChar *) "xmlZMemBuffGetContent:  %s - %d\n",
                     "Error flushing zlib buffers.  Error code", z_err );
         xmlIOErr(XML_IO_WRITE, (const char *) msg);
     }
-    
+
     return ( zlgth );
 }
 #endif /* LIBXML_OUTPUT_ENABLED */
 #endif  /*  HAVE_ZLIB_H  */
 
 #ifdef LIBXML_OUTPUT_ENABLED
 /**
  * xmlFreeHTTPWriteCtxt
  * @ctxt:  Context to cleanup
  *
@@ skipping 99 matching lines @@
 #ifdef HAVE_ZLIB_H
     if ((compression > 0) && (compression <= 9)) {
 
         ctxt->compression = compression;
         ctxt->doc_buff = xmlCreateZMemBuff(compression);
     } else
 #endif
     {
         /*  Any character conversions should have been done before this  */
 
-        ctxt->doc_buff = xmlAllocOutputBuffer(NULL);
+        ctxt->doc_buff = xmlAllocOutputBufferInternal(NULL);
     }
 
     if (ctxt->doc_buff == NULL) {
         xmlFreeHTTPWriteCtxt(ctxt);
         ctxt = NULL;
     }
 
     return (ctxt);
 }
 #endif /* LIBXML_OUTPUT_ENABLED */
-                                
+
 #ifdef LIBXML_OUTPUT_ENABLED
 /**
  * xmlIOHTTPDfltOpenW
  * @post_uri:  The destination URI for this document.
  *
  * Calls xmlIOHTTPOpenW with no compression to set up for a subsequent
  * HTTP post command.  This function should generally not be used as
  * the open callback is short circuited in xmlOutputBufferCreateFile.
  *
  * Returns a pointer to the new IO context.
  */
 static void *
 xmlIOHTTPDfltOpenW( const char * post_uri ) {
     return ( xmlIOHTTPOpenW( post_uri, 0 ) );
 }
 #endif /* LIBXML_OUTPUT_ENABLED */
 
 /**
  * xmlIOHTTPRead:
  * @context:  the I/O context
  * @buffer:  where to drop data
  * @len:  number of bytes to write
  *
  * Read @len bytes to @buffer from the I/O channel.
  *
  * Returns the number of bytes written
  */
-int 
+int
 xmlIOHTTPRead(void * context, char * buffer, int len) {
     if ((buffer == NULL) || (len < 0)) return(-1);
     return(xmlNanoHTTPRead(context, &buffer[0], len));
 }
 
 #ifdef LIBXML_OUTPUT_ENABLED
 /**
  * xmlIOHTTPWrite
  * @context:  previously opened writing context
  * @buffer:   data to output to temporary buffer
  * @len:      bytes to output
  *
  * Collect data from memory buffer into a temporary file for later
  * processing.
  *
  * Returns number of bytes written.
  */
 
 static int
-xmlIOHTTPWrite( void * context, const char * buffer, int len ) { 
+xmlIOHTTPWrite( void * context, const char * buffer, int len ) {
 
     xmlIOHTTPWriteCtxtPtr       ctxt = context;
 
     if ( ( ctxt == NULL ) || ( ctxt->doc_buff == NULL ) || ( buffer == NULL ) )
         return ( -1 );
 
     if ( len > 0 ) {
 
         /*  Use gzwrite or fwrite as previously setup in the open call  */
 
 #ifdef HAVE_ZLIB_H
-        if ( ctxt->compression > 0 ) 
+        if ( ctxt->compression > 0 )
             len = xmlZMemBuffAppend( ctxt->doc_buff, buffer, len );
 
         else
 #endif
             len = xmlOutputBufferWrite( ctxt->doc_buff, len, buffer );
 
         if ( len < 0 ) {
             xmlChar msg[500];
             xmlStrPrintf(msg, 500,
                         (const xmlChar *) "xmlIOHTTPWrite:  %s\n%s '%s'.\n",
@@ skipping 70 matching lines @@
         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);
     }
 
     else {
 
         http_ctxt = xmlNanoHTTPMethod( ctxt->uri, http_mthd, http_content,
-                                        &content_type, content_encoding, 
+                                        &content_type, content_encoding,
                                         content_lgth );
 
         if ( http_ctxt != NULL ) {
 #ifdef DEBUG_HTTP
             /*  If testing/debugging - dump reply with request content  */
 
             FILE *      tst_file = NULL;
             char        buffer[ 4096 ];
             char *      dump_name = NULL;
             int         avail;
 
             xmlGenericError( xmlGenericErrorContext,
                         "xmlNanoHTTPCloseWrite:  HTTP %s to\n%s returned %d.\n",
                         http_mthd, ctxt->uri,
                         xmlNanoHTTPReturnCode( http_ctxt ) );
 
             /*
             **  Since either content or reply may be gzipped,
-            **  dump them to separate files instead of the 
+            **  dump them to separate files instead of the
             **  standard error context.
             */
 
             dump_name = tempnam( NULL, "lxml" );
             if ( dump_name != NULL ) {
                 (void)snprintf( buffer, sizeof(buffer), "%s.content", dump_name );
 
                 tst_file = fopen( buffer, "wb" );
                 if ( tst_file != NULL ) {
                     xmlGenericError( xmlGenericErrorContext,
@@ skipping 116 matching lines @@
 /**
  * xmlIOFTPRead:
  * @context:  the I/O context
  * @buffer:  where to drop data
  * @len:  number of bytes to write
  *
  * Read @len bytes to @buffer from the I/O channel.
  *
  * Returns the number of bytes written
  */
-int 
+int
 xmlIOFTPRead(void * context, char * buffer, int len) {
     if ((buffer == NULL) || (len < 0)) return(-1);
     return(xmlNanoFTPRead(context, &buffer[0], len));
 }
 
 /**
  * xmlIOFTPClose:
  * @context:  the I/O context
  *
  * Close an FTP I/O channel
@@ skipping 42 matching lines @@
  * @closeFunc:  the xmlOutputCloseCallback
  *
  * Register a new set of I/O callback for handling output.
  *
  * Returns the registered handler number or -1 in case of error
  */
 int
 xmlRegisterOutputCallbacks(xmlOutputMatchCallback matchFunc,
         xmlOutputOpenCallback openFunc, xmlOutputWriteCallback writeFunc,
         xmlOutputCloseCallback closeFunc) {
-    if (xmlOutputCallbackNr >= MAX_INPUT_CALLBACK) {
+    if (xmlOutputCallbackNr >= MAX_OUTPUT_CALLBACK) {
         return(-1);
     }
     xmlOutputCallbackTable[xmlOutputCallbackNr].matchcallback = matchFunc;
     xmlOutputCallbackTable[xmlOutputCallbackNr].opencallback = openFunc;
     xmlOutputCallbackTable[xmlOutputCallbackNr].writecallback = writeFunc;
     xmlOutputCallbackTable[xmlOutputCallbackNr].closecallback = closeFunc;
     xmlOutputCallbackInitialized = 1;
     return(xmlOutputCallbackNr++);
 }
 #endif /* LIBXML_OUTPUT_ENABLED */
@@ skipping 152 matching lines @@
     if (ret == NULL) {
         xmlIOErrMemory("creating output buffer");
         return(NULL);
     }
     memset(ret, 0, (size_t) sizeof(xmlOutputBuffer));
     ret->buffer = xmlBufferCreate();
     if (ret->buffer == NULL) {
         xmlFree(ret);
         return(NULL);
     }
-    ret->buffer->alloc = XML_BUFFER_ALLOC_DOUBLEIT;
+
+    /* try to avoid a performance problem with Windows realloc() */
+    if (ret->buffer->alloc == XML_BUFFER_ALLOC_EXACT)
+        ret->buffer->alloc = XML_BUFFER_ALLOC_DOUBLEIT;
+
     ret->encoder = encoder;
     if (encoder != NULL) {
         ret->conv = xmlBufferCreateSize(4000);
+        if (ret->conv == NULL) {
+            xmlFree(ret);
+            return(NULL);
+        }
+
         /*
          * This call is designed to initiate the encoder state
          */
-        xmlCharEncOutFunc(encoder, ret->conv, NULL); 
+        xmlCharEncOutFunc(encoder, ret->conv, NULL);
     } 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();
+    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;
+
+    ret->encoder = encoder;
+    if (encoder != NULL) {
+        ret->conv = xmlBufferCreateSize(4000);
+        if (ret->conv == NULL) {
+            xmlFree(ret);
+            return(NULL);
+        }
+
+        /*
+         * This call is designed to initiate the encoder state
+         */
+        xmlCharEncOutFunc(encoder, ret->conv, NULL);
+    } 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) {
@@ skipping 94 matching lines @@
      * Allocate the Input buffer front-end.
      */
     ret = xmlAllocParserInputBuffer(enc);
     if (ret != NULL) {
         ret->context = context;
         ret->readcallback = xmlInputCallbackTable[i].readcallback;
         ret->closecallback = xmlInputCallbackTable[i].closecallback;
 #ifdef HAVE_ZLIB_H
         if ((xmlInputCallbackTable[i].opencallback == xmlGzfileOpen) &&
                 (strcmp(URI, "-") != 0)) {
+#if defined(ZLIB_VERNUM) && ZLIB_VERNUM >= 0x1230
+            ret->compressed = !gzdirect(context);
+#else
             if (((z_stream *)context)->avail_in > 4) {
                 char *cptr, buff4[4];
                 cptr = (char *) ((z_stream *)context)->next_in;
                 if (gzread(context, buff4, 4) == 4) {
                     if (strncmp(buff4, cptr, 4) == 0)
                         ret->compressed = 0;
                     else
                         ret->compressed = 1;
                     gzrewind(context);
                 }
             }
+#endif
         }
 #endif
     }
     else
       xmlInputCallbackTable[i].closecallback (context);
 
     return(ret);
 }
 
 /**
@@ skipping 55 matching lines @@
     /*
      * Try to find one of the output accept method accepting that scheme
      * Go in reverse to give precedence to user defined handlers.
      * try with an unescaped version of the URI
      */
     if (unescaped != NULL) {
 #ifdef HAVE_ZLIB_H
         if ((compression > 0) && (compression <= 9) && (is_file_uri == 1)) {
             context = xmlGzfileOpenW(unescaped, compression);
             if (context != NULL) {
-                ret = xmlAllocOutputBuffer(encoder);
+                ret = xmlAllocOutputBufferInternal(encoder);
                 if (ret != NULL) {
                     ret->context = context;
                     ret->writecallback = xmlGzfileWrite;
                     ret->closecallback = xmlGzfileClose;
                 }
                 xmlFree(unescaped);
                 return(ret);
             }
         }
 #endif
@@ skipping 16 matching lines @@
 
     /*
      * If this failed try with a non-escaped URI this may be a strange
      * filename
      */
     if (context == NULL) {
 #ifdef HAVE_ZLIB_H
         if ((compression > 0) && (compression <= 9) && (is_file_uri == 1)) {
             context = xmlGzfileOpenW(URI, compression);
             if (context != NULL) {
-                ret = xmlAllocOutputBuffer(encoder);
+                ret = xmlAllocOutputBufferInternal(encoder);
                 if (ret != NULL) {
                     ret->context = context;
                     ret->writecallback = xmlGzfileWrite;
                     ret->closecallback = xmlGzfileClose;
                 }
                 return(ret);
             }
         }
 #endif
         for (i = xmlOutputCallbackNr - 1;i >= 0;i--) {
@@ skipping 12 matching lines @@
         }
     }
 
     if (context == NULL) {
         return(NULL);
     }
 
     /*
      * Allocate the Output buffer front-end.
      */
-    ret = xmlAllocOutputBuffer(encoder);
+    ret = xmlAllocOutputBufferInternal(encoder);
     if (ret != NULL) {
         ret->context = context;
         ret->writecallback = xmlOutputCallbackTable[i].writecallback;
         ret->closecallback = xmlOutputCallbackTable[i].closecallback;
     }
     return(ret);
 }
 
 /**
  * xmlOutputBufferCreateFilename:
@@ skipping 16 matching lines @@
                               int compression ATTRIBUTE_UNUSED) {
     if ((xmlOutputBufferCreateFilenameValue)) {
                 return xmlOutputBufferCreateFilenameValue(URI, encoder, compression);
         }
         return __xmlOutputBufferCreateFilename(URI, encoder, compression);
 }
 #endif /* LIBXML_OUTPUT_ENABLED */
 
 /**
  * xmlParserInputBufferCreateFile:
- * @file:  a FILE* 
+ * @file:  a FILE*
  * @enc:  the charset encoding if known
  *
  * Create a buffered parser input for the progressive parsing of a FILE *
  * buffered C I/O
  *
  * Returns the new parser input or NULL
  */
 xmlParserInputBufferPtr
 xmlParserInputBufferCreateFile(FILE *file, xmlCharEncoding enc) {
     xmlParserInputBufferPtr ret;
 
     if (xmlInputCallbackInitialized == 0)
         xmlRegisterDefaultInputCallbacks();
 
     if (file == NULL) return(NULL);
 
     ret = xmlAllocParserInputBuffer(enc);
     if (ret != NULL) {
         ret->context = file;
         ret->readcallback = xmlFileRead;
         ret->closecallback = xmlFileFlush;
     }
 
     return(ret);
 }
 
 #ifdef LIBXML_OUTPUT_ENABLED
 /**
  * xmlOutputBufferCreateFile:
- * @file:  a FILE* 
+ * @file:  a FILE*
  * @encoder:  the encoding converter or NULL
  *
  * Create a buffered output for the progressive saving to a FILE *
  * buffered C I/O
  *
  * Returns the new parser output or NULL
  */
 xmlOutputBufferPtr
 xmlOutputBufferCreateFile(FILE *file, xmlCharEncodingHandlerPtr encoder) {
     xmlOutputBufferPtr ret;
 
     if (xmlOutputCallbackInitialized == 0)
         xmlRegisterDefaultOutputCallbacks();
 
     if (file == NULL) return(NULL);
 
-    ret = xmlAllocOutputBuffer(encoder);
+    ret = xmlAllocOutputBufferInternal(encoder);
     if (ret != NULL) {
         ret->context = file;
         ret->writecallback = xmlFileWrite;
         ret->closecallback = xmlFileFlush;
     }
 
     return(ret);
 }
 
 /**
@@ skipping 126 matching lines @@
 
     return(ret);
 }
 
 #ifdef LIBXML_OUTPUT_ENABLED
 /**
  * xmlOutputBufferCreateFd:
  * @fd:  a file descriptor number
  * @encoder:  the encoding converter or NULL
  *
- * Create a buffered output for the progressive saving 
+ * Create a buffered output for the progressive saving
  * to a file descriptor
  *
  * Returns the new parser output or NULL
  */
 xmlOutputBufferPtr
 xmlOutputBufferCreateFd(int fd, xmlCharEncodingHandlerPtr encoder) {
     xmlOutputBufferPtr ret;
 
     if (fd < 0) return(NULL);
 
-    ret = xmlAllocOutputBuffer(encoder);
+    ret = xmlAllocOutputBufferInternal(encoder);
     if (ret != NULL) {
         ret->context = (void *) (long) fd;
         ret->writecallback = xmlFdWrite;
         ret->closecallback = NULL;
     }
 
     return(ret);
 }
 #endif /* LIBXML_OUTPUT_ENABLED */
 
@@ skipping 40 matching lines @@
  * Returns the new parser output or NULL
  */
 xmlOutputBufferPtr
 xmlOutputBufferCreateIO(xmlOutputWriteCallback   iowrite,
          xmlOutputCloseCallback  ioclose, void *ioctx,
          xmlCharEncodingHandlerPtr encoder) {
     xmlOutputBufferPtr ret;
 
     if (iowrite == NULL) return(NULL);
 
-    ret = xmlAllocOutputBuffer(encoder);
+    ret = xmlAllocOutputBufferInternal(encoder);
     if (ret != NULL) {
         ret->context = (void *) ioctx;
         ret->writecallback = iowrite;
         ret->closecallback = ioclose;
     }
 
     return(ret);
 }
 #endif /* LIBXML_OUTPUT_ENABLED */
 
@@ skipping 189 matching lines @@
         use = in->raw->use;
         nbchars = xmlCharEncInFunc(in->encoder, in->buffer, in->raw);
         if (nbchars < 0) {
             xmlIOErr(XML_IO_ENCODER, NULL);
             in->error = XML_IO_ENCODER;
             return(-1);
         }
         in->rawconsumed += (use - in->raw->use);
     } else {
         nbchars = len;
-        in->buffer->use += nbchars;
+        in->buffer->use += nbchars;
         buffer[nbchars] = 0;
     }
 #ifdef DEBUG_INPUT
     xmlGenericError(xmlGenericErrorContext,
             "I/O: read %d chars, buffer %d/%d\n",
             nbchars, in->buffer->use, in->buffer->size);
 #endif
     return(nbchars);
 }
 
@@ skipping 89 matching lines @@
         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, 
+                ret = out->writecallback(out->context,
                                  (const char *)out->conv->content, nbchars);
                 if (ret >= 0)
                     xmlBufferShrink(out->conv, ret);
             } else {
-                ret = out->writecallback(out->context, 
+                ret = out->writecallback(out->context,
                                  (const char *)out->buffer->content, nbchars);
                 if (ret >= 0)
                     xmlBufferShrink(out->buffer, ret);
             }
             if (ret < 0) {
                 xmlIOErr(XML_IO_WRITE, NULL);
                 out->error = XML_IO_WRITE;
                 return(ret);
             }
             out->written += ret;
@@ skipping 24 matching lines @@
  */
 static int
 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';
             *out++ = ';';
         } else if (*in == '&') {
             if (outend - out < 5) break;
             *out++ = '&';
             *out++ = 'a';
             *out++ = 'm';
             *out++ = 'p';
             *out++ = ';';
         } else if (*in == '\r') {
             if (outend - out < 5) break;
             *out++ = '&';
             *out++ = '#';
             *out++ = '1';
             *out++ = '3';
             *out++ = ';';
         } else {
             *out++ = (unsigned char) *in;
         }
         ++in;
-    }   
+    }
     *outlen = out - outstart;
     *inlen = in - base;
     return(0);
 }
 
 /**
  * xmlOutputBufferWriteEscape:
  * @out:  a buffered parser output
  * @str:  a zero terminated UTF-8 string
  * @escaping:  an optional escaping function (or NULL)
@@ skipping 33 matching lines @@
          * how many bytes to consume and how many bytes to store.
          */
         cons = len;
         chunk = (out->buffer->size - out->buffer->use) - 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) {
-            nbchars = 0;
-            oldwritten = -1;
-            goto flush;
+            if (xmlBufferGrow(out->buffer, out->buffer->size + 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) {
@@ skipping 27 matching lines @@
             out->buffer->use += chunk;
             out->buffer->content[out->buffer->use] = 0;
             nbchars = out->buffer->use;
         }
         str += cons;
         len -= cons;
 
         if ((nbchars < MINLEN) && (len <= 0))
             goto done;
 
-flush:
         if (out->writecallback) {
             /*
              * second write the stuff to the I/O channel
              */
             if (out->encoder != NULL) {
-                ret = out->writecallback(out->context, 
+                ret = out->writecallback(out->context,
                                  (const char *)out->conv->content, nbchars);
                 if (ret >= 0)
                     xmlBufferShrink(out->conv, ret);
             } else {
-                ret = out->writecallback(out->context, 
+                ret = out->writecallback(out->context,
                                  (const char *)out->buffer->content, nbchars);
                 if (ret >= 0)
                     xmlBufferShrink(out->buffer, ret);
             }
             if (ret < 0) {
                 xmlIOErr(XML_IO_WRITE, NULL);
                 out->error = XML_IO_WRITE;
                 return(ret);
             }
             out->written += ret;
@@ skipping 20 matching lines @@
  * This routine handle the I18N transcoding from internal UTF-8
  * The buffer is lossless, i.e. will store in case of partial
  * or delayed writes.
  *
  * Returns the number of chars immediately written, or -1
  *         in case of error.
  */
 int
 xmlOutputBufferWriteString(xmlOutputBufferPtr out, const char *str) {
     int len;
-    
+
     if ((out == NULL) || (out->error)) return(-1);
     if (str == NULL)
         return(-1);
     len = strlen(str);
 
     if (len > 0)
         return(xmlOutputBufferWrite(out, len, str));
     return(len);
 }
 
@@ skipping 196 matching lines @@
         path = &URL[17];
 #else
         path = &URL[16];
 #endif
     else if (!xmlStrncasecmp(BAD_CAST URL, BAD_CAST "file:///", 8)) {
 #if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
         path = &URL[8];
 #else
         path = &URL[7];
 #endif
-    } else 
+    } else
         path = URL;
-        
+
     return xmlCheckFilename(path);
 }
 
 #ifdef LIBXML_CATALOG_ENABLED
 
 /**
  * xmlResolveResourceFromCatalog:
  * @URL:  the URL for the entity to load
  * @ID:  the System ID for the entity to load
  * @ctxt:  the context in which the entity is called or NULL
@@ skipping 167 matching lines @@
         }
 
         ret = xmlCurrentExternalEntityLoader(canonicFilename, ID, ctxt);
         xmlFree(canonicFilename);
         return(ret);
     }
     return(xmlCurrentExternalEntityLoader(URL, ID, ctxt));
 }
 
 /************************************************************************
- *                                                                      *
- *              Disabling Network access                                *
- *                                                                      *
+ *                                                                      *
+ *              Disabling Network access                                *
+ *                                                                      *
  ************************************************************************/
 
 /**
  * xmlNoNetExternalEntityLoader:
  * @URL:  the URL for the entity to load
  * @ID:  the System ID for the entity to load
  * @ctxt:  the context in which the entity is called or NULL
  *
  * A specific entity loader disabling network accesses, though still
  * allowing local catalog accesses for resolution.
@@ skipping 23 matching lines @@
         }
     }
     input = xmlDefaultExternalEntityLoader((const char *) resource, ID, ctxt);
     if (resource != (xmlChar *) URL)
         xmlFree(resource);
     return(input);
 }
 
 #define bottom_xmlIO
 #include "elfgcchack.h"