儲存庫 vbox 的更動 42160

時間撮記:

2012-7-16 上午11:41:10 (12 年 以前)

作者:

vboxsync

訊息:

Guest Control 2.0: Update.

位置:

trunk

檔案:

• include/VBox/HostServices/GuestControlSvc.h (修改) (2 筆差異)
• src/VBox/Main/Makefile.kmk (修改) (2 筆差異)
• src/VBox/Main/include/GuestCtrlImplPrivate.h (修改) (4 筆差異)
• src/VBox/Main/include/GuestImpl.h (修改) (4 筆差異)
• src/VBox/Main/include/GuestProcessImpl.h (修改) (3 筆差異)
• src/VBox/Main/include/GuestSessionImpl.h (修改) (5 筆差異)
• src/VBox/Main/src-client/GuestCtrlImpl.cpp (修改) (3 筆差異)
• src/VBox/Main/src-client/GuestCtrlImplTasks.cpp (修改) (1 筆差異)
• src/VBox/Main/src-client/GuestCtrlPrivate.cpp (移動) (移動 從 trunk/src/VBox/Main/src-client/GuestCtrlIO.cpp ) (5 筆差異)
• src/VBox/Main/src-client/GuestProcessImpl.cpp (修改) (13 筆差異)
• src/VBox/Main/src-client/GuestSessionImpl.cpp (修改) (16 筆差異)
• src/VBox/Main/testcase/Makefile.kmk (修改) (1 筆差異)

trunk/include/VBox/HostServices/GuestControlSvc.h

@@ -4 +4 @@
 
 /*
- * Copyright (C) 2011 Oracle Corporation
+ * Copyright (C) 2011-2012 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -73 +73 @@
  * Note: Has to match Main's ProcessInputFlag_* flags!
  */
-#define INPUT_FLAG_NONE             0
-#define INPUT_FLAG_EOF              RT_BIT(0)
+#define INPUT_FLAG_NONE                     0x0
+#define INPUT_FLAG_EOF                      RT_BIT(0)
 
 /**
  * Execution flags.
- * Note: Has to match Main's ExecuteProcessFlag_* flags!
+ * Note: Has to match Main's CreateProcessFlag_* flags!
  */
 #define EXECUTEPROCESSFLAG_NONE             0x0

trunk/src/VBox/Main/Makefile.kmk

@@ -620 +620 @@
         src-client/GuestSessionImpl.cpp \
         src-client/GuestCtrlImpl.cpp \
-        src-client/GuestCtrlIO.cpp \
         src-client/GuestCtrlImplDir.cpp \
         src-client/GuestCtrlImplFile.cpp \
@@ -641 +640 @@
 ifdef VBOX_WITH_GUEST_CONTROL
 VBoxC_SOURCES += \
+        src-client/GuestCtrlPrivate.cpp \
         src-client/GuestCtrlImplTasks.cpp \
         src-client/GuestDirEntryImpl.cpp

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

@@ -1 +1 @@
 /** @file
  *
- * VirtualBox Guest Control - Private data definitions / classes.
+ * Internal helpers/structures for guest control functionality.
  */
 
 /*
- * Copyright (C) 2011 Oracle Corporation
+ * Copyright (C) 2011-2012 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -19 +19 @@
 #define ____H_GUESTIMPLPRIVATE
 
+#include <iprt/semaphore.h>
+
 #include <VBox/com/com.h>
+#include <VBox/com/ErrorInfo.h>
 #include <VBox/com/string.h>
 #include <VBox/com/VirtualBox.h>
@@ -33 +36 @@
 #endif
 
-class Guest;
-class Progress;
-
-/** Structure representing the "value" side of a "key=value" pair. */
+
+/* Builds a context ID out of the session ID, process ID and an
+ * increasing count. */
+#define VBOX_GUESTCTRL_CONTEXTID_MAKE(uSession, uProcess, uCount) \
+    (  (uint32_t)((uSession) &   0xff) << 24 \
+     | (uint32_t)((uProcess) &   0xff) << 16 \
+     | (uint32_t)((uCount)   & 0xffff)       \
+    )
+
+
+typedef std::vector <LONG> ProcessAffinity;
+typedef std::vector <Utf8Str> ProcessArguments;
+typedef std::map <Utf8Str, Utf8Str> ProcessEnvironmentMap;
+
+
+/**
+ * Generic class for a all guest control callbacks.
+ */
+class GuestCtrlCallback
+{
+public:
+
+    GuestCtrlCallback(void);
+
+    GuestCtrlCallback(eVBoxGuestCtrlCallbackType enmType);
+
+    virtual ~GuestCtrlCallback(void);
+
+    /** @todo Copy/comparison operator? */
+
+public:
+
+    int Init(eVBoxGuestCtrlCallbackType enmType);
+
+    void Destroy(void);
+
+    eVBoxGuestCtrlCallbackType Type(void);
+
+    int Wait(RTMSINTERVAL timeoutMS);
+
+protected:
+
+    /** The callback type. */
+    eVBoxGuestCtrlCallbackType  mType;
+    /** Callback flags. */
+    uint32_t                    mFlags;
+    /** Pointer to user-supplied data. */
+    void                       *pvData;
+    /** Size of user-supplied data. */
+    size_t                      cbData;
+    /** The event semaphore triggering the*/
+    RTSEMEVENT                  mEventSem;
+    /** Extended error information, if any. */
+    ErrorInfo                   mErrorInfo;
+};
+typedef std::map <uint32_t, GuestCtrlCallback> GuestCtrlCallbacks;
+
+/**
+ * Simple structure mantaining guest credentials.
+ */
+class GuestCredentials
+{
+public:
+
+
+public:
+
+    Utf8Str                     mUser;
+    Utf8Str                     mPassword;
+    Utf8Str                     mDomain;
+};
+
+/**
+ * Structure for keeping all the relevant process
+ * starting parameters around.
+ */
+struct GuestProcessInfo
+{
+    Utf8Str                     mCommand;
+    ProcessArguments            mArguments;
+    ProcessEnvironmentMap       mEnvironment;
+    uint32_t                    mFlags;
+    ULONG                       mTimeoutMS;
+    ProcessPriority_T           mPriority;
+    ProcessAffinity             mAffinity;
+};
+
+/**
+ * Class representing the "value" side of a "key=value" pair.
+ */
 class GuestProcessStreamValue
 {
@@ -144 +233 @@
     BYTE *m_pbBuffer;
 };
+
+class Guest;
+class Progress;
 
 class GuestTask

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

@@ -4 +4 @@
 
 /*
- * Copyright (C) 2006-2011 Oracle Corporation
+ * Copyright (C) 2006-2012 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -205 +205 @@
     /** @name Public internal methods.
      * @{ */
-    int sessionClose(ComObjPtr<GuestSession> pSession);
+    Console    *getConsole(void) { return mParent; }
+    int         sessionClose(ComObjPtr<GuestSession> pSession);
+    int         sessionCreate(const Utf8Str &strUser, const Utf8Str &aPassword, const Utf8Str &aDomain,
+                              const Utf8Str &aSessionName, IGuestSession **aGuestSession);
+    inline bool sessionExists(uint32_t uSessionID);
     /** @}  */
 
@@ -303 +307 @@
     typedef std::map< AdditionsFacilityType_T, ComObjPtr<AdditionsFacility> >::const_iterator FacilityMapIterConst;
 
-    typedef std::list <ComObjPtr<GuestSession> > GuestSessions;
+    /** Map for keeping the guest sessions. The primary key marks the guest session ID. */
+    typedef std::map <uint32_t, ComObjPtr<GuestSession> > GuestSessions;
 
     struct Data
@@ -320 +325 @@
         Bstr                    mInterfaceVersion;
         GuestSessions           mGuestSessions;
+        uint32_t                mNextSessionID;
     };
 

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

@@ -21 +21 @@
 
 #include "VirtualBoxBase.h"
+#include "GuestCtrlImplPrivate.h"
 
-#include <vector>
-
-typedef std::vector<Utf8Str> StringsArray;
-
+class Console;
 class GuestSession;
 
@@ -47 +45 @@
     DECLARE_EMPTY_CTOR_DTOR(GuestProcess)
 
-    int     init(GuestSession *pSession,
-                 const Utf8Str &aCommand, const StringsArray &aArguments, const StringsArray &aEnvironment,
-                 ComSafeArrayIn(ProcessCreateFlag_T, aFlags), ULONG aTimeoutMS,
-                 ProcessPriority_T aPriority, ComSafeArrayIn(LONG, aAffinity));
+    int     init(Console *aConsole, GuestSession *aSession, uint32_t aProcessID, const GuestProcessInfo &aProcInfo);
     void    uninit(void);
     HRESULT FinalConstruct(void);
@@ -74 +69 @@
     /** @name Public internal methods.
      * @{ */
+    int callbackAdd(const GuestCtrlCallback& theCallback, uint32_t *puContextID);
+    bool callbackExists(uint32_t uContextID);
+    bool isReady(void);
+    int prepareExecuteEnv(const char *pszEnv, void **ppvList, uint32_t *pcbList, uint32_t *pcEnvVars);
+    int readData(ULONG aHandle, ULONG aSize, ULONG aTimeoutMS, ComSafeArrayOut(BYTE, aData));
+    int startProcess(void);
+    static DECLCALLBACK(int) GuestProcess::startProcessThread(RTTHREAD Thread, void *pvUser);
+    int terminateProcess(void);
+    int waitFor(ComSafeArrayIn(ProcessWaitForFlag_T, aFlags), ULONG aTimeoutMS, ProcessWaitReason_T *aReason);
+    int writeData(ULONG aHandle, ComSafeArrayIn(BYTE, aData), ULONG aTimeoutMS, ULONG *aWritten);
     /** @}  */
 
 private:
 
-    typedef std::map <Utf8Str, Utf8Str> MyStringMap;
-
     struct Data
     {
-        GuestSession        *mParent;
-        Bstr                 mName;
+        /** Pointer to parent session. */
+        GuestSession            *mParent;
+        /** Pointer to the console object. Needed
+         *  for HGCM (VMMDev) communication. */
+        Console                 *mConsole;
+        /** All related callbacks to this process. */
+        GuestCtrlCallbacks       mCallbacks;
+        /** The process start information. */
+        GuestProcessInfo         mProcess;
+        /** Exit code if process has been terminated. */
+        LONG                     mExitCode;
+        /** PID reported from the guest. */
+        ULONG                    mPID;
+        /** Internal, host-side process ID. */
+        uint32_t                 mProcessID;
+        /** The current process status. */
+        ProcessStatus_T          mStatus;
+        /** Flag indicating whether the process has been started. */
+        bool                     mStarted;
+        /** The next upcoming context ID. */
+        uint32_t                 mNextContextID;
     } mData;
 };

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

@@ -22 +22 @@
 #include "VirtualBoxBase.h"
 
+#include "GuestCtrlImplPrivate.h"
 #include "GuestProcessImpl.h"
 #include "GuestDirectoryImpl.h"
 #include "GuestFileImpl.h"
 #include "GuestFsObjInfoImpl.h"
-
-#include <map>
-#include <vector>
-
-typedef std::vector<Utf8Str> StringsArray;
 
 class Guest;
@@ -52 +48 @@
     DECLARE_EMPTY_CTOR_DTOR(GuestSession)
 
-    int     init(Guest *aGuest, Utf8Str aUser, Utf8Str aPassword, Utf8Str aDomain, Utf8Str aName);
+    int     init(Guest *aGuest, uint32_t aSessionID, Utf8Str aUser, Utf8Str aPassword, Utf8Str aDomain, Utf8Str aName);
     void    uninit(void);
     HRESULT FinalConstruct(void);
@@ -115 +111 @@
     /** @name Public internal methods.
      * @{ */
-    int directoryClose(ComObjPtr<GuestDirectory> pDirectory);
-    int fileClose(ComObjPtr<GuestFile> pFile);
-    int processClose(ComObjPtr<GuestProcess> pProcess);
-    int processCreateExInteral(const Utf8Str &aCommand, const StringsArray &aArguments, const StringsArray &aEnvironment,
-                               ComSafeArrayIn(ProcessCreateFlag_T, aFlags), ULONG aTimeoutMS,
-                               ProcessPriority_T aPriority, ComSafeArrayIn(LONG, aAffinity),
-                               IGuestProcess **aProcess);
+    int                     directoryClose(ComObjPtr<GuestDirectory> pDirectory);
+    int                     fileClose(ComObjPtr<GuestFile> pFile);
+    const GuestCredentials &getCredentials(void);
+    int                     processClose(ComObjPtr<GuestProcess> pProcess);
+    int                     processCreateExInteral(GuestProcessInfo &aProcInfo, IGuestProcess **aProcess);
+    inline bool             processExists(uint32_t uProcessID);
     /** @}  */
 
@@ -128 +123 @@
     typedef std::map <Utf8Str, Utf8Str> SessionEnvironment;
 
-    typedef std::list <ComObjPtr<GuestDirectory> > SessionDirectories;
-    typedef std::list <ComObjPtr<GuestFile> > SessionFiles;
-    typedef std::list <ComObjPtr<GuestProcess> > SessionProcesses;
+    typedef std::vector <ComObjPtr<GuestDirectory> > SessionDirectories;
+    typedef std::vector <ComObjPtr<GuestFile> > SessionFiles;
+    typedef std::map <uint32_t, ComObjPtr<GuestProcess> > SessionProcesses;
 
     struct Data
@@ -137 +132 @@
          *  or not. Internal session are not accessible by clients. */
         bool                 fInternal;
-        /** Pointer to the parent (IGuest). */
+        /** Pointer to the parent (Guest). */
         Guest               *mParent;
         /** The session credentials. */
-        Utf8Str              mUser;
-        Utf8Str              mPassword;
-        Utf8Str              mDomain;
+        GuestCredentials     mCredentials;
         /** The (optional) session name. */
         Utf8Str              mName;

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

@@ -2671 +2671 @@
          itSessions != mData.mGuestSessions.end(); ++itSessions)
     {
-        if (pSession == (*itSessions))
-        {
-            mData.mGuestSessions.remove((*itSessions));
+        if (pSession == itSessions->second)
+        {
+            mData.mGuestSessions.erase(itSessions);
             return VINF_SUCCESS;
         }
@@ -2679 +2679 @@
 
     return VERR_NOT_FOUND;
+}
+
+int Guest::sessionCreate(const Utf8Str &strUser, const Utf8Str &strPassword, const Utf8Str &strDomain,
+                         const Utf8Str &strSessionName, IGuestSession **aGuestSession)
+{
+    AssertPtrReturn(aGuestSession, VERR_INVALID_POINTER);
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    int rc = VERR_MAX_PROCS_REACHED;
+    ComObjPtr<GuestSession> pGuestSession;
+    try
+    {
+        /* Create a new session ID and assign it. */
+        uint32_t uNewSessionID = 0;
+        uint32_t uTries = 0;
+
+        for (;;)
+        {
+            /* Is the context ID already used?  Try next ID ... */
+            if (!sessionExists(uNewSessionID++))
+            {
+                /* Callback with context ID was not found. This means
+                 * we can use this context ID for our new callback we want
+                 * to add below. */
+                rc = VINF_SUCCESS;
+                break;
+            }
+
+            if (++uTries == UINT32_MAX)
+                break; /* Don't try too hard. */
+        }
+        if (RT_FAILURE(rc)) throw rc;
+
+        /* Create the session object. */
+        HRESULT hr = pGuestSession.createObject();
+        if (FAILED(hr)) throw VERR_COM_UNEXPECTED;
+
+        rc = pGuestSession->init(this, uNewSessionID,
+                                 strUser, strPassword, strDomain, strSessionName);
+        if (RT_FAILURE(rc)) throw VBOX_E_IPRT_ERROR;
+
+        mData.mGuestSessions[uNewSessionID] = pGuestSession;
+
+        /* Return guest session to the caller. */
+        hr = pGuestSession.queryInterfaceTo(aGuestSession);
+        if (FAILED(hr)) throw VERR_COM_OBJECT_NOT_FOUND;
+    }
+    catch (int rc2)
+    {
+        rc = rc2;
+    }
+
+    return rc;
+}
+
+inline bool Guest::sessionExists(uint32_t uSessionID)
+{
+    AssertReturn(uSessionID, false);
+
+    GuestSessions::const_iterator itSessions = mData.mGuestSessions.find(uSessionID);
+    return (itSessions == mData.mGuestSessions.end()) ? false : true;
 }
 
@@ -2698 +2760 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT hr;
-    ComObjPtr<GuestSession> pGuestSession;
-    try
-    {
-        /* Create the session object. */
-        hr = pGuestSession.createObject();
-        if (FAILED(hr)) throw hr;
-
-        int rc = pGuestSession->init(this,
-                                     aUser, aPassword, aDomain, aSessionName);
-        if (RT_FAILURE(rc)) throw VBOX_E_IPRT_ERROR;
-
-        mData.mGuestSessions.push_back(pGuestSession);
-
-        /* Return guest session to the caller. */
-        hr = pGuestSession.queryInterfaceTo(aGuestSession);
-    }
-    catch (HRESULT aRC)
-    {
-        hr = aRC;
-    }
-
-    return hr;
+
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }

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

@@ -49 +49 @@
 }
 
-GuestTask::~GuestTask()
+GuestTask::~GuestTask(void)
 {
 
 }
 
-int GuestTask::startThread()
+int GuestTask::startThread(void)
 {
     return RTThreadCreate(NULL, GuestTask::taskThread, this,

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

@@ -2 +2 @@
 /** @file
  *
- * IO helper for IGuest COM class implementations.
+ * Internal helpers/structures for guest control functionality.
  */
 
 /*
- * Copyright (C) 2011 Oracle Corporation
+ * Copyright (C) 2011-2012 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -30 +30 @@
  ******************************************************************************/
 
+GuestCtrlCallback::GuestCtrlCallback(void)
+    : mType(VBOXGUESTCTRLCALLBACKTYPE_UNKNOWN),
+      pvData(NULL),
+      cbData(0),
+      mEventSem(NIL_RTSEMEVENT)
+{
+}
+
+GuestCtrlCallback::GuestCtrlCallback(eVBoxGuestCtrlCallbackType enmType)
+    : mType(VBOXGUESTCTRLCALLBACKTYPE_UNKNOWN),
+      pvData(NULL),
+      cbData(0),
+      mEventSem(NIL_RTSEMEVENT)
+{
+    int rc = Init(enmType);
+    AssertRC(rc);
+}
+
+GuestCtrlCallback::~GuestCtrlCallback(void)
+{
+    Destroy();
+}
+
+int GuestCtrlCallback::Init(eVBoxGuestCtrlCallbackType enmType)
+{
+    AssertReturn(enmType > VBOXGUESTCTRLCALLBACKTYPE_UNKNOWN, VERR_INVALID_PARAMETER);
+    Assert((pvData == NULL) && !cbData);
+
+    int rc = VINF_SUCCESS;
+    switch (enmType)
+    {
+        case VBOXGUESTCTRLCALLBACKTYPE_EXEC_START:
+        {
+            pvData = (PCALLBACKDATAEXECSTATUS)RTMemAlloc(sizeof(CALLBACKDATAEXECSTATUS));
+            AssertPtrReturn(pvData, VERR_NO_MEMORY);
+            RT_BZERO(pvData, sizeof(CALLBACKDATAEXECSTATUS));
+            cbData = sizeof(CALLBACKDATAEXECSTATUS);
+            break;
+        }
+
+        case VBOXGUESTCTRLCALLBACKTYPE_EXEC_OUTPUT:
+        {
+            pvData = (PCALLBACKDATAEXECOUT)RTMemAlloc(sizeof(CALLBACKDATAEXECOUT));
+            AssertPtrReturn(pvData, VERR_NO_MEMORY);
+            RT_BZERO(pvData, sizeof(CALLBACKDATAEXECOUT));
+            cbData = sizeof(CALLBACKDATAEXECOUT);
+            break;
+        }
+
+        case VBOXGUESTCTRLCALLBACKTYPE_EXEC_INPUT_STATUS:
+        {
+            PCALLBACKDATAEXECINSTATUS pData = (PCALLBACKDATAEXECINSTATUS)RTMemAlloc(sizeof(CALLBACKDATAEXECINSTATUS));
+            AssertPtrReturn(pData, VERR_NO_MEMORY);
+            RT_BZERO(pData, sizeof(CALLBACKDATAEXECINSTATUS));
+            cbData = sizeof(CALLBACKDATAEXECINSTATUS);
+            break;
+        }
+
+        default:
+            AssertMsgFailed(("Unknown callback type specified (%d)\n", enmType));
+            break;
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        rc = RTSemEventCreate(&mEventSem);
+        if (RT_SUCCESS(rc))
+            mType  = enmType;
+    }
+
+    return rc;
+}
+
+void GuestCtrlCallback::Destroy(void)
+{
+    mType = VBOXGUESTCTRLCALLBACKTYPE_UNKNOWN;
+    if (pvData)
+    {
+        RTMemFree(pvData);
+        pvData = NULL;
+    }
+    cbData = 0;
+    if (mEventSem != NIL_RTSEMEVENT)
+        RTSemEventDestroy(mEventSem);
+}
+
+eVBoxGuestCtrlCallbackType GuestCtrlCallback::Type(void)
+{
+    return mType;
+}
+
+int GuestCtrlCallback::Wait(RTMSINTERVAL timeoutMS)
+{
+    Assert(mEventSem != NIL_RTSEMEVENT);
+    return RTSemEventWait(mEventSem, timeoutMS);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 /** @todo *NOT* thread safe yet! */
 /** @todo Add exception handling for STL stuff! */
 
-GuestProcessStreamBlock::GuestProcessStreamBlock()
+GuestProcessStreamBlock::GuestProcessStreamBlock(void)
 {
 
@@ -223 +322 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-GuestProcessStream::GuestProcessStream()
+GuestProcessStream::GuestProcessStream(void)
     : m_cbAllocated(0),
       m_cbSize(0),
@@ -232 +331 @@
 }
 
-GuestProcessStream::~GuestProcessStream()
+GuestProcessStream::~GuestProcessStream(void)
 {
     Destroy();
@@ -311 +410 @@
  * Destroys the internal data buffer.
  */
-void GuestProcessStream::Destroy()
+void GuestProcessStream::Destroy(void)
 {
     if (m_pbBuffer)

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

@@ -22 +22 @@
 *******************************************************************************/
 #include "GuestProcessImpl.h"
+#include "GuestSessionImpl.h"
+#include "ConsoleImpl.h"
 
 #include "Global.h"
 #include "AutoCaller.h"
 #include "Logging.h"
+#include "VMMDev.h"
+
+#include <iprt/asm.h>
+#include <iprt/getopt.h>
+#include <VBox/VMMDev.h>
+#include <VBox/com/array.h>
+
+
+struct GuestProcessTask
+{
+    GuestProcessTask(GuestProcess *pProcess)
+        : mProcess(pProcess) { }
+
+    ~GuestProcessTask(void) { }
+
+    int rc() const { return mRC; }
+    bool isOk() const { return RT_SUCCESS(rc()); }
+
+    const ComObjPtr<GuestProcess>    mProcess;
+
+private:
+    int                              mRC;
+};
+
+struct GuestProcessStartTask : public GuestProcessTask
+{
+    GuestProcessStartTask(GuestProcess *pProcess)
+        : GuestProcessTask(pProcess) { }
+};
 
 
@@ -36 +67 @@
 {
     LogFlowThisFunc(("\n"));
+
+    mData.mExitCode = 0;
+    mData.mNextContextID = 0;
+    mData.mPID = 0;
+    mData.mProcessID = 0;
+    mData.mStatus = ProcessStatus_Undefined;
+    mData.mStarted = false;
+
     return BaseFinalConstruct();
 }
@@ -50 +89 @@
 /////////////////////////////////////////////////////////////////////////////
 
-int GuestProcess::init(GuestSession *pSession,
-                       const Utf8Str &aCommand, const StringsArray &aArguments, const StringsArray &aEnvironment,
-                       ComSafeArrayIn(ProcessCreateFlag_T, aFlags), ULONG aTimeoutMS,
-                       ProcessPriority_T aPriority, ComSafeArrayIn(LONG, aAffinity))
-{
+int GuestProcess::init(Console *aConsole, GuestSession *aSession, uint32_t aProcessID, const GuestProcessInfo &aProcInfo)
+{
+    AssertPtrReturn(aSession, VERR_INVALID_POINTER);
+
     /* Enclose the state transition NotReady->InInit->Ready. */
     AutoInitSpan autoInitSpan(this);
     AssertReturn(autoInitSpan.isOk(), VERR_OBJECT_DESTROYED);
 
-    int rc = VINF_SUCCESS;
-
-    mData.mParent = pSession;
-
-    /* Confirm a successful initialization when it's the case. */
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    mData.mConsole = aConsole;
+    mData.mParent = aSession;
+    mData.mProcessID = aProcessID;
+    mData.mStatus = ProcessStatus_Starting;
+    /* Everything else will be set by the actual starting routine. */
+
+    /* Asynchronously start the process on the guest by kicking off a
+     * worker thread. */
+    std::auto_ptr<GuestProcessStartTask> pTask(new GuestProcessStartTask(this));
+    AssertReturn(pTask->isOk(), pTask->rc());
+
+    int rc = RTThreadCreate(NULL, GuestProcess::startProcessThread,
+                            (void *)pTask.get(), 0,
+                            RTTHREADTYPE_MAIN_WORKER, 0,
+                            "gctlPrcStart");
     if (RT_SUCCESS(rc))
+    {
+        /* task is now owned by startProcessThread(), so release it. */
+        pTask.release();
+
+        /* Confirm a successful initialization when it's the case. */
         autoInitSpan.setSucceeded();
+    }
 
     return rc;
@@ -97 +153 @@
     CheckComArgOutSafeArrayPointerValid(aArguments);
 
-    ReturnComNotImplemented();
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    com::SafeArray<BSTR> collection(mData.mProcess.mArguments.size());
+    size_t s = 0;
+    for (ProcessArguments::const_iterator it = mData.mProcess.mArguments.begin();
+         it != mData.mProcess.mArguments.end();
+         ++it, ++s)
+    {
+        collection[s] = Bstr((*it)).raw();
+    }
+
+    collection.detachTo(ComSafeArrayOutArg(aArguments));
+
+    return S_OK;
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }
@@ -111 +180 @@
     CheckComArgOutSafeArrayPointerValid(aEnvironment);
 
-    ReturnComNotImplemented();
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    com::SafeArray<BSTR> collection(mData.mProcess.mEnvironment.size());
+    size_t s = 0;
+    for (ProcessEnvironmentMap::const_iterator it = mData.mProcess.mEnvironment.begin();
+         it != mData.mProcess.mEnvironment.end();
+         ++it, ++s)
+    {
+        collection[s] = Bstr(it->first + "=" + it->second).raw();
+    }
+
+    collection.detachTo(ComSafeArrayOutArg(aEnvironment));
+
+    return S_OK;
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }
@@ -123 +205 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    ReturnComNotImplemented();
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    mData.mProcess.mCommand.cloneTo(aExecutablePath);
+
+    return S_OK;
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }
@@ -135 +221 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    ReturnComNotImplemented();
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    *aExitCode = mData.mExitCode;
+
+    return S_OK;
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }
@@ -147 +237 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    ReturnComNotImplemented();
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    *aPID = mData.mPID;
+
+    return S_OK;
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }
@@ -159 +253 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    ReturnComNotImplemented();
-#endif /* VBOX_WITH_GUEST_CONTROL */
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    *aStatus = mData.mStatus;
+
+    return S_OK;
+#endif /* VBOX_WITH_GUEST_CONTROL */
+}
+
+// private methods
+/////////////////////////////////////////////////////////////////////////////
+
+/*
+
+    SYNC TO ASK:
+    Everything which involves HGCM communication (start, read/write/status(?)/...)
+    either can be called synchronously or asynchronously by running in a Main worker
+    thread.
+
+    Rules:
+        - Only one async operation per process a time can be around.
+
+*/
+
+int GuestProcess::callbackAdd(const GuestCtrlCallback& theCallback, uint32_t *puContextID)
+{
+    const ComObjPtr<GuestSession> pSession(mData.mParent);
+    Assert(!pSession.isNull());
+    ULONG uSessionID = 0;
+    HRESULT hr = pSession->COMGETTER(Id)(&uSessionID);
+    ComAssertComRC(hr);
+
+    /* Create a new context ID and assign it. */
+    int rc = VERR_NOT_FOUND;
+    uint32_t uNewContextID = 0;
+    uint32_t uTries = 0;
+    for (;;)
+    {
+        /* Create a new context ID ... */
+        uNewContextID = VBOX_GUESTCTRL_CONTEXTID_MAKE(uSessionID,
+                                                      mData.mProcessID, ASMAtomicIncU32(&mData.mNextContextID));
+        if (uNewContextID == UINT32_MAX)
+            ASMAtomicUoWriteU32(&mData.mNextContextID, 0);
+        /* Is the context ID already used?  Try next ID ... */
+        if (!callbackExists(uNewContextID))
+        {
+            /* Callback with context ID was not found. This means
+             * we can use this context ID for our new callback we want
+             * to add below. */
+            rc = VINF_SUCCESS;
+            break;
+        }
+
+        if (++uTries == UINT32_MAX)
+            break; /* Don't try too hard. */
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        /* Add callback with new context ID to our callback map. */
+        mData.mCallbacks[uNewContextID] = theCallback;
+        Assert(mData.mCallbacks.size());
+
+        /* Report back new context ID. */
+        if (puContextID)
+            *puContextID = uNewContextID;
+    }
+
+    return rc;
+}
+
+bool GuestProcess::callbackExists(uint32_t uContextID)
+{
+    AssertReturn(uContextID, false);
+
+    GuestCtrlCallbacks::const_iterator it = mData.mCallbacks.find(uContextID);
+    return (it == mData.mCallbacks.end()) ? false : true;
+}
+
+bool GuestProcess::isReady(void)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    if (mData.mStatus == ProcessStatus_Started)
+    {
+        Assert(mData.mPID); /* PID must not be 0. */
+        return true;
+    }
+
+    return false;
+}
+
+/**
+ * Appends environment variables to the environment block.
+ *
+ * Each var=value pair is separated by the null character ('\\0').  The whole
+ * block will be stored in one blob and disassembled on the guest side later to
+ * fit into the HGCM param structure.
+ *
+ * @returns VBox status code.
+ *
+ * @param   pszEnvVar       The environment variable=value to append to the
+ *                          environment block.
+ * @param   ppvList         This is actually a pointer to a char pointer
+ *                          variable which keeps track of the environment block
+ *                          that we're constructing.
+ * @param   pcbList         Pointer to the variable holding the current size of
+ *                          the environment block.  (List is a misnomer, go
+ *                          ahead a be confused.)
+ * @param   pcEnvVars       Pointer to the variable holding count of variables
+ *                          stored in the environment block.
+ */
+int GuestProcess::prepareExecuteEnv(const char *pszEnv, void **ppvList, uint32_t *pcbList, uint32_t *pcEnvVars)
+{
+    int rc = VINF_SUCCESS;
+    uint32_t cchEnv = strlen(pszEnv); Assert(cchEnv >= 2);
+    if (*ppvList)
+    {
+        uint32_t cbNewLen = *pcbList + cchEnv + 1; /* Include zero termination. */
+        char *pvTmp = (char *)RTMemRealloc(*ppvList, cbNewLen);
+        if (pvTmp == NULL)
+            rc = VERR_NO_MEMORY;
+        else
+        {
+            memcpy(pvTmp + *pcbList, pszEnv, cchEnv);
+            pvTmp[cbNewLen - 1] = '\0'; /* Add zero termination. */
+            *ppvList = (void **)pvTmp;
+        }
+    }
+    else
+    {
+        char *pszTmp;
+        if (RTStrAPrintf(&pszTmp, "%s", pszEnv) >= 0)
+        {
+            *ppvList = (void **)pszTmp;
+            /* Reset counters. */
+            *pcEnvVars = 0;
+            *pcbList = 0;
+        }
+    }
+    if (RT_SUCCESS(rc))
+    {
+        *pcbList += cchEnv + 1; /* Include zero termination. */
+        *pcEnvVars += 1;        /* Increase env variable count. */
+    }
+    return rc;
+}
+
+int GuestProcess::readData(ULONG aHandle, ULONG aSize, ULONG aTimeoutMS, ComSafeArrayOut(BYTE, aData))
+{
+    LogFlowFuncEnter();
+
+    LogFlowFuncLeave();
+    return 0;
+}
+
+int GuestProcess::startProcess(void)
+{
+    LogFlowFuncEnter();
+
+    AssertReturn(!mData.mStarted, VERR_ALREADY_EXISTS);
+
+    int rc;
+    uint32_t uContextID;
+
+    {
+        /* Wait until the caller function (if kicked off by a thread)
+         * has returned and continue operation. */
+        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+        /* Create callback and add it to the map. */
+        GuestCtrlCallback callbackStart;
+        rc = callbackStart.Init(VBOXGUESTCTRLCALLBACKTYPE_EXEC_START);
+        if (RT_FAILURE(rc))
+            return rc;
+
+        rc = callbackAdd(callbackStart, &uContextID);
+        Assert(uContextID);
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        ComObjPtr<GuestSession> pSession(mData.mParent);
+        Assert(!pSession.isNull());
+
+        const GuestCredentials &sessionCreds = pSession->getCredentials();
+
+        /* Prepare arguments. */
+        char *pszArgs = NULL;
+        size_t cArgs = mData.mProcess.mArguments.size();
+        if (cArgs)
+        {
+            char **papszArgv = (char**)RTMemAlloc(sizeof(char*) * (cArgs + 1));
+            AssertReturn(papszArgv, VERR_NO_MEMORY);
+            for (size_t i = 0; RT_SUCCESS(rc) && i < cArgs; i++)
+                rc = RTStrDupEx(&papszArgv[i], mData.mProcess.mArguments[i].c_str());
+            papszArgv[cArgs] = NULL;
+
+            if (RT_SUCCESS(rc))
+                rc = RTGetOptArgvToString(&pszArgs, papszArgv, RTGETOPTARGV_CNV_QUOTE_MS_CRT);
+        }
+        uint32_t cbArgs = pszArgs ? strlen(pszArgs) + 1 : 0; /* Include terminating zero. */
+
+        /* Prepare environment. */
+        void *pvEnv = NULL;
+        size_t cEnv = mData.mProcess.mEnvironment.size();
+        uint32_t cbEnv = 0;
+        if (   RT_SUCCESS(rc)
+            && cEnv)
+        {
+            uint32_t cEnvBuild = 0;
+            ProcessEnvironmentMap::const_iterator itEnv = mData.mProcess.mEnvironment.begin();
+            for (; itEnv != mData.mProcess.mEnvironment.end() && RT_SUCCESS(rc); itEnv++)
+            {
+                char *pszEnv;
+                if (!RTStrAPrintf(&pszEnv, "%s=%s", itEnv->first, itEnv->second))
+                    break;
+                AssertPtr(pszEnv);
+                rc = prepareExecuteEnv(pszEnv, &pvEnv, &cbEnv, &cEnvBuild);
+                RTStrFree(pszEnv);
+            }
+            Assert(cEnv == cEnvBuild);
+        }
+
+        if (RT_SUCCESS(rc))
+        {
+            /* Prepare HGCM call. */
+            VBOXHGCMSVCPARM paParms[15];
+            int i = 0;
+            paParms[i++].setUInt32(uContextID);
+            paParms[i++].setPointer((void*)mData.mProcess.mCommand.c_str(),
+                                    (uint32_t)mData.mProcess.mCommand.length() + 1);
+            paParms[i++].setUInt32(mData.mProcess.mFlags);
+            paParms[i++].setUInt32(mData.mProcess.mArguments.size());
+            paParms[i++].setPointer((void*)pszArgs, cbArgs);
+            paParms[i++].setUInt32(mData.mProcess.mEnvironment.size());
+            paParms[i++].setUInt32(cbEnv);
+            paParms[i++].setPointer((void*)pvEnv, cbEnv);
+            paParms[i++].setPointer((void*)sessionCreds.mUser.c_str(), (uint32_t)sessionCreds.mUser.length() + 1);
+            paParms[i++].setPointer((void*)sessionCreds.mPassword.c_str(), (uint32_t)sessionCreds.mPassword.length() + 1);
+
+            /*
+             * If the WaitForProcessStartOnly flag is set, we only want to define and wait for a timeout
+             * until the process was started - the process itself then gets an infinite timeout for execution.
+             * This is handy when we want to start a process inside a worker thread within a certain timeout
+             * but let the started process perform lengthly operations then.
+             */
+            if (mData.mProcess.mFlags & ProcessCreateFlag_WaitForProcessStartOnly)
+                paParms[i++].setUInt32(UINT32_MAX /* Infinite timeout */);
+            else
+                paParms[i++].setUInt32(mData.mProcess.mTimeoutMS);
+
+            const ComObjPtr<Console> pConsole(mData.mConsole);
+            Assert(!pConsole.isNull());
+
+            VMMDev *pVMMDev = NULL;
+            {
+                /* 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. */
+                pVMMDev = pConsole->getVMMDev();
+            }
+
+            LogFlowFunc(("hgcmHostCall numParms=%d, CID=%RU32\n", i, uContextID));
+            rc = pVMMDev->hgcmHostCall("VBoxGuestControlSvc", HOST_EXEC_CMD,
+                                       i, paParms);
+        }
+
+        if (pvEnv)
+            RTMemFree(pvEnv);
+        if (pszArgs)
+            RTStrFree(pszArgs);
+    }
+
+    LogFlowFuncLeave();
+    return rc;
+}
+
+DECLCALLBACK(int) GuestProcess::startProcessThread(RTTHREAD Thread, void *pvUser)
+{
+    LogFlowFuncEnter();
+
+    const ComObjPtr<GuestProcess> pProcess = static_cast<GuestProcess*>(pvUser);
+    Assert(!pProcess.isNull());
+
+    int rc = pProcess->startProcess();
+
+    LogFlowFuncLeave();
+    return rc;
+}
+
+int GuestProcess::terminateProcess(void)
+{
+    LogFlowFuncEnter();
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    LogFlowFuncLeave();
+    return 0;
+}
+
+int GuestProcess::waitFor(ComSafeArrayIn(ProcessWaitForFlag_T, aFlags), ULONG aTimeoutMS, ProcessWaitReason_T *aReason)
+{
+    LogFlowFuncEnter();
+
+    LogFlowFuncLeave();
+    return 0;
+}
+
+int GuestProcess::writeData(ULONG aHandle, ComSafeArrayIn(BYTE, aData), ULONG aTimeoutMS, ULONG *aWritten)
+{
+    LogFlowFuncEnter();
+
+    LogFlowFuncLeave();
+    return 0;
 }
 
@@ -171 +580 @@
     ReturnComNotImplemented();
 #else
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    ReturnComNotImplemented();
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    int rc = readData(aHandle, aSize, aTimeoutMS, ComSafeArrayOutArg(aData));
+    /** @todo Do setError() here. */
+    return RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }
@@ -186 +598 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    ReturnComNotImplemented();
+    int rc = terminateProcess();
+    /** @todo Do setError() here. */
+    return RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }
@@ -198 +612 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    ReturnComNotImplemented();
+    int rc = waitFor(ComSafeArrayInArg(aFlags), aTimeoutMS, aReason);
+    /** @todo Do setError() here. */
+    return RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }
@@ -210 +626 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    ReturnComNotImplemented();
-#endif /* VBOX_WITH_GUEST_CONTROL */
-}
-
+    int rc = writeData(aHandle, ComSafeArrayInArg(aData), aTimeoutMS, aWritten);
+    /** @todo Do setError() here. */
+    return RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;
+#endif /* VBOX_WITH_GUEST_CONTROL */
+}
+

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

@@ -53 +53 @@
 /////////////////////////////////////////////////////////////////////////////
 
-int GuestSession::init(Guest *aGuest,
+int GuestSession::init(Guest *aGuest, uint32_t aSessionID,
                        Utf8Str aUser, Utf8Str aPassword, Utf8Str aDomain, Utf8Str aName)
 {
@@ -63 +63 @@
 
     mData.mParent = aGuest;
-
-    mData.mUser = aUser;
-    mData.mPassword = aPassword;
-    mData.mDomain = aDomain;
+    mData.mId = aSessionID;
+
+    mData.mCredentials.mUser = aUser;
+    mData.mCredentials.mPassword = aPassword;
+    mData.mCredentials.mDomain = aDomain;
     mData.mName = aName;
 
@@ -108 +109 @@
          itProcs != mData.mProcesses.end(); ++itProcs)
     {
-        (*itProcs)->uninit();
-        (*itProcs).setNull();
+        itProcs->second->uninit();
+        itProcs->second.setNull();
     }
     mData.mProcesses.clear();
@@ -132 +133 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    mData.mUser.cloneTo(aUser);
+    mData.mCredentials.mUser.cloneTo(aUser);
 
     return S_OK;
@@ -150 +151 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    mData.mDomain.cloneTo(aDomain);
+    mData.mCredentials.mDomain.cloneTo(aDomain);
 
     return S_OK;
@@ -228 +229 @@
          ++it, ++s)
     {
-        /** @todo */
+        collection[s] = Bstr(it->first + "=" + it->second).raw();
     }
 
@@ -306 +307 @@
         if (pDirectory == (*itDirs))
         {
-            mData.mDirectories.remove((*itDirs));
+            mData.mDirectories.erase(itDirs);
             return VINF_SUCCESS;
         }
@@ -323 +324 @@
         if (pFile == (*itFiles))
         {
-            mData.mFiles.remove((*itFiles));
+            mData.mFiles.erase(itFiles);
             return VINF_SUCCESS;
         }
@@ -331 +332 @@
 }
 
+const GuestCredentials& GuestSession::getCredentials(void)
+{
+    return mData.mCredentials;
+}
+
 int GuestSession::processClose(ComObjPtr<GuestProcess> pProcess)
 {
@@ -338 +344 @@
          itProcs != mData.mProcesses.end(); ++itProcs)
     {
-        if (pProcess == (*itProcs))
+        if (pProcess == itProcs->second)
         {
-            mData.mProcesses.remove((*itProcs));
+            mData.mProcesses.erase(itProcs);
             return VINF_SUCCESS;
         }
@@ -348 +354 @@
 }
 
-int GuestSession::processCreateExInteral(const Utf8Str &aCommand, const StringsArray &aArguments, const StringsArray &aEnvironment,
-                                         ComSafeArrayIn(ProcessCreateFlag_T, aFlags), ULONG aTimeoutMS,
-                                         ProcessPriority_T aPriority, ComSafeArrayIn(LONG, aAffinity),
-                                         IGuestProcess **aProcess)
+int GuestSession::processCreateExInteral(GuestProcessInfo &aProcInfo, IGuestProcess **aProcess)
 {
     AssertPtrReturn(aProcess, VERR_INVALID_POINTER);
 
     /* Validate flags. */
-    com::SafeArray<ProcessCreateFlag_T> arrFlags(ComSafeArrayInArg(aFlags));
-    for (size_t i = 0; i < arrFlags.size(); i++)
-    {
-        if (arrFlags[i] == ExecuteProcessFlag_None)
-            continue;
-
-        if (   !(arrFlags[i] & ExecuteProcessFlag_IgnoreOrphanedProcesses)
-            && !(arrFlags[i] & ExecuteProcessFlag_WaitForProcessStartOnly)
-            && !(arrFlags[i] & ExecuteProcessFlag_Hidden)
-            && !(arrFlags[i] & ExecuteProcessFlag_NoProfile))
+    if (aProcInfo.mFlags)
+    {
+        if (   !(aProcInfo.mFlags & ProcessCreateFlag_IgnoreOrphanedProcesses)
+            && !(aProcInfo.mFlags & ProcessCreateFlag_WaitForProcessStartOnly)
+            && !(aProcInfo.mFlags & ProcessCreateFlag_Hidden)
+            && !(aProcInfo.mFlags & ProcessCreateFlag_NoProfile))
         {
             return VERR_INVALID_PARAMETER;
@@ -373 +372 @@
     /* Adjust timeout. If set to 0, we define
      * an infinite timeout. */
-    if (aTimeoutMS == 0)
-        aTimeoutMS = UINT32_MAX;
+    if (aProcInfo.mTimeoutMS == 0)
+        aProcInfo.mTimeoutMS = UINT32_MAX;
 
     /** @tood Implement process priority + affinity. */
 
-    int rc;
+    int rc = VERR_MAX_THRDS_REACHED;
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    /* Create a new (host-based) process ID and assign it. */
+    uint32_t uNewProcessID = 0;
+    uint32_t uTries = 0;
+
+    for (;;)
+    {
+        /* Is the context ID already used?  Try next ID ... */
+        if (!processExists(uNewProcessID++))
+        {
+            /* Callback with context ID was not found. This means
+             * we can use this context ID for our new callback we want
+             * to add below. */
+            rc = VINF_SUCCESS;
+            break;
+        }
+
+        if (++uTries == UINT32_MAX)
+            break; /* Don't try too hard. */
+    }
+    if (RT_FAILURE(rc)) throw rc;
+
     ComObjPtr<GuestProcess> pGuestProcess;
     try
@@ -386 +409 @@
         if (FAILED(hr)) throw VERR_COM_UNEXPECTED;
 
-        rc = pGuestProcess->init(this,
-                                 aCommand, aArguments, aEnvironment,
-                                 ComSafeArrayInArg(aFlags), aTimeoutMS,
-                                 aPriority, ComSafeArrayInArg(aAffinity));
+        rc = pGuestProcess->init(mData.mParent->getConsole() /* Console */, this /* Session */,
+                                 uNewProcessID, aProcInfo);
         if (RT_FAILURE(rc)) throw rc;
 
-        mData.mProcesses.push_back(pGuestProcess);
+        mData.mProcesses[uNewProcessID] = pGuestProcess;
 
         /* Return guest session to the caller. */
@@ -404 +425 @@
 
     return rc;
-
-#if 0
-    int rc = VINF_SUCCESS;
-
-    char **papszArgv = NULL;
-    try
-    {
-        /* Prepare arguments. */
-        uint32_t uNumArgs = 0;
-        if (aArguments)
-        {
-            com::SafeArray<IN_BSTR> args(ComSafeArrayInArg(aArguments));
-            uNumArgs = args.size();
-            papszArgv = (char**)RTMemAlloc(sizeof(char*) * (uNumArgs + 1));
-            AssertReturn(papszArgv, VERR_NO_MEMORY);
-            for (unsigned i = 0; RT_SUCCESS(rc) && i < uNumArgs; i++)
-                rc = RTUtf16ToUtf8(args[i], &papszArgv[i]);
-            papszArgv[uNumArgs] = NULL;
-
-            if (RT_FAILURE(rc))
-                return rc;
-        }
-
-        char *pszArgs = NULL;
-        if (uNumArgs)
-        {
-            rc = RTGetOptArgvToString(&pszArgs, papszArgv, RTGETOPTARGV_CNV_QUOTE_MS_CRT);
-            if (RT_FAILURE(rc)) throw rc;
-        }
-
-        /* Get number of arguments. */
-        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)
-        {
-            com::SafeArray<IN_BSTR> env(ComSafeArrayInArg(aEnvironment));
-
-            for (unsigned i = 0; RT_SUCCESS(rc) && i < env.size(); i++)
-                rc = prepareExecuteEnv(Utf8Str(env[i]).c_str(), &pvEnv, &cbEnv, &uNumEnv);
-        }
-    }
-    catch (int eRc)
-    {
-
-
-        rc = exRc;
-    }
-
-    for (unsigned i = 0; i < uNumArgs; i++)
-        RTMemFree(papszArgv[i]);
-            RTMemFree(papszArgv);
-#endif
-
-    return rc;
+}
+
+inline bool GuestSession::processExists(uint32_t uProcessID)
+{
+    AssertReturn(uProcessID, false);
+
+    SessionProcesses::const_iterator itProcesses = mData.mProcesses.find(uProcessID);
+    return (itProcesses == mData.mProcesses.end()) ? false : true;
 }
 
@@ -760 +731 @@
     ReturnComNotImplemented();
 #else
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    CheckComArgOutPointerValid(aProcess);
-
-    com::SafeArray<LONG> affinity; /** @todo Process affinity, not used yet. */
-
-    com::SafeArray<IN_BSTR> arguments(ComSafeArrayInArg(aArguments));
-    StringsArray argumentsUtf8(arguments.size());
-    for (size_t i = 0; i < arguments.size(); i++)
-        argumentsUtf8[i] = Utf8Str(Bstr(arguments[i]));
-
-    com::SafeArray<IN_BSTR> environment(ComSafeArrayInArg(aEnvironment));
-    StringsArray environmentUtf8(environment.size());
-    for (size_t i = 0; i < environment.size(); i++)
-        environmentUtf8[i] = Utf8Str(Bstr(environment[i]));
-
-    int rc = processCreateExInteral(Utf8Str(aCommand), argumentsUtf8, environmentUtf8,
-                                    ComSafeArrayInArg(aFlags), aTimeoutMS,
-                                    ProcessPriority_Default, ComSafeArrayAsInParam(affinity), aProcess);
-    return RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;
+
+    com::SafeArray<LONG> affinity;
+
+    return ProcessCreateEx(aCommand, ComSafeArrayInArg(aArguments), ComSafeArrayInArg(aEnvironment),
+                           ComSafeArrayInArg(aFlags), aTimeoutMS, ProcessPriority_Default, ComSafeArrayAsInParam(affinity), aProcess);
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }
@@ -797 +752 @@
     CheckComArgOutPointerValid(aProcess);
 
+    GuestProcessInfo procInfo;
+
+    procInfo.mCommand = Utf8Str(aCommand);
+
     com::SafeArray<IN_BSTR> arguments(ComSafeArrayInArg(aArguments));
-    StringsArray argumentsUtf8(arguments.size());
+    procInfo.mArguments.reserve(arguments.size());
     for (size_t i = 0; i < arguments.size(); i++)
-        argumentsUtf8[i] = Utf8Str(Bstr(arguments[i]));
+        procInfo.mArguments[i] = Utf8Str(Bstr(arguments[i]));
 
     com::SafeArray<IN_BSTR> environment(ComSafeArrayInArg(aEnvironment));
-    StringsArray environmentUtf8(environment.size());
     for (size_t i = 0; i < environment.size(); i++)
-        environmentUtf8[i] = Utf8Str(Bstr(environment[i]));
-
-    int rc = processCreateExInteral(Utf8Str(aCommand), argumentsUtf8, environmentUtf8,
-                                    ComSafeArrayInArg(aFlags), aTimeoutMS,
-                                    aPriority, ComSafeArrayInArg(aAffinity), aProcess);
+    {
+        Utf8Str strEnv = Bstr(environment[i]);
+        RTCList<RTCString> listPair = strEnv.split("=", RTCString::KeepEmptyParts);
+        size_t p = 0;
+        while(p < listPair.size())
+        {
+            Utf8Str strKey = listPair.at(p++);
+            if (strKey.isEmpty()) /* Skip pairs with empty keys (e.g. "=FOO"). */
+            {
+                p++;
+                continue;
+            }
+            Utf8Str strValue;
+            if (p < listPair.size())
+                strValue = listPair.at(p++);
+            procInfo.mEnvironment[strKey] = strValue;
+        }
+    }
+
+    com::SafeArray<ProcessCreateFlag_T> flags(ComSafeArrayInArg(aFlags));
+    for (size_t i = 0; i < flags.size(); i++)
+        procInfo.mFlags |= flags[i];
+
+    procInfo.mTimeoutMS = aTimeoutMS;
+
+    com::SafeArray<LONG> affinity(ComSafeArrayInArg(aAffinity));
+    procInfo.mAffinity.reserve(affinity.size());
+    for (size_t i = 0; i < affinity.size(); i++)
+        procInfo.mAffinity[i] = affinity[i]; /** @todo Really necessary? Later. */
+
+    procInfo.mPriority = aPriority;
+
+    int rc = processCreateExInteral(procInfo, aProcess);
     return RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;
 #endif /* VBOX_WITH_GUEST_CONTROL */

trunk/src/VBox/Main/testcase/Makefile.kmk

@@ -151 +151 @@
 #
 tstGuestCtrlParseBuffer_TEMPLATE = VBOXMAINCLIENTEXE
+tstGuestCtrlParseBuffer_DEFS    += VBOX_WITH_HGCM VBOX_WITH_GUEST_CONTROL
 tstGuestCtrlParseBuffer_SOURCES  = \
         tstGuestCtrlParseBuffer.cpp \
-        ../src-client/GuestCtrlIO.cpp
+        ../src-client/GuestCtrlPrivate.cpp
 tstGuestCtrlParseBuffer_INCS     = ../include
 ifeq ($(KBUILD_TARGET),win) ## @todo just add this to the template.