Changeset 33492 in vbox for trunk

Timestamp:

Oct 27, 2010 11:05:14 AM (14 years ago)

Author:

vboxsync

Message:

Guest Copy/Guest Additions: Update.

Location:

trunk

Files:

• include/VBox/HostServices/GuestControlSvc.h (modified) (1 diff)
• include/iprt/isofs.h (modified) (1 diff)
• src/VBox/Additions/common/VBoxService/VBoxServiceControlExec.cpp (modified) (1 diff)
• src/VBox/Frontends/VirtualBox/src/globals/VBoxProblemReporter.cpp (modified) (2 diffs)
• src/VBox/Frontends/VirtualBox/src/globals/VBoxProblemReporter.h (modified) (1 diff)
• src/VBox/Frontends/VirtualBox/src/runtime/UISession.cpp (modified) (1 diff)
• src/VBox/Main/GuestImpl.cpp (modified) (15 diffs)
• src/VBox/Main/idl/VirtualBox.xidl (modified) (6 diffs)
• src/VBox/Main/include/GuestImpl.h (modified) (2 diffs)
• src/VBox/Runtime/r3/isofs.cpp (modified) (1 diff)

trunk/include/VBox/HostServices/GuestControlSvc.h

@@ -69 +69 @@
 
 /**
- * Input flags, set by the host.
+ * Input flags, set by the host. This is needed for
+ * handling flags on the guest side.
  * Note: Has to match Main's ProcessInputFlag_* flags!
  */

trunk/include/iprt/isofs.h

@@ -44 +44 @@
 #define RTISOFS_MAX_PREPARER_ID    128
 #define RTISOFS_MAX_APPLICATION_ID 128
+#define RTISOFS_MAX_STRING_LEN     256
 
 /** Standard ID of volume descriptors. */

trunk/src/VBox/Additions/common/VBoxService/VBoxServiceControlExec.cpp

@@ -1140 +1140 @@
         if (RT_SUCCESS(rc) && pszCmdTool)
         {
+            /* Disable service flag bit, because we're executing the internal
+             * tool with the profile which was used to start VBoxService. */
+            fFlags &= ~RTPROC_FLAGS_SERVICE;
+
             rc = RTProcCreateEx(pszCmdTool, papszArgsTool ? papszArgsTool : papszArgs,
                                 hEnv, fFlags,
-                                phStdIn, phStdOut, phStdErr, pszAsUser,
-                                pszPassword, phProcess);
+                                phStdIn, phStdOut, phStdErr,
+                                strlen(pszAsUser) ? pszAsUser : NULL,
+                                strlen(pszPassword) ? pszPassword : NULL,
+                                phProcess);
             if (papszArgsTool)
                 RTGetOptArgvFree(papszArgsTool);

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

@@ -2381 +2381 @@
 }
 
-void VBoxProblemReporter::warnAboutIncorrectPort(QWidget *pParent) const
+void VBoxProblemReporter::cannotUpdateGuestAdditions (const CProgress &aProgress, QWidget *aParent /* = NULL */) const
+{
+    AssertWrapperOk (aProgress);
+
+    message (aParent ? aParent : mainWindowShown(),
+             Error,
+             tr ("Failed to update Guest Additions."),
+             formatErrorInfo (aProgress.GetErrorInfo()));
+}
+
+void VBoxProblemReporter::warnAboutIncorrectPort (QWidget *pParent) const
 {
     message(pParent, Error,
@@ -2388 +2398 @@
 }
 
-bool VBoxProblemReporter::confirmCancelingPortForwardingDialog(QWidget *pParent) const
+bool VBoxProblemReporter::confirmCancelingPortForwardingDialog (QWidget *pParent) const
 {
     return messageOkCancel(pParent, Question,

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

@@ -372 +372 @@
     void cannotExportAppliance (const CProgress &aProgress, CAppliance *aAppliance, QWidget *aParent = NULL) const;
 
+    void cannotUpdateGuestAdditions (const CProgress &aProgress, QWidget *aParent /* = NULL */) const;
+
     void warnAboutIncorrectPort(QWidget *pParent) const;
     bool confirmCancelingPortForwardingDialog(QWidget *pParent) const;

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UISession.cpp

@@ -355 +355 @@
     CMachine machine = session().GetMachine();
     CVirtualBox vbox = vboxGlobal().virtualBox();
-    QString strUuid;
-
-    CMedium image = vbox.FindMedium(strSource, KDeviceType_DVD);
-    if (image.isNull())
-    {
-        image = vbox.OpenMedium(strSource, KDeviceType_DVD, KAccessMode_ReadWrite);
-        if (vbox.isOk())
+
+#ifdef DEBUG_andy
+    /*
+     * If the already installed Guest Additions indicate a
+     * high enough run level (at the moment this is level "Desktop",
+     * which means that a user has to be logged in to acknowledge
+     * WHQL popups), try an automatic Guest Additions update.
+     */
+    CGuest guest = session().GetConsole().GetGuest();
+    QString osType = guest.GetOSTypeId();
+    ULONG ulGuestAdditionsRunLevel = guest.GetAdditionsRunLevel();
+    if (   ulGuestAdditionsRunLevel >= AdditionsRunLevelType_System // Desktop
+#if 1  /* Only Windows is supported at the moment! */
+        && (   osType.contains("Microsoft", Qt::CaseInsensitive)
+            || osType.contains("Windows", Qt::CaseInsensitive)
+           )
+#endif
+       )
+    {
+#ifdef DEBUG_andy
+        CProgress progressInstall = guest.UpdateGuestAdditions("c:\\Downloads\\VBoxGuestAdditions_3.2.8.iso");
+#else
+        CProgress progressInstall = guest.UpdateGuestAdditions(strSource);
+#endif
+#if 0
+        bool fResult = guest.isOk();
+        if (fResult)
+        {
+            vboxProblem().showModalProgressDialog(progressInstall, tr("Updating Guest Additions ..."), mainMachineWindow());
+            if (progressInstall.GetCanceled())
+                return;
+            if (!progressInstall.isOk() || progressInstall.GetResultCode() != 0)
+            {
+                vboxProblem().cannotUpdateGuestAdditions(progressInstall, mainMachineWindow());
+                return;
+            }
+        }
+#endif
+    }
+    else /* Fallback to only mounting the .ISO file. */
+    {
+#endif /* DEBUG_andy */
+        QString strUuid;
+        CMedium image = vbox.FindMedium(strSource, KDeviceType_DVD);
+        if (image.isNull())
+        {
+            image = vbox.OpenMedium(strSource, KDeviceType_DVD, KAccessMode_ReadWrite);
+            if (vbox.isOk())
+                strUuid = image.GetId();
+        }
+        else
             strUuid = image.GetId();
-    }
-    else
-        strUuid = image.GetId();
-
-    if (!vbox.isOk())
-    {
-        vboxProblem().cannotOpenMedium(0, vbox, VBoxDefs::MediumType_DVD, strSource);
-        return;
-    }
-
-    AssertMsg(!strUuid.isNull(), ("Guest Additions image UUID should be valid!\n"));
-
-    QString strCntName;
-    LONG iCntPort = -1, iCntDevice = -1;
-    /* Searching for the first suitable slot */
-    {
-        CStorageControllerVector controllers = machine.GetStorageControllers();
-        int i = 0;
-        while (i < controllers.size() && strCntName.isNull())
-        {
-            CStorageController controller = controllers[i];
-            CMediumAttachmentVector attachments = machine.GetMediumAttachmentsOfController(controller.GetName());
-            int j = 0;
-            while (j < attachments.size() && strCntName.isNull())
+
+        if (!vbox.isOk())
+        {
+            vboxProblem().cannotOpenMedium(0, vbox, VBoxDefs::MediumType_DVD, strSource);
+            return;
+        }
+
+        AssertMsg(!strUuid.isNull(), ("Guest Additions image UUID should be valid!\n"));
+
+        QString strCntName;
+        LONG iCntPort = -1, iCntDevice = -1;
+        /* Searching for the first suitable slot */
+        {
+            CStorageControllerVector controllers = machine.GetStorageControllers();
+            int i = 0;
+            while (i < controllers.size() && strCntName.isNull())
             {
-                CMediumAttachment attachment = attachments[j];
-                if (attachment.GetType() == KDeviceType_DVD)
+                CStorageController controller = controllers[i];
+                CMediumAttachmentVector attachments = machine.GetMediumAttachmentsOfController(controller.GetName());
+                int j = 0;
+                while (j < attachments.size() && strCntName.isNull())
                 {
-                    strCntName = controller.GetName();
-                    iCntPort = attachment.GetPort();
-                    iCntDevice = attachment.GetDevice();
+                    CMediumAttachment attachment = attachments[j];
+                    if (attachment.GetType() == KDeviceType_DVD)
+                    {
+                        strCntName = controller.GetName();
+                        iCntPort = attachment.GetPort();
+                        iCntDevice = attachment.GetDevice();
+                    }
+                    ++ j;
                 }
-                ++ j;
+                ++ i;
             }
-            ++ i;
-        }
-    }
-
-    if (!strCntName.isNull())
-    {
-        bool fIsMounted = false;
-
-        VBoxMedium vmedium = vboxGlobal().findMedium(strUuid);
-        CMedium medium = vmedium.medium();              // @todo r=dj can this be cached somewhere?
-
-        /* Mount medium to the predefined port/device */
-        machine.MountMedium(strCntName, iCntPort, iCntDevice, medium, false /* force */);
-        if (machine.isOk())
-            fIsMounted = true;
+        }
+
+        if (!strCntName.isNull())
+        {
+            bool fIsMounted = false;
+
+            VBoxMedium vmedium = vboxGlobal().findMedium(strUuid);
+            CMedium medium = vmedium.medium();              // @todo r=dj can this be cached somewhere?
+
+            /* Mount medium to the predefined port/device */
+            machine.MountMedium(strCntName, iCntPort, iCntDevice, medium, false /* force */);
+            if (machine.isOk())
+                fIsMounted = true;
+            else
+            {
+                /* Ask for force mounting */
+                if (vboxProblem().cannotRemountMedium(0, machine, VBoxMedium(image, VBoxDefs::MediumType_DVD),
+                                                      true /* mount? */, true /* retry? */) == QIMessageBox::Ok)
+                {
+                    /* Force mount medium to the predefined port/device */
+                    machine.MountMedium(strCntName, iCntPort, iCntDevice, medium, true /* force */);
+                    if (machine.isOk())
+                        fIsMounted = true;
+                    else
+                        vboxProblem().cannotRemountMedium(0, machine, VBoxMedium(image, VBoxDefs::MediumType_DVD),
+                                                          true /* mount? */, false /* retry? */);
+                }
+            }
+        }
         else
-        {
-            /* Ask for force mounting */
-            if (vboxProblem().cannotRemountMedium(0, machine, VBoxMedium(image, VBoxDefs::MediumType_DVD),
-                                                  true /* mount? */, true /* retry? */) == QIMessageBox::Ok)
-            {
-                /* Force mount medium to the predefined port/device */
-                machine.MountMedium(strCntName, iCntPort, iCntDevice, medium, true /* force */);
-                if (machine.isOk())
-                    fIsMounted = true;
-                else
-                    vboxProblem().cannotRemountMedium(0, machine, VBoxMedium(image, VBoxDefs::MediumType_DVD),
-                                                      true /* mount? */, false /* retry? */);
-            }
-        }
-    }
-    else
-        vboxProblem().cannotMountGuestAdditions(machine.GetName());
+            vboxProblem().cannotMountGuestAdditions(machine.GetName());
+#ifdef DEBUG_andy
+    }
+#endif /* DEBUG_andy */
 }
 

trunk/src/VBox/Main/GuestImpl.cpp

@@ -35 +35 @@
 #include <iprt/file.h>
 #include <iprt/getopt.h>
+#include <iprt/isofs.h>
 #include <iprt/list.h>
 #include <iprt/path.h>
@@ -47 +48 @@
 DEFINE_EMPTY_CTOR_DTOR (Guest)
 
+struct Guest::TaskGuest
+{
+    enum TaskType
+    {
+        UpdateGuestAdditions = 100
+    };
+
+    TaskGuest(TaskType aTaskType, Guest *aThat, Progress *aProgress)
+        : taskType(aTaskType),
+          pGuest(aThat),
+          progress(aProgress),
+          rc(S_OK)
+    {}
+    ~TaskGuest() {}
+
+    int startThread();
+    static int taskThread(RTTHREAD aThread, void *pvUser);
+    static int uploadProgress(unsigned uPercent, void *pvUser);
+
+    TaskType taskType;
+    Guest *pGuest;
+    ComObjPtr<Progress> progress;
+    HRESULT rc;
+
+    /* Task data. */
+    Utf8Str strSource;
+};
+
+int Guest::TaskGuest::startThread()
+{
+    int vrc = RTThreadCreate(NULL, Guest::TaskGuest::taskThread, this,
+                             0, RTTHREADTYPE_MAIN_HEAVY_WORKER, 0,
+                             "Guest::Task");
+
+    if (RT_FAILURE(vrc))
+        return Guest::setErrorStatic(E_FAIL, Utf8StrFmt("Could not create taskThreadGuest (%Rrc)\n", vrc));
+
+    return vrc;
+}
+
+/* static */
+DECLCALLBACK(int) Guest::TaskGuest::taskThread(RTTHREAD /* aThread */, void *pvUser)
+{
+    std::auto_ptr<TaskGuest> task(static_cast<TaskGuest*>(pvUser));
+    AssertReturn(task.get(), VERR_GENERAL_FAILURE);
+
+    Guest *pGuest = task->pGuest;
+
+    LogFlowFuncEnter();
+    LogFlowFunc(("Guest %p\n", pGuest));
+
+    HRESULT rc = S_OK;
+
+    switch (task->taskType)
+    {
+#ifdef VBOX_WITH_GUEST_CONTROL
+        case TaskGuest::UpdateGuestAdditions:
+        {
+            rc = pGuest->taskUpdateGuestAdditions(task.get());
+            break;
+        }
+#endif
+        default:
+            AssertMsgFailed(("Invalid task type %u specified!\n", task->taskType));
+            break;
+    }
+
+    LogFlowFunc(("rc=%Rhrc\n", rc));
+    LogFlowFuncLeave();
+
+    return VINF_SUCCESS;
+}
+
+/* static */
+int Guest::TaskGuest::uploadProgress(unsigned uPercent, void *pvUser)
+{
+    Guest::TaskGuest *pTask = *(Guest::TaskGuest**)pvUser;
+
+    if (pTask &&
+        !pTask->progress.isNull())
+    {
+        BOOL fCanceled;
+        pTask->progress->COMGETTER(Canceled)(&fCanceled);
+        if (fCanceled)
+            return -1;
+        pTask->progress->SetCurrentOperationProgress(uPercent);
+    }
+    return VINF_SUCCESS;
+}
+
+#ifdef VBOX_WITH_GUEST_CONTROL
+HRESULT Guest::taskUpdateGuestAdditions(TaskGuest *aTask)
+{
+    LogFlowFuncEnter();
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoWriteLock appLock(this COMMA_LOCKVAL_SRC_POS);
+
+    HRESULT rc = S_OK;
+
+    try
+    {
+        Guest *pGuest = aTask->pGuest;
+        AssertPtr(pGuest);
+        /*Console *pConsole = pGuest->mParent;
+        AssertPtr(pConsole);
+        Console *pMachine = pConsole->machine();
+        AssertPtr(pMachine);*/
+
+        if (aTask->progress)
+            aTask->progress->SetCurrentOperationProgress(10);
+
+        /*
+         * Determine guest type to know which installer stuff
+         * we need. At the moment only Windows guests are supported.
+         */
+        Utf8Str installerImage;
+        Utf8Str osType = pGuest->mData.mOSTypeId;
+        if (   osType.contains("Microsoft", Utf8Str::CaseInsensitive)
+            || osType.contains("Windows", Utf8Str::CaseInsensitive))
+        {
+            if (osType.contains("64", Utf8Str::CaseInsensitive))
+                installerImage = "VBOXWINDOWSADDITIONS_AMD64.EXE";
+            else
+                installerImage = "VBOXWINDOWSADDITIONS_X86.EXE";
+            /* Since the installers are located in the root directory,
+             * no further path processing needs to be done (yet). */
+        }
+
+        /* No (suited) installer found? Bail out. */
+        if (installerImage.isEmpty())
+            throw setError(VBOX_E_FILE_ERROR, tr("Guest OS not supported for automatic Guest Additions updating yet"));
+
+        /*
+         * Try to open the .ISO file and locate the specified installer.
+         */
+        RTISOFSFILE iso;
+        int vrc = RTIsoFsOpen(&iso, aTask->strSource.c_str());
+        if (RT_SUCCESS(vrc))
+        {
+            uint32_t cbOffset;
+            size_t cbLength;
+            vrc = RTIsoFsGetFileInfo(&iso, installerImage.c_str(), &cbOffset, &cbLength);
+            if (   RT_SUCCESS(vrc)
+                && cbOffset
+                && cbLength)
+            {
+                vrc = RTFileSeek(iso.file, cbOffset, RTFILE_SEEK_BEGIN, NULL);
+            }
+
+            /** @todo Only Windows! */
+            Utf8Str strInstallerPath = "C:\\Windows\\VBoxWindowsAdditions.exe";
+
+            if (RT_FAILURE(vrc))
+            {
+                switch (vrc)
+                {
+                    case VERR_FILE_NOT_FOUND:
+                        rc = setError(VBOX_E_IPRT_ERROR, tr("Installer file was not found on medium"));
+                        break;
+
+                    default:
+                        rc = setError(VBOX_E_IPRT_ERROR, tr("An unknown error occured, rc=%Rrc"), vrc);
+                        break;
+                }
+            }
+            else
+            {
+                /* Okay, we're ready to transfer the bits! */
+                if (aTask->progress)
+                    aTask->progress->SetCurrentOperationProgress(15);
+
+                /* Prepare command line args. */
+                com::SafeArray<IN_BSTR> args;
+                com::SafeArray<IN_BSTR> env;
+
+                char szOutput[RTPATH_MAX];
+                if (RTStrPrintf(szOutput, sizeof(szOutput), "--output=%s", strInstallerPath.c_str()))
+                {
+                    args.push_back(Bstr("vbox_cat").raw()); /* The actual (internal) tool to use (as argv[0]). */
+                    args.push_back(Bstr(szOutput).raw());   /* We want to write a file ... */
+                }
+                else
+                    rc = setError(VBOX_E_IPRT_ERROR, tr("Error preparing command line fopr copy operation"));
+
+                if (SUCCEEDED(rc))
+                {
+                    ComPtr<IProgress> progressCopy;
+                    ULONG uPID;
+
+                    /*
+                     * Start built-in "vbox_cat" tool (inside VBoxService) to
+                     * copy over/pipe the data into a file on the guest (with
+                     * system rights, no username/password specified).
+                     */
+                    rc = pGuest->executeProcessInternal(Bstr("vbox_cat").raw(),
+                                                        ExecuteProcessFlag_WaitForProcessStartOnly,
+                                                        ComSafeArrayAsInParam(args),
+                                                        ComSafeArrayAsInParam(env),
+                                                        Bstr("admin")  /* Username */,
+                                                        Bstr("password")  /* Password */,
+                                                        10 * 1000 /* Wait 10s for getting the process started */,
+                                                        &uPID, progressCopy.asOutParam());
+                    if (SUCCEEDED(rc))
+                    {
+                        if (aTask->progress)
+                            aTask->progress->SetCurrentOperationProgress(20);
+
+                        /* Wait for process to exit ... */
+                        BOOL fCompleted = FALSE;
+                        BOOL fCanceled = FALSE;
+
+                        size_t cbRead;
+                        size_t cbToRead;
+                        SafeArray<BYTE> aInputData(_64K);
+                        while (   SUCCEEDED(progressCopy->COMGETTER(Completed(&fCompleted)))
+                               && !fCompleted)
+                        {
+                            cbToRead = RT_MIN(cbLength, _64K);
+                            vrc = RTFileRead(iso.file, (uint8_t*)aInputData.raw(), cbToRead, &cbRead);
+                            if (   cbRead
+                                && RT_SUCCESS(vrc))
+                            {
+                                aInputData.resize(cbRead);
+
+                                /* Did we reach the end of the content
+                                 * we want to transfer (last chunk)? */
+                                ULONG uFlags = ProcessInputFlag_None;
+                                if (cbRead < _64K)
+                                    uFlags |= ProcessInputFlag_EndOfFile;
+
+                                /* Transfer the current chunk ... */
+                                ULONG uBytesWritten;
+                                rc = SetProcessInput(uPID, uFlags,
+                                                     ComSafeArrayAsInParam(aInputData), &uBytesWritten);
+                                if (FAILED(rc))
+                                {
+                                    break;
+                                }
+                                else
+                                {
+                                    cbLength -= uBytesWritten;
+                                }
+
+                                /* Progress canceled by Main API? */
+                                if (   SUCCEEDED(progressCopy->COMGETTER(Canceled(&fCanceled)))
+                                    && fCanceled)
+                                {
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            RTIsoFsClose(&iso);
+
+            if (SUCCEEDED(rc))
+            {
+                /*
+                 * Installer was transferred successfully, so let's start it
+                 * (with system rights).
+                 */
+                if (aTask->progress)
+                    aTask->progress->SetCurrentOperationProgress(66);
+
+                /* Prepare command line args for installer. */
+                com::SafeArray<IN_BSTR> installerArgs;
+                com::SafeArray<IN_BSTR> installerEnv;
+
+                /** @todo Only Windows! */
+                installerArgs.push_back(Bstr(strInstallerPath).raw()); /* The actual (internal) installer image (as argv[0]). */
+                installerArgs.push_back(Bstr("/S").raw());             /* We want to install in silent mode. */
+                installerArgs.push_back(Bstr("/l").raw());             /* ... and logging enabled. */
+
+                /*
+                 * Start built-in "vbox_cat" tool (inside VBoxService) to
+                 * copy over/pipe the data into a file on the guest (with
+                 * system rights, no username/password specified).
+                 */
+                ComPtr<IProgress> progressInstaller;
+                ULONG uPID;
+                rc = pGuest->executeProcessInternal(Bstr(strInstallerPath).raw(), 0 /* Flags */,
+                                                    ComSafeArrayAsInParam(installerArgs),
+                                                    ComSafeArrayAsInParam(installerEnv),
+                                                    Bstr("") /* Username */,
+                                                    Bstr("") /* Password */,
+                                                    0 /* Timeout */,
+                                                    &uPID, progressInstaller.asOutParam());
+                if (SUCCEEDED(rc))
+                {
+                    /* Nothing yet. */
+                }
+            }
+        }
+    }
+    catch(HRESULT aRC)
+    {
+        rc = aRC;
+    }
+
+    /* Clean up */
+    if (aTask->progress)
+        aTask->progress->SetCurrentOperationProgress(99);
+
+    /* Assign data. */
+    if (rc == S_OK)
+    {
+    }
+
+    aTask->rc = rc;
+
+    if (!aTask->progress.isNull())
+        aTask->progress->notifyComplete(rc);
+
+    LogFlowFunc(("rc=%Rhrc\n", rc));
+    LogFlowFuncLeave();
+
+    return VINF_SUCCESS;
+}
+#endif
+
 HRESULT Guest::FinalConstruct()
 {
@@ -63 +388 @@
  * Initializes the guest object.
  */
-HRESULT Guest::init (Console *aParent)
+HRESULT Guest::init(Console *aParent)
 {
     LogFlowThisFunc(("aParent=%p\n", aParent));
@@ -1101 +1426 @@
         return setError(E_INVALIDARG, tr("No user name specified"));
 
+    LogRel(("Executing guest process \"%s\" as user \"%s\" ...\n",
+            Utf8Str(aCommand).c_str(), Utf8Str(aUserName).c_str()));
+
+    return executeProcessInternal(aCommand, aFlags,aArguments, aEnvironment,
+                                  aUserName, aPassword, aTimeoutMS, aPID, aProgress);
+#endif
+}
+
+HRESULT Guest::executeProcessInternal(Bstr aCommand, ULONG aFlags,
+                                      ComSafeArrayIn(Bstr, aArguments), ComSafeArrayIn(Bstr, aEnvironment),
+                                      Bstr aUserName, Bstr aPassword,
+                                      ULONG aTimeoutMS, ULONG *aPID, IProgress **aProgress)
+{
+/** @todo r=bird: Eventually we should clean up all the timeout parameters
+ *        in the API and have the same way of specifying infinite waits!  */
+#ifndef VBOX_WITH_GUEST_CONTROL
+    ReturnComNotImplemented();
+#else  /* VBOX_WITH_GUEST_CONTROL */
+    using namespace guestControl;
+
     AutoCaller autoCaller(this);
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
@@ -1107 +1452 @@
     if (aFlags)
     {
-        if (!(aFlags & ExecuteProcessFlag_IgnoreOrphanedProcesses))
-            return E_INVALIDARG;
+        if (   !(aFlags & ExecuteProcessFlag_IgnoreOrphanedProcesses)
+            && !(aFlags & ExecuteProcessFlag_WaitForProcessStartOnly))
+        {
+            return setError(E_INVALIDARG, tr("Unknown flags (%#x)"), aFlags);
+        }
     }
 
@@ -1189 +1537 @@
                 }
 
-                LogRel(("Executing guest process \"%s\" as user \"%s\" ...\n",
-                        Utf8Command.c_str(), Utf8UserName.c_str()));
-
                 if (RT_SUCCESS(vrc))
                 {
@@ -1213 +1558 @@
                     paParms[i++].setPointer((void*)Utf8UserName.c_str(), (uint32_t)Utf8UserName.length() + 1);
                     paParms[i++].setPointer((void*)Utf8Password.c_str(), (uint32_t)Utf8Password.length() + 1);
-                    paParms[i++].setUInt32(aTimeoutMS);
+
+                    /*
+                     * If the WaitForProcessStartOnly flag is set, we only want to define and wait for a timeout
+                     * until the process was started - the process itself then gets an infinit timeout for execution.
+                     * This is handy when we want to start a process inside a worker thread within a certain timeout
+                     * but let the started process perform lengthly operations then.
+                     */
+                    if (aFlags & ExecuteProcessFlag_WaitForProcessStartOnly)
+                        paParms[i++].setUInt32(UINT32_MAX /* Infinite timeout */);
+                    else
+                        paParms[i++].setUInt32(aTimeoutMS);
 
                     VMMDev *vmmDev;
@@ -1383 +1738 @@
 
         if (RT_FAILURE(vrc))
-            LogRel(("Executing guest process \"%s\" as user \"%s\" failed with %Rrc\n",
-                    Utf8Command.c_str(), Utf8UserName.c_str(), vrc));
+        {
+            if (!Utf8UserName.isEmpty()) /* Skip logging internal calls. */
+                LogRel(("Executing guest process \"%s\" as user \"%s\" failed with %Rrc\n",
+                        Utf8Command.c_str(), Utf8UserName.c_str(), vrc));
+        }
     }
     catch (std::bad_alloc &)
@@ -1834 +2192 @@
 #ifndef VBOX_WITH_GUEST_CONTROL
     ReturnComNotImplemented();
-#else  /* VBOX_WITH_GUEST_CONTROL */
+#else /* VBOX_WITH_GUEST_CONTROL */
     using namespace guestControl;
 
@@ -1914 +2272 @@
                         LogRel(("Copying file \"%s\" to guest \"%s\" ...\n",
                                 Utf8Source.c_str(), Utf8Dest.c_str()));
-
                         /*
                          * Okay, since we gathered all stuff we need until now to start the
                          * actual copying, start the guest part now.
                          */
-                        rc = ExecuteProcess(Bstr("vbox_cat").raw(), 0 /* Flags */,
+                        rc = ExecuteProcess(Bstr("vbox_cat").raw(),
+                                            ExecuteProcessFlag_WaitForProcessStartOnly,
                                             ComSafeArrayAsInParam(args),
                                             ComSafeArrayAsInParam(env),
                                             Bstr(Utf8UserName).raw(),
-                                            Bstr(Utf8Password).raw(), 0 /* Timeout */,
+                                            Bstr(Utf8Password).raw(),
+                                            10 * 1000 /* Wait 10s for getting the process started */,
                                             &uPID, execProgress.asOutParam());
                     }
@@ -1985 +2344 @@
 }
 
+STDMETHODIMP Guest::UpdateGuestAdditions(IN_BSTR aSource, IProgress **aProgress)
+{
+#ifndef VBOX_WITH_GUEST_CONTROL
+    ReturnComNotImplemented();
+#else /* VBOX_WITH_GUEST_CONTROL */
+    CheckComArgStrNotEmptyOrNull(aSource);
+    CheckComArgOutPointerValid(aProgress);
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    HRESULT rc = S_OK;
+
+    ComObjPtr<Progress> progress;
+    try
+    {
+        /* Create the progress object. */
+        progress.createObject();
+
+        rc = progress->init(static_cast<IGuest*>(this),
+                            Bstr(tr("Updating Guest Additions")).raw(),
+                            TRUE /* aCancelable */);
+        if (FAILED(rc)) throw rc;
+
+        /* Initialize our worker task. */
+        std::auto_ptr<TaskGuest> task(new TaskGuest(TaskGuest::UpdateGuestAdditions, this, progress));
+
+        /* Assign data. */
+        task->strSource = (Utf8Str(aSource));
+
+        rc = task->startThread();
+        if (FAILED(rc)) throw rc;
+
+        /* Don't destruct on success. */
+        task.release();
+    }
+    catch (HRESULT aRC)
+    {
+        rc = aRC;
+    }
+
+    if (SUCCEEDED(rc))
+        /* Return progress to the caller. */
+        progress.queryInterfaceTo(aProgress);
+
+    return rc;
+#endif /* VBOX_WITH_GUEST_CONTROL */
+}
+
 // public methods only for internal purposes
 /////////////////////////////////////////////////////////////////////////////
@@ -1999 +2409 @@
 {
     AutoCaller autoCaller(this);
-    AssertComRCReturnVoid (autoCaller.rc());
+    AssertComRCReturnVoid(autoCaller.rc());
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -2057 +2467 @@
 {
     AutoCaller autoCaller(this);
-    AssertComRCReturnVoid (autoCaller.rc());
+    AssertComRCReturnVoid(autoCaller.rc());
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -2082 +2492 @@
 {
     AutoCaller autoCaller(this);
-    AssertComRCReturnVoid (autoCaller.rc());
+    AssertComRCReturnVoid(autoCaller.rc());
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -2125 +2535 @@
 {
     AutoCaller autoCaller(this);
-    AssertComRCReturnVoid (autoCaller.rc());
+    AssertComRCReturnVoid(autoCaller.rc());
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);

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

@@ -7618 +7618 @@
     </const>
     <const name="System"   value="1">
-        <desc>Guest drivers are loaded.</desc>
+      <desc>Guest drivers are loaded.</desc>
     </const>
     <const name="Userland" value="2">
-        <desc>Common components (such as application services) are loaded.</desc>
+      <desc>Common components (such as application services) are loaded.</desc>
     </const>
     <const name="Desktop"  value="3">
-        <desc>Per-user desktop components are loaded.</desc>
+      <desc>Per-user desktop components are loaded.</desc>
     </const>
   </enum>
@@ -7630 +7630 @@
   <enum
     name="ExecuteProcessFlag"
-    uuid="9a24c17d-bd46-4207-b247-517fdd6d6b8f"
+    uuid="3258e8a5-ba0c-43d5-86b5-cf91405fddc0"
   >
     <desc>
@@ -7638 +7638 @@
     <const name="None"                    value="0">
       <desc>No flag set.</desc>
+    </const>
+
+    <const name="WaitForProcessStartOnly" value="1">
+      <desc>Only use the specified timeout value to wait for starting the guest process - the guest
+        process itself then uses an infinite timeout.</desc>
     </const>
 
@@ -7688 +7693 @@
   <interface
      name="IGuest" extends="$unknown"
-     uuid="ed69cdce-2905-4275-872b-3c743a85c584"
+     uuid="5a4f265c-0c0e-495a-8ff6-7d68682e276b"
      wsmap="managed"
      >
@@ -7988 +7993 @@
       <param name="source" type="wstring" dir="in">
         <desc>
-          Foo.
+          Source file on the host to copy.
         </desc>
       </param>
       <param name="dest" type="wstring" dir="in">
         <desc>
-          Bar.
+          Destination path on the guest.
         </desc>
       </param>
@@ -8046 +8051 @@
           Number of bytes written.
         </desc>
+      </param>
+    </method>
+
+    <method name="updateGuestAdditions">
+      <desc>
+        Updates already installed Guest Additions in a VM
+        (Windows guests only).
+
+        <result name="VBOX_E_IPRT_ERROR">
+          Error while updating.
+        </result>
+
+      </desc>
+      <param name="source" type="wstring" dir="in">
+        <desc>
+          Path to the Guest Additions .ISO file to use for the upate.
+        </desc>
+      </param>
+      <param name="progress" type="IProgress" dir="return">
+        <desc>Progress object to track the operation completion.</desc>
       </param>
     </method>

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

@@ -105 +105 @@
                                      ULONG *aMemTotal, ULONG *aMemFree, ULONG *aMemBalloon, ULONG *aMemShared, ULONG *aMemCache,
                                      ULONG *aPageTotal, ULONG *aMemAllocTotal, ULONG *aMemFreeTotal, ULONG *aMemBalloonTotal, ULONG *aMemSharedTotal);
+    STDMETHOD(UpdateGuestAdditions)(IN_BSTR aSource, IProgress **aProgress);
 
     // Public methods that are not in IDL (only called internally).
+    HRESULT executeProcessInternal(Bstr aCommand, ULONG aFlags,
+                                   ComSafeArrayIn(Bstr, aArguments), ComSafeArrayIn(Bstr, aEnvironment),
+                                   Bstr aUserName, Bstr aPassword,
+                                   ULONG aTimeoutMS, ULONG *aPID, IProgress **aProgress);
     void setAdditionsInfo(Bstr aInterfaceVersion, VBOXOSTYPE aOsType);
     void setAdditionsInfo2(Bstr aAdditionsVersion, Bstr aVersionName, Bstr aRevision);
@@ -113 +118 @@
     HRESULT setStatistic(ULONG aCpuId, GUESTSTATTYPE enmType, ULONG aVal);
     BOOL isPageFusionEnabled();
-
 # ifdef VBOX_WITH_GUEST_CONTROL
     /** Static callback for handling guest notifications. */
     static DECLCALLBACK(int) doGuestCtrlNotification(void *pvExtension, uint32_t u32Function, void *pvParms, uint32_t cbParms);
 # endif
+    static HRESULT setErrorStatic(HRESULT aResultCode,
+                                  const Utf8Str &aText)
+    {
+        return setErrorInternal(aResultCode, getStaticClassIID(), getStaticComponentName(), aText, false, true);
+    }
 
 private:
 
-# ifdef VBOX_WITH_GUEST_CONTROL
+    // Internal tasks
+    struct TaskGuest; /* Worker thread helper. */
+#ifdef VBOX_WITH_GUEST_CONTROL
+    HRESULT taskUpdateGuestAdditions(TaskGuest *aTask);
+
     struct CallbackContext
     {

trunk/src/VBox/Runtime/r3/isofs.cpp

@@ -333 +333 @@
                     break;
 
-                Assert(pCurRecord->name_len > 0);
+                Assert(   pCurRecord->name_len  > 0
+                       && pCurRecord->name_len <= RTISOFS_MAX_STRING_LEN);
                 char *pszName = RTStrAlloc(pCurRecord->name_len + 1);
                 AssertPtr(pszName);
                 Assert(idx + sizeof(RTISOFSDIRRECORD) < cbRead);
                 memcpy(pszName, &uBuffer[idx + sizeof(RTISOFSDIRRECORD)], pCurRecord->name_len);
+                pszName[pCurRecord->name_len] = '\0'; /* Force string termination. */
 
                 if (   pCurRecord->name_len == 1