Changeset 33064 in vbox

Timestamp:

Oct 12, 2010 1:20:50 PM (14 years ago)

Author:

vboxsync

Message:

Guest Execution/Copy: Added support for input handling, added more code for data copying.

Location:

trunk

Files:

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

trunk/include/VBox/HostServices/GuestControlSvc.h

@@ -108 +108 @@
     /** Optional data buffer. */
     void *pvData;
-    /** Size of optional data buffer. */
+    /** Size (in bytes) of optional data buffer. */
     uint32_t cbData;
 } CALLBACKDATAEXECOUT, *PCALLBACKDATAEXECOUT;
+
+typedef struct _VBoxGuestCtrlCallbackDataExecInStatus
+{
+    /** Callback data header. */
+    CALLBACKHEADER hdr;
+    /** The process ID (PID). */
+    uint32_t u32PID;
+    /** Optional flags (not used atm). */
+    uint32_t u32Flags;
+    /** Size (in bytes) of processed input data. */
+    uint32_t cbProcessed;
+} CALLBACKDATAEXECINSTATUS, *PCALLBACKDATAEXECINSTATUS;
 
 typedef struct _VBoxGuestCtrlCallbackDataClientDisconnected
@@ -125 +137 @@
     CALLBACKDATAMAGICEXECSTATUS = 0x26011982,
     /** Magic number for sanity checking the CALLBACKDATAEXECOUT structure. */
-    CALLBACKDATAMAGICEXECOUT = 0x11061949
+    CALLBACKDATAMAGICEXECOUT = 0x11061949,
+    /** Magic number for sanity checking the CALLBACKDATAEXECIN structure. */
+    CALLBACKDATAMAGICEXECINSTATUS = 0x19091951
 };
 
@@ -132 +146 @@
     VBOXGUESTCTRLCALLBACKTYPE_UNKNOWN = 0,
     VBOXGUESTCTRLCALLBACKTYPE_EXEC_START = 1,
-    VBOXGUESTCTRLCALLBACKTYPE_EXEC_OUTPUT = 2
+    VBOXGUESTCTRLCALLBACKTYPE_EXEC_OUTPUT = 2,
+    VBOXGUESTCTRLCALLBACKTYPE_EXEC_INPUT_STATUS = 3
 };
 
@@ -140 +155 @@
 enum eHostFn
 {
+    /**
+     * The host asks the client to cancel all pending waits and exit.
+     */
+    HOST_CANCEL_PENDING_WAITS = 0,
     /**
      * The host wants to execute something in the guest. This can be a command line
@@ -179 +198 @@
     GUEST_DISCONNECTED = 3,
     /**
-     * TODO
+     * Guests sends output from an executed process.
      */
     GUEST_EXEC_SEND_OUTPUT = 100,
     /**
-     * TODO
-     */
-    GUEST_EXEC_SEND_STATUS = 101
-};
-
-/**
- * Sub host commands.  These commands are stored as first (=0) parameter in a GUEST_GET_HOST_MSG
- * so that the guest can react dynamically to requests from the host.
- */
-enum eGetHostMsgFn
-{
-    /**
-     * Hosts wants the guest to stop waiting for new messages.
-     */
-    GETHOSTMSG_EXEC_HOST_CANCEL_WAIT = 0,
-    /**
-     * The host wants to execute something in the guest. This can be a command line
-     * or starting a program.
-     */
-    GETHOSTMSG_EXEC_START_PROCESS = 100,
-    /**
-     * Sends input data for stdin to a running process executed by HOST_EXEC_CMD.
-     */
-    GETHOSTMSG_EXEC_SEND_INPUT = 101,
-    /**
-     * Host requests the so far collected stdout/stderr output
-     * from a running process executed by HOST_EXEC_CMD.
-     */
-    GETHOSTMSG_EXEC_GET_OUTPUT = 102
+     * Guest sends a status update of an executed process to the host.
+     */
+    GUEST_EXEC_SEND_STATUS = 101,
+    /**
+     * Guests sends an input status notification to the host.
+     */
+    GUEST_EXEC_SEND_INPUT_STATUS = 102
 };
 
@@ -265 +262 @@
 } VBoxGuestCtrlHGCMMsgExecCmd;
 
+typedef struct _VBoxGuestCtrlHGCMMsgExecIn
+{
+    VBoxGuestHGCMCallInfo hdr;
+    /** Context ID. */
+    HGCMFunctionParameter context;
+    /** The process ID (PID). */
+    HGCMFunctionParameter pid;
+    /** Optional flags. */
+    HGCMFunctionParameter flags;
+    /** Data buffer. */
+    HGCMFunctionParameter data;
+    /** Actual size of data. */
+    HGCMFunctionParameter size;
+
+} VBoxGuestCtrlHGCMMsgExecIn;
+
 typedef struct _VBoxGuestCtrlHGCMMsgExecOut
 {
@@ -272 +285 @@
     /** The process ID (PID). */
     HGCMFunctionParameter pid;
-    /** The pipe handle ID. */
+    /** The pipe handle ID (stdout/stderr). */
     HGCMFunctionParameter handle;
     /** Optional flags. */
@@ -296 +309 @@
 
 } VBoxGuestCtrlHGCMMsgExecStatus;
+
+typedef struct _VBoxGuestCtrlHGCMMsgExecStatusIn
+{
+    VBoxGuestHGCMCallInfo hdr;
+    /** Context ID. */
+    HGCMFunctionParameter context;
+    /** The process ID (PID). */
+    HGCMFunctionParameter pid;
+    /** Optional flags. */
+    HGCMFunctionParameter flags;
+    /** Data written. */
+    HGCMFunctionParameter written;
+
+} VBoxGuestCtrlHGCMMsgExecStatusIn;
 #pragma pack ()
 

trunk/include/VBox/VBoxGuestLib.h

@@ -557 +557 @@
                                                   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)     VbglR3GuestCtrlExecGetHostCmdInput(uint32_t  u32ClientId,    uint32_t   uNumParms,
+                                                       uint32_t *puContext,      uint32_t  *puPID,
+                                                       uint32_t *puFlags,        void      *pvData,
+                                                       uint32_t  cbData,         uint32_t  *pcbSize);
+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,
@@ -574 +578 @@
                                                void        *pvData,
                                                uint32_t     cbData);
+VBGLR3DECL(int)     VbglR3GuestCtrlExecReportStatusIn(uint32_t     u32ClientId,
+                                                      uint32_t     u32Context,
+                                                      uint32_t     u32PID,
+                                                      uint32_t     u32Flags,
+                                                      uint32_t     cbWritten);
 /** @}  */
 # endif /* VBOX_WITH_GUEST_CONTROL defined */

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

@@ -105 +105 @@
 VBGLR3DECL(int) VbglR3GuestCtrlGetHostMsg(uint32_t u32ClientId, uint32_t *puMsg, uint32_t *puNumParms)
 {
-    AssertPtr(puMsg);
-    AssertPtr(puNumParms);
+    AssertPtrReturn(puMsg, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(puNumParms, VERR_INVALID_PARAMETER);
 
     VBoxGuestCtrlHGCMMsgType Msg;
@@ -178 +178 @@
                                               uint32_t *puTimeLimit)
 {
-    AssertPtr(puContext);
-    AssertPtr(pszCmd);
-    AssertPtr(puFlags);
-    AssertPtr(pszArgs);
-    AssertPtr(puNumArgs);
-    AssertPtr(pszEnv);
-    AssertPtr(pcbEnv);
-    AssertPtr(puNumEnvVars);
-    AssertPtr(pszUser);
-    AssertPtr(pszPassword);
-    AssertPtr(puTimeLimit);
+    AssertPtrReturn(puContext, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pszCmd, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(puFlags, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pszArgs, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(puNumArgs, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pszEnv, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pcbEnv, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(puNumEnvVars, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pszUser, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pszPassword, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(puTimeLimit, VERR_INVALID_PARAMETER);
 
     VBoxGuestCtrlHGCMMsgExecCmd Msg;
@@ -197 +197 @@
     Msg.hdr.cParms = uNumParms;
 
-    VbglHGCMParmUInt32Set(&Msg.context, 0); /** @todo Put this some header struct! */
+    VbglHGCMParmUInt32Set(&Msg.context, 0);
     VbglHGCMParmPtrSet(&Msg.cmd, pszCmd, cbCmd);
     VbglHGCMParmUInt32Set(&Msg.flags, 0);
@@ -245 +245 @@
                                                     uint32_t *puHandle,       uint32_t *puFlags)
 {
-    AssertPtr(puContext);
-    AssertPtr(puPID);
+    AssertPtrReturn(puContext, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(puPID, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(puHandle, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(puFlags, VERR_INVALID_PARAMETER);
 
     VBoxGuestCtrlHGCMMsgExecOut Msg;
@@ -255 +257 @@
     Msg.hdr.cParms = uNumParms;
 
-    VbglHGCMParmUInt32Set(&Msg.context, 0); /** @todo Put this some header struct! */
+    VbglHGCMParmUInt32Set(&Msg.context, 0);
     VbglHGCMParmUInt32Set(&Msg.pid, 0);
     VbglHGCMParmUInt32Set(&Msg.handle, 0);
@@ -274 +276 @@
             Msg.handle.GetUInt32(puHandle);
             Msg.flags.GetUInt32(puFlags);
+        }
+    }
+    return rc;
+}
+
+
+/**
+ * Retrieves the input data from host which then gets sent to the
+ * started process.
+ *
+ * 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) VbglR3GuestCtrlExecGetHostCmdInput(uint32_t  u32ClientId,    uint32_t   uNumParms,
+                                                   uint32_t *puContext,      uint32_t  *puPID,
+                                                   uint32_t *puFlags,
+                                                   void      *pvData,        uint32_t  cbData,
+                                                   uint32_t *pcbSize)
+{
+    AssertPtrReturn(puContext, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(puPID, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(puFlags, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pvData, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pcbSize, VERR_INVALID_PARAMETER);
+
+    VBoxGuestCtrlHGCMMsgExecIn 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);
+    VbglHGCMParmUInt32Set(&Msg.pid, 0);
+    VbglHGCMParmUInt32Set(&Msg.flags, 0);
+    VbglHGCMParmPtrSet(&Msg.data, pvData, cbData);
+    VbglHGCMParmUInt32Set(&Msg.size, 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.flags.GetUInt32(puFlags);
+            Msg.size.GetUInt32(pcbSize);
         }
     }
@@ -355 +413 @@
 }
 
+
+/**
+ * Reports back the input status to the host.
+ *
+ * @returns VBox status code.
+ ** @todo Docs!
+ */
+VBGLR3DECL(int) VbglR3GuestCtrlExecReportStatusIn(uint32_t     u32ClientId,
+                                                  uint32_t     u32Context,
+                                                  uint32_t     u32PID,
+                                                  uint32_t     u32Flags,
+                                                  uint32_t     cbWritten)
+{
+    VBoxGuestCtrlHGCMMsgExecStatusIn Msg;
+
+    Msg.hdr.result = VERR_WRONG_ORDER;
+    Msg.hdr.u32ClientID = u32ClientId;
+    Msg.hdr.u32Function = GUEST_EXEC_SEND_INPUT_STATUS;
+    Msg.hdr.cParms = 4;
+
+    VbglHGCMParmUInt32Set(&Msg.context, u32Context);
+    VbglHGCMParmUInt32Set(&Msg.pid, u32PID);
+    VbglHGCMParmUInt32Set(&Msg.flags, u32Flags);
+    VbglHGCMParmUInt32Set(&Msg.written, cbWritten);
+
+    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/Makefile.kmk

@@ -39 +39 @@
 ifdef VBOX_WITH_GUEST_PROPS
  VBoxService_DEFS        += VBOX_WITH_GUEST_PROPS VBOXSERVICE_VMINFO
- if1of ($(KBUILD_TARGET), win)
-  VBoxService_DEFS       += VBOXSERVICE_EXEC
- endif
 endif
 ifdef VBOX_WITH_GUEST_CONTROL

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

@@ -105 +105 @@
 
 
-static int VBoxServiceControlHandleCmdStartProcess(uint32_t u32ClientId, uint32_t uNumParms)
-{
-    uint32_t uContextID;
-    char szCmd[_1K];
-    uint32_t uFlags;
-    char szArgs[_1K];
-    uint32_t uNumArgs;
-    char szEnv[_64K];
-    uint32_t cbEnv = sizeof(szEnv);
-    uint32_t uNumEnvVars;
-    char szUser[128];
-    char szPassword[128];
-    uint32_t uTimeLimitMS;
-
-#if 0 /* for valgrind */
-    RT_ZERO(szCmd);
-    RT_ZERO(szArgs);
-    RT_ZERO(szEnv);
-    RT_ZERO(szUser);
-    RT_ZERO(szPassword);
-#endif
-
-    if (uNumParms != 11)
-        return VERR_INVALID_PARAMETER;
-
-    int rc = VbglR3GuestCtrlExecGetHostCmd(u32ClientId,
-                                           uNumParms,
-                                           &uContextID,
-                                           /* Command */
-                                           szCmd,      sizeof(szCmd),
-                                           /* Flags */
-                                           &uFlags,
-                                           /* Arguments */
-                                           szArgs,     sizeof(szArgs), &uNumArgs,
-                                           /* Environment */
-                                           szEnv, &cbEnv, &uNumEnvVars,
-                                           /* Credentials */
-                                           szUser,     sizeof(szUser),
-                                           szPassword, sizeof(szPassword),
-                                           /* Timelimit */
-                                           &uTimeLimitMS);
-    if (RT_FAILURE(rc))
-    {
-        VBoxServiceError("Control: Failed to retrieve exec start command! Error: %Rrc\n", rc);
-    }
-    else
-    {
-        rc = VBoxServiceControlExecProcess(uContextID, szCmd, uFlags, szArgs, uNumArgs,
-                                           szEnv, cbEnv, uNumEnvVars,
-                                           szUser, szPassword, uTimeLimitMS);
-    }
-
-    VBoxServiceVerbose(3, "Control: VBoxServiceControlHandleCmdStartProcess returned with %Rrc\n", rc);
-    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 fFound = false;
-        RTListForEach(&g_GuestControlExecThreads, pNode, VBOXSERVICECTRLTHREAD, Node)
-        {
-            if (   pNode->fStarted
-                && pNode->enmType == VBoxServiceCtrlThreadDataExec)
-            {
-                PVBOXSERVICECTRLTHREADDATAEXEC pData = (PVBOXSERVICECTRLTHREADDATAEXEC)pNode->pvData;
-                if (pData && pData->uPID == uPID)
-                {
-                    fFound = true;
-                    break;
-                }
-            }
-        }
-
-        if (fFound)
-        {
-            PVBOXSERVICECTRLTHREADDATAEXEC pData = (PVBOXSERVICECTRLTHREADDATAEXEC)pNode->pvData;
-            AssertPtr(pData);
-
-            const uint32_t cbSize = _4K;
-            uint32_t cbRead = cbSize;
-            uint8_t *pBuf = (uint8_t*)RTMemAlloc(cbSize);
-            if (pBuf)
-            {
-                rc = VBoxServiceControlExecReadPipeBufferContent(&pData->stdOut, pBuf, cbSize, &cbRead);
-                if (RT_SUCCESS(rc))
-                {
-                    /* 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! */
-    }
-    VBoxServiceVerbose(3, "Control: VBoxServiceControlHandleCmdGetOutput returned with %Rrc\n", rc);
-    return rc;
-}
-
-
 /** @copydoc VBOXSERVICE::pfnWorker */
 DECLCALLBACK(int) VBoxServiceControlWorker(bool volatile *pfShutdown)
@@ -263 +144 @@
             switch(uMsg)
             {
-                case GETHOSTMSG_EXEC_HOST_CANCEL_WAIT:
+                case HOST_CANCEL_PENDING_WAITS:
                     VBoxServiceVerbose(3, "Control: Host asked us to quit ...\n");
                     break;
 
-                case GETHOSTMSG_EXEC_START_PROCESS:
-                    rc = VBoxServiceControlHandleCmdStartProcess(g_GuestControlSvcClientID, uNumParms);
-                    break;
-
-                case GETHOSTMSG_EXEC_GET_OUTPUT:
-                    rc = VBoxServiceControlHandleCmdGetOutput(g_GuestControlSvcClientID, uNumParms);
+                case HOST_EXEC_CMD:
+                    rc = VBoxServiceControlExecHandleCmdStartProcess(g_GuestControlSvcClientID, uNumParms);
+                    break;
+
+                case HOST_EXEC_SET_INPUT:
+                    rc = VBoxServiceControlExecHandleCmdSetInput(g_GuestControlSvcClientID, uNumParms);
+                    break;
+
+                case HOST_EXEC_GET_OUTPUT:
+                    rc = VBoxServiceControlExecHandleCmdGetOutput(g_GuestControlSvcClientID, uNumParms);
                     break;
 
@@ -287 +172 @@
         /* Do we need to shutdown? */
         if (   *pfShutdown
-            || uMsg == GETHOSTMSG_EXEC_HOST_CANCEL_WAIT)
+            || uMsg == HOST_CANCEL_PENDING_WAITS)
         {
             rc = VINF_SUCCESS;

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

@@ -47 +47 @@
 extern RTLISTNODE g_GuestControlExecThreads;
 
+
 /**
  * Handle an error event on standard input.
  *
+ * @returns IPRT status code.
  * @param   hPollSet            The polling set.
  * @param   fPollEvt            The event mask returned by RTPollNoResume.
@@ -55 +57 @@
  * @param   pStdInBuf           The standard input buffer.
  */
-static void VBoxServiceControlExecProcHandleStdInErrorEvent(RTPOLLSET hPollSet, uint32_t fPollEvt, PRTPIPE phStdInW,
-                                                            PVBOXSERVICECTRLSTDINBUF pStdInBuf)
-{
-    int rc2;
-    if (pStdInBuf->off < pStdInBuf->cb)
-    {
-        rc2 = RTPollSetRemove(hPollSet, 4 /*TXSEXECHNDID_STDIN_WRITABLE*/);
+static int VBoxServiceControlExecProcHandleStdInErrorEvent(RTPOLLSET hPollSet, uint32_t fPollEvt, PRTPIPE phStdInW,
+                                                           PVBOXSERVICECTRLEXECPIPEBUF pStdInBuf)
+{
+    int rc = RTCritSectEnter(&pStdInBuf->CritSect);
+    if (RT_SUCCESS(rc))
+    {
+        int rc2;
+        /* If no data is to be processed anymore, remove the writable pipe from
+         * the poll set. */
+        if (pStdInBuf->cbProcessed <= pStdInBuf->cbSize)
+        {
+            rc2 = RTPollSetRemove(hPollSet, VBOXSERVICECTRLPIPEID_STDIN_WRITABLE);
+            AssertRC(rc2);
+
+            rc2 = RTPipeClose(*phStdInW);
+            AssertRC(rc2);
+            *phStdInW = NIL_RTPIPE;
+
+            /* Mark the stdin buffer as dead; we're not using it anymore. */
+            pStdInBuf->fAlive = false;
+        }
+
+        rc2 = RTPollSetRemove(hPollSet, VBOXSERVICECTRLPIPEID_STDIN_ERROR);
         AssertRC(rc2);
-    }
-
-    rc2 = RTPollSetRemove(hPollSet, 0 /*TXSEXECHNDID_STDIN*/);
-    AssertRC(rc2);
-
-    rc2 = RTPipeClose(*phStdInW);
-    AssertRC(rc2);
-    *phStdInW = NIL_RTPIPE;
-
-    RTMemFree(pStdInBuf->pch);
-    pStdInBuf->pch          = NULL;
-    pStdInBuf->off          = 0;
-    pStdInBuf->cb           = 0;
-    pStdInBuf->cbAllocated  = 0;
-    pStdInBuf->fBitBucket   = true;
+
+        rc2 = RTCritSectLeave(&pStdInBuf->CritSect);
+        if (RT_SUCCESS(rc))
+            rc = rc2;
+    }
+    return rc;
 }
 
@@ -88 +97 @@
  * @param   hStdInW             The standard input pipe.
  */
-static int VBoxServiceControlExecProcWriteStdIn(PVBOXSERVICECTRLSTDINBUF pStdInBuf, RTPIPE hStdInW)
-{
-    size_t  cbToWrite = pStdInBuf->cb - pStdInBuf->off;
-    size_t  cbWritten;
-    int     rc = RTPipeWrite(hStdInW, &pStdInBuf->pch[pStdInBuf->off], cbToWrite, &cbWritten);
+static int VBoxServiceControlExecProcWriteStdIn(PVBOXSERVICECTRLEXECPIPEBUF pStdInBuf, RTPIPE hStdInW, size_t *pcbWritten)
+{
+    AssertPtrReturn(pcbWritten, VERR_INVALID_PARAMETER);
+
+    int rc = RTCritSectEnter(&pStdInBuf->CritSect);
     if (RT_SUCCESS(rc))
     {
-        Assert(cbWritten == cbToWrite);
-        pStdInBuf->off += cbWritten;
+        size_t cbToWrite = pStdInBuf->cbSize - pStdInBuf->cbProcessed;
+        int rc = VINF_SUCCESS;
+        if (cbToWrite && pStdInBuf->fAlive)
+        {
+            rc = RTPipeWrite(hStdInW, &pStdInBuf->pbData[pStdInBuf->cbProcessed], cbToWrite, pcbWritten);
+            if (RT_SUCCESS(rc))
+            {
+                Assert(*pcbWritten <= cbToWrite);
+                pStdInBuf->cbProcessed += *pcbWritten;
+            }
+            else
+                *pcbWritten = 0;
+        }
+        else
+            rc = VERR_BAD_PIPE;
+        int rc2 = RTCritSectLeave(&pStdInBuf->CritSect);
+        if (RT_SUCCESS(rc))
+            rc = rc2;
     }
     return rc;
@@ -106 +131 @@
  * child process.
  *
+ * @returns IPRT status code.
  * @param   hPollSet            The polling set.
  * @param   fPollEvt            The event mask returned by RTPollNoResume.
@@ -111 +137 @@
  * @param   pStdInBuf           The standard input buffer.
  */
-static void VBoxServiceControlExecProcHandleStdInWritableEvent(RTPOLLSET hPollSet, uint32_t fPollEvt, PRTPIPE phStdInW,
-                                                               PVBOXSERVICECTRLSTDINBUF pStdInBuf)
-{
-    int rc;
+static int  VBoxServiceControlExecProcHandleStdInWritableEvent(RTPOLLSET hPollSet, uint32_t fPollEvt, PRTPIPE phStdInW,
+                                                               PVBOXSERVICECTRLEXECPIPEBUF pStdInBuf)
+{
+    VBoxServiceVerbose(4, "ControlExec: HandleStdInWritableEvent: fPollEvt=%#x\n", fPollEvt);
+
+    int rc = VINF_SUCCESS;
     if (!(fPollEvt & RTPOLL_EVT_ERROR))
     {
-        rc = VBoxServiceControlExecProcWriteStdIn(pStdInBuf, *phStdInW);
-        if (RT_FAILURE(rc) && rc != VERR_BAD_PIPE)
-        {
-            /** @todo do we need to do something about this error condition? */
+        size_t cbWritten;
+        rc = VBoxServiceControlExecProcWriteStdIn(pStdInBuf, *phStdInW, &cbWritten);
+        if (   RT_FAILURE(rc)
+            && rc != VERR_BAD_PIPE)
+        {
+            /** @todo Do we need to do something about this error condition? */
             AssertRC(rc);
         }
 
-        if (pStdInBuf->off < pStdInBuf->cb)
-        {
-            rc = RTPollSetRemove(hPollSet, 4 /*TXSEXECHNDID_STDIN_WRITABLE*/);
+        /* No more data to write to stdin? Then remove stdin from poll set. */
+        if (   cbWritten <= 0
+            || rc == VERR_BAD_PIPE)
+        {
+            rc = RTPollSetRemove(hPollSet, VBOXSERVICECTRLPIPEID_STDIN_WRITABLE);
             AssertRC(rc);
         }
     }
     else
-        VBoxServiceControlExecProcHandleStdInErrorEvent(hPollSet, fPollEvt, phStdInW, pStdInBuf);
+        rc = VBoxServiceControlExecProcHandleStdInErrorEvent(hPollSet, fPollEvt, phStdInW, pStdInBuf);
+    return rc;
+}
+
+
+static int VBoxServiceControlExecProcHandleInputEvent(RTPOLLSET hPollSet, uint32_t fPollEvt, PRTPIPE phStdInW,
+                                                      uint32_t uHandleId, PVBOXSERVICECTRLEXECPIPEBUF pStdInBuf)
+{
+    VBoxServiceVerbose(4, "ControlExec: HandleInputEvent: fPollEvt=%#x\n", fPollEvt);
+
+    int rc = VINF_SUCCESS;
+    if (fPollEvt & RTPOLL_EVT_ERROR)
+        rc = VBoxServiceControlExecProcHandleStdInErrorEvent(hPollSet, fPollEvt, phStdInW, pStdInBuf);
+    return rc;
 }
 
@@ -146 +191 @@
  * @param   pu32Crc             The current CRC-32 of the stream. (In/Out)
  * @param   uHandleId           The handle ID.
- * @param   pszOpcode           The opcode for the data upload.
  *
  * @todo    Put the last 4 parameters into a struct!
  */
-static int VBoxServiceControlExecProcHandleOutputEvent(PVBOXSERVICECTRLTHREAD pThread,
-                                                       RTPOLLSET hPollSet, uint32_t fPollEvt, PRTPIPE phPipeR,
-                                                       uint32_t *puCrc32 , uint32_t uHandleId)
-{
-    Log(("VBoxServiceControlExecProcHandleOutputEvent: fPollEvt=%#x\n",  fPollEvt));
+static int VBoxServiceControlExecProcHandleOutputEvent(RTPOLLSET hPollSet, uint32_t fPollEvt, PRTPIPE phPipeR,
+                                                       uint32_t uHandleId, PVBOXSERVICECTRLEXECPIPEBUF pStdOutBuf)
+{
+    VBoxServiceVerbose(4, "ControlExec: HandleOutputEvent: fPollEvt=%#x\n", fPollEvt);
 
     /*
@@ -163 +206 @@
     uint8_t abBuf[_64K];
 
-    AssertPtr(pThread);
-    PVBOXSERVICECTRLTHREADDATAEXEC pData = (PVBOXSERVICECTRLTHREADDATAEXEC)pThread->pvData;
-    AssertPtr(pData);
-
     int rc2 = RTPipeRead(*phPipeR, abBuf, sizeof(abBuf), &cbRead);
     if (RT_SUCCESS(rc2) && cbRead)
@@ -183 +222 @@
         {
 #endif
-            rc = VBoxServiceControlExecWritePipeBuffer(&pData->stdOut, abBuf, cbRead);
+            rc = VBoxServiceControlExecWritePipeBuffer(pStdOutBuf, abBuf, cbRead);
             if (RT_SUCCESS(rc))
             {
@@ -229 +268 @@
  */
 static int VBoxServiceControlExecProcHandleTransportEvent(RTPOLLSET hPollSet, uint32_t fPollEvt, uint32_t idPollHnd,
-                                                          PRTPIPE phStdInW, PVBOXSERVICECTRLSTDINBUF pStdInBuf)
-{
-
-    int rc = RTPollSetAddPipe(hPollSet, *phStdInW, RTPOLL_EVT_WRITE, 4 /*TXSEXECHNDID_STDIN_WRITABLE*/);
-
-    return rc;
+                                                          PRTPIPE phStdInW, PVBOXSERVICECTRLEXECPIPEBUF pStdInBuf)
+{
+    return 0; //RTPollSetAddPipe(hPollSet, *phStdInW, RTPOLL_EVT_WRITE, 4 /*TXSEXECHNDID_STDIN_WRITABLE*/);
 }
 
@@ -244 +280 @@
     int                         rc;
     int                         rc2;
-    VBOXSERVICECTRLSTDINBUF     StdInBuf            = { 0, 0, NULL, 0, hStdInW == NIL_RTPIPE, RTCrc32Start() };
-    uint32_t                    uStdOutCrc32        = RTCrc32Start();
-    uint32_t                    uStdErrCrc32        = uStdOutCrc32;
     uint64_t const              MsStart             = RTTimeMilliTS();
     RTPROCSTATUS                ProcessStatus       = { 254, RTPROCEXITREASON_ABEND };
@@ -253 +286 @@
     uint64_t                    MsProcessKilled     = UINT64_MAX;
     RTMSINTERVAL const          cMsPollBase         = hStdInW != NIL_RTPIPE
-                                                      ? 100   /* need to poll for input */
-                                                      : 1000; /* need only poll for process exit and aborts */
+                                                      ? 100   /* Need to poll for input. */
+                                                      : 1000; /* Need only poll for process exit and aborts. */
     RTMSINTERVAL                cMsPollCur          = 0;
 
@@ -290 +323 @@
             continue;
 
-        cMsPollCur = 0;                 /* no rest until we've checked everything. */
+        cMsPollCur = 0; /* No rest until we've checked everything. */
 
         if (RT_SUCCESS(rc2))
         {
+            VBoxServiceVerbose(4, "ControlExec: RTPollNoResume idPollHnd=%u\n", idPollHnd);
             switch (idPollHnd)
             {
-                case 0 /* TXSEXECHNDID_STDIN */:
-                    VBoxServiceControlExecProcHandleStdInErrorEvent(hPollSet, fPollEvt, &hStdInW, &StdInBuf);
+                case VBOXSERVICECTRLPIPEID_STDIN_ERROR:
+                    rc = VBoxServiceControlExecProcHandleInputEvent(hPollSet, fPollEvt, &hStdInW,
+                                                                    VBOXSERVICECTRLPIPEID_STDIN_ERROR, &pData->stdIn);
                     break;
 
-                case 1 /* TXSEXECHNDID_STDOUT */:
-                    rc = VBoxServiceControlExecProcHandleOutputEvent(pThread, hPollSet, fPollEvt, &hStdOutR, &uStdOutCrc32, 1 /* TXSEXECHNDID_STDOUT */);
+                case VBOXSERVICECTRLPIPEID_STDIN_WRITABLE:
+                    rc = VBoxServiceControlExecProcHandleStdInWritableEvent(hPollSet, fPollEvt, &hStdInW, &pData->stdIn);
                     break;
 
-                case 2 /*TXSEXECHNDID_STDERR */:
-                    rc = VBoxServiceControlExecProcHandleOutputEvent(pThread, hPollSet, fPollEvt, &hStdErrR, &uStdErrCrc32, 2 /*TXSEXECHNDID_STDERR */);
+                case VBOXSERVICECTRLPIPEID_STDOUT:
+                    rc = VBoxServiceControlExecProcHandleOutputEvent(hPollSet, fPollEvt, &hStdOutR,
+                                                                     VBOXSERVICECTRLPIPEID_STDOUT, &pData->stdOut);
                     break;
 
-                case 4 /* TXSEXECHNDID_STDIN_WRITABLE */:
-                    VBoxServiceControlExecProcHandleStdInWritableEvent(hPollSet, fPollEvt, &hStdInW, &StdInBuf);
+                case VBOXSERVICECTRLPIPEID_STDERR:
+                    rc = VBoxServiceControlExecProcHandleOutputEvent(hPollSet, fPollEvt, &hStdErrR,
+                                                                     VBOXSERVICECTRLPIPEID_STDERR, &pData->stdOut);
                     break;
 
                 default:
-                    rc = VBoxServiceControlExecProcHandleTransportEvent(hPollSet, fPollEvt, idPollHnd, &hStdInW, &StdInBuf);
+                    //rc = VBoxServiceControlExecProcHandleTransportEvent(hPollSet, fPollEvt, idPollHnd, &hStdInW, &pData->stdIn);
                     break;
             }
             if (RT_FAILURE(rc) || rc == VINF_EOF)
-                break; /* abort command, or client dead or something */
+                break; /* Abort command, or client dead or something. */
             continue;
         }
-
-        /*
-         * Check for incoming data.
-         */
 
         /*
@@ -501 +534 @@
     else
         VBoxServiceError("ControlExec: Process loop failed with rc=%Rrc\n", rc);
-    RTMemFree(StdInBuf.pch);
     return rc;
 }
@@ -510 +542 @@
  *
  * @returns IPRT status code.  No client replies made.
- * @param   pszHowTo            How to set up this standard handle.
  * @param   fd                  Which standard handle it is (0 == stdin, 1 ==
  *                              stdout, 2 == stderr).
@@ -560 +591 @@
     AssertPtr(pBuf);
 
+    /** @todo Add allocation size as function parameter! */
     pBuf->pbData = (uint8_t*)RTMemAlloc(_64K); /* Start with a 64k buffer. */
     AssertReturn(pBuf->pbData, VERR_NO_MEMORY);
+    pBuf->cbAllocated = _64K;
     pBuf->cbSize = 0;
-    pBuf->cbOffset = 0;
-    pBuf->cbRead = 0;
+    pBuf->cbProcessed = 0;
+    pBuf->fAlive = true;
 
     return RTCritSectInit(&pBuf->CritSect);
@@ -576 +609 @@
             RTMemFree(pBuf->pbData);
         pBuf->pbData = NULL;
+        pBuf->cbAllocated = 0;
         pBuf->cbSize = 0;
-        pBuf->cbOffset = 0;
-        pBuf->cbRead = 0;
-    }
+        pBuf->cbProcessed = 0;
+    }
+    pBuf->fAlive = false;
     return RTCritSectDelete(&pBuf->CritSect);
 }
@@ -592 +626 @@
     if (RT_SUCCESS(rc))
     {
-        Assert(pBuf->cbOffset >= pBuf->cbRead);
-        if (*pcbToRead > pBuf->cbOffset - pBuf->cbRead)
-            *pcbToRead = pBuf->cbOffset - pBuf->cbRead;
+        Assert(pBuf->cbSize >= pBuf->cbProcessed);
+        if (*pcbToRead > pBuf->cbSize - pBuf->cbProcessed)
+            *pcbToRead = pBuf->cbSize - pBuf->cbProcessed;
 
         if (*pcbToRead > cbBuffer)
@@ -601 +635 @@
         if (*pcbToRead > 0)
         {
-            memcpy(pbBuffer, pBuf->pbData + pBuf->cbRead, *pcbToRead);
-            pBuf->cbRead += *pcbToRead;
+            memcpy(pbBuffer, pBuf->pbData + pBuf->cbProcessed, *pcbToRead);
+            pBuf->cbProcessed += *pcbToRead;
         }
         else
@@ -622 +656 @@
     if (RT_SUCCESS(rc))
     {
-        /** @todo Use RTMemCache or RTMemObj here? */
-        uint8_t *pNewBuf;
-        while (pBuf->cbSize - pBuf->cbOffset < cbData)
-        {
-            pNewBuf = (uint8_t*)RTMemRealloc(pBuf->pbData, pBuf->cbSize + _4K);
-            if (pNewBuf == NULL)
-                break;
-            pBuf->cbSize += _4K;
-            pBuf->pbData = pNewBuf;
-        }
-
-        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;
+        if (pBuf->fAlive)
+        {
+            /** @todo Buffer size limit! 4MB */
+
+            /* Resize buffer if not enough space for storing the read in data left. */
+            uint8_t *pNewBuf;
+            while (pBuf->cbAllocated - pBuf->cbSize < cbData)
+            {
+                pNewBuf = (uint8_t*)RTMemRealloc(pBuf->pbData, pBuf->cbAllocated + _4K);
+                if (pNewBuf == NULL)
+                    break;
+                pBuf->cbAllocated += _4K;
+                pBuf->pbData = pNewBuf;
+            }
+
+            rc = VINF_SUCCESS;
+            if (pBuf->pbData)
+            {
+                memcpy(pBuf->pbData + pBuf->cbSize, pbData, cbData);
+                pBuf->cbSize += cbData;
+                /** @todo Add offset clamping! */
+            }
+            else
+                rc = VERR_NO_MEMORY;
+        }
         int rc2 = RTCritSectLeave(&pBuf->CritSect);
         if (RT_SUCCESS(rc))
@@ -731 +770 @@
         if (RT_SUCCESS(rc))
             rc = VBoxServiceControlExecInitPipeBuffer(&pData->stdErr);
+            if (RT_SUCCESS(rc))
+                rc = VBoxServiceControlExecInitPipeBuffer(&pData->stdIn);
     }
 
@@ -763 +804 @@
         VBoxServiceControlExecDestroyPipeBuffer(&pData->stdOut);
         VBoxServiceControlExecDestroyPipeBuffer(&pData->stdErr);
+        VBoxServiceControlExecDestroyPipeBuffer(&pData->stdIn);
 
         RTMemFree(pData);
@@ -852 +894 @@
             RTHANDLE    hStdIn;
             PRTHANDLE   phStdIn;
-            RTPIPE      hStdInW;
-            rc = VBoxServiceControlExecSetupPipe(0 /* stdin */, &hStdIn, &phStdIn, &hStdInW);
+            rc = VBoxServiceControlExecSetupPipe(0 /*STDIN_FILENO*/, &hStdIn, &phStdIn, &pData->pipeStdInW);
             if (RT_SUCCESS(rc))
             {
@@ -859 +900 @@
                 PRTHANDLE   phStdOut;
                 RTPIPE      hStdOutR;
-                rc = VBoxServiceControlExecSetupPipe(1 /* stdout */, &hStdOut, &phStdOut, &hStdOutR);
+                rc = VBoxServiceControlExecSetupPipe(1 /*STDOUT_FILENO*/, &hStdOut, &phStdOut, &hStdOutR);
                 if (RT_SUCCESS(rc))
                 {
@@ -865 +906 @@
                     PRTHANDLE   phStdErr;
                     RTPIPE      hStdErrR;
-                    rc = VBoxServiceControlExecSetupPipe(2 /* stderr */, &hStdErr, &phStdErr, &hStdErrR);
+                    rc = VBoxServiceControlExecSetupPipe(2 /*STDERR_FILENO*/, &hStdErr, &phStdErr, &hStdErrR);
                     if (RT_SUCCESS(rc))
                     {
@@ -876 +917 @@
                         if (RT_SUCCESS(rc))
                         {
-                            rc = RTPollSetAddPipe(hPollSet, hStdInW, RTPOLL_EVT_ERROR, 0 /* TXSEXECHNDID_STDIN */);
+                            rc = RTPollSetAddPipe(hPollSet, pData->pipeStdInW, RTPOLL_EVT_ERROR, VBOXSERVICECTRLPIPEID_STDIN_ERROR);
                             if (RT_SUCCESS(rc))
-                                rc = RTPollSetAddPipe(hPollSet, hStdOutR, RTPOLL_EVT_READ | RTPOLL_EVT_ERROR, 1 /* TXSEXECHNDID_STDOUT */);
+                                rc = RTPollSetAddPipe(hPollSet, hStdOutR, RTPOLL_EVT_READ | RTPOLL_EVT_ERROR, VBOXSERVICECTRLPIPEID_STDOUT);
                             if (RT_SUCCESS(rc))
-                                rc = RTPollSetAddPipe(hPollSet, hStdErrR, RTPOLL_EVT_READ | RTPOLL_EVT_ERROR, 2 /* TXSEXECHNDID_TESTPIPE */);
+                                rc = RTPollSetAddPipe(hPollSet, hStdErrR, RTPOLL_EVT_READ | RTPOLL_EVT_ERROR, VBOXSERVICECTRLPIPEID_STDERR);
+                            if (RT_SUCCESS(rc))
+                                rc = RTPollSetAddPipe(hPollSet, pData->pipeStdInW, RTPOLL_EVT_WRITE, VBOXSERVICECTRLPIPEID_STDIN_WRITABLE);
                             if (RT_SUCCESS(rc))
                             {
@@ -915 +958 @@
                                     rc = VBoxServiceControlExecProcLoop(pThread,
                                                                         hProcess, pData->uTimeLimitMS, hPollSet,
-                                                                        hStdInW, hStdOutR, hStdErrR);
+                                                                        pData->pipeStdInW, hStdOutR, hStdErrR);
 
                                     /*
@@ -924 +967 @@
                                      */
                                     if (RT_FAILURE(RTPollSetQueryHandle(hPollSet, 0 /* stdin */, NULL)))
-                                        hStdInW = NIL_RTPIPE;
+                                        pData->pipeStdInW = NIL_RTPIPE;
                                     if (RT_FAILURE(RTPollSetQueryHandle(hPollSet, 1 /* stdout */, NULL)))
                                         hStdOutR = NIL_RTPIPE;
@@ -943 +986 @@
                                 }
                             }
+                            RTPollSetDestroy(hPollSet);
                         }
                         RTPipeClose(hStdErrR);
@@ -950 +994 @@
                     RTHandleClose(phStdOut);
                 }
-                RTPipeClose(hStdInW);
+                RTPipeClose(pData->pipeStdInW);
                 RTHandleClose(phStdIn);
             }
@@ -968 +1012 @@
         RTThreadUserSignal(RTThreadSelf());
     return rc;
+}
+
+PVBOXSERVICECTRLTHREAD VBoxServiceControlExecFindProcess(uint32_t uPID)
+{
+    PVBOXSERVICECTRLTHREAD pNode;
+    bool fFound = false;
+    RTListForEach(&g_GuestControlExecThreads, pNode, VBOXSERVICECTRLTHREAD, Node)
+    {
+        if (   pNode->fStarted
+            && pNode->enmType == VBoxServiceCtrlThreadDataExec)
+        {
+            PVBOXSERVICECTRLTHREADDATAEXEC pData = (PVBOXSERVICECTRLTHREADDATAEXEC)pNode->pvData;
+            if (pData && pData->uPID == uPID)
+            {
+                return pNode;
+            }
+        }
+    }
+    return NULL;
 }
 
@@ -1033 +1096 @@
 }
 
+
+/**
+ *
+ *
+ * @return  int
+ *
+ * @param   u32ClientId
+ * @param   uNumParms
+ */
+int VBoxServiceControlExecHandleCmdStartProcess(uint32_t u32ClientId, uint32_t uNumParms)
+{
+    uint32_t uContextID;
+    char szCmd[_1K];
+    uint32_t uFlags;
+    char szArgs[_1K];
+    uint32_t uNumArgs;
+    char szEnv[_64K];
+    uint32_t cbEnv = sizeof(szEnv);
+    uint32_t uNumEnvVars;
+    char szUser[128];
+    char szPassword[128];
+    uint32_t uTimeLimitMS;
+
+#if 0 /* for valgrind */
+    RT_ZERO(szCmd);
+    RT_ZERO(szArgs);
+    RT_ZERO(szEnv);
+    RT_ZERO(szUser);
+    RT_ZERO(szPassword);
+#endif
+
+    if (uNumParms != 11)
+        return VERR_INVALID_PARAMETER;
+
+    int rc = VbglR3GuestCtrlExecGetHostCmd(u32ClientId,
+                                           uNumParms,
+                                           &uContextID,
+                                           /* Command */
+                                           szCmd,      sizeof(szCmd),
+                                           /* Flags */
+                                           &uFlags,
+                                           /* Arguments */
+                                           szArgs,     sizeof(szArgs), &uNumArgs,
+                                           /* Environment */
+                                           szEnv, &cbEnv, &uNumEnvVars,
+                                           /* Credentials */
+                                           szUser,     sizeof(szUser),
+                                           szPassword, sizeof(szPassword),
+                                           /* Timelimit */
+                                           &uTimeLimitMS);
+    if (RT_FAILURE(rc))
+    {
+        VBoxServiceError("ControlExec: Failed to retrieve exec start command! Error: %Rrc\n", rc);
+    }
+    else
+    {
+        rc = VBoxServiceControlExecProcess(uContextID, szCmd, uFlags, szArgs, uNumArgs,
+                                           szEnv, cbEnv, uNumEnvVars,
+                                           szUser, szPassword, uTimeLimitMS);
+    }
+
+    VBoxServiceVerbose(3, "ControlExec: VBoxServiceControlExecHandleCmdStartProcess returned with %Rrc\n", rc);
+    return rc;
+}
+
+
+/**
+ * Handles input for the started process by copying the received data into its
+ * stdin pipe.
+ *
+ * @return  int
+ *
+ * @param   u32ClientId
+ * @param   uNumParms
+ */
+int VBoxServiceControlExecHandleCmdSetInput(uint32_t u32ClientId, uint32_t uNumParms)
+{
+    uint32_t uContextID;
+    uint32_t uPID;
+    uint32_t uFlags;
+    uint8_t  aBuffer[_64K];
+    uint32_t cbSize;
+
+    if (uNumParms != 5)
+        return VERR_INVALID_PARAMETER;
+
+    int rc = VbglR3GuestCtrlExecGetHostCmdInput(u32ClientId, uNumParms,
+                                                &uContextID, &uPID, &uFlags,
+                                                aBuffer, sizeof(aBuffer), &cbSize);
+    if (RT_FAILURE(rc))
+    {
+        VBoxServiceError("ControlExec: Failed to retrieve exec input command! Error: %Rrc\n", rc);
+    }
+    else
+    {
+        PVBOXSERVICECTRLTHREAD pNode = VBoxServiceControlExecFindProcess(uPID);
+        if (pNode)
+        {
+            PVBOXSERVICECTRLTHREADDATAEXEC pData = (PVBOXSERVICECTRLTHREADDATAEXEC)pNode->pvData;
+            AssertPtr(pData);
+            rc = VBoxServiceControlExecWritePipeBuffer(&pData->stdIn, aBuffer, cbSize);
+            if (RT_SUCCESS(rc))
+            {
+                size_t cbWritten;
+                rc = VBoxServiceControlExecProcWriteStdIn(&pData->stdIn, pData->pipeStdInW, &cbWritten);
+                if (RT_SUCCESS(rc))
+                    rc = VbglR3GuestCtrlExecReportStatusIn(u32ClientId, uContextID, uPID, 0 /* Flags */,
+                                                           cbWritten);
+            }
+        }
+        else
+            rc = VERR_NOT_FOUND; /* PID not found! */
+    }
+    VBoxServiceVerbose(3, "ControlExec: VBoxServiceControlExecHandleCmdSetInput returned with %Rrc\n", rc);
+    return rc;
+}
+
+
+/**
+ *
+ *
+ * @return  int
+ *
+ * @param   u32ClientId
+ * @param   uNumParms
+ */
+int VBoxServiceControlExecHandleCmdGetOutput(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("ControlExec: Failed to retrieve exec output command! Error: %Rrc\n", rc);
+    }
+    else
+    {
+        PVBOXSERVICECTRLTHREAD pNode = VBoxServiceControlExecFindProcess(uPID);
+        if (pNode)
+        {
+            PVBOXSERVICECTRLTHREADDATAEXEC pData = (PVBOXSERVICECTRLTHREADDATAEXEC)pNode->pvData;
+            AssertPtr(pData);
+
+            const uint32_t cbSize = _4K;
+            uint32_t cbRead = cbSize;
+            uint8_t *pBuf = (uint8_t*)RTMemAlloc(cbSize);
+            if (pBuf)
+            {
+                rc = VBoxServiceControlExecReadPipeBufferContent(&pData->stdOut, pBuf, cbSize, &cbRead);
+                if (RT_SUCCESS(rc))
+                {
+                    /* 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! */
+    }
+    VBoxServiceVerbose(3, "ControlExec: VBoxServiceControlExecHandleCmdGetOutput returned with %Rrc\n", rc);
+    return rc;
+}
+

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

@@ -112 +112 @@
 };
 
+enum VBOXSERVICECTRLPIPEID
+{
+    VBOXSERVICECTRLPIPEID_STDIN_ERROR  = 0,
+    VBOXSERVICECTRLPIPEID_STDIN_WRITABLE = 1,
+    VBOXSERVICECTRLPIPEID_STDOUT = 10,
+    VBOXSERVICECTRLPIPEID_STDERR = 20
+};
+
+/* Structure for holding buffered pipe data. */
 typedef struct
 {
+    /** The data buffer. */
     uint8_t    *pbData;
+    /** The amount of allocated buffer space. */
+    uint32_t    cbAllocated;
+    /** The actual used/occupied buffer space. */
     uint32_t    cbSize;
-    uint32_t    cbOffset;
-    uint32_t    cbRead;
+    /** Helper variable for keeping track of what
+     *  already was processed and what not. */
+    uint32_t    cbProcessed;
     RTCRITSECT  CritSect;
+    bool        fAlive;
 } VBOXSERVICECTRLEXECPIPEBUF;
-/** Pointer to thread data. */
+/** Pointer to buffered pipe data. */
 typedef VBOXSERVICECTRLEXECPIPEBUF *PVBOXSERVICECTRLEXECPIPEBUF;
 
@@ -137 +152 @@
     uint32_t  uTimeLimitMS;
 
+    RTPIPE                     pipeStdInW;
+    VBOXSERVICECTRLEXECPIPEBUF stdIn;
     VBOXSERVICECTRLEXECPIPEBUF stdOut;
     VBOXSERVICECTRLEXECPIPEBUF stdErr;
@@ -168 +185 @@
 /** Pointer to thread data. */
 typedef VBOXSERVICECTRLTHREAD *PVBOXSERVICECTRLTHREAD;
-
-/**
- * For buffering process input supplied by the client.
- */
-typedef struct VBOXSERVICECTRLSTDINBUF
-{
-    /** The mount of buffered data. */
-    size_t  cb;
-    /** The current data offset. */
-    size_t  off;
-    /** The data buffer. */
-    char   *pch;
-    /** The amount of allocated buffer space. */
-    size_t  cbAllocated;
-    /** Send further input into the bit bucket (stdin is dead). */
-    bool    fBitBucket;
-    /** The CRC-32 for standard input (received part). */
-    uint32_t uCrc32;
-} VBOXSERVICECTRLSTDINBUF;
-/** Pointer to a standard input buffer. */
-typedef VBOXSERVICECTRLSTDINBUF *PVBOXSERVICECTRLSTDINBUF;
-
 #endif /* VBOX_WITH_GUEST_CONTROL */
 #ifdef VBOX_WITH_GUEST_PROPS
@@ -277 +272 @@
 
 #ifdef VBOX_WITH_GUEST_CONTROL
+extern int  VBoxServiceControlExecHandleCmdStartProcess(uint32_t u32ClientId, uint32_t uNumParms);
+extern int  VBoxServiceControlExecHandleCmdGetOutput(uint32_t u32ClientId, uint32_t uNumParms);
+extern int  VBoxServiceControlExecHandleCmdStartProcess(uint32_t u32ClientId, uint32_t uNumParms);
+extern int  VBoxServiceControlExecHandleCmdSetInput(uint32_t u32ClientId, uint32_t uNumParms);
+extern int  VBoxServiceControlExecHandleCmdGetOutput(uint32_t u32ClientId, uint32_t uNumParms);
 extern int  VBoxServiceControlExecProcess(uint32_t uContext, const char *pszCmd, uint32_t uFlags,
                                           const char *pszArgs, uint32_t uNumArgs,
@@ -286 +286 @@
 extern int  VBoxServiceControlExecWritePipeBuffer(PVBOXSERVICECTRLEXECPIPEBUF pBuf,
                                                   uint8_t *pbData, uint32_t cbData);
-#endif
+#endif /* VBOX_WITH_GUEST_CONTROL */
 
 #ifdef VBOXSERVICE_MANAGEMENT

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

@@ -74 +74 @@
                  "                            [--flags <flags>] [--timeout <msec>]\n"
                  "                            [--verbose] [--wait-for exit,stdout,stderr||]\n"
+                 /** @todo Add a "--" parameter (has to be last parameter) to directly execute
+                  *        stuff, e.g. "VBoxManage guestcontrol execute <VMName> --username <> ... -- /bin/rm -Rf /foo". */
 #ifdef VBOX_WITH_COPYTOGUEST
                  "\n"
@@ -447 +449 @@
                     }
 
+#if 0
+                    static int sent = 0;
+                    if (sent < 1)
+                    {
+                        ULONG cbWritten;
+                        SafeArray<BYTE> aInputData(_64K);
+                        RTStrPrintf((char*)aInputData.raw(), _64K, "dir c:\\windows\n");
+                        rc = guest->SetProcessInput(uPID, 0 /* aFlags */,
+                                                    u32TimeoutMS, ComSafeArrayAsInParam(aInputData), &cbWritten);
+                        if (FAILED(rc))
+                        {
+                            /* If we got a VBOX_E_IPRT error we handle the error in a more gentle way
+                             * because it contains more accurate info about what went wrong. */
+                            ErrorInfo info(guest, COM_IIDOF(IGuest));
+                            if (info.isFullAvailable())
+                            {
+                                if (rc == VBOX_E_IPRT_ERROR)
+                                    RTMsgError("%ls.", info.getText().raw());
+                                else
+                                    RTMsgError("%ls (%Rhrc).", info.getText().raw(), info.getResultCode());
+                            }
+                        }
+                        else
+                        {
+                            RTPrintf("sent\n");
+                        }
+                    }
+                    sent++;
+#endif
                     if (cbOutputData <= 0) /* No more output data left? */
                     {
@@ -552 +583 @@
 static int handleCtrlCopyTo(HandlerArg *a)
 {
+#if 0
     RTISOFSFILE file;
     int vrc = RTIsoFsOpen(&file, "c:\\Downloads\\VBoxGuestAdditions_3.2.8.iso");
@@ -562 +594 @@
     }
     return vrc;
+#endif
 
     /*

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

@@ -389 +389 @@
     if (cParms != pBuf->uParmCount)
     {
+        LogFlowFunc(("Parameter count does not match (%u (buffer), %u (guest))\n",
+                     pBuf->uParmCount, cParms));
         rc = VERR_INVALID_PARAMETER;
     }
@@ -583 +585 @@
             if (it->mNumParms >= 2)
             {
-                it->mParms[0].setUInt32(GETHOSTMSG_EXEC_HOST_CANCEL_WAIT); /* Message ID. */
-                it->mParms[1].setUInt32(0);                                /* Required parameters for message. */
+                it->mParms[0].setUInt32(HOST_CANCEL_PENDING_WAITS); /* Message ID. */
+                it->mParms[1].setUInt32(0);                         /* Required parameters for message. */
             }
             if (mpHelpers)
@@ -628 +630 @@
         paParms[3].getUInt32(&data.u32Flags);
         paParms[4].getPointer(&data.pvData, &data.cbData);
+
+        if (mpfnHostCallback)
+            rc = mpfnHostCallback(mpvHostData, eFunction,
+                                  (void *)(&data), sizeof(data));
+    }
+    else if (   eFunction == GUEST_EXEC_SEND_INPUT_STATUS
+             && cParms    == 4)
+    {
+        CALLBACKDATAEXECINSTATUS data;
+        data.hdr.u32Magic = CALLBACKDATAMAGICEXECINSTATUS;
+        paParms[0].getUInt32(&data.hdr.u32ContextID);
+
+        paParms[1].getUInt32(&data.u32PID);
+        paParms[2].getUInt32(&data.u32Flags);
+        paParms[3].getUInt32(&data.cbProcessed);
 
         if (mpfnHostCallback)
@@ -745 +762 @@
 
             /*
-             * The guest notifies the host of the current client status.
+             * The guest notifies the host of the executed process status.
              */
             case GUEST_EXEC_SEND_STATUS:
-                LogFlowFunc(("SEND_STATUS\n"));
+                LogFlowFunc(("GUEST_EXEC_SEND_STATUS\n"));
+                rc = notifyHost(eFunction, cParms, paParms);
+                break;
+
+            case GUEST_EXEC_SEND_INPUT_STATUS:
+                LogFlowFunc(("GUEST_EXEC_SEND_INPUT_STATUS\n"));
                 rc = notifyHost(eFunction, cParms, paParms);
                 break;
@@ -790 +812 @@
                 break;
 
-            /* The host wants to send something to the guest's stdin pipe. */
+            /* The host wants to send something to the
+             * started process' stdin pipe. */
             case HOST_EXEC_SET_INPUT:
                 LogFlowFunc(("HOST_EXEC_SET_INPUT\n"));
+                rc = processHostCmd(eFunction, cParms, paParms);
                 break;
 

trunk/src/VBox/Main/GuestImpl.cpp

@@ -579 +579 @@
 
     int rc = VINF_SUCCESS;
-    if (u32Function == GUEST_DISCONNECTED)
-    {
-        //LogFlowFunc(("GUEST_DISCONNECTED\n"));
-
-        PCALLBACKDATACLIENTDISCONNECTED pCBData = reinterpret_cast<PCALLBACKDATACLIENTDISCONNECTED>(pvParms);
-        AssertPtr(pCBData);
-        AssertReturn(sizeof(CALLBACKDATACLIENTDISCONNECTED) == cbParms, VERR_INVALID_PARAMETER);
-        AssertReturn(CALLBACKDATAMAGICCLIENTDISCONNECTED == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
-
-        rc = pGuest->notifyCtrlClientDisconnected(u32Function, pCBData);
-    }
-    else if (u32Function == GUEST_EXEC_SEND_STATUS)
-    {
-        //LogFlowFunc(("GUEST_EXEC_SEND_STATUS\n"));
-
-        PCALLBACKDATAEXECSTATUS pCBData = reinterpret_cast<PCALLBACKDATAEXECSTATUS>(pvParms);
-        AssertPtr(pCBData);
-        AssertReturn(sizeof(CALLBACKDATAEXECSTATUS) == cbParms, VERR_INVALID_PARAMETER);
-        AssertReturn(CALLBACKDATAMAGICEXECSTATUS == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
-
-        rc = pGuest->notifyCtrlExecStatus(u32Function, pCBData);
-    }
-    else if (u32Function == GUEST_EXEC_SEND_OUTPUT)
-    {
-        //LogFlowFunc(("GUEST_EXEC_SEND_OUTPUT\n"));
-
-        PCALLBACKDATAEXECOUT pCBData = reinterpret_cast<PCALLBACKDATAEXECOUT>(pvParms);
-        AssertPtr(pCBData);
-        AssertReturn(sizeof(CALLBACKDATAEXECOUT) == cbParms, VERR_INVALID_PARAMETER);
-        AssertReturn(CALLBACKDATAMAGICEXECOUT == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
-
-        rc = pGuest->notifyCtrlExecOut(u32Function, pCBData);
-    }
-    else
-        rc = VERR_NOT_SUPPORTED;
+    switch (u32Function)
+    {
+        case GUEST_DISCONNECTED:
+        {
+            //LogFlowFunc(("GUEST_DISCONNECTED\n"));
+
+            PCALLBACKDATACLIENTDISCONNECTED pCBData = reinterpret_cast<PCALLBACKDATACLIENTDISCONNECTED>(pvParms);
+            AssertPtr(pCBData);
+            AssertReturn(sizeof(CALLBACKDATACLIENTDISCONNECTED) == cbParms, VERR_INVALID_PARAMETER);
+            AssertReturn(CALLBACKDATAMAGICCLIENTDISCONNECTED == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
+
+            rc = pGuest->notifyCtrlClientDisconnected(u32Function, pCBData);
+            break;
+        }
+
+        case GUEST_EXEC_SEND_STATUS:
+        {
+            //LogFlowFunc(("GUEST_EXEC_SEND_STATUS\n"));
+
+            PCALLBACKDATAEXECSTATUS pCBData = reinterpret_cast<PCALLBACKDATAEXECSTATUS>(pvParms);
+            AssertPtr(pCBData);
+            AssertReturn(sizeof(CALLBACKDATAEXECSTATUS) == cbParms, VERR_INVALID_PARAMETER);
+            AssertReturn(CALLBACKDATAMAGICEXECSTATUS == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
+
+            rc = pGuest->notifyCtrlExecStatus(u32Function, pCBData);
+            break;
+        }
+
+        case GUEST_EXEC_SEND_OUTPUT:
+        {
+            //LogFlowFunc(("GUEST_EXEC_SEND_OUTPUT\n"));
+
+            PCALLBACKDATAEXECOUT pCBData = reinterpret_cast<PCALLBACKDATAEXECOUT>(pvParms);
+            AssertPtr(pCBData);
+            AssertReturn(sizeof(CALLBACKDATAEXECOUT) == cbParms, VERR_INVALID_PARAMETER);
+            AssertReturn(CALLBACKDATAMAGICEXECOUT == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
+
+            rc = pGuest->notifyCtrlExecOut(u32Function, pCBData);
+            break;
+        }
+
+        case GUEST_EXEC_SEND_INPUT_STATUS:
+        {
+            //LogFlowFunc(("GUEST_EXEC_SEND_INPUT_STATUS\n"));
+
+            PCALLBACKDATAEXECINSTATUS pCBData = reinterpret_cast<PCALLBACKDATAEXECINSTATUS>(pvParms);
+            AssertPtr(pCBData);
+            AssertReturn(sizeof(CALLBACKDATAEXECINSTATUS) == cbParms, VERR_INVALID_PARAMETER);
+            AssertReturn(CALLBACKDATAMAGICEXECINSTATUS == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
+
+            rc = pGuest->notifyCtrlExecInStatus(u32Function, pCBData);
+            break;
+        }
+
+        default:
+            AssertMsgFailed(("Unknown guest control notification received, u32Function=%u", u32Function));
+            rc = VERR_INVALID_PARAMETER;
+            break;
+    }
     return rc;
 }
@@ -775 +799 @@
 
                         default:
-                            AssertMsgFailed(("unknown callback type %d\n", it2->second.mType));
+                            AssertMsgFailed(("Unknown callback type %d\n", it2->second.mType));
                             break;
                     }
@@ -808 +832 @@
     if (it != mCallbackMap.end())
     {
-        PCALLBACKDATAEXECOUT pCBData = (CALLBACKDATAEXECOUT*)it->second.pvData;
+        PCALLBACKDATAEXECOUT pCBData = (PCALLBACKDATAEXECOUT)it->second.pvData;
         AssertPtr(pCBData);
 
@@ -841 +865 @@
                                                  Guest::getStaticComponentName(),
                                                  Guest::tr("The output operation was canceled"));
+        }
+        else
+            it->second.pProgress->notifyComplete(S_OK);
+    }
+    else
+        LogFlowFunc(("Unexpected callback (magic=%u, context ID=%u) arrived\n", pData->hdr.u32Magic, pData->hdr.u32ContextID));
+    return rc;
+}
+
+/* Function for handling the execution input status notification. */
+int Guest::notifyCtrlExecInStatus(uint32_t                  u32Function,
+                                  PCALLBACKDATAEXECINSTATUS pData)
+{
+    int rc = VINF_SUCCESS;
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    AssertPtr(pData);
+    CallbackMapIter it = getCtrlCallbackContextByID(pData->hdr.u32ContextID);
+    if (it != mCallbackMap.end())
+    {
+        PCALLBACKDATAEXECINSTATUS pCBData = (PCALLBACKDATAEXECINSTATUS)it->second.pvData;
+        AssertPtr(pCBData);
+
+        /* Nothing to do here yet. */
+
+        /* Was progress canceled before? */
+        BOOL fCanceled;
+        ComAssert(!it->second.pProgress.isNull());
+        if (SUCCEEDED(it->second.pProgress->COMGETTER(Canceled)(&fCanceled)) && fCanceled)
+        {
+            it->second.pProgress->notifyComplete(VBOX_E_IPRT_ERROR,
+                                                 COM_IIDOF(IGuest),
+                                                 Guest::getStaticComponentName(),
+                                                 Guest::tr("The input operation was canceled"));
         }
         else
@@ -1303 +1362 @@
 }
 
+STDMETHODIMP Guest::SetProcessInput(ULONG aPID, ULONG aFlags, ULONG aTimeoutMS, ComSafeArrayIn(BYTE, aData), ULONG *aBytesWritten)
+{
+#ifndef VBOX_WITH_GUEST_CONTROL
+    ReturnComNotImplemented();
+#else  /* VBOX_WITH_GUEST_CONTROL */
+    using namespace guestControl;
+
+    CheckComArgExpr(aPID, aPID > 0);
+    if (aFlags != 0) /* Flags are not supported at the moment. */
+        return setError(E_INVALIDARG, tr("Unknown flags (%#x)"), aFlags);
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    HRESULT rc = S_OK;
+
+    try
+    {
+        /* Search for existing PID. */
+        GuestProcessMapIterConst it = getProcessByPID(aPID);
+        if (it != mGuestProcessMap.end())
+        {
+            /* PID exists; check if process is still running. */
+            if (it->second.mStatus != PROC_STS_STARTED)
+            {
+                rc = setError(VBOX_E_IPRT_ERROR,
+                              tr("Process (PID %u) does not run anymore! Status: %ld, Flags: %u, Exit Code: %u"),
+                              aPID, it->second.mStatus, it->second.mFlags, it->second.mExitCode);
+            }
+        }
+        else
+            rc = setError(VBOX_E_IPRT_ERROR,
+                          tr("Process (PID %u) not found!"), aPID);
+
+        if (SUCCEEDED(rc))
+        {
+            /*
+             * Create progress object.
+             * This progress object, compared to the one in executeProgress() above
+             * is only local and is used to determine whether the operation finished
+             * or got canceled.
+             */
+            ComObjPtr <Progress> progress;
+            rc = progress.createObject();
+            if (SUCCEEDED(rc))
+            {
+                rc = progress->init(static_cast<IGuest*>(this),
+                                    Bstr(tr("Getting output of process")).raw(),
+                                    TRUE);
+            }
+            if (FAILED(rc)) return rc;
+
+            /* Adjust timeout */
+            if (aTimeoutMS == 0)
+                aTimeoutMS = UINT32_MAX;
+
+            PCALLBACKDATAEXECINSTATUS pData = (PCALLBACKDATAEXECINSTATUS)RTMemAlloc(sizeof(CALLBACKDATAEXECINSTATUS));
+            AssertReturn(pData, VBOX_E_IPRT_ERROR);
+            RT_ZERO(*pData);
+            /* Save PID + output flags for later use. */
+            pData->u32PID = aPID;
+            pData->u32Flags = aFlags;
+            /* Add job to callback contexts. */
+            uint32_t uContextID = addCtrlCallbackContext(VBOXGUESTCTRLCALLBACKTYPE_EXEC_INPUT_STATUS,
+                                                         pData, sizeof(CALLBACKDATAEXECINSTATUS), progress);
+            Assert(uContextID > 0);
+
+            com::SafeArray<BYTE> sfaData(ComSafeArrayInArg(aData));
+
+            VBOXHGCMSVCPARM paParms[6];
+            int i = 0;
+            paParms[i++].setUInt32(uContextID);
+            paParms[i++].setUInt32(aPID);
+            paParms[i++].setUInt32(aFlags);
+            paParms[i++].setPointer(sfaData.raw(), sfaData.size());
+            paParms[i++].setUInt32(sfaData.size());
+
+            int vrc = VINF_SUCCESS;
+
+            {
+                VMMDev *vmmDev;
+                {
+                    /* Make sure mParent is valid, so set the read lock while using.
+                     * Do not keep this lock while doing the actual call, because in the meanwhile
+                     * another thread could request a write lock which would be a bad idea ... */
+                    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+                    /* Forward the information to the VMM device. */
+                    AssertPtr(mParent);
+                    vmmDev = mParent->getVMMDev();
+                }
+
+                if (vmmDev)
+                {
+                    LogFlowFunc(("hgcmHostCall numParms=%d\n", i));
+                    vrc = vmmDev->hgcmHostCall("VBoxGuestControlSvc", HOST_EXEC_SET_INPUT,
+                                               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.
+                 */
+                CallbackMapIter it = getCtrlCallbackContextByID(uContextID);
+                BOOL fCanceled = FALSE;
+                if (it != mCallbackMap.end())
+                {
+                    ComAssert(!it->second.pProgress.isNull());
+
+                    /* Wait until operation completed. */
+                    rc = it->second.pProgress->WaitForCompletion(aTimeoutMS);
+                    if (FAILED(rc)) throw rc;
+
+                    /* Was the operation canceled by one of the parties? */
+                    rc = it->second.pProgress->COMGETTER(Canceled)(&fCanceled);
+                    if (FAILED(rc)) throw rc;
+
+                    if (!fCanceled)
+                    {
+                        BOOL fCompleted;
+                        if (   SUCCEEDED(it->second.pProgress->COMGETTER(Completed)(&fCompleted))
+                            && fCompleted)
+                        {
+                            /* Nothing to do here yet. */
+                        }
+                        else /* If callback not called within time ... well, that's a timeout! */
+                            vrc = VERR_TIMEOUT;
+                    }
+                    else /* Operation was canceled. */
+                    {
+                        vrc = VERR_CANCELLED;
+                    }
+
+                    if (RT_FAILURE(vrc))
+                    {
+                        if (vrc == VERR_TIMEOUT)
+                        {
+                            rc = setError(VBOX_E_IPRT_ERROR,
+                                          tr("The guest did not process input within time (%ums)"), aTimeoutMS);
+                        }
+                        else if (vrc == VERR_CANCELLED)
+                        {
+                            rc = setError(VBOX_E_IPRT_ERROR,
+                                          tr("The input operation was canceled"));
+                        }
+                        else
+                        {
+                            rc = setError(E_UNEXPECTED,
+                                          tr("The service call failed with error %Rrc"), vrc);
+                        }
+                    }
+
+                    {
+                        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+                        /*
+                         * Destroy locally used progress object.
+                         */
+                        destroyCtrlCallbackContext(it);
+                    }
+
+                    /* Remove callback context (not used anymore). */
+                    mCallbackMap.erase(it);
+                }
+                else /* PID lookup failed. */
+                    rc = setError(VBOX_E_IPRT_ERROR,
+                                  tr("Process (PID %u) not found!"), aPID);
+            }
+            else /* HGCM operation failed. */
+                rc = setError(E_UNEXPECTED,
+                              tr("The HGCM call failed with error %Rrc"), vrc);
+
+            /* Cleanup. */
+            progress->uninit();
+            progress.setNull();
+        }
+    }
+    catch (std::bad_alloc &)
+    {
+        rc = E_OUTOFMEMORY;
+    }
+    return rc;
+#endif
+}
+
 STDMETHODIMP Guest::GetProcessOutput(ULONG aPID, ULONG aFlags, ULONG aTimeoutMS, LONG64 aSize, ComSafeArrayOut(BYTE, aData))
 {
@@ -1552 +1801 @@
     LogFlowFunc(("Appending to pList=%p: %s\n", pList, pszPath));
 
-    DirEntry *pNode = (DirEntry*)RTMemAlloc(sizeof(DirEntry));
+    VBoxGuestDirEntry *pNode = (VBoxGuestDirEntry*)RTMemAlloc(sizeof(VBoxGuestDirEntry));
     if (pNode == NULL)
         return VERR_NO_MEMORY;
 
+    pNode->pszPath = NULL;
     if (RT_SUCCESS(RTStrAAppend(&pNode->pszPath, pszPath)))
     {
@@ -1579 +1829 @@
                  pszDirectory, pszFilter ? pszFilter : "<None>"));
 
-    char *pszDirWithFilter = NULL;
-    PRTDIR pDir;
-    int rc = RTStrAAppend(&pszDirWithFilter, pszDirectory);
+    PRTDIR pDir = NULL;
+    int rc = RTDirOpenFiltered(&pDir, pszDirectory,
+#ifdef RT_OS_WINDOWS
+                               RTDIRFILTER_WINNT);
+#else
+                               RTDIRFILTER_UNIX);
+#endif
+    char *pszDirectoryStrip = RTStrDup(pszDirectory);
+    if (!pszDirectoryStrip)
+        rc = VERR_NO_MEMORY;
+
     if (RT_SUCCESS(rc))
     {
-        if (pszFilter)
-        {
-            RTStrAAppend(&pszDirWithFilter, pszDirectory);
-            rc = RTDirOpenFiltered(&pDir, pszDirectory, RTDIRFILTER_WINNT);
-        }
-        else
-            rc = RTDirOpen(&pDir, pszDirectory);
-    }
-
-    if (RT_SUCCESS(rc))
-    {
-        rc = directoryEntryAppend(pszDirectory, pList);
-        if (RT_SUCCESS(rc))
-        {
-            *pcObjects = *pcObjects + 1;
-            for (;;)
+        RTPathStripFilename(pszDirectoryStrip);
+        for (;;)
+        {
+            RTDIRENTRY DirEntry;
+            rc = RTDirRead(pDir, &DirEntry, NULL);
+            if (RT_FAILURE(rc))
             {
-                RTDIRENTRY DirEntry;
-                rc = RTDirRead(pDir, &DirEntry, NULL);
-                if (RT_FAILURE(rc))
-                    break;
-                switch (DirEntry.enmType)
-                {
-                    case RTDIRENTRYTYPE_DIRECTORY:
-                        if (uFlags & CopyFileFlag_Recursive)
-                            rc = directoryRead(DirEntry.szName, pszFilter,
-                                               uFlags, pcObjects, pList);
-                        break;
-
-                    case RTDIRENTRYTYPE_FILE:
+                if (rc == VERR_NO_MORE_FILES)
+                    rc = VINF_SUCCESS;
+                break;
+            }
+            switch (DirEntry.enmType)
+            {
+                case RTDIRENTRYTYPE_DIRECTORY:
+                    /* Skip "." and ".." entrires. */
+                    if (   !strcmp(DirEntry.szName, ".")
+                        || !strcmp(DirEntry.szName, ".."))
                     {
-                        char *pszFile;
-                        if (RTStrAPrintf(&pszFile, "%s/%s",
-                                         pszDirectory, DirEntry.szName))
-                        {
-                            rc = directoryEntryAppend(pszFile, pList);
-                            if (RT_SUCCESS(rc))
-                                *pcObjects = *pcObjects + 1;
-                            RTStrFree(pszFile);
-                        }
                         break;
                     }
-
-                    case RTDIRENTRYTYPE_SYMLINK:
-                        if (   (uFlags & CopyFileFlag_Recursive)
-                            && (uFlags & CopyFileFlag_FollowLinks))
-                        {
-                            rc = directoryRead(DirEntry.szName, pszFilter,
-                                               uFlags, pcObjects, pList);
-                        }
-                        break;
-
-                    default:
-                        break;
+                    if (uFlags & CopyFileFlag_Recursive)
+                        rc = directoryRead(DirEntry.szName, pszFilter,
+                                           uFlags, pcObjects, pList);
+                    break;
+
+                case RTDIRENTRYTYPE_FILE:
+                {
+                    char *pszFile;
+                    if (RTStrAPrintf(&pszFile, "%s%c%s",
+                                     pszDirectoryStrip, RTPATH_SLASH, DirEntry.szName))
+                    {
+                        rc = directoryEntryAppend(pszFile, pList);
+                        if (RT_SUCCESS(rc))
+                            *pcObjects = *pcObjects + 1;
+                        RTStrFree(pszFile);
+                    }
+                    break;
                 }
-                if (RT_FAILURE(rc))
+
+                case RTDIRENTRYTYPE_SYMLINK:
+                    if (   (uFlags & CopyFileFlag_Recursive)
+                        && (uFlags & CopyFileFlag_FollowLinks))
+                    {
+                        rc = directoryRead(DirEntry.szName, pszFilter,
+                                           uFlags, pcObjects, pList);
+                    }
+                    break;
+
+                default:
                     break;
             }
-        }
+            if (RT_FAILURE(rc))
+                break;
+        }
+        RTStrFree(pszDirectoryStrip);
+    }
+
+    if (pDir)
         RTDirClose(pDir);
-    }
-    if (pszDirWithFilter)
-        RTStrFree(pszDirWithFilter);
     return rc;
 }
@@ -1682 +1936 @@
     try
     {
-        char szSourceAbs[RTPATH_MAX];
-        Utf8Str Utf8Dest(aDest);
-
-        int vrc = RTPathAbs(Utf8Str(aSource).c_str(),
-                            szSourceAbs, sizeof(szSourceAbs));
-        if (RT_SUCCESS(vrc))
-        {
-            LogRel(("Copying \"%s\" to guest into \"%s\" ...\n",
-                    szSourceAbs, Utf8Dest.c_str()));
-        }
-        else
-            rc = setError(VBOX_E_IPRT_ERROR,
-                          tr("Could not determine absolute path! rc=%Rrc"), vrc);
-
         ULONG cObjectsToCopy = 0;
         RTLISTNODE listEntries;
-        if (SUCCEEDED(rc))
-        {
-            /*
-             * Count objects to copy.
-             * This is needed for have multi operation progress object.
-             * Examples:
-             *     D:\ -> D:\*
-             *     E:\asdf\qwer\ -> E:\asdf\qwer\*
-             *     C:\temp.txt
-             *     C:\Foo\bar\*.txt
-             *     /home/foo/bar/movie.avi
-             */
-            char *pszFileName = RTPathFilename(szSourceAbs);
-            RTListInit(&listEntries);
-
-            vrc = directoryRead(szSourceAbs, pszFileName /* Filter */,
-                                    aFlags, &cObjectsToCopy, &listEntries);
-            if (RT_FAILURE(vrc))
-                rc = setError(VBOX_E_IPRT_ERROR,
-                              tr("Could not open source directory! rc=%Rrc"), vrc);
-        }
-
-        if (SUCCEEDED(rc))
-        {
-            /*
-             * Create progress object.  Note that this is a multi operation
-             * object to perform an operation per the following steps:
-             * - Operation 1 (0): Create/start process.
-             * - Operation 2 (1): Wait for process to exit.
-             * If this progress completed successfully (S_OK), the process
-             * started and exited normally. In any other case an error/exception
-             * occured.
-             */
-            ComObjPtr <Progress> progress;
-            rc = progress.createObject();
+
+        Utf8Str Utf8Source(aSource);
+        Utf8Str Utf8Dest(aDest);
+
+        char *pszSourceAbs = RTPathAbsDup(Utf8Source.c_str());
+        if (!pszSourceAbs)
+        {
+            rc = setError(VBOX_E_IPRT_ERROR,
+                          tr("Could not determine absolute path of \"%s\""), Utf8Source.c_str());
+        }
+        else
+        {
+            if (RTDirExists(pszSourceAbs))
+            {
+                size_t cch = strlen(pszSourceAbs);
+                if (    cch > 1
+                    &&  !RTPATH_IS_SLASH(pszSourceAbs[cch - 1])
+                    &&  !RTPATH_IS_SLASH(pszSourceAbs[cch - 2]))
+                {
+                    int vrc = RTStrAAppend(&pszSourceAbs, RTPATH_SLASH_STR);
+                    if (RT_FAILURE(vrc))
+                        rc = setError(VBOX_E_IPRT_ERROR,
+                                      tr("Failed to extend source path, rc=%Rrc\n"), vrc);
+                }
+            }
+
             if (SUCCEEDED(rc))
             {
-                rc = progress->init(static_cast<IGuest*>(this),
-                                    Bstr(tr("Executing process")).raw(),
-                                    TRUE,
-                                    cObjectsToCopy,                             /* Number of operations. */
-                                    Bstr(tr("Starting process ...")).raw());    /* Description of first stage. */
+                LogRel(("Copying \"%s\" to guest into \"%s\" ...\n",
+                    pszSourceAbs, Utf8Dest.c_str()));
+
+                /*
+                 * Count objects to copy and build file list.
+                 */
+                RTListInit(&listEntries);
+                int vrc = directoryRead(pszSourceAbs, NULL /* Filter */,
+                                        aFlags, &cObjectsToCopy, &listEntries);
+                if (RT_FAILURE(vrc))
+                {
+                    if (vrc != VERR_FILE_NOT_FOUND) /* If no files found, this is no error! */
+                        rc = setError(VBOX_E_IPRT_ERROR,
+                                      tr("Error reading source directory \"%s\", rc=%Rrc"),
+                                      pszSourceAbs, vrc);
+                }
             }
-            if (FAILED(rc)) return rc;
-        }
-
-        /* Destroy list. */
-        DirEntry *pNode = RTListNodeGetFirst(&listEntries, DirEntry, Node);
-        while (pNode)
-        {
-            DirEntry *pNext = RTListNodeGetNext(&pNode->Node, DirEntry, Node);
-            bool fLast = RTListNodeIsLast(&listEntries, &pNode->Node);
-
-            if (pNode->pszPath)
-                RTStrFree(pNode->pszPath);
-            RTListNodeRemove(&pNode->Node);
-            RTMemFree(pNode);
-
-            if (fLast)
-                break;
-
-            pNode = pNext;
-        }
-    }
-
+            RTStrFree(pszSourceAbs);
+        }
+
+        if (SUCCEEDED(rc))
+        {
+            if (cObjectsToCopy) /* Do we have some objects to copy? */
+            {
+                /*
+                 * Create progress object.  Note that this is a multi operation
+                 * object to perform an operation per file object we just gathered
+                 * in our list above.
+                 */
+                ComObjPtr <Progress> progress;
+                rc = progress.createObject();
+                if (SUCCEEDED(rc))
+                {
+                    rc = progress->init(static_cast<IGuest*>(this),
+                                        Bstr(tr("Copying to guest")).raw(),
+                                        TRUE,
+                                        cObjectsToCopy,                      /* Number of operations. */
+                                        Bstr(tr("Copying ...")).raw());      /* Description of first stage. */
+                }
+                if (FAILED(rc)) return rc;
 #if 0
-
-        /*
-         * Prepare process execution.
-         */
-        int vrc = VINF_SUCCESS;
-        Utf8Str Utf8Command(aCommand);
-
-        /* Adjust timeout */
-        if (aTimeoutMS == 0)
-            aTimeoutMS = UINT32_MAX;
-
-        /* Prepare arguments. */
-        char **papszArgv = NULL;
-        uint32_t uNumArgs = 0;
-        if (aArguments > 0)
-        {
-            com::SafeArray<IN_BSTR> args(ComSafeArrayInArg(aArguments));
-            uNumArgs = args.size();
-            papszArgv = (char**)RTMemAlloc(sizeof(char*) * (uNumArgs + 1));
-            AssertReturn(papszArgv, E_OUTOFMEMORY);
-            for (unsigned i = 0; RT_SUCCESS(vrc) && i < uNumArgs; i++)
-                vrc = RTUtf16ToUtf8(args[i], &papszArgv[i]);
-            papszArgv[uNumArgs] = NULL;
-        }
-
-        Utf8Str Utf8UserName(aUserName);
-        Utf8Str Utf8Password(aPassword);
-        if (RT_SUCCESS(vrc))
-        {
-            uint32_t uContextID = 0;
-
-            char *pszArgs = NULL;
-            if (uNumArgs > 0)
-                vrc = RTGetOptArgvToString(&pszArgs, papszArgv, 0);
-            if (RT_SUCCESS(vrc))
-            {
-                uint32_t cbArgs = pszArgs ? strlen(pszArgs) + 1 : 0; /* Include terminating zero. */
-
-                /* Prepare environment. */
-                void *pvEnv = NULL;
-                uint32_t uNumEnv = 0;
-                uint32_t cbEnv = 0;
-                if (aEnvironment > 0)
-                {
-                    com::SafeArray<IN_BSTR> env(ComSafeArrayInArg(aEnvironment));
-
-                    for (unsigned i = 0; i < env.size(); i++)
-                    {
-                        vrc = prepareExecuteEnv(Utf8Str(env[i]).c_str(), &pvEnv, &cbEnv, &uNumEnv);
-                        if (RT_FAILURE(vrc))
-                            break;
-                    }
-                }
-
-                LogRel(("Executing guest process \"%s\" as user \"%s\" ...\n",
-                        Utf8Command.c_str(), Utf8UserName.c_str()));
-
-                if (RT_SUCCESS(vrc))
+                if (SUCCEEDED(rc))
                 {
                     PCALLBACKDATAEXECSTATUS pData = (PCALLBACKDATAEXECSTATUS)RTMemAlloc(sizeof(CALLBACKDATAEXECSTATUS));
@@ -1864 +2050 @@
                     else
                         vrc = VERR_INVALID_VM_HANDLE;
-                    RTMemFree(pvEnv);
                 }
-                RTStrFree(pszArgs);
+#endif
+                /* Destroy list. */
+                VBoxGuestDirEntry *pNode = RTListNodeGetFirst(&listEntries, VBoxGuestDirEntry, Node);
+                while (pNode)
+                {
+                    VBoxGuestDirEntry *pNext = RTListNodeGetNext(&pNode->Node, VBoxGuestDirEntry, Node);
+                    bool fLast = RTListNodeIsLast(&listEntries, &pNode->Node);
+
+                    if (pNode->pszPath)
+                        RTStrFree(pNode->pszPath);
+                    RTListNodeRemove(&pNode->Node);
+                    RTMemFree(pNode);
+
+                    if (fLast)
+                        break;
+
+                    pNode = pNext;
+                }
             }
-            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.
-                 */
-                CallbackMapIter it = getCtrlCallbackContextByID(uContextID);
-                BOOL fCanceled = FALSE;
-                if (it != mCallbackMap.end())
-                {
-                    ComAssert(!it->second.pProgress.isNull());
-
-                    /*
-                     * Wait for the first stage (=0) to complete (that is starting the process).
-                     */
-                    PCALLBACKDATAEXECSTATUS pData = NULL;
-                    rc = it->second.pProgress->WaitForOperationCompletion(0, aTimeoutMS);
-                    if (SUCCEEDED(rc))
-                    {
-                        /* Was the operation canceled by one of the parties? */
-                        rc = it->second.pProgress->COMGETTER(Canceled)(&fCanceled);
-                        if (FAILED(rc)) throw rc;
-
-                        if (!fCanceled)
-                        {
-                            AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-                            pData = (PCALLBACKDATAEXECSTATUS)it->second.pvData;
-                            Assert(it->second.cbData == sizeof(CALLBACKDATAEXECSTATUS));
-                            AssertPtr(pData);
-
-                            /* Did we get some status? */
-                            switch (pData->u32Status)
-                            {
-                                case PROC_STS_STARTED:
-                                    /* Process is (still) running; get PID. */
-                                    *aPID = pData->u32PID;
-                                    break;
-
-                                /* In any other case the process either already
-                                 * terminated or something else went wrong, so no PID ... */
-                                case PROC_STS_TEN: /* Terminated normally. */
-                                case PROC_STS_TEA: /* Terminated abnormally. */
-                                case PROC_STS_TES: /* Terminated through signal. */
-                                case PROC_STS_TOK:
-                                case PROC_STS_TOA:
-                                case PROC_STS_DWN:
-                                    /*
-                                     * Process (already) ended, but we want to get the
-                                     * PID anyway to retrieve the output in a later call.
-                                     */
-                                    *aPID = pData->u32PID;
-                                    break;
-
-                                case PROC_STS_ERROR:
-                                    vrc = pData->u32Flags; /* u32Flags member contains IPRT error code. */
-                                    break;
-
-                                case PROC_STS_UNDEFINED:
-                                    vrc = VERR_TIMEOUT;    /* Operation did not complete within time. */
-                                    break;
-
-                                default:
-                                    vrc = VERR_INVALID_PARAMETER; /* Unknown status, should never happen! */
-                                    break;
-                            }
-                        }
-                        else /* Operation was canceled. */
-                            vrc = VERR_CANCELLED;
-                    }
-                    else /* Operation did not complete within time. */
-                        vrc = VERR_TIMEOUT;
-
-                    /*
-                     * Do *not* remove the callback yet - we might wait with the IProgress object on something
-                     * else (like end of process) ...
-                     */
-                    if (RT_FAILURE(vrc))
-                    {
-                        if (vrc == VERR_FILE_NOT_FOUND) /* This is the most likely error. */
-                            rc = setError(VBOX_E_IPRT_ERROR,
-                                          tr("The file '%s' was not found on guest"), Utf8Command.c_str());
-                        else if (vrc == VERR_PATH_NOT_FOUND)
-                            rc = setError(VBOX_E_IPRT_ERROR,
-                                          tr("The path to file '%s' was not found on guest"), Utf8Command.c_str());
-                        else if (vrc == VERR_BAD_EXE_FORMAT)
-                            rc = setError(VBOX_E_IPRT_ERROR,
-                                          tr("The file '%s' is not an executable format on guest"), Utf8Command.c_str());
-                        else if (vrc == VERR_AUTHENTICATION_FAILURE)
-                            rc = setError(VBOX_E_IPRT_ERROR,
-                                          tr("The specified user '%s' was not able to logon on guest"), Utf8UserName.c_str());
-                        else if (vrc == VERR_TIMEOUT)
-                            rc = setError(VBOX_E_IPRT_ERROR,
-                                          tr("The guest did not respond within time (%ums)"), aTimeoutMS);
-                        else if (vrc == VERR_CANCELLED)
-                            rc = setError(VBOX_E_IPRT_ERROR,
-                                          tr("The execution operation was canceled"));
-                        else if (vrc == VERR_PERMISSION_DENIED)
-                            rc = setError(VBOX_E_IPRT_ERROR,
-                                          tr("Invalid user/password credentials"));
-                        else
-                        {
-                            if (pData && pData->u32Status == PROC_STS_ERROR)
-                                rc = setError(VBOX_E_IPRT_ERROR,
-                                              tr("Process could not be started: %Rrc"), pData->u32Flags);
-                            else
-                                rc = setError(E_UNEXPECTED,
-                                              tr("The service call failed with error %Rrc"), vrc);
-                        }
-                    }
-                    else /* Execution went fine. */
-                    {
-                        /* Return the progress to the caller. */
-                        progress.queryInterfaceTo(aProgress);
-                    }
-                }
-                else /* Callback context not found; should never happen! */
-                    AssertMsg(it != mCallbackMap.end(), ("Callback context with ID %u not found!", uContextID));
-            }
-            else /* HGCM related error codes .*/
-            {
-                if (vrc == VERR_INVALID_VM_HANDLE)
-                    rc = setError(VBOX_E_VM_ERROR,
-                                  tr("VMM device is not available (is the VM running?)"));
-                else if (vrc == VERR_TIMEOUT)
-                    rc = setError(VBOX_E_VM_ERROR,
-                                  tr("The guest execution service is not ready"));
-                else if (vrc == VERR_HGCM_SERVICE_NOT_FOUND)
-                    rc = setError(VBOX_E_VM_ERROR,
-                                  tr("The guest execution service is not available"));
-                else /* HGCM call went wrong. */
-                    rc = setError(E_UNEXPECTED,
-                                  tr("The HGCM call failed with error %Rrc"), vrc);
-            }
-
-            for (unsigned i = 0; i < uNumArgs; i++)
-                RTMemFree(papszArgv[i]);
-            RTMemFree(papszArgv);
-        }
-
-        if (RT_FAILURE(vrc))
-            LogRel(("Executing guest process \"%s\" as user \"%s\" failed with %Rrc\n",
-                    Utf8Command.c_str(), Utf8UserName.c_str(), vrc));
-#endif
+        }
+    }
     catch (std::bad_alloc &)
     {

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

@@ -7746 +7746 @@
   <interface
      name="IGuest" extends="$unknown"
-     uuid="6e3113ac-ed90-4864-8c2c-942c8022324d"
+     uuid="c165a809-0882-4c76-9220-746da84b5ecf"
      wsmap="managed"
      >
@@ -8061 +8061 @@
       <param name="progress" type="IProgress" dir="return">
         <desc>Progress object to track the operation completion.</desc>
+      </param>
+    </method>
+
+    <method name="setProcessInput">
+      <desc>
+        Sends input into a formerly started process.
+
+        <result name="VBOX_E_IPRT_ERROR">
+          Could not send input.
+        </result>
+
+      </desc>
+      <param name="pid" type="unsigned long" dir="in">
+        <desc>
+          Process id returned by earlier executeProcess() call.
+        </desc>
+      </param>
+      <param name="flags" type="unsigned long" dir="in">
+        <desc>
+          Not used, must be set to zero.
+        </desc>
+      </param>
+      <param name="timeoutMS" type="unsigned long" dir="in">
+        <desc>
+          The maximum timeout value (in msec) to wait for handling
+          the input data. Pass 0 for an infinite timeout.
+        </desc>
+      </param>
+      <param name="data" type="octet" dir="in" safearray="yes">
+        <desc>
+          Buffer of input data to send to the started process to.
+        </desc>
+      </param>
+      <param name="written" type="unsigned long" dir="return">
+        <desc>
+          Number of bytes written.
+        </desc>
       </param>
     </method>

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

@@ -99 +99 @@
                               ULONG aTimeoutMS, ULONG *aPID, IProgress **aProgress);
     STDMETHOD(GetProcessOutput)(ULONG aPID, ULONG aFlags, ULONG aTimeoutMS, LONG64 aSize, ComSafeArrayOut(BYTE, aData));
+    STDMETHOD(SetProcessInput)(ULONG aPID, ULONG aFlags, ULONG aTimeoutMS, ComSafeArrayIn(BYTE, aData), ULONG *aBytesWritten);
     STDMETHOD(GetProcessStatus)(ULONG aPID, ULONG *aExitCode, ULONG *aFlags, ULONG *aStatus);
     STDMETHOD(CopyToGuest)(IN_BSTR aSource, IN_BSTR aDest, ULONG aFlags, IProgress **aProgress);
@@ -153 +154 @@
 #ifdef VBOX_WITH_COPYTOGUEST
     /*
-     *
+     * Structure holding a directory entry.
      */
-    struct DirEntry
+    struct VBoxGuestDirEntry
     {
         char       *pszPath;
@@ -170 +171 @@
     int notifyCtrlExecStatus(uint32_t u32Function, PCALLBACKDATAEXECSTATUS pData);
     int notifyCtrlExecOut(uint32_t u32Function, PCALLBACKDATAEXECOUT pData);
+    int notifyCtrlExecInStatus(uint32_t u32Function, PCALLBACKDATAEXECINSTATUS pData);
     CallbackMapIter getCtrlCallbackContextByID(uint32_t u32ContextID);
     GuestProcessMapIter getProcessByPID(uint32_t u32PID);