Changeset 43892 in vbox

Timestamp:

Nov 16, 2012 8:55:44 AM (12 years ago)

Author:

vboxsync

Message:

HostServices/HostChannel,Main: updates.

Location:

trunk/src/VBox

Files:

• HostServices/HostChannel/HostChannel.cpp (modified) (1 diff)
• Main/include/ConsoleVRDPServer.h (modified) (1 diff)
• Main/src-client/ConsoleVRDPServer.cpp (modified) (11 diffs)

trunk/src/VBox/HostServices/HostChannel/HostChannel.cpp

@@ -316 +316 @@
     VBOXHOSTCHINSTANCE *pInstance = NULL;
 
+    if (pvChannel == NULL)
+    {
+        return NULL;
+    }
+
     int rc = vboxHostChannelLock();
 

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

@@ -302 +302 @@
                                                     const void *pvParm, uint32_t cbParm,
                                                     const void *pvData, uint32_t cbData, uint32_t *pcbDataReturned);
+    int tsmfLock(void);
+    void tsmfUnlock(void);
+    RTCRITSECT mTSMFLock;
 };
 

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

@@ -1381 +1381 @@
     RT_ZERO(m_interfaceTSMF);
     RT_ZERO(m_interfaceCallbacksTSMF);
+
+    rc = RTCritSectInit(&mTSMFLock);
+    AssertRC(rc);
 }
 
@@ -1409 +1412 @@
         RTCritSectDelete(&mCritSect);
         memset(&mCritSect, 0, sizeof(mCritSect));
+    }
+
+    if (RTCritSectIsInitialized(&mTSMFLock))
+    {
+        RTCritSectDelete(&mTSMFLock);
+        memset(&mTSMFLock, 0, sizeof(mTSMFLock));
     }
 }
@@ -2099 +2108 @@
 }
 
-typedef struct TSMFHOSTCHANNELCTX
+
+struct TSMFHOSTCHCTX;
+struct TSMFVRDPCTX;
+
+typedef struct TSMFHOSTCHCTX
 {
     ConsoleVRDPServer *pThis;
 
-    VBOXHOSTCHANNELCALLBACKS *pCallbacks;
-    void *pvCallbacks;
-
-    uint32_t u32ChannelHandle;
+    struct TSMFVRDPCTX *pVRDPCtx; /* NULL if no corresponding host channel context. */
 
     void *pvDataReceived;
     uint32_t cbDataReceived;
     uint32_t cbDataAllocated;
-} TSMFHOSTCHANNELCTX;
+} TSMFHOSTCHCTX;
+
+typedef struct TSMFVRDPCTX
+{
+    ConsoleVRDPServer *pThis;
+
+    VBOXHOSTCHANNELCALLBACKS *pCallbacks;
+    void *pvCallbacks;
+
+    TSMFHOSTCHCTX *pHostChCtx; /* NULL if no corresponding host channel context. */
+
+    uint32_t u32ChannelHandle;
+} TSMFVRDPCTX;
+
+static int tsmfContextsAlloc(TSMFHOSTCHCTX **ppHostChCtx, TSMFVRDPCTX **ppVRDPCtx)
+{
+    TSMFHOSTCHCTX *pHostChCtx = (TSMFHOSTCHCTX *)RTMemAllocZ(sizeof(TSMFHOSTCHCTX));
+    if (!pHostChCtx)
+    {
+        return VERR_NO_MEMORY;
+    }
+
+    TSMFVRDPCTX *pVRDPCtx = (TSMFVRDPCTX *)RTMemAllocZ(sizeof(TSMFVRDPCTX));
+    if (!pVRDPCtx)
+    {
+        RTMemFree(pHostChCtx);
+        return VERR_NO_MEMORY;
+    }
+
+    *ppHostChCtx = pHostChCtx;
+    *ppVRDPCtx = pVRDPCtx;
+    return VINF_SUCCESS;
+}
+
+int ConsoleVRDPServer::tsmfLock(void)
+{
+    int rc = RTCritSectEnter(&mTSMFLock);
+    AssertRC(rc);
+    return rc;
+}
+
+void ConsoleVRDPServer::tsmfUnlock(void)
+{
+    RTCritSectLeave(&mTSMFLock);
+}
 
 /* static */ DECLCALLBACK(int) ConsoleVRDPServer::tsmfHostChannelAttach(void *pvProvider,
@@ -2123 +2177 @@
     ConsoleVRDPServer *pThis = static_cast<ConsoleVRDPServer*>(pvProvider);
 
-    TSMFHOSTCHANNELCTX *pCtx = (TSMFHOSTCHANNELCTX *)RTMemAllocZ(sizeof(TSMFHOSTCHANNELCTX));
-    if (!pCtx)
-    {
-        return VERR_NO_MEMORY;
-    }
-
-    pCtx->pThis = pThis;
-    pCtx->pCallbacks = pCallbacks;
-    pCtx->pvCallbacks = pvCallbacks;
-
-    int rc = pThis->m_interfaceTSMF.VRDETSMFChannelCreate(pThis->mhServer, pCtx, u32Flags);
+    /* Create 2 context structures: for the VRDP server and for the host service. */
+    TSMFHOSTCHCTX *pHostChCtx = NULL;
+    TSMFVRDPCTX *pVRDPCtx = NULL;
+
+    int rc = tsmfContextsAlloc(&pHostChCtx, &pVRDPCtx);
+    if (RT_FAILURE(rc))
+    {
+        return rc;
+    }
+
+    pHostChCtx->pThis = pThis;
+    pHostChCtx->pVRDPCtx = pVRDPCtx;
+
+    pVRDPCtx->pThis = pThis;
+    pVRDPCtx->pCallbacks = pCallbacks;
+    pVRDPCtx->pvCallbacks = pvCallbacks;
+    pVRDPCtx->pHostChCtx = pHostChCtx;
+
+    rc = pThis->m_interfaceTSMF.VRDETSMFChannelCreate(pThis->mhServer, pVRDPCtx, u32Flags);
 
     if (RT_SUCCESS(rc))
     {
         /* @todo contexts should be in a list for accounting. */
-        *ppvChannel = pCtx;
+        *ppvChannel = pHostChCtx;
     }
     else
     {
-        RTMemFree(pCtx);
+        RTMemFree(pHostChCtx);
+        RTMemFree(pVRDPCtx);
     }
 
@@ -2152 +2215 @@
     LogFlowFunc(("\n"));
 
-    TSMFHOSTCHANNELCTX *pCtx = (TSMFHOSTCHANNELCTX *)pvChannel;
-
-    pCtx->pThis->m_interfaceTSMF.VRDETSMFChannelClose(pCtx->pThis->mhServer, pCtx->u32ChannelHandle);
-    /* @todo */
+    TSMFHOSTCHCTX *pHostChCtx = (TSMFHOSTCHCTX *)pvChannel;
+    ConsoleVRDPServer *pThis = pHostChCtx->pThis;
+
+    int rc = pThis->tsmfLock();
+    if (RT_SUCCESS(rc))
+    {
+        bool fClose = false;
+        uint32_t u32ChannelHandle = 0;
+
+        if (pHostChCtx->pVRDPCtx)
+        {
+            /* There is still a VRDP context for this channel. */
+            pHostChCtx->pVRDPCtx->pHostChCtx = NULL;
+            u32ChannelHandle = pHostChCtx->pVRDPCtx->u32ChannelHandle;
+            fClose = true;
+        }
+
+        pThis->tsmfUnlock();
+
+        RTMemFree(pHostChCtx);
+
+        if (fClose)
+        {
+            LogFlowFunc(("Closing VRDE channel %d.\n", u32ChannelHandle));
+            pThis->m_interfaceTSMF.VRDETSMFChannelClose(pThis->mhServer, u32ChannelHandle);
+        }
+        else
+        {
+            LogFlowFunc(("No VRDE channel.\n"));
+        }
+    }
 }
 
@@ -2162 +2252 @@
                                                                       uint32_t cbData)
 {
-    LogFlowFunc(("\n"));
-    TSMFHOSTCHANNELCTX *pCtx = (TSMFHOSTCHANNELCTX *)pvChannel;
-
-    int rc = pCtx->pThis->m_interfaceTSMF.VRDETSMFChannelSend(pCtx->pThis->mhServer, pCtx->u32ChannelHandle,
-                                                              pvData, cbData);
+    LogFlowFunc(("cbData %d\n", cbData));
+
+    TSMFHOSTCHCTX *pHostChCtx = (TSMFHOSTCHCTX *)pvChannel;
+    ConsoleVRDPServer *pThis = pHostChCtx->pThis;
+
+    int rc = pThis->tsmfLock();
+    if (RT_SUCCESS(rc))
+    {
+        bool fSend = false;
+        uint32_t u32ChannelHandle = 0;
+
+        if (pHostChCtx->pVRDPCtx)
+        {
+            u32ChannelHandle = pHostChCtx->pVRDPCtx->u32ChannelHandle;
+            fSend = true;
+        }
+
+        pThis->tsmfUnlock();
+
+        if (fSend)
+        {
+            LogFlowFunc(("Send to VRDE channel %d.\n", u32ChannelHandle));
+            rc = pThis->m_interfaceTSMF.VRDETSMFChannelSend(pThis->mhServer, u32ChannelHandle,
+                                                            pvData, cbData);
+        }
+    }
 
     return rc;
@@ -2177 +2288 @@
                                                                       uint32_t *pcbRemaining)
 {
-    LogFlowFunc(("\n"));
-
-    TSMFHOSTCHANNELCTX *pCtx = (TSMFHOSTCHANNELCTX *)pvChannel;
-    int rc = VINF_SUCCESS;
-
-    uint32_t cbToCopy = RT_MIN(cbData, pCtx->cbDataReceived);
-    uint32_t cbRemaining = pCtx->cbDataReceived - cbToCopy;
-
-    LogFlowFunc(("cbToCopy %d, cbRemaining %d\n", cbToCopy, cbRemaining));
-
-    if (cbToCopy != 0)
-    {
-        memcpy(pvData, pCtx->pvDataReceived, cbToCopy);
-
-        if (cbRemaining != 0)
-        {
-            memmove(pCtx->pvDataReceived, (uint8_t *)pCtx->pvDataReceived + cbToCopy, cbRemaining);
-        }
-
-        pCtx->cbDataReceived = cbRemaining;
-    }
-
-    *pcbRemaining = cbRemaining;
-    *pcbReceived = cbToCopy;
-
-    return VINF_SUCCESS;
+    LogFlowFunc(("cbData %d\n", cbData));
+
+    TSMFHOSTCHCTX *pHostChCtx = (TSMFHOSTCHCTX *)pvChannel;
+    ConsoleVRDPServer *pThis = pHostChCtx->pThis;
+
+    int rc = pThis->tsmfLock();
+    if (RT_SUCCESS(rc))
+    {
+        uint32_t cbToCopy = RT_MIN(cbData, pHostChCtx->cbDataReceived);
+        uint32_t cbRemaining = pHostChCtx->cbDataReceived - cbToCopy;
+
+        LogFlowFunc(("cbToCopy %d, cbRemaining %d\n", cbToCopy, cbRemaining));
+
+        if (cbToCopy != 0)
+        {
+            memcpy(pvData, pHostChCtx->pvDataReceived, cbToCopy);
+
+            if (cbRemaining != 0)
+            {
+                memmove(pHostChCtx->pvDataReceived, (uint8_t *)pHostChCtx->pvDataReceived + cbToCopy, cbRemaining);
+            }
+
+            pHostChCtx->cbDataReceived = cbRemaining;
+        }
+
+        pThis->tsmfUnlock();
+
+        *pcbRemaining = cbRemaining;
+        *pcbReceived = cbToCopy;
+    }
+
+    return rc;
 }
 
@@ -2213 +2330 @@
                                                                          uint32_t *pcbDataReturned)
 {
-    LogFlowFunc(("\n"));
+    LogFlowFunc(("u32Code %u\n", u32Code));
+
     if (!pvChannel)
     {
@@ -2296 +2414 @@
                                                                     uint32_t cbParm)
 {
+    int rc = VINF_SUCCESS;
+
     ConsoleVRDPServer *pThis = static_cast<ConsoleVRDPServer*>(pvContext);
 
-    TSMFHOSTCHANNELCTX *pCtx = (TSMFHOSTCHANNELCTX *)pvChannel;
-
-    Assert(pCtx->pThis == pThis);
-
-    switch(u32Notification)
+    TSMFVRDPCTX *pVRDPCtx = (TSMFVRDPCTX *)pvChannel;
+
+    Assert(pVRDPCtx->pThis == pThis);
+
+    if (pVRDPCtx->pCallbacks == NULL)
+    {
+        LogFlowFunc(("tsmfHostChannel: Channel disconnected. Skipping.\n"));
+        return;
+    }
+
+    switch (u32Notification)
     {
         case VRDE_TSMF_N_CREATE_ACCEPTED:
@@ -2309 +2435 @@
             Assert(cbParm == sizeof(VRDETSMFNOTIFYCREATEACCEPTED));
 
-            LogFlowFunc(("VRDE_TSMF_N_CREATE_ACCEPTED: p->u32ChannelHandle %d\n", p->u32ChannelHandle));
-
-            pCtx->u32ChannelHandle = p->u32ChannelHandle;
-
-            pCtx->pCallbacks->HostChannelCallbackEvent(pCtx->pvCallbacks, pCtx,
-                                                       VBOX_TSMF_HCH_CREATE_ACCEPTED,
-                                                       NULL, 0);
+            LogFlowFunc(("tsmfHostChannel: VRDE_TSMF_N_CREATE_ACCEPTED(%p): p->u32ChannelHandle %d\n",
+                          pVRDPCtx, p->u32ChannelHandle));
+
+            pVRDPCtx->u32ChannelHandle = p->u32ChannelHandle;
+
+            pVRDPCtx->pCallbacks->HostChannelCallbackEvent(pVRDPCtx->pvCallbacks, pVRDPCtx->pHostChCtx,
+                                                           VBOX_TSMF_HCH_CREATE_ACCEPTED,
+                                                           NULL, 0);
         } break;
 
         case VRDE_TSMF_N_CREATE_DECLINED:
         {
-            pCtx->pCallbacks->HostChannelCallbackEvent(pCtx->pvCallbacks, pCtx,
-                                                       VBOX_TSMF_HCH_CREATE_DECLINED,
-                                                       NULL, 0);
+            LogFlowFunc(("tsmfHostChannel: VRDE_TSMF_N_CREATE_DECLINED(%p)\n", pVRDPCtx));
+
+            pVRDPCtx->pCallbacks->HostChannelCallbackEvent(pVRDPCtx->pvCallbacks, pVRDPCtx->pHostChCtx,
+                                                           VBOX_TSMF_HCH_CREATE_DECLINED,
+                                                           NULL, 0);
         } break;
 
@@ -2331 +2460 @@
             Assert(cbParm == sizeof(VRDETSMFNOTIFYDATA));
 
-            LogFlowFunc(("VRDE_TSMF_N_DATA: p->cbData %d\n", p->cbData));
-
-            if (pCtx->pvDataReceived)
-            {
-                uint32_t cbAlloc = p->cbData + pCtx->cbDataReceived;
-                pCtx->pvDataReceived = RTMemRealloc(pCtx->pvDataReceived, cbAlloc);
-                memcpy((uint8_t *)pCtx->pvDataReceived + pCtx->cbDataReceived, p->pvData, p->cbData);
-
-                pCtx->cbDataReceived += p->cbData;
-                pCtx->cbDataAllocated = cbAlloc;
-            }
-            else
-            {
-                pCtx->pvDataReceived = RTMemAlloc(p->cbData);
-                memcpy(pCtx->pvDataReceived, p->pvData, p->cbData);
-
-                pCtx->cbDataReceived = p->cbData;
-                pCtx->cbDataAllocated = p->cbData;
-            }
+            LogFlowFunc(("tsmfHostChannel: VRDE_TSMF_N_DATA(%p): p->cbData %d\n", pVRDPCtx, p->cbData));
 
             VBOXHOSTCHANNELEVENTRECV ev;
-            ev.u32SizeAvailable = p->cbData;
-
-            pCtx->pCallbacks->HostChannelCallbackEvent(pCtx->pvCallbacks, pCtx,
-                                                       VBOX_HOST_CHANNEL_EVENT_RECV,
-                                                       &ev, sizeof(ev));
+            ev.u32SizeAvailable = 0;
+
+            rc = pThis->tsmfLock();
+
+            if (RT_SUCCESS(rc))
+            {
+                TSMFHOSTCHCTX *pHostChCtx = pVRDPCtx->pHostChCtx;
+
+                if (pHostChCtx)
+                {
+                    if (pHostChCtx->pvDataReceived)
+                    {
+                        uint32_t cbAlloc = p->cbData + pHostChCtx->cbDataReceived;
+                        pHostChCtx->pvDataReceived = RTMemRealloc(pHostChCtx->pvDataReceived, cbAlloc);
+                        memcpy((uint8_t *)pHostChCtx->pvDataReceived + pHostChCtx->cbDataReceived, p->pvData, p->cbData);
+
+                        pHostChCtx->cbDataReceived += p->cbData;
+                        pHostChCtx->cbDataAllocated = cbAlloc;
+                    }
+                    else
+                    {
+                        pHostChCtx->pvDataReceived = RTMemAlloc(p->cbData);
+                        memcpy(pHostChCtx->pvDataReceived, p->pvData, p->cbData);
+
+                        pHostChCtx->cbDataReceived = p->cbData;
+                        pHostChCtx->cbDataAllocated = p->cbData;
+                    }
+
+                    ev.u32SizeAvailable = p->cbData;
+                }
+                else
+                {
+                    LogFlowFunc(("tsmfHostChannel: VRDE_TSMF_N_DATA: no host channel. Skipping\n"));
+                }
+
+                pThis->tsmfUnlock();
+            }
+
+            pVRDPCtx->pCallbacks->HostChannelCallbackEvent(pVRDPCtx->pvCallbacks, pVRDPCtx->pHostChCtx,
+                                                           VBOX_HOST_CHANNEL_EVENT_RECV,
+                                                           &ev, sizeof(ev));
         } break;
 
         case VRDE_TSMF_N_DISCONNECTED:
         {
-            pCtx->pCallbacks->HostChannelCallbackEvent(pCtx->pvCallbacks, pCtx,
-                                                       VBOX_TSMF_HCH_DISCONNECTED,
-                                                       NULL, 0);
+            LogFlowFunc(("tsmfHostChannel: VRDE_TSMF_N_DISCONNECTED(%p)\n", pVRDPCtx));
+
+            pVRDPCtx->pCallbacks->HostChannelCallbackEvent(pVRDPCtx->pvCallbacks, pVRDPCtx->pHostChCtx,
+                                                           VBOX_TSMF_HCH_DISCONNECTED,
+                                                           NULL, 0);
+
+            /* The callback context will not be used anymore. */
+            pVRDPCtx->pCallbacks->HostChannelCallbackDeleted(pVRDPCtx->pvCallbacks, pVRDPCtx->pHostChCtx);
+            pVRDPCtx->pCallbacks = NULL;
+            pVRDPCtx->pvCallbacks = NULL;
+
+            rc = pThis->tsmfLock();
+            if (RT_SUCCESS(rc))
+            {
+                if (pVRDPCtx->pHostChCtx)
+                {
+                    /* There is still a host channel context for this channel. */
+                    pVRDPCtx->pHostChCtx->pVRDPCtx = NULL;
+                }
+
+                pThis->tsmfUnlock();
+
+                memset(pVRDPCtx, 0, sizeof(*pVRDPCtx));
+                RTMemFree(pVRDPCtx);
+            }
         } break;