Changeset 42214 in vbox

Timestamp:

Jul 18, 2012 6:02:58 PM (13 years ago)

Author:

vboxsync

Message:

Guest Control 2.0: Update.

Location:

trunk/src/VBox/Main

Files:

• include/GuestCtrlImplPrivate.h (modified) (8 diffs)
• include/GuestImpl.h (modified) (1 diff)
• include/GuestProcessImpl.h (modified) (4 diffs)
• include/GuestSessionImpl.h (modified) (4 diffs)
• src-client/GuestCtrlImpl.cpp (modified) (8 diffs)
• src-client/GuestCtrlPrivate.cpp (modified) (8 diffs)
• src-client/GuestProcessImpl.cpp (modified) (33 diffs)
• src-client/GuestSessionImpl.cpp (modified) (8 diffs)
• testcase/Makefile.kmk (modified) (2 diffs)
• testcase/tstGuestCtrlContextID.cpp (added)
• testcase/tstGuestCtrlParseBuffer.cpp (modified) (3 diffs)

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

@@ -37 +37 @@
 
 
-/* Builds a context ID out of the session ID, process ID and an
- * increasing count. */
+/** Maximum number of guest sessions a VM can have. */
+#define VBOX_GUESTCTRL_MAX_SESSIONS     255
+/** Maximum of guest processes a guest session can have. */
+#define VBOX_GUESTCTRL_MAX_PROCESSES    255
+/** Maximum of callback contexts a guest process can have. */
+#define VBOX_GUESTCTRL_MAX_CONTEXTS     _64K - 1
+
+/** 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 \
@@ -44 +51 @@
      | (uint32_t)((uCount)   & 0xffff)       \
     )
+/** Gets the session ID out of a context ID. */
+#define VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(uContextID) \
+    ((uContextID) >> 24)
+/** Gets the process ID out of a context ID. */
+#define VBOX_GUESTCTRL_CONTEXTID_GET_PROCESS(uContextID) \
+    (((uContextID) >> 16) & 0xff)
+/** Gets the conext count of a process out of a context ID. */
+#define VBOX_GUESTCTRL_CONTEXTID_GET_COUNT(uContextID) \
+    ((uContextID) & 0xffff)
 
 
@@ -67 +83 @@
 public:
 
+    int Cancel(void);
+
+    bool Canceled(void);
+
     int Init(eVBoxGuestCtrlCallbackType enmType);
 
@@ -73 +93 @@
     eVBoxGuestCtrlCallbackType Type(void);
 
-    int Wait(RTMSINTERVAL timeoutMS);
+    int Wait(ULONG uTimeoutMS);
 
 protected:
@@ -80 +100 @@
     eVBoxGuestCtrlCallbackType  mType;
     /** Callback flags. */
-    uint32_t                    mFlags;
+    uint32_t                    uFlags;
+    /** Was the callback canceled? */
+    bool                        fCanceled;
     /** Pointer to user-supplied data. */
     void                       *pvData;
@@ -86 +108 @@
     size_t                      cbData;
     /** The event semaphore triggering the*/
-    RTSEMEVENT                  mEventSem;
+    RTSEMEVENT                  hEventSem;
     /** Extended error information, if any. */
     ErrorInfo                   mErrorInfo;
 };
-typedef std::map <uint32_t, GuestCtrlCallback> GuestCtrlCallbacks;
+typedef std::map < uint32_t, GuestCtrlCallback* > GuestCtrlCallbacks;
 
 /**
@@ -112 +134 @@
 public:
 
-    int BuildEnvironmentBlock(void **ppvEnv, uint32_t *pcbEnv, uint32_t *pcEnvVars);
+    int BuildEnvironmentBlock(void **ppvEnv, size_t *pcbEnv, uint32_t *pcEnvVars);
 
     void Clear(void);
@@ -144 +166 @@
 protected:
 
-    int appendToEnvBlock(const char *pszEnv, void **ppvList, uint32_t *pcbList, uint32_t *pcEnvVars);
+    int appendToEnvBlock(const char *pszEnv, void **ppvList, size_t *pcbList, uint32_t *pcEnvVars);
 
 protected:

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

@@ -205 +205 @@
     /** @name Public internal methods.
      * @{ */
+    int         dispatchToSession(uint32_t uContextID, uint32_t uFunction, void *pvData, size_t cbData);
     Console    *getConsole(void) { return mParent; }
     int         sessionClose(ComObjPtr<GuestSession> pSession);

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

@@ -45 +45 @@
     DECLARE_EMPTY_CTOR_DTOR(GuestProcess)
 
-    int     init(Console *aConsole, GuestSession *aSession, uint32_t aProcessID, const GuestProcessInfo &aProcInfo);
+    int     init(Console *aConsole, GuestSession *aSession, ULONG aProcessID, const GuestProcessInfo &aProcInfo);
     void    uninit(void);
     HRESULT FinalConstruct(void);
@@ -69 +69 @@
     /** @name Public internal methods.
      * @{ */
-    int callbackAdd(const GuestCtrlCallback& theCallback, uint32_t *puContextID);
-    bool callbackExists(uint32_t uContextID);
+    int callbackAdd(GuestCtrlCallback *pCallback, ULONG *puContextID);
+    int callbackDispatcher(uint32_t uContextID, uint32_t uFunction, void *pvData, size_t cbData);
+    bool callbackExists(ULONG 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));
+    ULONG getPID(void) { return mData.mPID; }
+    int onGuestDisconnected(void);
+    int onProcessInputStatus(uint32_t uStatus, uint32_t uFlags, uint32_t cbDataProcessed);
+    int onProcessStatusChange(uint32_t uStatus, uint32_t uFlags, uint32_t uPID);
+    int onProcessOutput(uint32_t uHandle, uint32_t uFlags, void *pvData, uint32_t cbData);
+    int prepareExecuteEnv(const char *pszEnv, void **ppvList, ULONG *pcbList, ULONG *pcEnvVars);
+    int readData(ULONG uHandle, ULONG uSize, ULONG uTimeoutMS, BYTE *pbData, size_t cbData);
     int startProcess(void);
     static DECLCALLBACK(int) 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);
+    int waitFor(uint32_t fFlags, ULONG uTimeoutMS, ProcessWaitReason_T *penmReason);
+    int writeData(ULONG uHandle, BYTE const *pbData, size_t cbData, ULONG uTimeoutMS, ULONG *puWritten);
     /** @}  */
 
@@ -99 +105 @@
         ULONG                    mPID;
         /** Internal, host-side process ID. */
-        uint32_t                 mProcessID;
+        ULONG                 mProcessID;
         /** The current process status. */
         ProcessStatus_T          mStatus;
@@ -105 +111 @@
         bool                     mStarted;
         /** The next upcoming context ID. */
-        uint32_t                 mNextContextID;
+        ULONG                    mNextContextID;
+        /** The waiting event. */
+        RTSEMEVENT               mEvent;
     } mData;
+
+    friend GuestSession; /* Let's be friends! */
 };
 

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

@@ -48 +48 @@
     DECLARE_EMPTY_CTOR_DTOR(GuestSession)
 
-    int     init(Guest *aGuest, uint32_t aSessionID, Utf8Str aUser, Utf8Str aPassword, Utf8Str aDomain, Utf8Str aName);
+    int     init(Guest *aGuest, ULONG aSessionID, Utf8Str aUser, Utf8Str aPassword, Utf8Str aDomain, Utf8Str aName);
     void    uninit(void);
     HRESULT FinalConstruct(void);
@@ -113 +113 @@
     typedef std::vector <ComObjPtr<GuestDirectory> > SessionDirectories;
     typedef std::vector <ComObjPtr<GuestFile> > SessionFiles;
-    typedef std::map <uint32_t, ComObjPtr<GuestProcess> > SessionProcesses;
+    /** Map of guest processes. The key specifies the internal process number.
+     *  To retrieve the process' guest PID use the Id() method of the IProgress interface. */
+    typedef std::map <ULONG, ComObjPtr<GuestProcess> > SessionProcesses;
 
 public:
@@ -119 +121 @@
      * @{ */
     int                     directoryClose(ComObjPtr<GuestDirectory> pDirectory);
+    int                     dispatchToProcess(uint32_t uContextID, uint32_t uFunction, void *pvData, size_t cbData);
     int                     fileClose(ComObjPtr<GuestFile> pFile);
     const GuestCredentials &getCredentials(void);
@@ -124 +127 @@
     int                     processClose(ComObjPtr<GuestProcess> pProcess);
     int                     processCreateExInteral(GuestProcessInfo &aProcInfo, IGuestProcess **aProcess);
-    inline bool             processExists(uint32_t uProcessID);
+    inline bool             processExists(ULONG uProcessID, ComObjPtr<GuestProcess> *pProcess);
+    inline int              processGetByPID(ULONG uPID, ComObjPtr<GuestProcess> *pProcess);
     /** @}  */
 

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

@@ -684 +684 @@
      * changes to the object state.
      */
-#ifdef DEBUG_andy
-    LogFlowFunc(("pvExtension=%p, u32Function=%d, pvParms=%p, cbParms=%d\n",
+    LogFlowFunc(("pvExtension=%p, u32Function=%RU32, pvParms=%p, cbParms=%RU32\n",
                  pvExtension, u32Function, pvParms, cbParms));
-#endif
     ComObjPtr<Guest> pGuest = reinterpret_cast<Guest *>(pvExtension);
-
-    int rc = VINF_SUCCESS;
+    Assert(!pGuest.isNull());
+
+    /*
+     * For guest control 2.0 using the legacy commands we need to do the following here:
+     * - Get the callback header to access the context ID
+     * - Get the context ID of the callback
+     * - Extract the session ID out of the context ID
+     * - Dispatch the whole stuff to the appropriate session (if still exists)
+     */
+
+    PCALLBACKHEADER pHeader = (PCALLBACKHEADER)pvParms;
+    AssertPtr(pHeader);
+
+    int rc = pGuest->dispatchToSession(pHeader->u32ContextID, u32Function, pvParms, cbParms);
+
+#ifdef VBOX_WITH_GUEST_CONTROL_LEGACY
+    if (RT_SUCCESS(rc))
+        return rc;
+
+    /* Legacy handling. */
     switch (u32Function)
     {
         case GUEST_DISCONNECTED:
         {
-            //LogFlowFunc(("GUEST_DISCONNECTED\n"));
-
             PCALLBACKDATACLIENTDISCONNECTED pCBData = reinterpret_cast<PCALLBACKDATACLIENTDISCONNECTED>(pvParms);
             AssertPtr(pCBData);
@@ -708 +722 @@
         case GUEST_EXEC_SEND_STATUS:
         {
-            //LogFlowFunc(("GUEST_EXEC_SEND_STATUS\n"));
-
             PCALLBACKDATAEXECSTATUS pCBData = reinterpret_cast<PCALLBACKDATAEXECSTATUS>(pvParms);
             AssertPtr(pCBData);
@@ -721 +733 @@
         case GUEST_EXEC_SEND_OUTPUT:
         {
-            //LogFlowFunc(("GUEST_EXEC_SEND_OUTPUT\n"));
-
             PCALLBACKDATAEXECOUT pCBData = reinterpret_cast<PCALLBACKDATAEXECOUT>(pvParms);
             AssertPtr(pCBData);
@@ -734 +744 @@
         case GUEST_EXEC_SEND_INPUT_STATUS:
         {
-            //LogFlowFunc(("GUEST_EXEC_SEND_INPUT_STATUS\n"));
-
             PCALLBACKDATAEXECINSTATUS pCBData = reinterpret_cast<PCALLBACKDATAEXECINSTATUS>(pvParms);
             AssertPtr(pCBData);
@@ -746 +754 @@
 
         default:
-            AssertMsgFailed(("Unknown guest control notification received, u32Function=%u\n", u32Function));
-            rc = VERR_INVALID_PARAMETER;
+            /* Silently ignore not implemented functions. */
+            rc = VERR_NOT_IMPLEMENTED;
             break;
     }
+#endif /* VBOX_WITH_GUEST_CONTROL_LEGACY */
     return rc;
 }
@@ -2664 +2673 @@
 /////////////////////////////////////////////////////////////////////////////
 
+int Guest::dispatchToSession(uint32_t uContextID, uint32_t uFunction, void *pvData, size_t cbData)
+{
+    AssertPtrReturn(pvData, VERR_INVALID_POINTER);
+    AssertReturn(cbData, VERR_INVALID_PARAMETER);
+
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    GuestSessions::const_iterator itSession
+        = mData.mGuestSessions.find(VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(uContextID));
+    if (itSession != mData.mGuestSessions.end())
+    {
+        ComObjPtr<GuestSession> pSession(itSession->second);
+        Assert(!pSession.isNull());
+
+        alock.release();
+        return pSession->dispatchToProcess(uContextID, uFunction, pvData, cbData);
+    }
+    return VERR_NOT_FOUND;
+}
+
 int Guest::sessionClose(ComObjPtr<GuestSession> pSession)
 {
@@ -2749 +2778 @@
 #else /* VBOX_WITH_GUEST_CONTROL */
 
-    /* Do not allow anonymous sessions (with system rights). */
+    LogFlowFuncEnter();
+
+    /* Do not allow anonymous sessions (with system rights) with official API. */
     if (RT_UNLIKELY((aUser) == NULL || *(aUser) == '\0'))
         return setError(E_INVALIDARG, tr("No user name specified"));
     CheckComArgOutPointerValid(aGuestSession);
+    /* Rest is optional. */
 
     AutoCaller autoCaller(this);
@@ -2758 +2790 @@
 
     int rc = sessionCreate(aUser, aPassword, aDomain, aSessionName, aGuestSession);
-    return RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;
+
+    /** @todo Do setError() here. */
+    HRESULT hr = RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;
+    LogFlowFuncLeaveRC(hr);
+
+    return hr;
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }

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

@@ -22 +22 @@
 #include "GuestCtrlImplPrivate.h"
 
+#include <iprt/asm.h>
 #include <iprt/ctype.h>
 #ifdef DEBUG
@@ -34 +35 @@
 GuestCtrlCallback::GuestCtrlCallback(void)
     : mType(VBOXGUESTCTRLCALLBACKTYPE_UNKNOWN),
+      uFlags(0),
+      fCanceled(false),
       pvData(NULL),
       cbData(0),
-      mEventSem(NIL_RTSEMEVENT)
+      hEventSem(NIL_RTSEMEVENT)
 {
 }
@@ -42 +45 @@
 GuestCtrlCallback::GuestCtrlCallback(eVBoxGuestCtrlCallbackType enmType)
     : mType(VBOXGUESTCTRLCALLBACKTYPE_UNKNOWN),
+      uFlags(0),
+      fCanceled(false),
       pvData(NULL),
       cbData(0),
-      mEventSem(NIL_RTSEMEVENT)
+      hEventSem(NIL_RTSEMEVENT)
 {
     int rc = Init(enmType);
@@ -53 +58 @@
 {
     Destroy();
+}
+
+int GuestCtrlCallback::Cancel(void)
+{
+    if (!ASMAtomicReadBool(&fCanceled))
+    {
+        int rc = RTSemEventSignal(hEventSem);
+        if (RT_SUCCESS(rc))
+            ASMAtomicXchgBool(&fCanceled, true);
+    }
+    return VINF_SUCCESS;
+}
+
+bool GuestCtrlCallback::Canceled(void)
+{
+    return ASMAtomicReadBool(&fCanceled);
 }
 
@@ -97 +118 @@
     if (RT_SUCCESS(rc))
     {
-        rc = RTSemEventCreate(&mEventSem);
+        rc = RTSemEventCreate(&hEventSem);
         if (RT_SUCCESS(rc))
             mType  = enmType;
@@ -114 +135 @@
     }
     cbData = 0;
-    if (mEventSem != NIL_RTSEMEVENT)
-        RTSemEventDestroy(mEventSem);
+    if (hEventSem != NIL_RTSEMEVENT)
+        RTSemEventDestroy(hEventSem);
 }
 
@@ -123 +144 @@
 }
 
-int GuestCtrlCallback::Wait(RTMSINTERVAL timeoutMS)
-{
-    Assert(mEventSem != NIL_RTSEMEVENT);
-    return RTSemEventWait(mEventSem, timeoutMS);
+int GuestCtrlCallback::Wait(ULONG uTimeoutMS)
+{
+    Assert(hEventSem != NIL_RTSEMEVENT);
+
+    RTMSINTERVAL msInterval = uTimeoutMS;
+    if (!uTimeoutMS)
+        msInterval = RT_INDEFINITE_WAIT;
+    return RTSemEventWait(hEventSem, msInterval);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-int GuestEnvironment::BuildEnvironmentBlock(void **ppvEnv, uint32_t *pcbEnv, uint32_t *pcEnvVars)
+int GuestEnvironment::BuildEnvironmentBlock(void **ppvEnv, size_t *pcbEnv, uint32_t *pcEnvVars)
 {
     AssertPtrReturn(ppvEnv, VERR_INVALID_POINTER);
     /* Rest is optional. */
 
-    uint32_t cbEnv = 0;
+    size_t cbEnv = 0;
     uint32_t cEnvVars = 0;
 
@@ -338 +363 @@
  *                          stored in the environment block.
  */
-int GuestEnvironment::appendToEnvBlock(const char *pszEnv, void **ppvList, uint32_t *pcbList, uint32_t *pcEnvVars)
+int GuestEnvironment::appendToEnvBlock(const char *pszEnv, void **ppvList, size_t *pcbList, uint32_t *pcEnvVars)
 {
     int rc = VINF_SUCCESS;
-    uint32_t cchEnv = strlen(pszEnv); Assert(cchEnv >= 2);
+    size_t cchEnv = strlen(pszEnv); Assert(cchEnv >= 2);
     if (*ppvList)
     {
-        uint32_t cbNewLen = *pcbList + cchEnv + 1; /* Include zero termination. */
+        size_t cbNewLen = *pcbList + cchEnv + 1; /* Include zero termination. */
         char *pvTmp = (char *)RTMemRealloc(*ppvList, cbNewLen);
         if (pvTmp == NULL)

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

@@ -91 +91 @@
 /////////////////////////////////////////////////////////////////////////////
 
-int GuestProcess::init(Console *aConsole, GuestSession *aSession, uint32_t aProcessID, const GuestProcessInfo &aProcInfo)
+int GuestProcess::init(Console *aConsole, GuestSession *aSession, ULONG aProcessID, const GuestProcessInfo &aProcInfo)
 {
     AssertPtrReturn(aSession, VERR_INVALID_POINTER);
@@ -103 +103 @@
     mData.mConsole = aConsole;
     mData.mParent = aSession;
+    mData.mPID = 0; /* Will be assigned by the guest OS later. */
     mData.mProcessID = aProcessID;
     mData.mStatus = ProcessStatus_Starting;
@@ -150 +151 @@
     ReturnComNotImplemented();
 #else
+    LogFlowThisFuncEnter();
+
     AutoCaller autoCaller(this);
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
@@ -169 +172 @@
     collection.detachTo(ComSafeArrayOutArg(aArguments));
 
+    LogFlowFuncLeaveRC(S_OK);
     return S_OK;
 #endif /* VBOX_WITH_GUEST_CONTROL */
@@ -178 +182 @@
     ReturnComNotImplemented();
 #else
+    LogFlowThisFuncEnter();
+
     AutoCaller autoCaller(this);
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
@@ -193 +199 @@
     arguments.detachTo(ComSafeArrayOutArg(aEnvironment));
 
+    LogFlowFuncLeaveRC(S_OK);
     return S_OK;
 #endif /* VBOX_WITH_GUEST_CONTROL */
@@ -202 +209 @@
     ReturnComNotImplemented();
 #else
+    LogFlowThisFuncEnter();
+
     AutoCaller autoCaller(this);
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
@@ -209 +218 @@
     mData.mProcess.mCommand.cloneTo(aExecutablePath);
 
+    LogFlowFuncLeaveRC(S_OK);
     return S_OK;
 #endif /* VBOX_WITH_GUEST_CONTROL */
@@ -218 +228 @@
     ReturnComNotImplemented();
 #else
+    LogFlowThisFuncEnter();
+
     AutoCaller autoCaller(this);
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
@@ -225 +237 @@
     *aExitCode = mData.mExitCode;
 
+    LogFlowFuncLeaveRC(S_OK);
     return S_OK;
 #endif /* VBOX_WITH_GUEST_CONTROL */
@@ -234 +247 @@
     ReturnComNotImplemented();
 #else
+    LogFlowThisFuncEnter();
+
     AutoCaller autoCaller(this);
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
@@ -241 +256 @@
     *aPID = mData.mPID;
 
+    LogFlowFuncLeaveRC(S_OK);
     return S_OK;
 #endif /* VBOX_WITH_GUEST_CONTROL */
@@ -250 +266 @@
     ReturnComNotImplemented();
 #else
+    LogFlowThisFuncEnter();
+
     AutoCaller autoCaller(this);
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
@@ -257 +275 @@
     *aStatus = mData.mStatus;
 
+    LogFlowFuncLeaveRC(S_OK);
     return S_OK;
 #endif /* VBOX_WITH_GUEST_CONTROL */
@@ -276 +295 @@
 */
 
-int GuestProcess::callbackAdd(const GuestCtrlCallback& theCallback, uint32_t *puContextID)
+int GuestProcess::callbackAdd(GuestCtrlCallback *pCallback, ULONG *puContextID)
 {
     const ComObjPtr<GuestSession> pSession(mData.mParent);
@@ -286 +305 @@
     /* Create a new context ID and assign it. */
     int rc = VERR_NOT_FOUND;
-    uint32_t uNewContextID = 0;
-    uint32_t uTries = 0;
+    ULONG uNewContextID = 0;
+    ULONG uTries = 0;
     for (;;)
     {
         /* Create a new context ID ... */
         uNewContextID = VBOX_GUESTCTRL_CONTEXTID_MAKE(uSessionID,
-                                                      mData.mProcessID, ASMAtomicIncU32(&mData.mNextContextID));
+                                                      mData.mProcessID, mData.mNextContextID++);
         if (uNewContextID == UINT32_MAX)
-            ASMAtomicUoWriteU32(&mData.mNextContextID, 0);
+            mData.mNextContextID = 0;
         /* Is the context ID already used?  Try next ID ... */
         if (!callbackExists(uNewContextID))
@@ -312 +331 @@
     {
         /* Add callback with new context ID to our callback map. */
-        mData.mCallbacks[uNewContextID] = theCallback;
+        mData.mCallbacks[uNewContextID] = pCallback;
         Assert(mData.mCallbacks.size());
 
@@ -323 +342 @@
 }
 
-bool GuestProcess::callbackExists(uint32_t uContextID)
+int GuestProcess::callbackDispatcher(uint32_t uContextID, uint32_t uFunction, void *pvData, size_t cbData)
+{
+    AssertPtrReturn(pvData, VERR_INVALID_POINTER);
+    AssertReturn(cbData, VERR_INVALID_PARAMETER);
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    GuestCtrlCallbacks::const_iterator it
+        = mData.mCallbacks.find(VBOX_GUESTCTRL_CONTEXTID_GET_COUNT(uContextID));
+    if (it != mData.mCallbacks.end())
+    {
+        std::auto_ptr<GuestCtrlCallback> pCallback = it->second;
+        AssertPtr(pCallback.get());
+
+        int rc;
+
+        switch (uFunction)
+        {
+            case GUEST_DISCONNECTED:
+            {
+                PCALLBACKDATACLIENTDISCONNECTED pCBData = reinterpret_cast<PCALLBACKDATACLIENTDISCONNECTED>(pvData);
+                AssertPtr(pCBData);
+                AssertReturn(sizeof(CALLBACKDATACLIENTDISCONNECTED) == cbData, VERR_INVALID_PARAMETER);
+                AssertReturn(CALLBACKDATAMAGIC_CLIENT_DISCONNECTED == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
+
+                rc = onGuestDisconnected(); /* Affects all callbacks. */
+                break;
+            }
+
+            case GUEST_EXEC_SEND_STATUS:
+            {
+                PCALLBACKDATAEXECSTATUS pCBData = reinterpret_cast<PCALLBACKDATAEXECSTATUS>(pvData);
+                AssertPtr(pCBData);
+                AssertReturn(sizeof(CALLBACKDATAEXECSTATUS) == cbData, VERR_INVALID_PARAMETER);
+                AssertReturn(CALLBACKDATAMAGIC_EXEC_STATUS == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
+
+                rc = onProcessStatusChange(pCBData->u32Status, pCBData->u32Flags, pCBData->u32PID);
+                break;
+            }
+
+            case GUEST_EXEC_SEND_OUTPUT:
+            {
+                PCALLBACKDATAEXECOUT pCBData = reinterpret_cast<PCALLBACKDATAEXECOUT>(pvData);
+                AssertPtr(pCBData);
+                AssertReturn(sizeof(CALLBACKDATAEXECOUT) == cbData, VERR_INVALID_PARAMETER);
+                AssertReturn(CALLBACKDATAMAGIC_EXEC_OUT == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
+
+                Assert(mData.mPID == pCBData->u32PID);
+                rc = onProcessOutput(pCBData->u32HandleId, pCBData->u32Flags, pCBData->pvData, pCBData->cbData);
+                break;
+            }
+
+            case GUEST_EXEC_SEND_INPUT_STATUS:
+            {
+                PCALLBACKDATAEXECINSTATUS pCBData = reinterpret_cast<PCALLBACKDATAEXECINSTATUS>(pvData);
+                AssertPtr(pCBData);
+                AssertReturn(sizeof(CALLBACKDATAEXECINSTATUS) == cbData, VERR_INVALID_PARAMETER);
+                AssertReturn(CALLBACKDATAMAGIC_EXEC_IN_STATUS == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
+
+                Assert(mData.mPID == pCBData->u32PID);
+                rc = onProcessInputStatus(pCBData->u32Status, pCBData->u32Flags, pCBData->cbProcessed);
+                break;
+            }
+
+            default:
+                /* Silently ignore not implemented functions. */
+                rc = VERR_NOT_IMPLEMENTED;
+                break;
+        }
+
+        return rc;
+    }
+
+    return VERR_NOT_FOUND;
+}
+
+bool GuestProcess::callbackExists(ULONG uContextID)
 {
     AssertReturn(uContextID, false);
@@ -344 +439 @@
 }
 
-int GuestProcess::readData(ULONG aHandle, ULONG aSize, ULONG aTimeoutMS, ComSafeArrayOut(BYTE, aData))
-{
-    LogFlowFuncEnter();
+int GuestProcess::onGuestDisconnected(void)
+{
+    LogFlowFunc(("uPID=%RU32", mData.mPID));
 
     LogFlowFuncLeave();
@@ -352 +447 @@
 }
 
+int GuestProcess::onProcessInputStatus(uint32_t uStatus, uint32_t uFlags, uint32_t cbDataProcessed)
+{
+    LogFlowFunc(("uPID=%RU32, uStatus=%RU32, uFlags=%RU32, cbDataProcessed=%RU32\n",
+                 mData.mPID, uStatus, uFlags, cbDataProcessed));
+
+    LogFlowFuncLeave();
+    return 0;
+}
+
+int GuestProcess::onProcessStatusChange(uint32_t uStatus, uint32_t uFlags, uint32_t uPID)
+{
+    LogFlowFunc(("uPID=%RU32, uStatus=%RU32, uFlags=%RU32\n",
+                 uPID, uStatus, uFlags));
+
+    LogFlowFuncLeave();
+    return 0;
+}
+
+int GuestProcess::onProcessOutput(uint32_t uHandle, uint32_t uFlags, void *pvData, uint32_t cbData)
+{
+    LogFlowFunc(("uPID=%RU32, uHandle=%RU32, uFlags=%RU32, pvData=%p, cbData=%RU32\n",
+                 mData.mPID, uHandle, uFlags, pvData, cbData));
+
+    LogFlowFuncLeave();
+    return 0;
+}
+
+int GuestProcess::readData(ULONG uHandle, ULONG uSize, ULONG uTimeoutMS, BYTE *pbData, size_t cbData)
+{
+    LogFlowFunc(("uPID=%RU32, uHandle=%RU32, uSize=%RU32, uTimeoutMS=%RU32, pbData=%p, cbData=%z\n",
+                 mData.mPID, uHandle, uSize, uTimeoutMS, pbData, cbData));
+    AssertReturn(uSize, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pbData, VERR_INVALID_POINTER);
+    AssertReturn(cbData >= uSize, VERR_INVALID_PARAMETER);
+
+    LogFlowFuncLeave();
+    return 0;
+}
+
 int GuestProcess::startProcess(void)
 {
-    LogFlowFuncEnter();
+    LogFlowFunc(("aCmd=%s, aTimeoutMS=%RU32, fFlags=%x\n",
+                 mData.mProcess.mCommand.c_str(), mData.mProcess.mTimeoutMS, mData.mProcess.mFlags));
 
     AssertReturn(!mData.mStarted, VERR_ALREADY_EXISTS);
 
     int rc;
-    uint32_t uContextID;
+    ULONG uContextID;
+    GuestCtrlCallback *pCallbackStart = (GuestCtrlCallback *)RTMemAlloc(sizeof(GuestCtrlCallback));
+    if (!pCallbackStart)
+        return VERR_NO_MEMORY;
 
     {
@@ -367 +505 @@
 
         /* 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);
+        rc = pCallbackStart->Init(VBOXGUESTCTRLCALLBACKTYPE_EXEC_START);
+        if (RT_SUCCESS(rc))
+            rc = callbackAdd(pCallbackStart, &uContextID);
+    }
+
+    if (RT_SUCCESS(rc))
+    {
         Assert(uContextID);
-    }
-
-    if (RT_SUCCESS(rc))
-    {
+
         ComObjPtr<GuestSession> pSession(mData.mParent);
         Assert(!pSession.isNull());
@@ -397 +533 @@
                 rc = RTGetOptArgvToString(&pszArgs, papszArgv, RTGETOPTARGV_CNV_QUOTE_MS_CRT);
         }
-        uint32_t cbArgs = pszArgs ? strlen(pszArgs) + 1 : 0; /* Include terminating zero. */
+        size_t cbArgs = pszArgs ? strlen(pszArgs) + 1 : 0; /* Include terminating zero. */
 
         /* Prepare environment. */
         void *pvEnv = NULL;
-        uint32_t cbEnv = 0;
+        size_t cbEnv = 0;
         rc = mData.mProcess.mEnvironment.BuildEnvironmentBlock(&pvEnv, &cbEnv, NULL /* cEnv */);
 
@@ -411 +547 @@
             paParms[i++].setUInt32(uContextID);
             paParms[i++].setPointer((void*)mData.mProcess.mCommand.c_str(),
-                                    (uint32_t)mData.mProcess.mCommand.length() + 1);
+                                    (ULONG)mData.mProcess.mCommand.length() + 1);
             paParms[i++].setUInt32(mData.mProcess.mFlags);
             paParms[i++].setUInt32(mData.mProcess.mArguments.size());
@@ -418 +554 @@
             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);
+            paParms[i++].setPointer((void*)sessionCreds.mUser.c_str(), (ULONG)sessionCreds.mUser.length() + 1);
+            paParms[i++].setPointer((void*)sessionCreds.mPassword.c_str(), (ULONG)sessionCreds.mPassword.length() + 1);
 
             /*
@@ -454 +590 @@
         if (pszArgs)
             RTStrFree(pszArgs);
+
+        if (RT_SUCCESS(rc))
+        {
+            /*
+             * Let's wait for the process being started.
+             * Note: Be sure not keeping a AutoRead/WriteLock here.
+             */
+            rc = pCallbackStart->Wait(mData.mProcess.mTimeoutMS);
+        }
     }
 
@@ -464 +609 @@
     LogFlowFuncEnter();
 
-    const ComObjPtr<GuestProcess> pProcess = static_cast<GuestProcess*>(pvUser);
+    std::auto_ptr<GuestProcessStartTask> pTask(static_cast<GuestProcessStartTask*>(pvUser));
+    AssertPtr(pTask.get());
+
+    const ComObjPtr<GuestProcess> pProcess(pTask->mProcess);
     Assert(!pProcess.isNull());
 
@@ -483 +631 @@
 }
 
-int GuestProcess::waitFor(ComSafeArrayIn(ProcessWaitForFlag_T, aFlags), ULONG aTimeoutMS, ProcessWaitReason_T *aReason)
-{
-    LogFlowFuncEnter();
+int GuestProcess::waitFor(uint32_t fFlags, ULONG uTimeoutMS, ProcessWaitReason_T *penmReason)
+{
+    LogFlowFunc(("fFlags=%x, uTimeoutMS=%RU32, penmReason=%p\n",
+                 fFlags, uTimeoutMS, penmReason));
 
     LogFlowFuncLeave();
@@ -491 +640 @@
 }
 
-int GuestProcess::writeData(ULONG aHandle, ComSafeArrayIn(BYTE, aData), ULONG aTimeoutMS, ULONG *aWritten)
-{
-    LogFlowFuncEnter();
+int GuestProcess::writeData(ULONG uHandle, const BYTE *pbData, size_t cbData, ULONG uTimeoutMS, ULONG *puWritten)
+{
+    LogFlowFunc(("uPID=%RU32, uHandle=%RU32, pbData=%p, cbData=%z, uTimeoutMS=%RU32, puWritten=%p\n",
+                 mData.mPID, uHandle, pbData, cbData, uTimeoutMS, puWritten));
+    AssertPtrReturn(pbData, VERR_INVALID_POINTER);
+    AssertReturn(pbData, VERR_INVALID_PARAMETER);
+    /* Rest is optional. */
 
     LogFlowFuncLeave();
@@ -507 +660 @@
     ReturnComNotImplemented();
 #else
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    int rc = readData(aHandle, aSize, aTimeoutMS, ComSafeArrayOutArg(aData));
+    LogFlowThisFuncEnter();
+
+    if (aSize == 0)
+        return setError(E_INVALIDARG, tr("Invalid size to read specified"));
+    CheckComArgOutSafeArrayPointerValid(aData);
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    com::SafeArray<BYTE> data(aSize);
+    int rc = readData(aHandle, aSize, aTimeoutMS, data.raw(), aSize);
+    if (RT_SUCCESS(rc))
+        data.detachTo(ComSafeArrayOutArg(aData));
+
     /** @todo Do setError() here. */
-    return RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;
+    HRESULT hr = RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;
+    LogFlowFuncLeaveRC(hr);
+
+    return hr;
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }
@@ -522 +689 @@
     ReturnComNotImplemented();
 #else
+    LogFlowThisFuncEnter();
+
     AutoCaller autoCaller(this);
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
@@ -527 +696 @@
     int rc = terminateProcess();
     /** @todo Do setError() here. */
-    return RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;
+    HRESULT hr = RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;
+    LogFlowFuncLeaveRC(hr);
+
+    return hr;
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }
@@ -536 +708 @@
     ReturnComNotImplemented();
 #else
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    int rc = waitFor(ComSafeArrayInArg(aFlags), aTimeoutMS, aReason);
+    LogFlowThisFuncEnter();
+
+    CheckComArgOutPointerValid(aReason);
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    uint32_t fFlags = ProcessWaitForFlag_None;
+    com::SafeArray<ProcessWaitForFlag_T> flags(ComSafeArrayInArg(aFlags));
+    for (size_t i = 0; i < flags.size(); i++)
+        fFlags |= flags[i];
+
+    int rc = waitFor(fFlags, aTimeoutMS, aReason);
     /** @todo Do setError() here. */
-    return RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;
+    HRESULT hr = RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;
+    LogFlowFuncLeaveRC(hr);
+
+    return hr;
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }
@@ -550 +736 @@
     ReturnComNotImplemented();
 #else
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    int rc = writeData(aHandle, ComSafeArrayInArg(aData), aTimeoutMS, aWritten);
+    LogFlowThisFuncEnter();
+
+    CheckComArgOutPointerValid(aWritten);
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    com::SafeArray<BYTE> data(aData);
+    int rc = writeData(aHandle, data.raw(), data.size(), aTimeoutMS, aWritten);
     /** @todo Do setError() here. */
-    return RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;
-#endif /* VBOX_WITH_GUEST_CONTROL */
-}
-
+    HRESULT hr = RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;
+    LogFlowFuncLeaveRC(hr);
+
+    return hr;
+#endif /* VBOX_WITH_GUEST_CONTROL */
+}
+

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

@@ -55 +55 @@
 /////////////////////////////////////////////////////////////////////////////
 
-int GuestSession::init(Guest *aGuest, uint32_t aSessionID,
+int GuestSession::init(Guest *aGuest, ULONG aSessionID,
                        Utf8Str aUser, Utf8Str aPassword, Utf8Str aDomain, Utf8Str aName)
 {
@@ -347 +347 @@
     }
 
+    return VERR_NOT_FOUND;
+}
+
+int GuestSession::dispatchToProcess(uint32_t uContextID, uint32_t uFunction, void *pvData, size_t cbData)
+{
+    AssertPtrReturn(pvData, VERR_INVALID_POINTER);
+    AssertReturn(cbData, VERR_INVALID_PARAMETER);
+
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    SessionProcesses::const_iterator itProc
+        = mData.mProcesses.find(VBOX_GUESTCTRL_CONTEXTID_GET_PROCESS(uContextID));
+    if (itProc != mData.mProcesses.end())
+    {
+        ComObjPtr<GuestProcess> pProcess(itProc->second);
+        Assert(!pProcess.isNull());
+
+        alock.release();
+        return pProcess->callbackDispatcher(uContextID, uFunction, pvData, cbData);
+    }
     return VERR_NOT_FOUND;
 }
@@ -422 +442 @@
 
     /* Create a new (host-based) process ID and assign it. */
-    uint32_t uNewProcessID = 0;
-    uint32_t uTries = 0;
+    ULONG uNewProcessID = 0;
+    ULONG uTries = 0;
 
     for (;;)
     {
         /* Is the context ID already used?  Try next ID ... */
-        if (!processExists(uNewProcessID++))
+        if (!processExists(uNewProcessID++, NULL /* pProgress */))
         {
             /* Callback with context ID was not found. This means
@@ -467 +487 @@
 }
 
-inline bool GuestSession::processExists(uint32_t uProcessID)
+inline bool GuestSession::processExists(ULONG uProcessID, ComObjPtr<GuestProcess> *pProcess)
 {
     AssertReturn(uProcessID, false);
 
-    SessionProcesses::const_iterator itProcesses = mData.mProcesses.find(uProcessID);
-    return (itProcesses == mData.mProcesses.end()) ? false : true;
+    SessionProcesses::const_iterator it = mData.mProcesses.find(uProcessID);
+    if (it != mData.mProcesses.end())
+    {
+        if (pProcess)
+            *pProcess = it->second;
+        return true;
+    }
+    return false;
+}
+
+inline int GuestSession::processGetByPID(ULONG uPID, ComObjPtr<GuestProcess> *pProcess)
+{
+    AssertReturn(uPID, false);
+    /* pProcess is optional. */
+
+    SessionProcesses::iterator it = mData.mProcesses.begin();
+    for (; it != mData.mProcesses.end(); it++)
+    {
+        ComObjPtr<GuestProcess> pCurProc = it->second;
+        AutoCaller procCaller(pCurProc);
+        if (procCaller.rc())
+            return VERR_COM_INVALID_OBJECT_STATE;
+
+        if (it->second->getPID() == uPID)
+        {
+            if (pProcess)
+                *pProcess = pCurProc;
+            return VINF_SUCCESS;
+        }
+    }
+
+    return VERR_NOT_FOUND;
 }
 
@@ -897 +947 @@
     LogFlowThisFuncEnter();
 
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+    if (RT_UNLIKELY((aCommand) == NULL || *(aCommand) == '\0'))
+        return setError(E_INVALIDARG, tr("No command to execute specified"));
     CheckComArgOutPointerValid(aProcess);
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
     GuestProcessInfo procInfo;
@@ -925 +977 @@
     if (RT_SUCCESS(rc))
     {
-
         com::SafeArray<ProcessCreateFlag_T> flags(ComSafeArrayInArg(aFlags));
         for (size_t i = 0; i < flags.size(); i++)
@@ -953 +1004 @@
     ReturnComNotImplemented();
 #else
-    LogFlowThisFuncEnter();
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    ReturnComNotImplemented();
+    LogFlowThisFunc(("aPID=%RU32\n", aPID));
+
+    CheckComArgOutPointerValid(aProcess);
+    if (aPID == 0)
+        return setError(E_INVALIDARG, tr("No valid process ID (PID) specified"));
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    HRESULT hr = S_OK;
+
+    ComObjPtr<GuestProcess> pProcess;
+    int rc = processGetByPID(aPID, &pProcess);
+    if (RT_FAILURE(rc))
+        hr = setError(E_INVALIDARG, tr("No process with PID %RU32 found"), aPID);
+
+    /* This will set (*aProcess) to NULL if pProgress is NULL. */
+    HRESULT hr2 = pProcess.queryInterfaceTo(aProcess);
+    if (SUCCEEDED(hr))
+        hr = hr2;
+
+    LogFlowThisFunc(("aProcess=%p, hr=%Rrc\n", *aProcess, hr));
+    return hr;
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }
@@ -972 +1042 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    ReturnComNotImplemented();
+    if (aTimeoutMS < 1000)
+        return setError(E_INVALIDARG, tr("Invalid timeout value specified"));
+
+    mData.mTimeout = aTimeoutMS;
+
+    LogFlowThisFunc(("aTimeoutMS=%RU32\n", mData.mTimeout));
+    return S_OK;
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }

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

@@ -29 +29 @@
         $(if $(VBOX_WITH_XPCOM),tstVBoxAPILinux,tstVBoxAPIWin) \
         $(if $(VBOX_WITH_RESOURCE_USAGE_API),tstCollector,) \
-        $(if $(VBOX_WITH_GUEST_CONTROL),tstGuestCtrlParseBuffer,)
+        $(if $(VBOX_WITH_GUEST_CONTROL),tstGuestCtrlParseBuffer,) \
+        $(if $(VBOX_WITH_GUEST_CONTROL),tstGuestCtrlContextID,)
   PROGRAMS.linux += \
         $(if $(VBOX_WITH_USB),tstUSBProxyLinux,)
@@ -160 +161 @@
 else
  tstGuestCtrlParseBuffer_DEPS    = $(VBOX_PATH_SDK)/bindings/xpcom/include/VirtualBox_XPCOM.h
+endif
+
+
+#
+# tstGuestCtrlContextID
+#
+tstGuestCtrlContextID_TEMPLATE = VBOXMAINCLIENTEXE
+tstGuestCtrlContextID_DEFS    += VBOX_WITH_HGCM VBOX_WITH_GUEST_CONTROL
+tstGuestCtrlContextID_SOURCES  = \
+        tstGuestCtrlContextID.cpp \
+        ../src-client/GuestCtrlPrivate.cpp
+tstGuestCtrlContextID_INCS     = ../include
+ifeq ($(KBUILD_TARGET),win) ## @todo just add this to the template.
+ tstGuestCtrlContextID_DEPS    = $(VBOX_PATH_SDK)/bindings/mscom/include/VirtualBox.h
+else
+ tstGuestCtrlContextID_DEPS    = $(VBOX_PATH_SDK)/bindings/xpcom/include/VirtualBox_XPCOM.h
 endif
 

trunk/src/VBox/Main/testcase/tstGuestCtrlParseBuffer.cpp

@@ -205 +205 @@
             if (iResult != aTestBlock[iTest].iResult)
             {
-                RTTestFailed(hTest, "\tReturned %Rrc, expected %Rrc",
+                RTTestFailed(hTest, "\tReturned %Rrc, expected %Rrc\n",
                              iResult, aTestBlock[iTest].iResult);
             }
             else if (stream.GetOffset() != aTestBlock[iTest].uOffsetAfter)
             {
-                RTTestFailed(hTest, "\tOffset %u wrong, expected %u",
+                RTTestFailed(hTest, "\tOffset %u wrong, expected %u\n",
                              stream.GetOffset(), aTestBlock[iTest].uOffsetAfter);
             }
@@ -223 +223 @@
                 if (curBlock.GetCount() != aTestBlock[iTest].uMapElements)
                 {
-                    RTTestFailed(hTest, "\tMap has %u elements, expected %u",
+                    RTTestFailed(hTest, "\tMap has %u elements, expected %u\n",
                                  curBlock.GetCount(), aTestBlock[iTest].uMapElements);
                 }
@@ -275 +275 @@
             if (iResult != aTestStream[iTest].iResult)
             {
-                RTTestFailed(hTest, "\tReturned %Rrc, expected %Rrc",
+                RTTestFailed(hTest, "\tReturned %Rrc, expected %Rrc\n",
                              iResult, aTestStream[iTest].iResult);
             }