Changeset 38290 in vbox

Timestamp:

Aug 3, 2011 9:22:12 AM (13 years ago)

Author:

vboxsync

Message:

GuestCtrl: Update.

Location:

trunk/src/VBox

Files:

• Additions/WINNT/VBoxGINA/Helper.cpp (modified) (2 diffs)
• Additions/WINNT/VBoxGINA/Makefile.kmk (modified) (1 diff)
• Additions/WINNT/VBoxGINA/VBoxGINA.cpp (modified) (1 diff)
• Frontends/VBoxManage/VBoxManageGuestCtrl.cpp (modified) (1 diff)
• Main/Makefile.kmk (modified) (1 diff)
• Main/include/GuestCtrlImplPrivate.h (modified) (2 diffs)
• Main/include/GuestDirEntryImpl.h (added)
• Main/include/GuestImpl.h (modified) (4 diffs)
• Main/src-client/GuestCtrlImpl.cpp (modified) (4 diffs)
• Main/src-client/GuestCtrlImplDir.cpp (modified) (4 diffs)
• Main/src-client/GuestCtrlImplFile.cpp (modified) (1 diff)
• Main/src-client/GuestCtrlImplTasks.cpp (modified) (1 diff)
• Main/src-client/GuestDirEntryImpl.cpp (added)

trunk/src/VBox/Additions/WINNT/VBoxGINA/Helper.cpp

@@ -17 +17 @@
 
 #include <windows.h>
+#ifndef TARGET_NT4
+# include <Wtsapi32.h>
+#endif
 #include "winwlx.h"
 #include "Helper.h"
@@ -59 +62 @@
 bool isRemoteSession(void)
 {
-    return (0 != GetSystemMetrics(SM_REMOTESESSION)) ? true : false;
+    bool fIsRemote = false;
+
+#if 0
+#ifndef TARGET_NT4
+    WTS_SESSION_INFO *pSessionInfo = NULL;
+    DWORD dwSessions;
+    if (WTSEnumerateSessions(WTS_CURRENT_SERVER_HANDLE,
+                             0 /* Reserved */,
+                             1 /* Version */,
+                             &pSessionInfo,
+                             &dwSessions))
+    {
+        DWORD dwRemoteSessions = 0;
+        for (DWORD i = 0; i < dwSessions; i++)
+        {
+            switch (pSessionInfo[i].State)
+            {
+                case WTSConnected:
+                case WTSActive:
+                {
+                    LPTSTR pBuffer;
+                    DWORD cbBuffer;
+                    if (  WTSQuerySessionInformation(WTS_CURRENT_SERVER_HANDLE,
+                                                     pSessionInfo[i].SessionId,
+                                                     WTSClientProtocolType,
+                                                     &pBuffer, &cbBuffer)
+                        && pBuffer
+                        && cbBuffer)
+                    {
+                        USHORT uProto = (USHORT)(pBuffer);
+                        /* Only count RDP sessions -- these are the ones we're
+                         * interested in here. */
+                        if (uProto == WTS_PROTOCOL_TYPE_RDP)
+                            dwRemoteSessions++;
+                        WTSFreeMemory(pBuffer);
+#ifndef DEBUG
+                        if (dwRemoteSessions) /* Bail out as soon as possible. */
+                            break;
+#endif
+                    }
+                    break;
+                }
+
+                default:
+                    break;
+            }
+        }
+
+#ifdef DEBUG
+        Log(("VBoxGINA: %s connections detected\n",
+             dwRemoteSessions ? "RDP" : "No RDP"));
+#endif
+        if (pSessionInfo)
+            WTSFreeMemory(pSessionInfo);
+
+        if (dwSessions)
+            fIsRemote = true;
+    }
+#endif
+#else
+    LPTSTR pBuffer;
+    DWORD cbBuffer;
+    if (  WTSQuerySessionInformation(WTS_CURRENT_SERVER_HANDLE,
+                                     WTS_CURRENT_SESSION,
+                                     WTSClientProtocolType,
+                                     &pBuffer, &cbBuffer)
+        && pBuffer
+        && cbBuffer)
+    {
+        USHORT uProto = (USHORT)(pBuffer);
+        /* Only count RDP sessions -- these are the ones we're
+         * interested in here. */
+        fIsRemote = uProto == WTS_PROTOCOL_TYPE_RDP;
+        WTSFreeMemory(pBuffer);
+    }
+    else
+        Log(("VBoxGINA: Error %ld querying session information\n",
+             GetLastError()));
+#endif
+
+#ifdef DEBUG
+    Log(("VBoxGINA: Is remote session: %s\n",
+         fIsRemote ? "Yes" : "No"));
+#endif
+    return fIsRemote;
 }
 

trunk/src/VBox/Additions/WINNT/VBoxGINA/Makefile.kmk

@@ -31 +31 @@
         $(VBOX_LIB_IPRT_GUEST_R3) \
         $(VBOX_LIB_VBGL_R3)
+ifndef TARGET_NT4
+ VBoxGINA_LIBS   += \
+        WtsApi32.lib
+endif
 
 include $(KBUILD_PATH)/subfooter.kmk

trunk/src/VBox/Additions/WINNT/VBoxGINA/VBoxGINA.cpp

@@ -107 +107 @@
     HINSTANCE hDll;
 
-#ifdef DEBUG
-    /* enable full log output */
-    RTLogGroupSettings(RTLogDefaultInstance(), "all=~0");
+#ifdef DEBUG_andy
+    /* Enable full log output. */
+    RTLogGroupSettings(RTLogRelDefaultInstance(), "+default.e.l.f.l2.l3");
 #endif
 

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

@@ -1204 +1204 @@
         rc = RTPathAppend(szCurDir, sizeof(szCurDir), pszSubDir);
 
+    if (RT_FAILURE(rc))
+        return rc;
+
     /* Flag indicating whether the current directory was created on the
      * target or not. */

trunk/src/VBox/Main/Makefile.kmk

@@ -677 +677 @@
 ifdef VBOX_WITH_GUEST_CONTROL
 VBoxC_SOURCES += \
-        src-client/GuestCtrlImplTasks.cpp
+        src-client/GuestCtrlImplTasks.cpp \
+        src-client/GuestDirEntryImpl.cpp
 endif
 

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

@@ -37 +37 @@
 
 /** Structure representing the "value" side of a "key=value" pair. */
-typedef struct VBOXGUESTCTRL_STREAM_PAIR
+typedef struct VBOXGUESTCTRL_STREAMPAIR
 {
     char *pszValue;
-} VBOXGUESTCTRL_STREAM_PAIR, *PVBOXGUESTCTRL_STREAM_PAIR;
+} VBOXGUESTCTRL_STREAMPAIR, *PVBOXGUESTCTRL_STREAM_PAIR;
 
 /** Map containing "key=value" pairs of a guest process stream. */
-typedef std::map< Utf8Str, VBOXGUESTCTRL_STREAM_PAIR > GuestCtrlStreamPairs;
-typedef std::map< Utf8Str, VBOXGUESTCTRL_STREAM_PAIR >::iterator GuestCtrlStreamPairsIter;
-typedef std::map< Utf8Str, VBOXGUESTCTRL_STREAM_PAIR >::const_iterator GuestCtrlStreamPairsIterConst;
+typedef std::map< Utf8Str, VBOXGUESTCTRL_STREAMPAIR > GuestCtrlStreamPairs;
+typedef std::map< Utf8Str, VBOXGUESTCTRL_STREAMPAIR >::iterator GuestCtrlStreamPairsIter;
+typedef std::map< Utf8Str, VBOXGUESTCTRL_STREAMPAIR >::const_iterator GuestCtrlStreamPairsIterConst;
 
 /**
@@ -90 +90 @@
 /**
  * Class for parsing machine-readable guest process output by VBoxService'
- * toolbox commands ("vbox_ls", "vbox_stat" etc).
+ * toolbox commands ("vbox_ls", "vbox_stat" etc), aka "guest stream".
  */
 class GuestProcessStream

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

@@ -141 +141 @@
                                   IN_BSTR aUsername, IN_BSTR aPassword,
                                   IProgress **aProgress, ULONG *aPID);
-    HRESULT executeCollectOutput(ULONG aPID, GuestCtrlStreamObjects &streamObjects);
     HRESULT executeProcessInternal(IN_BSTR aCommand, ULONG aFlags,
                                    ComSafeArrayIn(IN_BSTR, aArguments), ComSafeArrayIn(IN_BSTR, aEnvironment),
                                    IN_BSTR aUsername, IN_BSTR aPassword,
                                    ULONG aTimeoutMS, ULONG *aPID, IProgress **aProgress, int *pRC);
+    HRESULT executeProcessResult(const char *pszCommand, const char *pszUser, ULONG ulTimeout, PCALLBACKDATAEXECSTATUS pExecStatus, ULONG *puPID);
+    HRESULT executeStreamCollectBlock(ULONG aPID,
+                                      GuestProcessStream &stream, GuestProcessStreamBlock &streamBlock);
+    HRESULT executeStreamCollectOutput(ULONG aPID, GuestCtrlStreamObjects &streamObjects);
+    HRESULT executeWaitForStatusChange(ULONG uPID, ULONG uTimeoutMS, ExecuteProcessStatus_T *pRetStatus, ULONG *puRetExitCode);
     HRESULT fileExistsInternal(IN_BSTR aFile, IN_BSTR aUsername, IN_BSTR aPassword, BOOL *aExists, int *pRC);
     HRESULT fileQuerySizeInternal(IN_BSTR aFile, IN_BSTR aUsername, IN_BSTR aPassword, LONG64 *aSize, int *pRC);
@@ -215 +219 @@
     typedef struct VBOXGUESTCTRL_DIRECTORY
     {
-        char    *mpszDirectory;
-        char    *mpszFilter;
-        ULONG    mFlags;
+        char                       *mpszDirectory;
+        char                       *mpszFilter;
+        ULONG                       mFlags;
         /** Associated PID of started vbox_ls tool. */
-        uint32_t mPID;
-        /** Offset within the current retrieved stdout buffer. */
-        uint64_t mOffset;
+        uint32_t                    mPID;
+        GuestProcessStream          mStream;
+#if 0
+        /** Next enetry in our stream objects vector
+         *  to process. */
+        uint32_t                    mNextEntry;
+        /** The guest stream object containing all */
+        GuestCtrlStreamObjects      mStream;
+#endif
     } VBOXGUESTCTRL_DIRECTORY, *PVBOXGUESTCTRL_DIRECTORY;
     typedef std::map< uint32_t, VBOXGUESTCTRL_DIRECTORY > GuestDirectoryMap;
@@ -230 +240 @@
     void directoryDestroyHandle(uint32_t uHandle);
     uint32_t directoryGetPID(uint32_t uHandle);
+    int directoryGetNextEntry(uint32_t uHandle, GuestProcessStreamBlock &streamBlock);
     bool directoryHandleExists(uint32_t uHandle);
 
@@ -240 +251 @@
     HRESULT handleErrorCompletion(int rc);
     HRESULT handleErrorHGCM(int rc);
-
-    HRESULT waitForProcessStatusChange(ULONG uPID, ExecuteProcessStatus_T *pRetStatus, ULONG *puRetExitCode, ULONG uTimeoutMS);
-    HRESULT executeProcessResult(const char *pszCommand, const char *pszUser, ULONG ulTimeout, PCALLBACKDATAEXECSTATUS pExecStatus, ULONG *puPID);
 # endif
 

trunk/src/VBox/Main/src-client/GuestCtrlImpl.cpp

@@ -972 +972 @@
     return hRC;
 }
-
-HRESULT Guest::waitForProcessStatusChange(ULONG uPID, ExecuteProcessStatus_T *pRetStatus, ULONG *puRetExitCode, ULONG uTimeoutMS)
-{
-    AssertPtr(pRetStatus);
-    AssertPtr(puRetExitCode);
-
-    if (uTimeoutMS == 0)
-        uTimeoutMS = UINT32_MAX;
-
-    uint64_t u64StartMS = RTTimeMilliTS();
-
-    HRESULT hRC;
-    ULONG uRetFlagsIgnored;
-    do
-    {
-        /*
-         * Do some busy waiting within the specified time period (if any).
-         */
-        if (   uTimeoutMS != UINT32_MAX
-            && RTTimeMilliTS() - u64StartMS > uTimeoutMS)
-        {
-            hRC = setError(VBOX_E_IPRT_ERROR,
-                           tr("The process (PID %u) did not change its status within time (%ums)"),
-                           uPID, uTimeoutMS);
-            break;
-        }
-        hRC = GetProcessStatus(uPID, puRetExitCode, &uRetFlagsIgnored, pRetStatus);
-        if (FAILED(hRC))
-            break;
-        RTThreadSleep(100);
-    } while(*pRetStatus == ExecuteProcessStatus_Started && SUCCEEDED(hRC));
-    return hRC;
+#endif /* VBOX_WITH_GUEST_CONTROL */
+
+STDMETHODIMP Guest::ExecuteProcess(IN_BSTR aCommand, ULONG aFlags,
+                                   ComSafeArrayIn(IN_BSTR, aArguments), ComSafeArrayIn(IN_BSTR, aEnvironment),
+                                   IN_BSTR aUsername, IN_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;
+
+    CheckComArgStrNotEmptyOrNull(aCommand);
+    CheckComArgOutPointerValid(aPID);
+    CheckComArgOutPointerValid(aProgress);
+
+    /* Do not allow anonymous executions (with system rights). */
+    if (RT_UNLIKELY((aUsername) == NULL || *(aUsername) == '\0'))
+        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, ComSafeArrayInArg(aArguments),
+                                  ComSafeArrayInArg(aEnvironment),
+                                  aUsername, aPassword, aTimeoutMS, aPID, aProgress, NULL /* rc */);
+#endif
+}
+
+#ifdef VBOX_WITH_GUEST_CONTROL
+/**
+ * Executes and waits for an internal tool (that is, a tool which is integrated into
+ * VBoxService, beginning with "vbox_" (e.g. "vbox_ls")) to finish its operation.
+ *
+ * @return  HRESULT
+ * @param   aTool                   Name of tool to execute.
+ * @param   aDescription            Friendly description of the operation.
+ * @param   aFlags                  Execution flags.
+ * @param   aUsername               Username to execute tool under.
+ * @param   aPassword               The user's password.
+ * @param   aProgress               Pointer which receives the tool's progress object. Optional.
+ * @param   aPID                    Pointer which receives the tool's PID. Optional.
+ */
+HRESULT Guest::executeAndWaitForTool(IN_BSTR aTool, IN_BSTR aDescription,
+                                     ComSafeArrayIn(IN_BSTR, aArguments), ComSafeArrayIn(IN_BSTR, aEnvironment),
+                                     IN_BSTR aUsername, IN_BSTR aPassword,
+                                     IProgress **aProgress, ULONG *aPID)
+{
+    ComPtr<IProgress> progressTool;
+    ULONG uPID;
+
+    HRESULT rc = this->ExecuteProcess(aTool,
+                                      ExecuteProcessFlag_Hidden,
+                                      ComSafeArrayInArg(aArguments),
+                                      ComSafeArrayInArg(aEnvironment),
+                                      aUsername, aPassword,
+                                      5 * 1000 /* Wait 5s for getting the process started. */,
+                                      &uPID, progressTool.asOutParam());
+    if (SUCCEEDED(rc))
+    {
+        /* Wait for process to exit ... */
+        rc = progressTool->WaitForCompletion(-1);
+        if (FAILED(rc)) return rc;
+
+        BOOL fCompleted = FALSE;
+        BOOL fCanceled = FALSE;
+        progressTool->COMGETTER(Completed)(&fCompleted);
+        if (!fCompleted)
+            progressTool->COMGETTER(Canceled)(&fCanceled);
+
+        if (fCompleted)
+        {
+            ExecuteProcessStatus_T retStatus;
+            ULONG uRetExitCode, uRetFlags;
+            if (SUCCEEDED(rc))
+            {
+                rc = GetProcessStatus(uPID, &uRetExitCode, &uRetFlags, &retStatus);
+                if (SUCCEEDED(rc))
+                {
+                    if (!uRetExitCode)
+                    {
+                        rc = setError(VBOX_E_IPRT_ERROR,
+                                      tr("Error %u occurred while %s"),
+                                      uRetExitCode, Utf8Str(aDescription).c_str());
+                    }
+                    else
+                    {
+                        if (aProgress)
+                        {
+                            /* Return the progress to the caller. */
+                            progressTool.queryInterfaceTo(aProgress);
+                        }
+                        if (aPID)
+                            *aPID = uPID;
+                    }
+                }
+            }
+        }
+        else if (fCanceled)
+        {
+            rc = setError(VBOX_E_IPRT_ERROR,
+                          tr("%s was aborted"), aDescription);
+        }
+        else
+            AssertReleaseMsgFailed(("Operation \"%s\" neither completed nor canceled!?\n",
+                                    Utf8Str(aDescription).c_str()));
+    }
+
+    return rc;
 }
 
@@ -1090 +1169 @@
     return rc;
 }
-#endif /* VBOX_WITH_GUEST_CONTROL */
-
-STDMETHODIMP Guest::ExecuteProcess(IN_BSTR aCommand, ULONG aFlags,
-                                   ComSafeArrayIn(IN_BSTR, aArguments), ComSafeArrayIn(IN_BSTR, aEnvironment),
-                                   IN_BSTR aUsername, IN_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;
-
-    CheckComArgStrNotEmptyOrNull(aCommand);
-    CheckComArgOutPointerValid(aPID);
-    CheckComArgOutPointerValid(aProgress);
-
-    /* Do not allow anonymous executions (with system rights). */
-    if (RT_UNLIKELY((aUsername) == NULL || *(aUsername) == '\0'))
-        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, ComSafeArrayInArg(aArguments),
-                                  ComSafeArrayInArg(aEnvironment),
-                                  aUsername, aPassword, aTimeoutMS, aPID, aProgress, NULL /* rc */);
-#endif
-}
-
-#ifdef VBOX_WITH_GUEST_CONTROL
+
 /**
- * Executes and waits for an internal tool (that is, a tool which is integrated into
- * VBoxService, beginning with "vbox_" (e.g. "vbox_ls")) to finish its operation.
+ * Gets the next stream block from a formerly processed guest stream. Will return
+ * E_PENDING if not enough guest stream data was read yet, otherwise S_OK or an appropriate
+ * error.
  *
  * @return  HRESULT
- * @param   aTool                   Name of tool to execute.
- * @param   aDescription            Friendly description of the operation.
- * @param   aFlags                  Execution flags.
- * @param   aUsername               Username to execute tool under.
- * @param   aPassword               The user's password.
- * @param   aProgress               Pointer which receives the tool's progress object. Optional.
- * @param   aPID                    Pointer which receives the tool's PID. Optional.
+ * @param   aPID                    PID of process to get the next stream block from.
+ * @param   stream                  Reference to an already filled guest process stream.
+ * @param   streamBlock             Reference to a stream block which receives the parsed data.
  */
-HRESULT Guest::executeAndWaitForTool(IN_BSTR aTool, IN_BSTR aDescription,
-                                     ComSafeArrayIn(IN_BSTR, aArguments), ComSafeArrayIn(IN_BSTR, aEnvironment),
-                                     IN_BSTR aUsername, IN_BSTR aPassword,
-                                     IProgress **aProgress, ULONG *aPID)
-{
-    ComPtr<IProgress> progressTool;
-    ULONG uPID;
-
-    HRESULT rc = this->ExecuteProcess(aTool,
-                                      ExecuteProcessFlag_Hidden,
-                                      ComSafeArrayInArg(aArguments),
-                                      ComSafeArrayInArg(aEnvironment),
-                                      aUsername, aPassword,
-                                      5 * 1000 /* Wait 5s for getting the process started. */,
-                                      &uPID, progressTool.asOutParam());
-    if (SUCCEEDED(rc))
-    {
-        /* Wait for process to exit ... */
-        rc = progressTool->WaitForCompletion(-1);
-        if (FAILED(rc)) return rc;
-
-        BOOL fCompleted = FALSE;
-        BOOL fCanceled = FALSE;
-        progressTool->COMGETTER(Completed)(&fCompleted);
-        if (!fCompleted)
-            progressTool->COMGETTER(Canceled)(&fCanceled);
-
-        if (fCompleted)
-        {
-            ExecuteProcessStatus_T retStatus;
-            ULONG uRetExitCode, uRetFlags;
-            if (SUCCEEDED(rc))
-            {
-                rc = GetProcessStatus(uPID, &uRetExitCode, &uRetFlags, &retStatus);
-                if (SUCCEEDED(rc))
-                {
-                    if (!uRetExitCode)
-                    {
-                        rc = setError(VBOX_E_IPRT_ERROR,
-                                      tr("Error %u occurred while %s"),
-                                      uRetExitCode, Utf8Str(aDescription).c_str());
-                    }
-                    else
-                    {
-                        if (aProgress)
-                        {
-                            /* Return the progress to the caller. */
-                            progressTool.queryInterfaceTo(aProgress);
-                        }
-                        if (aPID)
-                            *aPID = uPID;
-                    }
-                }
-            }
-        }
-        else if (fCanceled)
-        {
-            rc = setError(VBOX_E_IPRT_ERROR,
-                          tr("%s was aborted"), aDescription);
-        }
-        else
-            AssertReleaseMsgFailed(("Operation \"%s\" neither completed nor canceled!?\n",
-                                    Utf8Str(aDescription).c_str()));
-    }
-
-    return rc;
-}
-
-HRESULT Guest::executeCollectOutput(ULONG aPID, GuestCtrlStreamObjects &streamObjects)
-{
+HRESULT Guest::executeStreamCollectBlock(ULONG aPID,
+                                         GuestProcessStream &stream, GuestProcessStreamBlock &streamBlock)
+{
+    HRESULT rc = S_OK;
+
     SafeArray<BYTE> aOutputData;
     ULONG cbOutputData = 0;
-
-    int rc = S_OK;
-    GuestProcessStream guestStream;
-
+    int vrc = VINF_SUCCESS;
     for (;;)
     {
@@ -1219 +1196 @@
             && aOutputData.size())
         {
+            int vrc = stream.AddData(aOutputData.raw(), aOutputData.size());
+            if (RT_UNLIKELY(RT_FAILURE(vrc)))
+            {
+                rc = setError(VBOX_E_IPRT_ERROR,
+                              tr("Error while adding guest output to stream buffer (%Rrc)"), vrc);
+                break;
+            }
+            else
+            {
+                /* Try to parse the stream output we gathered until now. If we still need more
+                 * data the parsing routine will tell us and we just do another poll round. */
+                vrc = stream.ParseBlock(streamBlock);
+                if (RT_SUCCESS(vrc))
+                {
+                    /* Yay, we're done! */
+                    break;
+                }
+                else if (vrc == VERR_MORE_DATA)
+                {
+                    /* We need another poll round. */
+                    continue;
+                }
+                else
+                    rc = setError(VBOX_E_IPRT_ERROR,
+                                  tr("Error while parsing guest output (%Rrc)"), vrc);
+            }
+        }
+        else /* No more output! */
+        {
+            if (vrc == VERR_MORE_DATA)
+                rc = E_PENDING; /** @todo Find a better rc! */
+            break;
+        }
+    }
+
+    return rc;
+}
+
+/**
+ * Gets output from a formerly started guest process, tries to parse all of its guest
+ * stream (as long as data is available) and returns a stream object which can contain
+ * multiple stream blocks (which in turn then can contain key=value pairs).
+ *
+ * @return  HRESULT
+ * @param   aPID                    PID of process to get/parse the output from.
+ * @param   streamObjects           Reference to a guest stream object structure for
+ *                                  storing the parsed data.
+ */
+HRESULT Guest::executeStreamCollectOutput(ULONG aPID, GuestCtrlStreamObjects &streamObjects)
+{
+    HRESULT rc = S_OK;
+
+    SafeArray<BYTE> aOutputData;
+    ULONG cbOutputData = 0;
+    GuestProcessStream guestStream;
+
+    for (;;)
+    {
+        rc = this->GetProcessOutput(aPID, ProcessOutputFlag_None,
+                                    10 * 1000 /* Timeout in ms */,
+                                    _64K, ComSafeArrayAsOutParam(aOutputData));
+        if (   SUCCEEDED(rc)
+            && aOutputData.size())
+        {
             int vrc = guestStream.AddData(aOutputData.raw(), aOutputData.size());
             if (RT_UNLIKELY(RT_FAILURE(vrc)))
+            {
                 rc = setError(VBOX_E_IPRT_ERROR,
                               tr("Error while adding guest output to stream buffer (%Rrc)"), vrc);
+                break;
+            }
         }
         else /* No more output! */
@@ -1230 +1274 @@
     if (SUCCEEDED(rc))
     {
-        GuestProcessStreamBlock curPairs;
-        int vrc = guestStream.ParseBlock(curPairs);
-        if (   RT_SUCCESS(vrc)
-            || vrc == VERR_MORE_DATA)
-        {
-            /** @todo Catch exceptions! */
-            if (curPairs.GetCount())
-                streamObjects.push_back(curPairs);
-        }
-        else
-            rc = setError(VBOX_E_IPRT_ERROR,
-                          tr("Error while parsing guest output (%Rrc)"), vrc);
+        for (;;)
+        {
+            GuestProcessStreamBlock curBlock;
+            rc = executeStreamCollectBlock(aPID,
+                                           guestStream, curBlock);
+            if (SUCCEEDED(rc))
+
+            {
+                if (curBlock.GetCount())
+                    streamObjects.push_back(curBlock);
+                else
+                    break; /* No more data. */
+            }
+            else
+            {
+                rc = setError(VBOX_E_IPRT_ERROR,
+                              tr("Error while parsing guest stream block"));
+                break;
+            }
+        }
     }
 
     return rc;
+}
+
+/**
+ * Does busy waiting on a formerly started guest process.
+ *
+ * @return  HRESULT
+ * @param   uPID                    PID of guest process to wait for.
+ * @param   uTimeoutMS              Waiting timeout (in ms). Specify 0 for an infinite timeout.
+ * @param   pRetStatus              Pointer which receives current process status after the change.
+ *                                  Optional.
+ * @param   puRetExitCode           Pointer which receives the final exit code in case of guest process
+ *                                  termination. Optional.
+ */
+HRESULT Guest::executeWaitForStatusChange(ULONG uPID, ULONG uTimeoutMS,
+                                          ExecuteProcessStatus_T *pRetStatus, ULONG *puRetExitCode)
+{
+    if (uTimeoutMS == 0)
+        uTimeoutMS = UINT32_MAX;
+
+    uint64_t u64StartMS = RTTimeMilliTS();
+
+    HRESULT hRC;
+    ULONG uExitCode, uRetFlags;
+    ExecuteProcessStatus_T curStatus;
+    hRC = GetProcessStatus(uPID, &uExitCode, &uRetFlags, &curStatus);
+    if (FAILED(hRC))
+        return hRC;
+
+    do
+    {
+        if (   uTimeoutMS != UINT32_MAX
+            && RTTimeMilliTS() - u64StartMS > uTimeoutMS)
+        {
+            hRC = setError(VBOX_E_IPRT_ERROR,
+                           tr("The process (PID %u) did not change its status within time (%ums)"),
+                           uPID, uTimeoutMS);
+            break;
+        }
+        hRC = GetProcessStatus(uPID, &uExitCode, &uRetFlags, &curStatus);
+        if (FAILED(hRC))
+            break;
+        RTThreadSleep(100);
+    } while(*pRetStatus == curStatus);
+
+    if (SUCCEEDED(hRC))
+    {
+        if (pRetStatus)
+            *pRetStatus = curStatus;
+        if (puRetExitCode)
+            *puRetExitCode = uExitCode;
+    }
+    return hRC;
 }
 

trunk/src/VBox/Main/src-client/GuestCtrlImplDir.cpp

@@ -18 +18 @@
 #include "GuestImpl.h"
 #include "GuestCtrlImplPrivate.h"
+#include "GuestDirEntryImpl.h"
 
 #include "Global.h"
@@ -210 +211 @@
         RTStrFree(it->second.mpszFilter);
 
+        /* Destroy raw guest stream buffer - not used
+         * anymore. */
+        it->second.mStream.Destroy();
+
         /* Remove callback context (not used anymore). */
         mGuestDirectoryMap.erase(it);
@@ -230 +235 @@
 
     return 0;
+}
+
+int Guest::directoryGetNextEntry(uint32_t uHandle, GuestProcessStreamBlock &streamBlock)
+{
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    GuestDirectoryMapIter it = mGuestDirectoryMap.find(uHandle);
+    if (it != mGuestDirectoryMap.end())
+    {
+        HRESULT hr = executeStreamCollectBlock(it->second.mPID,
+                                               it->second.mStream, streamBlock);
+        if (FAILED(hr))
+            return VERR_INVALID_PARAMETER; /** @todo Find better rc! */
+
+        return VINF_SUCCESS;
+    }
+
+    return VERR_NOT_FOUND;
 }
 
@@ -363 +386 @@
     using namespace guestControl;
 
-    uint32_t uPID = directoryGetPID(aHandle);
-    if (uPID)
-    {
-        SafeArray<BYTE> aOutputData;
-        ULONG cbOutputData = 0;
-
-        HRESULT rc = this->GetProcessOutput(uPID, ProcessOutputFlag_None,
-                                            30 * 1000 /* Timeout in ms */,
-                                            _64K, ComSafeArrayAsOutParam(aOutputData));
-        if (SUCCEEDED(rc))
+    CheckComArgOutPointerValid(aDirEntry);
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    HRESULT rc = S_OK;
+    try
+    {
+        GuestProcessStreamBlock streamBlock;
+        int vrc = directoryGetNextEntry(aHandle, streamBlock);
+        if (RT_SUCCESS(vrc))
         {
-
+            ComObjPtr <GuestDirEntry> pDirEntry;
+            rc = pDirEntry.createObject();
+            ComAssertComRC(rc);
+
+            rc = pDirEntry->init(this, streamBlock);
+            if (SUCCEEDED(rc))
+            {
+                pDirEntry.queryInterfaceTo(aDirEntry);
+            }
+            else
+                rc = setError(VBOX_E_IPRT_ERROR,
+                              Guest::tr("Unable to init guest directory entry"));
         }
-
-        return rc;
-    }
-
-    return setError(VBOX_E_IPRT_ERROR,
-                    Guest::tr("Directory handle is invalid"));
+        else
+            rc = setError(VBOX_E_IPRT_ERROR,
+                          Guest::tr("Directory handle is invalid"));
+    }
+    catch (std::bad_alloc &)
+    {
+        rc = E_OUTOFMEMORY;
+    }
+    return rc;
 #endif
 }

trunk/src/VBox/Main/src-client/GuestCtrlImplFile.cpp

@@ -167 +167 @@
         {
             GuestCtrlStreamObjects streamObjs;
-            rc = executeCollectOutput(uPID, streamObjs);
+            rc = executeStreamCollectOutput(uPID, streamObjs);
             if (SUCCEEDED(rc))
             {

trunk/src/VBox/Main/src-client/GuestCtrlImplTasks.cpp

@@ -356 +356 @@
                             ExecuteProcessStatus_T retStatus;
                             ULONG uRetExitCode;
-                            rc = pGuest->waitForProcessStatusChange(uPID, &retStatus, &uRetExitCode, 10 * 1000 /* 10s timeout. */);
+                            rc = pGuest->executeWaitForStatusChange(uPID, 10 * 1000 /* 10s timeout. */,
+                                                                    &retStatus, &uRetExitCode);
                             if (FAILED(rc))
                             {