Changeset 67203 in vbox for trunk/src/VBox/Main/src-server

Timestamp:

Jun 1, 2017 11:50:09 AM (8 years ago)

Author:

vboxsync

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

115885

Message:

Main: ApplianceImplExport.cpp: More hacking on OPC exporting.

Location:

trunk/src/VBox/Main/src-server

Files:

• ApplianceImplExport.cpp (modified) (1 diff)
• MediumImpl.cpp (modified) (1 diff)

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

@@ -2206 +2206 @@
 {
     LogFlowFuncEnter();
+    HRESULT hrc = S_OK;
 
     /*
-     * Open the output file, pipe it thru gzip and attach a TAR creator.
+     * We're duplicating parts of i_writeFSImpl here because that's simpler
+     * and creates less spaghetti code.
      */
-    HRESULT hrc;
-    RTVFSIOSTREAM hVfsIosFile;
-    int vrc = RTVfsIoStrmOpenNormal(pTask->locInfo.strPath.c_str(),
-                                    RTFILE_O_CREATE | RTFILE_O_WRITE | RTFILE_O_DENY_WRITE,
-                                    &hVfsIosFile);
-    if (RT_SUCCESS(vrc))
-    {
-
-        RTVFSIOSTREAM hVfsIosGzip;
-        vrc = RTZipGzipCompressIoStream(hVfsIosFile, 0 /*fFlags*/, 6 /*uLevel*/, &hVfsIosGzip);
-        RTVfsIoStrmRelease(hVfsIosFile);
-        if (RT_SUCCESS(vrc))
-        {
-
-            RTVFSFSSTREAM hVfsFssTar;
-            vrc = RTZipTarFsStreamToIoStream(hVfsIosGzip, RTZIPTARFORMAT_GNU, RTZIPTAR_C_SPARSE, &hVfsFssTar);
+    std::list<Utf8Str> lstTarballs;
+    try
+    {
+        /*
+         * Use i_buildXML to build a stack of disk images.  We don't care about the XML doc here.
+         */
+        XMLStack stack;
+        {
+            xml::Document doc;
+            i_buildXML(writeLock, doc, stack, pTask->locInfo.strPath, ovf::OVFVersion_2_0);
+        }
+
+        /*
+         * Process the disk images.
+         */
+        unsigned cTarballs = 0;
+        for (list<Utf8Str>::const_iterator it = stack.mapDiskSequence.begin();
+             it != stack.mapDiskSequence.end();
+             ++it)
+        {
+            const Utf8Str                       &strDiskID = *it;
+            const VirtualSystemDescriptionEntry *pDiskEntry = stack.mapDisks[strDiskID];
+            const Utf8Str                       &strSrcFilePath = pDiskEntry->strVBoxCurrent;  // where the VBox image is
+
+            /*
+             * Some skipping.
+             */
+            if (pDiskEntry->skipIt)
+                continue;
+
+            /* Skip empty media (DVD-ROM, floppy). */
+            if (strSrcFilePath.isEmpty())
+                continue;
+
+            /* Only deal with harddisk and DVD-ROMs, skip any floppies for now. */
+            if (   pDiskEntry->type != VirtualSystemDescriptionType_HardDiskImage
+                && pDiskEntry->type != VirtualSystemDescriptionType_CDROM)
+                continue;
+
+            /*
+             * Locate the Medium object for this entry (by location/path).
+             */
+            Log(("Finding source disk \"%s\"\n", strSrcFilePath.c_str()));
+            ComObjPtr<Medium> ptrSourceDisk;
+            if (pDiskEntry->type == VirtualSystemDescriptionType_HardDiskImage)
+                hrc = mVirtualBox->i_findHardDiskByLocation(strSrcFilePath, true, &ptrSourceDisk);
+            else
+                hrc = mVirtualBox->i_findDVDOrFloppyImage(DeviceType_DVD, NULL /*aId*/, strSrcFilePath,
+                                                          true /*aSetError*/, &ptrSourceDisk);
+            if (FAILED(hrc))
+                throw hrc;
+            if (strSrcFilePath.isEmpty())
+                continue;
+
+            /*
+             * Figure out the names.
+             */
+
+            /* The name inside the tarball.  Replace the suffix of harddisk images with ".img". */
+            Utf8Str strInsideName = pDiskEntry->strOvf;
+            if (pDiskEntry->type == VirtualSystemDescriptionType_HardDiskImage)
+                strInsideName.stripSuffix().append(".img");
+
+            /* The first tarball we create uses the specified name. Subsequent
+               takes the name from the disk entry or something. */
+            Utf8Str strTarballPath = pTask->locInfo.strPath;
+            if (cTarballs > 0)
+            {
+                /** @todo test this stuff   */
+                const char *pszExt = RTPathSuffix(pDiskEntry->strOvf.c_str());
+                pszExt = !pszExt || *pszExt == '.' ? "" : pszExt + 1;
+
+                strTarballPath.stripFilename().append(RTPATH_SLASH_STR).append(pDiskEntry->strOvf);
+                strTarballPath.stripSuffix().append("_").append(pszExt).append(".tar.gz");
+
+            }
+            cTarballs++;
+
+            /*
+             * Create the tar output stream.
+             */
+            RTVFSIOSTREAM hVfsIosFile;
+            int vrc = RTVfsIoStrmOpenNormal(strTarballPath.c_str(),
+                                            RTFILE_O_CREATE | RTFILE_O_WRITE | RTFILE_O_DENY_WRITE,
+                                            &hVfsIosFile);
+            if (RT_FAILURE(vrc))
+                throw setErrorVrc(vrc, tr("Failed to create '%s' (%Rrc)"), strTarballPath.c_str(), vrc);
+
+            RTVFSIOSTREAM hVfsIosGzip;
+            vrc = RTZipGzipCompressIoStream(hVfsIosFile, 0 /*fFlags*/, 6 /*uLevel*/, &hVfsIosGzip);
+            RTVfsIoStrmRelease(hVfsIosFile);
+
+            RTVFSFSSTREAM hVfsFssTar = NIL_RTVFSFSSTREAM;
+            if (RT_SUCCESS(vrc))
+                vrc = RTZipTarFsStreamToIoStream(hVfsIosGzip, RTZIPTARFORMAT_GNU, RTZIPTAR_C_SPARSE, &hVfsFssTar);
             RTVfsIoStrmRelease(hVfsIosGzip);
-            if (RT_SUCCESS(vrc))
+
+            if (RT_FAILURE(vrc))
             {
+                RTFileDelete(strTarballPath.c_str());
+                throw setErrorVrc(vrc, tr("Failed to TAR creator instance for '%s' (%Rrc)"), strTarballPath.c_str(), vrc);
+            }
+
+            /*
+             * The exporting requests a lock on the media tree. So temporarily
+             * leave the appliance lock.
+             */
+            writeLock.release();
+
+            try
+            {
+                /* advance to the next operation */
+                pTask->pProgress->SetNextOperation(BstrFmt(tr("Exporting to disk image '%Rbn'"), strTarballPath.c_str()).raw(),
+                                                   pDiskEntry->ulSizeMB);     // operation's weight, as set up
+                                                                              // with the IProgress originally
+                ///*
+                // * We threat the harddisks are raw images, but since they typically
+                // * require a lot more setup and configuration compares to ISOs, we
+                // * don't bother trying sharing code here (yet).
+                // */
+                //if (pDiskEntry->type == VirtualSystemDescriptionType_HardDiskImage)
+                    hrc = ptrSourceDisk->i_addRawToFss(strInsideName.c_str(), m->m_pSecretKeyStore, hVfsFssTar /*, pProgress2*/);
+                //else if (pDiskEntry->type == VirtualSystemDescriptionType_CDROM)
+                //{
+                //    /* Open the source image and cast it to a VFS base object. */
+                //    RTVFSFILE hVfsSrcFile;
+                //    vrc = RTVfsFileOpenNormal(strSrcFilePath.c_str(),
+                //                              RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_NONE,
+                //                              &hVfsSrcFile);
+                //    if (RT_FAILURE(vrc))
+                //        throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                //                           tr("Could not create or open file '%s' (%Rrc)"), strSrcFilePath.c_str(), vrc);
+                //
+                //    RTVFSOBJ hVfsSrc = RTVfsObjFromFile(hVfsSrcFile);
+                //    RTVfsFileRelease(hVfsSrcFile);
+                //    AssertStmt(hVfsSrc != NIL_RTVFSOBJ, throw VERR_INTERNAL_ERROR);
+                //
+                //    /* Add it to the output stream.  This will pull in all the data from the object. */
+                //    vrc = RTVfsFsStrmAdd(hVfsFssTar, strInsideName.c_str(), hVfsSrc, 0 /*fFlags*/);
+                //    RTVfsObjRelease(hVfsSrc);
+                //    if (RT_FAILURE(vrc))
+                //        throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,  tr("Error during copy CD/DVD image '%s' (%Rrc)"),
+                //                           strSrcFilePath.c_str(), vrc);
+                //}
+                //else
+                //    AssertFailedStmt(throw E_UNEXPECTED);
+                if (FAILED(hrc))
+                    throw hrc;
+
                 /*
-                 * Before we do the actual writing, disable OVF and manifest creation.
+                 * Complete and close the tarball.
                  */
-                bool fManifestSaved = m->fManifest;
-                m->fManifest = false;
-
-                hrc = i_writeFSImpl(pTask, writeLock, hVfsFssTar, false /*fOvfFile*/, false /*fStreamOptimizedVmdk*/);
+                vrc = RTVfsFsStrmEnd(hVfsFssTar);
                 RTVfsFsStrmRelease(hVfsFssTar);
-
-                m->fManifest = fManifestSaved;
+                hVfsFssTar = NIL_RTVFSFSSTREAM;
+                if (RT_FAILURE(vrc))
+                    throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                       tr("Error completing TAR file '%s' (%Rrc)"), strTarballPath.c_str(), vrc);
+
+                /* Remember the tarball name for cleanup. */
+                try { lstTarballs.push_back(strTarballPath.c_str()); }
+                catch (std::bad_alloc) { throw E_OUTOFMEMORY; }
             }
-            else
-                hrc = setErrorVrc(vrc, tr("Failed create TAR creator for '%s' (%Rrc)"), pTask->locInfo.strPath.c_str(), vrc);
-        }
-        else
-            hrc = setErrorVrc(vrc, tr("Failed create gzipper for '%s' (%Rrc)"), pTask->locInfo.strPath.c_str(), vrc);
-
-        /* Delete the OVA on failure. */
-        if (FAILED(hrc))
-            RTFileDelete(pTask->locInfo.strPath.c_str());
-    }
-    else
-        hrc = setErrorVrc(vrc, tr("Failed to open '%s' for writing (%Rrc)"), pTask->locInfo.strPath.c_str(), vrc);
+            catch (HRESULT hrc3)
+            {
+                writeLock.acquire();
+                RTVfsFsStrmRelease(hVfsFssTar);
+                RTFileDelete(strTarballPath.c_str());
+                throw hrc3;
+            }
+
+            // Finished, lock again (so nobody mess around with the medium tree
+            // in the meantime)
+            writeLock.acquire();
+        }
+    }
+    catch (HRESULT hrc2)
+    {
+        hrc = hrc2;
+    }
+
+    /*
+     * Delete output files on failure.
+     */
+    if (FAILED(hrc))
+        for (list<Utf8Str>::const_iterator it = lstTarballs.begin(); it != lstTarballs.end(); ++it)
+            RTFileDelete(it->c_str());
 
     LogFlowFuncLeave();

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

@@ -6092 +6092 @@
     }
     catch (HRESULT aRC) { rc = aRC; }
+
+    return rc;
+}
+
+/**
+ *
+ * @note    Similar code exists in i_taskExportHandler.
+ */
+HRESULT Medium::i_addRawToFss(const char *aFilename, SecretKeyStore *pKeyStore,
+                              RTVFSFSSTREAM hVfsFssDst /*, const ComObjPtr<Progress> &aProgress*/)
+{
+
+    //RT_NOREF(aProgress); /** @todo fix progress object. */
+
+    /*
+     * Build the source lock list.
+     */
+    MediumLockList SourceMediumLockList;
+    HRESULT rc = i_createMediumLockList(true /* fFailIfInaccessible */,
+                                        NULL /* pToLockWrite */,
+                                        false /* fMediumLockWriteAll */,
+                                        NULL,
+                                        SourceMediumLockList);
+    if (FAILED(rc))
+        return rc;
+
+    try
+    {
+        /*
+         * Lock all in {parent,child} order.
+         */
+        ComObjPtr<Medium> pBase = i_getBase();
+        AutoWriteLock thisLock(this COMMA_LOCKVAL_SRC_POS);
+
+        PVDISK hdd;
+        int vrc = VDCreate(m->vdDiskIfaces, i_convertDeviceType(), &hdd);
+        ComAssertRCThrow(vrc, E_FAIL);
+
+        try
+        {
+            settings::StringsMap::iterator itKeyStore = pBase->m->mapProperties.find("CRYPT/KeyStore");
+            if (itKeyStore != pBase->m->mapProperties.end())
+            {
+                settings::StringsMap::iterator itKeyId = pBase->m->mapProperties.find("CRYPT/KeyId");
+
+#ifdef VBOX_WITH_EXTPACK
+                ExtPackManager *pExtPackManager = m->pVirtualBox->i_getExtPackManager();
+                if (pExtPackManager->i_isExtPackUsable(ORACLE_PUEL_EXTPACK_NAME))
+                {
+                    /* Load the plugin */
+                    Utf8Str strPlugin;
+                    rc = pExtPackManager->i_getLibraryPathForExtPack(g_szVDPlugin, ORACLE_PUEL_EXTPACK_NAME, &strPlugin);
+                    if (SUCCEEDED(rc))
+                    {
+                        vrc = VDPluginLoadFromFilename(strPlugin.c_str());
+                        if (RT_FAILURE(vrc))
+                            throw setError(VBOX_E_NOT_SUPPORTED,
+                                           tr("Retrieving encryption settings of the image failed because the encryption plugin could not be loaded (%s)"),
+                                           i_vdError(vrc).c_str());
+                    }
+                    else
+                        throw setError(VBOX_E_NOT_SUPPORTED,
+                                       tr("Encryption is not supported because the extension pack '%s' is missing the encryption plugin (old extension pack installed?)"),
+                                       ORACLE_PUEL_EXTPACK_NAME);
+                }
+                else
+                    throw setError(VBOX_E_NOT_SUPPORTED,
+                                   tr("Encryption is not supported because the extension pack '%s' is missing"),
+                                   ORACLE_PUEL_EXTPACK_NAME);
+#else
+                throw setError(VBOX_E_NOT_SUPPORTED,
+                               tr("Encryption is not supported because extension pack support is not built in"));
+#endif
+
+                if (itKeyId == pBase->m->mapProperties.end())
+                    throw setError(VBOX_E_INVALID_OBJECT_STATE,
+                                   tr("Image '%s' is configured for encryption but doesn't has a key identifier set"),
+                                   pBase->m->strLocationFull.c_str());
+
+                /* Find the proper secret key in the key store. */
+                if (!pKeyStore)
+                    throw setError(VBOX_E_INVALID_OBJECT_STATE,
+                                   tr("Image '%s' is configured for encryption but there is no key store to retrieve the password from"),
+                                   pBase->m->strLocationFull.c_str());
+
+                SecretKey *pKey = NULL;
+                vrc = pKeyStore->retainSecretKey(itKeyId->second, &pKey);
+                if (RT_FAILURE(vrc))
+                    throw setError(VBOX_E_INVALID_OBJECT_STATE,
+                                   tr("Failed to retrieve the secret key with ID \"%s\" from the store (%Rrc)"),
+                                   itKeyId->second.c_str(), vrc);
+
+                Medium::CryptoFilterSettings CryptoSettingsRead;
+                i_taskEncryptSettingsSetup(&CryptoSettingsRead, NULL, itKeyStore->second.c_str(), (const char *)pKey->getKeyBuffer(),
+                                           false /* fCreateKeyStore */);
+                vrc = VDFilterAdd(hdd, "CRYPT", VD_FILTER_FLAGS_READ, CryptoSettingsRead.vdFilterIfaces);
+                pKeyStore->releaseSecretKey(itKeyId->second);
+                if (vrc == VERR_VD_PASSWORD_INCORRECT)
+                    throw setError(VBOX_E_PASSWORD_INCORRECT, tr("The password to decrypt the image is incorrect"));
+                if (RT_FAILURE(vrc))
+                    throw setError(VBOX_E_INVALID_OBJECT_STATE, tr("Failed to load the decryption filter: %s"),
+                                   i_vdError(vrc).c_str());
+            }
+
+            /* Open all media in the source chain. */
+            MediumLockList::Base::const_iterator sourceListBegin = SourceMediumLockList.GetBegin();
+            MediumLockList::Base::const_iterator sourceListEnd = SourceMediumLockList.GetEnd();
+            for (MediumLockList::Base::const_iterator it = sourceListBegin; it != sourceListEnd; ++it)
+            {
+                const MediumLock &mediumLock = *it;
+                const ComObjPtr<Medium> &pMedium = mediumLock.GetMedium();
+                AutoReadLock alock(pMedium COMMA_LOCKVAL_SRC_POS);
+
+                /* sanity check */
+                Assert(pMedium->m->state == MediumState_LockedRead);
+
+                /* Open all media in read-only mode. */
+                vrc = VDOpen(hdd,
+                             pMedium->m->strFormat.c_str(),
+                             pMedium->m->strLocationFull.c_str(),
+                             VD_OPEN_FLAGS_READONLY | m->uOpenFlagsDef,
+                             pMedium->m->vdImageIfaces);
+                if (RT_FAILURE(vrc))
+                    throw setError(VBOX_E_FILE_ERROR,
+                                   tr("Could not open the medium storage unit '%s'%s"),
+                                   pMedium->m->strLocationFull.c_str(),
+                                   i_vdError(vrc).c_str());
+            }
+
+            Assert(m->state == MediumState_LockedRead);
+
+            /* unlock before the potentially lengthy operation */
+            thisLock.release();
+
+            /*
+             * Create a VFS file interface to the HDD.
+             */
+            RTVFSFILE hVfsFile = NIL_RTVFSFILE;
+            vrc = VDCreateVfsFileFromDisk(hdd, 0 /*fFlags*/, &hVfsFile);
+            if (RT_SUCCESS(vrc))
+            {
+                RTVFSOBJ hVfsObj = RTVfsObjFromFile(hVfsFile);
+                RTVfsFileRelease(hVfsFile);
+                vrc = RTVfsFsStrmAdd(hVfsFssDst, aFilename, hVfsObj, 0 /*fFlags*/);
+                RTVfsObjRelease(hVfsObj);
+                if (RT_FAILURE(vrc))
+                    rc = setErrorBoth(VBOX_E_FILE_ERROR, vrc, tr("Failed to add '%s' to output (%Rrc)"), aFilename, vrc);
+            }
+            else
+                rc = setErrorBoth(VBOX_E_FILE_ERROR, vrc, tr("VDCreateVfsFileFromDisk failed for '%s' (%Rrc)"), aFilename, vrc);
+        }
+        catch (HRESULT hrc3) { rc = hrc3; }
+
+        VDDestroy(hdd);
+    }
+    catch (HRESULT hrc2) { rc = hrc2; }
+
+    /* Everything is explicitly unlocked when the task exits,
+     * as the task destruction also destroys the source chain. */
+
+    /* Make sure the source chain is released early, otherwise it can
+     * lead to deadlocks with concurrent IAppliance activities. */
+    SourceMediumLockList.Clear();
 
     return rc;