Changeset 2386

Timestamp:

04/27/07 11:59:46 (2 years ago)

Author:

vboxsync

Message:

Clipboard RDP channel

Files:

• trunk/include/VBox/hgcmsvc.h (modified) (4 diffs)
• trunk/include/VBox/vrdpapi.h (modified) (3 diffs)
• trunk/src/VBox/Additions/WINNT/VBoxService/VBoxClipboard.cpp (modified) (2 diffs)
• trunk/src/VBox/Main/ConsoleImpl.cpp (modified) (3 diffs)
• trunk/src/VBox/Main/ConsoleVRDPServer.cpp (modified) (7 diffs)
• trunk/src/VBox/Main/hgcm/HGCM.cpp (modified) (20 diffs)
• trunk/src/VBox/Main/hgcm/HGCMThread.cpp (modified) (1 diff)
• trunk/src/VBox/Main/include/ConsoleImpl.h (modified) (2 diffs)
• trunk/src/VBox/Main/include/ConsoleVRDPServer.h (modified) (4 diffs)
• trunk/src/VBox/Main/include/hgcm/HGCM.h (modified) (2 diffs)

trunk/include/VBox/hgcmsvc.h

@@ -46 +46 @@
- * 2.1->2.2 Because pfnSaveState and pfnLoadState were added
- * 2.2->3.1 Because pfnHostCall is now synchronous, returns rc, and parameters were changed
+ * 3.1->3.2 Because pfnRegisterExtension was added
- */
-#define VBOX_HGCM_SVC_VERSION_MINOR (0x0001)
-#define VBOX_HGCM_SVC_VERSION_MAJOR (0x0003)
+#define VBOX_HGCM_SVC_VERSION_MINOR (0x0002)
-#define VBOX_HGCM_SVC_VERSION ((VBOX_HGCM_SVC_VERSION_MAJOR << 16) + VBOX_HGCM_SVC_VERSION_MINOR)
-
@@ -92 +93 @@
-typedef VBOXHGCMSVCPARM *PVBOXHGCMSVCPARM;
-
+/** Service specific extension callback.
+ *  This callback is called by the service to perform service specific operation.
+ *  
+ * @param pvExtension The extension pointer.
+ * @param u32Function What the callback is supposed to do.
+ * @param pvParm      The function parameters.
+ * @param cbParm      The size of the function parameters.
+ */
+typedef DECLCALLBACK(int) FNHGCMSVCEXT(void *pvExtension, uint32_t u32Function, void *pvParm, uint32_t cbParms);
+typedef FNHGCMSVCEXT *PFNHGCMSVCEXT;
+
-/** The Service DLL entry points.
- *
@@ -118 +130 @@
-    uint32_t                 cbClient;
-#if ARCH_BITS == 64
-
-
-
+
+
-#endif
-
@@ -148 +159 @@
-    DECLCALLBACKMEMBER(int, pfnLoadState) (uint32_t u32ClientID, void *pvClient, PSSMHANDLE pSSM);
-
+    /** Manage the service extension. */
+    DECLCALLBACKMEMBER(int, pfnRegisterExtension) (PFNHGCMSVCEXT pfnExtension, void *pvExtension);
+
-} VBOXHGCMSVCFNTABLE;
-#pragma pack()

trunk/include/VBox/vrdpapi.h

@@ -542 +542 @@
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-#ifdef VRDP_MC
@@ -586 +607 @@
-
-/**
-
+
+
+
+
+
+
+
- *
- * @param pvCallback  Callback specific value returned by VRDPSERVERCALLBACK::pfnInterceptClipboard.
-
-
+
+
+
- * @param pvData      Points to data received from the client.
- * @param cbData      Size of the data in bytes.
@@ -598 +626 @@
-typedef DECLCALLBACK(int) FNVRDPCLIPBOARDCALLBACK (void *pvCallback,
-                                                   uint32_t u32ClientId,
+                                                   uint32_t u32Function,
-                                                   uint32_t u32Format,
-                                                   const void *pvData,

trunk/src/VBox/Additions/WINNT/VBoxService/VBoxClipboard.cpp

@@ -24 +24 @@
-// #include <iprt/crc64.h>
-
-
+// 
-
-#ifdef LOG_ENABLED
@@ -320 +320 @@
-        while ((format = EnumClipboardFormats (format)) != 0)
-        {
+            dprintf (("vboxClipboardChanged: format 0x%08X\n", format));
-            switch (format)
-            {

trunk/src/VBox/Main/ConsoleImpl.cpp

@@ -666 +666 @@
-        console->mConsoleVRDPServer->USBBackendDelete (u32ClientId);
-    }
+
+    if (fu32Intercepted & VRDP_CLIENT_INTERCEPT_CLIPBOARD)
+    {
+        console->mConsoleVRDPServer->ClipboardDelete (u32ClientId);
+    }
-#else
-    console->mConsoleVRDPServer->DeleteUSBBackend ();
@@ -788 +793 @@
-}
-
+#ifdef VRDP_MC
+DECLCALLBACK(void) Console::vrdp_InterceptClipboard (void *pvUser,
+                                                     uint32_t u32ClientId,
+                                                     PFNVRDPCLIPBOARDCALLBACK *ppfn,
+                                                     void **ppv)
+{
+    LogFlowFuncEnter();
+
+    Console *console = static_cast <Console *> (pvUser);
+    AssertReturnVoid (console);
+
+    AutoCaller autoCaller (console);
+    AssertComRCReturnVoid (autoCaller.rc());
+
+    AssertReturnVoid (console->mConsoleVRDPServer);
+
+    console->mConsoleVRDPServer->ClipboardCreate (u32ClientId, ppfn, ppv);
+
+    LogFlowFuncLeave();
+    return;
+}
+#else
+DECLCALLBACK(void) Console::vrdp_InterceptClipboard (void *pvUser,
+                                                     PFNVRDPCLIPBOARDCALLBACK *ppfn,
+                                                     void **ppv)
+{
+    /* Obsolete. */
+    return;
+}
+#endif /* VRDP_MC */
+
+
-// static
-VRDPSERVERCALLBACK Console::sVrdpServerCallback =
@@ -795 +832 @@
-    vrdp_ClientDisconnect,
-    vrdp_InterceptAudio,
-
+
+
-};
-

trunk/src/VBox/Main/ConsoleVRDPServer.cpp

@@ -26 +26 @@
-#include "Logging.h"
-
+#include <iprt/asm.h>
-#include <iprt/ldr.h>
-
@@ -33 +34 @@
-// ConsoleVRDPServer
-////////////////////////////////////////////////////////////////////////////////
+
+#define VBOX_CLIPBOARD_NO_DATA      0
+#define VBOX_CLIPBOARD_DATA_WAITING 1
+#define VBOX_CLIPBOARD_DATA_ARRIVED 2
-
-#ifdef VBOX_VRDP
@@ -51 +56 @@
-void (VBOXCALL *ConsoleVRDPServer::mpfnVRDPSendUpdate)      (HVRDPSERVER hServer, void *pvUpdate, uint32_t cbUpdate);
-void (VBOXCALL *ConsoleVRDPServer::mpfnVRDPQueryInfo)       (HVRDPSERVER hserver, uint32_t index, void *pvBuffer, uint32_t cbBuffer, uint32_t *pcbOut);
+void (VBOXCALL *ConsoleVRDPServer::mpfnVRDPClipboard)       (HVRDPSERVER hserver, uint32_t u32Function, uint32_t u32Format, const void *pvData, uint32_t cbData);
-#endif
-
@@ -60 +66 @@
-    int rc = RTCritSectInit (&mCritSect);
-    AssertRC (rc);
-
+
+
+
+
+
+
+
+
+
+
-#ifdef VBOX_WITH_USB
-    mUSBBackends.pHead = NULL;
@@ -86 +101 @@
-#ifdef VRDP_MC
-    Stop ();
+    
+    RTSemEventMultiDestroy (mEventClipboardData);
-
-    if (RTCritSectIsInitialized (&mCritSect))
@@ -417 +434 @@
-}
-
+DECLCALLBACK(int) ConsoleVRDPServer::ClipboardCallback (void *pvCallback,
+                                                        uint32_t u32ClientId,
+                                                        uint32_t u32Function,
+                                                        uint32_t u32Format,
+                                                        const void *pvData,
+                                                        uint32_t cbData)
+{
+    LogFlowFunc(("pvCallback = %p, u32ClientId = %d, u32Function = %d, u32Format = 0x%08X, pvData = %p, cbData = %d\n",
+                 pvCallback, u32ClientId, u32Function, u32Format, pvData, cbData));
+
+    int rc = VINF_SUCCESS;
+    
+    ConsoleVRDPServer *pServer = static_cast <ConsoleVRDPServer *>(pvCallback);
+    
+    NOREF(u32ClientId);
+    
+    switch (u32Function)
+    {
+        case VRDP_CLIPBOARD_FUNCTION_FORMAT_ANNOUNCE:
+        {
+            if (pServer->mpfnClipboardCallback)
+            {
+                pServer->mpfnClipboardCallback (VBOX_CLIPBOARD_EXT_FN_FORMAT_ANNOUNCE,
+                                                u32Format,
+                                                (void *)pvData,
+                                                cbData);
+            }
+            
+            /* Discard current data. */
+            ASMAtomicCmpXchgU32(&pServer->mfu32ClipboardWaitData, VBOX_CLIPBOARD_NO_DATA, VBOX_CLIPBOARD_DATA_ARRIVED);
+        } break; 
+        
+        case VRDP_CLIPBOARD_FUNCTION_DATA_READ:
+        {
+            if (pServer->mpfnClipboardCallback)
+            {
+                pServer->mpfnClipboardCallback (VBOX_CLIPBOARD_EXT_FN_DATA_READ,
+                                                u32Format,
+                                                (void *)pvData,
+                                                cbData);
+            }
+        } break; 
+
+        case VRDP_CLIPBOARD_FUNCTION_DATA_WRITE:
+        {
+            if (ASMAtomicCmpXchgU32(&pServer->mfu32ClipboardWaitData, VBOX_CLIPBOARD_DATA_ARRIVED, VBOX_CLIPBOARD_DATA_WAITING))
+            {
+                LogFlowFunc(("Got clipboard data\n"));
+                
+                if (pServer->mpvClipboardData)
+                {
+                    RTMemFree (pServer->mpvClipboardData);
+                    pServer->mpvClipboardData = NULL;
+                }
+                
+                if (cbData)
+                {
+                    void *pv = RTMemAlloc (cbData);
+            
+                    memcpy (pv, pvData, cbData);
+            
+                    pServer->mpvClipboardData = pv;
+                    pServer->mcbClipboardData = cbData;
+                }
+                else
+                {
+                    pServer->mpvClipboardData = NULL;
+                    pServer->mcbClipboardData = 0;
+                }
+            
+                RTSemEventMultiSignal (pServer->mEventClipboardData);
+            }
+        } break; 
+
+        default: 
+            rc = VERR_NOT_SUPPORTED;
+    }
+    
+    return rc;
+}
+
+DECLCALLBACK(int) ConsoleVRDPServer::ClipboardServiceExtension (void *pvExtension,
+                                                                uint32_t u32Function,
+                                                                void *pvParms,
+                                                                uint32_t cbParms)
+{
+    LogFlowFunc(("pvExtension = %p, u32Function = %d, pvParms = %p, cbParms = %d\n",
+                 pvExtension, u32Function, pvParms, cbParms));
+    
+    int rc = VINF_SUCCESS;
+    
+    ConsoleVRDPServer *pServer = static_cast <ConsoleVRDPServer *>(pvExtension);
+    
+    VBOXCLIPBOARDEXTPARMS *pParms = (VBOXCLIPBOARDEXTPARMS *)pvParms;
+    
+    switch (u32Function)
+    {
+        case VBOX_CLIPBOARD_EXT_FN_SET_CALLBACK:
+        {
+            pServer->mpfnClipboardCallback = (PFNVRDPCLIPBOARDEXTCALLBACK)pParms->pvData;
+        } break;
+
+        case VBOX_CLIPBOARD_EXT_FN_FORMAT_ANNOUNCE:
+        {
+            if (mpfnVRDPClipboard)
+            {
+                mpfnVRDPClipboard (pServer->mhServer, 
+                                   VRDP_CLIPBOARD_FUNCTION_FORMAT_ANNOUNCE,
+                                   pParms->u32Format,
+                                   NULL,
+                                   0);
+            }
+        } break;
+
+        case VBOX_CLIPBOARD_EXT_FN_DATA_READ:
+        {
+            if (mpfnVRDPClipboard)
+            {
+                if (ASMAtomicCmpXchgU32(&pServer->mfu32ClipboardWaitData, VBOX_CLIPBOARD_DATA_WAITING, VBOX_CLIPBOARD_NO_DATA))
+                {
+                    LogFlowFunc(("Wait for clipboard data\n"));
+                    RTSemEventMultiReset(pServer->mEventClipboardData);
+                    
+                    mpfnVRDPClipboard (pServer->mhServer, 
+                                       VRDP_CLIPBOARD_FUNCTION_DATA_READ,
+                                       pParms->u32Format,
+                                       NULL,
+                                       0);
+                    
+                    /* Wait for the client. 10 seconds should be enough. */
+                    int rc = RTSemEventMultiWait(pServer->mEventClipboardData, 10*1000);
+                    LogFlowFunc (("Wait completed rc = %d.\n", rc)); NOREF(rc);
+                }
+                
+                if (pServer->mfu32ClipboardWaitData == VBOX_CLIPBOARD_DATA_ARRIVED)
+                {
+                    LogFlowFunc(("Return clipboard data: pParms->cbData = %d, mcbClipboardData = %d\n", pParms->cbData, pServer->mcbClipboardData));
+                    if (pParms->cbData >= pServer->mcbClipboardData)
+                    {
+                        if (pServer->mcbClipboardData)
+                        {
+                            memcpy (pParms->pvData, pServer->mpvClipboardData, pServer->mcbClipboardData);
+                        }
+                    
+                        RTMemFree (pServer->mpvClipboardData);
+                        pServer->mpvClipboardData = NULL;
+                        
+                        pServer->mfu32ClipboardWaitData = VBOX_CLIPBOARD_NO_DATA;
+                    }
+                
+                    pParms->cbData = pServer->mcbClipboardData;
+                }
+                else
+                {
+                    pParms->pvData = NULL;
+                    pParms->cbData = 0;
+                }
+            }
+        } break;
+
+        case VBOX_CLIPBOARD_EXT_FN_DATA_WRITE:
+        {
+            if (mpfnVRDPClipboard)
+            {
+                mpfnVRDPClipboard (pServer->mhServer, 
+                                   VRDP_CLIPBOARD_FUNCTION_DATA_WRITE,
+                                   pParms->u32Format,
+                                   pParms->pvData,
+                                   pParms->cbData);
+            }
+        } break;
+        
+        default: 
+            rc = VERR_NOT_SUPPORTED;
+    }
+    
+    return rc;
+}
+
+void ConsoleVRDPServer::ClipboardCreate (uint32_t u32ClientId, PFNVRDPCLIPBOARDCALLBACK *ppfn, void **ppv)
+{
+    int rc = lockConsoleVRDPServer ();
+        
+    if (VBOX_SUCCESS (rc))
+    {
+        if (mcClipboardRefs == 0)
+        {
+            rc = HGCMHostRegisterServiceExtension (&mhClipboard, "VBoxSharedClipboard", ClipboardServiceExtension, this);
+            
+            if (VBOX_SUCCESS (rc))
+            {
+                mcClipboardRefs++;
+            }
+        }
+        
+        if (VBOX_SUCCESS (rc))
+        {
+            *ppfn = ClipboardCallback;
+            *ppv = this;
+        }
+
+        unlockConsoleVRDPServer ();
+    }
+}
+
+void ConsoleVRDPServer::ClipboardDelete (uint32_t u32ClientId)
+{
+    int rc = lockConsoleVRDPServer ();
+        
+    if (VBOX_SUCCESS (rc))
+    {
+        mcClipboardRefs--;
+        
+        if (mcClipboardRefs == 0)
+        {
+            HGCMHostUnregisterServiceExtension (mhClipboard);
+        }
+
+        unlockConsoleVRDPServer ();
+    }
+}
+
-/* That is called on INPUT thread of the VRDP server.
- * The ConsoleVRDPServer keeps a list of created backend instances.
@@ -825 +1064 @@
-                DEFSYMENTRY(VRDPSendUSBRequest),
-                DEFSYMENTRY(VRDPQueryInfo),
+                DEFSYMENTRY(VRDPClipboard)
-            };
-

trunk/src/VBox/Main/hgcm/HGCM.cpp

@@ -66 +66 @@
-#define VBOX_HGCM_SVC_NAME_MAX_BYTES 1024
-
+struct _HGCMSVCEXTHANDLEDATA
+{
+    char *pszServiceName;
+    /* The service name follows. */
+};
+
-/** Internal helper service object. HGCM code would use it to
- *  hold information about services and communicate with services.
@@ -103 +109 @@
-
-        uint32_t *m_paClientIds;
+        
+        HGCMSVCEXTHANDLE m_hExtension;
-
-        int loadServiceDLL (void);
@@ -127 +135 @@
-         */
-        static int LoadService (const char *pszServiceLibrary, const char *pszServiceName);
-
+void
-
-        static void UnloadAll (void);
@@ -146 +154 @@
-
-        uint32_t SizeOfClient (void) { return m_fntable.cbClient; };
+
+        int RegisterExtension (HGCMSVCEXTHANDLE handle, PFNHGCMSVCEXT pfnExtension, void *pvExtension);
+        void UnregisterExtension (HGCMSVCEXTHANDLE handle);
-
-        /*
@@ -213 +224 @@
-    m_cClients   (0),
-    m_cClientsAllocated (0),
-
+
+
-{
-    memset (&m_fntable, 0, sizeof (m_fntable));
@@ -230 +242 @@
-int HGCMService::loadServiceDLL (void)
-{
-(("HGCMService::loadServiceDLL: 
+Func(("
-
-    if (m_pszSvcLibrary == NULL)
@@ -243 +255 @@
-    if (VBOX_SUCCESS(rc))
-    {
-(("HGCMService::loadServiceDLL: 
+Func(("
-
-        m_pfnLoad = NULL;
@@ -270 +282 @@
-            rc = m_pfnLoad (&m_fntable);
-
-(("HGCMService::loadServiceDLL: 
+Func(("
-
-            if (VBOX_SUCCESS (rc))
@@ -294 +306 @@
-    else
-    {
-(("HGCMService::loadServiceDLL: 
+Func(("
-        m_hLdrMod = NIL_RTLDRMOD;
-    }
@@ -335 +347 @@
-#define SVC_MSG_SAVESTATE  (7)  /* pfnSaveState. */
-#define SVC_MSG_QUIT       (8)  /* Terminate the thread. */
+#define SVC_MSG_REGEXT     (9)  /* pfnRegisterExtension */
+#define SVC_MSG_UNREGEXT   (10) /* pfnRegisterExtension */
-
-class HGCMMsgSvcLoad: public HGCMMsgCore
@@ -403 +417 @@
-
-        VBOXHGCMSVCPARM *paParms;
+};
+
+class HGCMMsgSvcRegisterExtension: public HGCMMsgCore
+{
+    public:
+        /* Handle of the extension to be registered. */
+        HGCMSVCEXTHANDLE handle;
+        /* The extension entry point. */
+        PFNHGCMSVCEXT pfnExtension;
+        /* The extension pointer. */
+        void *pvExtension;
+};
+
+class HGCMMsgSvcUnregisterExtension: public HGCMMsgCore
+{
+    public:
+        /* Handle of the registered extension. */
+        HGCMSVCEXTHANDLE handle;
-};
-
@@ -417 +449 @@
-        case SVC_MSG_LOADSTATE:      
-        case SVC_MSG_SAVESTATE:   return new HGCMMsgLoadSaveStateClient ();
+        case SVC_MSG_REGEXT:      return new HGCMMsgSvcRegisterExtension ();
+        case SVC_MSG_UNREGEXT:    return new HGCMMsgSvcUnregisterExtension ();
-        default:
-            AssertReleaseMsgFailed(("Msg id = %08X\n", u32MsgId));
@@ -581 +615 @@
-                {
-                    rc = VERR_HGCM_INVALID_CLIENT_ID;
+                }
+            } break;
+            
+            case SVC_MSG_REGEXT:
+            {
+                HGCMMsgSvcRegisterExtension *pMsg = (HGCMMsgSvcRegisterExtension *)pMsgCore;
+
+                LogFlowFunc(("SVC_MSG_REGEXT handle = %p, pfn = %p\n", pMsg->handle, pMsg->pfnExtension));
+                
+                if (pSvc->m_hExtension)
+                {
+                    rc = VERR_NOT_SUPPORTED;
+                }
+                else
+                {
+                    if (pSvc->m_fntable.pfnRegisterExtension)
+                    {
+                        rc = pSvc->m_fntable.pfnRegisterExtension (pMsg->pfnExtension, pMsg->pvExtension);
+                    }
+                    else
+                    {
+                        rc = VERR_NOT_SUPPORTED;
+                    }
+                    
+                    if (VBOX_SUCCESS (rc))
+                    {
+                        pSvc->m_hExtension = pMsg->handle;
+                    }
+                }
+            } break;
+
+            case SVC_MSG_UNREGEXT:
+            {
+                HGCMMsgSvcUnregisterExtension *pMsg = (HGCMMsgSvcUnregisterExtension *)pMsgCore;
+
+                LogFlowFunc(("SVC_MSG_UNREGEXT handle = %p\n", pMsg->handle));
+                
+                if (pSvc->m_hExtension != pMsg->handle)
+                {
+                    rc = VERR_NOT_SUPPORTED;
+                }
+                else
+                {
+                    if (pSvc->m_fntable.pfnRegisterExtension)
+                    {
+                        rc = pSvc->m_fntable.pfnRegisterExtension (NULL, NULL);
+                    }
+                    else
+                    {
+                        rc = VERR_NOT_SUPPORTED;
+                    }
+                    
+                    pSvc->m_hExtension = NULL;
-                }
-            } break;
@@ -1278 +1365 @@
-}
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
- *
- * @param pHGCMPort      The port to be used for completion confirmation.
@@ -1319 +1455 @@
-    }
-
+    LogFlowFunc(("rc = %Vrc\n", rc));
-    return rc;
-}
@@ -1369 +1506 @@
-#define HGCM_MSG_RESET      (16)  /* Disconnect all clients from the specified service. */
-#define HGCM_MSG_QUIT       (17)  /* Unload all services and terminate the thread. */
+#define HGCM_MSG_REGEXT     (18)  /* Register a service extension. */
+#define HGCM_MSG_UNREGEXT   (19)  /* Unregister a service extension. */
-
-class HGCMMsgMainConnect: public HGCMMsgHeader
@@ -1423 +1562 @@
-};
-
+class HGCMMsgMainRegisterExtension: public HGCMMsgCore
+{
+    public:
+        /* Returned handle to be used in HGCMMsgMainUnregisterExtension. */
+        HGCMSVCEXTHANDLE *pHandle;
+        /* Name of the service. */
+        const char *pszServiceName;
+        /* The extension entry point. */
+        PFNHGCMSVCEXT pfnExtension;
+        /* The extension pointer. */
+        void *pvExtension;
+};
+
+class HGCMMsgMainUnregisterExtension: public HGCMMsgCore
+{
+    public:
+        /* Handle of the registered extension. */
+        HGCMSVCEXTHANDLE handle;
+};
+
-static HGCMMsgCore *hgcmMainMessageAlloc (uint32_t u32MsgId)
-{
@@ -1435 +1594 @@
-        case HGCM_MSG_RESET:      return new HGCMMsgMainReset ();
-        case HGCM_MSG_QUIT:       return new HGCMMsgMainQuit ();
+        case HGCM_MSG_REGEXT:     return new HGCMMsgMainRegisterExtension ();
+        case HGCM_MSG_UNREGEXT:   return new HGCMMsgMainUnregisterExtension ();
-        default:
-            AssertReleaseMsgFailed(("Msg id = %08X\n", u32MsgId));
@@ -1578 +1739 @@
-            } break;
-
+            case HGCM_MSG_REGEXT:
+            {
+                HGCMMsgMainRegisterExtension *pMsg = (HGCMMsgMainRegisterExtension *)pMsgCore;
+                
+                LogFlowFunc(("HGCM_MSG_REGEXT\n"));
+                
+                /* Allocate the handle data. */
+                HGCMSVCEXTHANDLE handle = (HGCMSVCEXTHANDLE)RTMemAllocZ (sizeof (struct _HGCMSVCEXTHANDLEDATA)
+                                                                         + strlen (pMsg->pszServiceName)
+                                                                         + sizeof (char));
+                
+                if (handle == NULL)
+                {
+                    rc = VERR_NO_MEMORY;
+                }
+                else
+                {
+                    handle->pszServiceName = (char *)((uint8_t *)handle + sizeof (struct _HGCMSVCEXTHANDLEDATA));
+                    strcpy (handle->pszServiceName, pMsg->pszServiceName);
+                    
+                    HGCMService *pService;
+                    rc = HGCMService::ResolveService (&pService, handle->pszServiceName);
+
+                    if (VBOX_SUCCESS (rc))
+                    {
+                        pService->RegisterExtension (handle, pMsg->pfnExtension, pMsg->pvExtension);
+
+                        pService->ReleaseService ();
+                    }
+                    
+                    if (VBOX_FAILURE (rc))
+                    {
+                        RTMemFree (handle);
+                    }
+                    else
+                    {
+                        *pMsg->pHandle = handle;
+                    }
+                }
+            } break;
+
+            case HGCM_MSG_UNREGEXT:
+            {
+                HGCMMsgMainUnregisterExtension *pMsg = (HGCMMsgMainUnregisterExtension *)pMsgCore;
+
+                LogFlowFunc(("HGCM_MSG_UNREGEXT\n"));
+
+                HGCMService *pService;
+                rc = HGCMService::ResolveService (&pService, pMsg->handle->pszServiceName);
+
+                if (VBOX_SUCCESS (rc))
+                {
+                    pService->UnregisterExtension (pMsg->handle);
+
+                    pService->ReleaseService ();
+                }
+                
+                RTMemFree (pMsg->handle);
+            } break;
+
-            default:
-            {
@@ -1647 +1868 @@
-}
-
+/* Register a HGCM service extension.
+ *
+ * @param pHandle            Returned handle for the registered extension.
+ * @param pszServiceName     The name of the service.
+ * @param pfnExtension       The extension callback.
+ * @return VBox rc.
+ */
+int HGCMHostRegisterServiceExtension (HGCMSVCEXTHANDLE *pHandle,
+                                      const char *pszServiceName,
+                                      PFNHGCMSVCEXT pfnExtension,
+                                      void *pvExtension)
+{
+    LogFlowFunc(("pHandle = %p, name = %s, pfn = %p, rv = %p\n", pHandle, pszServiceName, pfnExtension, pvExtension));
+
+    if (!pHandle || !pszServiceName || !pfnExtension)
+    {
+        return VERR_INVALID_PARAMETER;
+    }
+
+    /* Forward the request to the main hgcm thread. */
+    HGCMMSGHANDLE hMsg = 0;
+
+    int rc = hgcmMsgAlloc (g_hgcmThread, &hMsg, HGCM_MSG_REGEXT, hgcmMainMessageAlloc);
+
+    if (VBOX_SUCCESS(rc))
+    {
+        /* Initialize the message. Since the message is synchronous, use the supplied pointers. */
+        HGCMMsgMainRegisterExtension *pMsg = (HGCMMsgMainRegisterExtension *)hgcmObjReference (hMsg, HGCMOBJ_MSG);
+        AssertRelease(pMsg);
+
+        pMsg->pHandle        = pHandle;
+        pMsg->pszServiceName = pszServiceName;
+        pMsg->pfnExtension   = pfnExtension;
+        pMsg->pvExtension    = pvExtension;
+
+        hgcmObjDereference (pMsg);
+
+        rc = hgcmMsgSend (hMsg);
+    }
+
+    LogFlowFunc(("*pHandle = %p, rc = %Vrc\n", *pHandle, rc));
+    return rc;
+}
+
+void HGCMHostUnregisterServiceExtension (HGCMSVCEXTHANDLE handle)
+{
+    LogFlowFunc(("handle = %p\n", handle));
+
+    /* Forward the request to the main hgcm thread. */
+    HGCMMSGHANDLE hMsg = 0;
+
+    int rc = hgcmMsgAlloc (g_hgcmThread, &hMsg, HGCM_MSG_UNREGEXT, hgcmMainMessageAlloc);
+
+    if (VBOX_SUCCESS(rc))
+    {
+        /* Initialize the message. */
+        HGCMMsgMainUnregisterExtension *pMsg = (HGCMMsgMainUnregisterExtension *)hgcmObjReference (hMsg, HGCMOBJ_MSG);
+        AssertRelease(pMsg);
+
+        pMsg->handle = handle;
+
+        hgcmObjDereference (pMsg);
+
+        rc = hgcmMsgSend (hMsg);
+    }
+
+    LogFlowFunc(("rc = %Vrc\n", rc));
+    return;
+}
-
-/* Find a service and inform it about a client connection, create a client handle.

trunk/src/VBox/Main/hgcm/HGCMThread.cpp

@@ -200 +200 @@
-    pThread->m_fu32ThreadFlags |= HGCMMSG_TF_TERMINATED;
-
+    pThread->m_thread = NIL_RTTHREAD;
+
-    hgcmObjDeleteHandle (pThread->Handle ());
-
-    pThread->m_thread = NIL_RTTHREAD;
-
-    LogFlow(("MAIN::hgcmWorkerThreadFunc: completed HGCM thread %p\n", pThread));

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

@@ -410 +410 @@
-    static DECLCALLBACK(void)   vrdp_InterceptAudio (void *pvUser, uint32_t u32ClientId);
-    static DECLCALLBACK(void)   vrdp_InterceptUSB (void *pvUser, uint32_t u32ClientId, PFNVRDPUSBCALLBACK *ppfn, void **ppv);
+    static DECLCALLBACK(void)   vrdp_InterceptClipboard (void *pvUser, uint32_t u32ClientId, PFNVRDPCLIPBOARDCALLBACK *ppfn, void **ppv);
-#else
-    static DECLCALLBACK(int)    vrdp_ClientLogon (void *pvUser, const char *pszUser, const char *pszPassword, const char *pszDomain);
@@ -416 +417 @@
-    static DECLCALLBACK(void)   vrdp_InterceptAudio (void *pvUser, bool keepHostAudio);
-    static DECLCALLBACK(void)   vrdp_InterceptUSB (void *pvUser, PFNVRDPUSBCALLBACK *ppfn, void **ppv);
+    static DECLCALLBACK(void)   vrdp_InterceptClipboard (void *pvUser, PFNVRDPCLIPBOARDCALLBACK *ppfn, void **ppv);
-#endif /* VRDP_MC */
-