Changeset 80444 in vbox for trunk/src/VBox/Additions/WINNT/VBoxTray

Timestamp:

Aug 27, 2019 5:47:44 PM (5 years ago)

Author:

vboxsync

Message:

Shared Clipboard/URI: Added protocol versioning support plus enhanced versions of existing commands (to also provide context IDs, among other stuff). So far only the host service(s) and the Windows guest is using the new(er) protocol.

Location:

trunk/src/VBox/Additions/WINNT/VBoxTray

Files:

• Makefile.kmk (modified) (2 diffs)
• VBoxClipboard.cpp (modified) (19 diffs)

trunk/src/VBox/Additions/WINNT/VBoxTray/Makefile.kmk

@@ -51 +51 @@
  VBoxTray_SOURCES  += \
         VBoxClipboard.cpp \
-        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/clipboard-win.cpp
+        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/clipboard-win.cpp \
+        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/clipboard-common.cpp
  ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
   VBoxTray_DEFS     += VBOX_WITH_SHARED_CLIPBOARD_GUEST
@@ -60 +61 @@
         $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardPath.cpp \
         $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardStreamImpl-win.cpp \
-        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/clipboard-common.cpp \
         $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/clipboard-uri.cpp
  endif

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

@@ -27 +27 @@
 
 #include <iprt/asm.h>
+#include <iprt/errcore.h>
+#include <iprt/mem.h>
 #include <iprt/ldr.h>
 
-#include <iprt/errcore.h>
 
 #include <VBox/GuestHost/SharedClipboard.h>
+#include <VBox/GuestHost/SharedClipboard-win.h>
+#include <VBox/GuestHost/clipboard-helper.h>
 #include <VBox/HostServices/VBoxClipboardSvc.h> /* Temp, remove. */
-#include <VBox/GuestHost/SharedClipboard-win.h>
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
 # include <VBox/GuestHost/SharedClipboard-uri.h>
@@ -118 +120 @@
     if (RT_SUCCESS(rc))
     {
-        rc = VbglR3ClipboardTransferSendStatus(&cmdCtx, SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING);
+        rc = VbglR3ClipboardTransferSendStatus(&cmdCtx, pTransfer, SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING);
         if (RT_SUCCESS(rc))
         {
@@ -127 +129 @@
             {
                 PVBGLR3CLIPBOARDEVENT pEvent = NULL;
-                rc = VbglR3ClipboardEventGetNext(&cmdCtx, pTransfer, &pEvent);
+                rc = VbglR3ClipboardEventGetNext(&cmdCtx, &pEvent);
                 if (RT_SUCCESS(rc))
                 {
@@ -425 +427 @@
                /* Clipboard was updated by another application.
                 * Report available formats to the host. */
-               VBOXCLIPBOARDFORMATS fFormats;
-               int rc = VBoxClipboardWinGetFormats(&pCtx->Win, &fFormats);
+               SHAREDCLIPBOARDFORMATDATA Formats;
+               int rc = VBoxClipboardWinGetFormats(&pCtx->Win, &Formats);
                if (RT_SUCCESS(rc))
                {
-                   LogFunc(("WM_CLIPBOARDUPDATE: Reporting formats 0x%x\n", fFormats));
-                   rc = VbglR3ClipboardReportFormats(pCtx->CmdCtx.uClientID, fFormats);
+                   LogFunc(("WM_CLIPBOARDUPDATE: Reporting formats 0x%x\n", Formats.uFormats));
+                   rc = VbglR3ClipboardFormatsSend(&pCtx->CmdCtx, &Formats);
                }
            }
@@ -452 +454 @@
                /* Clipboard was updated by another application. */
                /* WM_DRAWCLIPBOARD always expects a return code of 0, so don't change "rc" here. */
-               VBOXCLIPBOARDFORMATS fFormats;
-               int rc = VBoxClipboardWinGetFormats(pWinCtx, &fFormats);
+               SHAREDCLIPBOARDFORMATDATA Formats;
+               int rc = VBoxClipboardWinGetFormats(pWinCtx, &Formats);
                if (RT_SUCCESS(rc))
-                   rc = VbglR3ClipboardReportFormats(pCtx->CmdCtx.uClientID, fFormats);
+                   rc = VbglR3ClipboardFormatsSend(&pCtx->CmdCtx, &Formats);
            }
 
@@ -641 +643 @@
 
            /* Announce available formats. Do not insert data -- will be inserted in WM_RENDERFORMAT. */
-           VBOXCLIPBOARDFORMATS fFormats = (uint32_t)lParam;
+           PVBGLR3CLIPBOARDEVENT pEvent = (PVBGLR3CLIPBOARDEVENT)lParam;
+           AssertPtr(pEvent);
+           Assert(pEvent->enmType == VBGLR3CLIPBOARDEVENTTYPE_REPORT_FORMATS);
+
+           const VBOXCLIPBOARDFORMATS fFormats =  pEvent->u.ReportFormats.uFormats;
+
            if (fFormats != VBOX_SHARED_CLIPBOARD_FMT_NONE) /* Could arrive with some older GA versions. */
            {
@@ -687 +694 @@
        {
            /* Send data in the specified format to the host. */
-           VBOXCLIPBOARDFORMAT uFormat = (uint32_t)lParam;
+           PVBGLR3CLIPBOARDEVENT pEvent = (PVBGLR3CLIPBOARDEVENT)lParam;
+           AssertPtr(pEvent);
+           Assert(pEvent->enmType == VBGLR3CLIPBOARDEVENTTYPE_READ_DATA);
+
+           const VBOXCLIPBOARDFORMAT uFormat = (uint32_t)pEvent->u.ReadData.uFmt;
+
            HANDLE hClip = NULL;
 
@@ -703 +715 @@
                        if (lp != NULL)
                        {
-                           rc = VbglR3ClipboardWriteData(pCtx->CmdCtx.uClientID, VBOX_SHARED_CLIPBOARD_FMT_BITMAP,
-                                                         lp, GlobalSize(hClip));
+                           SHAREDCLIPBOARDDATABLOCK dataBlock = { uFormat, lp, (uint32_t)GlobalSize(hClip) };
+
+                           rc = VbglR3ClipboardWriteDataEx(&pEvent->cmdCtx, &dataBlock);
+
                            GlobalUnlock(hClip);
                        }
@@ -721 +735 @@
                        if (uniString != NULL)
                        {
-                           rc = VbglR3ClipboardWriteData(pCtx->CmdCtx.uClientID, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT,
-                                                         uniString, (lstrlenW(uniString) + 1) * 2);
+                           SHAREDCLIPBOARDDATABLOCK dataBlock = { uFormat, uniString, ((uint32_t)lstrlenW(uniString) + 1) * 2 };
+
+                           rc = VbglR3ClipboardWriteDataEx(&pEvent->cmdCtx, &dataBlock);
+
                            GlobalUnlock(hClip);
                        }
@@ -743 +759 @@
                            if (lp != NULL)
                            {
-                               rc = VbglR3ClipboardWriteData(pCtx->CmdCtx.uClientID, VBOX_SHARED_CLIPBOARD_FMT_HTML,
-                                                             lp, GlobalSize(hClip));
+                               SHAREDCLIPBOARDDATABLOCK dataBlock = { uFormat, lp, (uint32_t)GlobalSize(hClip) };
+
+                               rc = VbglR3ClipboardWriteDataEx(&pEvent->cmdCtx, &dataBlock);
+
                                GlobalUnlock(hClip);
                            }
@@ -754 +772 @@
                    }
                }
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+               else if (uFormat == VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
+               {
+                   LogFunc(("cTransfersRunning=%RU32\n", SharedClipboardURICtxGetRunningTransfers(&pCtx->URI)));
+
+                   int rc = VBoxClipboardWinOpen(hwnd);
+                   if (RT_SUCCESS(rc))
+                   {
+                       PSHAREDCLIPBOARDURITRANSFER pTransfer;
+                       rc = SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR_WRITE,
+                                                             SHAREDCLIPBOARDSOURCE_LOCAL,
+                                                             &pTransfer);
+                       if (RT_SUCCESS(rc))
+                       {
+                           rc = SharedClipboardURICtxTransferAdd(&pCtx->URI, pTransfer);
+                           if (RT_SUCCESS(rc))
+                           {
+                               /* The data data in CF_HDROP format, as the files are locally present and don't need to be
+                                * presented as a IDataObject or IStream. */
+                               HANDLE hClip = hClip = GetClipboardData(CF_HDROP);
+                               if (hClip)
+                               {
+                                   HDROP hDrop = (HDROP)GlobalLock(hClip);
+                                   if (hDrop)
+                                   {
+                                       char    *papszList;
+                                       uint32_t cbList;
+                                       rc = VBoxClipboardWinDropFilesToStringList((DROPFILES *)hDrop, &papszList, &cbList);
+
+                                       GlobalUnlock(hClip);
+
+                                       if (RT_SUCCESS(rc))
+                                       {
+                                           rc = SharedClipboardURILTransferSetRoots(pTransfer,
+                                                                                    papszList, cbList + 1 /* Include termination */);
+                                           if (RT_SUCCESS(rc))
+                                           {
+                                               PVBOXCLIPBOARDURIWRITETHREADCTX pThreadCtx
+                                                   = (PVBOXCLIPBOARDURIWRITETHREADCTX)RTMemAllocZ(sizeof(VBOXCLIPBOARDURIWRITETHREADCTX));
+                                               if (pThreadCtx)
+                                               {
+                                                   pThreadCtx->pClipboardCtx = pCtx;
+                                                   pThreadCtx->pTransfer     = pTransfer;
+
+                                                   rc = SharedClipboardURITransferPrepare(pTransfer);
+                                                   if (RT_SUCCESS(rc))
+                                                   {
+                                                       rc = SharedClipboardURITransferRun(pTransfer, vboxClipboardURIWriteThread,
+                                                                                          pThreadCtx /* pvUser */);
+                                                       /* pThreadCtx now is owned by vboxClipboardURIWriteThread(). */
+                                                   }
+                                               }
+                                               else
+                                                   rc = VERR_NO_MEMORY;
+                                           }
+
+                                           if (papszList)
+                                               RTStrFree(papszList);
+                                       }
+                                   }
+                                   else
+                                   {
+                                       hClip = NULL;
+                                   }
+                               }
+                           }
+                       }
+
+                       VBoxClipboardWinClose();
+                   }
+
+                   if (RT_FAILURE(rc))
+                       LogFunc(("Failed with rc=%Rrc\n", rc));
+               }
+#endif
 
                if (hClip == NULL)
@@ -771 +864 @@
        }
 
-#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+#if 0
        /* The host wants to read URI data. */
        case VBOX_CLIPBOARD_WM_URI_START_READ:
@@ -1055 +1148 @@
         /* ignore rc */ VBoxClipboardWinCheckAndInitNewAPI(&pCtx->Win.newAPI);
 
-        rc = VbglR3ClipboardConnect(&pCtx->CmdCtx.uClientID);
+        rc = VbglR3ClipboardConnectEx(&pCtx->CmdCtx);
         if (RT_SUCCESS(rc))
         {
-            pCtx->CmdCtx.uProtocol = 0;
-
             rc = vboxClipboardCreateWindow(pCtx);
             if (RT_SUCCESS(rc))
@@ -1071 +1162 @@
             else
             {
-                VbglR3ClipboardDisconnect(pCtx->CmdCtx.uClientID);
+                VbglR3ClipboardDisconnectEx(&pCtx->CmdCtx);
             }
         }
@@ -1098 +1189 @@
     int rc;
 
+    LogFlowFunc(("Using protocol %RU32\n", pCtx->CmdCtx.uProtocolVer));
+
+    uint32_t uMsg;
+    uint32_t uFormats;
+
     /* The thread waits for incoming messages from the host. */
     for (;;)
     {
-        LogFlowFunc(("Waiting for host message ...\n"));
-
-        uint32_t u32Msg;
-        uint32_t u32Formats;
-        rc = VbglR3ClipboardGetHostMsgOld(pCtx->CmdCtx.uClientID, &u32Msg, &u32Formats);
+        PVBGLR3CLIPBOARDEVENT pEvent = NULL;
+
+        LogFlowFunc(("Waiting for host message (protocol v%RU32) ...\n", pCtx->CmdCtx.uProtocolVer));
+
+        if (pCtx->CmdCtx.uProtocolVer == 0) /* Legacy protocol */
+        {
+            rc = VbglR3ClipboardGetHostMsgOld(pCtx->CmdCtx.uClientID, &uMsg, &uFormats);
+            if (RT_FAILURE(rc))
+            {
+                if (rc == VERR_INTERRUPTED)
+                    break;
+
+                LogFunc(("Error getting host message, rc=%Rrc\n", rc));
+            }
+            else
+            {
+                PVBGLR3CLIPBOARDEVENT pEvent = (PVBGLR3CLIPBOARDEVENT)RTMemAllocZ(sizeof(VBGLR3CLIPBOARDEVENT));
+                if (!pEvent)
+                {
+                    rc = VERR_NO_MEMORY;
+                    break;
+                }
+
+                switch (uMsg)
+                {
+                    case VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_WRITE:
+                    {
+                        pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_REPORT_FORMATS;
+                        pEvent->u.ReportFormats.uFormats = uFormats;
+                        break;
+                    }
+
+                    case VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA:
+                    {
+                        pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_READ_DATA;
+                        pEvent->u.ReadData.uFmt = uFormats;
+                        break;
+                    }
+
+                    default:
+                        rc = VERR_NOT_SUPPORTED;
+                        break;
+                }
+            }
+        }
+        else /* Protocol >= v1. */
+        {
+            rc = VbglR3ClipboardEventGetNext(&pCtx->CmdCtx, &pEvent);
+        }
+
         if (RT_FAILURE(rc))
         {
-            if (rc == VERR_INTERRUPTED)
-                break;
-
-            LogFunc(("Error getting host message, rc=%Rrc\n", rc));
-
             if (*pfShutdown)
                 break;
@@ -1122 +1258 @@
         else
         {
-            LogFlowFunc(("u32Msg=%RU32, u32Formats=0x%x\n", u32Msg, u32Formats));
-            switch (u32Msg)
+            AssertPtr(pEvent);
+            LogFlowFunc(("Event uType=%RU32\n", pEvent->enmType));
+
+            switch (pEvent->enmType)
             {
-               case VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS:
-               {
-                   LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS\n"));
-
+               case VBGLR3CLIPBOARDEVENTTYPE_REPORT_FORMATS:
+               {
                    /* The host has announced available clipboard formats.
                     * Forward the information to the window, so it can later
                     * respond to WM_RENDERFORMAT message. */
-                   ::PostMessage(pWinCtx->hWnd, VBOX_CLIPBOARD_WM_REPORT_FORMATS, 0, u32Formats);
+                   ::PostMessage(pWinCtx->hWnd, VBOX_CLIPBOARD_WM_REPORT_FORMATS,
+                                 0 /* wParam */, (LPARAM)pEvent /* lParam */);
                    break;
                }
 
-               case VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA:
-               {
-                   LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA\n"));
-
+               case VBGLR3CLIPBOARDEVENTTYPE_READ_DATA:
+               {
                    /* The host needs data in the specified format. */
-                   ::PostMessage(pWinCtx->hWnd, VBOX_CLIPBOARD_WM_READ_DATA, 0, u32Formats);
+                   ::PostMessage(pWinCtx->hWnd, VBOX_CLIPBOARD_WM_READ_DATA,
+                                 0 /* wParam */, (LPARAM)pEvent /* lParam */);
                    break;
                }
-
-#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+#if 0
                case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START:
                {
-                   LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START\n"));
-
                    const UINT uMsg = u32Formats == 0 ?
                                      VBOX_CLIPBOARD_WM_URI_START_READ : VBOX_CLIPBOARD_WM_URI_START_WRITE;
@@ -1157 +1290 @@
                }
 #endif
-               case VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT:
-               {
-                   LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT\n"));
-
+               case VBGLR3CLIPBOARDEVENTTYPE_QUIT:
+               {
                    /* The host is terminating. */
                    LogRel(("Clipboard: Terminating ...\n"));
@@ -1169 +1300 @@
                default:
                {
-                   LogFlowFunc(("Unsupported message from host, message=%RU32\n", u32Msg));
-
                    /* Wait a bit before retrying. */
                    RTThreadSleep(1000);
@@ -1176 +1305 @@
                }
             }
+
+            if (RT_FAILURE(rc))
+                VbglR3ClipboardEventFree(pEvent);
         }