Changeset 28557 in vbox

Timestamp:

Apr 21, 2010 11:18:32 AM (15 years ago)

Author:

vboxsync

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

60367

Message:

Guest Control: Update (first stuff for piping output).

Location:

trunk

Files:

• include/VBox/HostServices/GuestControlSvc.h (modified) (6 diffs)
• include/VBox/VBoxGuestLib.h (modified) (2 diffs)
• src/VBox/Additions/common/VBoxGuestLib/VBoxGuestR3LibGuestCtrl.cpp (modified) (3 diffs)
• src/VBox/Additions/common/VBoxService/VBoxServiceControl.cpp (modified) (6 diffs)
• src/VBox/Additions/common/VBoxService/VBoxServiceControlExec.cpp (modified) (21 diffs)
• src/VBox/Additions/common/VBoxService/VBoxServiceInternal.h (modified) (3 diffs)
• src/VBox/Frontends/VBoxManage/VBoxManageGuestCtrl.cpp (modified) (3 diffs)
• src/VBox/HostServices/GuestControl/Makefile.kmk (modified) (1 diff)
• src/VBox/HostServices/GuestControl/service.cpp (modified) (8 diffs)
• src/VBox/Main/GuestImpl.cpp (modified) (6 diffs)
• src/VBox/Main/idl/VirtualBox.xidl (modified) (2 diffs)
• src/VBox/Main/include/GuestImpl.h (modified) (2 diffs)

trunk/include/VBox/HostServices/GuestControlSvc.h

@@ -98 +98 @@
     /** Size of optional data buffer (not used atm). */
     uint32_t cbData;
-
 } HOSTEXECCALLBACKDATA, *PHOSTEXECCALLBACKDATA;
 
+typedef struct _VBoxGuestCtrlExecOutCallbackData
+{
+    /** Callback data header. */
+    HOSTCCALLBACKHEADER hdr;
+    /** The process ID (PID). */
+    uint32_t u32PID;
+    /* The handle ID (stdout/stderr). */
+    uint32_t u32HandleId;
+    /** Optional flags (not used atm). */
+    uint32_t u32Flags;
+    /** Optional data buffer. */
+    void *pvData;
+    /** Size of optional data buffer. */
+    uint32_t cbData;
+} HOSTEXECOUTCALLBACKDATA, *PHOSTEXECOUTCALLBACKDATA;
+
 enum
 {
-    /** Magic number for sanity checking the HOSTEXECCALLBACKDATA structure */
-    HOSTEXECCALLBACKDATAMAGIC = 0x26011982
+    /** Magic number for sanity checking the HOSTEXECCALLBACKDATA structure. */
+    HOSTEXECCALLBACKDATAMAGIC = 0x26011982,
+    /** Magic number for sanity checking the HOSTEXECOUTCALLBACKDATA structure. */
+    HOSTEXECOUTCALLBACKDATAMAGIC = 0x11061949
 };
 
@@ -120 +137 @@
      * Sends input data for stdin to a running process executed by HOST_EXEC_CMD.
      */
-    HOST_EXEC_SEND_STDIN = 2,
+    HOST_EXEC_SET_INPUT = 2,
     /**
      * Gets the current status of a running process, e.g.
      * new data on stdout/stderr, process terminated etc.
      */
-    HOST_EXEC_GET_STATUS = 3
+    HOST_EXEC_GET_OUTPUT = 3
 };
 
@@ -141 +158 @@
      * TODO
      */
-    GUEST_EXEC_SEND_STDOUT = 3,
+    GUEST_EXEC_SEND_OUTPUT = 2,
     /**
      * TODO
      */
-    GUEST_EXEC_SEND_STDERR = 4,
-    /**
-     * TODO
-     */
-    GUEST_EXEC_SEND_STATUS = 5
+    GUEST_EXEC_SEND_STATUS = 3
 };
 
@@ -162 +175 @@
      * or starting a program.
      */
-    GETHOSTMSG_EXEC_CMD = 1,
+    GETHOSTMSG_EXEC_START_PROCESS = 1,
     /**
      * Sends input data for stdin to a running process executed by HOST_EXEC_CMD.
      */
-    GETHOSTMSG_EXEC_STDIN = 2
+    GETHOSTMSG_EXEC_SEND_INPUT = 2,
+    /**
+     * Host requests the so far collected stdout/stderr output
+     * from a running process executed by HOST_EXEC_CMD.
+     */
+    GETHOSTMSG_EXEC_GET_OUTPUT = 3
 };
 
@@ -220 +238 @@
 
 } VBoxGuestCtrlHGCMMsgExecCmd;
+
+typedef struct _VBoxGuestCtrlHGCMMsgExecOut
+{
+    VBoxGuestHGCMCallInfo hdr;
+    /** Context ID. */
+    HGCMFunctionParameter context;
+    /** The process ID (PID). */
+    HGCMFunctionParameter pid;
+    /** The pipe handle ID. */
+    HGCMFunctionParameter handle;
+    /** Optional flags. */
+    HGCMFunctionParameter flags;
+    /** Data buffer. */
+    HGCMFunctionParameter data;
+
+} VBoxGuestCtrlHGCMMsgExecOut;
 
 typedef struct _VBoxGuestCtrlHGCMMsgExecStatus
@@ -241 +275 @@
 typedef struct _VBoxGuestCtrlParamBuffer
 {
+    uint32_t uMsg;
     uint32_t uParmCount;
     VBOXHGCMSVCPARM *pParms;

trunk/include/VBox/VBoxGuestLib.h

@@ -526 +526 @@
                                                   char     *pszPassword,    uint32_t  cbPassword,
                                                   uint32_t *puTimeLimit);
+VBGLR3DECL(int) VbglR3GuestCtrlExecGetHostCmdOutput(uint32_t  u32ClientId,    uint32_t  uNumParms,
+                                                    uint32_t *puContext,      uint32_t *puPID,
+                                                    uint32_t *puHandle,       uint32_t *puFlags);
 VBGLR3DECL(int)     VbglR3GuestCtrlExecReportStatus(uint32_t  u32ClientId,
                                                     uint32_t  u32Context,
@@ -533 +536 @@
                                                     void     *pvData,
                                                     uint32_t  cbData);
+VBGLR3DECL(int)     VbglR3GuestCtrlExecSendOut(uint32_t     u32ClientId,
+                                               uint32_t     u32Context,
+                                               uint32_t     u32PID,
+                                               uint32_t     u32Handle,
+                                               uint32_t     u32Flags,
+                                               void        *pvData,
+                                               uint32_t     cbData);
 /** @}  */
 # endif /* VBOX_WITH_GUEST_CONTROL defined */

trunk/src/VBox/Additions/common/VBoxGuestLib/VBoxGuestR3LibGuestCtrl.cpp

@@ -146 +146 @@
  * @returns VBox status code.
  * @param   u32ClientId     The client id returned by VbglR3GuestCtrlConnect().
- * @param   ppvData
  * @param   uNumParms
  ** @todo Docs!
@@ -223 +222 @@
 
 
+/**
+ * Allocates and gets host data, based on the message id.
+ *
+ * This will block until data becomes available.
+ *
+ * @returns VBox status code.
+ * @param   u32ClientId     The client id returned by VbglR3GuestCtrlConnect().
+ * @param   uNumParms
+ ** @todo Docs!
+ */
+VBGLR3DECL(int) VbglR3GuestCtrlExecGetHostCmdOutput(uint32_t  u32ClientId,    uint32_t  uNumParms,
+                                                    uint32_t *puContext,      uint32_t *puPID,
+                                                    uint32_t *puHandle,       uint32_t *puFlags)
+{
+    AssertPtr(puContext);
+    AssertPtr(puPID);
+
+    VBoxGuestCtrlHGCMMsgExecOut Msg;
+
+    Msg.hdr.result = VERR_WRONG_ORDER;
+    Msg.hdr.u32ClientID = u32ClientId;
+    Msg.hdr.u32Function = GUEST_GET_HOST_MSG;
+    Msg.hdr.cParms = uNumParms;
+
+    VbglHGCMParmUInt32Set(&Msg.context, 0); /** @todo Put this some header struct! */
+    VbglHGCMParmUInt32Set(&Msg.pid, 0);
+    VbglHGCMParmUInt32Set(&Msg.handle, 0);    
+    VbglHGCMParmUInt32Set(&Msg.flags, 0);
+
+    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
+    if (RT_SUCCESS(rc))
+    {
+        int rc2 = Msg.hdr.result;
+        if (RT_FAILURE(rc2))
+        {
+            rc = rc2;
+        }
+        else
+        {
+            Msg.context.GetUInt32(puContext);
+            Msg.pid.GetUInt32(puPID);
+            Msg.handle.GetUInt32(puHandle);
+            Msg.flags.GetUInt32(puFlags);            
+        }
+    }
+    return rc;
+}
 
 
@@ -262 +308 @@
 }
 
+
+/**
+ * Sends output (from stdout/stderr) from a running process.
+ *
+ * @returns VBox status code.
+ ** @todo Docs!
+ */
+VBGLR3DECL(int) VbglR3GuestCtrlExecSendOut(uint32_t     u32ClientId,
+                                           uint32_t     u32Context,
+                                           uint32_t     u32PID,
+                                           uint32_t     u32Handle,
+                                           uint32_t     u32Flags,
+                                           void        *pvData,
+                                           uint32_t     cbData)
+{
+    VBoxGuestCtrlHGCMMsgExecOut Msg;
+
+    Msg.hdr.result = VERR_WRONG_ORDER;
+    Msg.hdr.u32ClientID = u32ClientId;
+    Msg.hdr.u32Function = GUEST_EXEC_SEND_OUTPUT;
+    Msg.hdr.cParms = 5;
+
+    VbglHGCMParmUInt32Set(&Msg.context, u32Context);
+    VbglHGCMParmUInt32Set(&Msg.pid, u32PID);
+    VbglHGCMParmUInt32Set(&Msg.handle, u32Handle);
+    VbglHGCMParmUInt32Set(&Msg.flags, u32Flags);
+    VbglHGCMParmPtrSet(&Msg.data, pvData, cbData);
+
+    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
+    if (RT_SUCCESS(rc))
+    {
+        int rc2 = Msg.hdr.result;
+        if (RT_FAILURE(rc2))
+            rc = rc2;
+    }
+    return rc;
+}
+

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

@@ -100 +100 @@
 
 
-static int VBoxServiceControlHandleCmdExec(uint32_t u32ClientId, uint32_t uNumParms)
+static int VBoxServiceControlHandleCmdStartProcess(uint32_t u32ClientId, uint32_t uNumParms)
 {
     uint32_t uContextID;
@@ -142 +142 @@
     if (RT_FAILURE(rc))
     {
-        VBoxServiceError("Control: Failed to retrieve execution command! Error: %Rrc\n", rc);
+        VBoxServiceError("Control: Failed to retrieve exec start command! Error: %Rrc\n", rc);
     }
     else
@@ -150 +150 @@
                                            szStdIn, szStdOut, szStdErr,
                                            szUser, szPassword, uTimeLimitMS);
+    }
+    return rc;
+}
+
+
+static int VBoxServiceControlHandleCmdGetOutput(uint32_t u32ClientId, uint32_t uNumParms)
+{
+    uint32_t uContextID;
+    uint32_t uPID;
+    uint32_t uHandleID;
+    uint32_t uFlags;
+
+    int rc = VbglR3GuestCtrlExecGetHostCmdOutput(u32ClientId, uNumParms,
+                                                 &uContextID, &uPID, &uHandleID, &uFlags);
+    if (RT_FAILURE(rc))
+    {
+        VBoxServiceError("Control: Failed to retrieve exec output command! Error: %Rrc\n", rc);
+    }
+    else
+    {
+        /* Let's have a look if we have a running process with PID = uPID ... */
+        PVBOXSERVICECTRLTHREAD pNode;
+        bool bFound = false;
+        RTListForEach(&g_GuestControlExecThreads, pNode, VBOXSERVICECTRLTHREAD, Node)
+        {
+            if (   pNode->fStarted 
+                && pNode->enmType == VBoxServiceCtrlThreadDataExec)
+            {
+                PVBOXSERVICECTRLTHREADDATAEXEC pData = (PVBOXSERVICECTRLTHREADDATAEXEC)pNode->pvData;
+                if (pData && pData->uPID == uPID)
+                {
+                    bFound = true;
+                    break;
+                }
+            }
+        }
+
+        if (bFound)
+        {
+            PVBOXSERVICECTRLTHREADDATAEXEC pData = (PVBOXSERVICECTRLTHREADDATAEXEC)pNode->pvData;
+            AssertPtr(pData);
+
+            uint32_t cbRead = _4K; /* Try reading 4k. */
+            BYTE *pBuf = (BYTE*)RTMemAlloc(cbRead);
+            if (pBuf)
+            {
+                rc = VBoxServiceControlExecReadPipeBufferContent(&pData->stdOut, pBuf, cbRead, &cbRead);
+                if (RT_SUCCESS(rc))
+                {    
+                    AssertPtr(pBuf);
+                    /* cbRead now contains actual size. */
+                    rc = VbglR3GuestCtrlExecSendOut(u32ClientId, uContextID, uPID, 0 /* handle ID */, 0 /* flags */,
+                                                    pBuf, cbRead);
+                }
+                RTMemFree(pBuf);
+            }
+            else
+                rc = VERR_NO_MEMORY;
+        }
+        else
+            rc = VERR_NOT_FOUND; /* PID not found! */
     }
     return rc;
@@ -176 +237 @@
         uint32_t uMsg;
         uint32_t uNumParms;
-        VBoxServiceVerbose(3, "Control: Waiting for host msg ...\n");
+        VBoxServiceVerbose(4, "Control: Waiting for host msg ...\n");
         rc = VbglR3GuestCtrlGetHostMsg(g_GuestControlSvcClientID, &uMsg, &uNumParms, 1000 /* 1s timeout */);
         if (rc == VERR_TOO_MUCH_DATA)
@@ -190 +251 @@
         if (RT_SUCCESS(rc))
         {
+            VBoxServiceVerbose(3, "Control: Msg=%u (%u parms) retrieved\n", uMsg, uNumParms);
             switch(uMsg)
             {
-                case GETHOSTMSG_EXEC_CMD:
-                    rc = VBoxServiceControlHandleCmdExec(g_GuestControlSvcClientID, uNumParms);
+                case GETHOSTMSG_EXEC_START_PROCESS:
+                    rc = VBoxServiceControlHandleCmdStartProcess(g_GuestControlSvcClientID, uNumParms);
                     break;
 
+                case GETHOSTMSG_EXEC_GET_OUTPUT:
+                    rc = VBoxServiceControlHandleCmdGetOutput(g_GuestControlSvcClientID, uNumParms);
+                    break;
+
                 default:
-                    VBoxServiceVerbose(3, "Control: Unsupported message from host! Msg=%ld\n", uMsg);
+                    VBoxServiceVerbose(3, "Control: Unsupported message from host! Msg=%u\n", uMsg);
                     /* Don't terminate here; just wait for the next message. */
                     break;
             }
+
+            if (RT_FAILURE(rc))
+                VBoxServiceVerbose(3, "Control: Message was processed with rc=%Rrc\n", rc);
         }
 
@@ -252 +321 @@
             int rc2 = RTThreadWait(pNode->Thread, 30 * 1000 /* Wait 30 seconds max. */, NULL);
             if (RT_FAILURE(rc2))
-                VBoxServiceError("Control: Thread (PID: %u) failed to stop; rc2=%Rrc\n", pNode->uPID, rc2);
-        }
-        VBoxServiceControlExecDestroyThreadData(pNode);
+                VBoxServiceError("Control: Thread failed to stop; rc2=%Rrc\n", rc2);
+        }
+
+        /* Destroy thread specific data. */
+        switch (pNode->enmType)
+        {
+            case VBoxServiceCtrlThreadDataExec:
+                VBoxServiceControlExecDestroyThreadData((PVBOXSERVICECTRLTHREADDATAEXEC)pNode->pvData);
+                break;
+
+            default:
+                break;
+        }
     }
 

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

@@ -145 +145 @@
  *
  * @returns IPRT status code from client send.
+ * @param   pThread             The thread specific data.
  * @param   hPollSet            The polling set.
  * @param   fPollEvt            The event mask returned by RTPollNoResume.
@@ -154 +155 @@
  * @todo    Put the last 4 parameters into a struct!
  */
-static int VBoxServiceControlExecProcHandleOutputEvent(RTPOLLSET hPollSet, uint32_t fPollEvt, PRTPIPE phPipeR,
+static int VBoxServiceControlExecProcHandleOutputEvent(PVBOXSERVICECTRLTHREAD pThread,
+                                                       RTPOLLSET hPollSet, uint32_t fPollEvt, PRTPIPE phPipeR,
                                                        uint32_t *puCrc32 , uint32_t uHandleId)
 {
@@ -163 +165 @@
      */
     int rc = VINF_SUCCESS;
-
-    char    abBuf[_64K];
     size_t  cbRead;
-    int     rc2 = RTPipeRead(*phPipeR, abBuf, sizeof(abBuf), &cbRead);
+    BYTE    abBuf[_64K];
+
+    AssertPtr(pThread);
+    PVBOXSERVICECTRLTHREADDATAEXEC pData = (PVBOXSERVICECTRLTHREADDATAEXEC)pThread->pvData;
+    AssertPtr(pData);
+
+    int rc2 = RTPipeRead(*phPipeR, abBuf, sizeof(abBuf), &cbRead);
     if (RT_SUCCESS(rc2) && cbRead)
     {
-        Log(("Crc32=%#x ", *puCrc32));
-
-#if 1
-            abBuf[cbRead] = '\0';
-            RTPrintf("%s: %s\n", uHandleId == 1 ? "StdOut: " : "StdErr: ", abBuf);
+#if 0
+        /* Only used for "real-time" stdout/stderr data; gets sent immediately (later)! */
+        rc = VbglR3GuestCtrlExecSendOut(pThread->uClientID, pThread->uContextID,
+                                        pData->uPID, uHandleId, 0 /* u32Flags */,
+                                        abBuf, cbRead);
 #endif
-
-        /**puCrc32 = RTCrc32Process(*puCrc32, abBuf, cbRead);
-        Log(("cbRead=%#x Crc32=%#x \n", cbRead, *puCrc32));
-        Pkt.uCrc32 = RTCrc32Finish(*puCrc32);*/
-       /* if (g_fDisplayOutput)
-        {
-            if (enmHndId == TXSEXECHNDID_STDOUT)
-                RTStrmPrintf(g_pStdErr, "%.*s", cbRead, Pkt.abBuf);
-            else if (enmHndId == TXSEXECHNDID_STDERR)
-                RTStrmPrintf(g_pStdErr, "%.*s", cbRead, Pkt.abBuf);
-        }
-
-        rc = txsReplyInternal(&Pkt.Hdr, pszOpcode, cbRead + sizeof(uint32_t));*/
-
-        /* Make sure we go another poll round in case there was too much data
-           for the buffer to hold. */
-        fPollEvt &= RTPOLL_EVT_ERROR;
+        rc = VBoxServiceControlExecWritePipeBuffer(&pData->stdOut, abBuf, cbRead);
+        if (RT_SUCCESS(rc))
+        {
+            /* Make sure we go another poll round in case there was too much data
+               for the buffer to hold. */
+            fPollEvt &= RTPOLL_EVT_ERROR;
+        }
     }
     else if (RT_FAILURE(rc2))
@@ -254 +250 @@
                                                       || hStdOutR   != NIL_RTPIPE
                                                       || hStdErrR   != NIL_RTPIPE;
-    RTMSINTERVAL const  cMsPollBase                 = hStdInW != NIL_RTPIPE
+    RTMSINTERVAL const          cMsPollBase         = hStdInW != NIL_RTPIPE
                                                       ? 100   /* need to poll for input */
                                                       : 1000; /* need only poll for process exit and aborts */
-    RTMSINTERVAL        cMsPollCur                  = 0;
+    RTMSINTERVAL                cMsPollCur          = 0;
+
+    AssertPtr(pThread);
+
+    AssertPtr(pThread);
+    PVBOXSERVICECTRLTHREADDATAEXEC pData = (PVBOXSERVICECTRLTHREADDATAEXEC)pThread->pvData;
+    AssertPtr(pData);
 
     /* Assign PID to thread data. */
-    pThread->uPID = hProcess;
+    pData->uPID = hProcess;
 
     /*
@@ -266 +268 @@
      * and that it's now OK to send input to the process.
      */
-    AssertPtr(pThread);
     VBoxServiceVerbose(3, "Control: Process started: PID=%u, CID=%u\n",
-                       pThread->uPID, pThread->uContextID);
+                       pData->uPID, pThread->uContextID);
     rc = VbglR3GuestCtrlExecReportStatus(pThread->uClientID, pThread->uContextID,
-                                         pThread->uPID, PROC_STS_STARTED, 0 /* u32Flags */,
+                                         pData->uPID, PROC_STS_STARTED, 0 /* u32Flags */,
                                          NULL /* pvData */, 0 /* cbData */);
 
@@ -299 +300 @@
 
                 case 1 /* TXSEXECHNDID_STDOUT */:
-                    rc = VBoxServiceControlExecProcHandleOutputEvent(hPollSet, fPollEvt, &hStdOutR, &uStdOutCrc32, 1 /* TXSEXECHNDID_STDOUT */);
+                    rc = VBoxServiceControlExecProcHandleOutputEvent(pThread, hPollSet, fPollEvt, &hStdOutR, &uStdOutCrc32, 1 /* TXSEXECHNDID_STDOUT */);
                     break;
 
                 case 2 /*TXSEXECHNDID_STDERR */:
-                    rc = VBoxServiceControlExecProcHandleOutputEvent(hPollSet, fPollEvt, &hStdErrR, &uStdErrCrc32, 2 /*TXSEXECHNDID_STDERR */);
+                    rc = VBoxServiceControlExecProcHandleOutputEvent(pThread, hPollSet, fPollEvt, &hStdErrR, &uStdErrCrc32, 2 /*TXSEXECHNDID_STDERR */);
                     break;
 
@@ -467 +468 @@
 
         VBoxServiceVerbose(3, "Control: Process ended: PID=%u, CID=%u, Status=%u, Flags=%u\n",
-                           pThread->uPID, pThread->uContextID, uStatus, uFlags);
+                           pData->uPID, pThread->uContextID, uStatus, uFlags);
         rc = VbglR3GuestCtrlExecReportStatus(pThread->uClientID, pThread->uContextID,
-                                             pThread->uPID, uStatus, uFlags,
+                                             pData->uPID, uStatus, uFlags,
                                              NULL /* pvData */, 0 /* cbData */);
     }
     RTMemFree(StdInBuf.pch);
-
     VBoxServiceVerbose(3, "Control: Process loop ended with rc=%Rrc\n", rc);
     return rc;
@@ -529 +529 @@
 }
 
+int VBoxServiceControlExecReadPipeBufferContent(PVBOXSERVICECTRLEXECPIPEBUF pBuf,
+                                                BYTE *pbBuffer, uint32_t cbBuffer, uint32_t *pcbToRead)
+{
+    AssertPtr(pcbToRead);
+
+// LOCKING
+
+    Assert(pBuf->cbOffset >= pBuf->cbRead);
+    if (*pcbToRead > pBuf->cbOffset - pBuf->cbRead)
+        *pcbToRead = pBuf->cbOffset - pBuf->cbRead;
+
+    if (*pcbToRead > cbBuffer)
+        *pcbToRead = cbBuffer;
+
+    if (*pcbToRead > 0)
+    {
+        memcpy(pbBuffer, pBuf->pbData + pBuf->cbRead, *pcbToRead);
+        pBuf->cbRead += *pcbToRead;
+    }
+    else
+        pbBuffer = NULL;
+    return VINF_SUCCESS;
+}
+
+int VBoxServiceControlExecWritePipeBuffer(PVBOXSERVICECTRLEXECPIPEBUF pBuf,
+                                          BYTE *pbData, uint32_t cbData)
+{
+    AssertPtr(pBuf);
+
+// LOCKING
+
+    /** @todo Use RTMemCache or RTMemObj here? */
+    BYTE *pNewBuf;
+    while (pBuf->cbSize - pBuf->cbOffset < cbData)
+    {
+        pNewBuf = (BYTE*)RTMemRealloc(pBuf->pbData, pBuf->cbSize + _4K);
+        if (pNewBuf == NULL)
+            break;
+        pBuf->cbSize += _4K;
+        pBuf->pbData = pNewBuf;
+    }
+
+    int rc = VINF_SUCCESS;
+    if (pBuf->pbData)
+    {
+        memcpy(pBuf->pbData + pBuf->cbOffset, pbData, cbData);
+        pBuf->cbOffset += cbData;
+        /** @todo Add offset clamping! */
+    }
+    else
+        rc = VERR_NO_MEMORY;
+    return rc;
+}
+
 /** Allocates and gives back a thread data struct which then can be used by the worker thread. */
 int VBoxServiceControlExecAllocateThreadData(PVBOXSERVICECTRLTHREAD pThread,
@@ -540 +594 @@
     AssertPtr(pThread);
 
+    /* General stuff. */    
     pThread->Node.pPrev = NULL;
     pThread->Node.pNext = NULL;
@@ -547 +602 @@
     pThread->fStopped = false;
 
+    pThread->uContextID = u32ContextID;
     /* ClientID will be assigned when thread is started! */
-    pThread->uContextID = u32ContextID;
-    pThread->uPID = 0; /* Don't have a PID yet. */
-    pThread->pszCmd = RTStrDup(pszCmd);
-    pThread->uFlags = uFlags;
-    pThread->uNumEnvVars = 0;
-    pThread->uNumArgs = 0; /* Initialize in case of RTGetOptArgvFromString() is failing ... */
+
+    /* Specific stuff. */
+    PVBOXSERVICECTRLTHREADDATAEXEC pData = (PVBOXSERVICECTRLTHREADDATAEXEC)RTMemAlloc(sizeof(VBOXSERVICECTRLTHREADDATAEXEC));
+    if (pData == NULL)
+        return VERR_NO_MEMORY;
+
+    pData->uPID = 0; /* Don't have a PID yet. */
+    pData->pszCmd = RTStrDup(pszCmd);
+    pData->uFlags = uFlags;
+    pData->uNumEnvVars = 0;
+    pData->uNumArgs = 0; /* Initialize in case of RTGetOptArgvFromString() is failing ... */
 
     /* Prepare argument list. */
-    int rc = RTGetOptArgvFromString(&pThread->papszArgs, (int*)&pThread->uNumArgs,
+    int rc = RTGetOptArgvFromString(&pData->papszArgs, (int*)&pData->uNumArgs,
                                     (uNumArgs > 0) ? pszArgs : "", NULL);
     /* Did we get the same result? */
-    Assert(uNumArgs == pThread->uNumArgs);
+    Assert(uNumArgs == pData->uNumArgs);
 
     if (RT_SUCCESS(rc))
@@ -566 +627 @@
         if (uNumEnvVars)
         {
-            pThread->papszEnv = (char**)RTMemAlloc(uNumEnvVars * sizeof(char*));
-            AssertPtr(pThread->papszEnv);
-            pThread->uNumEnvVars = uNumEnvVars;
+            pData->papszEnv = (char**)RTMemAlloc(uNumEnvVars * sizeof(char*));
+            AssertPtr(pData->papszEnv);
+            pData->uNumEnvVars = uNumEnvVars;
 
             const char *pcCur = pszEnv;
@@ -575 +636 @@
             while (cbLen < cbEnv)
             {
-                if (RTStrAPrintf(& pThread->papszEnv[i++], "%s", pcCur) < 0)
+                if (RTStrAPrintf(&pData->papszEnv[i++], "%s", pcCur) < 0)
                 {
                     rc = VERR_NO_MEMORY;
@@ -585 +646 @@
         }
 
-        pThread->pszStdIn = RTStrDup(pszStdIn);
-        pThread->pszStdOut = RTStrDup(pszStdOut);
-        pThread->pszStdErr = RTStrDup(pszStdErr);
-        pThread->pszUser = RTStrDup(pszUser);
-        pThread->pszPassword = RTStrDup(pszPassword);
-        pThread->uTimeLimitMS = uTimeLimitMS;
-    }
-
-    /* Adjust time limit value. */
-    pThread->uTimeLimitMS = (   (uTimeLimitMS == UINT32_MAX)
-                             || (uTimeLimitMS == 0)) ?
-                             RT_INDEFINITE_WAIT : uTimeLimitMS;
+        pData->pszStdIn = RTStrDup(pszStdIn);
+        pData->pszStdOut = RTStrDup(pszStdOut);
+        pData->pszStdErr = RTStrDup(pszStdErr);
+        pData->pszUser = RTStrDup(pszUser);
+        pData->pszPassword = RTStrDup(pszPassword);
+        pData->uTimeLimitMS = uTimeLimitMS;
+
+        /* Adjust time limit value. */
+        pData->uTimeLimitMS = (   (uTimeLimitMS == UINT32_MAX)
+                               || (uTimeLimitMS == 0)) ?
+                               RT_INDEFINITE_WAIT : uTimeLimitMS;
+
+        /* Init buffers. */
+        pData->stdOut.pbData = NULL;
+        pData->stdOut.cbSize = 0;
+        pData->stdOut.cbOffset = 0;
+        pData->stdOut.cbRead = 0;
+
+        pData->stdErr.pbData = NULL;
+        pData->stdErr.cbSize = 0;
+        pData->stdErr.cbOffset = 0;
+        pData->stdErr.cbRead = 0;
+    }
+
+    if (RT_FAILURE(rc))
+    {
+        VBoxServiceControlExecDestroyThreadData(pData);
+    }
+    else
+    {
+        pThread->enmType = VBoxServiceCtrlThreadDataExec;
+        pThread->pvData = pData;
+    }
     return rc;
 }
 
+void VBoxServiceControlExecDestroyPipeBuffer(PVBOXSERVICECTRLEXECPIPEBUF pBuf)
+{
+    if (pBuf)
+    {
+        if (pBuf->pbData)
+            RTMemFree(pBuf->pbData);
+        pBuf->pbData = NULL;
+        pBuf->cbSize = 0;
+        pBuf->cbOffset = 0;
+        pBuf->cbRead = 0;
+    }
+}
+
 /** Frees an allocated thread data structure along with all its allocated parameters. */
-void VBoxServiceControlExecDestroyThreadData(PVBOXSERVICECTRLTHREAD pThread)
+void VBoxServiceControlExecDestroyThreadData(PVBOXSERVICECTRLTHREADDATAEXEC pData)
+{
+    if (pData)
+    {    
+        RTStrFree(pData->pszCmd);
+        if (pData->uNumEnvVars)
+        {
+            for (uint32_t i = 0; i < pData->uNumEnvVars; i++)
+                RTStrFree(pData->papszEnv[i]);
+            RTMemFree(pData->papszEnv);
+        }
+        RTGetOptArgvFree(pData->papszArgs);
+        RTStrFree(pData->pszStdIn);
+        RTStrFree(pData->pszStdOut);
+        RTStrFree(pData->pszStdErr);
+        RTStrFree(pData->pszUser);
+        RTStrFree(pData->pszPassword);
+    
+        VBoxServiceControlExecDestroyPipeBuffer(&pData->stdOut);
+        VBoxServiceControlExecDestroyPipeBuffer(&pData->stdErr);
+
+        RTMemFree(pData);
+        pData = NULL;
+    }
+}
+
+DECLCALLBACK(int) VBoxServiceControlExecProcessWorker(PVBOXSERVICECTRLTHREAD pThread)
 {
     AssertPtr(pThread);
-    RTStrFree(pThread->pszCmd);
-    if (pThread->uNumEnvVars)
-    {
-        for (uint32_t i = 0; i < pThread->uNumEnvVars; i++)
-            RTStrFree(pThread->papszEnv[i]);
-        RTMemFree(pThread->papszEnv);
-    }
-    RTGetOptArgvFree(pThread->papszArgs);
-    RTStrFree(pThread->pszStdIn);
-    RTStrFree(pThread->pszStdOut);
-    RTStrFree(pThread->pszStdErr);
-    RTStrFree(pThread->pszUser);
-    RTStrFree(pThread->pszPassword);
-}
-
-DECLCALLBACK(int) VBoxServiceControlExecProcessWorker(PVBOXSERVICECTRLTHREAD pThread)
-{
-    AssertPtr(pThread);
-
-    AssertPtr(pThread);
-    AssertPtr(pThread->papszArgs);
-    AssertPtr(pThread->papszEnv);
+    PVBOXSERVICECTRLTHREADDATAEXEC pData = (PVBOXSERVICECTRLTHREADDATAEXEC)pThread->pvData;
+    AssertPtr(pData);
 
     /*
@@ -632 +733 @@
      */
     RTThreadUserSignal(RTThreadSelf());
-    VBoxServiceVerbose(3, "Control: Thread of process \"%s\" started\n", pThread->pszCmd);
+    VBoxServiceVerbose(3, "Control: Thread of process \"%s\" started\n", pData->pszCmd);
 
     int rc = VbglR3GuestCtrlConnect(&pThread->uClientID);
@@ -649 +750 @@
     {
         size_t i;
-        for (i = 0; i < pThread->uNumEnvVars; i++)
-        {
-            rc = RTEnvPutEx(hEnv, pThread->papszEnv[i]);
+        for (i = 0; i < pData->uNumEnvVars && pData->papszEnv; i++)
+        {
+            rc = RTEnvPutEx(hEnv, pData->papszEnv[i]);
             if (RT_FAILURE(rc))
                 break;
@@ -695 +796 @@
                             {
                                 RTPROCESS hProcess;
-                                rc = RTProcCreateEx(pThread->pszCmd, pThread->papszArgs, hEnv, pThread->uFlags,
+                                rc = RTProcCreateEx(pData->pszCmd, pData->papszArgs, hEnv, pData->uFlags,
                                                     phStdIn, phStdOut, phStdErr,
-                                                    strlen(pThread->pszUser) ? pThread->pszUser : NULL,
-                                                    strlen(pThread->pszUser) && strlen(pThread->pszPassword) ? pThread->pszPassword : NULL,
+                                                    strlen(pData->pszUser) ? pData->pszUser : NULL,
+                                                    strlen(pData->pszUser) && strlen(pData->pszPassword) ? pData->pszPassword : NULL,
                                                     &hProcess);
                                 if (RT_SUCCESS(rc))
@@ -714 +815 @@
                                     /* Enter the process loop. */
                                     rc = VBoxServiceControlExecProcLoop(pThread,
-                                                                        hProcess, pThread->uTimeLimitMS, hPollSet,
+                                                                        hProcess, pData->uTimeLimitMS, hPollSet,
                                                                         hStdInW, hStdOutR, hStdErrR);
 
@@ -732 +833 @@
                                 else /* Something went wrong; report error! */
                                 {
-                                    int rc2 = VbglR3GuestCtrlExecReportStatus(pThread->uClientID, pThread->uContextID, pThread->uPID,
+                                    int rc2 = VbglR3GuestCtrlExecReportStatus(pThread->uClientID, pThread->uContextID, pData->uPID,
                                                                               PROC_STS_ERROR, rc,
                                                                               NULL /* pvData */, 0 /* cbData */);
@@ -756 +857 @@
     VbglR3GuestCtrlDisconnect(pThread->uClientID);
     VBoxServiceVerbose(3, "Control: Thread of process \"%s\" (PID: %u) ended with rc=%Rrc\n",
-                       pThread->pszCmd, pThread->uPID, rc);
+                       pData->pszCmd, pData->uPID, rc);
     return rc;
 }
@@ -807 +908 @@
                 else
                 {
+                    pThread->fStarted = true;
                     /*rc =*/ RTListAppend(&g_GuestControlExecThreads, &pThread->Node);
                 }
@@ -812 +914 @@
 
             if (RT_FAILURE(rc))
-                VBoxServiceControlExecDestroyThreadData(pThread);
+                VBoxServiceControlExecDestroyThreadData((PVBOXSERVICECTRLTHREADDATAEXEC)pThread->pvData);
         }
         if (RT_FAILURE(rc))

trunk/src/VBox/Additions/common/VBoxService/VBoxServiceInternal.h

@@ -130 +130 @@
 
 #ifdef VBOX_WITH_GUEST_CONTROL
-/* Structure for holding thread relevant data. */
-typedef struct
-{
-    /** Node. */
-    RTLISTNODE                 Node;
-    /** The worker thread. */
-    RTTHREAD                   Thread;
-    /** Shutdown indicator. */
-    bool volatile              fShutdown;
-    /** Indicator set by the service thread exiting. */
-    bool volatile              fStopped;
-    /** Whether the service was started or not. */
-    bool                       fStarted;
-    /** @todo */
-    uint32_t  uClientID;
-    uint32_t  uContextID;
+enum VBOXSERVICECTRLTHREADDATATYPE
+{
+    VBoxServiceCtrlThreadDataUnknown = 0,
+    VBoxServiceCtrlThreadDataExec = 1
+};
+
+typedef struct
+{
+    BYTE     *pbData;
+    uint32_t  cbSize;
+    uint32_t  cbOffset;
+    uint32_t  cbRead;
+} VBOXSERVICECTRLEXECPIPEBUF;
+/** Pointer to thread data. */
+typedef VBOXSERVICECTRLEXECPIPEBUF *PVBOXSERVICECTRLEXECPIPEBUF;
+
+/* Structure for holding guest exection relevant data. */
+typedef struct
+{
     uint32_t  uPID;
     char     *pszCmd;
@@ -159 +162 @@
     char     *pszPassword;
     uint32_t  uTimeLimitMS;
+
+    VBOXSERVICECTRLEXECPIPEBUF stdOut;
+    VBOXSERVICECTRLEXECPIPEBUF stdErr;
+
+} VBOXSERVICECTRLTHREADDATAEXEC;
+/** Pointer to thread data. */
+typedef VBOXSERVICECTRLTHREADDATAEXEC *PVBOXSERVICECTRLTHREADDATAEXEC;
+
+/* Structure for holding thread relevant data. */
+typedef struct
+{
+    /** Node. */
+    RTLISTNODE                      Node;
+    /** The worker thread. */
+    RTTHREAD                        Thread;
+    /** Shutdown indicator. */
+    bool volatile                   fShutdown;
+    /** Indicator set by the service thread exiting. */
+    bool volatile                   fStopped;
+    /** Whether the service was started or not. */
+    bool                            fStarted;
+    /** Client ID. */
+    uint32_t                        uClientID;
+    /** Context ID. */
+    uint32_t                        uContextID;
+    /** Type of thread.  See VBOXSERVICECTRLTHREADDATATYPE for more info. */
+    VBOXSERVICECTRLTHREADDATATYPE   enmType;
+    /** Pointer to actual thread data, depending on enmType. */
+    void                           *pvData;
 } VBOXSERVICECTRLTHREAD;
 /** Pointer to thread data. */
@@ -236 +268 @@
                                          const char *pszStdIn, const char *pszStdOut, const char *pszStdErr,
                                          const char *pszUser, const char *pszPassword, uint32_t uTimeLimitMS);
-extern void VBoxServiceControlExecDestroyThreadData(PVBOXSERVICECTRLTHREAD pThread);
+extern void VBoxServiceControlExecDestroyThreadData(PVBOXSERVICECTRLTHREADDATAEXEC pThread);
+extern int VBoxServiceControlExecReadPipeBufferContent(PVBOXSERVICECTRLEXECPIPEBUF pBuf,
+                                                       BYTE *pbBuffer, uint32_t cbBuffer, uint32_t *pcbToRead);
+extern int VBoxServiceControlExecWritePipeBuffer(PVBOXSERVICECTRLEXECPIPEBUF pBuf,
+                                                 BYTE *pbData, uint32_t cbData);
 #endif
 

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

@@ -63 +63 @@
 {
     RTPrintf("VBoxManage guestcontrol     execute <vmname>|<uuid>\n"
-             "                            <path to program> [--arguments \"<arguments>\"] [--environment \"NAME=VALUE NAME=VALUE\"]\n"
+             "                            <path to program> [--arguments \"<arguments>\"] [--environment \"<NAME=VALUE NAME=VALUE>\"]\n"
              "                            [--flags <flags>] [--timeout <msec>] [--username <name> [--password <password>]]\n"
              "                            [--verbose] [--wait-for exit]\n"
@@ -187 +187 @@
                     waitForExit = true;
                 else if (!strcmp(a->argv[i + 1], "stdout"))
+                {
+                    waitForExit = true;
                     waitForStdOut = true;
+                }
                 else if (!strcmp(a->argv[i + 1], "stderr"))
+                {
+                    waitForExit = true;
                     waitForStdErr = true;
+                }
                 else
                     usageOK = false;
@@ -324 +330 @@
                             SafeArray<BYTE> aOutputData;
                             ULONG cbOutputData;
-                            CHECK_ERROR_BREAK(guest, GetProcessOutput(uPID, 0 /* aFlags */, _512K, ComSafeArrayAsOutParam(aOutputData)));
+                            CHECK_ERROR_BREAK(guest, GetProcessOutput(uPID, 0 /* aFlags */, 
+                                                                      uTimeoutMS, _64K, ComSafeArrayAsOutParam(aOutputData)));
                             cbOutputData = aOutputData.size();
                             if (cbOutputData == 0)

trunk/src/VBox/HostServices/GuestControl/Makefile.kmk

@@ -24 +24 @@
 
 # Include sub-makefile(s).
-include $(PATH_SUB_CURRENT)/testcase/Makefile.kmk
+# include $(PATH_SUB_CURRENT)/testcase/Makefile.kmk
 
 #

trunk/src/VBox/HostServices/GuestControl/service.cpp

@@ -235 +235 @@
     }
 private:
-    int paramBufferAllocate(PVBOXGUESTCTRPARAMBUFFER pBuf, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
+    int paramBufferAllocate(PVBOXGUESTCTRPARAMBUFFER pBuf, uint32_t uMsg, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
     void paramBufferFree(PVBOXGUESTCTRPARAMBUFFER pBuf);
     int paramBufferAssign(PVBOXGUESTCTRPARAMBUFFER pBuf, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
@@ -269 +269 @@
 /** @todo Write some nice doc headers! */
 /* Stores a HGCM request in an internal buffer (pEx). Needs to be freed later using execBufferFree(). */
-int Service::paramBufferAllocate(PVBOXGUESTCTRPARAMBUFFER pBuf, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
+int Service::paramBufferAllocate(PVBOXGUESTCTRPARAMBUFFER pBuf, uint32_t uMsg, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
 {
     AssertPtr(pBuf);
@@ -281 +281 @@
     if (RT_SUCCESS(rc))
     {
+        pBuf->uMsg = uMsg;
         pBuf->uParmCount = cParms;
         pBuf->pParms = (VBOXHGCMSVCPARM*)RTMemAlloc(sizeof(VBOXHGCMSVCPARM) * pBuf->uParmCount);
@@ -436 +437 @@
              if (uParmCount > cParms)
              {
-                uint32_t uCmd = 0;
-                if (uParmCount)
-                    curCmd.parmBuf.pParms[0].getUInt32(&uCmd);
-
-                 paParms[0].setUInt32(/*uCmd*/ 1); /* Message ID */
+                 paParms[0].setUInt32(curCmd.parmBuf.uMsg); /* Message ID */
                  paParms[1].setUInt32(uParmCount); /* Required parameters for message */
 
@@ -508 +505 @@
                                   (void *)(&data), sizeof(data));
     }
+    else if (   eFunction == GUEST_EXEC_SEND_OUTPUT
+             && cParms    == 5)
+    {
+        HOSTEXECOUTCALLBACKDATA data;
+        data.hdr.u32Magic = HOSTEXECOUTCALLBACKDATAMAGIC;
+        paParms[0].getUInt32(&data.hdr.u32ContextID);
+
+        paParms[1].getUInt32(&data.u32PID);
+        paParms[2].getUInt32(&data.u32HandleId);
+        paParms[3].getUInt32(&data.u32Flags);
+        paParms[4].getPointer(&data.pvData, &data.cbData);
+
+        if (mpfnHostCallback)
+            rc = mpfnHostCallback(mpvHostData, eFunction,
+                                  (void *)(&data), sizeof(data));
+    }
     else
         rc = VERR_NOT_SUPPORTED;
@@ -519 +532 @@
 
     HostCmd newCmd;
-    rc = paramBufferAllocate(&newCmd.parmBuf, cParms, paParms);
+    rc = paramBufferAllocate(&newCmd.parmBuf, eFunction, cParms, paParms);
     if (RT_SUCCESS(rc))
     {
@@ -565 +578 @@
                 break;
 
-            /* The guest notifies the host that some output at stdout is available. */
-            case GUEST_EXEC_SEND_STDOUT:
-                LogFlowFunc(("GUEST_EXEC_SEND_STDOUT\n"));
-                break;
-
-            /* The guest notifies the host that some output at stderr is available. */
-            case GUEST_EXEC_SEND_STDERR:
-                LogFlowFunc(("GUEST_EXEC_SEND_STDERR\n"));
+            /* The guest notifies the host that some output at stdout/stderr is available. */
+            case GUEST_EXEC_SEND_OUTPUT:
+                LogFlowFunc(("GUEST_EXEC_SEND_OUTPUT\n"));
+                rc = notifyHost(eFunction, cParms, paParms);
                 break;
 
@@ -621 +630 @@
 
             /* The host wants to send something to the guest's stdin pipe. */
-            case HOST_EXEC_SEND_STDIN:
-                LogFlowFunc(("HOST_EXEC_SEND_STDIN\n"));
-                break;
-
-            case HOST_EXEC_GET_STATUS:
-                LogFlowFunc(("HOST_EXEC_GET_STATUS\n"));
+            case HOST_EXEC_SET_INPUT:
+                LogFlowFunc(("HOST_EXEC_SET_INPUT\n"));
+                break;
+
+            case HOST_EXEC_GET_OUTPUT:
+                LogFlowFunc(("HOST_EXEC_GET_OUTPUT\n"));
+                rc = processCmd(eFunction, cParms, paParms);
                 break;
 

trunk/src/VBox/Main/GuestImpl.cpp

@@ -485 +485 @@
         rc = pGuest->notifyCtrlExec(u32Function, pCBData);
     }
+    else if (u32Function == GUEST_EXEC_SEND_OUTPUT)
+    {
+        LogFlowFunc(("GUEST_EXEC_SEND_OUTPUT\n"));
+
+        PHOSTEXECOUTCALLBACKDATA pCBData = reinterpret_cast<PHOSTEXECOUTCALLBACKDATA>(pvParms);
+        AssertPtr(pCBData);
+        AssertReturn(sizeof(HOSTEXECOUTCALLBACKDATA) == cbParms, VERR_INVALID_PARAMETER);
+        AssertReturn(HOSTEXECOUTCALLBACKDATAMAGIC == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
+
+        rc = pGuest->notifyCtrlExecOut(u32Function, pCBData);
+    }
     else
         rc = VERR_NOT_SUPPORTED;
@@ -498 +509 @@
 
     AssertPtr(pData);
-    CallbackListIter it = getCtrlCallbackContext(pData->hdr.u32ContextID);
+    CallbackListIter it = getCtrlCallbackContextByID(pData->hdr.u32ContextID);
     if (it != mCallbackList.end())
     {
+        Assert(!it->bCalled);
         PHOSTEXECCALLBACKDATA pCBData = (HOSTEXECCALLBACKDATA*)it->pvData;
         AssertPtr(pCBData);
@@ -555 +567 @@
         ASMAtomicWriteBool(&it->bCalled, true);
     }
+    else
+        LogFlowFunc(("Unexpected callback (magic=%u, context ID=%u) arrived\n", pData->hdr.u32Magic, pData->hdr.u32ContextID));
     LogFlowFuncLeave();
     return rc;
 }
 
-Guest::CallbackListIter Guest::getCtrlCallbackContext(uint32_t u32ContextID)
-{
+/* Notifier function for control execution stuff. */
+int Guest::notifyCtrlExecOut(uint32_t                 u32Function,
+                             PHOSTEXECOUTCALLBACKDATA pData)
+{
+    LogFlowFuncEnter();
+    int rc = VINF_SUCCESS;
+
+    AssertPtr(pData);
+    CallbackListIter it = getCtrlCallbackContextByID(pData->hdr.u32ContextID);
+    if (it != mCallbackList.end())
+    {
+        Assert(!it->bCalled);
+        PHOSTEXECOUTCALLBACKDATA pCBData = (HOSTEXECOUTCALLBACKDATA*)it->pvData;
+        AssertPtr(pCBData);
+
+        pCBData->u32PID = pData->u32PID;
+        pCBData->u32HandleId = pData->u32HandleId;
+        pCBData->u32Flags = pData->u32Flags;
+        
+        /* Allocate data buffer and copy it */
+        if (pData->cbData && pData->pvData)
+        {
+            pCBData->pvData = RTMemAlloc(pData->cbData);
+            AssertPtr(pCBData->pvData);
+            memcpy(pCBData->pvData, pData->pvData, pData->cbData);
+            pCBData->cbData = pData->cbData;
+        }
+
+        ASMAtomicWriteBool(&it->bCalled, true);
+    }
+    else
+        LogFlowFunc(("Unexpected callback (magic=%u, context ID=%u) arrived\n", pData->hdr.u32Magic, pData->hdr.u32ContextID));
+    LogFlowFuncLeave();
+    return rc;
+}
+
+Guest::CallbackListIter Guest::getCtrlCallbackContextByID(uint32_t u32ContextID)
+{
+    /** @todo Maybe use a map instead of list for fast context lookup. */
     CallbackListIter it;
     for (it = mCallbackList.begin(); it != mCallbackList.end(); it++)
     {
         if (it->mContextID == u32ContextID)
+            return (it);
+    }
+    return it;
+}
+
+Guest::CallbackListIter Guest::getCtrlCallbackContextByPID(uint32_t u32PID)
+{
+    /** @todo Maybe use a map instead of list for fast context lookup. */
+    CallbackListIter it;
+    for (it = mCallbackList.begin(); it != mCallbackList.end(); it++)
+    {
+        PHOSTEXECCALLBACKDATA pCBData = (HOSTEXECCALLBACKDATA*)it->pvData;
+        if (pCBData && pCBData->u32PID == u32PID)
             return (it);
     }
@@ -755 +819 @@
                  * get the PID.
                  */
-                CallbackListIter it = getCtrlCallbackContext(uContextID);
+                CallbackListIter it = getCtrlCallbackContextByID(uContextID);
                 uint64_t u64Started = RTTimeMilliTS();
                 do
@@ -854 +918 @@
 }
 
-STDMETHODIMP Guest::GetProcessOutput(ULONG aPID, ULONG aFlags, ULONG64 aSize, ComSafeArrayOut(BYTE, aData))
+STDMETHODIMP Guest::GetProcessOutput(ULONG aPID, ULONG aFlags, ULONG aTimeoutMS, ULONG64 aSize, ComSafeArrayOut(BYTE, aData))
 {
 #ifndef VBOX_WITH_GUEST_CONTROL
@@ -861 +925 @@
     using namespace guestControl;
 
-    NOREF(aPID);
-    NOREF(aFlags);
-    NOREF(aSize);
-    NOREF(aData);
-
     HRESULT rc = S_OK;
 
-    size_t cbData = (size_t)RT_MIN(aSize, _1K);
+    /* Search for existing PID. */
+    PHOSTEXECOUTCALLBACKDATA pData = (HOSTEXECOUTCALLBACKDATA*)RTMemAlloc(sizeof(HOSTEXECOUTCALLBACKDATA));
+    AssertPtr(pData);
+    uint32_t uContextID = addCtrlCallbackContext(pData, sizeof(HOSTEXECOUTCALLBACKDATA), NULL /* pProgress */);
+    Assert(uContextID > 0);
+
+    size_t cbData = (size_t)RT_MIN(aSize, _64K);
     com::SafeArray<BYTE> outputData(cbData);
 
-    if (FAILED(rc))
-        outputData.resize(0);
-    outputData.detachTo(ComSafeArrayOutArg(aData));
-
+    VBOXHGCMSVCPARM paParms[5];
+    int i = 0;
+    paParms[i++].setUInt32(uContextID);
+    paParms[i++].setUInt32(aPID);
+    paParms[i++].setUInt32(aFlags); /** @todo Should represent stdout and/or stderr. */
+    //paParms[i++].setPointer(outputData.raw(), aSize);
+
+    int vrc = VINF_SUCCESS;
+
+    /* Forward the information to the VMM device. */
+    AssertPtr(mParent);
+    VMMDev *vmmDev = mParent->getVMMDev();
+    if (vmmDev)
+    {
+        LogFlowFunc(("hgcmHostCall numParms=%d\n", i));
+        vrc = vmmDev->hgcmHostCall("VBoxGuestControlSvc", HOST_EXEC_GET_OUTPUT,
+                                   i, paParms);
+    }
+
+    if (RT_SUCCESS(vrc))
+    {
+        LogFlowFunc(("Waiting for HGCM callback (timeout=%ldms) ...\n", aTimeoutMS));
+
+        /*
+         * Wait for the HGCM low level callback until the process
+         * has been started (or something went wrong). This is necessary to
+         * get the PID.
+         */
+        CallbackListIter it = getCtrlCallbackContextByID(uContextID);
+        uint64_t u64Started = RTTimeMilliTS();
+        do
+        {
+            unsigned cMsWait;
+            if (aTimeoutMS == RT_INDEFINITE_WAIT)
+                cMsWait = 1000;
+            else
+            {
+                uint64_t cMsElapsed = RTTimeMilliTS() - u64Started;
+                if (cMsElapsed >= aTimeoutMS)
+                    break; /* timed out */
+                cMsWait = RT_MIN(1000, aTimeoutMS - (uint32_t)cMsElapsed);
+            }
+            RTThreadSleep(100);
+        } while (it != mCallbackList.end() && !it->bCalled);
+
+        /* Did we get some output? */
+        PHOSTEXECOUTCALLBACKDATA pData = (HOSTEXECOUTCALLBACKDATA*)it->pvData;
+        Assert(it->cbData == sizeof(HOSTEXECOUTCALLBACKDATA));
+        AssertPtr(pData);
+
+        if (   it->bCalled
+            && pData->cbData)
+        {
+            /* Do we need to resize the array? */
+            if (pData->cbData > cbData)
+                outputData.resize(pData->cbData);
+
+            /* Fill output in supplied out buffer. */  
+            memcpy(outputData.raw(), pData->pvData, pData->cbData);
+            outputData.resize(pData->cbData); /* Shrink to fit actual buffer size. */
+        }
+        else
+            vrc = VERR_NO_DATA; /* This is not an error we want to report to COM. */
+
+        if (RT_FAILURE(vrc) || FAILED(rc))
+            outputData.resize(0);
+        outputData.detachTo(ComSafeArrayOutArg(aData));
+    }
     return rc;
 #endif

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

@@ -8377 +8377 @@
   <interface
      name="IGuest" extends="$unknown"
-     uuid="419cb190-a2f1-4beb-af8d-fadc75c6ecf7"
+     uuid="4b8f90ce-e8ef-4f07-af1b-b0b85bc07e37"
      wsmap="managed"
      >
@@ -8613 +8613 @@
         </desc>
       </param>
+      <param name="timeoutMS" type="unsigned long" dir="in">
+        <desc>
+          The maximum timeout value (in msec) to wait for output
+          data. Pass 0 for an infinite timeout.
+        </desc>
+      </param>     
       <param name="size" type="unsigned long long" dir="in">
         <desc>

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

@@ -97 +97 @@
                               IN_BSTR aUserName, IN_BSTR aPassword,
                               ULONG aTimeoutMS, ULONG* aPID, IProgress **aProgress);
-    STDMETHOD(GetProcessOutput)(ULONG aPID, ULONG aFlags, ULONG64 aSize, ComSafeArrayOut(BYTE, aData));
+    STDMETHOD(GetProcessOutput)(ULONG aPID, ULONG aFlags, ULONG aTimeoutMS, ULONG64 aSize, ComSafeArrayOut(BYTE, aData));
     STDMETHOD(InternalGetStatistics)(ULONG *aCpuUser, ULONG *aCpuKernel, ULONG *aCpuIdle,
                                      ULONG *aMemTotal, ULONG *aMemFree, ULONG *aMemBalloon, ULONG *aMemCache,
@@ -140 +140 @@
     /** Handler for guest execution control notifications. */
     int notifyCtrlExec(uint32_t u32Function, PHOSTEXECCALLBACKDATA pData);
-    CallbackListIter getCtrlCallbackContext(uint32_t u32ContextID);
+    int notifyCtrlExecOut(uint32_t u32Function, PHOSTEXECOUTCALLBACKDATA pData);
+    CallbackListIter getCtrlCallbackContextByID(uint32_t u32ContextID);
+    CallbackListIter getCtrlCallbackContextByPID(uint32_t u32PID);
     void removeCtrlCallbackContext(CallbackListIter it);
     uint32_t addCtrlCallbackContext(void *pvData, uint32_t cbData, Progress* pProgress);