Changeset 50709 in vbox

Timestamp:

Mar 5, 2014 6:29:52 PM (11 years ago)

Author:

vboxsync

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

92670

Message:

6813 src-client/GuestProcessImpl.cpp

Location:

trunk/src/VBox/Main

Files:

• include/GuestProcessImpl.h (modified) (6 diffs)
• src-client/GuestDirectoryImpl.cpp (modified) (5 diffs)
• src-client/GuestProcessImpl.cpp (modified) (87 diffs)
• src-client/GuestSessionImpl.cpp (modified) (12 diffs)
• src-client/GuestSessionImplTasks.cpp (modified) (16 diffs)
• src-client/xpcom/module.cpp (modified) (1 diff)

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

@@ -20 +20 @@
 #define ____H_GUESTPROCESSIMPL
 
-#include "VirtualBoxBase.h"
 #include "GuestCtrlImplPrivate.h"
+#include "GuestProcessWrap.h"
 
 class Console;
@@ -30 +30 @@
  */
 class ATL_NO_VTABLE GuestProcess :
-    public VirtualBoxBase,
-    public GuestObject,
-    VBOX_SCRIPTABLE_IMPL(IGuestProcess)
+    public GuestProcessWrap,
+    public GuestObject
 {
 public:
     /** @name COM and internal init/term/mapping cruft.
      * @{ */
-    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(GuestProcess, IGuestProcess)
-    DECLARE_NOT_AGGREGATABLE(GuestProcess)
-    DECLARE_PROTECT_FINAL_CONSTRUCT()
-    BEGIN_COM_MAP(GuestProcess)
-        VBOX_DEFAULT_INTERFACE_ENTRIES(IGuestProcess)
-        COM_INTERFACE_ENTRY(IProcess)
-    END_COM_MAP()
     DECLARE_EMPTY_CTOR_DTOR(GuestProcess)
 
@@ -52 +44 @@
     /** @}  */
 
-    /** @name IProcess interface.
-     * @{ */
-    STDMETHOD(COMGETTER(Arguments))(ComSafeArrayOut(BSTR, aArguments));
-    STDMETHOD(COMGETTER(Environment))(ComSafeArrayOut(BSTR, aEnvironment));
-    STDMETHOD(COMGETTER(EventSource))(IEventSource ** aEventSource);
-    STDMETHOD(COMGETTER(ExecutablePath))(BSTR *aExecutablePath);
-    STDMETHOD(COMGETTER(ExitCode))(LONG *aExitCode);
-    STDMETHOD(COMGETTER(Name))(BSTR *aName);
-    STDMETHOD(COMGETTER(PID))(ULONG *aPID);
-    STDMETHOD(COMGETTER(Status))(ProcessStatus_T *aStatus);
-
-    STDMETHOD(Read)(ULONG aHandle, ULONG aToRead, ULONG aTimeoutMS, ComSafeArrayOut(BYTE, aData));
-    STDMETHOD(Terminate)(void);
-    STDMETHOD(WaitFor)(ULONG aWaitFlags, ULONG aTimeoutMS, ProcessWaitResult_T *aReason);
-    STDMETHOD(WaitForArray)(ComSafeArrayIn(ProcessWaitForFlag_T, aFlags), ULONG aTimeoutMS, ProcessWaitResult_T *aReason);
-    STDMETHOD(Write)(ULONG aHandle, ULONG aFlags, ComSafeArrayIn(BYTE, aData), ULONG aTimeoutMS, ULONG *aWritten);
-    STDMETHOD(WriteArray)(ULONG aHandle, ComSafeArrayIn(ProcessInputFlag_T, aFlags), ComSafeArrayIn(BYTE, aData), ULONG aTimeoutMS, ULONG *aWritten);
-    /** @}  */
 
 public:
@@ -75 +49 @@
      * @{ */
     int i_callbackDispatcher(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
-    inline int checkPID(uint32_t uPID);
-    static Utf8Str guestErrorToString(int guestRc);
+    inline int i_checkPID(uint32_t uPID);
+    static Utf8Str i_guestErrorToString(int guestRc);
     int i_onRemove(void);
-    int readData(uint32_t uHandle, uint32_t uSize, uint32_t uTimeoutMS, void *pvData, size_t cbData, uint32_t *pcbRead, int *pGuestRc);
-    static HRESULT setErrorExternal(VirtualBoxBase *pInterface, int guestRc);
-    int startProcess(uint32_t uTimeoutMS, int *pGuestRc);
-    int startProcessAsync(void);
-    int terminateProcess(uint32_t uTimeoutMS, int *pGuestRc);
-    static ProcessWaitResult_T waitFlagsToResultEx(uint32_t fWaitFlags, ProcessStatus_T oldStatus, ProcessStatus_T newStatus, uint32_t uProcFlags, uint32_t uProtocol);
-    ProcessWaitResult_T waitFlagsToResult(uint32_t fWaitFlags);
-    int waitFor(uint32_t fWaitFlags, ULONG uTimeoutMS, ProcessWaitResult_T &waitResult, int *pGuestRc);
-    int waitForInputNotify(GuestWaitEvent *pEvent, uint32_t uHandle, uint32_t uTimeoutMS, ProcessInputStatus_T *pInputStatus, uint32_t *pcbProcessed);
-    int waitForOutput(GuestWaitEvent *pEvent, uint32_t uHandle, uint32_t uTimeoutMS, void* pvData, size_t cbData, uint32_t *pcbRead);
-    int waitForStatusChange(GuestWaitEvent *pEvent, uint32_t uTimeoutMS, ProcessStatus_T *pProcessStatus, int *pGuestRc);
-    static bool waitResultImpliesEx(ProcessWaitResult_T waitResult, ProcessStatus_T procStatus, uint32_t uProcFlags, uint32_t uProtocol);
-    int writeData(uint32_t uHandle, uint32_t uFlags, void *pvData, size_t cbData, uint32_t uTimeoutMS, uint32_t *puWritten, int *pGuestRc);
+    int i_readData(uint32_t uHandle, uint32_t uSize, uint32_t uTimeoutMS, void *pvData, size_t cbData, uint32_t *pcbRead, int *pGuestRc);
+    static HRESULT i_setErrorExternal(VirtualBoxBase *pInterface, int guestRc);
+    int i_startProcess(uint32_t uTimeoutMS, int *pGuestRc);
+    int i_startProcessAsync(void);
+    int i_terminateProcess(uint32_t uTimeoutMS, int *pGuestRc);
+    static ProcessWaitResult_T i_waitFlagsToResultEx(uint32_t fWaitFlags, ProcessStatus_T oldStatus, ProcessStatus_T newStatus, uint32_t uProcFlags, uint32_t uProtocol);
+    ProcessWaitResult_T i_waitFlagsToResult(uint32_t fWaitFlags);
+    int i_waitFor(uint32_t fWaitFlags, ULONG uTimeoutMS, ProcessWaitResult_T &waitResult, int *pGuestRc);
+    int i_waitForInputNotify(GuestWaitEvent *pEvent, uint32_t uHandle, uint32_t uTimeoutMS, ProcessInputStatus_T *pInputStatus, uint32_t *pcbProcessed);
+    int i_waitForOutput(GuestWaitEvent *pEvent, uint32_t uHandle, uint32_t uTimeoutMS, void* pvData, size_t cbData, uint32_t *pcbRead);
+    int i_waitForStatusChange(GuestWaitEvent *pEvent, uint32_t uTimeoutMS, ProcessStatus_T *pProcessStatus, int *pGuestRc);
+    static bool i_waitResultImpliesEx(ProcessWaitResult_T waitResult, ProcessStatus_T procStatus, uint32_t uProcFlags, uint32_t uProtocol);
+    int i_writeData(uint32_t uHandle, uint32_t uFlags, void *pvData, size_t cbData, uint32_t uTimeoutMS, uint32_t *puWritten, int *pGuestRc);
     /** @}  */
 
@@ -96 +70 @@
     /** @name Protected internal methods.
      * @{ */
-    inline bool isAlive(void);
-    inline bool hasEnded(void);
-    int onGuestDisconnected(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
-    int onProcessInputStatus(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
-    int onProcessNotifyIO(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
-    int onProcessStatusChange(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
-    int onProcessOutput(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
-    int prepareExecuteEnv(const char *pszEnv, void **ppvList, ULONG *pcbList, ULONG *pcEnvVars);
-    int setProcessStatus(ProcessStatus_T procStatus, int procRc);
-    static DECLCALLBACK(int) startProcessThread(RTTHREAD Thread, void *pvUser);
+    inline bool i_isAlive(void);
+    inline bool i_hasEnded(void);
+    int i_onGuestDisconnected(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
+    int i_onProcessInputStatus(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
+    int i_onProcessNotifyIO(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
+    int i_onProcessStatusChange(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
+    int i_onProcessOutput(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
+    int i_prepareExecuteEnv(const char *pszEnv, void **ppvList, ULONG *pcbList, ULONG *pcEnvVars);
+    int i_setProcessStatus(ProcessStatus_T procStatus, int procRc);
+    static DECLCALLBACK(int) i_startProcessThread(RTTHREAD Thread, void *pvUser);
     /** @}  */
 
 private:
+    /** Wrapped @name IProcess data .
+     * @{ */
+     HRESULT getArguments(std::vector<com::Utf8Str> &aArguments);
+     HRESULT getEnvironment(std::vector<com::Utf8Str> &aEnvironment);
+     HRESULT getEventSource(ComPtr<IEventSource> &aEventSource);
+     HRESULT getExecutablePath(com::Utf8Str &aExecutablePath);
+     HRESULT getExitCode(LONG *aExitCode);
+     HRESULT getName(com::Utf8Str &aName);
+     HRESULT getPID(ULONG *aPID);
+     HRESULT getStatus(ProcessStatus_T *aStatus);
+
+    /** Wrapped @name IProcess methods.
+     * @{ */
+     HRESULT waitFor(ULONG aWaitFor,
+                     ULONG aTimeoutMS,
+                     ProcessWaitResult_T *aReason);
+     HRESULT waitForArray(const std::vector<ProcessWaitForFlag_T> &aWaitFor,
+                          ULONG aTimeoutMS,
+                          ProcessWaitResult_T *aReason);
+     HRESULT read(ULONG aHandle,
+                  ULONG aToRead,
+                  ULONG aTimeoutMS,
+                  std::vector<BYTE> &aData);
+     HRESULT write(ULONG aHandle,
+                   ULONG aFlags,
+                   const std::vector<BYTE> &aData,
+                   ULONG aTimeoutMS,
+                   ULONG *aWritten);
+     HRESULT writeArray(ULONG aHandle,
+                        const std::vector<ProcessInputFlag_T> &aFlags,
+                        const std::vector<BYTE> &aData,
+                        ULONG aTimeoutMS,
+                        ULONG *aWritten);
+     HRESULT terminate();
 
     /**
@@ -160 +168 @@
     int Init(GuestSession *pGuestSession, const GuestProcessStartupInfo &startupInfo, bool fAsync, int *pGuestRc);
 
-    GuestProcessStream &GetStdOut(void) { return mStdOut; }
-
-    GuestProcessStream &GetStdErr(void) { return mStdErr; }
-
-    int Wait(uint32_t fFlags, int *pGuestRc);
-
-    int WaitEx(uint32_t fFlags, GuestProcessStreamBlock *pStreamBlock, int *pGuestRc);
-
-    int GetCurrentBlock(uint32_t uHandle, GuestProcessStreamBlock &strmBlock);
-
-    bool IsRunning(void);
-
-    static int Run(GuestSession *pGuestSession, const GuestProcessStartupInfo &startupInfo, int *pGuestRc);
-
-    static int RunEx(GuestSession *pGuestSession, const GuestProcessStartupInfo &startupInfo, GuestCtrlStreamObjects *pStrmOutObjects,
-                     uint32_t cStrmOutObjects, int *pGuestRc);
-
-    int TerminatedOk(LONG *pExitCode);
-
-    int Terminate(uint32_t uTimeoutMS, int *pGuestRc);
+    GuestProcessStream &i_getStdOut(void) { return mStdOut; }
+
+    GuestProcessStream &i_getStdErr(void) { return mStdErr; }
+
+    int i_wait(uint32_t fFlags, int *pGuestRc);
+
+    int i_waitEx(uint32_t fFlags, GuestProcessStreamBlock *pStreamBlock, int *pGuestRc);
+
+    int i_getCurrentBlock(uint32_t uHandle, GuestProcessStreamBlock &strmBlock);
+
+    bool i_isRunning(void);
+
+    static int i_run(GuestSession *pGuestSession, const GuestProcessStartupInfo &startupInfo, int *pGuestRc);
+
+    static int i_runEx(GuestSession *pGuestSession, const GuestProcessStartupInfo &startupInfo, GuestCtrlStreamObjects *pStrmOutObjects,
+                       uint32_t cStrmOutObjects, int *pGuestRc);
+
+    int i_terminatedOk(LONG *pExitCode);
+
+    int i_terminate(uint32_t uTimeoutMS, int *pGuestRc);
 
 protected:

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

@@ -276 +276 @@
 
     int guestRc;
-    int rc = mData.mProcessTool.Terminate(30 * 1000, &guestRc);
+    int rc = mData.mProcessTool.i_terminate(30 * 1000, &guestRc);
     if (RT_FAILURE(rc))
     {
@@ -282 +282 @@
         {
             case VERR_GSTCTL_GUEST_ERROR:
-                hr = GuestProcess::setErrorExternal(this, guestRc);
+                hr = GuestProcess::i_setErrorExternal(this, guestRc);
                 break;
 
@@ -321 +321 @@
     int guestRc;
 
-    int rc = mData.mProcessTool.WaitEx(GUESTPROCESSTOOL_FLAG_STDOUT_BLOCK,
-                                       &curBlock, &guestRc);
+    int rc = mData.mProcessTool.i_waitEx(GUESTPROCESSTOOL_FLAG_STDOUT_BLOCK,
+                                         &curBlock, &guestRc);
 
     /*
@@ -329 +329 @@
      */
     if (   RT_SUCCESS(rc)
-        && !mData.mProcessTool.IsRunning())
-    {
-        rc = mData.mProcessTool.TerminatedOk(NULL /* Exit code */);
+        && !mData.mProcessTool.i_isRunning())
+    {
+        rc = mData.mProcessTool.i_terminatedOk(NULL /* Exit code */);
         if (rc == VERR_NOT_EQUAL)
             rc = VERR_ACCESS_DENIED;
@@ -379 +379 @@
         {
             case VERR_GSTCTL_GUEST_ERROR:
-                hr = GuestProcess::setErrorExternal(this, guestRc);
+                hr = GuestProcess::i_setErrorExternal(this, guestRc);
                 break;
 

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

@@ -65 +65 @@
     virtual ~GuestProcessTask(void) { }
 
-    int rc(void) const { return mRC; }
-    bool isOk(void) const { return RT_SUCCESS(mRC); }
-    const ComObjPtr<GuestProcess> &Process(void) const { return mProcess; }
+    int i_rc(void) const { return mRC; }
+    bool i_isOk(void) const { return RT_SUCCESS(mRC); }
+    const ComObjPtr<GuestProcess> &i_process(void) const { return mProcess; }
 
 protected:
@@ -271 +271 @@
     /* Terminate process if not already done yet. */
     int guestRc = VINF_SUCCESS;
-    int vrc = terminateProcess(30 * 1000, &guestRc); /** @todo Make timeouts configurable. */
+    int vrc = i_terminateProcess(30 * 1000, &guestRc); /** @todo Make timeouts configurable. */
     /* Note: Don't return here yet; first uninit all other stuff in
      *       case of failure. */
@@ -284 +284 @@
 // implementation of public getters/setters for attributes
 /////////////////////////////////////////////////////////////////////////////
-
-STDMETHODIMP GuestProcess::COMGETTER(Arguments)(ComSafeArrayOut(BSTR, aArguments))
+HRESULT GuestProcess::getArguments(std::vector<com::Utf8Str> &aArguments)
 {
 #ifndef VBOX_WITH_GUEST_CONTROL
@@ -291 +290 @@
 #else
     LogFlowThisFuncEnter();
-
-    CheckComArgOutSafeArrayPointerValid(aArguments);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -304 +298 @@
          it != mData.mProcess.mArguments.end();
          it++, s++)
-    {
-        Bstr tmp = *it;
-        tmp.cloneTo(&collection[s]);
-    }
-
-    collection.detachTo(ComSafeArrayOutArg(aArguments));
+         aArguments[s] = (*it);
 
     return S_OK;
@@ -315 +304 @@
 }
 
-STDMETHODIMP GuestProcess::COMGETTER(Environment)(ComSafeArrayOut(BSTR, aEnvironment))
+HRESULT GuestProcess::getEnvironment(std::vector<com::Utf8Str> &aEnvironment)
 {
 #ifndef VBOX_WITH_GUEST_CONTROL
@@ -322 +311 @@
     LogFlowThisFuncEnter();
 
-    CheckComArgOutSafeArrayPointerValid(aEnvironment);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
     com::SafeArray<BSTR> arguments(mData.mProcess.mEnvironment.Size());
     for (size_t i = 0; i < arguments.size(); i++)
-    {
-        Bstr tmp = mData.mProcess.mEnvironment.Get(i);
-        tmp.cloneTo(&arguments[i]);
-    }
-    arguments.detachTo(ComSafeArrayOutArg(aEnvironment));
+        aEnvironment[i] = mData.mProcess.mEnvironment.Get(i);
 
     return S_OK;
@@ -341 +321 @@
 }
 
-STDMETHODIMP GuestProcess::COMGETTER(EventSource)(IEventSource ** aEventSource)
+HRESULT GuestProcess::getEventSource(ComPtr<IEventSource> &aEventSource)
 {
 #ifndef VBOX_WITH_GUEST_CONTROL
@@ -348 +328 @@
     LogFlowThisFuncEnter();
 
-    CheckComArgOutPointerValid(aEventSource);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
     // no need to lock - lifetime constant
-    mEventSource.queryInterfaceTo(aEventSource);
+    mEventSource.queryInterfaceTo(aEventSource.asOutParam());
 
     LogFlowThisFuncLeave();
@@ -361 +336 @@
 }
 
-STDMETHODIMP GuestProcess::COMGETTER(ExecutablePath)(BSTR *aExecutablePath)
+HRESULT GuestProcess::getExecutablePath(com::Utf8Str &aExecutablePath)
 {
 #ifndef VBOX_WITH_GUEST_CONTROL
@@ -368 +343 @@
     LogFlowThisFuncEnter();
 
-    CheckComArgOutPointerValid(aExecutablePath);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    mData.mProcess.mCommand.cloneTo(aExecutablePath);
+    aExecutablePath = mData.mProcess.mCommand;
 
     return S_OK;
@@ -381 +351 @@
 }
 
-STDMETHODIMP GuestProcess::COMGETTER(ExitCode)(LONG *aExitCode)
+HRESULT GuestProcess::getExitCode(LONG *aExitCode)
 {
 #ifndef VBOX_WITH_GUEST_CONTROL
@@ -388 +358 @@
     LogFlowThisFuncEnter();
 
-    CheckComArgOutPointerValid(aExitCode);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -401 +366 @@
 }
 
-STDMETHODIMP GuestProcess::COMGETTER(Name)(BSTR *aName)
+HRESULT GuestProcess::getName(com::Utf8Str &aName)
 {
 #ifndef VBOX_WITH_GUEST_CONTROL
@@ -408 +373 @@
     LogFlowThisFuncEnter();
 
-    CheckComArgOutPointerValid(aName);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    mData.mProcess.mName.cloneTo(aName);
+    aName = mData.mProcess.mName;
 
     return S_OK;
@@ -421 +381 @@
 }
 
-STDMETHODIMP GuestProcess::COMGETTER(PID)(ULONG *aPID)
+HRESULT GuestProcess::getPID(ULONG *aPID)
 {
 #ifndef VBOX_WITH_GUEST_CONTROL
@@ -428 +388 @@
     LogFlowThisFuncEnter();
 
-    CheckComArgOutPointerValid(aPID);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -441 +396 @@
 }
 
-STDMETHODIMP GuestProcess::COMGETTER(Status)(ProcessStatus_T *aStatus)
+HRESULT GuestProcess::getStatus(ProcessStatus_T *aStatus)
 {
 #ifndef VBOX_WITH_GUEST_CONTROL
@@ -447 +402 @@
 #else
     LogFlowThisFuncEnter();
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -476 +428 @@
         case GUEST_DISCONNECTED:
         {
-            vrc = onGuestDisconnected(pCbCtx, pSvcCb);
+            vrc = i_onGuestDisconnected(pCbCtx, pSvcCb);
             break;
         }
@@ -482 +434 @@
         case GUEST_EXEC_STATUS:
         {
-            vrc = onProcessStatusChange(pCbCtx, pSvcCb);
+            vrc = i_onProcessStatusChange(pCbCtx, pSvcCb);
             break;
         }
@@ -488 +440 @@
         case GUEST_EXEC_OUTPUT:
         {
-            vrc = onProcessOutput(pCbCtx, pSvcCb);
+            vrc = i_onProcessOutput(pCbCtx, pSvcCb);
             break;
         }
@@ -494 +446 @@
         case GUEST_EXEC_INPUT_STATUS:
         {
-            vrc = onProcessInputStatus(pCbCtx, pSvcCb);
+            vrc = i_onProcessInputStatus(pCbCtx, pSvcCb);
             break;
         }
@@ -526 +478 @@
  * @param   uPID                    PID to check.
  */
-inline int GuestProcess::checkPID(uint32_t uPID)
+inline int GuestProcess::i_checkPID(uint32_t uPID)
 {
     int rc = VINF_SUCCESS;
@@ -545 +497 @@
 
 /* static */
-Utf8Str GuestProcess::guestErrorToString(int guestRc)
+Utf8Str GuestProcess::i_guestErrorToString(int guestRc)
 {
     Utf8Str strError;
@@ -612 +564 @@
 }
 
-inline bool GuestProcess::isAlive(void)
+inline bool GuestProcess::i_isAlive(void)
 {
     return (   mData.mStatus == ProcessStatus_Started
@@ -619 +571 @@
 }
 
-inline bool GuestProcess::hasEnded(void)
+inline bool GuestProcess::i_hasEnded(void)
 {
     return (   mData.mStatus == ProcessStatus_TerminatedNormally
@@ -630 +582 @@
 }
 
-int GuestProcess::onGuestDisconnected(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
+int GuestProcess::i_onGuestDisconnected(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
 {
     AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
     AssertPtrReturn(pSvcCbData, VERR_INVALID_POINTER);
 
-    int vrc = setProcessStatus(ProcessStatus_Down, VINF_SUCCESS);
+    int vrc = i_setProcessStatus(ProcessStatus_Down, VINF_SUCCESS);
 
     LogFlowFuncLeaveRC(vrc);
@@ -641 +593 @@
 }
 
-int GuestProcess::onProcessInputStatus(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
+int GuestProcess::i_onProcessInputStatus(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
 {
     AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
@@ -664 +616 @@
                      dataCb.uPID, dataCb.uStatus, dataCb.uFlags, dataCb.uProcessed));
 
-    vrc = checkPID(dataCb.uPID);
+    vrc = i_checkPID(dataCb.uPID);
     if (RT_SUCCESS(vrc))
     {
@@ -708 +660 @@
 }
 
-int GuestProcess::onProcessNotifyIO(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
+int GuestProcess::i_onProcessNotifyIO(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
 {
     AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
@@ -716 +668 @@
 }
 
-int GuestProcess::onProcessStatusChange(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
+int GuestProcess::i_onProcessStatusChange(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
 {
     AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
@@ -738 +690 @@
                      dataCb.uPID, dataCb.uStatus, dataCb.uFlags));
 
-    vrc = checkPID(dataCb.uPID);
+    vrc = i_checkPID(dataCb.uPID);
     if (RT_SUCCESS(vrc))
     {
@@ -817 +769 @@
 
         /* Set the process status. */
-        int rc2 = setProcessStatus(procStatus, procRc);
+        int rc2 = i_setProcessStatus(procStatus, procRc);
         if (RT_SUCCESS(vrc))
             vrc = rc2;
@@ -826 +778 @@
 }
 
-int GuestProcess::onProcessOutput(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
+int GuestProcess::i_onProcessOutput(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
 {
     AssertPtrReturn(pSvcCbData, VERR_INVALID_POINTER);
@@ -847 +799 @@
                      dataCb.uPID, dataCb.uHandle, dataCb.uFlags, dataCb.pvData, dataCb.cbData));
 
-    vrc = checkPID(dataCb.uPID);
+    vrc = i_checkPID(dataCb.uPID);
     if (RT_SUCCESS(vrc))
     {
@@ -890 +842 @@
 }
 
-int GuestProcess::readData(uint32_t uHandle, uint32_t uSize, uint32_t uTimeoutMS,
-                           void *pvData, size_t cbData, uint32_t *pcbRead, int *pGuestRc)
+int GuestProcess::i_readData(uint32_t uHandle, uint32_t uSize, uint32_t uTimeoutMS,
+                             void *pvData, size_t cbData, uint32_t *pcbRead, int *pGuestRc)
 {
     LogFlowThisFunc(("uPID=%RU32, uHandle=%RU32, uSize=%RU32, uTimeoutMS=%RU32, pvData=%p, cbData=%RU32, pGuestRc=%p\n",
@@ -961 +913 @@
 
     if (RT_SUCCESS(vrc))
-        vrc = waitForOutput(pEvent, uHandle, uTimeoutMS,
-                            pvData, cbData, pcbRead);
+        vrc = i_waitForOutput(pEvent, uHandle, uTimeoutMS,
+                              pvData, cbData, pcbRead);
 
     unregisterWaitEvent(pEvent);
@@ -971 +923 @@
 
 /* Does not do locking; caller is responsible for that! */
-int GuestProcess::setProcessStatus(ProcessStatus_T procStatus, int procRc)
+int GuestProcess::i_setProcessStatus(ProcessStatus_T procStatus, int procRc)
 {
     LogFlowThisFuncEnter();
@@ -1004 +956 @@
             hr = errorInfo->initEx(VBOX_E_IPRT_ERROR, mData.mLastError,
                                    COM_IIDOF(IGuestProcess), getComponentName(),
-                                   guestErrorToString(mData.mLastError));
+                                   i_guestErrorToString(mData.mLastError));
             ComAssertComRC(hr);
         }
@@ -1036 +988 @@
 
 /* static */
-HRESULT GuestProcess::setErrorExternal(VirtualBoxBase *pInterface, int guestRc)
+HRESULT GuestProcess::i_setErrorExternal(VirtualBoxBase *pInterface, int guestRc)
 {
     AssertPtr(pInterface);
     AssertMsg(RT_FAILURE(guestRc), ("Guest rc does not indicate a failure when setting error\n"));
 
-    return pInterface->setError(VBOX_E_IPRT_ERROR, GuestProcess::guestErrorToString(guestRc).c_str());
-}
-
-int GuestProcess::startProcess(uint32_t uTimeoutMS, int *pGuestRc)
+    return pInterface->setError(VBOX_E_IPRT_ERROR, GuestProcess::i_guestErrorToString(guestRc).c_str());
+}
+
+int GuestProcess::i_startProcess(uint32_t uTimeoutMS, int *pGuestRc)
 {
     LogFlowThisFunc(("uTimeoutMS=%RU32, procCmd=%s, procTimeoutMS=%RU32, procFlags=%x, sessionID=%RU32\n",
@@ -1172 +1124 @@
         if (RT_FAILURE(vrc))
         {
-            int rc2 = setProcessStatus(ProcessStatus_Error, vrc);
+            int rc2 = i_setProcessStatus(ProcessStatus_Error, vrc);
             AssertRC(rc2);
         }
@@ -1182 +1134 @@
 
     if (RT_SUCCESS(vrc))
-        vrc = waitForStatusChange(pEvent, uTimeoutMS,
-                                  NULL /* Process status */, pGuestRc);
+        vrc = i_waitForStatusChange(pEvent, uTimeoutMS,
+                                    NULL /* Process status */, pGuestRc);
     unregisterWaitEvent(pEvent);
 
@@ -1190 +1142 @@
 }
 
-int GuestProcess::startProcessAsync(void)
+int GuestProcess::i_startProcessAsync(void)
 {
     LogFlowThisFuncEnter();
@@ -1201 +1153 @@
          * worker thread. */
         std::auto_ptr<GuestProcessStartTask> pTask(new GuestProcessStartTask(this));
-        AssertReturn(pTask->isOk(), pTask->rc());
-
-        vrc = RTThreadCreate(NULL, GuestProcess::startProcessThread,
+        AssertReturn(pTask->i_isOk(), pTask->i_rc());
+
+        vrc = RTThreadCreate(NULL, GuestProcess::i_startProcessThread,
                              (void *)pTask.get(), 0,
                              RTTHREADTYPE_MAIN_WORKER, 0,
@@ -1223 +1175 @@
 
 /* static */
-DECLCALLBACK(int) GuestProcess::startProcessThread(RTTHREAD Thread, void *pvUser)
+DECLCALLBACK(int) GuestProcess::i_startProcessThread(RTTHREAD Thread, void *pvUser)
 {
     LogFlowFunc(("pvUser=%p\n", pvUser));
@@ -1230 +1182 @@
     AssertPtr(pTask.get());
 
-    const ComObjPtr<GuestProcess> pProcess(pTask->Process());
+    const ComObjPtr<GuestProcess> pProcess(pTask->i_process());
     Assert(!pProcess.isNull());
 
@@ -1236 +1188 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    int vrc = pProcess->startProcess(30 * 1000 /* 30s timeout */,
-                                     NULL /* Guest rc, ignored */);
+    int vrc = pProcess->i_startProcess(30 * 1000 /* 30s timeout */,
+                                       NULL /* Guest rc, ignored */);
     /* Nothing to do here anymore. */
 
@@ -1244 +1196 @@
 }
 
-int GuestProcess::terminateProcess(uint32_t uTimeoutMS, int *pGuestRc)
+int GuestProcess::i_terminateProcess(uint32_t uTimeoutMS, int *pGuestRc)
 {
     /* pGuestRc is optional. */
@@ -1293 +1245 @@
             vrc = sendCommand(HOST_EXEC_TERMINATE, i, paParms);
             if (RT_SUCCESS(vrc))
-                vrc = waitForStatusChange(pEvent, uTimeoutMS,
-                                          NULL /* ProcessStatus */, pGuestRc);
+                vrc = i_waitForStatusChange(pEvent, uTimeoutMS,
+                                            NULL /* ProcessStatus */, pGuestRc);
             unregisterWaitEvent(pEvent);
         }
@@ -1304 +1256 @@
 
 /* static */
-ProcessWaitResult_T GuestProcess::waitFlagsToResultEx(uint32_t fWaitFlags,
-                                                      ProcessStatus_T oldStatus, ProcessStatus_T newStatus,
-                                                      uint32_t uProcFlags, uint32_t uProtocol)
+ProcessWaitResult_T GuestProcess::i_waitFlagsToResultEx(uint32_t fWaitFlags,
+                                                        ProcessStatus_T oldStatus, ProcessStatus_T newStatus,
+                                                        uint32_t uProcFlags, uint32_t uProtocol)
 {
     ProcessWaitResult_T waitResult = ProcessWaitResult_None;
@@ -1403 +1355 @@
 }
 
-ProcessWaitResult_T GuestProcess::waitFlagsToResult(uint32_t fWaitFlags)
+ProcessWaitResult_T GuestProcess::i_waitFlagsToResult(uint32_t fWaitFlags)
 {
     AssertPtr(mSession);
-    return GuestProcess::waitFlagsToResultEx(fWaitFlags,
-                                             mData.mStatus /* curStatus */, mData.mStatus /* newStatus */,
-                                             mData.mProcess.mFlags, mSession->getProtocolVersion());
-}
-
-int GuestProcess::waitFor(uint32_t fWaitFlags, ULONG uTimeoutMS,
-                          ProcessWaitResult_T &waitResult, int *pGuestRc)
+    return GuestProcess::i_waitFlagsToResultEx(fWaitFlags,
+                                               mData.mStatus /* curStatus */, mData.mStatus /* newStatus */,
+                                               mData.mProcess.mFlags, mSession->getProtocolVersion());
+}
+
+int GuestProcess::i_waitFor(uint32_t fWaitFlags, ULONG uTimeoutMS,
+                            ProcessWaitResult_T &waitResult, int *pGuestRc)
 {
     AssertReturn(fWaitFlags, VERR_INVALID_PARAMETER);
@@ -1433 +1385 @@
     }
 
-    waitResult = waitFlagsToResult(fWaitFlags);
+    waitResult = i_waitFlagsToResult(fWaitFlags);
 
     /* No waiting needed? Return immediately using the last set error. */
@@ -1483 +1435 @@
         }
 
-        vrc = waitForStatusChange(pEvent,
+        vrc = i_waitForStatusChange(pEvent,
                                     uTimeoutMS == RT_INDEFINITE_WAIT
-                                  ? RT_INDEFINITE_WAIT : uTimeoutMS - (uint32_t)u64ElapsedMS,
-                                  &newStatus, pGuestRc);
+                                    ? RT_INDEFINITE_WAIT : uTimeoutMS - (uint32_t)u64ElapsedMS,
+                                    &newStatus, pGuestRc);
         if (RT_SUCCESS(vrc))
         {
             alock.acquire();
 
-            waitResult = waitFlagsToResultEx(fWaitFlags, curStatus, newStatus,
-                                             mData.mProcess.mFlags, mSession->getProtocolVersion());
+            waitResult = i_waitFlagsToResultEx(fWaitFlags, curStatus, newStatus,
+                                               mData.mProcess.mFlags, mSession->getProtocolVersion());
 #ifdef DEBUG
             LogFlowThisFunc(("Got new status change: fWaitFlags=0x%x, newStatus=%RU32, waitResult=%RU32\n",
@@ -1513 +1465 @@
 }
 
-int GuestProcess::waitForInputNotify(GuestWaitEvent *pEvent, uint32_t uHandle, uint32_t uTimeoutMS,
-                                     ProcessInputStatus_T *pInputStatus, uint32_t *pcbProcessed)
+int GuestProcess::i_waitForInputNotify(GuestWaitEvent *pEvent, uint32_t uHandle, uint32_t uTimeoutMS,
+                                       ProcessInputStatus_T *pInputStatus, uint32_t *pcbProcessed)
 {
     AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
@@ -1549 +1501 @@
 }
 
-int GuestProcess::waitForOutput(GuestWaitEvent *pEvent, uint32_t uHandle, uint32_t uTimeoutMS,
-                                void *pvData, size_t cbData, uint32_t *pcbRead)
+int GuestProcess::i_waitForOutput(GuestWaitEvent *pEvent, uint32_t uHandle, uint32_t uTimeoutMS,
+                                  void *pvData, size_t cbData, uint32_t *pcbRead)
 {
     AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
@@ -1631 +1583 @@
 }
 
-int GuestProcess::waitForStatusChange(GuestWaitEvent *pEvent, uint32_t uTimeoutMS,
-                                      ProcessStatus_T *pProcessStatus, int *pGuestRc)
+int GuestProcess::i_waitForStatusChange(GuestWaitEvent *pEvent, uint32_t uTimeoutMS,
+                                        ProcessStatus_T *pProcessStatus, int *pGuestRc)
 {
     AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
@@ -1677 +1629 @@
 
 /* static */
-bool GuestProcess::waitResultImpliesEx(ProcessWaitResult_T waitResult,
-                                       ProcessStatus_T procStatus, uint32_t uProcFlags,
-                                       uint32_t uProtocol)
+bool GuestProcess::i_waitResultImpliesEx(ProcessWaitResult_T waitResult,
+                                         ProcessStatus_T procStatus, uint32_t uProcFlags,
+                                         uint32_t uProtocol)
 {
     bool fImplies;
@@ -1707 +1659 @@
 }
 
-int GuestProcess::writeData(uint32_t uHandle, uint32_t uFlags,
-                            void *pvData, size_t cbData, uint32_t uTimeoutMS, uint32_t *puWritten, int *pGuestRc)
+int GuestProcess::i_writeData(uint32_t uHandle, uint32_t uFlags,
+                              void *pvData, size_t cbData, uint32_t uTimeoutMS, uint32_t *puWritten, int *pGuestRc)
 {
     LogFlowThisFunc(("uPID=%RU32, uHandle=%RU32, uFlags=%RU32, pvData=%p, cbData=%RU32, uTimeoutMS=%RU32, puWritten=%p, pGuestRc=%p\n",
@@ -1767 +1719 @@
     {
         ProcessInputStatus_T inputStatus;
-        vrc = waitForInputNotify(pEvent, uHandle, uTimeoutMS,
-                                 &inputStatus, &cbProcessed);
+        vrc = i_waitForInputNotify(pEvent, uHandle, uTimeoutMS,
+                                   &inputStatus, &cbProcessed);
         if (RT_SUCCESS(vrc))
         {
@@ -1789 +1741 @@
 /////////////////////////////////////////////////////////////////////////////
 
-STDMETHODIMP GuestProcess::Read(ULONG aHandle, ULONG aToRead, ULONG aTimeoutMS, ComSafeArrayOut(BYTE, aData))
+HRESULT GuestProcess::read(ULONG aHandle, ULONG aToRead, ULONG aTimeoutMS, std::vector<BYTE> &aData)
 {
 #ifndef VBOX_WITH_GUEST_CONTROL
@@ -1798 +1750 @@
     if (aToRead == 0)
         return setError(E_INVALIDARG, tr("The size to read is zero"));
-    CheckComArgOutSafeArrayPointerValid(aData);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
     com::SafeArray<BYTE> data((size_t)aToRead);
@@ -1809 +1757 @@
 
     uint32_t cbRead; int guestRc;
-    int vrc = readData(aHandle, aToRead, aTimeoutMS, data.raw(), aToRead, &cbRead, &guestRc);
+    int vrc = i_readData(aHandle, aToRead, aTimeoutMS, data.raw(), aToRead, &cbRead, &guestRc);
     if (RT_SUCCESS(vrc))
     {
         if (data.size() != cbRead)
             data.resize(cbRead);
-        data.detachTo(ComSafeArrayOutArg(aData));
+        for(size_t i = 0; i < data.size(); ++i)
+            aData[i] = data[i];
     }
     else
@@ -1821 +1770 @@
         {
             case VERR_GSTCTL_GUEST_ERROR:
-                hr = GuestProcess::setErrorExternal(this, guestRc);
+                hr = GuestProcess::i_setErrorExternal(this, guestRc);
                 break;
 
@@ -1839 +1788 @@
 }
 
-STDMETHODIMP GuestProcess::Terminate(void)
+HRESULT GuestProcess::terminate()
 {
 #ifndef VBOX_WITH_GUEST_CONTROL
     ReturnComNotImplemented();
 #else
-    LogFlowThisFuncEnter();
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
     HRESULT hr = S_OK;
 
     int guestRc;
-    int vrc = terminateProcess(30 * 1000 /* Timeout in ms */,
-                               &guestRc);
+    int vrc = i_terminateProcess(30 * 1000 /* Timeout in ms */,
+                                 &guestRc);
     if (RT_FAILURE(vrc))
     {
@@ -1859 +1804 @@
         {
            case VERR_GSTCTL_GUEST_ERROR:
-                hr = GuestProcess::setErrorExternal(this, guestRc);
+                hr = GuestProcess::i_setErrorExternal(this, guestRc);
                 break;
 
@@ -1888 +1833 @@
 }
 
-STDMETHODIMP GuestProcess::WaitFor(ULONG aWaitFlags, ULONG aTimeoutMS, ProcessWaitResult_T *aReason)
+HRESULT GuestProcess::waitFor(ULONG aWaitFor,
+                              ULONG aTimeoutMS,
+                              ProcessWaitResult_T *aReason)
+{
+#ifndef VBOX_WITH_GUEST_CONTROL
+    ReturnComNotImplemented();
+#else
+
+    /*
+     * Note: Do not hold any locks here while waiting!
+     */
+    HRESULT hr = S_OK;
+
+    int guestRc; ProcessWaitResult_T waitResult;
+    int vrc = i_waitFor(aWaitFor, aTimeoutMS, waitResult, &guestRc);
+    if (RT_SUCCESS(vrc))
+    {
+        *aReason = waitResult;
+    }
+    else
+    {
+        switch (vrc)
+        {
+            case VERR_GSTCTL_GUEST_ERROR:
+                hr = GuestProcess::i_setErrorExternal(this, guestRc);
+                break;
+
+            case VERR_TIMEOUT:
+                *aReason = ProcessWaitResult_Timeout;
+                break;
+
+            default:
+                hr = setError(VBOX_E_IPRT_ERROR,
+                              tr("Waiting for process \"%s\" (PID %RU32) failed: %Rrc"),
+                              mData.mProcess.mCommand.c_str(), mData.mPID, vrc);
+                break;
+        }
+    }
+
+    LogFlowFuncLeaveRC(vrc);
+    return hr;
+#endif /* VBOX_WITH_GUEST_CONTROL */
+}
+
+HRESULT GuestProcess::waitForArray(const std::vector<ProcessWaitForFlag_T> &aWaitFor, ULONG aTimeoutMS, ProcessWaitResult_T *aReason)
+
+{
+#ifndef VBOX_WITH_GUEST_CONTROL
+    ReturnComNotImplemented();
+#else
+    /*
+     * Note: Do not hold any locks here while waiting!
+     */
+    uint32_t fWaitFor = ProcessWaitForFlag_None;
+    for (size_t i = 0; i < aWaitFor.size(); i++)
+        fWaitFor |= aWaitFor[i];
+
+    return WaitFor(fWaitFor, aTimeoutMS, aReason);
+#endif /* VBOX_WITH_GUEST_CONTROL */
+}
+
+HRESULT GuestProcess::write(ULONG aHandle, ULONG aFlags, const std::vector<BYTE> &aData,
+                            ULONG aTimeoutMS, ULONG *aWritten)
 {
 #ifndef VBOX_WITH_GUEST_CONTROL
@@ -1895 +1902 @@
     LogFlowThisFuncEnter();
 
-    CheckComArgOutPointerValid(aReason);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    /*
-     * Note: Do not hold any locks here while waiting!
-     */
     HRESULT hr = S_OK;
-
-    int guestRc; ProcessWaitResult_T waitResult;
-    int vrc = waitFor(aWaitFlags, aTimeoutMS, waitResult, &guestRc);
-    if (RT_SUCCESS(vrc))
-    {
-        *aReason = waitResult;
-    }
-    else
+    com::SafeArray<BYTE> data;
+    for(size_t i = 0; i < aData.size(); ++i)
+        data[i] = aData[i];
+    uint32_t cbWritten; int guestRc;
+    int vrc = i_writeData(aHandle, aFlags, data.raw(), data.size(), aTimeoutMS, &cbWritten, &guestRc);
+    if (RT_FAILURE(vrc))
     {
         switch (vrc)
         {
             case VERR_GSTCTL_GUEST_ERROR:
-                hr = GuestProcess::setErrorExternal(this, guestRc);
-                break;
-
-            case VERR_TIMEOUT:
-                *aReason = ProcessWaitResult_Timeout;
+                hr = GuestProcess::i_setErrorExternal(this, guestRc);
                 break;
 
             default:
                 hr = setError(VBOX_E_IPRT_ERROR,
-                              tr("Waiting for process \"%s\" (PID %RU32) failed: %Rrc"),
+                              tr("Writing to process \"%s\" (PID %RU32) failed: %Rrc"),
                               mData.mProcess.mCommand.c_str(), mData.mPID, vrc);
                 break;
         }
     }
+
+    LogFlowThisFunc(("rc=%Rrc, aWritten=%RU32\n", vrc, cbWritten));
+
+    *aWritten = (ULONG)cbWritten;
 
     LogFlowFuncLeaveRC(vrc);
@@ -1936 +1933 @@
 }
 
-STDMETHODIMP GuestProcess::WaitForArray(ComSafeArrayIn(ProcessWaitForFlag_T, aFlags), ULONG aTimeoutMS, ProcessWaitResult_T *aReason)
+HRESULT GuestProcess::writeArray(ULONG aHandle, const std::vector<ProcessInputFlag_T> &aFlags,
+                                 const std::vector<BYTE> &aData, ULONG aTimeoutMS, ULONG *aWritten)
 {
 #ifndef VBOX_WITH_GUEST_CONTROL
@@ -1943 +1941 @@
     LogFlowThisFuncEnter();
 
-    CheckComArgOutPointerValid(aReason);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    /*
-     * Note: Do not hold any locks here while waiting!
-     */
-    uint32_t fWaitFor = ProcessWaitForFlag_None;
-    com::SafeArray<ProcessWaitForFlag_T> flags(ComSafeArrayInArg(aFlags));
-    for (size_t i = 0; i < flags.size(); i++)
-        fWaitFor |= flags[i];
-
-    return WaitFor(fWaitFor, aTimeoutMS, aReason);
-#endif /* VBOX_WITH_GUEST_CONTROL */
-}
-
-STDMETHODIMP GuestProcess::Write(ULONG aHandle, ULONG aFlags,
-                                 ComSafeArrayIn(BYTE, aData), ULONG aTimeoutMS, ULONG *aWritten)
-{
-#ifndef VBOX_WITH_GUEST_CONTROL
-    ReturnComNotImplemented();
-#else
-    LogFlowThisFuncEnter();
-
-    CheckComArgSafeArrayNotNull(aData);
-    CheckComArgOutPointerValid(aWritten);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    com::SafeArray<BYTE> data(ComSafeArrayInArg(aData));
-
-    HRESULT hr = S_OK;
-
-    uint32_t cbWritten; int guestRc;
-    int vrc = writeData(aHandle, aFlags, data.raw(), data.size(), aTimeoutMS, &cbWritten, &guestRc);
-    if (RT_FAILURE(vrc))
-    {
-        switch (vrc)
-        {
-            case VERR_GSTCTL_GUEST_ERROR:
-                hr = GuestProcess::setErrorExternal(this, guestRc);
-                break;
-
-            default:
-                hr = setError(VBOX_E_IPRT_ERROR,
-                              tr("Writing to process \"%s\" (PID %RU32) failed: %Rrc"),
-                              mData.mProcess.mCommand.c_str(), mData.mPID, vrc);
-                break;
-        }
-    }
-
-    LogFlowThisFunc(("rc=%Rrc, aWritten=%RU32\n", vrc, cbWritten));
-
-    *aWritten = (ULONG)cbWritten;
-
-    LogFlowFuncLeaveRC(vrc);
-    return hr;
-#endif /* VBOX_WITH_GUEST_CONTROL */
-}
-
-STDMETHODIMP GuestProcess::WriteArray(ULONG aHandle, ComSafeArrayIn(ProcessInputFlag_T, aFlags),
-                                      ComSafeArrayIn(BYTE, aData), ULONG aTimeoutMS, ULONG *aWritten)
-{
-#ifndef VBOX_WITH_GUEST_CONTROL
-    ReturnComNotImplemented();
-#else
-    LogFlowThisFuncEnter();
-
-    CheckComArgSafeArrayNotNull(aData);
-    CheckComArgOutPointerValid(aWritten);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
     /*
      * Note: Do not hold any locks here while writing!
      */
     ULONG fWrite = ProcessInputFlag_None;
-    com::SafeArray<ProcessInputFlag_T> flags(ComSafeArrayInArg(aFlags));
-    for (size_t i = 0; i < flags.size(); i++)
-        fWrite |= flags[i];
-
-    return Write(aHandle, fWrite, ComSafeArrayInArg(aData), aTimeoutMS, aWritten);
+    for (size_t i = 0; i < aFlags.size(); i++)
+        fWrite |= aFlags[i];
+
+    return write(aHandle, fWrite, aData, aTimeoutMS, aWritten);
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }
@@ -2041 +1962 @@
 GuestProcessTool::~GuestProcessTool(void)
 {
-    Terminate(30 * 1000, NULL /* pGuestRc */);
+    i_terminate(30 * 1000, NULL /* pGuestRc */);
 }
 
@@ -2061 +1982 @@
     if (RT_SUCCESS(vrc))
         vrc = fAsync
-            ? pProcess->startProcessAsync()
-            : pProcess->startProcess(30 * 1000 /* 30s timeout */, pGuestRc);
+            ? pProcess->i_startProcessAsync()
+            : pProcess->i_startProcess(30 * 1000 /* 30s timeout */, pGuestRc);
 
     if (   RT_SUCCESS(vrc)
@@ -2078 +1999 @@
 }
 
-int GuestProcessTool::GetCurrentBlock(uint32_t uHandle, GuestProcessStreamBlock &strmBlock)
+int GuestProcessTool::i_getCurrentBlock(uint32_t uHandle, GuestProcessStreamBlock &strmBlock)
 {
     const GuestProcessStream *pStream = NULL;
@@ -2103 +2024 @@
 }
 
-bool GuestProcessTool::IsRunning(void)
+bool GuestProcessTool::i_isRunning(void)
 {
     AssertReturn(!pProcess.isNull(), false);
@@ -2122 +2043 @@
 
 /* static */
-int GuestProcessTool::Run(      GuestSession            *pGuestSession,
-                          const GuestProcessStartupInfo &startupInfo,
-                                int                     *pGuestRc)
-{
-    return RunEx(pGuestSession, startupInfo,
-                 NULL /* pStrmOutObjects */, 0 /* cStrmOutObjects */,
-                 pGuestRc);
+int GuestProcessTool::i_run(      GuestSession            *pGuestSession,
+                            const GuestProcessStartupInfo &startupInfo,
+                            int                           *pGuestRc)
+{
+    return i_runEx(pGuestSession, startupInfo,
+                   NULL /* pStrmOutObjects */, 0 /* cStrmOutObjects */,
+                   pGuestRc);
 }
 
 /* static */
-int GuestProcessTool::RunEx(      GuestSession            *pGuestSession,
-                            const GuestProcessStartupInfo &startupInfo,
-                                  GuestCtrlStreamObjects  *pStrmOutObjects,
-                                  uint32_t                 cStrmOutObjects,
-                                  int                     *pGuestRc)
+int GuestProcessTool::i_runEx(      GuestSession            *pGuestSession,
+                              const GuestProcessStartupInfo &startupInfo,
+                                    GuestCtrlStreamObjects  *pStrmOutObjects,
+                                    uint32_t                 cStrmOutObjects,
+                                    int                     *pGuestRc)
 {
     GuestProcessTool procTool; int guestRc;
@@ -2147 +2068 @@
             {
                 GuestProcessStreamBlock strmBlk;
-                vrc = procTool.WaitEx(  pStrmOutObjects
-                                      ? GUESTPROCESSTOOL_FLAG_STDOUT_BLOCK
-                                      : GUESTPROCESSTOOL_FLAG_NONE, &strmBlk, &guestRc);
+                vrc = procTool.i_waitEx(  pStrmOutObjects
+                                        ? GUESTPROCESSTOOL_FLAG_STDOUT_BLOCK
+                                        : GUESTPROCESSTOOL_FLAG_NONE, &strmBlk, &guestRc);
                 if (pStrmOutObjects)
                     pStrmOutObjects->push_back(strmBlk);
@@ -2163 +2084 @@
     {
         /* Make sure the process runs until completion. */
-        vrc = procTool.Wait(GUESTPROCESSTOOL_FLAG_NONE, &guestRc);
+        vrc = procTool.i_wait(GUESTPROCESSTOOL_FLAG_NONE, &guestRc);
         if (RT_SUCCESS(vrc))
         {
-            guestRc = procTool.TerminatedOk(NULL /* Exit code */);
+            guestRc = procTool.i_terminatedOk(NULL /* Exit code */);
             if (RT_FAILURE(guestRc))
                 vrc = VERR_GSTCTL_GUEST_ERROR;
@@ -2179 +2100 @@
 }
 
-int GuestProcessTool::TerminatedOk(LONG *pExitCode)
+int GuestProcessTool::i_terminatedOk(LONG *pExitCode)
 {
     Assert(!pProcess.isNull());
@@ -2185 +2106 @@
 
     int vrc;
-    if (!IsRunning())
+    if (!i_isRunning())
     {
         LONG exitCode;
@@ -2205 +2126 @@
 }
 
-int GuestProcessTool::Wait(uint32_t fFlags, int *pGuestRc)
-{
-    return WaitEx(fFlags, NULL /* pStrmBlkOut */, pGuestRc);
-}
-
-int GuestProcessTool::WaitEx(uint32_t fFlags, GuestProcessStreamBlock *pStrmBlkOut, int *pGuestRc)
+int GuestProcessTool::i_wait(uint32_t fFlags, int *pGuestRc)
+{
+    return i_waitEx(fFlags, NULL /* pStrmBlkOut */, pGuestRc);
+}
+
+int GuestProcessTool::i_waitEx(uint32_t fFlags, GuestProcessStreamBlock *pStrmBlkOut, int *pGuestRc)
 {
     LogFlowThisFunc(("fFlags=0x%x, pStreamBlock=%p, pGuestRc=%p\n",
@@ -2220 +2141 @@
     {
         AssertPtr(pStrmBlkOut);
-        vrc = GetCurrentBlock(OUTPUT_HANDLE_ID_STDOUT, *pStrmBlkOut);
+        vrc = i_getCurrentBlock(OUTPUT_HANDLE_ID_STDOUT, *pStrmBlkOut);
         if (RT_SUCCESS(vrc))
             return vrc;
@@ -2272 +2193 @@
         UPDATE_AND_CHECK_ELAPSED_TIME();
 
-        vrc = pProcess->waitFor(fWaitFlags, GET_REMAINING_TIME,
-                                waitRes, &guestRc);
+        vrc = pProcess->i_waitFor(fWaitFlags, GET_REMAINING_TIME,
+                                  waitRes, &guestRc);
         if (RT_FAILURE(vrc))
             break;
@@ -2331 +2252 @@
 
             cbRead = 0;
-            vrc = pProcess->readData(OUTPUT_HANDLE_ID_STDOUT, sizeof(byBuf),
-                                     GET_REMAINING_TIME,
-                                     byBuf, sizeof(byBuf),
-                                     &cbRead, &guestRc);
+            vrc = pProcess->i_readData(OUTPUT_HANDLE_ID_STDOUT, sizeof(byBuf),
+                                       GET_REMAINING_TIME,
+                                       byBuf, sizeof(byBuf),
+                                       &cbRead, &guestRc);
             if (   RT_FAILURE(vrc)
                 || vrc == VWRN_GSTCTL_OBJECTSTATE_CHANGED)
@@ -2348 +2269 @@
                 {
                     AssertPtr(pStrmBlkOut);
-                    vrc = GetCurrentBlock(OUTPUT_HANDLE_ID_STDOUT, *pStrmBlkOut);
+                    vrc = i_getCurrentBlock(OUTPUT_HANDLE_ID_STDOUT, *pStrmBlkOut);
 
                     /* When successful, break out of the loop because we're done
@@ -2365 +2286 @@
 
             cbRead = 0;
-            vrc = pProcess->readData(OUTPUT_HANDLE_ID_STDERR, sizeof(byBuf),
-                                     GET_REMAINING_TIME,
-                                     byBuf, sizeof(byBuf),
-                                     &cbRead, &guestRc);
+            vrc = pProcess->i_readData(OUTPUT_HANDLE_ID_STDERR, sizeof(byBuf),
+                                       GET_REMAINING_TIME,
+                                       byBuf, sizeof(byBuf),
+                                       &cbRead, &guestRc);
             if (   RT_FAILURE(vrc)
                 || vrc == VWRN_GSTCTL_OBJECTSTATE_CHANGED)
@@ -2399 +2320 @@
 }
 
-int GuestProcessTool::Terminate(uint32_t uTimeoutMS, int *pGuestRc)
+int GuestProcessTool::i_terminate(uint32_t uTimeoutMS, int *pGuestRc)
 {
     LogFlowThisFuncEnter();
@@ -2406 +2327 @@
     if (!pProcess.isNull())
     {
-        rc = pProcess->terminateProcess(uTimeoutMS, pGuestRc);
+        rc = pProcess->i_terminateProcess(uTimeoutMS, pGuestRc);
         pProcess.setNull();
     }

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

@@ -753 +753 @@
 
     if (RT_SUCCESS(vrc))
-        vrc = GuestProcessTool::Run(this, procInfo, pGuestRc);
+        vrc = GuestProcessTool::i_run(this, procInfo, pGuestRc);
 
     LogFlowFuncLeaveRC(vrc);
@@ -898 +898 @@
     int guestRc; GuestCtrlStreamObjects stdOut;
     if (RT_SUCCESS(vrc))
-        vrc = GuestProcessTool::RunEx(this, procInfo,
-                                      &stdOut, 1 /* cStrmOutObjects */,
-                                      &guestRc);
+        vrc = GuestProcessTool::i_runEx(this, procInfo,
+                                        &stdOut, 1 /* cStrmOutObjects */,
+                                        &guestRc);
     if (   RT_SUCCESS(vrc)
         && RT_SUCCESS(guestRc))
@@ -1289 +1289 @@
 
     if (RT_SUCCESS(vrc))
-        vrc = GuestProcessTool::Run(this, procInfo, pGuestRc);
+        vrc = GuestProcessTool::i_run(this, procInfo, pGuestRc);
 
     LogFlowFuncLeaveRC(vrc);
@@ -1448 +1448 @@
     int guestRc; GuestCtrlStreamObjects stdOut;
     if (RT_SUCCESS(vrc))
-        vrc = GuestProcessTool::RunEx(this, procInfo,
-                                      &stdOut, 1 /* cStrmOutObjects */,
-                                      &guestRc);
+        vrc = GuestProcessTool::i_runEx(this, procInfo,
+                                        &stdOut, 1 /* cStrmOutObjects */,
+                                        &guestRc);
     if (   RT_SUCCESS(vrc)
         && RT_SUCCESS(guestRc))
@@ -2674 +2674 @@
         {
             case VERR_GSTCTL_GUEST_ERROR:
-                hr = GuestProcess::setErrorExternal(this, guestRc);
+                hr = GuestProcess::i_setErrorExternal(this, guestRc);
                 break;
 
@@ -2715 +2715 @@
         {
             case VERR_GSTCTL_GUEST_ERROR:
-                hr = GuestProcess::setErrorExternal(this, guestRc);
+                hr = GuestProcess::i_setErrorExternal(this, guestRc);
                 break;
 
@@ -2834 +2834 @@
         {
             case VERR_GSTCTL_GUEST_ERROR:
-                hr = GuestProcess::setErrorExternal(this, guestRc);
+                hr = GuestProcess::i_setErrorExternal(this, guestRc);
                 break;
 
@@ -3157 +3157 @@
     {
         case VERR_GSTCTL_GUEST_ERROR:
-            hr = GuestProcess::setErrorExternal(this, guestRc);
+            hr = GuestProcess::i_setErrorExternal(this, guestRc);
             break;
 
@@ -3196 +3196 @@
         {
             case VERR_GSTCTL_GUEST_ERROR:
-                hr = GuestProcess::setErrorExternal(this, guestRc);
+                hr = GuestProcess::i_setErrorExternal(this, guestRc);
                 break;
 
@@ -3336 +3336 @@
         {
             case VERR_GSTCTL_GUEST_ERROR:
-                hr = GuestProcess::setErrorExternal(this, guestRc);
+                hr = GuestProcess::i_setErrorExternal(this, guestRc);
                 break;
 
@@ -3380 +3380 @@
         {
             case VERR_GSTCTL_GUEST_ERROR:
-                hr = GuestProcess::setErrorExternal(this, guestRc);
+                hr = GuestProcess::i_setErrorExternal(this, guestRc);
                 break;
 
@@ -3554 +3554 @@
 
             if (RT_SUCCESS(rc))
-                rc = pProcess->startProcessAsync();
+                rc = pProcess->i_startProcessAsync();
         }
     }

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

@@ -323 +323 @@
     {
         Assert(!pProcess.isNull());
-        rc = pProcess->startProcess(30 * 1000 /* 30s timeout */,
-                                    &guestRc);
+        rc = pProcess->i_startProcess(30 * 1000 /* 30s timeout */,
+                                      &guestRc);
     }
 
@@ -333 +333 @@
             case VERR_GSTCTL_GUEST_ERROR:
                 setProgressErrorMsg(VBOX_E_IPRT_ERROR,
-                                    GuestProcess::guestErrorToString(guestRc));
+                                    GuestProcess::i_guestErrorToString(guestRc));
                 break;
 
@@ -355 +355 @@
         for (;;)
         {
-            rc = pProcess->waitFor(ProcessWaitForFlag_StdIn,
-                                   30 * 1000 /* Timeout */, waitRes, &guestRc);
+            rc = pProcess->i_waitFor(ProcessWaitForFlag_StdIn,
+                                     30 * 1000 /* Timeout */, waitRes, &guestRc);
             if (   RT_FAILURE(rc)
                 || (   waitRes != ProcessWaitResult_StdIn
@@ -419 +419 @@
             uint32_t cbWritten;
             Assert(sizeof(byBuf) >= cbRead);
-            rc = pProcess->writeData(0 /* StdIn */, fFlags,
-                                     byBuf, cbRead,
-                                     30 * 1000 /* Timeout */, &cbWritten, &guestRc);
+            rc = pProcess->i_writeData(0 /* StdIn */, fFlags,
+                                       byBuf, cbRead,
+                                       30 * 1000 /* Timeout */, &cbWritten, &guestRc);
             if (RT_FAILURE(rc))
             {
@@ -428 +428 @@
                     case VERR_GSTCTL_GUEST_ERROR:
                         setProgressErrorMsg(VBOX_E_IPRT_ERROR,
-                                            GuestProcess::guestErrorToString(guestRc));
+                                            GuestProcess::i_guestErrorToString(guestRc));
                         break;
 
@@ -499 +499 @@
             else
             {
-                rc = pProcess->waitFor(ProcessWaitForFlag_Terminate,
-                                       30 * 1000 /* Timeout */, waitRes, &guestRc);
+                rc = pProcess->i_waitFor(ProcessWaitForFlag_Terminate,
+                                         30 * 1000 /* Timeout */, waitRes, &guestRc);
                 if (   RT_FAILURE(rc)
                     || waitRes != ProcessWaitResult_Terminate)
@@ -643 +643 @@
             rc = pSession->processCreateExInteral(procInfo, pProcess);
             if (RT_SUCCESS(rc))
-                rc = pProcess->startProcess(30 * 1000 /* 30s timeout */,
-                                            &guestRc);
+                rc = pProcess->i_startProcess(30 * 1000 /* 30s timeout */,
+                                              &guestRc);
             if (RT_FAILURE(rc))
             {
@@ -651 +651 @@
                     case VERR_GSTCTL_GUEST_ERROR:
                         setProgressErrorMsg(VBOX_E_IPRT_ERROR,
-                                            GuestProcess::guestErrorToString(guestRc));
+                                            GuestProcess::i_guestErrorToString(guestRc));
                         break;
 
@@ -672 +672 @@
                 for (;;)
                 {
-                    rc = pProcess->waitFor(ProcessWaitForFlag_StdOut,
-                                           30 * 1000 /* Timeout */, waitRes, &guestRc);
+                    rc = pProcess->i_waitFor(ProcessWaitForFlag_StdOut,
+                                             30 * 1000 /* Timeout */, waitRes, &guestRc);
                     if (RT_FAILURE(rc))
                     {
@@ -680 +680 @@
                             case VERR_GSTCTL_GUEST_ERROR:
                                 setProgressErrorMsg(VBOX_E_IPRT_ERROR,
-                                                    GuestProcess::guestErrorToString(guestRc));
+                                                    GuestProcess::i_guestErrorToString(guestRc));
                                 break;
 
@@ -702 +702 @@
 
                         uint32_t cbRead = 0; /* readData can return with VWRN_GSTCTL_OBJECTSTATE_CHANGED. */
-                        rc = pProcess->readData(OUTPUT_HANDLE_ID_STDOUT, sizeof(byBuf),
-                                                30 * 1000 /* Timeout */, byBuf, sizeof(byBuf),
-                                                &cbRead, &guestRc);
+                        rc = pProcess->i_readData(OUTPUT_HANDLE_ID_STDOUT, sizeof(byBuf),
+                                                  30 * 1000 /* Timeout */, byBuf, sizeof(byBuf),
+                                                  &cbRead, &guestRc);
                         if (RT_FAILURE(rc))
                         {
@@ -711 +711 @@
                                 case VERR_GSTCTL_GUEST_ERROR:
                                     setProgressErrorMsg(VBOX_E_IPRT_ERROR,
-                                                        GuestProcess::guestErrorToString(guestRc));
+                                                        GuestProcess::i_guestErrorToString(guestRc));
                                     break;
 
@@ -988 +988 @@
                     case VERR_GSTCTL_GUEST_ERROR:
                         setProgressErrorMsg(VBOX_E_IPRT_ERROR,
-                                            GuestProcess::guestErrorToString(guestRc));
+                                            GuestProcess::i_guestErrorToString(guestRc));
                         break;
 
@@ -1022 +1022 @@
     {
         if (RT_SUCCESS(guestRc))
-            vrc = procTool.Wait(GUESTPROCESSTOOL_FLAG_NONE, &guestRc);
+            vrc = procTool.i_wait(GUESTPROCESSTOOL_FLAG_NONE, &guestRc);
         if (RT_SUCCESS(vrc))
-            vrc = procTool.TerminatedOk(&exitCode);
+            vrc = procTool.i_terminatedOk(&exitCode);
     }
 
@@ -1039 +1039 @@
             case VERR_GSTCTL_GUEST_ERROR:
                 setProgressErrorMsg(VBOX_E_IPRT_ERROR,
-                                    GuestProcess::guestErrorToString(guestRc));
+                                    GuestProcess::i_guestErrorToString(guestRc));
                 break;
 
@@ -1288 +1288 @@
                     case VERR_GSTCTL_GUEST_ERROR:
                         hr = setProgressErrorMsg(VBOX_E_IPRT_ERROR,
-                                                 GuestProcess::guestErrorToString(guestRc));
+                                                 GuestProcess::i_guestErrorToString(guestRc));
                         break;
 

trunk/src/VBox/Main/src-client/xpcom/module.cpp

@@ -69 +69 @@
 NS_IMPL_THREADSAFE_ISUPPORTS1_CI(Guest, IGuest)
  #ifdef VBOX_WITH_GUEST_CONTROL
-NS_DECL_CLASSINFO(GuestProcess)
-NS_IMPL_THREADSAFE_ISUPPORTS2_CI(GuestProcess, IGuestProcess, IProcess)
 NS_DECL_CLASSINFO(GuestSession)
 NS_IMPL_THREADSAFE_ISUPPORTS1_CI(GuestSession, IGuestSession)