Changeset 78897 in vbox for trunk/src/VBox/Main/src-client

Timestamp:

May 31, 2019 3:23:14 PM (6 years ago)

Author:

vboxsync

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

131016

Message:

Shared Clipboard/URI: Update.

Location:

trunk/src/VBox/Main/src-client

Files:

• ConsoleImpl.cpp (modified) (5 diffs)
• ConsoleImpl2.cpp (modified) (3 diffs)
• ConsoleVRDPServer.cpp (modified) (5 diffs)
• SharedClipboardPrivate.cpp (modified) (1 diff)

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

@@ -126 +126 @@
 #include <VBox/VMMDev.h>
 
+#ifdef VBOX_WITH_SHARED_CLIPBOARD
 #include <VBox/HostServices/VBoxClipboardSvc.h>
+# ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+#  include "SharedClipboardPrivate.h"
+# endif
+#endif
 #include <VBox/HostServices/DragAndDropSvc.h>
 #ifdef VBOX_WITH_GUEST_PROPS
@@ -2085 +2090 @@
 HRESULT Console::setUseHostClipboard(BOOL aUseHostClipboard)
 {
-    mfUseHostClipboard = !!aUseHostClipboard;
+    if (mfUseHostClipboard != RT_BOOL(aUseHostClipboard))
+    {
+        mfUseHostClipboard = RT_BOOL(aUseHostClipboard);
+        LogRel(("Shared Clipboard: %s using host clipboard\n", mfUseHostClipboard ? "Enabled" : "Disabled"));
+    }
 
     return S_OK;
@@ -8399 +8408 @@
 }
 
+#ifdef VBOX_WITH_SHARED_CLIPBOARD
+/* static */
+DECLCALLBACK(int) Console::i_sharedClipboardServiceCallback(void *pvExtension, uint32_t u32Function,
+                                                            void *pvParms, uint32_t cbParms)
+{
+    LogFlowFunc(("pvExtension=%p, u32Function=%RU32, pvParms=%p, cbParms=%RU32\n",
+                 pvExtension, u32Function, pvParms, cbParms));
+
+    RT_NOREF(pvParms, cbParms);
+
+    Console *pThis = reinterpret_cast<Console *>(pvExtension);
+    AssertPtrReturn(pThis, VERR_INVALID_POINTER);
+
+    ComPtr<IInternalMachineControl> pControl = pThis->mControl;
+
+    int rc = VINF_SUCCESS;
+    HRESULT hrc;
+
+#define H()         AssertMsgBreakStmt(!FAILED(hrc), ("hrc=%Rhrc\n", hrc), rc = VERR_GENERAL_FAILURE)
+
+    switch (u32Function)
+    {
+        case VBOX_CLIPBOARD_EXT_FN_SET_CALLBACK:
+        {
+            LogFlowFunc(("VBOX_CLIPBOARD_EXT_FN_SET_CALLBACK\n"));
+        } break;
+
+        case VBOX_CLIPBOARD_EXT_FN_FORMAT_ANNOUNCE:
+        {
+            LogFlowFunc(("VBOX_CLIPBOARD_EXT_FN_FORMAT_ANNOUNCE\n"));
+
+            VBOXCLIPBOARDEXTPARMS *pParms = (VBOXCLIPBOARDEXTPARMS *)pvParms;
+
+            /* The guest announces clipboard formats. This must be delivered to all clients. */
+            if (pThis->mConsoleVRDPServer)
+                pThis->mConsoleVRDPServer->SendClipboard(VRDE_CLIPBOARD_FUNCTION_FORMAT_ANNOUNCE,
+                                                         pParms->u32Format,
+                                                         NULL,
+                                                         0,
+                                                         NULL);
+        } break;
+
+        case VBOX_CLIPBOARD_EXT_FN_DATA_READ:
+        {
+            LogFlowFunc(("VBOX_CLIPBOARD_EXT_FN_DATA_READ\n"));
+
+            VBOXCLIPBOARDEXTPARMS *pParms = (VBOXCLIPBOARDEXTPARMS *)pvParms;
+
+            /* The clipboard service expects that the pvData buffer will be filled
+             * with clipboard data. The server returns the data from the client that
+             * announced the requested format most recently.
+             */
+            if (pThis->mConsoleVRDPServer)
+                pThis->mConsoleVRDPServer->SendClipboard(VRDE_CLIPBOARD_FUNCTION_DATA_READ,
+                                                         pParms->u32Format,
+                                                         pParms->u.pvData,
+                                                         pParms->cbData,
+                                                         &pParms->cbData);
+        } break;
+
+        case VBOX_CLIPBOARD_EXT_FN_DATA_WRITE:
+        {
+            LogFlowFunc(("VBOX_CLIPBOARD_EXT_FN_DATA_WRITE\n"));
+
+            VBOXCLIPBOARDEXTPARMS *pParms = (VBOXCLIPBOARDEXTPARMS *)pvParms;
+
+            if (pThis->mConsoleVRDPServer)
+                pThis->mConsoleVRDPServer->SendClipboard(VRDE_CLIPBOARD_FUNCTION_DATA_WRITE,
+                                                         pParms->u32Format,
+                                                         pParms->u.pvData,
+                                                         pParms->cbData,
+                                                         NULL);
+        } break;
+
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+        case VBOX_CLIPBOARD_EXT_FN_AREA_REGISTER:
+        {
+            com::SafeArray<BSTR> abstrParms; /* Empty for now. */
+            ULONG uID;
+            hrc = pControl->ClipboardAreaRegister(ComSafeArrayAsInParam(abstrParms), &uID);      H();
+        } break;
+
+        case VBOX_CLIPBOARD_EXT_FN_AREA_UNREGISTER:
+        {
+            PVBOXCLIPBOARDEXTAREAPARMS pParms = (PVBOXCLIPBOARDEXTAREAPARMS)pvParms;
+            AssertPtrBreakStmt(pParms, rc = VERR_INVALID_POINTER);
+            hrc = pControl->ClipboardAreaUnregister(pParms->uID);                                H();
+        } break;
+
+        case VBOX_CLIPBOARD_EXT_FN_AREA_ATTACH:
+        {
+            PVBOXCLIPBOARDEXTAREAPARMS pParms = (PVBOXCLIPBOARDEXTAREAPARMS)pvParms;
+            AssertPtrBreakStmt(pParms, rc = VERR_INVALID_POINTER);
+            hrc = pControl->ClipboardAreaAttach(pParms->uID);                                    H();
+        } break;
+
+        case VBOX_CLIPBOARD_EXT_FN_AREA_DETACH:
+        {
+            PVBOXCLIPBOARDEXTAREAPARMS pParms = (PVBOXCLIPBOARDEXTAREAPARMS)pvParms;
+            AssertPtrBreakStmt(pParms, rc = VERR_INVALID_POINTER);
+            hrc = pControl->ClipboardAreaDetach(pParms->uID);                                    H();
+        } break;
+#endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
+
+        default:
+        {
+            rc = VERR_NOT_SUPPORTED;
+        } break;
+    }
+
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST_DISABLED
+    int rc2 = SharedClipboard::hostServiceCallback(SHAREDCLIPBOARDINST(), u32Function, pvParms, cbParms);
+    if (RT_SUCCESS(rc))
+        rc = rc2;
+#endif
+
+#undef H
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+#endif /* VBOX_WITH_SHARED_CLIPBOARD */
+
 /**
  * Searches for a shared folder with the given logical name
@@ -9124 +9256 @@
 {
     VMMDev *pVMMDev = m_pVMMDev;
-    AssertPtr(pVMMDev);
+    AssertPtrReturn(pVMMDev, VERR_INVALID_POINTER);
 
     VBOXHGCMSVCPARM parm;
@@ -9133 +9265 @@
         default:
         case ClipboardMode_Disabled:
-            LogRel(("Shared clipboard mode: Off\n"));
+            LogRel(("Shared Clipboard: Mode: Off\n"));
             parm.u.uint32 = VBOX_SHARED_CLIPBOARD_MODE_OFF;
             break;
         case ClipboardMode_GuestToHost:
-            LogRel(("Shared clipboard mode: Guest to Host\n"));
+            LogRel(("Shared Clipboard: Mode: Guest to Host\n"));
             parm.u.uint32 = VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST;
             break;
         case ClipboardMode_HostToGuest:
-            LogRel(("Shared clipboard mode: Host to Guest\n"));
+            LogRel(("Shared Clipboard: Mode: Host to Guest\n"));
             parm.u.uint32 = VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST;
             break;
         case ClipboardMode_Bidirectional:
-            LogRel(("Shared clipboard mode: Bidirectional\n"));
+            LogRel(("Shared Clipboard: Mode: Bidirectional\n"));
             parm.u.uint32 = VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL;
             break;
     }
 
-    int rc =  pVMMDev->hgcmHostCall("VBoxSharedClipboard", VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE, 1, &parm);
+    int rc = pVMMDev->hgcmHostCall("VBoxSharedClipboard", VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE, 1, &parm);
     if (RT_FAILURE(rc))
-        LogRel(("Error changing shared clipboard mode: %Rrc\n", rc));
+        LogRel(("Shared Clipboard: Error changing mode: %Rrc\n", rc));
 
     return rc;

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

@@ -3085 +3085 @@
          */
         {
-            /* Load the service */
-            rc = pVMMDev->hgcmLoadService("VBoxSharedClipboard", "VBoxSharedClipboard");
-            if (RT_SUCCESS(rc))
-            {
-                SharedClipboard *pSharedClipboard = SharedClipboard::createInstance(this /* pConsole */);
-                if (pSharedClipboard)
-                {
-# ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST_DISABLED
+            if (SharedClipboard::createInstance(this /* pConsole */) == NULL)
+            {
+                rc = VERR_NO_MEMORY;
+            }
+            else
+            {
+                /* Load the service */
+                rc = pVMMDev->hgcmLoadService("VBoxSharedClipboard", "VBoxSharedClipboard");
+                if (RT_SUCCESS(rc))
+                {
+                    LogRel(("Shared Clipboard: Service loaded\n"));
                     HGCMSVCEXTHANDLE hDummy;
                     rc = HGCMHostRegisterServiceExtension(&hDummy, "VBoxSharedClipboard",
-                                                          &SharedClipboard::hostServiceCallback,
-                                                          pSharedClipboard);
+                                                          &Console::i_sharedClipboardServiceCallback,
+                                                          this /* pvExtension */);
                     if (RT_FAILURE(rc))
+                    {
                         LogRel(("Shared Clipboard: Cannot register service extension, rc=%Rrc\n", rc));
-# endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
-
-                    if (RT_SUCCESS(rc))
+                    }
+                    else
                     {
-                        LogRel(("Shared Clipboard: Service loaded\n"));
-
                         /* Set initial clipboard mode. */
                         ClipboardMode_T mode = ClipboardMode_Disabled;
                         hrc = pMachine->COMGETTER(ClipboardMode)(&mode); H();
+
                         rc = i_changeClipboardMode(mode);
                         if (RT_SUCCESS(rc))
@@ -3114 +3116 @@
                             VBOXHGCMSVCPARM parm;
                             HGCMSvcSetU32(&parm, !i_useHostClipboard());
-                            rc = pSharedClipboard->hostCall(VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS, 1, &parm);
+                            rc = SHAREDCLIPBOARDINST()->hostCall(VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS, 1, &parm);
                             if (RT_FAILURE(rc))
                                 LogRel(("Shared Clipboard: Unable to set initial headless mode, rc=%Rrc\n", rc));
@@ -3120 +3122 @@
                     }
                 }
-                else
-                    rc = VERR_NO_MEMORY;
             }
 

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

@@ -3300 +3300 @@
     ConsoleVRDPServer *pServer = static_cast <ConsoleVRDPServer *>(pvCallback);
 
-    NOREF(u32ClientId);
+    RT_NOREF(u32ClientId);
 
     switch (u32Function)
@@ -3327 +3327 @@
 
         default:
+        {
             rc = VERR_NOT_SUPPORTED;
+        } break;
     }
 
@@ -3333 +3335 @@
 }
 
-DECLCALLBACK(int) ConsoleVRDPServer::ClipboardServiceExtension(void *pvExtension,
-                                                               uint32_t u32Function,
-                                                               void *pvParms,
-                                                               uint32_t cbParms)
-{
-    RT_NOREF(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 = pParms->u.pfnCallback;
-        } break;
-
-        case VBOX_CLIPBOARD_EXT_FN_FORMAT_ANNOUNCE:
-        {
-            /* The guest announces clipboard formats. This must be delivered to all clients. */
-            if (mpEntryPoints && pServer->mhServer)
-            {
-                mpEntryPoints->VRDEClipboard(pServer->mhServer,
-                                             VRDE_CLIPBOARD_FUNCTION_FORMAT_ANNOUNCE,
-                                             pParms->u32Format,
-                                             NULL,
-                                             0,
-                                             NULL);
-            }
-        } break;
-
-        case VBOX_CLIPBOARD_EXT_FN_DATA_READ:
-        {
-            /* The clipboard service expects that the pvData buffer will be filled
-             * with clipboard data. The server returns the data from the client that
-             * announced the requested format most recently.
-             */
-            if (mpEntryPoints && pServer->mhServer)
-            {
-                mpEntryPoints->VRDEClipboard(pServer->mhServer,
-                                             VRDE_CLIPBOARD_FUNCTION_DATA_READ,
-                                             pParms->u32Format,
-                                             pParms->u.pvData,
-                                             pParms->cbData,
-                                             &pParms->cbData);
-            }
-        } break;
-
-        case VBOX_CLIPBOARD_EXT_FN_DATA_WRITE:
-        {
-            if (mpEntryPoints && pServer->mhServer)
-            {
-                mpEntryPoints->VRDEClipboard(pServer->mhServer,
-                                             VRDE_CLIPBOARD_FUNCTION_DATA_WRITE,
-                                             pParms->u32Format,
-                                             pParms->u.pvData,
-                                             pParms->cbData,
-                                             NULL);
-            }
-        } break;
-
-        default:
-            rc = VERR_NOT_SUPPORTED;
-    }
-
-    return rc;
-}
-
 void ConsoleVRDPServer::ClipboardCreate(uint32_t u32ClientId)
 {
     RT_NOREF(u32ClientId);
+
     int rc = lockConsoleVRDPServer();
-
     if (RT_SUCCESS(rc))
     {
         if (mcClipboardRefs == 0)
-        {
-            rc = HGCMHostRegisterServiceExtension(&mhClipboard, "VBoxSharedClipboard", ClipboardServiceExtension, this);
-
-            if (RT_SUCCESS(rc))
-            {
-                mcClipboardRefs++;
-            }
-        }
+            mcClipboardRefs++;
 
         unlockConsoleVRDPServer();
@@ -3430 +3352 @@
 {
     RT_NOREF(u32ClientId);
+
     int rc = lockConsoleVRDPServer();
-
     if (RT_SUCCESS(rc))
     {
+        Assert(mcClipboardRefs);
         mcClipboardRefs--;
-
-        if (mcClipboardRefs == 0)
-        {
-            HGCMHostUnregisterServiceExtension(mhClipboard);
-        }
 
         unlockConsoleVRDPServer();
@@ -3753 +3671 @@
     {
         mpEntryPoints->VRDEUSBRequest(mhServer, u32ClientId, pvParms, cbParms);
+    }
+}
+
+void ConsoleVRDPServer::SendClipboard(uint32_t u32Function, uint32_t u32Format,
+                                      void *pvData, uint32_t cbData, uint32_t *pcbActualRead) const
+{
+    if (mpEntryPoints && mhServer)
+    {
+        mpEntryPoints->VRDEClipboard(mhServer, u32Function, u32Format, pvData, cbData, pcbActualRead);
     }
 }

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

@@ -61 +61 @@
     RT_NOREF(pvParms, cbParms);
 
-    SharedClipboard *pSharedClipboard = reinterpret_cast<SharedClipboard *>(pvExtension);
-    AssertPtrReturn(pSharedClipboard, VERR_INVALID_POINTER);
+    SharedClipboard *pThis = reinterpret_cast<SharedClipboard *>(pvExtension);
+    AssertPtrReturn(pThis, VERR_INVALID_POINTER);
 
-    int rc;
-
-    switch (u32Function)
-    {
-        default:
-            rc = VERR_NOT_SUPPORTED;
-            break;
-    }
+    int rc = VINF_SUCCESS;
 
     LogFlowFuncLeaveRC(rc);