Changeset 47340 in vbox

Timestamp:

Jul 23, 2013 12:27:35 PM (12 years ago)

Author:

vboxsync

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

87485

Message:

pr6022. OVA appliance don't fail when a certificate file exists. GZIP support has been implemented (first version).

Location:

trunk

Files:

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

trunk/include/iprt/mangling.h

@@ -1861 +1861 @@
 # define RTZipTarCmd                                    RT_MANGLER(RTZipTarCmd)
 # define RTZipTarFsStreamFromIoStream                   RT_MANGLER(RTZipTarFsStreamFromIoStream)
-
+# define RTZipGzipDecompressBuffer                      RT_MANGLER(RTZipGzipDecompressBuffer)
 /*
  * Stable variables (alphabetical order):

trunk/include/iprt/zip.h

@@ -29 +29 @@
 #include <iprt/cdefs.h>
 #include <iprt/types.h>
-
+# include <zlib.h>
 
 RT_C_DECLS_BEGIN
@@ -256 +256 @@
 RTDECL(RTEXITCODE) RTZipTarCmd(unsigned cArgs, char **papszArgs);
 
+RTDECL(int) RTZipGzipDecompressBuffer(z_stream streamIn,
+                                      uint32_t *cbDecompressed,
+                                      bool *finished);
 /** @} */
 

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

@@ -178 +178 @@
     HRESULT importS3(TaskOVF *pTask);
 
-    HRESULT readManifestFile(const Utf8Str &strFile, void **ppvBuf, size_t *pcbSize, PVDINTERFACEIO pCallbacks, PSHASTORAGE pStorage);
-    HRESULT readTarManifestFile(RTTAR tar, const Utf8Str &strFile, void **ppvBuf, size_t *pcbSize, PVDINTERFACEIO pCallbacks, PSHASTORAGE pStorage);
+    HRESULT readFileToBuf(const Utf8Str &strFile,
+                             void **ppvBuf,
+                             size_t *pcbSize,
+                             bool fCreateDigest,
+                             PVDINTERFACEIO pCallbacks,
+                             PSHASTORAGE pStorage);
+    HRESULT readTarFileToBuf(RTTAR tar,
+                             const Utf8Str &strFile,
+                             void **ppvBuf,
+                             size_t *pcbSize,
+                             bool fCreateDigest,
+                             PVDINTERFACEIO pCallbacks,
+                             PSHASTORAGE pStorage);
     HRESULT verifyManifestFile(const Utf8Str &strFile, ImportStack &stack, void *pvBuf, size_t cbSize);
 
@@ -189 +200 @@
 
     void importOneDiskImage(const ovf::DiskImage &di,
-                            const Utf8Str &strTargetPath,
+                            Utf8Str *strTargetPath,
                             ComObjPtr<Medium> &pTargetHD,
                             ImportStack &stack,

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

@@ -243 +243 @@
 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

@@ -24 +24 @@
 #include "ApplianceImpl.h"
 #include "ApplianceImplPrivate.h"
-
+#include "VirtualBoxImpl.h"
+
+#include <iprt/zip.h>
 #include <iprt/tar.h>
 #include <iprt/sha.h>
@@ -32 +34 @@
 #include <iprt/circbuf.h>
 #include <VBox/vd.h>
+#include <zlib.h>
 
 /******************************************************************************
@@ -92 +95 @@
 } SHASTORAGEINTERNAL, *PSHASTORAGEINTERNAL;
 
+typedef struct GZIPSTORAGEINTERNAL
+{
+    /** Completion callback. */
+    PFNVDCOMPLETED pfnCompleted;
+    /** Storage handle for the next callback in chain. */
+    void *pvStorage;
+    /** Current file open mode. */
+    uint32_t fOpenMode;
+    /** Circular buffer used for transferring data from/to the worker thread. */
+    PRTCIRCBUF pCircBuf;
+    /** Current absolute position (regardless of the real read/written data). */
+    uint64_t cbCurAll;
+    /** Current real position in the file. */
+    uint64_t cbCurFile;
+    /** Handle of the worker thread. */
+    RTTHREAD pWorkerThread;
+    /** Status of the worker thread. */
+    volatile uint32_t u32Status;
+    /** Event for signaling a new status. */
+    RTSEMEVENT newStatusEvent;
+    /** Event for signaling a finished task of the worker thread. */
+    RTSEMEVENT workFinishedEvent;
+    /** Write mode only: Memory buffer for writing zeros. */
+    void *pvZeroBuf;
+    /** Write mode only: Size of the zero memory buffer. */
+    size_t cbZeroBuf;
+    /** Read mode only: Indicate if we reached end of file. */
+    volatile bool fEOF;
+//    uint64_t calls;
+//    uint64_t waits;
+} GZIPSTORAGEINTERNAL, *PGZIPSTORAGEINTERNAL;
+
 /******************************************************************************
  *   Defined Constants And Macros                                             *
@@ -110 +145 @@
 #endif
 
+/** Buffer for the decompressed data. */
+//static uint8_t *compressedBuffer;
+/** The current size of the compressed data*/
+static size_t   cbComprData;
+/** The current offset into the compressed data */
+static size_t   offComprData;
+
 /******************************************************************************
  *   Internal Functions                                                       *
  ******************************************************************************/
+//static DECLCALLBACK(int) CopyCompressedDataToBuffer(void *pvUser, void *pvBuf, size_t cbBuf, size_t *pcbRead);
 
 /******************************************************************************
@@ -1174 +1217 @@
 
 /******************************************************************************
+ *   Internal: RTGZIP interface
+ ******************************************************************************/
+
+//DECLCALLBACK(int) gzipCalcWorkerThread(RTTHREAD /* aThread */, void *pvUser)
+//{
+//    /* Validate input. */
+//    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
+//
+//    PGZIPSTORAGEINTERNAL pInt = (PGZIPSTORAGEINTERNAL)pvUser;
+//
+//    PVDINTERFACEIO pIfIo = VDIfIoGet(pInt->pShaStorage->pVDImageIfaces);
+//    AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
+//
+//    int rc = VINF_SUCCESS;
+//    bool fLoop = true;
+//    while (fLoop)
+//    {
+//        /* What should we do next? */
+//        uint32_t u32Status = ASMAtomicReadU32(&pInt->u32Status);
+////        RTPrintf("status: %d\n", u32Status);
+//        switch (u32Status)
+//        {
+//            case STATUS_WAIT:
+//            {
+//                /* Wait for new work. */
+//                rc = RTSemEventWait(pInt->newStatusEvent, 100);
+//                if (   RT_FAILURE(rc)
+//                    && rc != VERR_TIMEOUT)
+//                    fLoop = false;
+//                break;
+//            }
+//            case STATUS_READ:
+//            {
+//                ASMAtomicCmpXchgU32(&pInt->u32Status, STATUS_READING, STATUS_READ);
+//                size_t cbAvail = RTCircBufFree(pInt->pCircBuf);
+//                size_t cbMemAllWrite = 0;
+//                /* First loop over all the available memory in the circular
+//                 * memory buffer (could be turn around at the end). */
+//                for (;;)
+//                {
+//                    if (   cbMemAllWrite == cbAvail
+//                        || fLoop == false)
+//                        break;
+//                    char *pcBuf;
+//                    size_t cbMemToWrite = cbAvail - cbMemAllWrite;
+//                    size_t cbMemWrite = 0;
+//                    /* Try to acquire all the free space of the circular buffer. */
+//                    RTCircBufAcquireWriteBlock(pInt->pCircBuf, cbMemToWrite, (void**)&pcBuf, &cbMemWrite);
+//                    /* Second, read as long as we filled all the memory. The
+//                     * read method could also split the reads up into to
+//                     * smaller parts. */
+//                    size_t cbAllRead = 0;
+//                    for (;;)
+//                    {
+//                        if (cbAllRead == cbMemWrite)
+//                            break;
+//                        size_t cbToRead = cbMemWrite - cbAllRead;
+//                        size_t cbRead = 0;
+//                        rc = vdIfIoFileReadSync(pIfIo, pInt->pvStorage, pInt->cbCurFile, &pcBuf[cbAllRead], cbToRead, &cbRead);
+//                        if (RT_FAILURE(rc))
+//                        {
+//                            fLoop = false;
+//                            break;
+//                        }
+//                        /* This indicates end of file. Stop reading. */
+//                        if (cbRead == 0)
+//                        {
+//                            fLoop = false;
+//                            ASMAtomicWriteBool(&pInt->fEOF, true);
+//                            break;
+//                        }
+//                        cbAllRead += cbRead;
+//                        pInt->cbCurFile += cbRead;
+//                    }
+//                    /* Update the GZIP context with the next data block. */
+//                    if (RT_SUCCESS(rc))
+//                    {
+//                            RTSha256Update(&pInt->ctx.Sha256, pcBuf, cbAllRead);
+//                    }
+//                    /* Mark the block as full. */
+//                    RTCircBufReleaseWriteBlock(pInt->pCircBuf, cbAllRead);
+//                    cbMemAllWrite += cbAllRead;
+//                }
+//                /* Reset the thread status and signal the main thread that we
+//                 * are finished. Use CmpXchg, so we not overwrite other states
+//                 * which could be signaled in the meantime. */
+//                if (ASMAtomicCmpXchgU32(&pInt->u32Status, STATUS_WAIT, STATUS_READING))
+//                    rc = RTSemEventSignal(pInt->workFinishedEvent);
+//                break;
+//            }
+//            case STATUS_END:
+//            {
+//                /* End signaled */
+//                fLoop = false;
+//                break;
+//            }
+//        }
+//    }
+//    /* Cleanup any status changes to indicate we are finished. */
+//    ASMAtomicWriteU32(&pInt->u32Status, STATUS_END);
+//    rc = RTSemEventSignal(pInt->workFinishedEvent);
+//    return rc;
+//}
+//
+//DECLINLINE(int) gzipSignalManifestThread(PGZIPSTORAGEINTERNAL pInt, uint32_t uStatus)
+//{
+//    ASMAtomicWriteU32(&pInt->u32Status, uStatus);
+//    return RTSemEventSignal(pInt->newStatusEvent);
+//}
+//
+//DECLINLINE(int) gzipWaitForManifestThreadFinished(PGZIPSTORAGEINTERNAL pInt)
+//{
+////    RTPrintf("start\n");
+//    int rc = VINF_SUCCESS;
+//    for (;;)
+//    {
+////        RTPrintf(" wait\n");
+//        uint32_t u32Status = ASMAtomicReadU32(&pInt->u32Status);
+//        if (!(   u32Status == STATUS_WRITE
+//              || u32Status == STATUS_WRITING
+//              || u32Status == STATUS_READ
+//              || u32Status == STATUS_READING))
+//            break;
+//        rc = RTSemEventWait(pInt->workFinishedEvent, 100);
+//    }
+//    if (rc == VERR_TIMEOUT)
+//        rc = VINF_SUCCESS;
+//    return rc;
+//}
+//
+//DECLINLINE(int) gzipFlushCurBuf(PGZIPSTORAGEINTERNAL pInt)
+//{
+//    int rc = VINF_SUCCESS;
+//    if (pInt->fOpenMode & RTFILE_O_WRITE)
+//    {
+//        /* Let the write worker thread start immediately. */
+//        rc = gzipSignalManifestThread(pInt, STATUS_WRITE);
+//        if (RT_FAILURE(rc))
+//            return rc;
+//
+//        /* Wait until the write worker thread has finished. */
+//        rc = gzipWaitForManifestThreadFinished(pInt);
+//    }
+//
+//    return rc;
+//}
+//
+//static int gzipOpenCallback(void *pvUser, const char *pszLocation, uint32_t fOpen,
+//                              PFNVDCOMPLETED pfnCompleted, void **ppInt)
+//{
+//    /* Validate input. */
+//    AssertPtrReturn(pvUser, VERR_INVALID_PARAMETER);
+//    AssertPtrReturn(pszLocation, VERR_INVALID_POINTER);
+//    AssertPtrNullReturn(pfnCompleted, VERR_INVALID_PARAMETER);
+//    AssertPtrReturn(ppInt, VERR_INVALID_POINTER);
+//    AssertReturn((fOpen & RTFILE_O_READWRITE) != RTFILE_O_READWRITE, VERR_INVALID_PARAMETER); /* No read/write allowed */
+//
+//    DEBUG_PRINT_FLOW();
+//
+//    PGZIPSTORAGEINTERNAL pInt = (PGZIPSTORAGEINTERNAL)RTMemAllocZ(sizeof(GZIPSTORAGEINTERNAL));
+//    if (!pInt)
+//        return VERR_NO_MEMORY;
+//
+//    int rc = VINF_SUCCESS;
+//    do
+//    {
+//        pInt->pfnCompleted = pfnCompleted;
+//        pInt->fEOF         = false;
+//        pInt->fOpenMode    = fOpen;
+//        pInt->u32Status    = STATUS_WAIT;
+//
+//        /* Circular buffer in the read case. */
+//        rc = RTCircBufCreate(&pInt->pCircBuf, _1M * 2);
+//        if (RT_FAILURE(rc))
+//            break;
+//
+//        /* Create an event semaphore to indicate a state change for the worker
+//         * thread. */
+//        rc = RTSemEventCreate(&pInt->newStatusEvent);
+//        if (RT_FAILURE(rc))
+//            break;
+//        /* Create an event semaphore to indicate a finished calculation of the
+//           worker thread. */
+//        rc = RTSemEventCreate(&pInt->workFinishedEvent);
+//        if (RT_FAILURE(rc))
+//            break;
+//        /* Create the worker thread. */
+//        rc = RTThreadCreate(&pInt->pWorkerThread, gziCalcWorkerThread, pInt, 0, RTTHREADTYPE_MAIN_HEAVY_WORKER,
+//                            RTTHREADFLAGS_WAITABLE, "GZIP-Worker");
+//        if (RT_FAILURE(rc))
+//            break;
+//
+//        /* Open the file. */
+//        rc = vdIfIoFileOpen(pIfIo, pszLocation, fOpen, pInt->pfnCompleted,
+//                            &pInt->pvStorage);
+//        if (RT_FAILURE(rc))
+//            break;
+//
+//        if (fOpen & RTFILE_O_READ)
+//        {
+//            /* Immediately let the worker thread start the reading. */
+//            rc = gzipSignalManifestThread(pInt, STATUS_READ);
+//        }
+//    }
+//    while (0);
+//
+//    if (RT_FAILURE(rc))
+//    {
+//        if (pInt->pWorkerThread)
+//        {
+//            gzipSignalManifestThread(pInt, STATUS_END);
+//            RTThreadWait(pInt->pWorkerThread, RT_INDEFINITE_WAIT, 0);
+//        }
+//        if (pInt->workFinishedEvent)
+//            RTSemEventDestroy(pInt->workFinishedEvent);
+//        if (pInt->newStatusEvent)
+//            RTSemEventDestroy(pInt->newStatusEvent);
+//        if (pInt->pCircBuf)
+//            RTCircBufDestroy(pInt->pCircBuf);
+//        if (pInt->pvZeroBuf)
+//            RTMemFree(pInt->pvZeroBuf);
+//        RTMemFree(pInt);
+//    }
+//    else
+//        *ppInt = pInt;
+//
+//    return rc;
+//}
+//
+//static int gzipCloseCallback(void *pvUser, void *pvStorage)
+//{
+//    /* Validate input. */
+//    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
+//    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
+//
+//    PSHASTORAGE pShaStorage = (PSHASTORAGE)pvUser;
+//    PVDINTERFACEIO pIfIo = VDIfIoGet(pShaStorage->pVDImageIfaces);
+//    AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
+//
+//    PSHASTORAGEINTERNAL pInt = (PSHASTORAGEINTERNAL)pvStorage;
+//
+//    DEBUG_PRINT_FLOW();
+//
+//    int rc = VINF_SUCCESS;
+//
+//    /* Make sure all pending writes are flushed */
+//    rc = gzipFlushCurBuf(pInt);
+//
+//    if (pInt->pWorkerThread)
+//    {
+//        /* Signal the worker thread to end himself */
+//        rc = gzipSignalManifestThread(pInt, STATUS_END);
+//        /* Worker thread stopped? */
+//        rc = RTThreadWait(pInt->pWorkerThread, RT_INDEFINITE_WAIT, 0);
+//    }
+//
+//    /* Close the file */
+//    rc = vdIfIoFileClose(pIfIo, pInt->pvStorage);
+//
+//    /* Cleanup */
+//    if (pInt->workFinishedEvent)
+//        RTSemEventDestroy(pInt->workFinishedEvent);
+//    if (pInt->newStatusEvent)
+//        RTSemEventDestroy(pInt->newStatusEvent);
+//    if (pInt->pCircBuf)
+//        RTCircBufDestroy(pInt->pCircBuf);
+//    if (pInt->pvZeroBuf)
+//        RTMemFree(pInt->pvZeroBuf);
+//    RTMemFree(pInt);
+//
+//    return rc;
+//}
+//
+//static int gzipDeleteCallback(void *pvUser, const char *pcszFilename)
+//{
+//    /* Validate input. */
+//    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
+//
+//    DEBUG_PRINT_FLOW();
+//
+//    return VERR_NOT_IMPLEMENTED;
+//}
+//
+//static int gzipMoveCallback(void *pvUser, const char *pcszSrc, const char *pcszDst, unsigned fMove)
+//{
+//    /* Validate input. */
+//    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
+//
+//    DEBUG_PRINT_FLOW();
+//
+//    return VERR_NOT_IMPLEMENTED;
+//}
+//
+//static int gzipGetFreeSpaceCallback(void *pvUser, const char *pcszFilename, int64_t *pcbFreeSpace)
+//{
+//    /* Validate input. */
+//    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
+//
+//    DEBUG_PRINT_FLOW();
+//
+//    return VERR_NOT_IMPLEMENTED;
+//}
+//
+//static int gzipGetModificationTimeCallback(void *pvUser, const char *pcszFilename, PRTTIMESPEC pModificationTime)
+//{
+//    /* Validate input. */
+//    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
+//
+//    DEBUG_PRINT_FLOW();
+//
+//    return VERR_NOT_IMPLEMENTED;
+//}
+//
+//
+//static int gzipGetSizeCallback(void *pvUser, void *pvStorage, uint64_t *pcbSize)
+//{
+//    /* Validate input. */
+//    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
+//    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
+//
+//    PSHASTORAGE pShaStorage = (PSHASTORAGE)pvUser;
+//    PVDINTERFACEIO pIfIo = VDIfIoGet(pShaStorage->pVDImageIfaces);
+//    AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
+//
+//    PGZIPSTORAGEINTERNAL pInt = (PGZIPSTORAGEINTERNAL)pvStorage;
+//
+//    DEBUG_PRINT_FLOW();
+//
+//    uint64_t cbSize;
+//    int rc = vdIfIoFileGetSize(pIfIo, pInt->pvStorage, &cbSize);
+//    if (RT_FAILURE(rc))
+//        return rc;
+//
+//    *pcbSize = RT_MAX(pInt->cbCurAll, cbSize);
+//
+//    return VINF_SUCCESS;
+//}
+//
+//static int gzipSetSizeCallback(void *pvUser, void *pvStorage, uint64_t cbSize)
+//{
+//    /* Validate input. */
+//    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
+//    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
+//
+//    PSHASTORAGE pShaStorage = (PSHASTORAGE)pvUser;
+//    PVDINTERFACEIO pIfIo = VDIfIoGet(pShaStorage->pVDImageIfaces);
+//    AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
+//
+//    PGZIPSTORAGEINTERNAL pInt = (PGZIPSTORAGEINTERNAL)pvStorage;
+//
+//    DEBUG_PRINT_FLOW();
+//
+//    return vdIfIoFileSetSize(pIfIo, pInt->pvStorage, cbSize);
+//}
+//
+//static int gzipWriteSyncCallback(void *pvUser, void *pvStorage, uint64_t uOffset,
+//                                 const void *pvBuf, size_t cbWrite, size_t *pcbWritten)
+//{
+//    /* Validate input. */
+//    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
+//    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
+//
+//    PSHASTORAGE pShaStorage = (PSHASTORAGE)pvUser;
+//    PVDINTERFACEIO pIfIo = VDIfIoGet(pShaStorage->pVDImageIfaces);
+//    AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
+//
+//    PGZIPSTORAGEINTERNAL pInt = (PGZIPSTORAGEINTERNAL)pvStorage;
+//
+//    DEBUG_PRINT_FLOW();
+//
+//    int rc = VINF_SUCCESS;
+//
+//    return VERR_NOT_IMPLEMENTED;
+//}
+//
+//static int gzipReadSyncCallback(void *pvUser, void *pvStorage, uint64_t uOffset,
+//                               void *pvBuf, size_t cbRead, size_t *pcbRead)
+//{
+//    /* Validate input. */
+//    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
+//    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
+//
+//    PSHASTORAGE pShaStorage = (PSHASTORAGE)pvUser;
+//    PVDINTERFACEIO pIfIo = VDIfIoGet(pShaStorage->pVDImageIfaces);
+//    AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
+//
+//    DEBUG_PRINT_FLOW();
+//
+//    PGZIPSTORAGEINTERNAL pInt = (PGZIPSTORAGEINTERNAL)pvStorage;
+//
+//    int rc = VINF_SUCCESS;
+//
+//    return rc;
+//}
+//
+//static int gzipFlushSyncCallback(void *pvUser, void *pvStorage)
+//{
+//    /* Validate input. */
+//    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
+//    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
+//
+//    PSHASTORAGE pShaStorage = (PSHASTORAGE)pvUser;
+//    PVDINTERFACEIO pIfIo = VDIfIoGet(pShaStorage->pVDImageIfaces);
+//    AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
+//
+//    DEBUG_PRINT_FLOW();
+//
+//    PGZIPSTORAGEINTERNAL pInt = (PGZIPSTORAGEINTERNAL)pvStorage;
+//
+//    /* Check if there is still something in the buffer. If yes, flush it. */
+//    int rc = gzipFlushCurBuf(pInt);
+//    if (RT_FAILURE(rc))
+//        return rc;
+//
+//    return vdIfIoFileFlushSync(pIfIo, pInt->pvStorage);
+//}
+
+/******************************************************************************
  *   Public Functions                                                         *
  ******************************************************************************/
+//PVDINTERFACEIO GzipCreateInterface()
+//{
+//    PVDINTERFACEIO pCallbacks = (PVDINTERFACEIO)RTMemAllocZ(sizeof(VDINTERFACEIO));
+//    if (!pCallbacks)
+//        return NULL;
+//
+//    pCallbacks->pfnOpen                = gzipOpenCallback;
+//    pCallbacks->pfnClose               = gzipCloseCallback;
+//    pCallbacks->pfnDelete              = gzipDeleteCallback;
+//    pCallbacks->pfnMove                = gzipMoveCallback;
+//    pCallbacks->pfnGetFreeSpace        = gzipGetFreeSpaceCallback;
+//    pCallbacks->pfnGetModificationTime = gzipGetModificationTimeCallback;
+//    pCallbacks->pfnGetSize             = gzipGetSizeCallback;
+//    pCallbacks->pfnSetSize             = gzipSetSizeCallback;
+//    pCallbacks->pfnReadSync            = gzipReadSyncCallback;
+//    pCallbacks->pfnWriteSync           = gzipWriteSyncCallback;
+//    pCallbacks->pfnFlushSync           = gzipFlushSyncCallback;
+//
+//    return pCallbacks;
+//}
 
 PVDINTERFACEIO ShaCreateInterface()
@@ -1339 +1820 @@
 }
 
+int decompressImageAndSave(const char *pcszFullFilenameIn, const char *pcszFullFilenameOut, PVDINTERFACEIO pIfIo, void *pvUser)
+{
+    /* Validate input. */
+    AssertPtrReturn(pIfIo, VERR_INVALID_POINTER);
+
+    void *pvStorage;
+    int rc = pIfIo->pfnOpen(pvUser, pcszFullFilenameIn,
+                            RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_NONE, 0,
+                            &pvStorage);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    Bytef *decompressedBuffer = 0;
+    Bytef *compressedBuffer = 0;
+    uint64_t cbTmpSize = _1M;
+    size_t cbAllRead = 0;
+    size_t cbAllWritten = 0;
+    RTFILE pFile = NULL;
+    z_stream gzipStream;
+
+    Utf8Str pathOut(pcszFullFilenameOut);
+    pathOut = pathOut.stripFilename();
+
+    Utf8Str fileIn(pcszFullFilenameIn);
+    fileIn = fileIn.stripPath();
+
+    do
+    {
+        if (RTFileExists(pcszFullFilenameOut) == false)
+        {
+            /* ensure the directory exists */
+            rc = VirtualBox::ensureFilePathExists(Utf8Str(pcszFullFilenameOut), true);
+            if (FAILED(rc))
+            {
+                rc = VBOX_E_FILE_ERROR;
+                break;
+            }
+
+            rc = RTFileOpen(&pFile, pcszFullFilenameOut, RTFILE_O_OPEN_CREATE | RTFILE_O_WRITE | RTFILE_O_DENY_NONE);
+        }
+        else
+        {
+            rc = RTFileOpen(&pFile, pcszFullFilenameOut, RTFILE_O_CREATE_REPLACE | RTFILE_O_WRITE | RTFILE_O_DENY_NONE);
+        }
+
+        if (FAILED(rc) || pFile == NULL)
+        {
+            rc = VBOX_E_FILE_ERROR;
+            break;
+        }
+
+        compressedBuffer = (Bytef *)RTMemAlloc(cbTmpSize);
+
+        if (!compressedBuffer)
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+
+
+        decompressedBuffer = (Bytef *)RTMemAlloc(cbTmpSize*10);
+
+        if (!decompressedBuffer)
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+
+        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 */);
+
+        if (rc < 0)
+        {
+            break;
+        }
+
+        size_t cbRead = 0;
+        size_t cbDecompressed = 0;
+        bool fFinished = true;
+
+        for (;;)
+        {
+            if (fFinished == true)
+            {
+                rc = pIfIo->pfnReadSync(pvUser, pvStorage, cbAllRead, compressedBuffer, cbTmpSize, &cbRead);
+                if (   RT_FAILURE(rc)
+                    || cbRead == 0)
+                    break;
+
+                gzipStream.avail_in = cbRead;
+                gzipStream.avail_out = cbTmpSize*10;
+            }
+
+            /* decompress the buffer */
+            rc = RTZipGzipDecompressBuffer(gzipStream,
+                                           (uint32_t *)(&cbDecompressed), 
+                                           &fFinished);
+
+            if (RT_FAILURE(rc))
+                break;
+
+            rc = RTFileWrite(pFile, decompressedBuffer, cbDecompressed, &cbDecompressed);
+
+            if (RT_FAILURE(rc))
+                break;
+
+            cbAllWritten += cbDecompressed;
+            cbAllRead += cbRead;
+        }
+    } while (0);
+
+    pIfIo->pfnClose(pvUser, pvStorage);
+
+    if (rc == VERR_EOF)
+        rc = VINF_SUCCESS;
+
+    rc = inflateEnd(&gzipStream);
+
+    rc = RTFileClose(pFile);
+
+    if (decompressedBuffer)
+        RTMemFree(decompressedBuffer);
+    if (compressedBuffer)
+        RTMemFree(compressedBuffer);
+
+    return rc;
+}
+
+

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

@@ -119 +119 @@
 {
     // @todo:
-    //  - don't use COM methods but the methods directly (faster, but needs appropriate locking of that objects itself (s. HardDisk))
+    //  - don't use COM methods but the methods directly (faster, but needs appropriate
+    // locking of that objects itself (s. HardDisk))
     //  - Appropriate handle errors like not supported file formats
     AutoCaller autoCaller(this);
@@ -280 +281 @@
             if (cpuCountVBox > SchemaDefs::MaxCPUCount)
             {
-                addWarning(tr("The virtual system \"%s\" claims support for %u CPU's, but VirtualBox has support for max %u CPU's only."),
+                addWarning(tr("The virtual system \"%s\" claims support for %u CPU's, but VirtualBox has support for "
+                              "max %u CPU's only."),
                            vsysThis.strName.c_str(), cpuCountVBox, SchemaDefs::MaxCPUCount);
                 cpuCountVBox = SchemaDefs::MaxCPUCount;
@@ -306 +308 @@
                )
             {
-                addWarning(tr("The virtual system \"%s\" claims support for %llu MB RAM size, but VirtualBox has support for min %u & max %u MB RAM size only."),
+                addWarning(tr("The virtual system \"%s\" claims support for %llu MB RAM size, but VirtualBox has "
+                              "support for min %u & max %u MB RAM size only."),
                               vsysThis.strName.c_str(), ullMemSizeVBox, MM_RAM_MIN_IN_MB, MM_RAM_MAX_IN_MB);
                 ullMemSizeVBox = RT_MIN(RT_MAX(ullMemSizeVBox, MM_RAM_MIN_IN_MB), MM_RAM_MAX_IN_MB);
@@ -330 +333 @@
             if (   vsysThis.pelmVboxMachine
                 && pNewDesc->m->pConfig->hardwareMachine.audioAdapter.fEnabled)
-                strSoundCard = Utf8StrFmt("%RU32", (uint32_t)pNewDesc->m->pConfig->hardwareMachine.audioAdapter.controllerType);
+            {
+                strSoundCard = Utf8StrFmt("%RU32",
+                                          (uint32_t)pNewDesc->m->pConfig->hardwareMachine.audioAdapter.controllerType);
+            }
             else if (vsysThis.strSoundCardType.isNotEmpty())
             {
@@ -362 +368 @@
                 /* Check for the constrains */
                 if (llNetworkAdapters.size() > maxNetworkAdapters)
-                    addWarning(tr("The virtual system \"%s\" claims support for %zu network adapters, but VirtualBox has support for max %u network adapter only."),
+                    addWarning(tr("The virtual system \"%s\" claims support for %zu network adapters, but VirtualBox "
+                                  "has support for max %u network adapter only."),
                                   vsysThis.strName.c_str(), llNetworkAdapters.size(), maxNetworkAdapters);
                 /* Iterate through all network adapters. */
@@ -390 +397 @@
                 /* Check for the constrains */
                 if (cEthernetAdapters > maxNetworkAdapters)
-                    addWarning(tr("The virtual system \"%s\" claims support for %zu network adapters, but VirtualBox has support for max %u network adapter only."),
+                    addWarning(tr("The virtual system \"%s\" claims support for %zu network adapters, but VirtualBox "
+                                  "has support for max %u network adapter only."),
                                   vsysThis.strName.c_str(), cEthernetAdapters, maxNetworkAdapters);
 
@@ -534 +542 @@
                             /* Warn only once */
                             if (cIDEused == 2)
-                                addWarning(tr("The virtual \"%s\" system requests support for more than two IDE controller channels, but VirtualBox supports only two."),
+                                addWarning(tr("The virtual \"%s\" system requests support for more than two "
+                                              "IDE controller channels, but VirtualBox supports only two."),
                                             vsysThis.strName.c_str());
 
@@ -555 +564 @@
                             /* Warn only once */
                             if (cSATAused == 1)
-                                addWarning(tr("The virtual system \"%s\" requests support for more than one SATA controller, but VirtualBox has support for only one"),
+                                addWarning(tr("The virtual system \"%s\" requests support for more than one "
+                                              "SATA controller, but VirtualBox has support for only one"),
                                             vsysThis.strName.c_str());
 
@@ -582 +592 @@
                         }
                         else
-                            addWarning(tr("The virtual system \"%s\" requests support for an additional SCSI controller of type \"%s\" with ID %s, but VirtualBox presently supports only one SCSI controller."),
+                            addWarning(tr("The virtual system \"%s\" requests support for an additional "
+                                          "SCSI controller of type \"%s\" with ID %s, but VirtualBox presently "
+                                          "supports only one SCSI controller."),
                                         vsysThis.strName.c_str(),
                                         hdc.strControllerType.c_str(),
@@ -1276 +1288 @@
 
         /* Next we have to download the OVF */
-        vrc = RTS3Create(&hS3, pTask->locInfo.strUsername.c_str(), pTask->locInfo.strPassword.c_str(), pTask->locInfo.strHostname.c_str(), "virtualbox-agent/"VBOX_VERSION_STRING);
+        vrc = RTS3Create(&hS3,
+                         pTask->locInfo.strUsername.c_str(),
+                         pTask->locInfo.strPassword.c_str(),
+                         pTask->locInfo.strHostname.c_str(),
+                         "virtualbox-agent/"VBOX_VERSION_STRING);
         if (RT_FAILURE(vrc))
             throw setError(VBOX_E_IPRT_ERROR,
@@ -1291 +1307 @@
             else if (vrc == VERR_S3_ACCESS_DENIED)
                 throw setError(E_ACCESSDENIED,
-                               tr("Cannot download file '%s' from S3 storage server (Access denied). Make sure that your credentials are right."
+                               tr("Cannot download file '%s' from S3 storage server (Access denied). Make sure that "
+                                  "your credentials are right. "
                                   "Also check that your host clock is properly synced"),
                                pszFilename);
@@ -1496 +1513 @@
     PVDINTERFACEIO pFileIo = NULL;
     void *pvMfBuf = NULL;
+    void *pvCertBuf = NULL;
     writeLock.release();
     try
@@ -1505 +1523 @@
 
         Utf8Str strMfFile = Utf8Str(pTask->locInfo.strPath).stripExt().append(".mf");
+
         SHASTORAGE storage;
         RT_ZERO(storage);
@@ -1534 +1553 @@
             /* Add the ovf file to the digest list. */
             stack.llSrcDisksDigest.push_front(STRPAIR(pTask->locInfo.strPath, m->strOVFSHADigest));
-            rc = readManifestFile(strMfFile, &pvMfBuf, &cbMfSize, pShaIo, &storage);
+            rc = readFileToBuf(strMfFile, &pvMfBuf, &cbMfSize, true, pShaIo, &storage);
             if (FAILED(rc)) throw rc;
             rc = verifyManifestFile(strMfFile, stack, pvMfBuf, cbMfSize);
             if (FAILED(rc)) throw rc;
+
+            size_t cbCertSize = 0;
+            Utf8Str manifestShaDigest;
+            Utf8Str strCertFile = Utf8Str(pTask->locInfo.strPath).stripExt().append(".cert");
+            if (RTFileExists(strCertFile.c_str()))
+            {
+                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 */
+            }
         }
         else
@@ -1554 +1587 @@
     if (pvMfBuf)
         RTMemFree(pvMfBuf);
+    if (pvCertBuf)
+        RTMemFree(pvCertBuf);
     if (pShaIo)
         RTMemFree(pShaIo);
@@ -1570 +1605 @@
 
     RTTAR tar;
-    int vrc = RTTarOpen(&tar, pTask->locInfo.strPath.c_str(), RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_NONE, true);
+    int vrc = RTTarOpen(&tar,
+                        pTask->locInfo.strPath.c_str(),
+                        RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_NONE, true);
     if (RT_FAILURE(vrc))
         return setError(VBOX_E_FILE_ERROR,
@@ -1582 +1619 @@
     char *pszFilename = 0;
     void *pvMfBuf = 0;
+    void *pvCertBuf = 0;
+
     writeLock.release();
     try
@@ -1629 +1668 @@
         else
         {
+            RTTarCurrentFile(tar, &pszFilename);
             if (vrc == VINF_TAR_DIR_PATH)
             {
-                RTTarCurrentFile(tar, &pszFilename);
                 throw setError(VBOX_E_FILE_ERROR,
                        tr("Empty directory folder (%s) isn't allowed in the OVA package (%Rrc)"), 
@@ -1662 +1701 @@
          * If it fails here, we will try it again after all disks where read.
          */
-        rc = readTarManifestFile(tar, strMfFile, &pvMfBuf, &cbMfSize, pCallbacks, pStorage);
+        rc = readTarFileToBuf(tar, strMfFile, &pvMfBuf, &cbMfSize, true, pCallbacks, pStorage);
         if (FAILED(rc)) throw rc;
+
+        /* 
+         * Try to read the certificate file. First try.
+         * Logic is the same as with manifest file 
+         * Only if the manifest file had been read successfully before 
+         */
+        vrc = RTTarCurrentFile(tar, &pszFilename);
+        if (RT_FAILURE(vrc))
+            throw setError(VBOX_E_IPRT_ERROR,
+                           tr("Getting the current file within the archive failed (%Rrc)"), vrc);
+
+        size_t cbCertSize = 0;
+        Utf8Str strCertFile = Utf8Str(pszFilename).stripExt().append(".cert");
+        if (pvMfBuf)
+        {
+            if (strCertFile.compare(pszFilename) == 0)
+            {
+                rc = readTarFileToBuf(tar, strCertFile, &pvCertBuf, &cbCertSize, false, pCallbacks, pStorage);
+                if (FAILED(rc)) throw rc;
+
+                if (pvCertBuf)
+                {
+                /* verify the certificate */
+                }
+            }
+        }
+
         /* Now import the appliance. */
         importMachines(stack, pCallbacks, pStorage);
@@ -1669 +1735 @@
         if (!pvMfBuf)
         {
-            rc = readTarManifestFile(tar, strMfFile, &pvMfBuf, &cbMfSize, pCallbacks, pStorage);
+            rc = readTarFileToBuf(tar, strMfFile, &pvMfBuf, &cbMfSize, true, pCallbacks, pStorage);
             if (FAILED(rc)) throw rc;
-        }
-        /* If we were able to read a manifest file we can check it now. */
-        if (pvMfBuf)
-        {
-            /* Add the ovf file to the digest list. */
-            stack.llSrcDisksDigest.push_front(STRPAIR(Utf8Str(pszFilename).stripExt().append(".ovf"), m->strOVFSHADigest));
-            rc = verifyManifestFile(strMfFile, stack, pvMfBuf, cbMfSize);
-            if (FAILED(rc)) throw rc;
+
+            /* If we were able to read a manifest file we can check it now. */
+            if (pvMfBuf)
+            {
+                /* Add the ovf file to the digest list. */
+                stack.llSrcDisksDigest.push_front(STRPAIR(Utf8Str(pszFilename).stripExt().append(".ovf"),
+                                                  m->strOVFSHADigest));
+                rc = verifyManifestFile(strMfFile, stack, pvMfBuf, cbMfSize);
+                if (FAILED(rc)) throw rc;
+
+                /*
+                 * Try to read the certificate file. Second try.
+                 * Only if the manifest file had been read successfully before
+                 */
+
+                vrc = RTTarCurrentFile(tar, &pszFilename);
+                if (RT_FAILURE(vrc))
+                    throw setError(VBOX_E_IPRT_ERROR,
+                                   tr("Getting the current file within the archive failed (%Rrc)"), vrc);
+
+                if (strCertFile.compare(pszFilename) == 0)
+                {
+                    rc = readTarFileToBuf(tar, strCertFile, &pvCertBuf, &cbCertSize, false, pCallbacks, pStorage);
+                    if (FAILED(rc)) throw rc;
+
+                    if (pvCertBuf)
+                    {
+                    /* verify the certificate */
+                    }
+                }
+            }
         }
     }
@@ -1698 +1787 @@
     if (pTarIo)
         RTMemFree(pTarIo);
+    if (pvCertBuf)
+        RTMemFree(pvCertBuf);
 
     LogFlowFunc(("rc=%Rhrc\n", rc));
@@ -1770 +1861 @@
 
         /* Next we have to download the disk images */
-        vrc = RTS3Create(&hS3, pTask->locInfo.strUsername.c_str(), pTask->locInfo.strPassword.c_str(), pTask->locInfo.strHostname.c_str(), "virtualbox-agent/"VBOX_VERSION_STRING);
+        vrc = RTS3Create(&hS3,
+                         pTask->locInfo.strUsername.c_str(),
+                         pTask->locInfo.strPassword.c_str(),
+                         pTask->locInfo.strHostname.c_str(),
+                         "virtualbox-agent/"VBOX_VERSION_STRING);
         if (RT_FAILURE(vrc))
             throw setError(VBOX_E_IPRT_ERROR,
@@ -1795 +1890 @@
                     throw setError(E_ACCESSDENIED,
                                    tr("Cannot download file '%s' from S3 storage server (Access denied). "
-                                      "Make sure that your credentials are right. Also check that your host clock is properly synced"),
+                                      "Make sure that your credentials are right. Also check that your host clock is "
+                                      "properly synced"),
                                    pszFilename);
                 else if (vrc == VERR_S3_NOT_FOUND)
@@ -1831 +1927 @@
                 throw setError(E_ACCESSDENIED,
                                tr("Cannot download file '%s' from S3 storage server (Access denied)."
-                                  "Make sure that your credentials are right. Also check that your host clock is properly synced"),
+                                  "Make sure that your credentials are right. "
+                                  "Also check that your host clock is properly synced"),
                                pszFilename);
             else
@@ -1898 +1995 @@
 #endif /* VBOX_WITH_S3 */
 
-HRESULT Appliance::readManifestFile(const Utf8Str &strFile, void **ppvBuf, size_t *pcbSize, PVDINTERFACEIO pCallbacks, PSHASTORAGE pStorage)
+HRESULT Appliance::readFileToBuf(const Utf8Str &strFile,
+                                 void **ppvBuf,
+                                 size_t *pcbSize,
+                                 bool fCreateDigest,
+                                 PVDINTERFACEIO pCallbacks,
+                                 PSHASTORAGE pStorage)
 {
     HRESULT rc = S_OK;
 
-    bool fOldDigest = pStorage->fCreateDigest;
-    pStorage->fCreateDigest = false; /* No digest for the manifest file */
+    bool fOldDigest = pStorage->fCreateDigest;/* Save the old digest property */
+    pStorage->fCreateDigest = fCreateDigest; 
     int vrc = ShaReadBuf(strFile.c_str(), ppvBuf, pcbSize, pCallbacks, pStorage);
     if (   RT_FAILURE(vrc)
         && vrc != VERR_FILE_NOT_FOUND)
         rc = setError(VBOX_E_FILE_ERROR,
-                      tr("Could not read manifest file '%s' (%Rrc)"),
+                      tr("Could not read file '%s' (%Rrc)"),
                       RTPathFilename(strFile.c_str()), vrc);
     pStorage->fCreateDigest = fOldDigest; /* Restore the old digest creation behavior again. */
@@ -1915 +2017 @@
 }
 
-HRESULT Appliance::readTarManifestFile(RTTAR tar, const Utf8Str &strFile, void **ppvBuf, size_t *pcbSize, PVDINTERFACEIO pCallbacks, PSHASTORAGE pStorage)
+HRESULT Appliance::readTarFileToBuf(RTTAR tar,
+                                    const Utf8Str &strFile,
+                                    void **ppvBuf,
+                                    size_t *pcbSize,
+                                    bool fCreateDigest,
+                                    PVDINTERFACEIO pCallbacks,
+                                    PSHASTORAGE pStorage)
 {
     HRESULT rc = S_OK;
@@ -1933 +2041 @@
         {
             if (!strcmp(pszCurFile, RTPathFilename(strFile.c_str())))
-                rc = readManifestFile(strFile, ppvBuf, pcbSize, pCallbacks, pStorage);
+                rc = readFileToBuf(strFile, ppvBuf, pcbSize, fCreateDigest, pCallbacks, pStorage);
             RTStrFree(pszCurFile);
         }
@@ -1993 +2101 @@
                                             int32_t &lDevice)
 {
-    Log(("Appliance::convertDiskAttachmentValues: hdc.system=%d, hdc.fPrimary=%d, ulAddressOnParent=%d\n", hdc.system, hdc.fPrimary, ulAddressOnParent));
+    Log(("Appliance::convertDiskAttachmentValues: hdc.system=%d, hdc.fPrimary=%d, ulAddressOnParent=%d\n",
+         hdc.system,
+         hdc.fPrimary,
+         ulAddressOnParent));
 
     switch (hdc.system)
@@ -2089 +2200 @@
  *
  * @param di ovfreader.cpp structure describing the disk image from the OVF that is to be imported
- * @param ulSizeMB Size of the disk image (for progress reporting)
  * @param strTargetPath Where to create the target image.
  * @param pTargetHD out: The newly created target disk. This also gets pushed on stack.llHardDisksCreated for cleanup.
@@ -2095 +2205 @@
  */
 void Appliance::importOneDiskImage(const ovf::DiskImage &di,
-                                   const Utf8Str &strTargetPath,
+                                   Utf8Str *strTargetPath,
                                    ComObjPtr<Medium> &pTargetHD,
                                    ImportStack &stack,
@@ -2101 +2211 @@
                                    PSHASTORAGE pStorage)
 {
+    SHASTORAGE finalStorage;
+    PSHASTORAGE pRealUsedStorage = pStorage;/* may be changed later to finalStorage */
+    PVDINTERFACEIO pFileIo = NULL;/* used in GZIP case*/
     ComObjPtr<Progress> pProgress;
     pProgress.createObject();
-    HRESULT rc = pProgress->init(mVirtualBox, static_cast<IAppliance*>(this), BstrFmt(tr("Creating medium '%s'"), strTargetPath.c_str()).raw(), TRUE);
+    HRESULT rc = pProgress->init(mVirtualBox,
+                                 static_cast<IAppliance*>(this),
+                                 BstrFmt(tr("Creating medium '%s'"),
+                                 strTargetPath->c_str()).raw(),
+                                 TRUE);
     if (FAILED(rc)) throw rc;
 
@@ -2109 +2226 @@
     SystemProperties *pSysProps = mVirtualBox->getSystemProperties();
 
+    /* 
+     * we put strSourceOVF into the stack.llSrcDisksDigest in the end of this
+     * function like a key for a later validation of the SHA digests 
+     */ 
     const Utf8Str &strSourceOVF = di.strHref;
 
     Utf8Str strSrcFilePath(stack.strSourceDir);
+    Utf8Str strTargetDir(*strTargetPath);
+
     /* Construct source file path */
     Utf8Str name = applianceIOName(applianceIOTar);
@@ -2127 +2250 @@
      * example. */
     RTUUID uuid;
-    int vrc = RTUuidFromStr(&uuid, strTargetPath.c_str());
+    int vrc = RTUuidFromStr(&uuid, strTargetPath->c_str());
     if (vrc == VINF_SUCCESS)
     {
@@ -2135 +2258 @@
     else
     {
-        Utf8Str strTrgFormat = "VMDK";
-        ULONG lCabs = 0;
-
-        if (RTPathHaveExt(strTargetPath.c_str()))
+        /* check read file to GZIP compression */
+        try
         {
-            char *pszExt = RTPathExt(strTargetPath.c_str());
-            /* Figure out which format the user like to have. Default is VMDK. */
-            ComObjPtr<MediumFormat> trgFormat = pSysProps->mediumFormatFromExtension(&pszExt[1]);
-            if (trgFormat.isNull())
-                throw setError(VBOX_E_NOT_SUPPORTED,
-                               tr("Could not find a valid medium format for the target disk '%s'"),
-                               strTargetPath.c_str());
-            /* Check the capabilities. We need create capabilities. */
-            lCabs = 0;
-            com::SafeArray <MediumFormatCapabilities_T> mediumFormatCap;
-            rc = trgFormat->COMGETTER(Capabilities)(ComSafeArrayAsOutParam(mediumFormatCap));
-
-            if (FAILED(rc)) throw rc;
-            else
-            {
-                for (ULONG j = 0; j < mediumFormatCap.size(); j++)
-                    lCabs |= mediumFormatCap[j];
-            }
-
-            if (!(   ((lCabs & MediumFormatCapabilities_CreateFixed) == MediumFormatCapabilities_CreateFixed)
-                  || ((lCabs & MediumFormatCapabilities_CreateDynamic) == MediumFormatCapabilities_CreateDynamic)))
-                throw setError(VBOX_E_NOT_SUPPORTED,
-                               tr("Could not find a valid medium format for the target disk '%s'"),
-                               strTargetPath.c_str());
-            Bstr bstrFormatName;
-            rc = trgFormat->COMGETTER(Name)(bstrFormatName.asOutParam());
-            if (FAILED(rc)) throw rc;
-            strTrgFormat = Utf8Str(bstrFormatName);
-        }
-
-        /* Create an IMedium object. */
-        pTargetHD.createObject();
-
-        /*CD/DVD case*/
-        if (strTrgFormat.compare("RAW", Utf8Str::CaseInsensitive) == 0)
-        {
-            void *pvTmpBuf = 0;
-            size_t cbSize = 0;
-
-            /* Read the ISO file into a memory buffer */
-            vrc = ShaReadBuf(strSrcFilePath.c_str(), &pvTmpBuf, &cbSize, pCallbacks, pStorage);
-
-            if ( RT_FAILURE(vrc) || !pvTmpBuf)
-                throw setError(VBOX_E_FILE_ERROR,
-                               tr("Could not read ISO file '%s' (%Rrc)"),
-                               RTPathFilename(strSrcFilePath.c_str()), vrc);
-
-            if (RTFileExists(strTargetPath.c_str()) == false)
-            {
-
-                /* ensure the directory exists */
-                if (lCabs & MediumFormatCapabilities_File)
+            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
+                 */
+
+                /* Decompress the GZIP file and save a new file in the target path */
+                strTargetDir = strTargetDir.stripFilename();
+                strTargetDir.append("/temp_");
+
+                Utf8Str strTempTargetFilename(*strTargetPath);
+                strTempTargetFilename = strTempTargetFilename.stripPath();
+                strTempTargetFilename = strTempTargetFilename.stripExt();
+                Utf8Str vdf = typeOfVirtualDiskFormatFromURI(di.strFormat);
+
+                strTargetDir.append(strTempTargetFilename);
+
+                vrc = decompressImageAndSave(strSrcFilePath.c_str(), strTargetDir.c_str(), pCallbacks, pStorage);
+
+                if (RT_FAILURE(vrc))
+                    throw setError(VBOX_E_FILE_ERROR,
+                                   tr("Could not read the file '%s' (%Rrc)"),
+                                   RTPathFilename(strSrcFilePath.c_str()), vrc);
+
+                /* Create the necessary file access interfaces. */
+                pFileIo = FileCreateInterface();
+                if (!pFileIo)
+                    throw setError(E_OUTOFMEMORY);
+
+                name = applianceIOName(applianceIOFile);
+
+                vrc = VDInterfaceAdd(&pFileIo->Core, name.c_str(),
+                                     VDINTERFACETYPE_IO, NULL, sizeof(VDINTERFACEIO),
+                                     &finalStorage.pVDImageIfaces);
+                if (RT_FAILURE(vrc))
+                    throw setError(VBOX_E_IPRT_ERROR,
+                                   tr("Creation of the VD interface failed (%Rrc)"), vrc);
+
+                strSrcFilePath = strTargetDir;
+                strTargetDir = strTargetDir.stripFilename();
+                strTargetDir.append(RTPATH_SLASH_STR);
+                strTargetDir.append(strTempTargetFilename.c_str());
+                *strTargetPath = strTargetDir.c_str();
+
+                pRealUsedStorage = &finalStorage;
+            }
+
+            Utf8Str strTrgFormat = "VMDK";
+            ULONG lCabs = 0;
+
+            if (RTPathHaveExt(strTargetPath->c_str()))
+            {
+                char *pszExt = RTPathExt(strTargetPath->c_str());
+                /* Figure out which format the user like to have. Default is VMDK. */
+                ComObjPtr<MediumFormat> trgFormat = pSysProps->mediumFormatFromExtension(&pszExt[1]);
+                if (trgFormat.isNull())
+                    throw setError(VBOX_E_NOT_SUPPORTED,
+                                   tr("Could not find a valid medium format for the target disk '%s'"),
+                                   strTargetPath->c_str());
+                /* Check the capabilities. We need create capabilities. */
+                lCabs = 0;
+                com::SafeArray <MediumFormatCapabilities_T> mediumFormatCap;
+                rc = trgFormat->COMGETTER(Capabilities)(ComSafeArrayAsOutParam(mediumFormatCap));
+
+                if (FAILED(rc))
+                    throw rc;
+                else
                 {
-                    rc = VirtualBox::ensureFilePathExists(strTargetPath, true);
-                    if (FAILED(rc))
-                        throw rc;
+                    for (ULONG j = 0; j < mediumFormatCap.size(); j++)
+                        lCabs |= mediumFormatCap[j];
                 }
 
-                // 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)
+                if (!(   ((lCabs & MediumFormatCapabilities_CreateFixed) == MediumFormatCapabilities_CreateFixed)
+                      || ((lCabs & MediumFormatCapabilities_CreateDynamic) == MediumFormatCapabilities_CreateDynamic)))
+                    throw setError(VBOX_E_NOT_SUPPORTED,
+                                   tr("Could not find a valid medium format for the target disk '%s'"),
+                                   strTargetPath->c_str());
+                Bstr bstrFormatName;
+                rc = trgFormat->COMGETTER(Name)(bstrFormatName.asOutParam());
+                if (FAILED(rc)) throw rc;
+                strTrgFormat = Utf8Str(bstrFormatName);
+            }
+
+            /* Create an IMedium object. */
+            pTargetHD.createObject();
+
+            /*CD/DVD case*/
+            if (strTrgFormat.compare("RAW", Utf8Str::CaseInsensitive) == 0)
+            {
+                void *pvTmpBuf = 0;
+                size_t cbSize = 0;
+                try
                 {
-                    size_t cbWritten = 0;
-
-                    vrc = RTFileWrite(pFile, pvTmpBuf, cbSize, &cbWritten);
-
-                    if (RT_FAILURE(vrc))
+                    /* 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)
                     {
-                        Utf8Str path(strTargetPath);
-                        path = path.stripFilename();
-                        if (pvTmpBuf)
-                            RTMemFree(pvTmpBuf);
-                        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);
+
+                        /* 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);
                     }
                 }
-
-                RTFileClose(pFile);
-            }
-            /* Advance to the next operation. */
-            stack.pProgress->SetNextOperation(BstrFmt(tr("Importing virtual disk image '%s'"),
-                                            RTPathFilename(strSrcFilePath.c_str())).raw(),
-                                            di.ulSuggestedSizeMB);//operation's weight, as set up with the IProgress origi
+                catch (HRESULT arc)
+                {
+                    if (pvTmpBuf)
+                        RTMemFree(pvTmpBuf);
+                    throw;
+                }
+
+                if (pvTmpBuf)
+                    RTMemFree(pvTmpBuf);
+
+                /* Advance to the next operation. */
+                /* operation's weight, as set up with the IProgress originally */
+                stack.pProgress->SetNextOperation(BstrFmt(tr("Importing virtual disk image '%s'"),
+                                                  RTPathFilename(strSourceOVF.c_str())).raw(),
+                                                  di.ulSuggestedSizeMB);
+            }
+            else/* HDD case*/
+            {
+                rc = pTargetHD->init(mVirtualBox,
+                                     strTrgFormat,
+                                     *strTargetPath,
+                                     Guid::Empty /* media registry: none yet */);
+                if (FAILED(rc)) throw rc;
+
+                /* Now create an empty hard disk. */
+                rc = mVirtualBox->CreateHardDisk(Bstr(strTrgFormat).raw(),
+                                                 Bstr(*strTargetPath).raw(),
+                                                 ComPtr<IMedium>(pTargetHD).asOutParam());
+                if (FAILED(rc)) throw rc;
+
+                /* If strHref is empty we have to create a new file. */
+                if (strSourceOVF.isEmpty())
+                {
+                    com::SafeArray<MediumVariant_T>  mediumVariant;
+                    mediumVariant.push_back(MediumVariant_Standard);
+                    /* Create a dynamic growing disk image with the given capacity. */
+                    rc = pTargetHD->CreateBaseStorage(di.iCapacity / _1M,
+                                                      ComSafeArrayAsInParam(mediumVariant),
+                                                      ComPtr<IProgress>(pProgress).asOutParam());
+                    if (FAILED(rc)) throw rc;
+
+                    /* Advance to the next operation. */
+                    /* operation's weight, as set up with the IProgress originally */
+                    stack.pProgress->SetNextOperation(BstrFmt(tr("Creating disk image '%s'"),
+                                                      strTargetPath->c_str()).raw(),
+                                                      di.ulSuggestedSizeMB);
+                }
+                else
+                {
+                    /* We need a proper source format description */
+                    ComObjPtr<MediumFormat> srcFormat;
+                    /* Which format to use? */
+                    Utf8Str strSrcFormat = "VDI";
+
+                    std::set<Utf8Str> listURIs = Appliance::URIFromTypeOfVirtualDiskFormat("VMDK");
+                    std::set<Utf8Str>::const_iterator itr = listURIs.find(di.strFormat);
+
+                    if (itr != listURIs.end())
+                    {
+                        strSrcFormat = "VMDK";
+                    }
+
+                    srcFormat = pSysProps->mediumFormat(strSrcFormat);
+                    if (srcFormat.isNull())
+                        throw setError(VBOX_E_NOT_SUPPORTED,
+                                       tr("Could not find a valid medium format for the source disk '%s'"),
+                                       RTPathFilename(strSourceOVF.c_str()));
+
+                    /* Clone the source disk image */
+                    ComObjPtr<Medium> nullParent;
+                    rc = pTargetHD->importFile(strSrcFilePath.c_str(),
+                                               srcFormat,
+                                               MediumVariant_Standard,
+                                               pCallbacks, pRealUsedStorage,
+                                               nullParent,
+                                               pProgress);
+                    if (FAILED(rc)) throw rc;
+
+                    /* Advance to the next operation. */
+                    /* operation's weight, as set up with the IProgress originally */
+                    stack.pProgress->SetNextOperation(BstrFmt(tr("Importing virtual disk image '%s'"),
+                                                      RTPathFilename(strSourceOVF.c_str())).raw(),
+                                                      di.ulSuggestedSizeMB);
+                }
+
+                /* Now wait for the background disk operation to complete; this throws
+                 * HRESULTs on error. */
+                ComPtr<IProgress> pp(pProgress);
+                waitForAsyncProgress(stack.pProgress, pp);
+            }
         }
-        else/* HDD case*/
+        catch (...)
         {
-            rc = pTargetHD->init(mVirtualBox,
-                                 strTrgFormat,
-                                 strTargetPath,
-                                 Guid::Empty /* media registry: none yet */);
-            if (FAILED(rc)) throw rc;
-
-            /* Now create an empty hard disk. */
-            rc = mVirtualBox->CreateHardDisk(Bstr(strTrgFormat).raw(),
-                                             Bstr(strTargetPath).raw(),
-                                             ComPtr<IMedium>(pTargetHD).asOutParam());
-            if (FAILED(rc)) throw rc;
-
-            /* If strHref is empty we have to create a new file. */
-            if (strSourceOVF.isEmpty())
-            {
-                com::SafeArray<MediumVariant_T>  mediumVariant;
-                mediumVariant.push_back(MediumVariant_Standard);
-                /* Create a dynamic growing disk image with the given capacity. */
-                rc = pTargetHD->CreateBaseStorage(di.iCapacity / _1M, ComSafeArrayAsInParam(mediumVariant), ComPtr<IProgress>(pProgress).asOutParam());
-                if (FAILED(rc)) throw rc;
-
-                /* Advance to the next operation. */
-                stack.pProgress->SetNextOperation(BstrFmt(tr("Creating disk image '%s'"), strTargetPath.c_str()).raw(),
-                                                  di.ulSuggestedSizeMB);     // operation's weight, as set up with the IProgress originally
-            }
-            else
-            {
-                /* We need a proper source format description */
-                ComObjPtr<MediumFormat> srcFormat;
-                /* Which format to use? */
-                Utf8Str strSrcFormat = "VDI";
-
-                std::set<Utf8Str> listURIs = Appliance::URIFromTypeOfVirtualDiskFormat("VMDK");
-                std::set<Utf8Str>::const_iterator itr = listURIs.find(di.strFormat);
-
-                if (itr != listURIs.end())
-                {
-                    strSrcFormat = "VMDK";
-                }
-
-                srcFormat = pSysProps->mediumFormat(strSrcFormat);
-                if (srcFormat.isNull())
-                    throw setError(VBOX_E_NOT_SUPPORTED,
-                                   tr("Could not find a valid medium format for the source disk '%s'"),
-                                   RTPathFilename(strSrcFilePath.c_str()));
-
-                /* Clone the source disk image */
-                ComObjPtr<Medium> nullParent;
-                rc = pTargetHD->importFile(strSrcFilePath.c_str(),
-                                           srcFormat,
-                                           MediumVariant_Standard,
-                                           pCallbacks, pStorage,
-                                           nullParent,
-                                           pProgress);
-                if (FAILED(rc)) throw rc;
-
-                /* Advance to the next operation. */
-                stack.pProgress->SetNextOperation(BstrFmt(tr("Importing virtual disk image '%s'"), RTPathFilename(strSrcFilePath.c_str())).raw(),
-                                                  di.ulSuggestedSizeMB);// operation's weight, as set up with the IProgress originally);
-            }
-
-            /* Now wait for the background disk operation to complete; this throws
-             * HRESULTs on error. */
-            ComPtr<IProgress> pp(pProgress);
-            waitForAsyncProgress(stack.pProgress, pp);
+            if (pFileIo)
+                RTMemFree(pFileIo);
+
+            throw;
         }
     }
+
+    if (pFileIo)
+        RTMemFree(pFileIo);
 
     /* Add the newly create disk path + a corresponding digest the our list for
      * later manifest verification. */
-    stack.llSrcDisksDigest.push_back(STRPAIR(strSrcFilePath, pStorage ? pStorage->strDigest : ""));
+    stack.llSrcDisksDigest.push_back(STRPAIR(strSourceOVF, pStorage ? pStorage->strDigest : ""));
 }
 
@@ -2432 +2641 @@
     else if (vsdeNW.size() > maxNetworkAdapters)
         throw setError(VBOX_E_FILE_ERROR,
-                       tr("Too many network adapters: OVF requests %d network adapters, but VirtualBox only supports %d"),
+                       tr("Too many network adapters: OVF requests %d network adapters, "
+                          "but VirtualBox only supports %d"),
                        vsdeNW.size(), maxNetworkAdapters);
     else
@@ -2540 +2750 @@
     // IDE Hard disk controller
     std::list<VirtualSystemDescriptionEntry*> vsdeHDCIDE = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskControllerIDE);
-    // In OVF (at least VMware's version of it), an IDE controller has two ports, so VirtualBox's single IDE controller
-    // with two channels and two ports each counts as two OVF IDE controllers -- so we accept one or two such IDE controllers
+    /*
+     * In OVF (at least VMware's version of it), an IDE controller has two ports,
+     * so VirtualBox's single IDE controller with two channels and two ports each counts as
+     * two OVF IDE controllers -- so we accept one or two such IDE controllers
+     */
     size_t cIDEControllers = vsdeHDCIDE.size();
     if (cIDEControllers > 2)
@@ -2578 +2791 @@
         if (hdcVBox == "AHCI")
         {
-            rc = pNewMachine->AddStorageController(Bstr("SATA Controller").raw(), StorageBus_SATA, pController.asOutParam());
+            rc = pNewMachine->AddStorageController(Bstr("SATA Controller").raw(),
+                                                   StorageBus_SATA,
+                                                   pController.asOutParam());
             if (FAILED(rc)) throw rc;
         }
@@ -2629 +2844 @@
     {
         ComPtr<IStorageController> pController;
-        rc = pNewMachine->AddStorageController(Bstr(L"SAS Controller").raw(), StorageBus_SAS, pController.asOutParam());
+        rc = pNewMachine->AddStorageController(Bstr(L"SAS Controller").raw(),
+                                               StorageBus_SAS,
+                                               pController.asOutParam());
         if (FAILED(rc)) throw rc;
         rc = pController->COMSETTER(ControllerType)(StorageControllerType_LsiLogicSas);
@@ -2674 +2891 @@
             {
                 ComPtr<IStorageController> pController;
-                rc = sMachine->AddStorageController(Bstr("Floppy Controller").raw(), StorageBus_Floppy, pController.asOutParam());
+                rc = sMachine->AddStorageController(Bstr("Floppy Controller").raw(),
+                                                    StorageBus_Floppy,
+                                                    pController.asOutParam());
                 if (FAILED(rc)) throw rc;
 
@@ -2735 +2954 @@
             while(oit != stack.mapDisks.end())
             {
-                if (RTPathHaveExt(oit->second.strHref.c_str()))
-                {
-                    /* Figure out which format the user have. */
-                    char *pszExt = RTPathExt(oit->second.strHref.c_str());
-                    /* Get the system properties. */
-                    SystemProperties *pSysProps = mVirtualBox->getSystemProperties();
-                    ComObjPtr<MediumFormat> trgFormat = pSysProps->mediumFormatFromExtension(&pszExt[1]);
-                    if (trgFormat.isNull())
-                    {
-                        ++oit;
-                        continue;
-                    }
-                }
-
                 ovf::DiskImage diCurrent = oit->second;
                 ovf::VirtualDisksMap::const_iterator itVDisk = vsysThis.mapVirtualDisks.begin();
@@ -2789 +2994 @@
 
                 /*
-                 *
                  * preliminary check availability of the image
                  * This step is useful if image is placed in the OVA (TAR) package
-                 *
                  */
 
@@ -2820 +3023 @@
                         {
                             /* 
-                             * 
                              * availableImage contains the disk file reference (e.g. "disk1.vmdk"), which should exist
                              * in the global images map.
@@ -2847 +3049 @@
 
                             /* 
-                             *  
                              * Again iterate over all given disk images of the virtual system
                              * disks description using the found disk image 
-                             *  
                              */
                             {
@@ -2901 +3101 @@
                 ComObjPtr<Medium> pTargetHD;
 
+                Utf8Str savedVboxCurrent = vsdeTargetHD->strVboxCurrent;
+
                 importOneDiskImage(diCurrent,
-                                   vsdeTargetHD->strVboxCurrent,
+                                   &vsdeTargetHD->strVboxCurrent,
                                    pTargetHD,
                                    stack,
@@ -2965 +3167 @@
                 rc = sMachine->SaveSettings();
                 if (FAILED(rc)) throw rc;
+
+                /* restore */
+                vsdeTargetHD->strVboxCurrent = savedVboxCurrent;
+
             } // end while(oit != stack.mapDisks.end())
 
@@ -3024 +3230 @@
 
     /*
-     *
      * step 1): modify machine config according to OVF config, in case the user
      * has modified them using setFinalValues()
-     *
      */
 
@@ -3168 +3372 @@
 
     /*
-     *
      * step 2: scan the machine config for media attachments
-     *
      */
 
@@ -3187 +3389 @@
     while(oit != stack.mapDisks.end())
     {
-        if (RTPathHaveExt(oit->second.strHref.c_str()))
-        {
-            /* Figure out which format the user have. */
-            char *pszExt = RTPathExt(oit->second.strHref.c_str());
-            /* Get the system properties. */
-            SystemProperties *pSysProps = mVirtualBox->getSystemProperties();
-            ComObjPtr<MediumFormat> trgFormat = pSysProps->mediumFormatFromExtension(&pszExt[1]);
-            if (trgFormat.isNull())
-            {
-                ++oit;
-                continue;
-            }
-        }
-
         ovf::DiskImage diCurrent = oit->second;
 
@@ -3228 +3416 @@
 
         /*
-         *
          * preliminary check availability of the image
          * This step is useful if image is placed in the OVA (TAR) package
-         *
          */
 
@@ -3279 +3465 @@
                     diCurrent = *(&itDiskImage->second);
 
-                    /* Again iterate over all given disk images of the virtual system
+                    /* 
+                     * Again iterate over all given disk images of the virtual system
                      * disks description using the found disk image
                      */
@@ -3376 +3563 @@
                     continue;
                 }
+
                 /*
-                 *
                  * step 3: import disk
-                 *
                  */
+                Utf8Str savedVboxCurrent = vsdeTargetHD->strVboxCurrent;
                 ComObjPtr<Medium> pTargetHD;
                 importOneDiskImage(diCurrent,
-                                   vsdeTargetHD->strVboxCurrent,
+                                   &vsdeTargetHD->strVboxCurrent,
                                    pTargetHD,
                                    stack,
@@ -3418 +3605 @@
                 }
 
+                /* restore */
+                vsdeTargetHD->strVboxCurrent = savedVboxCurrent;
+
                 d.uuid = hdId;
                 fFound = true;
@@ -3434 +3624 @@
 
     /*
-     *
      * step 4): create the machine and have it import the config
-     *
      */
 
@@ -3446 +3634 @@
     // instance that we created from the vbox:Machine
     rc = pNewMachine->init(mVirtualBox,
-                           stack.strNameVBox,// name from OVF preparations; can be suffixed to avoid duplicates, or changed by user
+                           stack.strNameVBox,// name from OVF preparations; can be suffixed to avoid duplicates
                            config);          // the whole machine config
     if (FAILED(rc)) throw rc;

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

@@ -575 +575 @@
 {
     pZip->u.Zlib.next_out = (Bytef *)pvBuf;
-    pZip->u.Zlib.avail_out = (uInt)cbBuf;                   Assert(pZip->u.Zlib.avail_out == cbBuf);
+    pZip->u.Zlib.avail_out = (uInt)cbBuf;
+    Assert(pZip->u.Zlib.avail_out == cbBuf);
 
     /*
@@ -1927 +1928 @@
 RT_EXPORT_SYMBOL(RTZipBlockDecompress);
 
+RTDECL(int) RTZipGzipDecompressBuffer(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)
+        {
+            rc = zipErrConvertFromZlib(rc, false /*decompress*/);
+            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;
+}
+
+RT_EXPORT_SYMBOL(RTZipGzipDecompressBuffer);