Changeset 81699 in vbox for trunk/src/VBox

Timestamp:

Nov 6, 2019 10:54:35 AM (5 years ago)

Author:

vboxsync

Message:

Shared Clipboard/Transfers: Update.

Location:

trunk/src/VBox

Files:

• GuestHost/SharedClipboard/clipboard-transfers.cpp (modified) (4 diffs)
• GuestHost/SharedClipboard/clipboard-x11.cpp (modified) (49 diffs)
• HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp (modified) (5 diffs)
• HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp (modified) (1 diff)

trunk/src/VBox/GuestHost/SharedClipboard/clipboard-transfers.cpp

@@ -2203 +2203 @@
     AssertPtrReturn(pTransfer, 0);
 
+    LogFlowFunc(("[Transfer %RU16] cRoots=%RU64\n", pTransfer->State.uID, pTransfer->cRoots));
     return (uint32_t)pTransfer->cRoots;
 }
@@ -2498 +2499 @@
     AssertPtrReturn(pTransfer, SHCLTRANSFERDIR_UNKNOWN);
 
+    LogFlowFunc(("[Transfer %RU16] enmDir=%RU32\n", pTransfer->State.uID, pTransfer->State.enmDir));
     return pTransfer->State.enmDir;
 }
@@ -2511 +2513 @@
     AssertPtrReturn(pTransfer, SHCLSOURCE_INVALID);
 
+    LogFlowFunc(("[Transfer %RU16] enmSource=%RU32\n", pTransfer->State.uID, pTransfer->State.enmSource));
     return pTransfer->State.enmSource;
 }
@@ -2524 +2527 @@
     AssertPtrReturn(pTransfer, SHCLTRANSFERSTATUS_NONE);
 
+    LogFlowFunc(("[Transfer %RU16] enmStatus=%RU32\n", pTransfer->State.uID, pTransfer->State.enmStatus));
     return pTransfer->State.enmStatus;
 }

trunk/src/VBox/GuestHost/SharedClipboard/clipboard-x11.cpp

@@ -83 +83 @@
     UTF8,
     BMP,
-    HTML
+    HTML,
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
+    URI_LIST,
+#endif
 };
 
@@ -126 +129 @@
     { "image/bmp", BMP, VBOX_SHCL_FMT_BITMAP },
     { "image/x-bmp", BMP, VBOX_SHCL_FMT_BITMAP },
-    { "image/x-MS-bmp", BMP, VBOX_SHCL_FMT_BITMAP }
-
+    { "image/x-MS-bmp", BMP, VBOX_SHCL_FMT_BITMAP },
     /** @todo Inkscape exports image/png but not bmp... */
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
+    { "text/uri-list", URI_LIST, VBOX_SHCL_FMT_URI_LIST },
+    { "x-special/gnome-copied-files", URI_LIST, VBOX_SHCL_FMT_URI_LIST },
+    { "x-special/nautilus-clipboard", URI_LIST, VBOX_SHCL_FMT_URI_LIST },
+    { "application/x-kde-cutselection", URI_LIST, VBOX_SHCL_FMT_URI_LIST },
+    /** @todo Anything else we need to add here? */
+    /** @todo Add Wayland / Weston support. */
+#endif
 };
 
@@ -236 +246 @@
      * table */
     CLIPX11FORMAT X11HTMLFormat;
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
+    /** The best HTML format X11 has to offer, as an index into the formats
+     * table */
+    CLIPX11FORMAT X11URIListFormat;
+#endif
     /** What formats does VBox have on offer? */
     uint32_t vboxFormats;
@@ -262 +277 @@
 };
 
-/** The number of simultaneous instances we support.  For all normal purposes
+/**
+ * The number of simultaneous instances we support.  For all normal purposes
  * we should never need more than one.  For the testcase it is convenient to
  * have a second instance that the first can interact with in order to have
- * a more controlled environment. */
+ * a more controlled environment.
+ */
 enum { CLIP_MAX_CONTEXTS = 20 };
 
-/** Array of structures for mapping Xt widgets to context pointers.  We
- *  need this because the widget clipboard callbacks do not pass user data. */
+/**
+ * Array of structures for mapping Xt widgets to context pointers.  We
+ * need this because the widget clipboard callbacks do not pass user data.
+ */
 static struct
 {
@@ -278 +297 @@
 } g_contexts[CLIP_MAX_CONTEXTS];
 
-/** Registers a new X11 clipboard context. */
+/**
+ * Registers a new X11 clipboard context.
+ *
+ * @param   pCtx                The clipboard backend context to use.
+ */
 static int clipRegisterContext(CLIPBACKEND *pCtx)
 {
@@ -302 +325 @@
 }
 
-/** Unregister an X11 clipboard context. */
+/**
+ * Unregister an X11 clipboard context.
+ *
+ * @param   pCtx                The clipboard backend context to use.
+ */
 static void clipUnregisterContext(CLIPBACKEND *pCtx)
 {
@@ -340 +367 @@
 }
 
-/** Converts an atom name string to an X11 atom, looking it up in a cache
- *  before asking the server. */
+/**
+ * Converts an atom name string to an X11 atom, looking it up in a cache
+ * before asking the server.
+ */
 static Atom clipGetAtom(CLIPBACKEND *pCtx, const char *pszName)
 {
@@ -358 +387 @@
 #define WAKE_UP_STRING_LEN  ( sizeof(WAKE_UP_STRING) - 1 )
 
-/** Schedule a function call to run on the Xt event thread by passing it to
+/**
+ * Schedules a function call to run on the Xt event thread by passing it to
  * the application context as a 0ms timeout and waking up the event loop by
- * writing to the wakeup pipe which it monitors. */
+ * writing to the wakeup pipe which it monitors.
+ */
 static int clipQueueToEventThread(CLIPBACKEND *pCtx,
                                   void (*proc)(void *, void *),
@@ -385 +416 @@
 /**
  * Reports the formats currently supported by the X11 clipboard to VBox.
+ *
+ * @param   pCtx                The clipboard backend context to use.
  */
 static void clipReportFormatsToVBox(CLIPBACKEND *pCtx)
 {
-    uint32_t u32VBoxFormats = clipVBoxFormatForX11Format(pCtx->X11TextFormat);
-    u32VBoxFormats |= clipVBoxFormatForX11Format(pCtx->X11BitmapFormat);
-    u32VBoxFormats |= clipVBoxFormatForX11Format(pCtx->X11HTMLFormat);
-    LogFlowFunc(("clipReportFormatsToVBox format: %d\n", u32VBoxFormats));
-    LogFlowFunc(("clipReportFormatsToVBox txt: %d, bitm: %d, html:%d, u32VBoxFormats: %d\n",
-                    pCtx->X11TextFormat, pCtx->X11BitmapFormat, pCtx->X11HTMLFormat,
-                    u32VBoxFormats ));
-    ClipReportX11FormatsCallback(pCtx->pFrontend, u32VBoxFormats);
+    uint32_t fFormats  = clipVBoxFormatForX11Format(pCtx->X11TextFormat);
+             fFormats |= clipVBoxFormatForX11Format(pCtx->X11BitmapFormat);
+             fFormats |= clipVBoxFormatForX11Format(pCtx->X11HTMLFormat);
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
+             fFormats |= clipVBoxFormatForX11Format(pCtx->X11URIListFormat);
+#endif
+
+    LogFlowFunc(("fFormats=0x%x\n", fFormats));
+    LogFlowFunc(("txt: %u, bmp: %u, html: %u\n",
+                 pCtx->X11TextFormat, pCtx->X11BitmapFormat, pCtx->X11HTMLFormat));
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
+    LogFlowFunc(("uri list: %u\n", pCtx->X11URIListFormat));
+#endif
+
+    ClipReportX11FormatsCallback(pCtx->pFrontend, fFormats);
 }
 
 /**
  * Forgets which formats were previously in the X11 clipboard.  Called when we
- * grab the clipboard. */
+ * grab the clipboard.
+ *
+ * @param   pCtx                The clipboard backend context to use.
+ */
 static void clipResetX11Formats(CLIPBACKEND *pCtx)
 {
-    pCtx->X11TextFormat = INVALID;
-    pCtx->X11BitmapFormat = INVALID;
-    pCtx->X11HTMLFormat = INVALID;
+    LogFlowFuncEnter();
+
+    pCtx->X11TextFormat    = INVALID;
+    pCtx->X11BitmapFormat  = INVALID;
+    pCtx->X11HTMLFormat    = INVALID;
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
+    pCtx->X11URIListFormat = INVALID;
+#endif
 }
 
@@ -421 +469 @@
  *
  * @return Supported X clipboard format.
- * @param  pCtx                 The clipboard backend context structure.
+ * @param  pCtx                 The clipboard backend context to use.
  * @param  pTargets             The list of targets.
  * @param  cTargets             The size of the list in @a pTargets.
@@ -439 +487 @@
         if (format != NIL_CLIPX11FORMAT)
         {
-            if (   (clipVBoxFormatForX11Format(format)
-                            == VBOX_SHCL_FMT_UNICODETEXT)
-                    && enmBestTextTarget < clipRealFormatForX11Format(format))
+            if (   (clipVBoxFormatForX11Format(format) == VBOX_SHCL_FMT_UNICODETEXT)
+                && enmBestTextTarget < clipRealFormatForX11Format(format))
             {
                 enmBestTextTarget = clipRealFormatForX11Format(format);
@@ -477 +524 @@
  *
  * @return Supported X clipboard format.
- * @param  pCtx                 The clipboard backend context structure.
+ * @param  pCtx                 The clipboard backend context to use.
  * @param  pTargets             The list of targets.
  * @param  cTargets             The size of the list in @a pTargets.
@@ -495 +542 @@
         if (format != NIL_CLIPX11FORMAT)
         {
-            if (   (clipVBoxFormatForX11Format(format)
-                            == VBOX_SHCL_FMT_BITMAP)
-                    && enmBestBitmapTarget < clipRealFormatForX11Format(format))
+            if (   (clipVBoxFormatForX11Format(format) == VBOX_SHCL_FMT_BITMAP)
+                && enmBestBitmapTarget < clipRealFormatForX11Format(format))
             {
                 enmBestBitmapTarget = clipRealFormatForX11Format(format);
@@ -512 +558 @@
  *
  * @return Supported X clipboard format.
- * @param  pCtx                 The clipboard backend context structure.
+ * @param   pCtx                The clipboard backend context to use.
  * @param  pTargets             The list of targets.
  * @param  cTargets             The size of the list in @a pTargets.
@@ -541 +587 @@
 }
 
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
+/**
+ * Goes through an array of X11 clipboard targets to see if they contain an URI list
+ * format we can support, and if so choose the ones we prefer.
+ *
+ * @return Supported X clipboard format.
+ * @param  pCtx                 The clipboard backend context to use.
+ * @param  pTargets             The list of targets.
+ * @param  cTargets             The size of the list in @a pTargets.
+ */
+static CLIPX11FORMAT clipGetURIListFormatFromTargets(CLIPBACKEND *pCtx,
+                                                     CLIPX11FORMAT *pTargets,
+                                                     size_t cTargets)
+{
+    AssertPtrReturn(pCtx, NIL_CLIPX11FORMAT);
+    AssertReturn(VALID_PTR(pTargets) || cTargets == 0, NIL_CLIPX11FORMAT);
+
+    CLIPX11FORMAT bestURIListFormat = NIL_CLIPX11FORMAT;
+    CLIPFORMAT enmBestURIListTarget = INVALID;
+    for (unsigned i = 0; i < cTargets; ++i)
+    {
+        CLIPX11FORMAT format = pTargets[i];
+        if (format != NIL_CLIPX11FORMAT)
+        {
+            if (   (clipVBoxFormatForX11Format(format) == VBOX_SHCL_FMT_URI_LIST)
+                && enmBestURIListTarget < clipRealFormatForX11Format(format))
+            {
+                enmBestURIListTarget = clipRealFormatForX11Format(format);
+                bestURIListFormat = format;
+            }
+        }
+    }
+    return bestURIListFormat;
+}
+#endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
 
 /**
@@ -547 +628 @@
  * better than plain text).
  *
- * @param  pCtx                 The clipboard backend context structure.
+ * @param  pCtx                 The clipboard backend context to use.
  * @param  pTargets             The list of targets.
  * @param  cTargets             The size of the list in @a pTargets.
@@ -556 +637 @@
     AssertPtrReturnVoid(pCtx);
     AssertPtrReturnVoid(pTargets);
-    CLIPX11FORMAT bestTextFormat;
-    CLIPX11FORMAT bestBitmapFormat;
-    CLIPX11FORMAT bestHtmlFormat;
-    bestTextFormat = clipGetTextFormatFromTargets(pCtx, pTargets, cTargets);
+
+    CLIPX11FORMAT bestTextFormat = clipGetTextFormatFromTargets(pCtx, pTargets, cTargets);
     if (pCtx->X11TextFormat != bestTextFormat)
-    {
         pCtx->X11TextFormat = bestTextFormat;
-    }
-    pCtx->X11BitmapFormat = INVALID;  /* not yet supported */
-    bestBitmapFormat = clipGetBitmapFormatFromTargets(pCtx, pTargets, cTargets);
+
+    pCtx->X11BitmapFormat = INVALID; /* not yet supported */
+    CLIPX11FORMAT bestBitmapFormat = clipGetBitmapFormatFromTargets(pCtx, pTargets, cTargets);
     if (pCtx->X11BitmapFormat != bestBitmapFormat)
-    {
         pCtx->X11BitmapFormat = bestBitmapFormat;
-    }
-    bestHtmlFormat = clipGetHtmlFormatFromTargets(pCtx, pTargets, cTargets);
-    if(pCtx->X11HTMLFormat != bestHtmlFormat)
-    {
+
+    CLIPX11FORMAT bestHtmlFormat = clipGetHtmlFormatFromTargets(pCtx, pTargets, cTargets);
+    if (pCtx->X11HTMLFormat != bestHtmlFormat)
         pCtx->X11HTMLFormat = bestHtmlFormat;
-    }
+
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
+    CLIPX11FORMAT bestURIListFormat = clipGetURIListFormatFromTargets(pCtx, pTargets, cTargets);
+    if (pCtx->X11URIListFormat != bestURIListFormat)
+        pCtx->X11URIListFormat = bestURIListFormat;
+#endif
 }
 
@@ -583 +664 @@
  * based on an array of X11 atoms.
  *
- * @param  pCtx                 The context to be updated.
+ * @param   pCtx                The clipboard backend context to use.
  * @param  pTargets             The array of atoms describing the targets supported.
  * @param  cTargets             The size of the array @a pTargets.
@@ -614 +695 @@
  * "targets" information obtained from the X11 clipboard.
  *
- * @note  Callback for XtGetSelectionValue
+ * @note  Callback for XtGetSelectionValue.
  * @note  This function is treated as API glue, and as such is not part of any
  *        unit test.  So keep it simple, be paranoid and log everything.
@@ -626 +707 @@
 
     CLIPBACKEND *pCtx = reinterpret_cast<CLIPBACKEND *>(pClient);
+
     Atom *pAtoms = (Atom *)pValue;
     unsigned i, j;
@@ -639 +721 @@
        pFormats = (CLIPX11FORMAT *)RTMemAllocZ(*pcLen * sizeof(CLIPX11FORMAT));
     }
+
 #if defined(DEBUG) && !defined(TESTCASE)
     if (pValue)
@@ -653 +736 @@
     }
 #endif
+
     if (pFormats)
     {
@@ -685 +769 @@
 /**
  * Callback to notify us when the contents of the X11 clipboard change.
+ *
+ * @param   pCtx                The clipboard backend context to use.
  */
 static void clipQueryX11CBFormats(CLIPBACKEND *pCtx)
@@ -729 +815 @@
  * Waits until an event arrives and handle it if it is an XFIXES selection
  * event, which Xt doesn't know about.
+ *
+ * @param   pCtx                The clipboard backend context to use.
  */
 void clipPeekEventAndDoXFixesHandling(CLIPBACKEND *pCtx)
@@ -754 +842 @@
 /**
  * The main loop of our clipboard reader.
+ *
  * @note  X11 backend code.
  */
@@ -775 +864 @@
 #endif
 
-/** X11 specific uninitialisation for the shared clipboard.
+/**
+ * X11 specific uninitialisation for the shared clipboard.
+ *
  * @note  X11 backend code.
+ *
+ * @param   pCtx                The clipboard backend context to use.
  */
 static void clipUninit(CLIPBACKEND *pCtx)
@@ -817 +910 @@
 
 #ifndef TESTCASE
-/** Setup the XFixes library and load the XFixesSelectSelectionInput symbol */
+/**
+ * Sets up the XFixes library and load the XFixesSelectSelectionInput symbol.
+ */
 static int clipLoadXFixes(Display *pDisplay, CLIPBACKEND *pCtx)
 {
@@ -841 +936 @@
             {
                 if (pCtx->fixesEventBase >= 0)
+                {
                     rc = VINF_SUCCESS;
+                }
                 else
                 {
-                    LogRel(("clipLoadXFixes: fixesEventBase is less than zero: %d\n", pCtx->fixesEventBase));
+                    LogRel(("Shared Clipboard: fixesEventBase is less than zero: %d\n", pCtx->fixesEventBase));
                     rc = VERR_NOT_SUPPORTED;
                 }
@@ -850 +947 @@
             else
             {
-                LogRel(("clipLoadXFixes: XQueryExtension failed\n"));
+                LogRel(("Shared Clipboard: XQueryExtension failed\n"));
                 rc = VERR_NOT_SUPPORTED;
             }
@@ -856 +953 @@
         else
         {
-            LogRel(("clipLoadXFixes: Symbol XFixesSelectSelectionInput not found!\n"));
+            LogRel(("Shared Clipboard: Symbol XFixesSelectSelectionInput not found!\n"));
             rc = VERR_NOT_SUPPORTED;
         }
@@ -862 +959 @@
     else
     {
-        LogRel(("clipLoadXFixes: libxFixes.so.* not found!\n"));
+        LogRel(("Shared Clipboard: libxFixes.so.* not found!\n"));
         rc = VERR_NOT_SUPPORTED;
     }
@@ -869 +966 @@
 #endif
 
-/** This is the callback which is scheduled when data is available on the
- * wakeup pipe.  It simply reads all data from the pipe. */
+/**
+ * This is the callback which is scheduled when data is available on the
+ * wakeup pipe.  It simply reads all data from the pipe.
+ */
 static void clipDrainWakeupPipe(XtPointer pUserData, int *, XtInputId *)
 {
@@ -881 +980 @@
 }
 
-/** X11 specific initialisation for the shared clipboard.
+/**
+ * X11 specific initialisation for the shared clipboard.
+ *
  * @note  X11 backend code.
+ *
+ * @returns VBox status code.
+ * @param   pCtx                The clipboard backend context to use.
  */
 static int clipInit(CLIPBACKEND *pCtx)
@@ -892 +996 @@
     Display *pDisplay;
 
-    /* Make sure we are thread safe */
+    /* Make sure we are thread safe. */
     XtToolkitThreadInitialize();
-    /* Set up the Clipboard application context and main window.  We call all
+
+    /*
+     * Set up the Clipboard application context and main window.  We call all
      * these functions directly instead of calling XtOpenApplication() so
-     * that we can fail gracefully if we can't get an X11 display. */
+     * that we can fail gracefully if we can't get an X11 display.
+     */
     XtToolkitInitialize();
     pCtx->appContext = XtCreateApplicationContext();
@@ -932 +1039 @@
         XtRealizeWidget(pCtx->widget);
 #ifndef TESTCASE
-        /* Enable clipboard update notification */
+        /* Enable clipboard update notification. */
         pCtx->fixesSelectInput(pDisplay, XtWindow(pCtx->widget),
                                clipGetAtom(pCtx, "CLIPBOARD"),
@@ -938 +1045 @@
 #endif
     }
-    /* Create the pipes */
+
+    /*
+     * Create the pipes.
+     */
     int pipes[2];
     if (!pipe(pipes))
@@ -979 +1089 @@
          * This is important for VBoxHeadless.
          */
-        LogRel(("Shared Clipboard: X11 DISPLAY variable not set -- disabling shared clipboard\n"));
+        LogRel(("Shared Clipboard: X11 DISPLAY variable not set -- disabling clipboard sharing\n"));
         pCtx->fHaveX11 = false;
         return pCtx;
@@ -987 +1097 @@
 
     LogRel(("Shared Clipboard: Initializing X11 clipboard backend\n"));
+
     if (pCtx)
         pCtx->pFrontend = pFrontend;
@@ -995 +1106 @@
  * Destructs the shared clipboard X11 backend.
  *
- * @note  X11 backend code
+ * @note  X11 backend code.
+ *
+ * @param   pCtx                The clipboard backend context to use.
  */
 void ClipDestructX11(CLIPBACKEND *pCtx)
@@ -1008 +1121 @@
 
 /**
- * Announce to the X11 backend that we are ready to start.
- * @param  grab  whether we should try to grab the shared clipboard at once
- */
-int ClipStartX11(CLIPBACKEND *pCtx, bool grab)
+ * Announces to the X11 backend that we are ready to start.
+ *
+ * @returns VBox status code.
+ * @param   pCtx                The clipboard backend context to use.
+ * @param   fGrab               Whether we should try to grab the shared clipboard at once.
+ */
+int ClipStartX11(CLIPBACKEND *pCtx, bool fGrab)
 {
     int rc = VINF_SUCCESS;
@@ -1025 +1141 @@
     {
         clipResetX11Formats(pCtx);
-        pCtx->fGrabClipboardOnStart = grab;
+        pCtx->fGrabClipboardOnStart = fGrab;
     }
 #ifndef TESTCASE
@@ -1043 +1159 @@
 
 /**
- * Shut down the shared clipboard X11 backend.
- * @note  X11 backend code
+ * Shuts down the shared clipboard X11 backend.
+ *
+ * @note  X11 backend code.
  * @note  Any requests from this object to get clipboard data from VBox
  *        *must* have completed or aborted before we are called, as
  *        otherwise the X11 event loop will still be waiting for the request
  *        to return and will not be able to terminate.
+ *
+ * @returns VBox status code.
+ * @param   pCtx                The clipboard backend context to use.
  */
 int ClipStopX11(CLIPBACKEND *pCtx)
@@ -1093 +1213 @@
  *
  * @returns VBox status code.
+ * @param  pCtx                 The clipboard backend context to use.
  * @param  atomTypeReturn       The type of the data we are returning.
  * @param  pValReturn           A pointer to the data we are returning. This
@@ -1142 +1263 @@
  */
 static int clipReadVBoxShCl(CLIPBACKEND *pCtx, uint32_t u32Format,
-                                 void **ppv, uint32_t *pcb)
+                            void **ppv, uint32_t *pcb)
 {
     int rc = VINF_SUCCESS;
@@ -1336 +1457 @@
  * Does this atom correspond to one of the two selection types we support?
  *
- * @param  widget               A valid Xt widget.
+ * @param  pCtx                 The clipboard backend context to use.
  * @param  selType              The atom in question.
  */
@@ -1380 +1501 @@
         void *pv = NULL;
         uint32_t cb = 0;
-        rc = clipReadVBoxShCl(pCtx,
-                                   VBOX_SHCL_FMT_UNICODETEXT,
-                                   &pv, &cb);
+        rc = clipReadVBoxShCl(pCtx, VBOX_SHCL_FMT_UNICODETEXT, &pv, &cb);
         if (RT_SUCCESS(rc) && (cb == 0))
             rc = VERR_NO_DATA;
@@ -1845 +1964 @@
     /** The HTML format we requested from X11 if we requested HTML */
     CLIPX11FORMAT mHtmlFormat;
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
+    /** The URI list format we requested from X11 if we requested URI lists. */
+    CLIPX11FORMAT mURIListFormat;
+#endif
     /** The clipboard context this request is associated with */
     CLIPBACKEND *mCtx;
@@ -2032 +2155 @@
 #endif
 
-static void getSelectionValue(CLIPBACKEND *pCtx, CLIPX11FORMAT format,
-                              CLIPREADX11CBREQ *pReq)
+static int getSelectionValue(CLIPBACKEND *pCtx, CLIPX11FORMAT format,
+                             CLIPREADX11CBREQ *pReq)
 {
 #ifndef TESTCASE
@@ -2044 +2167 @@
     testRequestData(pCtx, format, (void *)pReq);
 #endif
-}
-
-/** Worker function for ClipRequestDataFromX11 which runs on the event
- * thread. */
+
+    return VINF_SUCCESS; /** @todo Return real rc. */
+}
+
+/**
+ * Worker function for ClipRequestDataFromX11 which runs on the event thread.
+ */
 static void vboxClipboardReadX11Worker(void *pUserData,
                                        void * /* interval */)
 {
+    AssertPtrReturnVoid(pUserData);
+
     CLIPREADX11CBREQ *pReq = (CLIPREADX11CBREQ *)pUserData;
-    CLIPBACKEND *pCtx = pReq->mCtx;
+    CLIPBACKEND      *pCtx = pReq->mCtx;
 
     LogFlowFunc(("pReq->mFormat = %02X\n", pReq->mFormat));
 
-    int rc = VINF_SUCCESS;
+    int rc = VERR_NO_DATA; /* VBox thinks we have data and we don't. */
+
 #ifndef VBOX_AFTER_5_2
     bool fBusy = pCtx->fBusy;
     pCtx->fBusy = true;
     if (fBusy)
+    {
         /* If the clipboard is busy just fend off the request. */
         rc = VERR_TRY_AGAIN;
+    }
     else
 #endif
     if (pReq->mFormat == VBOX_SHCL_FMT_UNICODETEXT)
     {
-        /*
-         * VBox wants to read data in the given format.
-         */
         pReq->mTextFormat = pCtx->X11TextFormat;
-        if (pReq->mTextFormat == INVALID)
-            /* VBox thinks we have data and we don't */
-            rc = VERR_NO_DATA;
-        else
-            /* Send out a request for the data to the current clipboard
-             * owner */
-            getSelectionValue(pCtx, pCtx->X11TextFormat, pReq);
+        if (pReq->mTextFormat != INVALID)
+        {
+            /* Send out a request for the data to the current clipboard owner. */
+            rc = getSelectionValue(pCtx, pCtx->X11TextFormat, pReq);
+        }
     }
     else if (pReq->mFormat == VBOX_SHCL_FMT_BITMAP)
     {
         pReq->mBitmapFormat = pCtx->X11BitmapFormat;
-        if (pReq->mBitmapFormat == INVALID)
-            /* VBox thinks we have data and we don't */
-            rc = VERR_NO_DATA;
-        else
-            /* Send out a request for the data to the current clipboard
-             * owner */
-            getSelectionValue(pCtx, pCtx->X11BitmapFormat, pReq);
+        if (pReq->mBitmapFormat != INVALID)
+        {
+            /* Send out a request for the data to the current clipboard owner. */
+            rc = getSelectionValue(pCtx, pCtx->X11BitmapFormat, pReq);
+        }
     }
     else if (pReq->mFormat == VBOX_SHCL_FMT_HTML)
     {
-        /* Send out a request for the data to the current clipboard
-             * owner */
         pReq->mHtmlFormat = pCtx->X11HTMLFormat;
-        if(pReq->mHtmlFormat == INVALID)
-                    /* VBox thinks we have data and we don't */
-            rc = VERR_NO_DATA;
-        else
-            /* Send out a request for the data to the current clipboard
-             * owner */
-            getSelectionValue(pCtx, pCtx->X11HTMLFormat, pReq);
-    }
+        if (pReq->mHtmlFormat != INVALID)
+        {
+            /* Send out a request for the data to the current clipboard owner. */
+            rc = getSelectionValue(pCtx, pCtx->X11HTMLFormat, pReq);
+        }
+    }
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
+    else if (pReq->mFormat == VBOX_SHCL_FMT_URI_LIST)
+    {
+        pReq->mURIListFormat = pCtx->X11URIListFormat;
+        if (pReq->mURIListFormat != INVALID)
+        {
+            /* Send out a request for the data to the current clipboard owner. */
+            rc = getSelectionValue(pCtx, pCtx->X11HTMLFormat, pReq);
+        }
+    }
+#endif
     else
     {

trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp

@@ -74 +74 @@
     formatData.uFormats = u32Formats;
 
-    int rc2 = shClSvcFormatsReport(pCtx->pClient, &formatData);
-    AssertRC(rc2);
+    int rc = shClSvcFormatsReport(pCtx->pClient, &formatData);
+    RT_NOREF(rc);
+
+    LogFlowFuncLeaveRC(rc);
 }
 
@@ -182 +184 @@
     RT_NOREF(pCmdCtx);
 
-#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
-    if (pFormats->uFormats & VBOX_SHCL_FMT_URI_LIST) /* No transfer support yet. */
-        return VINF_SUCCESS;
-#endif
-
-    ClipAnnounceFormatToX11(pClient->State.pCtx->pBackend, pFormats->uFormats);
-
-    return VINF_SUCCESS;
+    int rc = ClipAnnounceFormatToX11(pClient->State.pCtx->pBackend, pFormats->uFormats);
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
 }
 
@@ -356 +354 @@
 {
     RT_NOREF(pClient, pTransfer);
-    return VINF_SUCCESS;
+
+    int rc = VINF_SUCCESS;
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
 }
 
@@ -362 +364 @@
 {
     RT_NOREF(pClient, pTransfer);
-    return VINF_SUCCESS;
+
+    int rc = VINF_SUCCESS;
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
 }
 
@@ -368 +374 @@
 {
     RT_NOREF(pClient, pTransfer);
-    return VINF_SUCCESS;
+
+    int rc = VINF_SUCCESS;
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
 }
 #endif

trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp

@@ -1732 +1732 @@
             }
             else
+            {
+                LogRel2(("Shared Clipboard: File transfers are disabled for this VM\n"));
                 rc = VERR_ACCESS_DENIED;
+            }
 #else
-            rc = VERR_NOT_IMPLEMENTED;
+            rc = VERR_NOT_SUPPORTED;
 #endif
             break;