Changeset 47500 in vbox

Timestamp:

Aug 1, 2013 6:01:14 AM (12 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

87679

Message:

pr6022. Second variant of support GZIP files for OVA appliance.

Location:

trunk

Files:

• include/iprt/mangling.h (modified) (1 diff)
• include/iprt/zip.h (modified) (1 diff)
• src/VBox/Main/include/ApplianceImplPrivate.h (modified) (1 diff)
• src/VBox/Main/src-server/ApplianceImplIO.cpp (modified) (12 diffs)
• src/VBox/Main/src-server/ApplianceImplImport.cpp (modified) (11 diffs)
• src/VBox/Runtime/common/zip/zip.cpp (modified) (2 diffs)

trunk/include/iprt/mangling.h

@@ -1861 +1861 @@
 # define RTZipDecompDestroy                             RT_MANGLER(RTZipDecompDestroy)
 # define RTZipDecompress                                RT_MANGLER(RTZipDecompress)
+# define RTZipGzipFileBufferDecompress                  RT_MANGLER(RTZipGzipFileBufferDecompress)
 # define RTZipGzipCompressIoStream                      RT_MANGLER(RTZipGzipCompressIoStream)
 # define RTZipGzipDecompressIoStream                    RT_MANGLER(RTZipGzipDecompressIoStream)
 # define RTZipTarCmd                                    RT_MANGLER(RTZipTarCmd)
 # define RTZipTarFsStreamFromIoStream                   RT_MANGLER(RTZipTarFsStreamFromIoStream)
+
 /*
  * Stable variables (alphabetical order):

trunk/include/iprt/zip.h

@@ -170 +170 @@
 
 /**
+ * Decompresses a chunk of Gzip file.
+ *
+ * @returns iprt status code.
+ * @param   pZip        The stream decompressor instance. 
+ * @param   pvBufIn     Where to read the compressed data from.
+ * @param   cbBufIn     Number of bytes to read. 
+ * @param   pcbRead     Number of bytes actually read from the 
+ *                      buffer
+ * @param   pvBufOut    Where to store the decompressed data.
+ * @param   cbBufOut    Number of bytes to produce.
+ * @param   pcbWritten  Number of bytes actually written to the 
+ *                      buffer.
+ */
+RTDECL(int)     RTZipGzipFileBufferDecompress(PRTZIPDECOMP pZip,
+                                              void *pvBufIn, 
+                                              size_t cbBufIn, 
+                                              size_t *pcbRead,
+                                              void *pvBufOut, 
+                                              size_t cbBufOut, 
+                                              size_t *pcbWritten);
+
+/**
  * Destroys the stream decompressor instance.
  *

trunk/src/VBox/Main/include/ApplianceImplPrivate.h

@@ -241 +241 @@
 PVDINTERFACEIO FileCreateInterface();
 PVDINTERFACEIO TarCreateInterface();
+int copyFileAndCalcShaDigest(const char *pcszSourceFilename, const char *pcszTargetFilename, PVDINTERFACEIO pIfIo, void *pvUser);
 int ShaReadBuf(const char *pcszFilename, void **ppvBuf, size_t *pcbSize, PVDINTERFACEIO pIfIo, void *pvUser);
 int ShaWriteBuf(const char *pcszFilename, void *pvBuf, size_t cbSize, PVDINTERFACEIO pIfIo, void *pvUser);
 int decompressImageAndSave(const char *pcszFullFilenameIn, const char *pcszFullFilenameOut, PVDINTERFACEIO pIfIo, void *pvUser);
+
 #endif // !____H_APPLIANCEIMPLPRIVATE
 

trunk/src/VBox/Main/src-server/ApplianceImplIO.cpp

@@ -34 +34 @@
 #include <iprt/vfs.h>
 #include <VBox/vd.h>
-#include <zlib.h>
-//#define VBOX_MAIN_USE_VFS /** @todo Replace as much as possible with IPRT VFS. */
 
 /******************************************************************************
@@ -96 +94 @@
 } SHASTORAGEINTERNAL, *PSHASTORAGEINTERNAL;
 
+
 /******************************************************************************
  *   Defined Constants And Macros                                             *
@@ -117 +116 @@
  *   Internal Functions                                                       *
  ******************************************************************************/
-
+/**
+ * dummy function is needed only for initialization PRTZIPDECOMP pZipDecomp.
+ * see the call/description of RTZipDecompCreate
+ */
+static DECLCALLBACK(int) FillBufferWithGzipData(void *pvUser, void *pvBuf, size_t cbBuf, size_t *pcbBuf)
+{
+    return VINF_SUCCESS;
+}
 
 /******************************************************************************
@@ -1241 +1247 @@
 }
 
+
+int copyFileAndCalcShaDigest(const char *pcszSourceFilename, const char *pcszTargetFilename, PVDINTERFACEIO pIfIo, void *pvUser)
+{
+    /* Validate input. */
+    AssertPtrReturn(pIfIo, VERR_INVALID_POINTER);
+
+    void *pvStorage;
+    RTFILE pFile = NULL;
+
+    int rc = pIfIo->pfnOpen(pvUser, pcszSourceFilename,
+                            RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_NONE, 0,
+                            &pvStorage);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    try
+    {
+        if (RTFileExists(pcszTargetFilename) == false)
+        {
+            /* ensure the directory exists */
+            rc = VirtualBox::ensureFilePathExists(pcszTargetFilename, true);
+            if (FAILED(rc))
+                throw rc;
+
+            // create a new file and copy raw data into one from buffer pvTmpBuf
+            rc = RTFileOpen(&pFile,
+                            pcszTargetFilename,
+                            RTFILE_O_OPEN_CREATE | RTFILE_O_WRITE | RTFILE_O_DENY_NONE);
+
+            if (RT_FAILURE(rc) || pFile == NULL)
+            {
+                throw rc;
+            }
+        }
+        else
+        {
+            rc = RTFileOpen(&pFile,
+                            pcszTargetFilename,
+                            RTFILE_O_CREATE_REPLACE | RTFILE_O_WRITE | RTFILE_O_DENY_NONE);
+            if (RT_FAILURE(rc) || pFile == NULL)
+            {
+                throw rc;
+            }
+        }
+    }
+    catch(...)
+    {
+        pIfIo->pfnClose(pvUser, pvStorage);
+        return rc;
+    }
+
+    void *pvTmpBuf = 0;
+    uint64_t cbTmpSize = _1M;
+    size_t cbAllRead = 0;
+    do
+    {
+        pvTmpBuf = RTMemAlloc(cbTmpSize);
+        if (!pvTmpBuf)
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+
+        for (;;)
+        {
+            size_t cbRead = 0;
+            rc = pIfIo->pfnReadSync(pvUser, pvStorage, cbAllRead, pvTmpBuf, cbTmpSize, &cbRead);
+            if (   RT_FAILURE(rc)
+                || cbRead == 0)
+                break;
+
+            size_t cbWritten = 0;
+
+            rc = RTFileWrite(pFile, pvTmpBuf, cbRead, &cbWritten);
+
+            if (RT_FAILURE(rc))
+            {
+                break;
+            }
+
+            cbAllRead += cbRead;
+        }
+    } while (0);
+
+    pIfIo->pfnClose(pvUser, pvStorage);
+    RTFileClose(pFile);
+
+    if (rc == VERR_EOF)
+        rc = VINF_SUCCESS;
+
+    if (pvTmpBuf)
+        RTMemFree(pvTmpBuf);
+
+    return rc;
+}
+
 int ShaReadBuf(const char *pcszFilename, void **ppvBuf, size_t *pcbSize, PVDINTERFACEIO pIfIo, void *pvUser)
 {
@@ -1336 +1438 @@
 
     rc = pIfIo->pfnClose(pvUser, pvStorage);
-
-    return rc;
-}
-
-static int zipDecompressBuffer(z_stream streamIn,
-                                      uint32_t *cbDecompressed,
-                                      bool *finished)
-{
-    int rc;
-    int sh = streamIn.avail_out;
-
-    *cbDecompressed = 0;
-
-    do
-    {
-        rc = inflate(&streamIn, Z_NO_FLUSH);
-
-        if (rc < 0)
-        {
-            switch (rc)
-            {
-                case Z_STREAM_ERROR:
-                    rc = VERR_ZIP_CORRUPTED;
-                    break;
-                case Z_DATA_ERROR:
-                    rc = VERR_ZIP_CORRUPTED;
-                    break;
-                case Z_MEM_ERROR:
-                    rc = VERR_ZIP_NO_MEMORY;
-                    break;
-                case Z_BUF_ERROR:
-                    rc = VERR_ZIP_ERROR;
-                    break;
-                case Z_VERSION_ERROR:
-                    rc = VERR_ZIP_UNSUPPORTED_VERSION;
-                    break;
-                case Z_ERRNO: /* We shouldn't see this status! */
-                default:
-                    AssertMsgFailed(("%d\n", rc));
-                    if (rc >= 0)
-                        rc = VINF_SUCCESS;
-                    rc = VERR_ZIP_ERROR;
-            }
-
-            break;
-        }
-
-        *cbDecompressed += (sh - streamIn.avail_out);
-        sh = streamIn.avail_out;
-    }
-    while (streamIn.avail_out > 0 && streamIn.avail_in > 0 );
-
-    if (RT_SUCCESS(rc))
-    {
-        if (streamIn.avail_in == 0)
-            *finished = true;
-        else
-        {
-            if (streamIn.avail_out == 0)
-                *finished = false;
-        }
-    }
 
     return rc;
@@ -1416 +1456 @@
     if (RT_FAILURE(rc))
         return rc;
-#ifdef VBOX_MAIN_USE_VFS
-
-    /* Turn the source file handle/whatever into a VFS stream. */
-    RTVFSIOSTREAM hVfsIosCompressedSrc;
-    rc = VDIfCreateVfsStream(pIfIo, pvStorage, RTFILE_O_READ, &hVfsIosCompressedSrc);
-    if (RT_SUCCESS(rc))
-    {
-        /* Pass the source thru gunzip. */
-        RTVFSIOSTREAM hVfsIosSrc;
-        rc = RTZipGzipDecompressIoStream(hVfsIosCompressedSrc, 0, &hVfsIosSrc);
-        if (RT_SUCCESS(rc))
-        {
-            /*
-             * Create the output file, including necessary paths.
-             * Any existing file will be overwritten.
-             */
-            rc = VirtualBox::ensureFilePathExists(Utf8Str(pcszFullFilenameOut), true /*fCreate*/);
-            if (RT_SUCCESS(rc))
-            {
-                RTVFSIOSTREAM hVfsIosDst;
-                rc = RTVfsIoStrmOpenNormal(pcszFullFilenameOut,
-                                           RTFILE_O_CREATE_REPLACE | RTFILE_O_WRITE | RTFILE_O_DENY_ALL,
-                                           &hVfsIosDst);
-                if (RT_SUCCESS(rc))
-                {
-                    /*
-                     * Pump the bytes thru. If we fail, delete the output file.
-                     */
-                    rc = RTVfsUtilPumpIoStreams(hVfsIosSrc, hVfsIosDst, 0);
-
-                    RTVfsIoStrmRelease(hVfsIosDst);
-                    RTFileDelete(pcszFullFilenameOut);
-                }
-            }
-
-            RTVfsIoStrmRelease(hVfsIosSrc);
-        }
-        RTVfsIoStrmRelease(hVfsIosCompressedSrc);
-    }
-    pIfIo->pfnClose(pvUser, pvStorage);
-
-#else
-
-    Bytef *decompressedBuffer = 0;
-    Bytef *compressedBuffer = 0;
+
+    uint8_t *compressedBuffer = 0;
+    uint8_t *decompressedBuffer = 0;
     uint64_t cbTmpSize = _1M;
     size_t cbAllRead = 0;
     size_t cbAllWritten = 0;
     RTFILE pFile = NULL;
-    z_stream gzipStream;
+    PRTZIPDECOMP pZipDecomp;
 
     Utf8Str pathOut(pcszFullFilenameOut);
@@ -1498 +1496 @@
         }
 
-        compressedBuffer = (Bytef *)RTMemAlloc(cbTmpSize);
+        compressedBuffer = (uint8_t *)RTMemAlloc(cbTmpSize);
 
         if (!compressedBuffer)
@@ -1506 +1504 @@
         }
 
-
-        decompressedBuffer = (Bytef *)RTMemAlloc(cbTmpSize*10);
+        decompressedBuffer = (uint8_t *)RTMemAlloc(cbTmpSize);
 
         if (!decompressedBuffer)
@@ -1515 +1512 @@
         }
 
-        gzipStream.zalloc = Z_NULL;
-        gzipStream.zfree = Z_NULL;
-        gzipStream.opaque = Z_NULL;
-        gzipStream.next_in = compressedBuffer;
-        gzipStream.avail_in = 0;
-        gzipStream.next_out = decompressedBuffer;
-        gzipStream.avail_out = cbTmpSize*10;
-
-        rc = inflateInit2(&gzipStream, MAX_WBITS + 16 /* autodetect gzip header */);
+        rc = RTZipDecompCreate(&pZipDecomp, NULL, FillBufferWithGzipData);
 
         if (rc < 0)
@@ -1530 +1519 @@
         }
 
-        size_t cbRead = 0;
+        size_t cbRead = 0, cbActuallyRead = 0;
         size_t cbDecompressed = 0;
-        bool fFinished = true;
+        bool fData = false;
+        uint8_t *currentInput = compressedBuffer;
 
         for (;;)
         {
-            if (fFinished == true)
+            /*
+             * skip reading a new chunk of compressed data in case if we decompressed not at all data from the buffer
+             * 
+             */
+            if (fData == false)
             {
                 rc = pIfIo->pfnReadSync(pvUser, pvStorage, cbAllRead, compressedBuffer, cbTmpSize, &cbRead);
-                if (   RT_FAILURE(rc)
-                    || cbRead == 0)
+                if (RT_FAILURE(rc) || cbRead == 0)
                     break;
 
-                gzipStream.avail_in = cbRead;
-                gzipStream.avail_out = cbTmpSize*10;
+                currentInput = compressedBuffer;
             }
 
-            /* decompress the buffer */
-            rc = zipDecompressBuffer(gzipStream,
-                                           (uint32_t *)(&cbDecompressed),
-                                           &fFinished);
+            rc = RTZipGzipFileBufferDecompress(pZipDecomp, 
+                                               currentInput,
+                                               cbRead,
+                                               &cbActuallyRead,
+                                               decompressedBuffer, 
+                                               cbTmpSize, 
+                                               &cbDecompressed);
 
             if (RT_FAILURE(rc))
                 break;
 
+            cbAllRead += cbActuallyRead;
+
+            if (cbRead == cbActuallyRead)
+            {
+                /* it means the input buffer is empty */
+                fData = false;
+            }
+            else
+            {
+                /* some data still leaves in the input buffer */
+                fData = true;
+                cbRead = cbRead - cbActuallyRead;
+                currentInput = &currentInput[cbActuallyRead];
+            }
+
+            /* write decompressed data to the output file */
             rc = RTFileWrite(pFile, decompressedBuffer, cbDecompressed, &cbDecompressed);
 
@@ -1561 +1572 @@
 
             cbAllWritten += cbDecompressed;
-            cbAllRead += cbRead;
         }
     } while (0);
@@ -1570 +1580 @@
         rc = VINF_SUCCESS;
 
-    rc = inflateEnd(&gzipStream);
-
-    rc = RTFileClose(pFile);
-
+    RTZipDecompDestroy(pZipDecomp);
+
+    RTFileClose(pFile);
+
+    if (compressedBuffer)
+        RTMemFree(compressedBuffer);
     if (decompressedBuffer)
         RTMemFree(decompressedBuffer);
-    if (compressedBuffer)
-        RTMemFree(compressedBuffer);
-#endif /* !VBOX_MAIN_USE_VFS */
 
     return rc;
 }
 
-

trunk/src/VBox/Main/src-server/ApplianceImplImport.cpp

@@ -977 +977 @@
                     uint64_t maxFileSize = _1M;
                     size_t cbRead = 0;
-                    void  *pBuf; /** @todo r=bird: You leak this buffer! throwing stuff is evil. */
+                    void  *pBuf;
 
                     vrc = RTFileGetSize(pFile, &cbFile);
@@ -1008 +1008 @@
                     vrc = RTManifestVerifyDigestType(pBuf, cbRead, &digestType);
 
+                    /* pBuf isn't needed more. Here we free the memory allocated by the pBuf */
+                    if (pBuf)
+                        RTMemFree(pBuf);
+
                     if (RT_FAILURE(vrc))
                     {
-                        if (pBuf)
-                            RTMemFree(pBuf);
                         throw setError(VBOX_E_FILE_ERROR,
                                tr("Could not verify supported digest types in the manifest file '%s' (%Rrc)"),
@@ -1559 +1561 @@
 
             size_t cbCertSize = 0;
-            Utf8Str manifestShaDigest;
+            /* Save the SHA digest of the manifest file for the next validation */
+            Utf8Str manifestShaDigest = storage.strDigest;
             Utf8Str strCertFile = Utf8Str(pTask->locInfo.strPath).stripExt().append(".cert");
             if (RTFileExists(strCertFile.c_str()))
@@ -1565 +1568 @@
                 rc = readFileToBuf(strCertFile, &pvCertBuf, &cbCertSize, false, pShaIo, &storage);
                 if (FAILED(rc)) throw rc;
-
-                /* Save the SHA digest of the manifest file for the next validation */
-                manifestShaDigest = storage.strDigest;
 
                 /* verify Certificate */
@@ -2259 +2259 @@
     {
         /* check read file to GZIP compression */
+        bool fGzipUsed = !(di.strCompression.compare("gzip",Utf8Str::CaseInsensitive));
         try
         {
-            if (di.strCompression.compare("gzip",Utf8Str::CaseInsensitive) == 0)
-            {
-                /*
-                 * 1. extract a file to the local/temporary folder
-                 * 2. apply GZIP decompression for the file
-                 * 3. replace the value of strSrcFilePath with a new path to the file
-                 * 4. replace SHA-TAR I/O interface with File I/O interface
-                 * 5. save calculated SHA digest of GZIPed file for later validation
-                 */
-
+            if (fGzipUsed == true)
+            {
                 /* Decompress the GZIP file and save a new file in the target path */
                 strTargetDir = strTargetDir.stripFilename();
@@ -2289 +2282 @@
                                    RTPathFilename(strSrcFilePath.c_str()), vrc);
 
-                /* Create the necessary file access interfaces. */
+                /* 
+                 * Create the necessary file access interfaces. 
+                 * For the next step: 
+                 * We need to replace the previously created chain of SHA-TAR or SHA-FILE interfaces 
+                 * with simple FILE interface because we don't need SHA or TAR interfaces here anymore. 
+                 * But we mustn't delete the chain of SHA-TAR or SHA-FILE interfaces.
+                 */
                 pFileIo = FileCreateInterface();
                 if (!pFileIo)
@@ -2303 +2302 @@
                                    tr("Creation of the VD interface failed (%Rrc)"), vrc);
 
+                /* Correct the source and the target with the actual values */
                 strSrcFilePath = strTargetDir;
                 strTargetDir = strTargetDir.stripFilename();
@@ -2315 +2315 @@
             ULONG lCabs = 0;
 
+            char *pszExt = NULL;
+
             if (RTPathHaveExt(strTargetPath->c_str()))
             {
-                char *pszExt = RTPathExt(strTargetPath->c_str());
+                pszExt = RTPathExt(strTargetPath->c_str());
+
                 /* Figure out which format the user like to have. Default is VMDK. */
                 ComObjPtr<MediumFormat> trgFormat = pSysProps->mediumFormatFromExtension(&pszExt[1]);
@@ -2347 +2350 @@
                 strTrgFormat = Utf8Str(bstrFormatName);
             }
+            else
+            {
+                throw setError(VBOX_E_FILE_ERROR,
+                               tr("The target disk '%s' has no extension "),
+                               strTargetPath->c_str(), VERR_INVALID_NAME);
+            }
 
             /* Create an IMedium object. */
@@ -2355 +2364 @@
             {
                 void *pvTmpBuf = 0;
-                size_t cbSize = 0;
+
                 try
                 {
-                    /* Read the ISO file into a memory buffer */
-                    vrc = ShaReadBuf(strSrcFilePath.c_str(), &pvTmpBuf, &cbSize, pCallbacks, pRealUsedStorage);
-
-                    if ( RT_FAILURE(vrc) || !pvTmpBuf)
-                        throw setError(VBOX_E_FILE_ERROR,
-                                       tr("Could not read ISO file '%s' listed in the OVF file (%Rrc)"),
-                                       RTPathFilename(strSourceOVF.c_str()), vrc);
-
-                    if (RTFileExists(strTargetPath->c_str()) == false)
+                    if (fGzipUsed == true)
                     {
-
-                        /* ensure the directory exists */
-                        if (lCabs & MediumFormatCapabilities_File)
-                        {
-                            rc = VirtualBox::ensureFilePathExists(*strTargetPath, true);
-                            if (FAILED(rc))
-                                throw rc;
-                        }
-
-                        // create a new file and copy raw data into one from buffer pvTmpBuf
-                        RTFILE pFile = NULL;
-                        vrc = RTFileOpen(&pFile,
-                                         strTargetPath->c_str(),
-                                         RTFILE_O_OPEN_CREATE | RTFILE_O_WRITE | RTFILE_O_DENY_NONE);
-
-                        if (RT_SUCCESS(vrc) && pFile != NULL)
-                        {
-                            size_t cbWritten = 0;
-
-                            vrc = RTFileWrite(pFile, pvTmpBuf, cbSize, &cbWritten);
-
-                            if (RT_FAILURE(vrc))
-                            {
-                                Utf8Str path(*strTargetPath);
-                                path = path.stripFilename();
-
-                                throw setError(VBOX_E_FILE_ERROR,
-                                               tr("Could not write the ISO file '%s' into the folder %s (%Rrc)"),
-                                               strSrcFilePath.stripPath().c_str(),
-                                               path.c_str(),
-                                               vrc);
-                            }
-                        }
-                        RTFileClose(pFile);
+                        /* 
+                         * The source and target pathes are the same. 
+                         * It means that we have the needed file already.
+                         * For example, in GZIP case, we decompress the file and save it in the target path, 
+                         * but with some prefix like "temp_". See part "check read file to GZIP compression" earlier 
+                         * in this function.
+                         * Just rename the file by deleting "temp_" from it's name 
+                         */
+                        vrc = RTFileRename(strSrcFilePath.c_str(), strTargetPath->c_str(), RTPATHRENAME_FLAGS_NO_REPLACE);
+                        if (RT_FAILURE(vrc))
+                            throw setError(VBOX_E_FILE_ERROR,
+                                           tr("Could not rename the file '%s' (%Rrc)"),
+                                           RTPathFilename(strSourceOVF.c_str()), vrc);
+
+                    }
+                    else
+                    {
+                        /* Calculating SHA digest for ISO file while copying one */
+                        vrc = copyFileAndCalcShaDigest(strSrcFilePath.c_str(), 
+                                                       strTargetPath->c_str(), 
+                                                       pCallbacks, 
+                                                       pRealUsedStorage);
+
+                        if (RT_FAILURE(vrc))
+                            throw setError(VBOX_E_FILE_ERROR,
+                                           tr("Could not copy ISO file '%s' listed in the OVF file (%Rrc)"),
+                                           RTPathFilename(strSourceOVF.c_str()), vrc);
                     }
                 }
@@ -2493 +2487 @@
                 ComPtr<IProgress> pp(pProgress);
                 waitForAsyncProgress(stack.pProgress, pp);
+
+                if (fGzipUsed == true)
+                {
+                    /* 
+                     * Just delete the temporary file
+                     */
+                    vrc = RTFileDelete(strSrcFilePath.c_str());
+                    if (RT_FAILURE(vrc))
+                        setWarning(VBOX_E_FILE_ERROR,
+                                   tr("Could not delete the file '%s' (%Rrc)"),
+                                   RTPathFilename(strSrcFilePath.c_str()), vrc);
+                }
             }
         }

trunk/src/VBox/Runtime/common/zip/zip.cpp

@@ -616 +616 @@
 }
 
+/** 
+ * pZip->u.Zlib.avail_in must be correctly initialized before 
+ * calling this function 
+ * pZip->u.Zlib.next_in must be correctly initialized before 
+ * calling this function 
+ *  
+ * @param pZip The decompressor instance. 
+ * @param pvBufOut    Where to store the decompressed data.
+ * @param cbBufOut    Number of bytes to produce. 
+ * @param pcbWritten  Number of bytes actually written to the 
+ *                    buffer
+ * 
+ * @return iprt status code. 
+ */
+static DECLCALLBACK(int) rtZipZlibBufferDecompress(PRTZIPDECOMP pZip, void *pvBufOut, size_t cbBufOut, size_t *pcbWritten)
+{
+    int rc = VINF_SUCCESS;
+    pZip->u.Zlib.next_out = (Bytef *)pvBufOut;
+    pZip->u.Zlib.avail_out = (uInt)cbBufOut;
+    int sh = pZip->u.Zlib.avail_out;
+
+    *pcbWritten = 0;
+
+    do
+    {
+        rc = inflate(&pZip->u.Zlib, Z_SYNC_FLUSH);
+
+        if (rc != Z_OK && rc != Z_STREAM_END)
+        {
+            rc = zipErrConvertFromZlib(rc, false /*fCompressing*/);
+            break;
+        }
+
+        *pcbWritten += (sh - pZip->u.Zlib.avail_out);
+        sh = pZip->u.Zlib.avail_out;
+    }
+    while (pZip->u.Zlib.avail_out > 0 && pZip->u.Zlib.avail_in > 0 );
+
+    return rc;
+}
 
 /**
@@ -1637 +1677 @@
 }
 
+/**
+ * Lazy init of the decompressor for the Gzip file.
+ * @return iprt status code.
+ * @param   pZip  The decompressor instance.
+ */
+static int rtzipGzipFileDecompInit(PRTZIPDECOMP pZip)
+{
+    int rc = 0;
+#ifdef RTZIP_USE_ZLIB
+    pZip->pfnDecompress = rtZipZlibBufferDecompress;
+    pZip->pfnDestroy = rtZipZlibDecompDestroy;
+
+    memset(&pZip->u.Zlib, 0, sizeof(pZip->u.Zlib));
+    pZip->enmType = RTZIPTYPE_ZLIB;
+    pZip->u.Zlib.opaque    = pZip;
+
+    rc = inflateInit2(&pZip->u.Zlib, MAX_WBITS + 16 /* autodetect gzip header */);
+    rc >= 0 ? VINF_SUCCESS : zipErrConvertFromZlib(rc, false /*fCompressing*/);
+#else
+    AssertMsgFailed(("Zlib is not include in this build!\n"));
+#endif
+
+    if (RT_FAILURE(rc))
+    {
+        pZip->pfnDecompress = rtZipStubDecompress;
+        pZip->pfnDestroy = rtZipStubDecompDestroy;
+    }
+
+    return rc;
+}
+
+/**
+ * Decompresses a chunk of Gzip file.
+ *
+ * @returns iprt status code.
+ * @param   pZip        The stream decompressor instance. 
+ * @param   pvBufIn     Where to read the compressed data from.
+ * @param   cbBufIn     Number of bytes to read. 
+ * @param   pcbRead     Number of bytes actually read from the 
+ *                      buffer
+ * @param   pvBufOut    Where to store the decompressed data.
+ * @param   cbBufOut    Number of bytes to produce. 
+ * @param   pcbWritten  Number of bytes actually written to the 
+ *                      buffer.
+ */
+RTDECL(int)     RTZipGzipFileBufferDecompress(PRTZIPDECOMP pZip, 
+                                        void *pvBufIn, 
+                                        size_t cbBufIn, 
+                                        size_t *pcbRead,
+                                        void *pvBufOut, 
+                                        size_t cbBufOut, 
+                                        size_t *pcbWritten)
+{
+    int rc;
+    /*
+     * Skip empty requests.
+     */
+    if (!cbBufIn)
+        return VINF_SUCCESS;
+
+    if (!pZip->pfnDecompress)
+    {
+        rc = rtzipGzipFileDecompInit(pZip);
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+
+    pZip->u.Zlib.avail_in = (uInt)cbBufIn;
+    pZip->u.Zlib.next_in = (Bytef *)pvBufIn;
+
+    /*
+     * 'Read' the decompressed stream.
+     */
+    rc = pZip->pfnDecompress(pZip, pvBufOut, cbBufOut, pcbWritten);
+
+    *pcbRead = cbBufIn - pZip->u.Zlib.avail_in;
+
+    return rc;
+}
+RT_EXPORT_SYMBOL(RTZipGzipFileBufferDecompress);
 
 /**