Changeset 28557 in vbox for trunk/src/VBox/Additions/common/VBoxService

Timestamp:

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

Author:

vboxsync

Message:

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

Location:

trunk/src/VBox/Additions/common/VBoxService

Files:

• VBoxServiceControl.cpp (modified) (6 diffs)
• VBoxServiceControlExec.cpp (modified) (21 diffs)
• VBoxServiceInternal.h (modified) (3 diffs)

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