Changeset 34787 in vbox

Timestamp:

Dec 7, 2010 2:51:18 PM (14 years ago)

Author:

vboxsync

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

68597

Message:

Main,VBoxManage,FE/Qt: Implemented IExtPackFile and dropped IExtPackManager::Install.

Location:

trunk/src/VBox

Files:

• Frontends/VBoxManage/VBoxManageMisc.cpp (modified) (2 diffs)
• Frontends/VirtualBox/src/globals/VBoxProblemReporter.cpp (modified) (2 diffs)
• Frontends/VirtualBox/src/globals/VBoxProblemReporter.h (modified) (1 diff)
• Frontends/VirtualBox/src/selector/VBoxSelectorWnd.cpp (modified) (2 diffs)
• Frontends/VirtualBox/src/settings/global/UIGlobalSettingsExtension.cpp (modified) (3 diffs)
• Frontends/VirtualBox/src/settings/global/UIGlobalSettingsExtension.h (modified) (1 diff)
• Main/ExtPackManagerImpl.cpp (modified) (12 diffs)
• Main/ExtPackUtil.cpp (modified) (6 diffs)
• Main/VBoxExtPackHelperApp.cpp (modified) (9 diffs)
• Main/idl/VirtualBox.xidl (modified) (2 diffs)
• Main/include/ExtPackManagerImpl.h (modified) (6 diffs)
• Main/include/ExtPackUtil.h (modified) (4 diffs)

trunk/src/VBox/Frontends/VBoxManage/VBoxManageMisc.cpp

@@ -21 +21 @@
 *******************************************************************************/
 #ifndef VBOX_ONLY_DOCS
-#include <VBox/com/com.h>
-#include <VBox/com/string.h>
-#include <VBox/com/Guid.h>
-#include <VBox/com/array.h>
-#include <VBox/com/ErrorInfo.h>
-#include <VBox/com/errorprint.h>
-#include <VBox/com/EventQueue.h>
-
-#include <VBox/com/VirtualBox.h>
+# include <VBox/com/com.h>
+# include <VBox/com/string.h>
+# include <VBox/com/Guid.h>
+# include <VBox/com/array.h>
+# include <VBox/com/ErrorInfo.h>
+# include <VBox/com/errorprint.h>
+# include <VBox/com/EventQueue.h>
+
+# include <VBox/com/VirtualBox.h>
 #endif /* !VBOX_ONLY_DOCS */
 
@@ -912 +912 @@
         Bstr bstrTarball(szPath);
         Bstr bstrName;
-        CHECK_ERROR2_RET(ptrExtPackMgr, Install(bstrTarball.raw(), bstrName.asOutParam()), RTEXITCODE_FAILURE);
+        ComPtr<IExtPackFile> ptrExtPackFile;
+        CHECK_ERROR2_RET(ptrExtPackMgr, OpenExtPackFile(bstrTarball.raw(), ptrExtPackFile.asOutParam()), RTEXITCODE_FAILURE);
+        CHECK_ERROR2_RET(ptrExtPackFile, COMGETTER(Name)(bstrName.asOutParam()), RTEXITCODE_FAILURE);
+        CHECK_ERROR2_RET(ptrExtPackFile, Install(), RTEXITCODE_FAILURE);
         RTPrintf("Successfully installed \"%lS\".\n", bstrName.raw());
     }

trunk/src/VBox/Frontends/VirtualBox/src/globals/VBoxProblemReporter.cpp

@@ -45 +45 @@
 
 #if defined (Q_WS_WIN32)
-#include <Htmlhelp.h>
+# include <Htmlhelp.h>
 #endif
 
@@ -2110 +2110 @@
 }
 
-void VBoxProblemReporter::cannotInstallExtPack(const QString &strFilename, const CExtPackManager &extPackManager, QWidget *pParent /* = 0 */)
+void VBoxProblemReporter::cannotOpenExtPack(const QString &strFilename, const CExtPackManager &extPackManager, QWidget *pParent /* = 0 */)
+{
+    message (pParent ? pParent : mainWindowShown(),
+             Error,
+             tr("Failed to open the Extension Pack <b>%1</b>.").arg(strFilename),
+             formatErrorInfo(extPackManager));
+}
+
+void VBoxProblemReporter::badExtPackFile(const QString &strFilename, const CExtPackFile &extPackFile, QWidget *pParent /* = 0 */)
+{
+    message (pParent ? pParent : mainWindowShown(),
+             Error,
+             tr("Failed to open the Extension Pack <b>%1</b>.").arg(strFilename),
+             extPackFile.GetWhyUnusable());
+}
+
+void VBoxProblemReporter::cannotInstallExtPack(const QString &strFilename, const CExtPackFile &extPackFile, QWidget *pParent /* = 0 */)
 {
     message (pParent ? pParent : mainWindowShown(),
              Error,
              tr("Failed to install the Extension Pack <b>%1</b>.").arg(strFilename),
-             formatErrorInfo(extPackManager));
+             formatErrorInfo(extPackFile));
 }
 

trunk/src/VBox/Frontends/VirtualBox/src/globals/VBoxProblemReporter.h

@@ -338 +338 @@
     void cannotUpdateGuestAdditions (const CProgress &aProgress, QWidget *aParent /* = NULL */) const;
 
-    void cannotInstallExtPack(const QString &strFilename, const CExtPackManager &extPackManager, QWidget *pParent = 0);
+    void cannotOpenExtPack(const QString &strFilename, const CExtPackManager &extPackManager, QWidget *pParent = 0);
+    void badExtPackFile(const QString &strFilename, const CExtPackFile &extPackFile, QWidget *pParent = 0);
+    void cannotInstallExtPack(const QString &strFilename, const CExtPackFile &extPackFile, QWidget *pParent = 0);
     void cannotUninstallExtPack(const QString &strPackName, const CExtPackManager &extPackManager, QWidget *pParent = 0);
     bool confirmRemovingPackage(const QString &strPackName, QWidget *pParent = 0);

trunk/src/VBox/Frontends/VirtualBox/src/selector/VBoxSelectorWnd.cpp

@@ -39 +39 @@
 #include "QIFileDialog.h"
 #include "UIDesktopServices.h"
+#include "UIGlobalSettingsExtension.h" /* extension pack installation */
 
 #ifdef VBOX_GUI_WITH_SYSTRAY
@@ -1011 +1012 @@
             else if (VBoxGlobal::hasAllowedExtension(strFile, VBoxDefs::VBoxExtPackFileExts))
             {
-                CExtPackManager extPackManager = vboxGlobal().virtualBox().GetExtensionPackManager();
-                extPackManager.Install(strFile);
-                if (!extPackManager.isOk())
-                    vboxProblem().cannotInstallExtPack(strFile, extPackManager, this);
+                UIGlobalSettingsExtension::doInstallation(strFile, this, NULL);
             }
         }

trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsExtension.cpp

@@ -104 +104 @@
 }
 
+/**
+ * Attempt the actual installation.
+ *
+ * This code is shared by UIGlobalSettingsExtension::sltInstallPackage and
+ * VBoxSelectorWnd::sltOpenUrls.
+ * @todo    Is there perhaps a better home for this method?
+ *
+ * @returns true if successfully installed, false if not.
+ * @param   strFilePath     The path to the tarball.
+ * @param   pParent         The parent widget.
+ * @param   pstrExtPackName Where to return the extension pack name. Optional.
+ */
+/*static*/ bool UIGlobalSettingsExtension::doInstallation(QString const &strFilePath, QWidget *pParent, QString *pstrExtPackName)
+{
+    bool fInstalled = false;
+
+    /*
+     * Open the extpack tarball via IExtPackManager.
+     */
+    CExtPackManager manager = vboxGlobal().virtualBox().GetExtensionPackManager();
+    CExtPackFile extPackFile = manager.OpenExtPackFile(strFilePath);
+    if (manager.isOk())
+    {
+        if (pstrExtPackName)
+            *pstrExtPackName = extPackFile.GetName();
+        if (extPackFile.GetUsable())
+        {
+            bool fAck = true;
+            /** @todo display big fat warning message. */
+
+            if (fAck)
+            {
+                /** @todo display licenses.  */
+            }
+
+            /*
+             * Install it if everything was ACKed by the user.
+             */
+            if (fAck)
+            {
+                extPackFile.Install();
+                if (extPackFile.isOk())
+                    fInstalled = true;
+                else
+                    vboxProblem().cannotInstallExtPack(strFilePath, extPackFile, pParent);
+            }
+        }
+        else
+            vboxProblem().badExtPackFile(strFilePath, extPackFile, pParent);
+    }
+    else
+        vboxProblem().cannotOpenExtPack(strFilePath, manager, pParent);
+
+    return fInstalled;
+}
+
 /* Load data to cashe from corresponding external object(s),
  * this task COULD be performed in other than GUI thread: */
@@ -208 +264 @@
         extensions << QString("*.%1").arg(VBoxDefs::VBoxExtPackFileExts[i]);
     QString strFilter = tr("Extension package files (%1)").arg(extensions.join(" "));
+
     /* Create open file dialog: */
     QStringList fileNames = QIFileDialog::getOpenFileNames(strBaseFolder, strFilter, this, strTitle, 0, true, true);
@@ -213 +270 @@
         strFilePath = fileNames.at(0);
 
-    /* Install chosen package: */
+    /*
+     * Install chosen package.
+     */
     if (!strFilePath.isEmpty())
     {
-        /* Get package manager: */
-        CExtPackManager manager = vboxGlobal().virtualBox().GetExtensionPackManager();
-        /* Install package & get the name of newly installed package: */
-        QString strAddedPackageName = manager.Install(strFilePath);
-        if (manager.isOk())
+        QString strExtPackName;
+        if (doInstallation(strFilePath, this, &strExtPackName))
         {
-            /* Get the newly added package: */
-            const CExtPack &package = manager.Find(strAddedPackageName);
-            /* Add newly added package into cache: */
+            /*
+             * Insert the fresly installed extension pack, mark it as
+             * current in the tree and sort by name (col 1).
+             */
+            CExtPackManager manager = vboxGlobal().virtualBox().GetExtensionPackManager();
+            const CExtPack &package = manager.Find(strExtPackName);
             m_cache.m_items << fetchData(package);
-            /* Add newly added package into tree: */
             UIExtensionPackageItem *pItem = new UIExtensionPackageItem(m_pPackagesTree, m_cache.m_items.last());
-            /* Set the newly created item as current: */
             m_pPackagesTree->setCurrentItem(pItem);
-            /* Sort the tree by <name> column: */
             m_pPackagesTree->sortByColumn(1, Qt::AscendingOrder);
         }
-        else vboxProblem().cannotInstallExtPack(strFilePath, manager, this);
     }
 }

trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsExtension.h

@@ -51 +51 @@
     UIGlobalSettingsExtension();
 
+    static bool doInstallation(QString const &strFilePath, QWidget *pParent, QString *pstrExtPackName);
+
 protected:
 

trunk/src/VBox/Main/ExtPackManagerImpl.cpp

@@ -88 +88 @@
     /** The file handle of the extension pack file. */
     RTFILE              hExtPackFile;
+    /** Pointer to the extension pack manager. */
+    ComObjPtr<ExtPackManager> ptrExtPackMgr;
+
+    RTMEMEF_NEW_AND_DELETE_OPERATORS();
 };
 
@@ -119 +123 @@
     /** Set if we've made the pfnVirtualBoxReady or pfnConsoleReady call. */
     bool                fMadeReadyCall;
+
+    RTMEMEF_NEW_AND_DELETE_OPERATORS();
 };
 
@@ -143 +149 @@
     /** The current context. */
     VBOXEXTPACKCTX      enmContext;
+
+    RTMEMEF_NEW_AND_DELETE_OPERATORS();
 };
 
@@ -166 +174 @@
  * @returns COM status code.
  * @param   a_pszFile       The path to the extension pack file.
- */
-HRESULT ExtPackFile::initWithFile(const char *a_pszFile)
+ * @param   a_pExtPackMgr   Pointer to the extension pack manager.
+ */
+HRESULT ExtPackFile::initWithFile(const char *a_pszFile, ExtPackManager *a_pExtPackMgr)
 {
     AutoInitSpan autoInitSpan(this);
@@ -181 +190 @@
     m->strWhyUnusable               = tr("ExtPack::init failed");
     m->strExtPackFile               = a_pszFile;
-
-    /*
-     * Probe the extension pack (this code is shared with refresh()).
-     */
+    m->hExtPackFile                 = NIL_RTFILE;
+    m->ptrExtPackMgr                = a_pExtPackMgr;
+
+    iprt::MiniString *pstrTarName = VBoxExtPackExtractNameFromTarballPath(a_pszFile);
+    if (pstrTarName)
+    {
+        m->Desc.strName = *pstrTarName;
+        delete pstrTarName;
+        pstrTarName = NULL;
+    }
 
     autoInitSpan.setSucceeded();
+
+    /*
+     * Try open the extension pack and check that it is a regular file.
+     */
+    int vrc = RTFileOpen(&m->hExtPackFile, a_pszFile,
+                         RTFILE_O_READ | RTFILE_O_DENY_WRITE | RTFILE_O_OPEN);
+    if (RT_FAILURE(vrc))
+    {
+        if (vrc == VERR_FILE_NOT_FOUND || vrc == VERR_PATH_NOT_FOUND)
+            return initFailed(tr("'%s' file not found"), a_pszFile);
+        return initFailed(tr("RTFileOpen('%s',,) failed with %Rrc"), a_pszFile, vrc);
+    }
+
+    RTFSOBJINFO ObjInfo;
+    vrc = RTFileQueryInfo(m->hExtPackFile, &ObjInfo, RTFSOBJATTRADD_UNIX);
+    if (RT_FAILURE(vrc))
+        return initFailed(tr("RTFileQueryInfo failed with %Rrc on '%s'"), vrc, a_pszFile);
+    if (!RTFS_IS_FILE(ObjInfo.Attr.fMode))
+        return initFailed(tr("Not a regular file: %s"), a_pszFile);
+
+    /*
+     * Validate the tarball and extract the XML file.
+     */
+    char        szError[8192];
+    RTVFSFILE   hXmlFile;
+    vrc = VBoxExtPackValidateTarball(m->hExtPackFile, NULL /*pszExtPackName*/, a_pszFile,
+                                     szError, sizeof(szError), NULL /*phValidManifest*/, &hXmlFile);
+    if (RT_FAILURE(vrc))
+        return initFailed(tr("%s"), szError);
+
+    /*
+     * Parse the XML.
+     */
+    iprt::MiniString strSavedName(m->Desc.strName);
+    iprt::MiniString *pStrLoadErr = VBoxExtPackLoadDescFromVfsFile(hXmlFile, &m->Desc, &m->ObjInfoDesc);
+    RTVfsFileRelease(hXmlFile);
+    if (pStrLoadErr != NULL)
+    {
+        m->strWhyUnusable.printf(tr("Failed to the xml file: %s"), pStrLoadErr->c_str());
+        m->Desc.strName = strSavedName;
+        delete pStrLoadErr;
+        return S_OK;
+    }
+
+    /*
+     * Match the tarball name with the name from the XML.
+     */
+    /** @todo drop this restriction after the old install interface is
+     *        dropped. */
+    if (!strSavedName.equalsIgnoreCase(m->Desc.strName))
+        return initFailed(tr("Extension pack name mismatch between the downloaded file and the XML inside it (xml='%s' file='%s')"),
+                          m->Desc.strName.c_str(), strSavedName.c_str());
+
+    m->fUsable = true;
+    m->strWhyUnusable.setNull();
+    return S_OK;
+}
+
+/**
+ * Protected helper that formats the strExtPackFile value.
+ *
+ * @returns S_OK
+ * @param   a_pszWhyFmt         Why it failed, format string.
+ * @param   ...                 The format arguments.
+ */
+HRESULT ExtPackFile::initFailed(const char *a_pszWhyFmt, ...)
+{
+    va_list va;
+    va_start(va, a_pszWhyFmt);
+    m->strExtPackFile.printfV(a_pszWhyFmt, va);
+    va_end(va);
     return S_OK;
 }
@@ -208 +294 @@
     {
         VBoxExtPackFreeDesc(&m->Desc);
+        RTFileClose(m->hExtPackFile);
+        m->hExtPackFile = NIL_RTFILE;
 
         delete m;
@@ -326 +414 @@
 STDMETHODIMP ExtPackFile::Install(void)
 {
-    return E_NOTIMPL;
+    AutoCaller autoCaller(this);
+    HRESULT hrc = autoCaller.rc();
+    if (SUCCEEDED(hrc))
+    {
+        if (m->fUsable)
+            hrc = m->ptrExtPackMgr->doInstall(this);
+        else
+            hrc = setError(E_FAIL, "%s", m->strWhyUnusable.c_str());
+    }
+    return hrc;
 }
 
@@ -1452 +1549 @@
     /* else: ignore, the directory probably does not exist or something. */
 
+#if 0
     /*
      * Look for things in the drop zone.
@@ -1457 +1555 @@
     if (SUCCEEDED(hrc) && a_fCheckDropZone)
         processDropZone();
+#else
+    NOREF(a_fCheckDropZone);
+#endif
 
     if (SUCCEEDED(hrc))
@@ -1534 +1635 @@
     AssertReturn(m->enmContext == VBOXEXTPACKCTX_PER_USER_DAEMON, E_UNEXPECTED);
 
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP ExtPackManager::Install(IN_BSTR a_bstrTarball, BSTR *a_pbstrName)
-{
-    CheckComArgNotNull(a_bstrTarball);
-    CheckComArgOutPointerValid(a_pbstrName);
-    Utf8Str strTarball(a_bstrTarball);
-    AssertReturn(m->enmContext == VBOXEXTPACKCTX_PER_USER_DAEMON, E_UNEXPECTED);
-
-    AutoCaller autoCaller(this);
-    HRESULT hrc = autoCaller.rc();
-    if (SUCCEEDED(hrc))
-    {
-        AutoWriteLock autoLock(this COMMA_LOCKVAL_SRC_POS);
-
-        /*
-         * Check that the file exists and that we can access it.
-         */
-        if (RTFileExists(strTarball.c_str()))
-        {
-            RTFILE hFile;
-            int vrc = RTFileOpen(&hFile, strTarball.c_str(),
-                                 RTFILE_O_READ | RTFILE_O_DENY_WRITE | RTFILE_O_OPEN | RTFILE_O_INHERIT);
-            if (RT_SUCCESS(vrc))
-            {
-                RTFSOBJINFO ObjInfo;
-                vrc = RTFileQueryInfo(hFile, &ObjInfo, RTFSOBJATTRADD_NOTHING);
-                if (   RT_SUCCESS(vrc)
-                    && RTFS_IS_FILE(ObjInfo.Attr.fMode))
-                {
-                    /*
-                     * Derive the name of the extension pack from the file
-                     * name, saving us the trouble of having to unpack it and
-                     * parse its XML to figure it out.   While this restricts
-                     * the filename a bit, it also forces it to be clearer, so
-                     * it shouldn't really be a problem.
-                     */
-                    iprt::MiniString *pStrName = VBoxExtPackExtractNameFromTarballPath(strTarball.c_str());
-                    if (pStrName)
-                    {
-                        /*
-                         * Refresh the data we have on the extension pack as it
-                         * may be made stale by direct meddling or some other user.
-                         */
-                        ExtPack *pExtPack;
-                        hrc = refreshExtPack(pStrName->c_str(), false /*a_fUnsuableIsError*/, &pExtPack);
-                        if (SUCCEEDED(hrc) && !pExtPack)
-                        {
-                            /*
-                             * Run the set-uid-to-root binary that performs the actual
-                             * installation.  Then create an object for the packet (we
-                             * do this even on failure, to be on the safe side).
-                             */
-                            char szTarballFd[64];
-                            RTStrPrintf(szTarballFd, sizeof(szTarballFd), "0x%RX64",
-                                        (uint64_t)RTFileToNative(hFile));
-
-                            hrc = runSetUidToRootHelper("install",
-                                                        "--base-dir",   m->strBaseDir.c_str(),
-                                                        "--cert-dir",   m->strCertificatDirPath.c_str(),
-                                                        "--name",       pStrName->c_str(),
-                                                        "--tarball",    strTarball.c_str(),
-#ifndef RT_OS_WINDOWS /* Not possible since the app might be launched by some unrelated service. */
-                                                        "--tarball-fd", &szTarballFd[0],
-#endif
-                                                        NULL);
-                            RTFileClose(hFile); hFile = NIL_RTFILE;
-                            if (SUCCEEDED(hrc))
-                            {
-                                hrc = refreshExtPack(pStrName->c_str(), true /*a_fUnsuableIsError*/, &pExtPack);
-                                if (SUCCEEDED(hrc))
-                                {
-                                    LogRel(("ExtPackManager: Successfully installed extension pack '%s'.\n", pStrName->c_str()));
-                                    pExtPack->callInstalledHook(m->pVirtualBox, &autoLock);
-
-                                    /*
-                                     * Finally, return the name.
-                                     */
-                                    hrc = pExtPack->COMGETTER(Name)(a_pbstrName);
-                                }
-                            }
-                            else
-                            {
-                                ErrorInfoKeeper Eik;
-                                refreshExtPack(pStrName->c_str(), false /*a_fUnsuableIsError*/, NULL);
-                            }
-                        }
-                        else if (SUCCEEDED(hrc))
-                            hrc = setError(E_FAIL,
-                                           tr("Extension pack '%s' is already installed."
-                                              " In case of a reinstallation, please uninstall it first"),
-                                           pStrName->c_str());
-                        delete pStrName;
-                    }
-                    else
-                        hrc = setError(E_FAIL, tr("Malformed '%s' file name"), strTarball.c_str());
-                }
-                else if (RT_SUCCESS(vrc))
-                    hrc = setError(E_FAIL, tr("'%s' is not a regular file"), strTarball.c_str());
-                else
-                    hrc = setError(E_FAIL, tr("Failed to query info on '%s' (%Rrc)"), strTarball.c_str(), vrc);
-                RTFileClose(hFile);
-            }
-            else
-                hrc = setError(E_FAIL, tr("Failed to open '%s' (%Rrc)"), strTarball.c_str(), vrc);
-        }
-        else if (RTPathExists(strTarball.c_str()))
-            hrc = setError(E_FAIL, tr("'%s' is not a regular file"), strTarball.c_str());
-        else
-            hrc = setError(E_FAIL, tr("File '%s' was inaccessible or not found"), strTarball.c_str());
-
-        /*
-         * Do VirtualBoxReady callbacks now for any freshly installed
-         * extension pack (old ones will not be called).
-         */
-        if (m->enmContext == VBOXEXTPACKCTX_PER_USER_DAEMON)
-        {
-            autoLock.release();
-            callAllVirtualBoxReadyHooks();
-        }
-    }
+    ComObjPtr<ExtPackFile> NewExtPackFile;
+    HRESULT hrc = NewExtPackFile.createObject();
+    if (SUCCEEDED(hrc))
+        hrc = NewExtPackFile->initWithFile(strTarball.c_str(), this);
+    if (SUCCEEDED(hrc))
+        NewExtPackFile.queryInterfaceTo(a_ppExtPackFile);
 
     return hrc;
@@ -2157 +2142 @@
 }
 
-
+/**
+ * Worker for IExtPackFile::Install.
+ *
+ * @returns COM status code.
+ * @param   a_pExtPackFile  The extension pack file, caller checks that it's
+ *                          usable.
+ */
+HRESULT ExtPackManager::doInstall(ExtPackFile *a_pExtPackFile)
+{
+    AssertReturn(m->enmContext == VBOXEXTPACKCTX_PER_USER_DAEMON, E_UNEXPECTED);
+    iprt::MiniString const * const pStrName     = &a_pExtPackFile->m->Desc.strName;
+    iprt::MiniString const * const pStrTarball  = &a_pExtPackFile->m->strExtPackFile;
+
+    AutoCaller autoCaller(this);
+    HRESULT hrc = autoCaller.rc();
+    if (SUCCEEDED(hrc))
+    {
+        AutoWriteLock autoLock(this COMMA_LOCKVAL_SRC_POS);
+
+        /*
+         * Refresh the data we have on the extension pack as it
+         * may be made stale by direct meddling or some other user.
+         */
+        ExtPack *pExtPack;
+        hrc = refreshExtPack(pStrName->c_str(), false /*a_fUnsuableIsError*/, &pExtPack);
+        if (SUCCEEDED(hrc) && !pExtPack)
+        {
+            /*
+             * Run the privileged helper binary that performs the actual
+             * installation.  Then create an object for the packet (we do this
+             * even on failure, to be on the safe side).
+             */
+/** @todo add a hash (SHA-256) of the tarball or maybe just the manifest. */
+            hrc = runSetUidToRootHelper("install",
+                                        "--base-dir",   m->strBaseDir.c_str(),
+                                        "--cert-dir",   m->strCertificatDirPath.c_str(),
+                                        "--name",       pStrName->c_str(),
+                                        "--tarball",    pStrTarball->c_str(),
+                                        NULL);
+            if (SUCCEEDED(hrc))
+            {
+                hrc = refreshExtPack(pStrName->c_str(), true /*a_fUnsuableIsError*/, &pExtPack);
+                if (SUCCEEDED(hrc))
+                {
+                    LogRel(("ExtPackManager: Successfully installed extension pack '%s'.\n", pStrName->c_str()));
+                    pExtPack->callInstalledHook(m->pVirtualBox, &autoLock);
+                }
+            }
+            else
+            {
+                ErrorInfoKeeper Eik;
+                refreshExtPack(pStrName->c_str(), false /*a_fUnsuableIsError*/, NULL);
+            }
+        }
+        else if (SUCCEEDED(hrc))
+            hrc = setError(E_FAIL,
+                           tr("Extension pack '%s' is already installed."
+                              " In case of a reinstallation, please uninstall it first"),
+                           pStrName->c_str());
+
+        /*
+         * Do VirtualBoxReady callbacks now for any freshly installed
+         * extension pack (old ones will not be called).
+         */
+        if (m->enmContext == VBOXEXTPACKCTX_PER_USER_DAEMON)
+        {
+            autoLock.release();
+            callAllVirtualBoxReadyHooks();
+        }
+    }
+
+    return hrc;
+}
+
+#if 0
 /**
  * Processes anything new in the drop zone.
@@ -2241 +2300 @@
     RTDirClose(pDir);
 }
+#endif
 
 

trunk/src/VBox/Main/ExtPackUtil.cpp

@@ -25 +25 @@
 #include <iprt/dir.h>
 #include <iprt/file.h>
+#include <iprt/manifest.h>
 #include <iprt/param.h>
 #include <iprt/path.h>
 #include <iprt/string.h>
+#include <iprt/vfs.h>
+#include <iprt/tar.h>
+#include <iprt/zip.h>
 #include <iprt/cpp/xml.h>
 
@@ -57 +61 @@
 
 /**
- * Reads the extension pack descriptor.
- *
- * @returns NULL on success, pointer to an error message on failure (caller
- *          deletes it).
- * @param   a_pszDir        The directory containing the description file.
- * @param   a_pExtPackDesc  Where to store the extension pack descriptor.
- * @param   a_pObjInfo      Where to store the object info for the file (unix
- *                          attribs). Optional.
- */
-iprt::MiniString *VBoxExtPackLoadDesc(const char *a_pszDir, PVBOXEXTPACKDESC a_pExtPackDesc, PRTFSOBJINFO a_pObjInfo)
-{
-    /*
-     * Clear the descriptor.
-     */
+ * Clears the extension pack descriptor.
+ *
+ * @param   a_pExtPackDesc  The descriptor to clear.
+ */
+static void vboxExtPackClearDesc(PVBOXEXTPACKDESC a_pExtPackDesc)
+{
     a_pExtPackDesc->strName.setNull();
     a_pExtPackDesc->strDescription.setNull();
@@ -79 +75 @@
     a_pExtPackDesc->cPlugIns = 0;
     a_pExtPackDesc->paPlugIns = NULL;
-
-    /*
-     * Validate, open and parse the XML file.
-     */
-    char szFilePath[RTPATH_MAX];
-    int vrc = RTPathJoin(szFilePath, sizeof(szFilePath), a_pszDir, VBOX_EXTPACK_DESCRIPTION_NAME);
-    if (RT_FAILURE(vrc))
-        return new iprt::MiniString("RTPathJoin failed with %Rrc", vrc);
-
-    RTFSOBJINFO ObjInfo;
-    vrc = RTPathQueryInfoEx(szFilePath, &ObjInfo,  RTFSOBJATTRADD_UNIX, RTPATH_F_ON_LINK);
-    if (RT_FAILURE(vrc))
-        return &(new iprt::MiniString())->printf("RTPathQueryInfoEx failed with %Rrc", vrc);
-    if (a_pObjInfo)
-        *a_pObjInfo = ObjInfo;
-    if (!RTFS_IS_FILE(ObjInfo.Attr.fMode))
-    {
-        if (RTFS_IS_SYMLINK(ObjInfo.Attr.fMode))
-            return new iprt::MiniString("The XML file is symlinked, that is not allowed");
-        return &(new iprt::MiniString)->printf("The XML file is not a file (fMode=%#x)", ObjInfo.Attr.fMode);
-    }
-
-    xml::Document       Doc;
-    xml::XmlFileParser  Parser;
-    try
-    {
-        Parser.read(szFilePath, Doc);
-    }
-    catch (xml::XmlError Err)
-    {
-        return new iprt::MiniString(Err.what());
-    }
-
+}
+
+/**
+ * Load the extension pack descriptor from an XML document.
+ *
+ * @returns NULL on success, pointer to an error message on failure (caller
+ *          deletes it).
+ * @param   a_pDoc              Pointer to the the XML document.
+ * @param   a_pExtPackDesc      Where to store the extension pack descriptor.
+ */
+static iprt::MiniString *vboxExtPackLoadDescFromDoc(xml::Document *a_pDoc, PVBOXEXTPACKDESC a_pExtPackDesc)
+{
     /*
      * Get the main element and check its version.
      */
-    const xml::ElementNode *pVBoxExtPackElm = Doc.getRootElement();
+    const xml::ElementNode *pVBoxExtPackElm = a_pDoc->getRootElement();
     if (   !pVBoxExtPackElm
         || strcmp(pVBoxExtPackElm->getName(), "VirtualBoxExtensionPack") != 0)
@@ -209 +184 @@
 }
 
+/**
+ * Reads the extension pack descriptor.
+ *
+ * @returns NULL on success, pointer to an error message on failure (caller
+ *          deletes it).
+ * @param   a_pszDir        The directory containing the description file.
+ * @param   a_pExtPackDesc  Where to store the extension pack descriptor.
+ * @param   a_pObjInfo      Where to store the object info for the file (unix
+ *                          attribs). Optional.
+ */
+iprt::MiniString *VBoxExtPackLoadDesc(const char *a_pszDir, PVBOXEXTPACKDESC a_pExtPackDesc, PRTFSOBJINFO a_pObjInfo)
+{
+    vboxExtPackClearDesc(a_pExtPackDesc);
+
+    /*
+     * Validate, open and parse the XML file.
+     */
+    char szFilePath[RTPATH_MAX];
+    int vrc = RTPathJoin(szFilePath, sizeof(szFilePath), a_pszDir, VBOX_EXTPACK_DESCRIPTION_NAME);
+    if (RT_FAILURE(vrc))
+        return new iprt::MiniString("RTPathJoin failed with %Rrc", vrc);
+
+    RTFSOBJINFO ObjInfo;
+    vrc = RTPathQueryInfoEx(szFilePath, &ObjInfo,  RTFSOBJATTRADD_UNIX, RTPATH_F_ON_LINK);
+    if (RT_FAILURE(vrc))
+        return &(new iprt::MiniString())->printf("RTPathQueryInfoEx failed with %Rrc", vrc);
+    if (a_pObjInfo)
+        *a_pObjInfo = ObjInfo;
+    if (!RTFS_IS_FILE(ObjInfo.Attr.fMode))
+    {
+        if (RTFS_IS_SYMLINK(ObjInfo.Attr.fMode))
+            return new iprt::MiniString("The XML file is symlinked, that is not allowed");
+        return &(new iprt::MiniString)->printf("The XML file is not a file (fMode=%#x)", ObjInfo.Attr.fMode);
+    }
+
+    xml::Document       Doc;
+    {
+        xml::XmlFileParser  Parser;
+        try
+        {
+            Parser.read(szFilePath, Doc);
+        }
+        catch (xml::XmlError Err)
+        {
+            return new iprt::MiniString(Err.what());
+        }
+    }
+
+    /*
+     * Hand the xml doc over to the common code.
+     */
+    return vboxExtPackLoadDescFromDoc(&Doc, a_pExtPackDesc);
+}
+
+/**
+ * Reads the extension pack descriptor.
+ *
+ * @returns NULL on success, pointer to an error message on failure (caller
+ *          deletes it).
+ * @param   a_pszDir        The directory containing the description file.
+ * @param   a_pExtPackDesc  Where to store the extension pack descriptor.
+ * @param   a_pObjInfo      Where to store the object info for the file (unix
+ *                          attribs). Optional.
+ */
+iprt::MiniString *VBoxExtPackLoadDescFromVfsFile(RTVFSFILE hVfsFile, PVBOXEXTPACKDESC a_pExtPackDesc, PRTFSOBJINFO a_pObjInfo)
+{
+    vboxExtPackClearDesc(a_pExtPackDesc);
+
+    /*
+     * Query the object info.
+     */
+    RTFSOBJINFO ObjInfo;
+    int rc = RTVfsFileQueryInfo(hVfsFile, &ObjInfo, RTFSOBJATTRADD_UNIX);
+    if (RT_FAILURE(rc))
+        return &(new iprt::MiniString)->printf("RTVfsFileQueryInfo failed: %Rrc", rc);
+    if (a_pObjInfo)
+        *a_pObjInfo = ObjInfo;
+
+    /*
+     * The simple approach, read the whole thing into memory and pass this to
+     * the XML parser.
+     */
+
+    /* Check the file size. */
+    if (ObjInfo.cbObject > _1M || ObjInfo.cbObject < 0)
+        return &(new iprt::MiniString)->printf("The XML file is too large (%'RU64 bytes)", ObjInfo.cbObject);
+    size_t const cbFile = (size_t)ObjInfo.cbObject;
+
+    /* Rewind to the start of the file. */
+    rc = RTVfsFileSeek(hVfsFile, 0, RTFILE_SEEK_BEGIN, NULL);
+    if (RT_FAILURE(rc))
+        return &(new iprt::MiniString)->printf("RTVfsFileSeek(,0,BEGIN) failed: %Rrc", rc);
+
+    /* Allocate memory and read the file content into it. */
+    void *pvFile = RTMemTmpAlloc(cbFile);
+    if (!pvFile)
+        return &(new iprt::MiniString)->printf("RTMemTmpAlloc(%zu) failed", cbFile);
+
+    iprt::MiniString *pstrErr = NULL;
+    rc = RTVfsFileRead(hVfsFile, pvFile, cbFile, NULL);
+    if (RT_FAILURE(rc))
+        pstrErr = &(new iprt::MiniString)->printf("RTVfsFileRead failed: %Rrc", rc);
+
+    /*
+     * Parse the file.
+     */
+    xml::Document Doc;
+    if (RT_SUCCESS(rc))
+    {
+        xml::XmlMemParser   Parser;
+        iprt::MiniString    strFileName = VBOX_EXTPACK_DESCRIPTION_NAME;
+        try
+        {
+            Parser.read(pvFile, cbFile, strFileName, Doc);
+        }
+        catch (xml::XmlError Err)
+        {
+            pstrErr = new iprt::MiniString(Err.what());
+            rc = VERR_PARSE_ERROR;
+        }
+    }
+    RTMemTmpFree(pvFile);
+
+    /*
+     * Hand the xml doc over to the common code.
+     */
+    if (RT_SUCCESS(rc))
+        pstrErr = vboxExtPackLoadDescFromDoc(&Doc, a_pExtPackDesc);
+
+    return pstrErr;
+}
 
 /**
@@ -232 +338 @@
 }
 
-
 /**
  * Extract the extension pack name from the tarball path.
@@ -488 +593 @@
 }
 
+/**
+ * RTStrPrintfv wrapper.
+ *
+ * @returns @a rc
+ * @param   rc                  The status code to return.
+ * @param   pszError            The error buffer.
+ * @param   cbError             The size of the buffer.
+ * @param   pszFormat           The error message format string.
+ * @param   ...                 Format arguments.
+ */
+static int vboxExtPackReturnError(int rc, char *pszError, size_t cbError, const char *pszFormat, ...)
+{
+    va_list va;
+    va_start(va, pszFormat);
+    RTStrPrintfV(pszError, cbError, pszFormat, va);
+    va_end(va);
+    return rc;
+}
+
+/**
+ * RTStrPrintfv wrapper.
+ *
+ * @param   pszError            The error buffer.
+ * @param   cbError             The size of the buffer.
+ * @param   pszFormat           The error message format string.
+ * @param   ...                 Format arguments.
+ */
+static void vboxExtPackSetError(char *pszError, size_t cbError, const char *pszFormat, ...)
+{
+    va_list va;
+    va_start(va, pszFormat);
+    RTStrPrintfV(pszError, cbError, pszFormat, va);
+    va_end(va);
+}
+
+/**
+ * Verifies the manifest and its signature.
+ *
+ * @returns VBox status code, failures with message.
+ * @param   hManifestFile       The xml from the extension pack.
+ * @param   pszExtPackName      The expected extension pack name.  This can be
+ *                              NULL, in which we don't have any expectations.
+ * @param   pszError            Where to store an error message on failure.
+ * @param   cbError             The size of the buffer @a pszError points to.
+ */
+static int vboxExtPackVerifyXml(RTVFSFILE hXmlFile, const char *pszExtPackName, char *pszError, size_t cbError)
+{
+    /*
+     * Load the XML.
+     */
+    VBOXEXTPACKDESC     ExtPackDesc;
+    iprt::MiniString   *pstrErr = VBoxExtPackLoadDescFromVfsFile(hXmlFile, &ExtPackDesc, NULL);
+    if (pstrErr)
+    {
+        RTStrCopy(pszError, cbError, pstrErr->c_str());
+        delete pstrErr;
+        return VERR_PARSE_ERROR;
+    }
+
+    /*
+     * Check the name.
+     */
+    /** @todo drop this restriction after the old install interface is
+     *        dropped. */
+    int rc = VINF_SUCCESS;
+    if (   pszExtPackName
+        && !ExtPackDesc.strName.equalsIgnoreCase(pszExtPackName))
+        rc = vboxExtPackReturnError(VERR_NOT_EQUAL, pszError, cbError,
+                                    "The name of the downloaded file and the name stored inside the extension pack does not match"
+                                    " (xml='%s' file='%s')", ExtPackDesc.strName.c_str(), pszExtPackName);
+    return rc;
+}
+
+/**
+ * Verifies the manifest and its signature.
+ *
+ * @returns VBox status code, failures with message.
+ * @param   hOurManifest    The manifest we compiled.
+ * @param   hManifestFile   The manifest file in the extension pack.
+ * @param   hSignatureFile  The manifest signature file.
+ * @param   pszError            Where to store an error message on failure.
+ * @param   cbError             The size of the buffer @a pszError points to.
+ */
+static int vboxExtPackVerifyManifestAndSignature(RTMANIFEST hOurManifest, RTVFSFILE hManifestFile, RTVFSFILE hSignatureFile,
+                                                 char *pszError, size_t cbError)
+{
+    /*
+     * Read the manifest from the extension pack.
+     */
+    int rc = RTVfsFileSeek(hManifestFile, 0, RTFILE_SEEK_BEGIN, NULL);
+    if (RT_FAILURE(rc))
+        return vboxExtPackReturnError(rc, pszError, cbError, "RTVfsFileSeek failed: %Rrc", rc);
+
+    RTMANIFEST hTheirManifest;
+    rc = RTManifestCreate(0 /*fFlags*/, &hTheirManifest);
+    if (RT_FAILURE(rc))
+        return vboxExtPackReturnError(rc, pszError, cbError, "RTManifestCreate failed: %Rrc", rc);
+
+    RTVFSIOSTREAM hVfsIos = RTVfsFileToIoStream(hManifestFile);
+    rc = RTManifestReadStandard(hTheirManifest, hVfsIos);
+    RTVfsIoStrmRelease(hVfsIos);
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Compare the manifests.
+         */
+        static const char *s_apszIgnoreEntries[] =
+        {
+            VBOX_EXTPACK_MANIFEST_NAME,
+            VBOX_EXTPACK_SIGNATURE_NAME,
+            "./" VBOX_EXTPACK_MANIFEST_NAME,
+            "./" VBOX_EXTPACK_SIGNATURE_NAME,
+            NULL
+        };
+        char szError[RTPATH_MAX];
+        rc = RTManifestEqualsEx(hOurManifest, hTheirManifest, &s_apszIgnoreEntries[0], NULL,
+                                RTMANIFEST_EQUALS_IGN_MISSING_ATTRS /*fFlags*/,
+                                szError, sizeof(szError));
+        if (RT_SUCCESS(rc))
+        {
+            /*
+             * Validate the manifest file signature.
+             */
+            /** @todo implement signature stuff */
+            NOREF(hSignatureFile);
+
+        }
+        else if (rc == VERR_NOT_EQUAL && szError[0])
+            vboxExtPackSetError(pszError, cbError, "Manifest mismatch: %s", szError);
+        else
+            vboxExtPackSetError(pszError, cbError, "RTManifestEqualsEx failed: %Rrc", rc);
+#if 0
+        RTVFSIOSTREAM hVfsIosStdOut = NIL_RTVFSIOSTREAM;
+        RTVfsIoStrmFromStdHandle(RTHANDLESTD_OUTPUT, RTFILE_O_WRITE, true, &hVfsIosStdOut);
+        RTVfsIoStrmWrite(hVfsIosStdOut, "Our:\n", sizeof("Our:\n") - 1, true, NULL);
+        RTManifestWriteStandard(hOurManifest, hVfsIosStdOut);
+        RTVfsIoStrmWrite(hVfsIosStdOut, "Their:\n", sizeof("Their:\n") - 1, true, NULL);
+        RTManifestWriteStandard(hTheirManifest, hVfsIosStdOut);
+#endif
+    }
+    else
+        vboxExtPackSetError(pszError, cbError, "Error parsing '%s': %Rrc", VBOX_EXTPACK_MANIFEST_NAME, rc);
+
+    RTManifestRelease(hTheirManifest);
+    return rc;
+}
+
+
+/**
+ * Validates a name in an extension pack.
+ *
+ * We restrict the charset to try make sure the extension pack can be unpacked
+ * on all file systems.
+ *
+ * @returns VBox status code, failures with message.
+ * @param   pszName             The name to validate.
+ * @param   pszError            Where to store an error message on failure.
+ * @param   cbError             The size of the buffer @a pszError points to.
+ */
+static int vboxExtPackValidateMemberName(const char *pszName, char *pszError, size_t cbError)
+{
+    if (RTPathStartsWithRoot(pszName))
+        return vboxExtPackReturnError(VERR_PATH_IS_NOT_RELATIVE, pszError, cbError, "'%s': starts with root spec", pszName);
+
+    const char *pszErr = NULL;
+    const char *psz = pszName;
+    int ch;
+    while ((ch = *psz) != '\0')
+    {
+        /* Character set restrictions. */
+        if (ch < 0 || ch >= 128)
+        {
+            pszErr = "Only 7-bit ASCII allowed";
+            break;
+        }
+        if (ch <= 31 || ch == 127)
+        {
+            pszErr = "No control characters are not allowed";
+            break;
+        }
+        if (ch == '\\')
+        {
+            pszErr = "Only backward slashes are not allowed";
+            break;
+        }
+        if (strchr("'\":;*?|[]<>(){}", ch))
+        {
+            pszErr = "The characters ', \", :, ;, *, ?, |, [, ], <, >, (, ), { and } are not allowed";
+            break;
+        }
+
+        /* Take the simple way out and ban all ".." sequences. */
+        if (   ch     == '.'
+            && psz[1] == '.')
+        {
+            pszErr = "Double dot sequence are not allowed";
+            break;
+        }
+
+        /* Keep the tree shallow or the hardening checks will fail. */
+        if (psz - pszName > VBOX_EXTPACK_MAX_MEMBER_NAME_LENGTH)
+        {
+            pszErr = "Too long";
+            break;
+        }
+
+        /* advance */
+        psz++;
+    }
+
+    if (pszErr)
+        return vboxExtPackReturnError(VERR_INVALID_NAME, pszError, cbError,
+                                      "Bad member name '%s' (pos %zu): %s", pszName, (size_t)(psz - pszName), pszErr);
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Validates a file in an extension pack.
+ *
+ * @returns VBox status code, failures with message.
+ * @param   pszName             The name of the file.
+ * @param   hVfsObj             The VFS object.
+ * @param   pszError            Where to store an error message on failure.
+ * @param   cbError             The size of the buffer @a pszError points to.
+ */
+static int vboxExtPackValidateMemberFile(const char *pszName, RTVFSOBJ hVfsObj, char *pszError, size_t cbError)
+{
+    int rc = vboxExtPackValidateMemberName(pszName, pszError, cbError);
+    if (RT_SUCCESS(rc))
+    {
+        RTFSOBJINFO ObjInfo;
+        rc = RTVfsObjQueryInfo(hVfsObj, &ObjInfo, RTFSOBJATTRADD_NOTHING);
+        if (RT_SUCCESS(rc))
+        {
+            if (ObjInfo.cbObject >= 9*_1G64)
+                rc = vboxExtPackReturnError(VERR_OUT_OF_RANGE, pszError, cbError,
+                                            "'%s': too large (%'RU64 bytes)",
+                                            pszName, (uint64_t)ObjInfo.cbObject);
+            if (!RTFS_IS_FILE(ObjInfo.Attr.fMode))
+                rc = vboxExtPackReturnError(VERR_NOT_A_FILE, pszError, cbError,
+                                            "The alleged file '%s' has a mode mask stating otherwise (%RTfmode)",
+                                            pszName, ObjInfo.Attr.fMode);
+        }
+        else
+            vboxExtPackSetError(pszError, cbError, "RTVfsObjQueryInfo failed on '%s': %Rrc", pszName, rc);
+    }
+    return rc;
+}
+
+
+/**
+ * Validates a directory in an extension pack.
+ *
+ * @returns VBox status code, failures with message.
+ * @param   pszName             The name of the directory.
+ * @param   hVfsObj             The VFS object.
+ * @param   pszError            Where to store an error message on failure.
+ * @param   cbError             The size of the buffer @a pszError points to.
+ */
+static int vboxExtPackValidateMemberDir(const char *pszName, RTVFSOBJ hVfsObj, char *pszError, size_t cbError)
+{
+    int rc = vboxExtPackValidateMemberName(pszName, pszError, cbError);
+    if (RT_SUCCESS(rc))
+    {
+        RTFSOBJINFO ObjInfo;
+        rc = RTVfsObjQueryInfo(hVfsObj, &ObjInfo, RTFSOBJATTRADD_NOTHING);
+        if (RT_SUCCESS(rc))
+        {
+            if (!RTFS_IS_DIRECTORY(ObjInfo.Attr.fMode))
+                rc = vboxExtPackReturnError(VERR_NOT_A_DIRECTORY, pszError, cbError,
+                                            "The alleged directory '%s' has a mode mask saying differently (%RTfmode)",
+                                            pszName, ObjInfo.Attr.fMode);
+        }
+        else
+            vboxExtPackSetError(pszError, cbError, "RTVfsObjQueryInfo failed on '%s': %Rrc", pszName, rc);
+    }
+    return rc;
+}
+
+/**
+ * Validates a member of an extension pack.
+ *
+ * @returns VBox status code, failures with message.
+ * @param   pszName             The name of the directory.
+ * @param   enmType             The object type.
+ * @param   hVfsObj             The VFS object.
+ * @param   pszError            Where to store an error message on failure.
+ * @param   cbError             The size of the buffer @a pszError points to.
+ */
+int VBoxExtPackValidateMember(const char *pszName, RTVFSOBJTYPE enmType, RTVFSOBJ hVfsObj, char *pszError, size_t cbError)
+{
+    Assert(cbError > 0);
+    *pszError = '\0';
+
+    int rc;
+    if (   enmType == RTVFSOBJTYPE_FILE
+        || enmType == RTVFSOBJTYPE_IO_STREAM)
+        rc = vboxExtPackValidateMemberFile(pszName, hVfsObj, pszError, cbError);
+    else if (   enmType == RTVFSOBJTYPE_DIR
+             || enmType == RTVFSOBJTYPE_BASE)
+        rc = vboxExtPackValidateMemberDir(pszName, hVfsObj, pszError, cbError);
+    else
+        rc = vboxExtPackReturnError(VERR_UNEXPECTED_FS_OBJ_TYPE, pszError, cbError,
+                                    "'%s' is not a file or directory (enmType=%d)", pszName, enmType);
+    return rc;
+}
+
+
+/**
+ * Rewinds the tarball file handle and creates a gunzip | tar chain that
+ * results in a filesystem stream.
+ *
+ * @returns VBox status code, failures with message.
+ * @param   hTarballFile        The handle to the tarball file.
+ * @param   pszError            Where to store an error message on failure.
+ * @param   cbError             The size of the buffer @a pszError points to.
+ * @param   phTarFss            Where to return the filesystem stream handle.
+ */
+int VBoxExtPackOpenTarFss(RTFILE hTarballFile, char *pszError, size_t cbError, PRTVFSFSSTREAM phTarFss)
+{
+    Assert(cbError > 0);
+    *pszError = '\0';
+    *phTarFss = NIL_RTVFSFSSTREAM;
+
+    /*
+     * Rewind the file and set up a VFS chain for it.
+     */
+    int rc = RTFileSeek(hTarballFile, 0, RTFILE_SEEK_BEGIN, NULL);
+    if (RT_FAILURE(rc))
+        return vboxExtPackReturnError(rc, pszError, cbError, "Failed seeking to the start of the tarball: %Rrc", rc);
+
+    RTVFSIOSTREAM hTarballIos;
+    rc = RTVfsIoStrmFromRTFile(hTarballFile, RTFILE_O_READ | RTFILE_O_DENY_WRITE | RTFILE_O_OPEN, true /*fLeaveOpen*/,
+                               &hTarballIos);
+    if (RT_FAILURE(rc))
+        return vboxExtPackReturnError(rc, pszError, cbError, "RTVfsIoStrmFromRTFile failed: %Rrc", rc);
+
+    RTVFSIOSTREAM hGunzipIos;
+    rc = RTZipGzipDecompressIoStream(hTarballIos, 0 /*fFlags*/, &hGunzipIos);
+    if (RT_SUCCESS(rc))
+    {
+        RTVFSFSSTREAM hTarFss;
+        rc = RTZipTarFsStreamFromIoStream(hGunzipIos, 0 /*fFlags*/, &hTarFss);
+        if (RT_SUCCESS(rc))
+        {
+            RTVfsIoStrmRelease(hGunzipIos);
+            RTVfsIoStrmRelease(hTarballIos);
+            *phTarFss = hTarFss;
+            return VINF_SUCCESS;
+        }
+        vboxExtPackSetError(pszError, cbError, "RTZipTarFsStreamFromIoStream failed: %Rrc", rc);
+        RTVfsIoStrmRelease(hGunzipIos);
+    }
+    else
+        vboxExtPackSetError(pszError, cbError, "RTZipGzipDecompressIoStream failed: %Rrc", rc);
+    RTVfsIoStrmRelease(hTarballIos);
+    return rc;
+}
+
+
+/**
+ * Validates the extension pack tarball prior to unpacking.
+ *
+ * Operations performed:
+ *      - Mandatory files.
+ *      - Manifest check.
+ *      - Manifest seal check.
+ *      - XML check, match name.
+ *
+ * @returns VBox status code, failures with message.
+ * @param   hTarballFile        The handle to open the @a pszTarball file.
+ * @param   pszExtPackName      The name of the extension pack name.  NULL if
+ *                              the name is not fixed.
+ * @param   pszTarball          The name of the tarball in case we have to
+ *                              complain about something.
+ * @param   pszError            Where to store an error message on failure.
+ * @param   cbError             The size of the buffer @a pszError points to.
+ * @param   phValidManifest     Where to optionally return the handle to fully
+ *                              validated the manifest for the extension pack.
+ *                              This includes all files.
+ * @param   phXmlFile           Where to optionally return the memorized XML
+ *                              file.
+ *
+ * @todo    This function is a bit too long and should be split up if possible.
+ */
+int VBoxExtPackValidateTarball(RTFILE hTarballFile, const char *pszExtPackName, const char *pszTarball,
+                               char *pszError, size_t cbError, PRTMANIFEST phValidManifest, PRTVFSFILE phXmlFile)
+{
+    /*
+     * Clear return values.
+     */
+    if (phValidManifest)
+        *phValidManifest = NIL_RTMANIFEST;
+    if (phXmlFile)
+        *phXmlFile = NIL_RTVFSFILE;
+    Assert(cbError > 1);
+    *pszError = '\0';
+    NOREF(pszTarball);
+
+    /*
+     * Open the tar.gz filesystem stream and set up an manifest in-memory file.
+     */
+    RTVFSFSSTREAM hTarFss;
+    int rc = VBoxExtPackOpenTarFss(hTarballFile, pszError, cbError, &hTarFss);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    RTMANIFEST hOurManifest;
+    rc = RTManifestCreate(0 /*fFlags*/, &hOurManifest);
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Process the tarball (would be nice to move this to a function).
+         */
+        RTVFSFILE hXmlFile      = NIL_RTVFSFILE;
+        RTVFSFILE hManifestFile = NIL_RTVFSFILE;
+        RTVFSFILE hSignatureFile= NIL_RTVFSFILE;
+        for (;;)
+        {
+            /*
+             * Get the next stream object.
+             */
+            char           *pszName;
+            RTVFSOBJ        hVfsObj;
+            RTVFSOBJTYPE    enmType;
+            rc = RTVfsFsStrmNext(hTarFss, &pszName, &enmType, &hVfsObj);
+            if (RT_FAILURE(rc))
+            {
+                if (rc != VERR_EOF)
+                    vboxExtPackSetError(pszError, cbError, "RTVfsFsStrmNext failed: %Rrc", rc);
+                else
+                    rc = VINF_SUCCESS;
+                break;
+            }
+            const char     *pszAdjName = pszName[0] == '.' && pszName[1] == '/' ? &pszName[2] : pszName;
+
+            /*
+             * Check the type & name validity.
+             *
+             * N.B. We will always reach the end of the loop before breaking on
+             *      failure - cleanup reasons.
+             */
+            rc = VBoxExtPackValidateMember(pszName, enmType, hVfsObj, pszError, cbError);
+            if (RT_SUCCESS(rc))
+            {
+                /*
+                 * Check if this is one of the standard files.
+                 */
+                PRTVFSFILE phVfsFile;
+                if (!strcmp(pszAdjName, VBOX_EXTPACK_DESCRIPTION_NAME))
+                    phVfsFile = &hXmlFile;
+                else if (!strcmp(pszAdjName, VBOX_EXTPACK_MANIFEST_NAME))
+                    phVfsFile = &hManifestFile;
+                else if (!strcmp(pszAdjName, VBOX_EXTPACK_SIGNATURE_NAME))
+                    phVfsFile = &hSignatureFile;
+                else
+                    phVfsFile = NULL;
+                if (phVfsFile)
+                {
+                    /*
+                     * Make sure it's a file and that it isn't too large.
+                     */
+                    if (*phVfsFile != NIL_RTVFSFILE)
+                        rc = vboxExtPackReturnError(VERR_DUPLICATE, pszError, cbError,
+                                                    "There can only be one '%s'", pszAdjName);
+                    else if (enmType != RTVFSOBJTYPE_IO_STREAM && enmType != RTVFSOBJTYPE_FILE)
+                        rc = vboxExtPackReturnError(VERR_NOT_A_FILE, pszError, cbError,
+                                                    "Standard member '%s' is not a file", pszAdjName);
+                    else
+                    {
+                        RTFSOBJINFO ObjInfo;
+                        rc = RTVfsObjQueryInfo(hVfsObj, &ObjInfo, RTFSOBJATTRADD_NOTHING);
+                        if (RT_SUCCESS(rc))
+                        {
+                            if (!RTFS_IS_FILE(ObjInfo.Attr.fMode))
+                                rc = vboxExtPackReturnError(VERR_NOT_A_FILE, pszError, cbError,
+                                                            "Standard member '%s' is not a file", pszAdjName);
+                            else if (ObjInfo.cbObject >= _1M)
+                                rc = vboxExtPackReturnError(VERR_OUT_OF_RANGE, pszError, cbError,
+                                                            "Standard member '%s' is too large: %'RU64 bytes (max 1 MB)",
+                                                            pszAdjName, (uint64_t)ObjInfo.cbObject);
+                            else
+                            {
+                                /*
+                                 * Make an in memory copy of the stream.
+                                 */
+                                RTVFSIOSTREAM hVfsIos = RTVfsObjToIoStream(hVfsObj);
+                                rc = RTVfsMemorizeIoStreamAsFile(hVfsIos, RTFILE_O_READ, phVfsFile);
+                                if (RT_SUCCESS(rc))
+                                {
+                                    /*
+                                     * To simplify the code below, replace
+                                     * hVfsObj with the memorized file.
+                                     */
+                                    RTVfsObjRelease(hVfsObj);
+                                    hVfsObj = RTVfsObjFromFile(*phVfsFile);
+                                }
+                                else
+                                    vboxExtPackSetError(pszError, cbError, "RTVfsMemorizeIoStreamAsFile failed on '%s': %Rrc", pszName, rc);
+                                RTVfsIoStrmRelease(hVfsIos);
+                            }
+                        }
+                        else
+                            vboxExtPackSetError(pszError, cbError, "RTVfsObjQueryInfo failed on '%s': %Rrc", pszName, rc);
+                    }
+                }
+            }
+
+            /*
+             * Add any I/O stream to the manifest
+             */
+            if (   RT_SUCCESS(rc)
+                && (   enmType == RTVFSOBJTYPE_FILE
+                    || enmType == RTVFSOBJTYPE_IO_STREAM))
+            {
+                RTVFSIOSTREAM hVfsIos = RTVfsObjToIoStream(hVfsObj);
+                rc = RTManifestEntryAddIoStream(hOurManifest, hVfsIos, pszAdjName, RTMANIFEST_ATTR_SIZE | RTMANIFEST_ATTR_SHA256);
+                if (RT_FAILURE(rc))
+                    vboxExtPackSetError(pszError, cbError, "RTManifestEntryAddIoStream failed on '%s': %Rrc", pszAdjName, rc);
+                RTVfsIoStrmRelease(hVfsIos);
+            }
+
+            /*
+             * Clean up and break out on failure.
+             */
+            RTVfsObjRelease(hVfsObj);
+            RTStrFree(pszName);
+            if (RT_FAILURE(rc))
+                break;
+        }
+
+        /*
+         * If we've successfully processed the tarball, verify that the
+         * mandatory files are present.
+         */
+        if (RT_SUCCESS(rc))
+        {
+            if (hXmlFile == NIL_RTVFSFILE)
+                rc = vboxExtPackReturnError(VERR_MISSING, pszError, cbError, "Mandator file '%s' is missing", VBOX_EXTPACK_DESCRIPTION_NAME);
+            if (hManifestFile == NIL_RTVFSFILE)
+                rc = vboxExtPackReturnError(VERR_MISSING, pszError, cbError, "Mandator file '%s' is missing", VBOX_EXTPACK_MANIFEST_NAME);
+            if (hSignatureFile == NIL_RTVFSFILE)
+                rc = vboxExtPackReturnError(VERR_MISSING, pszError, cbError, "Mandator file '%s' is missing", VBOX_EXTPACK_SIGNATURE_NAME);
+        }
+
+        /*
+         * Check the manifest and it's signature.
+         */
+        if (RT_SUCCESS(rc))
+            rc = vboxExtPackVerifyManifestAndSignature(hOurManifest, hManifestFile, hSignatureFile, pszError, cbError);
+
+        /*
+         * Check the XML.
+         */
+        if (RT_SUCCESS(rc))
+            rc = vboxExtPackVerifyXml(hXmlFile, pszExtPackName, pszError, cbError);
+
+        /*
+         * Returns objects.
+         */
+        if (RT_SUCCESS(rc))
+        {
+            if (phValidManifest)
+            {
+                RTManifestRetain(hOurManifest);
+                *phValidManifest = hOurManifest;
+            }
+            if (phXmlFile)
+            {
+                RTVfsFileRetain(hXmlFile);
+                *phXmlFile = hXmlFile;
+            }
+        }
+
+        /*
+         * Release our object references.
+         */
+        RTManifestRelease(hOurManifest);
+        RTVfsFileRelease(hXmlFile);
+        RTVfsFileRelease(hManifestFile);
+        RTVfsFileRelease(hSignatureFile);
+    }
+    else
+        vboxExtPackSetError(pszError, cbError, "RTManifestCreate failed: %Rrc", rc);
+    RTVfsFsStrmRelease(hTarFss);
+
+    return rc;
+}
+

trunk/src/VBox/Main/VBoxExtPackHelperApp.cpp

@@ -78 +78 @@
 #endif
 
-/** The maximum entry name length.
- * Play short and safe. */
-#define VBOX_EXTPACK_MAX_ENTRY_NAME_LENGTH      128
 
 
@@ -202 +199 @@
 
 /**
- * Rewinds the tarball file handle and creates a gunzip | tar chain that
- * results in a filesystem stream.
+ * Wrapper around VBoxExtPackOpenTarFss.
  *
  * @returns success or failure, message displayed on failure.
@@ -211 +207 @@
 static RTEXITCODE OpenTarFss(RTFILE hTarballFile, PRTVFSFSSTREAM phTarFss)
 {
-    /*
-     * Rewind the file and set up a VFS chain for it.
-     */
-    int rc = RTFileSeek(hTarballFile, 0, RTFILE_SEEK_BEGIN, NULL);
-    if (RT_FAILURE(rc))
-        return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed seeking to the start of the tarball: %Rrc\n", rc);
-
-    RTVFSIOSTREAM hTarballIos;
-    rc = RTVfsIoStrmFromRTFile(hTarballFile, RTFILE_O_READ | RTFILE_O_DENY_WRITE | RTFILE_O_OPEN, true /*fLeaveOpen*/,
-                               &hTarballIos);
-    if (RT_FAILURE(rc))
-        return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTVfsIoStrmFromRTFile failed: %Rrc\n", rc);
-
-    RTVFSIOSTREAM hGunzipIos;
-    rc = RTZipGzipDecompressIoStream(hTarballIos, 0 /*fFlags*/, &hGunzipIos);
-    if (RT_SUCCESS(rc))
-    {
-        RTVFSFSSTREAM hTarFss;
-        rc = RTZipTarFsStreamFromIoStream(hGunzipIos, 0 /*fFlags*/, &hTarFss);
-        if (RT_SUCCESS(rc))
-        {
-            RTVfsIoStrmRelease(hGunzipIos);
-            RTVfsIoStrmRelease(hTarballIos);
-            *phTarFss = hTarFss;
-            return RTEXITCODE_SUCCESS;
-        }
-        RTMsgError("RTZipTarFsStreamFromIoStream failed: %Rrc\n", rc);
-        RTVfsIoStrmRelease(hGunzipIos);
-    }
-    else
-        RTMsgError("RTZipGzipDecompressIoStream failed: %Rrc\n", rc);
-    RTVfsIoStrmRelease(hTarballIos);
-    return RTEXITCODE_FAILURE;
+    char szError[8192];
+    int rc = VBoxExtPackOpenTarFss(hTarballFile, szError, sizeof(szError), phTarFss);
+    if (RT_FAILURE(rc))
+    {
+        Assert(szError[0]);
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "%s", szError);
+    }
+    Assert(!szError[0]);
+    return RTEXITCODE_SUCCESS;
 }
 
@@ -273 +245 @@
 
 /**
- * Verifies the manifest and its signature.
- *
- * @returns Program exit code, failure with message.
- * @param   hManifestFile   The xml from the extension pack.
- * @param   pszExtPackName  The expected extension pack name.
- */
-static RTEXITCODE VerifyXml(RTVFSFILE hXmlFile, const char *pszExtPackName)
-{
-    /** @todo implement XML verification. */
-    return RTEXITCODE_SUCCESS;
-}
-
-
-/**
- * Verifies the manifest and its signature.
- *
- * @returns Program exit code, failure with message.
- * @param   hOurManifest    The manifest we compiled.
- * @param   hManifestFile   The manifest file in the extension pack.
- * @param   hSignatureFile  The manifest signature file.
- */
-static RTEXITCODE VerifyManifestAndSignature(RTMANIFEST hOurManifest, RTVFSFILE hManifestFile, RTVFSFILE hSignatureFile)
-{
-    /*
-     * Read the manifest from the extension pack.
-     */
-    int rc = RTVfsFileSeek(hManifestFile, 0, RTFILE_SEEK_BEGIN, NULL);
-    if (RT_FAILURE(rc))
-        return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTVfsFileSeek failed: %Rrc", rc);
-
-    RTMANIFEST hTheirManifest;
-    rc = RTManifestCreate(0 /*fFlags*/, &hTheirManifest);
-    if (RT_FAILURE(rc))
-        return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTManifestCreate failed: %Rrc", rc);
-
-    RTVFSIOSTREAM hVfsIos = RTVfsFileToIoStream(hManifestFile);
-    rc = RTManifestReadStandard(hTheirManifest, hVfsIos);
-    RTVfsIoStrmRelease(hVfsIos);
-    if (RT_SUCCESS(rc))
-    {
-        /*
-         * Compare the manifests.
-         */
-        static const char *s_apszIgnoreEntries[] =
-        {
-            VBOX_EXTPACK_MANIFEST_NAME,
-            VBOX_EXTPACK_SIGNATURE_NAME,
-            "./" VBOX_EXTPACK_MANIFEST_NAME,
-            "./" VBOX_EXTPACK_SIGNATURE_NAME,
-            NULL
-        };
-        char szError[RTPATH_MAX];
-        rc = RTManifestEqualsEx(hOurManifest, hTheirManifest, &s_apszIgnoreEntries[0], NULL,
-                                RTMANIFEST_EQUALS_IGN_MISSING_ATTRS /*fFlags*/,
-                                szError, sizeof(szError));
-        if (RT_SUCCESS(rc))
-        {
-            /*
-             * Validate the manifest file signature.
-             */
-            /** @todo implement signature stuff */
-
-        }
-        else if (rc == VERR_NOT_EQUAL && szError[0])
-            RTMsgError("Manifest mismatch: %s", szError);
-        else
-            RTMsgError("RTManifestEqualsEx failed: %Rrc", rc);
-#if 0
-        RTVFSIOSTREAM hVfsIosStdOut = NIL_RTVFSIOSTREAM;
-        RTVfsIoStrmFromStdHandle(RTHANDLESTD_OUTPUT, RTFILE_O_WRITE, true, &hVfsIosStdOut);
-        RTVfsIoStrmWrite(hVfsIosStdOut, "Our:\n", sizeof("Our:\n") - 1, true, NULL);
-        RTManifestWriteStandard(hOurManifest, hVfsIosStdOut);
-        RTVfsIoStrmWrite(hVfsIosStdOut, "Their:\n", sizeof("Their:\n") - 1, true, NULL);
-        RTManifestWriteStandard(hTheirManifest, hVfsIosStdOut);
-#endif
-    }
-    else
-        RTMsgError("Error parsing '%s': %Rrc", VBOX_EXTPACK_MANIFEST_NAME, rc);
-
-    RTManifestRelease(hTheirManifest);
-    return RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
-}
-
-
-/**
- * Validates a name in an extension pack.
- *
- * We restrict the charset to try make sure the extension pack can be unpacked
- * on all file systems.
- *
- * @returns Program exit code, failure with message.
- * @param   pszName             The name to validate.
- */
-static RTEXITCODE ValidateNameInExtPack(const char *pszName)
-{
-    if (RTPathStartsWithRoot(pszName))
-        return RTMsgErrorExit(RTEXITCODE_FAILURE, "'%s': starts with root spec", pszName);
-
-    const char *pszErr = NULL;
-    const char *psz = pszName;
-    int ch;
-    while ((ch = *psz) != '\0')
-    {
-        /* Character set restrictions. */
-        if (ch < 0 || ch >= 128)
-        {
-            pszErr = "Only 7-bit ASCII allowed";
-            break;
-        }
-        if (ch <= 31 || ch == 127)
-        {
-            pszErr = "No control characters are not allowed";
-            break;
-        }
-        if (ch == '\\')
-        {
-            pszErr = "Only backward slashes are not allowed";
-            break;
-        }
-        if (strchr("'\":;*?|[]<>(){}", ch))
-        {
-            pszErr = "The characters ', \", :, ;, *, ?, |, [, ], <, >, (, ), { and } are not allowed";
-            break;
-        }
-
-        /* Take the simple way out and ban all ".." sequences. */
-        if (   ch     == '.'
-            && psz[1] == '.')
-        {
-            pszErr = "Double dot sequence are not allowed";
-            break;
-        }
-
-        /* Keep the tree shallow or the hardening checks will fail. */
-        if (psz - pszName > VBOX_EXTPACK_MAX_ENTRY_NAME_LENGTH)
-        {
-            pszErr = "Too long";
-            break;
-        }
-
-        /* advance */
-        psz++;
-    }
-
-    if (pszErr)
-        return RTMsgErrorExit(RTEXITCODE_FAILURE, "Bad member name '%s' (pos %zu): %s", pszName, (size_t)(psz - pszName), pszErr);
-    return RTEXITCODE_SUCCESS;
-}
-
-
-/**
- * Validates a file in an extension pack.
- *
- * @returns Program exit code, failure with message.
- * @param   pszName             The name of the file.
- * @param   hVfsObj             The VFS object.
- */
-static RTEXITCODE ValidateFileInExtPack(const char *pszName, RTVFSOBJ hVfsObj)
-{
-    RTEXITCODE rcExit = ValidateNameInExtPack(pszName);
-    if (rcExit == RTEXITCODE_SUCCESS)
-    {
-        RTFSOBJINFO ObjInfo;
-        int rc = RTVfsObjQueryInfo(hVfsObj, &ObjInfo, RTFSOBJATTRADD_NOTHING);
-        if (RT_SUCCESS(rc))
-        {
-            if (ObjInfo.cbObject >= 9*_1G64)
-                rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "'%s': too large (%'RU64 bytes)",
-                                        pszName, (uint64_t)ObjInfo.cbObject);
-            if (!RTFS_IS_FILE(ObjInfo.Attr.fMode))
-                rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE,
-                                        "The alleged file '%s' has a mode mask saying differently (%RTfmode)",
-                                        pszName, ObjInfo.Attr.fMode);
-        }
-        else
-            rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "RTVfsObjQueryInfo failed on '%s': %Rrc", pszName, rc);
-    }
-    return rcExit;
-}
-
-
-/**
- * Validates a directory in an extension pack.
- *
- * @returns Program exit code, failure with message.
- * @param   pszName             The name of the directory.
- * @param   hVfsObj             The VFS object.
- */
-static RTEXITCODE ValidateDirInExtPack(const char *pszName, RTVFSOBJ hVfsObj)
-{
-    RTEXITCODE rcExit = ValidateNameInExtPack(pszName);
-    if (rcExit == RTEXITCODE_SUCCESS)
-    {
-        RTFSOBJINFO ObjInfo;
-        int rc = RTVfsObjQueryInfo(hVfsObj, &ObjInfo, RTFSOBJATTRADD_NOTHING);
-        if (RT_SUCCESS(rc))
-        {
-            if (!RTFS_IS_DIRECTORY(ObjInfo.Attr.fMode))
-                rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE,
-                                        "The alleged directory '%s' has a mode mask saying differently (%RTfmode)",
-                                        pszName, ObjInfo.Attr.fMode);
-        }
-        else
-            rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "RTVfsObjQueryInfo failed on '%s': %Rrc", pszName, rc);
-    }
-    return rcExit;
-}
-
-
-/**
- * Validates a member of an extension pack.
+ * Wrapper around VBoxExtPackValidateMember.
  *
  * @returns Program exit code, failure with message.
@@ -492 +254 @@
 static RTEXITCODE ValidateMemberOfExtPack(const char *pszName, RTVFSOBJTYPE enmType, RTVFSOBJ hVfsObj)
 {
-    RTEXITCODE rcExit;
-    if (   enmType == RTVFSOBJTYPE_FILE
-        || enmType == RTVFSOBJTYPE_IO_STREAM)
-        rcExit = ValidateFileInExtPack(pszName, hVfsObj);
-    else if (   enmType == RTVFSOBJTYPE_DIR
-             || enmType == RTVFSOBJTYPE_BASE)
-        rcExit = ValidateDirInExtPack(pszName, hVfsObj);
-    else
-        rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "'%s' is not a file or directory (enmType=%d)", pszName, enmType);
-    return rcExit;
+    char szError[8192];
+    int rc = VBoxExtPackValidateMember(pszName, enmType, hVfsObj, szError, sizeof(szError));
+    if (RT_FAILURE(rc))
+    {
+        Assert(szError[0]);
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "%s", szError);
+    }
+    Assert(!szError[0]);
+    return RTEXITCODE_SUCCESS;
 }
 
@@ -657 +418 @@
      */
     char szDstPath[RTPATH_MAX];
-    int rc = RTPathAbs(pszDirDst, szDstPath, sizeof(szDstPath) - VBOX_EXTPACK_MAX_ENTRY_NAME_LENGTH - 2);
+    int rc = RTPathAbs(pszDirDst, szDstPath, sizeof(szDstPath) - VBOX_EXTPACK_MAX_MEMBER_NAME_LENGTH - 2);
     if (RT_FAILURE(rc))
         return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPathAbs('%s',,) failed: %Rrc", pszDirDst, rc);
@@ -763 +524 @@
 
 /**
- * Validates the extension pack tarball prior to unpacking.
- *
- * Operations performed:
- *      - Mandatory files.
- *      - Manifest check.
- *      - Manifest seal check.
- *      - XML check, match name.
+ * Wrapper around VBoxExtPackValidateTarball.
  *
  * @returns The program exit code.
@@ -779 +534 @@
  *                              the manifest for the extension pack.  This
  *                              includes all files.
- *
- * @todo    This function is a bit too long and should be split up if possible.
  */
 static RTEXITCODE ValidateExtPackTarball(RTFILE hTarballFile, const char *pszExtPackName, const char *pszTarball,
@@ -788 +541 @@
     RTMsgInfo("Validating extension pack '%s' ('%s')...", pszTarball, pszExtPackName);
 
-    /*
-     * Open the tar.gz filesystem stream and set up an manifest in-memory file.
-     */
-    RTVFSFSSTREAM hTarFss;
-    RTEXITCODE rcExit = OpenTarFss(hTarballFile, &hTarFss);
-    if (rcExit != RTEXITCODE_SUCCESS)
-        return rcExit;
-
-    RTMANIFEST hOurManifest;
-    int rc = RTManifestCreate(0 /*fFlags*/, &hOurManifest);
-    if (RT_SUCCESS(rc))
-    {
-        /*
-         * Process the tarball (would be nice to move this to a function).
-         */
-        RTVFSFILE hXmlFile      = NIL_RTVFSFILE;
-        RTVFSFILE hManifestFile = NIL_RTVFSFILE;
-        RTVFSFILE hSignatureFile= NIL_RTVFSFILE;
-        for (;;)
-        {
-            /*
-             * Get the next stream object.
-             */
-            char           *pszName;
-            RTVFSOBJ        hVfsObj;
-            RTVFSOBJTYPE    enmType;
-            rc = RTVfsFsStrmNext(hTarFss, &pszName, &enmType, &hVfsObj);
-            if (RT_FAILURE(rc))
-            {
-                if (rc != VERR_EOF)
-                    rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "RTVfsFsStrmNext failed: %Rrc", rc);
-                break;
-            }
-            const char     *pszAdjName = pszName[0] == '.' && pszName[1] == '/' ? &pszName[2] : pszName;
-
-            /*
-             * Check the type & name validity.
-             */
-            rcExit = ValidateMemberOfExtPack(pszName, enmType, hVfsObj);
-            if (rcExit == RTEXITCODE_SUCCESS)
-            {
-                /*
-                 * Check if this is one of the standard files.
-                 */
-                PRTVFSFILE  phVfsFile;
-                if (!strcmp(pszAdjName, VBOX_EXTPACK_DESCRIPTION_NAME))
-                    phVfsFile = &hXmlFile;
-                else if (!strcmp(pszAdjName, VBOX_EXTPACK_MANIFEST_NAME))
-                    phVfsFile = &hManifestFile;
-                else if (!strcmp(pszAdjName, VBOX_EXTPACK_SIGNATURE_NAME))
-                    phVfsFile = &hSignatureFile;
-                else
-                    phVfsFile = NULL;
-                if (phVfsFile)
-                {
-                    /*
-                     * Make sure it's a file and that it isn't too large.
-                     */
-                    if (*phVfsFile != NIL_RTVFSFILE)
-                        rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "There can only be one '%s'", pszAdjName);
-                    else if (enmType != RTVFSOBJTYPE_IO_STREAM && enmType != RTVFSOBJTYPE_FILE)
-                        rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Standard member '%s' is not a file", pszAdjName);
-                    else
-                    {
-                        RTFSOBJINFO ObjInfo;
-                        rc = RTVfsObjQueryInfo(hVfsObj, &ObjInfo, RTFSOBJATTRADD_NOTHING);
-                        if (RT_SUCCESS(rc))
-                        {
-                            if (!RTFS_IS_FILE(ObjInfo.Attr.fMode))
-                                rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Standard member '%s' is not a file", pszAdjName);
-                            else if (ObjInfo.cbObject >= _1M)
-                                rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE,
-                                                        "Standard member '%s' is too large: %'RU64 bytes (max 1 MB)",
-                                                        pszAdjName, (uint64_t)ObjInfo.cbObject);
-                            else
-                            {
-                                /*
-                                 * Make an in memory copy of the stream.
-                                 */
-                                RTVFSIOSTREAM hVfsIos = RTVfsObjToIoStream(hVfsObj);
-                                rc = RTVfsMemorizeIoStreamAsFile(hVfsIos, RTFILE_O_READ, phVfsFile);
-                                if (RT_SUCCESS(rc))
-                                {
-                                    /*
-                                     * To simplify the code below, replace
-                                     * hVfsObj with the memorized file.
-                                     */
-                                    RTVfsObjRelease(hVfsObj);
-                                    hVfsObj = RTVfsObjFromFile(*phVfsFile);
-                                }
-                                else
-                                    rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE,
-                                                            "RTVfsMemorizeIoStreamAsFile failed on '%s': %Rrc", pszName, rc);
-                                RTVfsIoStrmRelease(hVfsIos);
-                            }
-                        }
-                        else
-                            rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "RTVfsObjQueryInfo failed on '%s': %Rrc", pszName, rc);
-                    }
-                }
-            }
-
-            /*
-             * Add any I/O stream to the manifest
-             */
-            if (   rcExit == RTEXITCODE_SUCCESS
-                && (   enmType == RTVFSOBJTYPE_FILE
-                    || enmType == RTVFSOBJTYPE_IO_STREAM))
-            {
-                RTVFSIOSTREAM hVfsIos = RTVfsObjToIoStream(hVfsObj);
-                rc = RTManifestEntryAddIoStream(hOurManifest, hVfsIos, pszAdjName, RTMANIFEST_ATTR_SIZE | RTMANIFEST_ATTR_SHA256);
-                if (RT_FAILURE(rc))
-                    rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "RTManifestEntryAddIoStream failed on '%s': %Rrc", pszAdjName, rc);
-                RTVfsIoStrmRelease(hVfsIos);
-            }
-
-            /*
-             * Clean up and break out on failure.
-             */
-            RTVfsObjRelease(hVfsObj);
-            RTStrFree(pszName);
-            if (rcExit != RTEXITCODE_SUCCESS)
-                break;
-        }
-
-        /*
-         * If we've successfully processed the tarball, verify that the
-         * mandatory files are present.
-         */
-        if (rcExit == RTEXITCODE_SUCCESS)
-        {
-            if (hXmlFile == NIL_RTVFSFILE)
-                rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Mandator file '%s' is missing", VBOX_EXTPACK_DESCRIPTION_NAME);
-            if (hManifestFile == NIL_RTVFSFILE)
-                rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Mandator file '%s' is missing", VBOX_EXTPACK_MANIFEST_NAME);
-            if (hSignatureFile == NIL_RTVFSFILE)
-                rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Mandator file '%s' is missing", VBOX_EXTPACK_SIGNATURE_NAME);
-        }
-
-        /*
-         * Check the manifest and it's signature.
-         */
-        if (rcExit == RTEXITCODE_SUCCESS)
-            rcExit = VerifyManifestAndSignature(hOurManifest, hManifestFile, hSignatureFile);
-
-        /*
-         * Check the XML.
-         */
-        if (rcExit == RTEXITCODE_SUCCESS)
-            rcExit = VerifyXml(hXmlFile, pszExtPackName);
-
-        /*
-         * Release objects and stuff.
-         */
-        if (rcExit == RTEXITCODE_SUCCESS)
-            *phValidManifest = hOurManifest;
-        else
-            RTManifestRelease(hOurManifest);
-
-        RTVfsFileRelease(hXmlFile);
-        RTVfsFileRelease(hManifestFile);
-        RTVfsFileRelease(hSignatureFile);
-    }
-    RTVfsFsStrmRelease(hTarFss);
-
-    return rcExit;
+    char szError[8192];
+    int rc = VBoxExtPackValidateTarball(hTarballFile, pszExtPackName, pszTarball,
+                                        szError, sizeof(szError), phValidManifest, NULL /*phXmlFile*/);
+    if (RT_FAILURE(rc))
+    {
+        Assert(szError[0]);
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "%s", szError);
+    }
+    Assert(!szError[0]);
+    return RTEXITCODE_SUCCESS;
 }
 

trunk/src/VBox/Main/idl/VirtualBox.xidl

@@ -14432 +14432 @@
   <interface
     name="IExtPackManager" extends="$unknown"
-    uuid="8104df65-74d6-4e33-b374-50aa062b4afd"
+    uuid="70d808a9-176f-4d45-adad-7c509b8309b3"
     wsmap="suppress"
     >
@@ -14474 +14474 @@
       <param name="file" type="IExtPackFile" dir="return">
         <desc>The interface of the extension pack file object.</desc>
-      </param>
-    </method>
-
-    <method name="install">
-      <desc>
-        Please use openExtPackFile + IExtPackFile::install instead of this
-        interface.   This will be removed later in the beta cycle.
-      </desc>
-      <param name="path" type="wstring" dir="in">
-        <desc>The path of the extension pack tarball.</desc>
-      </param>
-      <param name="name" type="wstring" dir="return">
-        <desc>The name of the installed extension pack.</desc>
       </param>
     </method>

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

@@ -46 +46 @@
     HRESULT     FinalConstruct();
     void        FinalRelease();
-    HRESULT     initWithFile(const char *a_pszFile);
+    HRESULT     initWithFile(const char *a_pszFile, class ExtPackManager *a_pExtPackMgr);
     void        uninit();
+    RTMEMEF_NEW_AND_DELETE_OPERATORS();
     /** @}  */
 
@@ -67 +68 @@
     STDMETHOD(Install)(void);
     /** @}  */
+
+private:
+    /** @name Misc init helpers
+     * @{ */
+    HRESULT     initFailed(const char *a_pszWhyFmt, ...);
+    /** @} */
 
 private:
@@ -102 +109 @@
     HRESULT     initWithDir(VBOXEXTPACKCTX a_enmContext, const char *a_pszName, const char *a_pszDir);
     void        uninit();
+    RTMEMEF_NEW_AND_DELETE_OPERATORS();
     /** @}  */
 
@@ -188 +196 @@
                      VBOXEXTPACKCTX a_enmContext);
     void        uninit();
+    RTMEMEF_NEW_AND_DELETE_OPERATORS();
     /** @}  */
 
@@ -195 +204 @@
     STDMETHOD(Find)(IN_BSTR a_bstrName, IExtPack **a_pExtPack);
     STDMETHOD(OpenExtPackFile)(IN_BSTR a_bstrTarball, IExtPackFile **a_ppExtPackFile);
-    STDMETHOD(Install)(IN_BSTR a_bstrTarball, BSTR *a_pbstrName);
     STDMETHOD(Uninstall)(IN_BSTR a_bstrName, BOOL a_fForcedRemoval);
     STDMETHOD(Cleanup)(void);
@@ -203 +211 @@
     /** @name Internal interfaces used by other Main classes.
      * @{ */
-    void        processDropZone(void);
+    HRESULT     doInstall(ExtPackFile *a_pExtPackFile);
+    /*void        processDropZone(void);*/
     void        callAllVirtualBoxReadyHooks(void);
     void        callAllConsoleReadyHooks(IConsole *a_pConsole);

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

@@ -21 +21 @@
 #include <iprt/cpp/ministring.h>
 #include <iprt/fs.h>
+#include <iprt/vfs.h>
 
 
@@ -47 +48 @@
  * certificates are installed.  Relative to RTPathAppPrivateNoArch. */
 #define VBOX_EXTPACK_CERT_DIR           "ExtPackCertificates"
+
+/** The maximum entry name length.
+ * Play short and safe. */
+#define VBOX_EXTPACK_MAX_MEMBER_NAME_LENGTH 128
 
 
@@ -98 +103 @@
 
 iprt::MiniString   *VBoxExtPackLoadDesc(const char *a_pszDir, PVBOXEXTPACKDESC a_pExtPackDesc, PRTFSOBJINFO a_pObjInfo);
+iprt::MiniString   *VBoxExtPackLoadDescFromVfsFile(RTVFSFILE hVfsFile, PVBOXEXTPACKDESC a_pExtPackDesc, PRTFSOBJINFO a_pObjInfo);
 iprt::MiniString   *VBoxExtPackExtractNameFromTarballPath(const char *pszTarball);
 void                VBoxExtPackFreeDesc(PVBOXEXTPACKDESC a_pExtPackDesc);
@@ -108 +114 @@
 bool                VBoxExtPackIsValidModuleString(const char *pszModule);
 
+int                 VBoxExtPackValidateMember(const char *pszName, RTVFSOBJTYPE enmType, RTVFSOBJ hVfsObj, char *pszError, size_t cbError);
+int                 VBoxExtPackOpenTarFss(RTFILE hTarballFile, char *pszError, size_t cbError, PRTVFSFSSTREAM phTarFss);
+int                 VBoxExtPackValidateTarball(RTFILE hTarballFile, const char *pszExtPackName, const char *pszTarball,
+                                               char *pszError, size_t cbError, PRTMANIFEST phValidManifest, PRTVFSFILE phXmlFile);
+
 
 #endif