Changeset 33521 in vbox for trunk

Timestamp:

Oct 27, 2010 3:20:21 PM (14 years ago)

Author:

vboxsync

Message:

ExtPack: More code.

Location:

trunk/src/VBox/Main

Files:

• ExtPackManagerImpl.cpp (modified) (5 diffs)
• include/ExtPackManagerImpl.h (modified) (2 diffs)

trunk/src/VBox/Main/ExtPackManagerImpl.cpp

@@ -22 +22 @@
 #include "ExtPackManagerImpl.h"
 
+#include <iprt/ctype.h>
 #include <iprt/dir.h>
+#include <iprt/env.h>
 #include <iprt/file.h>
 #include <iprt/ldr.h>
 #include <iprt/param.h>
 #include <iprt/path.h>
+#include <iprt/pipe.h>
+#include <iprt/process.h>
+#include <iprt/string.h>
 
 #include <VBox/com/array.h>
+#include <VBox/com/ErrorInfo.h>
 #include <VBox/log.h>
 #include "AutoCaller.h"
+
+
+/*******************************************************************************
+*   Defined Constants And Macros                                               *
+*******************************************************************************/
+/** @name VBOX_EXTPACK_HELPER_NAME
+ * The name of the utility program we employ to install and uninstall the
+ * extension packs.  This is a set-uid-to-root binary on unixy platforms, which
+ * is why it has to be a separate program.
+ */
+#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
+# define VBOX_EXTPACK_HELPER_NAME   "VBoxExtPackHelper.exe"
+#else
+# define VBOX_EXTPACK_HELPER_NAME   "VBoxExtPackHelper"
+#endif
 
 
@@ -220 +241 @@
 }
 
+/**
+ * Refreshes the extension pack state.
+ *
+ * This is called by the manager so that the on disk changes are picked up.
+ *
+ * @returns S_OK or COM error status with error information.
+ * @param   pfCanDelete     Optional can-delete-this-object output indicator.
+ */
+HRESULT ExtPack::refresh(bool *pfCanDelete)
+{
+    if (pfCanDelete)
+        *pfCanDelete = false;
+    return S_OK;
+}
+
 
 
@@ -358 +394 @@
         AutoReadLock autoLock(this COMMA_LOCKVAL_SRC_POS);
 
-        hrc = VBOX_E_OBJECT_NOT_FOUND;
-        for (ExtPackList::iterator it = m->llInstalledExtPacks.begin();
-             it != m->llInstalledExtPacks.end();
-             it++)
-        {
-            ExtPack::Data *pExtPackData = (*it)->m;
-            if (   pExtPackData
-                && pExtPackData->strName.compare(strName) == 0)
-            {
-                (*it).queryInterfaceTo(a_pExtPack);
-                hrc = S_OK;
-                break;
-            }
-        }
+        ComPtr<ExtPack> ptrExtPack = findExtPack(strName.c_str());
+        if (!ptrExtPack.isNull())
+            ptrExtPack.queryInterfaceTo(a_pExtPack);
+        else
+            hrc = VBOX_E_OBJECT_NOT_FOUND;
     }
 
@@ -383 +410 @@
     Utf8Str strTarball(a_bstrTarball);
 
+    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);
+            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.
+                     *
+                     * RESTRICTION: The name can only contain english alphabet
+                     *              charactes, decimal digits and space.
+                     *              Impose a max length of 64 chars.
+                     */
+                    char *pszName = RTStrDup(RTPathFilename(strTarball.c_str()));
+                    if (pszName)
+                    {
+                        char *pszEnd = pszName;
+                        while (RT_C_IS_ALNUM(*pszEnd) || *pszEnd == ' ')
+                            pszEnd++;
+                        if (   pszEnd == pszName
+                            || pszEnd - pszName <= 64)
+                        {
+                            *pszEnd = '\0';
+
+                            /*
+                             * 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(pszName, 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",
+                                                            "--basepath",   m->strBasePath.c_str(),
+                                                            "--name",       pszName,
+                                                            "--tarball",    strTarball.c_str(),
+                                                            "--tarball-fd", &szTarballFd[0],
+                                                            NULL);
+                                if (SUCCEEDED(hrc))
+                                {
+                                    hrc = refreshExtPack(pszName, true /*a_fUnsuableIsError*/, &pExtPack);
+                                    if (SUCCEEDED(hrc))
+                                        LogRel(("ExtPackManager: Successfully installed extension pack '%s'.\n", pszName));
+                                }
+                                else
+                                {
+                                    ErrorInfoKeeper Eik;
+                                    refreshExtPack(pszName, 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"),
+                                               pszName);
+                        }
+                        else
+                            hrc = setError(E_FAIL, tr("Malformed '%s' file name"), strTarball.c_str());
+                    }
+                    else
+                        hrc = E_OUTOFMEMORY;
+                }
+                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());
+    }
+
+    return hrc;
+}
+
+STDMETHODIMP ExtPackManager::Uninstall(IN_BSTR a_bstrName, BOOL a_fForcedRemoval)
+{
+    CheckComArgNotNull(a_bstrName);
+    Utf8Str strName(a_bstrName);
+
+    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(strName.c_str(), false /*a_fUnsuableIsError*/, &pExtPack);
+        if (SUCCEEDED(hrc))
+        {
+            if (!pExtPack)
+            {
+                LogRel(("ExtPackManager: Extension pack '%s' is not installed, so nothing to uninstall.\n", strName.c_str()));
+                hrc = S_OK;             /* nothing to uninstall */
+            }
+            else
+            {
+                /*
+                 * Run the set-uid-to-root binary that performs the
+                 * uninstallation.  Then refresh the object.
+                 *
+                 * This refresh is theorically subject to races, but it's of
+                 * the don't-do-that variety.
+                 */
+                hrc = runSetUidToRootHelper("uninstall",
+                                            "--basepath", m->strBasePath.c_str(),
+                                            "--name",     strName.c_str(),
+                                            NULL);
+                if (SUCCEEDED(hrc))
+                {
+                    hrc = refreshExtPack(strName.c_str(), false /*a_fUnsuableIsError*/, &pExtPack);
+                    if (SUCCEEDED(hrc))
+                    {
+                        if (!pExtPack)
+                            LogRel(("ExtPackManager: Successfully uninstalled extension pack '%s'.\n", strName.c_str()));
+                        else
+                            hrc = setError(E_UNEXPECTED,
+                                           tr("Uninstall extension pack '%s' failed under mysterious circumstances"),
+                                           strName.c_str());
+                    }
+                }
+                else
+                {
+                    ErrorInfoKeeper Eik;
+                    refreshExtPack(strName.c_str(), false /*a_fUnsuableIsError*/, NULL);
+                }
+
+            }
+        }
+    }
+
+    return hrc;
+}
+
+
+/**
+ * Runs the helper program that does the privileged operations.
+ *
+ * @returns S_OK or a failure status with error information set.
+ * @param   a_pszCommand        The command to execute.
+ * @param   ...                 The argument strings that goes along with the
+ *                              command. Maximum is about 16.  Terminated by a
+ *                              NULL.
+ */
+HRESULT ExtPackManager::runSetUidToRootHelper(const char *a_pszCommand, ...)
+{
     /*
-     * Check that the file exists and that we can access it.
+     * Calculate the path to the helper program.
+     */
+    char szExecName[RTPATH_MAX];
+    int vrc = RTPathAppPrivateArch(szExecName, sizeof(szExecName));
+    AssertLogRelRCReturn(vrc, E_UNEXPECTED);
+
+    vrc = RTPathAppend(szExecName, sizeof(szExecName), VBOX_EXTPACK_HELPER_NAME);
+    AssertLogRelRCReturn(vrc, E_UNEXPECTED);
+
+    /*
+     * Convert the variable argument list to a RTProcCreate argument vector.
+     */
+    const char *apszArgs[20];
+    unsigned    cArgs = 0;
+    apszArgs[cArgs++] = &szExecName[0];
+    apszArgs[cArgs++] = a_pszCommand;
+
+    va_list va;
+    va_start(va, a_pszCommand);
+    const char *pszLastArg;
+    LogRel(("ExtPack: Executing '%s'", szExecName));
+    do
+    {
+        LogRel((" '%s'", apszArgs[cArgs - 1]));
+        AssertReturn(cArgs < RT_ELEMENTS(apszArgs) - 1, E_UNEXPECTED);
+        pszLastArg = va_arg(va, const char *);
+        apszArgs[cArgs++] = pszLastArg;
+    } while (pszLastArg != NULL);
+    LogRel(("\n"));
+    va_end(va);
+    apszArgs[cArgs] = NULL;
+
+    /*
+     * Create a PIPE which we attach to stderr so that we can read the error
+     * message on failure and report it back to the caller.
+     */
+    RTPIPE      hPipeR;
+    RTHANDLE    hStdErrPipe;
+    hStdErrPipe.enmType = RTHANDLETYPE_PIPE;
+    vrc = RTPipeCreate(&hPipeR, &hStdErrPipe.u.hPipe, RTPIPE_C_INHERIT_WRITE);
+    AssertLogRelRCReturn(vrc, E_UNEXPECTED);
+
+    /*
+     * Spawn the process.
      */
     HRESULT hrc;
-    if (RTFileExists(strTarball.c_str()))
-    {
-        RTFILE hFile;
-        int vrc = RTFileOpen(&hFile, strTarball.c_str(), RTFILE_O_READ | RTFILE_O_DENY_WRITE | RTFILE_O_OPEN);
-        if (RT_SUCCESS(vrc))
+    RTPROCESS hProcess;
+    vrc = RTProcCreateEx(szExecName,
+                         apszArgs,
+                         RTENV_DEFAULT,
+                         0 /*fFlags*/,
+                         NULL /*phStdIn*/,
+                         NULL /*phStdOut*/,
+                         &hStdErrPipe,
+                         NULL /*pszAsUser*/,
+                         NULL /*pszPassword*/,
+                         &hProcess);
+    if (RT_SUCCESS(vrc))
+    {
+        vrc = RTPipeClose(hStdErrPipe.u.hPipe);
+        hStdErrPipe.u.hPipe = NIL_RTPIPE;
+
+        /*
+         * Read the pipe output until the process completes.
+         */
+        RTPROCSTATUS    ProcStatus   = { -42, RTPROCEXITREASON_ABEND };
+        size_t          cbStdErrBuf  = 0;
+        size_t          offStdErrBuf = 0;
+        char           *pszStdErrBuf = NULL;
+        do
         {
             /*
-             * .
+             * Service the pipe. Block waiting for output or the pipe breaking
+             * when the process terminates.
              */
-
-
-            RTFileClose(hFile);
+            if (hPipeR != NIL_RTPIPE)
+            {
+                char    achBuf[16]; //1024
+                size_t  cbRead;
+                vrc = RTPipeReadBlocking(hPipeR, achBuf, sizeof(achBuf), &cbRead);
+                if (RT_SUCCESS(vrc))
+                {
+                    /* grow the buffer? */
+                    size_t cbBufReq = offStdErrBuf + cbRead + 1;
+                    if (   cbBufReq > cbStdErrBuf
+                        && cbBufReq < _256K)
+                    {
+                        size_t cbNew = RT_ALIGN_Z(cbBufReq, 16); // 1024
+                        void  *pvNew = RTMemRealloc(pszStdErrBuf, cbNew);
+                        if (pvNew)
+                        {
+                            pszStdErrBuf = (char *)pvNew;
+                            cbStdErrBuf  = cbNew;
+                        }
+                    }
+
+                    /* append if we've got room. */
+                    if (cbBufReq <= cbStdErrBuf)
+                    {
+                        memcpy(&pszStdErrBuf[offStdErrBuf], achBuf, cbRead);
+                        offStdErrBuf = offStdErrBuf + cbRead;
+                        pszStdErrBuf[offStdErrBuf] = '\0';
+                    }
+                }
+                else
+                {
+                    AssertLogRelMsg(vrc == VERR_BROKEN_PIPE, ("%Rrc\n", vrc));
+                    RTPipeClose(hPipeR);
+                    hPipeR = NIL_RTPIPE;
+                }
+            }
+
+            /*
+             * Service the process.  Block if we have no pipe.
+             */
+            if (hProcess != NIL_RTPROCESS)
+            {
+                vrc = RTProcWait(hProcess,
+                                 hPipeR == NIL_RTPIPE ? RTPROCWAIT_FLAGS_BLOCK : RTPROCWAIT_FLAGS_NOBLOCK,
+                                 &ProcStatus);
+                if (RT_SUCCESS(vrc))
+                    hProcess = NIL_RTPROCESS;
+                else
+                    AssertLogRelMsgStmt(vrc != VERR_PROCESS_RUNNING, ("%Rrc\n", vrc), hProcess = NIL_RTPROCESS);
+            }
+        } while (   hPipeR != NIL_RTPIPE
+                 || hProcess != NIL_RTPROCESS);
+
+        /*
+         * Compose the status code and, on failure, error message.
+         */
+        LogRel(("ExtPack: enmReason=%d iStatus=%d stderr='%s'\n",
+                ProcStatus.enmReason, ProcStatus.iStatus, offStdErrBuf ? pszStdErrBuf : ""));
+
+        if (   ProcStatus.enmReason == RTPROCEXITREASON_NORMAL
+            && ProcStatus.iStatus   == 0
+            && offStdErrBuf         == 0)
+            hrc = S_OK;
+        else if (ProcStatus.enmReason == RTPROCEXITREASON_NORMAL)
+        {
+            AssertMsg(ProcStatus.iStatus != 0, ("%s\n", pszStdErrBuf));
+            hrc = setError(E_UNEXPECTED, tr("The installer failed with exit code %d: %s"),
+                           ProcStatus.iStatus, offStdErrBuf ? pszStdErrBuf : "");
+        }
+        else if (ProcStatus.enmReason == RTPROCEXITREASON_SIGNAL)
+            hrc = setError(E_UNEXPECTED, tr("The installer was killed by signal #d (stderr: %s)"),
+                           ProcStatus.iStatus, offStdErrBuf ? pszStdErrBuf : "");
+        else if (ProcStatus.enmReason == RTPROCEXITREASON_ABEND)
+            hrc = setError(E_UNEXPECTED, tr("The installer aborted abnormally (stderr: %s)"),
+                           offStdErrBuf ? pszStdErrBuf : "");
+        else
+            hrc = setError(E_UNEXPECTED, tr("internal error: enmReason=%d iStatus=%d stderr='%s'"),
+                           ProcStatus.enmReason, ProcStatus.iStatus, offStdErrBuf ? pszStdErrBuf : "");
+
+        RTMemFree(pszStdErrBuf);
+    }
+    else
+        hrc = setError(VBOX_E_IPRT_ERROR, tr("Failed to launch the helper application '%s' (%Rrc)"), szExecName, vrc);
+
+    RTPipeClose(hPipeR);
+    RTPipeClose(hStdErrPipe.u.hPipe);
+
+    return hrc;
+}
+
+/**
+ * Finds an installed extension pack.
+ *
+ * @returns Pointer to the extension pack if found, NULL if not. (No reference
+ *          counting problem here since the caller must be holding the lock.)
+ * @param   a_pszName       The name of the extension pack.
+ */
+ExtPack *ExtPackManager::findExtPack(const char *a_pszName)
+{
+    size_t cchName = strlen(a_pszName);
+
+    for (ExtPackList::iterator it = m->llInstalledExtPacks.begin();
+         it != m->llInstalledExtPacks.end();
+         it++)
+    {
+        ExtPack::Data *pExtPackData = (*it)->m;
+        if (   pExtPackData
+            && pExtPackData->strName.length() == cchName
+            && pExtPackData->strName.compare(a_pszName, iprt::MiniString::CaseInsensitive) == 0)
+            return (*it);
+    }
+    return NULL;
+}
+
+/**
+ * Removes an installed extension pack from the internal list.
+ *
+ * The package is expected to exist!
+ *
+ * @param   a_pszName       The name of the extension pack.
+ */
+void ExtPackManager::removeExtPack(const char *a_pszName)
+{
+    size_t cchName = strlen(a_pszName);
+
+    for (ExtPackList::iterator it = m->llInstalledExtPacks.begin();
+         it != m->llInstalledExtPacks.end();
+         it++)
+    {
+        ExtPack::Data *pExtPackData = (*it)->m;
+        if (   pExtPackData
+            && pExtPackData->strName.length() == cchName
+            && pExtPackData->strName.compare(a_pszName, iprt::MiniString::CaseInsensitive) == 0)
+        {
+            m->llInstalledExtPacks.erase(it);
+            return;
+        }
+    }
+    AssertMsgFailed(("%s\n", a_pszName));
+}
+
+/**
+ * Refreshes the specified extension pack.
+ *
+ * This may remove the extension pack from the list, so any non-smart pointers
+ * to the extension pack object may become invalid.
+ *
+ * @returns S_OK and *ppExtPack on success, COM status code and error message
+ *          on failure.
+ * @param   a_pszName           The extension to update..
+ * @param   a_fUnsuableIsError  If @c true, report an unusable extension pack
+ *                              as an error.
+ * @param   a_ppExtPack         Where to store the pointer to the extension
+ *                              pack of it is still around after the refresh.
+ *                              This is optional.
+ */
+HRESULT ExtPackManager::refreshExtPack(const char *a_pszName, bool a_fUnsuableIsError, ExtPack **a_ppExtPack)
+{
+    HRESULT hrc;
+    ExtPack *pExtPack = findExtPack(a_pszName);
+    if (pExtPack)
+    {
+        /*
+         * Refresh existing object.
+         */
+        bool fCanDelete;
+        hrc = pExtPack->refresh(&fCanDelete);
+        if (SUCCEEDED(hrc))
+        {
+            if (fCanDelete)
+            {
+                removeExtPack(a_pszName);
+                pExtPack = NULL;
+            }
+        }
+    }
+    else
+    {
+        /*
+         * Does the dir exist?  Make some special effort to deal with case
+         * sensitivie file systems (a_pszName is case insensitive).
+         */
+        char szDir[RTPATH_MAX];
+        int vrc = RTPathJoin(szDir, sizeof(szDir), m->strBasePath.c_str(), a_pszName);
+        AssertLogRelRCReturn(vrc, E_FAIL);
+
+        RTDIRENTRYEX    Entry;
+        RTFSOBJINFO     ObjInfo;
+        vrc = RTPathQueryInfoEx(szDir, &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
+        bool fExists = RT_SUCCESS(vrc) && RTFS_IS_DIRECTORY(ObjInfo.Attr.fMode);
+        if (!fExists)
+        {
+            PRTDIR pDir;
+            vrc = RTDirOpen(&pDir, m->strBasePath.c_str());
+            if (RT_SUCCESS(vrc))
+            {
+                for (;;)
+                {
+                    vrc = RTDirReadEx(pDir, &Entry, NULL /*pcbDirEntry*/, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
+                    if (RT_FAILURE(vrc))
+                    {
+                        AssertLogRelMsg(vrc == VERR_NO_MORE_FILES, ("%Rrc\n", vrc));
+                        break;
+                    }
+                    if (   RTFS_IS_DIRECTORY(Entry.Info.Attr.fMode)
+                        && !RTStrICmp(Entry.szName, a_pszName))
+                    {
+                        /*
+                         * The installed extension pack has a uses different case.
+                         * Update the name and directory variables.
+                         */
+                        vrc = RTPathJoin(szDir, sizeof(szDir), m->strBasePath.c_str(), Entry.szName); /* not really necessary */
+                        AssertLogRelRCReturnStmt(vrc, E_UNEXPECTED, RTDirClose(pDir));
+                        a_pszName = Entry.szName;
+                        fExists   = true;
+                        break;
+                    }
+                }
+                RTDirClose(pDir);
+            }
+        }
+        if (fExists)
+        {
+            /*
+             * We've got something, create a new extension pack object for it.
+             */
+            ComObjPtr<ExtPack> NewExtPack;
+            hrc = NewExtPack.createObject();
+            if (SUCCEEDED(hrc))
+                hrc = NewExtPack->init(a_pszName, m->strBasePath.c_str());
+            if (SUCCEEDED(hrc))
+            {
+                m->llInstalledExtPacks.push_back(NewExtPack);
+                if (NewExtPack->m->fUsable)
+                    LogRel(("ExtPackManager: Found extension pack '%s'.\n", a_pszName));
+                else
+                    LogRel(("ExtPackManager: Found bad extension pack '%s': %s\n",
+                            a_pszName, NewExtPack->m->strWhyUnusable.c_str() ));
+                pExtPack = NewExtPack;
+            }
         }
         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());
-    return hrc;
-}
-
-STDMETHODIMP ExtPackManager::Uninstall(IN_BSTR a_bstrName, BOOL a_fForcedRemoval)
-{
-    NOREF(a_bstrName); NOREF(a_fForcedRemoval);
-    return E_NOTIMPL;
+            hrc = S_OK;
+    }
+
+    /*
+     * Report error if not usable, if that is desired.
+     */
+    if (   SUCCEEDED(hrc)
+        && pExtPack
+        && a_fUnsuableIsError
+        && !pExtPack->m->fUsable)
+        hrc = setError(E_FAIL, "%s", pExtPack->m->strWhyUnusable.c_str());
+
+    if (a_ppExtPack)
+        *a_ppExtPack = pExtPack;
+    return hrc;
 }
 
@@ -430 +939 @@
 }
 
+
 /* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

@@ -63 +63 @@
      * @{ */
     void *getCallbackTable();
+    HRESULT refresh(bool *pfCanDelete);
     /** @}  */
 
@@ -109 +110 @@
     /** @name Internal interfaces used by other Main classes.
      * @{ */
-    int callAllConfigHooks(IConsole *a_pConsole, PVM a_pVM);
-    int callAllNewMachineHooks(IMachine *a_pMachine);
+    int         callAllConfigHooks(IConsole *a_pConsole, PVM a_pVM);
+    int         callAllNewMachineHooks(IMachine *a_pMachine);
     /** @}  */
+
+private:
+    HRESULT     runSetUidToRootHelper(const char *a_pszCommand, ...);
+    ExtPack    *findExtPack(const char *a_pszName);
+    void        removeExtPack(const char *a_pszName);
+    HRESULT     refreshExtPack(const char *a_pszName, bool a_fUnsuableIsError, ExtPack **a_ppExtPack);
 
 private: