Changeset 81747 in vbox

Timestamp:

Nov 8, 2019 8:31:57 AM (5 years ago)

Author:

vboxsync

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

134534

Message:

Shared Clipboard/Transfers: Build fix, forgot some files.

Location:

trunk

Files:

• include/VBox/GuestHost/SharedClipboard.h (modified) (1 diff)
• include/VBox/HostServices/VBoxClipboardSvc.h (modified) (1 diff)
• src/VBox/GuestHost/SharedClipboard/clipboard-x11.cpp (modified) (90 diffs)

trunk/include/VBox/GuestHost/SharedClipboard.h

@@ -119 +119 @@
 /** Defines a pointer to a session ID. */
 typedef SHCLSESSIONID *PSHCLSESSIONID;
+/** Defines a NIL session ID. */
+#define NIL_SHCLSESSIONID                        UINT16_MAX
+
+/** Defines a transfer ID. */
+typedef uint16_t     SHCLTRANSFERID;
+/** Defines a pointer to a transfer ID. */
+typedef SHCLTRANSFERID *PSHCLTRANSFERID;
+/** Defines a NIL transfer ID. */
+#define NIL_SHCLTRANSFERID                       UINT16_MAX
+
 /** Defines an event ID. */
 typedef uint32_t     SHCLEVENTID;
 /** Defines a pointer to a event source ID. */
 typedef SHCLEVENTID *PSHCLEVENTID;
+/** Defines a NIL event ID. */
+#define NIL_SHCLEVENTID                          UINT32_MAX
 
 /** Maximum number of concurrent Shared Clipboard client sessions a VM can have. */
-#define VBOX_SHCL_MAX_SESSIONS                   UINT16_MAX
+#define VBOX_SHCL_MAX_SESSIONS                   UINT16_MAX - 1
 /** Maximum number of concurrent Shared Clipboard transfers a single
  *  client can have. */
-#define VBOX_SHCL_MAX_TRANSFERS                  UINT16_MAX
+#define VBOX_SHCL_MAX_TRANSFERS                  UINT16_MAX - 1
 /** Maximum number of events a single Shared Clipboard transfer can have. */
-#define VBOX_SHCL_MAX_EVENTS                     UINT32_MAX
+#define VBOX_SHCL_MAX_EVENTS                     UINT32_MAX - 1
 
 /**

trunk/include/VBox/HostServices/VBoxClipboardSvc.h

@@ -1168 +1168 @@
 } SHCLERRORDATA, *PSHCLERRORDATA;
 
+/** Opaque client structure for API access. */
+struct _SHCLCLIENT;
+typedef struct _SHCLCLIENT SHCLCLIENT, *PSHCLCLIENT;
+
+/** Opaque client structure for API access. */
+struct _SHCLCLIENTCMDCTX;
+typedef struct _SHCLCLIENTCMDCTX SHCLCLIENTCMDCTX, *PSHCLCLIENTCMDCTX;
+
+/** @name Public service functions, accessible by the backends.
+ *        Locking is between the (host) service thread and the platform-dependent (window) thread.
+ * @{
+ */
+int ShClSvcDataReadRequest(PSHCLCLIENT pClient, PSHCLDATAREQ pDataReq, PSHCLEVENTID puEvent);
+int ShClSvcDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData);
+int ShClSvcFormatsReport(PSHCLCLIENT pClient, PSHCLFORMATDATA pFormats);
+/** @} */
+
 uint32_t ShClSvcGetMode(void);
 bool ShClSvcGetHeadless(void);

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

@@ -53 +53 @@
 #include <iprt/utf16.h>
 
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
+# include <iprt/cpp/list.h>
+# include <iprt/cpp/ministring.h>
+#endif
+
 #include <VBox/log.h>
 #include <VBox/version.h>
@@ -74 +79 @@
     INVALID = 0,
     TARGETS,
-    TEXT,  /* Treat this as Utf8, but it may really be ascii */
+    TEXT,  /* Treat this as UTF-8, but it may really be ascii */
     UTF8,
     BMP,
@@ -364 +369 @@
 
 #ifdef TESTCASE
-static void testQueueToEventThread(void (*proc)(void *, void *),
-                                   void *client_data);
+static void tstClipQueueToEventThread(void (*proc)(void *, void *),
+                                      void *client_data);
 #endif
 
@@ -393 +398 @@
 #else
     RT_NOREF(pCtx);
-    testQueueToEventThread(proc, client_data);
+    tstClipQueueToEventThread(proc, client_data);
 #endif
 
@@ -402 +407 @@
 /**
  * Reports the formats currently supported by the X11 clipboard to VBox.
+ *
+ * @note    Runs in Xt event thread.
  *
  * @param   pCtx                The clipboard backend context to use.
@@ -442 +449 @@
 }
 
-/** Tells VBox that X11 currently has nothing in its clipboard. */
+/**
+ * Tells VBox that X11 currently has nothing in its clipboard.
+ *
+ * @param  pCtx                 The clipboard backend context to use.
+ */
 static void clipReportEmptyX11CB(CLIPBACKEND *pCtx)
 {
@@ -452 +463 @@
  * Go through an array of X11 clipboard targets to see if they contain a text
  * format we can support, and if so choose the ones we prefer (e.g. we like
- * Utf8 better than plain text).
+ * UTF-8 better than plain text).
  *
  * @return Supported X clipboard format.
@@ -485 +496 @@
 
 #ifdef TESTCASE
-static bool clipTestTextFormatConversion(CLIPBACKEND *pCtx)
+static bool tstClipTextFormatConversion(CLIPBACKEND *pCtx)
 {
     bool fSuccess = true;
@@ -644 +655 @@
 }
 
-static void clipQueryX11CBFormats(CLIPBACKEND *pCtx);
+static void clipQueryX11FormatsCallback(CLIPBACKEND *pCtx);
 
 /**
@@ -673 +684 @@
  * "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.
  */
-static void clipConvertX11Targets(Widget widget, XtPointer pClient,
-                                  Atom * /* selection */, Atom *atomType,
-                                  XtPointer pValue, long unsigned int *pcLen,
-                                  int *piFormat)
+static DECLCALLBACK(void) clipConvertX11TargetsCallback(Widget widget, XtPointer pClient,
+                                                        Atom * /* selection */, Atom *atomType,
+                                                        XtPointer pValue, long unsigned int *pcLen,
+                                                        int *piFormat)
 {
     RT_NOREF(piFormat);
@@ -742 +753 @@
 
 #ifdef TESTCASE
-    void testRequestTargets(CLIPBACKEND *pCtx);
+    void tstRequestTargets(CLIPBACKEND *pCtx);
 #endif
 
@@ -750 +761 @@
  * @param   pCtx                The clipboard backend context to use.
  */
-static void clipQueryX11CBFormats(CLIPBACKEND *pCtx)
+static DECLCALLBACK(void) clipQueryX11FormatsCallback(CLIPBACKEND *pCtx)
 {
     LogFlowFuncEnter();
@@ -758 +769 @@
                         clipGetAtom(pCtx, "CLIPBOARD"),
                         clipGetAtom(pCtx, "TARGETS"),
-                        clipConvertX11Targets, pCtx,
+                        clipConvertX11TargetsCallback, pCtx,
                         CurrentTime);
 #else
-    testRequestTargets(pCtx);
+    tstRequestTargets(pCtx);
 #endif
 }
@@ -802 +813 @@
             if (   (event.fixes.subtype == 0  /* XFixesSetSelectionOwnerNotify */)
                 && (event.fixes.owner != 0))
-                clipQueryX11CBFormats(pCtx);
+                clipQueryX11FormatsCallback(pCtx);
             else
                 clipReportEmptyX11CB(pCtx);
@@ -810 +821 @@
 
 /**
- * The main loop of our clipboard reader.
+ * The main loop of our X11 event thread.
  *
  * @note  X11 backend code.
@@ -817 +828 @@
 {
     RT_NOREF(hThreadSelf);
-    LogRel(("Shared Clipboard: Starting event thread\n"));
+
+    LogRel(("Shared Clipboard: Starting X11 event thread\n"));
 
     CLIPBACKEND *pCtx = (CLIPBACKEND *)pvUser;
 
     if (pCtx->fGrabClipboardOnStart)
-        clipQueryX11CBFormats(pCtx);
+        clipQueryX11FormatsCallback(pCtx);
+
     while (XtAppGetExitFlag(pCtx->appContext) == FALSE)
     {
@@ -828 +841 @@
         XtAppProcessEvent(pCtx->appContext, XtIMAll);
     }
-    LogRel(("Shared Clipboard: Event thread terminated successfully\n"));
+
+    LogRel(("Shared Clipboard: X11 event thread terminated successfully\n"));
     return VINF_SUCCESS;
 }
-#endif
+#endif /* !TESTCASE */
 
 /**
@@ -933 +947 @@
     return rc;
 }
-#endif
+#endif /* !TESTCASE */
 
 /**
@@ -1116 +1130 @@
     {
         rc = RTThreadCreate(&pCtx->thread, clipEventThread, pCtx, 0,
-                            RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "SHCLIP");
+                            RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "SHCLX11");
         if (RT_FAILURE(rc))
         {
-            LogRel(("Shared Clipboard: Failed to start the shared clipboard thread\n"));
+            LogRel(("Shared Clipboard: Failed to start the X11 event thread with %Rrc\n", rc));
             clipUninit(pCtx);
         }
@@ -1153 +1167 @@
     /* Write to the "stop" pipe */
     clipQueueToEventThread(pCtx, clipStopEventThreadWorker, (XtPointer) pCtx);
+
 #ifndef TESTCASE
     do
@@ -1282 +1297 @@
 
 /**
- * Converts text from Windows format (UCS-2 with CRLF line endings) to standard Utf-8.
+ * Converts text from Windows format (UCS-2 with CRLF line endings) to standard UTF-8.
  *
  * @returns VBox status code.
@@ -1314 +1329 @@
         rc = ShClUtf16WinToLin(pwszSrc, cwSrc, pwszTmp, cwTmp);
     if (RT_SUCCESS(rc))
-        /* Convert the Utf16 string to Utf8. */
+    {
+        /* Convert the UTF-16 string to Utf8. */
         rc = RTUtf16ToUtf8Ex(pwszTmp + 1, cwTmp - 1, &pszBuf, cbBuf,
                              &cbDest);
+    }
     RTMemFree(reinterpret_cast<void *>(pwszTmp));
     if (pcbActual)
@@ -1329 +1346 @@
 
 /**
- * Satisfies a request from X11 to convert the clipboard text to Utf-8.  We
+ * Satisfies a request from X11 to convert the clipboard text to UTF-8.  We
  * return null-terminated text, but can cope with non-null-terminated input.
  *
@@ -1362 +1379 @@
     if (RT_SUCCESS(rc))
     {
-        char *pszDest = (char *)XtMalloc(cbDest);
+        char  *pszDest  = (char *)XtMalloc(cbDest);
         size_t cbActual = 0;
         if (pszDest)
-            rc = clipWinTxtToUtf8(pwszSrc, cbSrc, pszDest, cbDest,
-                                  &cbActual);
+        {
+            rc = clipWinTxtToUtf8(pwszSrc, cbSrc, pszDest, cbDest, &cbActual);
+        }
+        else
+            rc = VERR_NO_MEMORY;
+
         if (RT_SUCCESS(rc))
         {
@@ -1379 +1400 @@
 
 /**
- * Satisfies a request from X11 to convert the clipboard HTML fragment to Utf-8.  We
+ * Satisfies a request from X11 to convert the clipboard HTML fragment to UTF-8.  We
  * return null-terminated text, but can cope with non-null-terminated input.
  *
@@ -1406 +1427 @@
 
     /* This may slightly overestimate the space needed. */
-    LogFlowFunc(("source: %s", pszSrc));
+    LogFlowFunc(("Source: %s", pszSrc));
 
     char *pszDest = (char *)XtMalloc(cbSrc);
-    if(pszDest == NULL)
+    if (pszDest == NULL)
         return VERR_NO_MEMORY;
 
@@ -1468 +1489 @@
         && (pCtx->vboxFormats & VBOX_SHCL_FMT_UNICODETEXT))
     {
-        void *pv = NULL;
+        void    *pv = NULL;
         uint32_t cb = 0;
         rc = clipReadVBoxShCl(pCtx, VBOX_SHCL_FMT_UNICODETEXT, &pv, &cb);
@@ -1480 +1501 @@
         if (RT_SUCCESS(rc))
             clipTrimTrailingNul(*(XtPointer *)pValReturn, pcLenReturn, format);
+
         RTMemFree(pv);
     }
@@ -1485 +1507 @@
              && (pCtx->vboxFormats & VBOX_SHCL_FMT_BITMAP))
     {
-        void *pv = NULL;
+        void    *pv = NULL;
         uint32_t cb = 0;
-        rc = clipReadVBoxShCl(pCtx,
-                                   VBOX_SHCL_FMT_BITMAP,
-                                   &pv, &cb);
+        rc = clipReadVBoxShCl(pCtx, VBOX_SHCL_FMT_BITMAP, &pv, &cb);
         if (RT_SUCCESS(rc) && (cb == 0))
             rc = VERR_NO_DATA;
@@ -1506 +1526 @@
             *piFormatReturn = 8;
         }
+
         RTMemFree(pv);
     }
-    else if ( (format == HTML)
+    else if (  (format == HTML)
             && (pCtx->vboxFormats & VBOX_SHCL_FMT_HTML))
     {
-        void *pv = NULL;
+        void    *pv = NULL;
         uint32_t cb = 0;
-        rc = clipReadVBoxShCl(pCtx,
-                                   VBOX_SHCL_FMT_HTML,
-                                   &pv, &cb);
+        rc = clipReadVBoxShCl(pCtx, VBOX_SHCL_FMT_HTML, &pv, &cb);
         if (RT_SUCCESS(rc) && (cb == 0))
             rc = VERR_NO_DATA;
@@ -1521 +1540 @@
         {
             /*
-            * The common VBox HTML encoding will be - Utf8
-            * becuase it more general for HTML formats then UTF16
-            * X11 clipboard returns UTF16, so before sending it we should
-            * convert it to UTF8
-            * It's very strange but here we get utf16 from x11 clipboard
-            * in same time we send utf8 to x11 clipboard and it's work
-            */
+             * The common VBox HTML encoding will be - Utf8
+             * because it more general for HTML formats then UTF16
+             * X11 clipboard returns UTF-16, so before sending it we should
+             * convert it to UTF8.
+             * It's very strange but here we get UTF-16 from x11 clipboard
+             * in same time we send UTF-8 to x11 clipboard and it's work.
+             */
             rc = clipWinHTMLToUtf8ForX11CB(XtDisplay(pCtx->widget),
-                (const char*)pv, cb, atomTarget,
-                atomTypeReturn, pValReturn,
-                pcLenReturn, piFormatReturn);
-
-
+                                           (const char*)pv, cb, atomTarget,
+                                           atomTypeReturn, pValReturn,
+                                           pcLenReturn, piFormatReturn);
             if (RT_SUCCESS(rc))
                 clipTrimTrailingNul(*(XtPointer *)pValReturn, pcLenReturn, format);
+
             RTMemFree(pv);
         }
@@ -1580 +1598 @@
 }
 
-/** Structure used to pass information about formats that VBox supports */
+/**
+ * Structure used to pass information about formats that VBox supports.
+ */
 typedef struct _CLIPNEWVBOXFORMATS
 {
-    /** Context information for the X11 clipboard */
+    /** Context information for the X11 clipboard. */
     CLIPBACKEND *pCtx;
-    /** Formats supported by VBox */
-    uint32_t formats;
+    /** Formats supported by VBox. */
+    SHCLFORMATS  formats;
 } CLIPNEWVBOXFORMATS, *PCLIPNEWVBOXFORMATS;
 
@@ -1652 +1672 @@
 
 /**
- * VBox is taking possession of the shared clipboard.
- *
- * @param                       u32Formats Clipboard formats that VBox is offering.
+ * VBox is taking possession of the Shared Clipboard.
+ *
+ * @param                       u32Formats clipboard formats that VBox is offering.
  * @note  X11 backend code
  */
@@ -1685 +1705 @@
 
 /**
- * Massages generic Utf16 with CR end-of-lines into the format Windows expects
+ * Massages generic UTF-16 with CR end-of-lines into the format Windows expects
  * and return the result in a RTMemAlloc allocated buffer.
  *
  * @returns VBox status code.
- * @param  pwcSrc               The source as Utf16.
+ * @param  pwcSrc               The source as UTF-16.
  * @param  cwcSrc               The number of 16bit elements in @a pwcSrc, not counting
  *                              the terminating zero.
@@ -1708 +1728 @@
 
     PRTUTF16 pwszDest = NULL;
-    size_t cwcDest;
+    size_t   cwcDest;
     int rc = ShClUtf16GetWinSize(pwcSrc, cwcSrc + 1, &cwcDest);
     if (RT_SUCCESS(rc))
@@ -1737 +1757 @@
 
 /**
- * Converts Utf-8 text with CR end-of-lines into Utf-16 as Windows expects it
+ * Converts UTF-8 text with CR end-of-lines into UTF-16 as Windows expects it
  * and return the result in a RTMemAlloc allocated buffer.
  *
  * @returns VBox status code.
- * @param  pcSrc                The source Utf-8.
+ * @param  pcSrc                The source UTF-8.
  * @param  cbSrc                The size of the source in bytes, not counting the
  *                              terminating zero.
@@ -1759 +1779 @@
         *pcbDest = 0;
 
-    /* Intermediate conversion to UTF16. */
-    size_t cwcTmp;
+    /* Intermediate conversion to UTF-16. */
+    size_t   cwcTmp;
     PRTUTF16 pwcTmp = NULL;
     int rc = RTStrToUtf16Ex(pcSrc, cbSrc, &pwcTmp, 0, &cwcTmp);
@@ -1773 +1793 @@
 
 /**
- * Converts Latin-1 text with CR end-of-lines into Utf-16 as Windows expects
+ * Converts Latin-1 text with CR end-of-lines into UTF-16 as Windows expects
  * it and return the result in a RTMemAlloc allocated buffer.
  *
@@ -1815 +1835 @@
 
     /* And do the conversion, bearing in mind that Latin-1 expands "naturally"
-     * to Utf-16. */
+     * to UTF-16. */
     if (RT_SUCCESS(rc))
     {
@@ -1847 +1867 @@
 
 /**
-* Converts Utf16 text into UTF8 as Windows expects
+* Converts UTF-16 text into UTF-8 as Windows expects
 * it and return the result in a RTMemAlloc allocated buffer.
 *
@@ -1893 +1913 @@
 
         /* append new substring */
-        char *pchNew = (char*)RTMemRealloc(pchRes, cRes + cch + 1);
+        char *pchNew = (char *)RTMemRealloc(pchRes, cRes + cch + 1);
         if (!pchNew)
         {
@@ -1926 +1946 @@
 {
     /** The format VBox would like the data in */
-    uint32_t mFormat;
+    SHCLFORMAT       mFormat;
+    /** @todo Put the following variables in an union or just use one for all formats? */
     /** The text format we requested from X11 if we requested text */
-    CLIPX11FORMAT mTextFormat;
+    CLIPX11FORMAT    mTextFormat;
     /** The bitmap format we requested from X11 if we requested bitmap */
-    CLIPX11FORMAT mBitmapFormat;
+    CLIPX11FORMAT    mBitmapFormat;
     /** The HTML format we requested from X11 if we requested HTML */
-    CLIPX11FORMAT mHtmlFormat;
+    CLIPX11FORMAT    mHtmlFormat;
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
     /** The URI list format we requested from X11 if we requested URI lists. */
-    CLIPX11FORMAT mURIListFormat;
+    CLIPX11FORMAT    mURIListFormat;
 #endif
     /** The clipboard context this request is associated with */
-    CLIPBACKEND *mCtx;
+    CLIPBACKEND     *mpCtx;
     /** The request structure passed in from the backend. */
-    CLIPREADCBREQ *mReq;
+    CLIPREADCBREQ   *mpReq;
 };
 
@@ -1955 +1976 @@
  *        the X11 clipboard contains a format we understand.
  */
-static void clipConvertX11CB(void *pClient, void *pvSrc, unsigned cbSrc)
-{
-    CLIPREADX11CBREQ *pReq = (CLIPREADX11CBREQ *) pClient;
-
-    LogFlowFunc(("pReq->mFormat=%02X, pReq->mTextFormat=%u, "
-                 "pReq->mBitmapFormat=%u, pReq->mHtmlFormat=%u, pReq->mCtx=%p\n",
-                 pReq->mFormat, pReq->mTextFormat, pReq->mBitmapFormat,
-                 pReq->mHtmlFormat, pReq->mCtx));
-
-    AssertPtr(pReq->mCtx);
-    Assert(pReq->mFormat != 0);  /* sanity */
+static void clipConvertDataFromX11CallbackWorker(void *pClient, void *pvSrc, unsigned cbSrc)
+{
+    CLIPREADX11CBREQ *pReq = (CLIPREADX11CBREQ *)pClient;
+
+    LogFlowFunc(("pReq->mFormat=%02X, pReq->mTextFormat=%u, pReq->mBitmapFormat=%u, pReq->mHtmlFormat=%u, pReq->mCtx=%p\n",
+                 pReq->mFormat, pReq->mTextFormat, pReq->mBitmapFormat, pReq->mHtmlFormat, pReq->mpCtx));
+
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
+    LogFlowFunc(("pReq->mURIListFormat=%u\n", pReq->mURIListFormat));
+#endif
+
+    AssertPtr(pReq->mpCtx);
+    Assert(pReq->mFormat != VBOX_SHCL_FMT_NONE); /* Sanity. */
 
     int rc = VINF_SUCCESS;
 
-    void *pvDest = NULL;
-    uint32_t cbDest = 0;
+    void    *pvDst = NULL;
+    uint32_t cbDst = 0;
 
     if (pvSrc == NULL)
@@ -1983 +2006 @@
         {
             case UTF8:
+                RT_FALL_THROUGH();
             case TEXT:
             {
-                /* If we are given broken Utf-8, we treat it as Latin1.  Is
-                 * this acceptable? */
-                if (RT_SUCCESS(RTStrValidateEncodingEx((char *)pvSrc, cbSrc,
-                                                       0)))
+                /* If we are given broken UTF-8, we treat it as Latin1. */ /** @todo Is this acceptable? */
+                if (RT_SUCCESS(RTStrValidateEncodingEx((char *)pvSrc, cbSrc, 0)))
+                {
                     rc = clipUtf8ToWinTxt((const char *)pvSrc, cbSrc,
-                                          (PRTUTF16 *) &pvDest, &cbDest);
+                                          (PRTUTF16 *)&pvDst, &cbDst);
+                }
                 else
-                    rc = clipLatin1ToWinTxt((char *) pvSrc, cbSrc,
-                                            (PRTUTF16 *) &pvDest, &cbDest);
+                {
+                    rc = clipLatin1ToWinTxt((char *)pvSrc, cbSrc,
+                                            (PRTUTF16 *)&pvDst, &cbDst);
+                }
                 break;
             }
+
             default:
+            {
                 rc = VERR_INVALID_PARAMETER;
+                break;
+            }
         }
     }
@@ -2013 +2043 @@
                 if (RT_SUCCESS(rc))
                 {
-                    pvDest = RTMemAlloc(cbDibSize);
-                    if (!pvDest)
+                    pvDst = RTMemAlloc(cbDibSize);
+                    if (!pvDst)
                         rc = VERR_NO_MEMORY;
                     else
                     {
-                        memcpy(pvDest, pDib, cbDibSize);
-                        cbDest = cbDibSize;
+                        memcpy(pvDst, pDib, cbDibSize);
+                        cbDst = cbDibSize;
                     }
                 }
                 break;
             }
+
             default:
+            {
                 rc = VERR_INVALID_PARAMETER;
-        }
-    }
-    else if(pReq->mFormat == VBOX_SHCL_FMT_HTML)
+                break;
+            }
+        }
+    }
+    else if (pReq->mFormat == VBOX_SHCL_FMT_HTML)
     {
         /* In which format is the clipboard data? */
@@ -2035 +2069 @@
             case HTML:
             {
-                /* The common VBox HTML encoding will be - Utf8
-                * becuase it more general for HTML formats then UTF16
-                * X11 clipboard returns UTF16, so before sending it we should
-                * convert it to UTF8
-                */
-                pvDest = NULL;
-                cbDest = 0;
-                /* Some applications sends data in utf16, some in itf8,
+                /*
+                 * The common VBox HTML encoding will be - UTF-8
+                 * because it more general for HTML formats then UTF-16
+                 * X11 clipboard returns UTF-16, so before sending it we should
+                 * convert it to UTF-8.
+                 */
+                pvDst = NULL;
+                cbDst = 0;
+
+                /*
+                 * Some applications sends data in UTF-16, some in UTF-8,
                  * without indication it in MIME.
-                 * But in case of utf16, at least an OpenOffice adds Byte Order Mark - 0xfeff
-                 * at start of clipboard data
+                 * But in case of UTF-16, at least an OpenOffice adds Byte Order Mark - 0xfeff
+                 * at start of clipboard data.
                  */
                 if (   cbSrc >= sizeof(RTUTF16)
@@ -2051 +2088 @@
                 {
                     LogFlowFunc((" \n"));
-                    rc = clipUTF16ToWinHTML((RTUTF16*)pvSrc, cbSrc,
-                        (char**)&pvDest, &cbDest);
+                    rc = clipUTF16ToWinHTML((RTUTF16 *)pvSrc, cbSrc,
+                                            (char**)&pvDst, &cbDst);
                 }
                 else
                 {
-                   pvDest = RTMemAlloc(cbSrc);
-                   if(pvDest)
+                   pvDst = RTMemAlloc(cbSrc);
+                   if(pvDst)
                    {
-                        memcpy(pvDest, pvSrc, cbSrc);
-                        cbDest = cbSrc;
+                        memcpy(pvDst, pvSrc, cbSrc);
+                        cbDst = cbSrc;
                    }
                    else
@@ -2070 +2107 @@
 
                 LogFlowFunc(("Source unicode %ls, cbSrc = %d\n, Byte Order Mark = %hx", pvSrc, cbSrc, ((PRTUTF16)pvSrc)[0]));
-                LogFlowFunc(("converted to win unicode %s, cbDest = %d, rc = %Rrc\n", pvDest, cbDest, rc));
+                LogFlowFunc(("converted to win unicode %s, cbDest = %d, rc = %Rrc\n", pvDst, cbDst, rc));
                 rc = VINF_SUCCESS;
                 break;
             }
+
             default:
             {
                 rc = VERR_INVALID_PARAMETER;
+                break;
             }
         }
     }
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
+    else if (pReq->mFormat == VBOX_SHCL_FMT_URI_LIST)
+    {
+        /* In which format is the clipboard data? */
+        switch (clipRealFormatForX11Format(pReq->mURIListFormat))
+        {
+            case URI_LIST:
+            {
+                /* For URI lists we only accept valid UTF-8 encodings. */
+                if (RT_SUCCESS(RTStrValidateEncodingEx((char *)pvSrc, cbSrc, 0)))
+                {
+                    /* URI lists on X are string separated with "\r\n". */
+                    RTCList<RTCString> lstRootEntries = RTCString((char *)pvSrc, cbSrc - 1).split("\r\n");
+                    for (size_t i = 0; i < lstRootEntries.size(); ++i)
+                    {
+                        const char *pcszEntry = lstRootEntries.at(i).c_str();
+                        AssertPtrBreakStmt(pcszEntry, VERR_INVALID_POINTER);
+
+                        rc = RTStrAAppend((char **)&pvDst, pcszEntry);
+                        AssertRCBreakStmt(rc, VERR_NO_MEMORY);
+                        cbDst += (uint32_t)strlen(pcszEntry);
+
+                        rc = RTStrAAppend((char **)&pvDst, "\r\n");
+                        AssertRCBreakStmt(rc, VERR_NO_MEMORY);
+                        cbDst += (uint32_t)strlen("\r\n");
+                    }
+
+                    if (cbDst)
+                        cbDst++; /* Include final (zero) termination. */
+
+                    LogFlowFunc(("URI list: cbDst=%RU32\n", cbDst));
+                }
+                else
+                    rc = VERR_INVALID_PARAMETER;
+                break;
+            }
+
+            default:
+            {
+                rc = VERR_INVALID_PARAMETER;
+                break;
+            }
+        }
+    }
+#endif
     else
-        rc = VERR_NOT_IMPLEMENTED;
-
-    ClipRequestFromX11CompleteCallback(pReq->mCtx->pFrontend, rc, pReq->mReq,
-                                       pvDest, cbDest);
-    RTMemFree(pvDest);
+        rc = VERR_NOT_SUPPORTED;
+
+    ClipRequestFromX11CompleteCallback(pReq->mpCtx->pFrontend, rc, pReq->mpReq,
+                                       pvDst, cbDst);
+    RTMemFree(pvDst);
     RTMemFree(pReq);
 
@@ -2099 +2183 @@
  * Converts full BMP data to DIB format.
  *
- * @note  X11 backend code, callback for XtGetSelectionValue, for use when
+ * @note  X11 backend code, callback for XtGetSelectionValue(), for use when
  *        the X11 clipboard contains a format we understand.
  */
-static void cbConvertX11CB(Widget widget, XtPointer pClient,
-                           Atom * /* selection */, Atom *atomType,
-                           XtPointer pvSrc, long unsigned int *pcLen,
-                           int *piFormat)
+static void clipConvertDataFromX11Callback(Widget widget, XtPointer pClient,
+                                           Atom * /* selection */, Atom *atomType,
+                                           XtPointer pvSrc, long unsigned int *pcLen,
+                                           int *piFormat)
 {
     RT_NOREF(widget);
     if (*atomType == XT_CONVERT_FAIL) /* Xt timeout */
-        clipConvertX11CB(pClient, NULL, 0);
+        clipConvertDataFromX11CallbackWorker(pClient, NULL, 0);
     else
-        clipConvertX11CB(pClient, pvSrc, (*pcLen) * (*piFormat) / 8);
+        clipConvertDataFromX11CallbackWorker(pClient, pvSrc, (*pcLen) * (*piFormat) / 8);
 
     XtFree((char *)pvSrc);
@@ -2118 +2202 @@
 
 #ifdef TESTCASE
-static void testRequestData(CLIPBACKEND* pCtx, CLIPX11FORMAT target,
-                            void *closure);
+static void tstClipRequestData(CLIPBACKEND* pCtx, CLIPX11FORMAT target,
+                               void *closure);
 #endif
 
-static int getSelectionValue(CLIPBACKEND *pCtx, CLIPX11FORMAT format,
-                             CLIPREADX11CBREQ *pReq)
+static int clipGetSelectionValue(CLIPBACKEND *pCtx, CLIPX11FORMAT format,
+                                 CLIPREADX11CBREQ *pReq)
 {
 #ifndef TESTCASE
     XtGetSelectionValue(pCtx->widget, clipGetAtom(pCtx, "CLIPBOARD"),
                         clipAtomForX11Format(pCtx, format),
-                        cbConvertX11CB,
+                        clipConvertDataFromX11Callback,
                         reinterpret_cast<XtPointer>(pReq),
                         CurrentTime);
 #else
-    testRequestData(pCtx, format, (void *)pReq);
+    tstClipRequestData(pCtx, format, (void *)pReq);
 #endif
 
@@ -2141 +2225 @@
  * 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;
+static void clipReadX11Worker(void *pvUserData, void * /* interval */)
+{
+    AssertPtrReturnVoid(pvUserData);
+
+    CLIPREADX11CBREQ *pReq = (CLIPREADX11CBREQ *)pvUserData;
+    CLIPBACKEND      *pCtx = pReq->mpCtx;
 
     LogFlowFunc(("pReq->mFormat = %02X\n", pReq->mFormat));
@@ -2159 +2242 @@
         {
             /* Send out a request for the data to the current clipboard owner. */
-            rc = getSelectionValue(pCtx, pCtx->X11TextFormat, pReq);
+            rc = clipGetSelectionValue(pCtx, pCtx->X11TextFormat, pReq);
         }
     }
@@ -2168 +2251 @@
         {
             /* Send out a request for the data to the current clipboard owner. */
-            rc = getSelectionValue(pCtx, pCtx->X11BitmapFormat, pReq);
+            rc = clipGetSelectionValue(pCtx, pCtx->X11BitmapFormat, pReq);
         }
     }
@@ -2177 +2260 @@
         {
             /* Send out a request for the data to the current clipboard owner. */
-            rc = getSelectionValue(pCtx, pCtx->X11HTMLFormat, pReq);
+            rc = clipGetSelectionValue(pCtx, pCtx->X11HTMLFormat, pReq);
         }
     }
@@ -2187 +2270 @@
         {
             /* Send out a request for the data to the current clipboard owner. */
-            rc = getSelectionValue(pCtx, pCtx->X11HTMLFormat, pReq);
+            rc = clipGetSelectionValue(pCtx, pCtx->X11URIListFormat, pReq);
         }
     }
@@ -2200 +2283 @@
         /* The clipboard callback was never scheduled, so we must signal
          * that the request processing is finished and clean up ourselves. */
-        ClipRequestFromX11CompleteCallback(pReq->mCtx->pFrontend, rc, pReq->mReq,
-                                           NULL, 0);
+        ClipRequestFromX11CompleteCallback(pReq->mpCtx->pFrontend, rc, pReq->mpReq,
+                                           NULL /* pv */ ,0 /* cb */);
         RTMemFree(pReq);
     }
@@ -2234 +2317 @@
     {
         pX11Req->mFormat = u32Format;
-        pX11Req->mCtx = pCtx;
-        pX11Req->mReq = pReq;
+        pX11Req->mpCtx   = pCtx;
+        pX11Req->mpReq   = pReq;
 
         /* We use this to schedule a worker function on the event thread. */
-        clipQueueToEventThread(pCtx, vboxClipboardReadX11Worker, (XtPointer) pX11Req);
+        rc = clipQueueToEventThread(pCtx, clipReadX11Worker, (XtPointer)pX11Req);
     }
     else
         rc = VERR_NO_MEMORY;
 
+    LogFlowFuncLeaveRC(rc);
     return rc;
 }
@@ -2261 +2345 @@
 /* For the purpose of the test case, we just execute the procedure to be
  * scheduled, as we are running single threaded. */
-void testQueueToEventThread(void (*proc)(void *, void *),
-                            void *client_data)
+void tstClipQueueToEventThread(void (*proc)(void *, void *),
+                               void *client_data)
 {
     proc(client_data, NULL);
@@ -2268 +2352 @@
 
 void XtFree(char *ptr)
-{ RTMemFree((void *) ptr); }
-
-/* The data in the simulated VBox clipboard */
-static int g_vboxDataRC = VINF_SUCCESS;
-static void *g_vboxDatapv = NULL;
-static uint32_t g_vboxDatacb = 0;
+{
+    RTMemFree((void *)ptr);
+}
+
+/* The data in the simulated VBox clipboard. */
+static int g_tstVBoxDataRC = VINF_SUCCESS;
+static void *g_tstVBoxDataPv = NULL;
+static uint32_t g_tstVBoxDataCb = 0;
 
 /* Set empty data in the simulated VBox clipboard. */
-static void clipEmptyVBox(CLIPBACKEND *pCtx, int retval)
-{
-    g_vboxDataRC = retval;
-    RTMemFree(g_vboxDatapv);
-    g_vboxDatapv = NULL;
-    g_vboxDatacb = 0;
+static void tstClipEmptyVBox(CLIPBACKEND *pCtx, int retval)
+{
+    g_tstVBoxDataRC = retval;
+    RTMemFree(g_tstVBoxDataPv);
+    g_tstVBoxDataPv = NULL;
+    g_tstVBoxDataCb = 0;
     ClipAnnounceFormatToX11(pCtx, 0);
 }
 
 /* Set the data in the simulated VBox clipboard. */
-static int clipSetVBoxUtf16(CLIPBACKEND *pCtx, int retval,
-                            const char *pcszData, size_t cb)
+static int tstClipSetVBoxUtf16(CLIPBACKEND *pCtx, int retval,
+                               const char *pcszData, size_t cb)
 {
     PRTUTF16 pwszData = NULL;
@@ -2299 +2385 @@
     if (pv == NULL)
         return VERR_NO_MEMORY;
-    if (g_vboxDatapv)
-        RTMemFree(g_vboxDatapv);
-    g_vboxDataRC = retval;
-    g_vboxDatapv = pv;
-    g_vboxDatacb = cb;
-    ClipAnnounceFormatToX11(pCtx,
-                                       VBOX_SHCL_FMT_UNICODETEXT);
+    if (g_tstVBoxDataPv)
+        RTMemFree(g_tstVBoxDataPv);
+    g_tstVBoxDataRC = retval;
+    g_tstVBoxDataPv = pv;
+    g_tstVBoxDataCb = cb;
+    ClipAnnounceFormatToX11(pCtx, VBOX_SHCL_FMT_UNICODETEXT);
     return VINF_SUCCESS;
 }
@@ -2313 +2398 @@
 {
     RT_NOREF(pCtx, u32Format);
-    *pcb = g_vboxDatacb;
-    if (g_vboxDatapv != NULL)
-    {
-        void *pv = RTMemDup(g_vboxDatapv, g_vboxDatacb);
+    *pcb = g_tstVBoxDataCb;
+    if (g_tstVBoxDataPv != NULL)
+    {
+        void *pv = RTMemDup(g_tstVBoxDataPv, g_tstVBoxDataCb);
         *ppv = pv;
-        return pv != NULL ? g_vboxDataRC : VERR_NO_MEMORY;
+        return pv != NULL ? g_tstVBoxDataRC : VERR_NO_MEMORY;
     }
     *ppv = NULL;
-    return g_vboxDataRC;
-}
-
-Display *XtDisplay(Widget w)
-{ NOREF(w); return (Display *) 0xffff; }
+    return g_tstVBoxDataRC;
+}
+
+Display *XtDisplay(Widget w) { NOREF(w); return (Display *) 0xffff; }
 
 void XtAppSetExitFlag(XtAppContext app_context) { NOREF(app_context); }
@@ -2368 +2452 @@
 
 /* Atoms we need other than the formats we support. */
-static const char *g_apszSupAtoms[] =
+static const char *g_tstapszSupAtoms[] =
 {
     "PRIMARY", "CLIPBOARD", "TARGETS", "MULTIPLE", "TIMESTAMP"
@@ -2381 +2465 @@
         if (!strcmp(pcsz, g_aFormats[i].pcszAtom))
             atom = (Atom) (i + 0x1000);
-    for (unsigned i = 0; i < RT_ELEMENTS(g_apszSupAtoms); ++i)
-        if (!strcmp(pcsz, g_apszSupAtoms[i]))
+    for (unsigned i = 0; i < RT_ELEMENTS(g_tstapszSupAtoms); ++i)
+        if (!strcmp(pcsz, g_tstapszSupAtoms[i]))
             atom = (Atom) (i + 0x2000);
     Assert(atom);  /* Have we missed any atoms? */
@@ -2392 +2476 @@
 static size_t g_cTargets = 0;
 
-void testRequestTargets(CLIPBACKEND* pCtx)
+void tstRequestTargets(CLIPBACKEND* pCtx)
 {
     clipUpdateX11Targets(pCtx, g_selTargets, g_cTargets);
@@ -2404 +2488 @@
 static int g_selFormat = 0;
 
-void testRequestData(CLIPBACKEND *pCtx, CLIPX11FORMAT target, void *closure)
+void tstClipRequestData(CLIPBACKEND *pCtx, CLIPX11FORMAT target, void *closure)
 {
     RT_NOREF(pCtx);
@@ -2411 +2495 @@
     if (target != g_selTargets[0])
     {
-        clipConvertX11CB(closure, NULL, 0); /* Could not convert to target. */
+        clipConvertDataFromX11CallbackWorker(closure, NULL, 0); /* Could not convert to target. */
         return;
     }
@@ -2423 +2507 @@
         format = 0;
     }
-    clipConvertX11CB(closure, pValue, count * format / 8);
+    clipConvertDataFromX11CallbackWorker(closure, pValue, count * format / 8);
     if (pValue)
         RTMemFree(pValue);
@@ -2437 +2521 @@
 }
 
-static uint32_t clipQueryFormats()
+static uint32_t tstClipQueryFormats(void)
 {
     return g_fX11Formats;
 }
 
-static void clipInvalidateFormats()
+static void tstClipInvalidateFormats(void)
 {
     g_fX11Formats = ~0;
@@ -2482 +2566 @@
 
 /* Request the shared clipboard to convert its data to a given format. */
-static bool clipConvertSelection(const char *pcszTarget, Atom *type,
-                                 XtPointer *value, unsigned long *length,
-                                 int *format)
+static bool tstClipConvertSelection(const char *pcszTarget, Atom *type,
+                                    XtPointer *value, unsigned long *length,
+                                    int *format)
 {
     Atom target = XInternAtom(NULL, pcszTarget, 0);
@@ -2508 +2592 @@
 
 /* Set the current X selection data */
-static void clipSetSelectionValues(const char *pcszTarget, Atom type,
-                                   const void *data,
-                                   unsigned long count, int format)
+static void tstClipSetSelectionValues(const char *pcszTarget, Atom type,
+                                      const void *data,
+                                      unsigned long count, int format)
 {
     Atom clipAtom = XInternAtom(NULL, "CLIPBOARD", 0);
@@ -2524 +2608 @@
 }
 
-static void clipSendTargetUpdate(CLIPBACKEND *pCtx)
-{
-    clipQueryX11CBFormats(pCtx);
-}
-
-/* Configure if and how the X11 TARGETS clipboard target will fail */
-static void clipSetTargetsFailure(void)
+static void tstClipSendTargetUpdate(CLIPBACKEND *pCtx)
+{
+    clipQueryX11FormatsCallback(pCtx);
+}
+
+/* Configure if and how the X11 TARGETS clipboard target will fail. */
+static void tstClipSetTargetsFailure(void)
 {
     g_cTargets = 0;
@@ -2553 +2637 @@
     {
         unsigned index = atom - 0x2000;
-        AssertReturn(index < RT_ELEMENTS(g_apszSupAtoms), NULL);
-        pcszName = g_apszSupAtoms[index];
+        AssertReturn(index < RT_ELEMENTS(g_tstapszSupAtoms), NULL);
+        pcszName = g_tstapszSupAtoms[index];
     }
     return (char *)RTMemDup(pcszName, sizeof(pcszName) + 1);
@@ -2594 +2678 @@
 }
 
-static void clipGetCompletedRequest(int *prc, char ** ppc, uint32_t *pcb, CLIPREADCBREQ **ppReq)
+static void tstClipGetCompletedRequest(int *prc, char ** ppc, uint32_t *pcb, CLIPREADCBREQ **ppReq)
 {
     *prc = g_completedRC;
@@ -2620 +2704 @@
 #endif
 
-static void testStringFromX11(RTTEST hTest, CLIPBACKEND *pCtx,
-                              const char *pcszExp, int rcExp)
+static void tstStringFromX11(RTTEST hTest, CLIPBACKEND *pCtx,
+                             const char *pcszExp, int rcExp)
 {
     bool retval = true;
-    clipSendTargetUpdate(pCtx);
-    if (clipQueryFormats() != VBOX_SHCL_FMT_UNICODETEXT)
+    tstClipSendTargetUpdate(pCtx);
+    if (tstClipQueryFormats() != VBOX_SHCL_FMT_UNICODETEXT)
         RTTestFailed(hTest, "Wrong targets reported: %02X\n",
-                     clipQueryFormats());
+                     tstClipQueryFormats());
     else
     {
@@ -2635 +2719 @@
         int rc = VINF_SUCCESS;
         uint32_t cbActual = 0;
-        clipGetCompletedRequest(&rc, &pc, &cbActual, &pReqRet);
+        tstClipGetCompletedRequest(&rc, &pc, &cbActual, &pReqRet);
         if (rc != rcExp)
             RTTestFailed(hTest, "Wrong return code, expected %Rrc, got %Rrc\n",
@@ -2677 +2761 @@
 }
 
-static void testLatin1FromX11(RTTEST hTest, CLIPBACKEND *pCtx,
-                              const char *pcszExp, int rcExp)
+static void tstLatin1FromX11(RTTEST hTest, CLIPBACKEND *pCtx,
+                             const char *pcszExp, int rcExp)
 {
     bool retval = false;
-    clipSendTargetUpdate(pCtx);
-    if (clipQueryFormats() != VBOX_SHCL_FMT_UNICODETEXT)
+    tstClipSendTargetUpdate(pCtx);
+    if (tstClipQueryFormats() != VBOX_SHCL_FMT_UNICODETEXT)
         RTTestFailed(hTest, "Wrong targets reported: %02X\n",
-                     clipQueryFormats());
+                     tstClipQueryFormats());
     else
     {
@@ -2692 +2776 @@
         int rc = VINF_SUCCESS;
         uint32_t cbActual = 0;
-        clipGetCompletedRequest(&rc, &pc, &cbActual, &pReqRet);
+        tstClipGetCompletedRequest(&rc, &pc, &cbActual, &pReqRet);
         if (rc != rcExp)
             RTTestFailed(hTest, "Wrong return code, expected %Rrc, got %Rrc\n",
@@ -2730 +2814 @@
 }
 
-static void testStringFromVBox(RTTEST hTest, CLIPBACKEND *pCtx, const char *pcszTarget, Atom typeExp,  const char *valueExp)
+static void tstStringFromVBox(RTTEST hTest, CLIPBACKEND *pCtx, const char *pcszTarget, Atom typeExp,  const char *valueExp)
 {
     RT_NOREF(pCtx);
@@ -2739 +2823 @@
     int format;
     size_t lenExp = strlen(valueExp);
-    if (clipConvertSelection(pcszTarget, &type, &value, &length, &format))
+    if (tstClipConvertSelection(pcszTarget, &type, &value, &length, &format))
     {
         if (   type != typeExp
@@ -2762 +2846 @@
 }
 
-static void testNoX11(CLIPBACKEND *pCtx, const char *pcszTestCtx)
+static void tstNoX11(CLIPBACKEND *pCtx, const char *pcszTestCtx)
 {
     CLIPREADCBREQ *pReq = (CLIPREADCBREQ *)&pReq;
@@ -2769 +2853 @@
 }
 
-static void testStringFromVBoxFailed(RTTEST hTest, CLIPBACKEND *pCtx, const char *pcszTarget)
+static void tstStringFromVBoxFailed(RTTEST hTest, CLIPBACKEND *pCtx, const char *pcszTarget)
 {
     RT_NOREF(pCtx);
@@ -2776 +2860 @@
     unsigned long length;
     int format;
-    RTTEST_CHECK_MSG(hTest, !clipConvertSelection(pcszTarget, &type, &value,
-                                                  &length, &format),
+    RTTEST_CHECK_MSG(hTest, !tstClipConvertSelection(pcszTarget, &type, &value,
+                                                     &length, &format),
                      (hTest, "Conversion to target %s, should have failed but didn't, returned type %d, length %u, format %d, value \"%.*s\"\n",
                       pcszTarget, type, length, format, RT_MIN(length, 20),
@@ -2784 +2868 @@
 }
 
-static void testNoSelectionOwnership(CLIPBACKEND *pCtx, const char *pcszTestCtx)
+static void tstNoSelectionOwnership(CLIPBACKEND *pCtx, const char *pcszTestCtx)
 {
     RT_NOREF(pCtx);
@@ -2790 +2874 @@
 }
 
-static void testBadFormatRequestFromHost(RTTEST hTest, CLIPBACKEND *pCtx)
-{
-    clipSetSelectionValues("UTF8_STRING", XA_STRING, "hello world",
+static void tstBadFormatRequestFromHost(RTTEST hTest, CLIPBACKEND *pCtx)
+{
+    tstClipSetSelectionValues("UTF8_STRING", XA_STRING, "hello world",
                            sizeof("hello world"), 8);
-    clipSendTargetUpdate(pCtx);
-    if (clipQueryFormats() != VBOX_SHCL_FMT_UNICODETEXT)
+    tstClipSendTargetUpdate(pCtx);
+    if (tstClipQueryFormats() != VBOX_SHCL_FMT_UNICODETEXT)
         RTTestFailed(hTest, "Wrong targets reported: %02X\n",
-                     clipQueryFormats());
+                     tstClipQueryFormats());
     else
     {
@@ -2805 +2889 @@
         int rc = VINF_SUCCESS;
         uint32_t cbActual = 0;
-        clipGetCompletedRequest(&rc, &pc, &cbActual, &pReqRet);
+        tstClipGetCompletedRequest(&rc, &pc, &cbActual, &pReqRet);
         if (rc != VERR_NOT_IMPLEMENTED)
             RTTestFailed(hTest, "Wrong return code, expected VERR_NOT_IMPLEMENTED, got %Rrc\n",
                          rc);
-        clipSetSelectionValues("", XA_STRING, "", sizeof(""), 8);
-        clipSendTargetUpdate(pCtx);
-        if (clipQueryFormats() == VBOX_SHCL_FMT_UNICODETEXT)
+        tstClipSetSelectionValues("", XA_STRING, "", sizeof(""), 8);
+        tstClipSendTargetUpdate(pCtx);
+        if (tstClipQueryFormats() == VBOX_SHCL_FMT_UNICODETEXT)
             RTTestFailed(hTest, "Failed to report targets after bad host request.\n");
     }
@@ -2837 +2921 @@
     AssertRCReturn(rc, 1);
 
-    /*** Utf-8 from X11 ***/
-    RTTestSub(hTest, "reading Utf-8 from X11");
+    /*** UTF-8 from X11 ***/
+    RTTestSub(hTest, "reading UTF-8 from X11");
     /* Simple test */
-    clipSetSelectionValues("UTF8_STRING", XA_STRING, "hello world",
-                           sizeof("hello world"), 8);
-    testStringFromX11(hTest, pCtx, "hello world", VINF_SUCCESS);
+    tstClipSetSelectionValues("UTF8_STRING", XA_STRING, "hello world",
+                              sizeof("hello world"), 8);
+    tstStringFromX11(hTest, pCtx, "hello world", VINF_SUCCESS);
     /* With an embedded carriage return */
-    clipSetSelectionValues("text/plain;charset=UTF-8", XA_STRING,
-                           "hello\nworld", sizeof("hello\nworld"), 8);
-    testStringFromX11(hTest, pCtx, "hello\r\nworld", VINF_SUCCESS);
+    tstClipSetSelectionValues("text/plain;charset=UTF-8", XA_STRING,
+                              "hello\nworld", sizeof("hello\nworld"), 8);
+    tstStringFromX11(hTest, pCtx, "hello\r\nworld", VINF_SUCCESS);
     /* With an embedded CRLF */
-    clipSetSelectionValues("text/plain;charset=UTF-8", XA_STRING,
-                           "hello\r\nworld", sizeof("hello\r\nworld"), 8);
-    testStringFromX11(hTest, pCtx, "hello\r\r\nworld", VINF_SUCCESS);
+    tstClipSetSelectionValues("text/plain;charset=UTF-8", XA_STRING,
+                              "hello\r\nworld", sizeof("hello\r\nworld"), 8);
+    tstStringFromX11(hTest, pCtx, "hello\r\r\nworld", VINF_SUCCESS);
     /* With an embedded LFCR */
-    clipSetSelectionValues("text/plain;charset=UTF-8", XA_STRING,
-                           "hello\n\rworld", sizeof("hello\n\rworld"), 8);
-    testStringFromX11(hTest, pCtx, "hello\r\n\rworld", VINF_SUCCESS);
+    tstClipSetSelectionValues("text/plain;charset=UTF-8", XA_STRING,
+                              "hello\n\rworld", sizeof("hello\n\rworld"), 8);
+    tstStringFromX11(hTest, pCtx, "hello\r\n\rworld", VINF_SUCCESS);
     /* An empty string */
-    clipSetSelectionValues("text/plain;charset=utf-8", XA_STRING, "",
-                           sizeof(""), 8);
-    testStringFromX11(hTest, pCtx, "", VINF_SUCCESS);
-    /* With an embedded Utf-8 character. */
-    clipSetSelectionValues("STRING", XA_STRING,
-                           "100\xE2\x82\xAC" /* 100 Euro */,
-                           sizeof("100\xE2\x82\xAC"), 8);
-    testStringFromX11(hTest, pCtx, "100\xE2\x82\xAC", VINF_SUCCESS);
+    tstClipSetSelectionValues("text/plain;charset=utf-8", XA_STRING, "",
+                              sizeof(""), 8);
+    tstStringFromX11(hTest, pCtx, "", VINF_SUCCESS);
+    /* With an embedded UTF-8 character. */
+    tstClipSetSelectionValues("STRING", XA_STRING,
+                              "100\xE2\x82\xAC" /* 100 Euro */,
+                              sizeof("100\xE2\x82\xAC"), 8);
+    tstStringFromX11(hTest, pCtx, "100\xE2\x82\xAC", VINF_SUCCESS);
     /* A non-zero-terminated string */
-    clipSetSelectionValues("TEXT", XA_STRING,
-                           "hello world", sizeof("hello world") - 1, 8);
-    testStringFromX11(hTest, pCtx, "hello world", VINF_SUCCESS);
+    tstClipSetSelectionValues("TEXT", XA_STRING,
+                              "hello world", sizeof("hello world") - 1, 8);
+    tstStringFromX11(hTest, pCtx, "hello world", VINF_SUCCESS);
 
     /*** Latin1 from X11 ***/
     RTTestSub(hTest, "reading Latin1 from X11");
     /* Simple test */
-    clipSetSelectionValues("STRING", XA_STRING, "Georges Dupr\xEA",
-                           sizeof("Georges Dupr\xEA"), 8);
-    testLatin1FromX11(hTest, pCtx, "Georges Dupr\xEA", VINF_SUCCESS);
+    tstClipSetSelectionValues("STRING", XA_STRING, "Georges Dupr\xEA",
+                              sizeof("Georges Dupr\xEA"), 8);
+    tstLatin1FromX11(hTest, pCtx, "Georges Dupr\xEA", VINF_SUCCESS);
     /* With an embedded carriage return */
-    clipSetSelectionValues("TEXT", XA_STRING, "Georges\nDupr\xEA",
-                           sizeof("Georges\nDupr\xEA"), 8);
-    testLatin1FromX11(hTest, pCtx, "Georges\r\nDupr\xEA", VINF_SUCCESS);
+    tstClipSetSelectionValues("TEXT", XA_STRING, "Georges\nDupr\xEA",
+                              sizeof("Georges\nDupr\xEA"), 8);
+    tstLatin1FromX11(hTest, pCtx, "Georges\r\nDupr\xEA", VINF_SUCCESS);
     /* With an embedded CRLF */
-    clipSetSelectionValues("TEXT", XA_STRING, "Georges\r\nDupr\xEA",
-                           sizeof("Georges\r\nDupr\xEA"), 8);
-    testLatin1FromX11(hTest, pCtx, "Georges\r\r\nDupr\xEA", VINF_SUCCESS);
+    tstClipSetSelectionValues("TEXT", XA_STRING, "Georges\r\nDupr\xEA",
+                              sizeof("Georges\r\nDupr\xEA"), 8);
+    tstLatin1FromX11(hTest, pCtx, "Georges\r\r\nDupr\xEA", VINF_SUCCESS);
     /* With an embedded LFCR */
-    clipSetSelectionValues("TEXT", XA_STRING, "Georges\n\rDupr\xEA",
-                           sizeof("Georges\n\rDupr\xEA"), 8);
-    testLatin1FromX11(hTest, pCtx, "Georges\r\n\rDupr\xEA", VINF_SUCCESS);
+    tstClipSetSelectionValues("TEXT", XA_STRING, "Georges\n\rDupr\xEA",
+                              sizeof("Georges\n\rDupr\xEA"), 8);
+    tstLatin1FromX11(hTest, pCtx, "Georges\r\n\rDupr\xEA", VINF_SUCCESS);
     /* A non-zero-terminated string */
-    clipSetSelectionValues("text/plain", XA_STRING,
-                           "Georges Dupr\xEA!",
-                           sizeof("Georges Dupr\xEA!") - 1, 8);
-    testLatin1FromX11(hTest, pCtx, "Georges Dupr\xEA!", VINF_SUCCESS);
+    tstClipSetSelectionValues("text/plain", XA_STRING,
+                              "Georges Dupr\xEA!",
+                              sizeof("Georges Dupr\xEA!") - 1, 8);
+    tstLatin1FromX11(hTest, pCtx, "Georges Dupr\xEA!", VINF_SUCCESS);
 
     /*** Unknown X11 format ***/
     RTTestSub(hTest, "handling of an unknown X11 format");
-    clipInvalidateFormats();
-    clipSetSelectionValues("CLIPBOARD", XA_STRING, "Test",
-                           sizeof("Test"), 8);
-    clipSendTargetUpdate(pCtx);
-    RTTEST_CHECK_MSG(hTest, clipQueryFormats() == 0,
+    tstClipInvalidateFormats();
+    tstClipSetSelectionValues("CLIPBOARD", XA_STRING, "Test",
+                              sizeof("Test"), 8);
+    tstClipSendTargetUpdate(pCtx);
+    RTTEST_CHECK_MSG(hTest, tstClipQueryFormats() == 0,
                      (hTest, "Failed to send a format update notification\n"));
 
     /*** Timeout from X11 ***/
     RTTestSub(hTest, "X11 timeout");
-    clipSetSelectionValues("UTF8_STRING", XT_CONVERT_FAIL, NULL,0, 8);
-    testStringFromX11(hTest, pCtx, "", VERR_NO_DATA);
+    tstClipSetSelectionValues("UTF8_STRING", XT_CONVERT_FAIL, NULL,0, 8);
+    tstStringFromX11(hTest, pCtx, "", VERR_NO_DATA);
 
     /*** No data in X11 clipboard ***/
     RTTestSub(hTest, "a data request from an empty X11 clipboard");
-    clipSetSelectionValues("UTF8_STRING", XA_STRING, NULL,
-                           0, 8);
+    tstClipSetSelectionValues("UTF8_STRING", XA_STRING, NULL,
+                              0, 8);
     ClipRequestDataFromX11(pCtx, VBOX_SHCL_FMT_UNICODETEXT, pReq);
-    clipGetCompletedRequest(&rc, &pc, &cbActual, &pReqRet);
+    tstClipGetCompletedRequest(&rc, &pc, &cbActual, &pReqRet);
     RTTEST_CHECK_MSG(hTest, rc == VERR_NO_DATA,
                      (hTest, "Returned %Rrc instead of VERR_NO_DATA\n",
@@ -2922 +3006 @@
     /*** Ensure that VBox is notified when we return the CB to X11 ***/
     RTTestSub(hTest, "notification of switch to X11 clipboard");
-    clipInvalidateFormats();
+    tstClipInvalidateFormats();
     clipReportEmptyX11CB(pCtx);
-    RTTEST_CHECK_MSG(hTest, clipQueryFormats() == 0,
+    RTTEST_CHECK_MSG(hTest, tstClipQueryFormats() == 0,
                      (hTest, "Failed to send a format update (release) notification\n"));
 
@@ -2930 +3014 @@
     RTTestSub(hTest, "a request for an invalid VBox format from X11");
     ClipRequestDataFromX11(pCtx, 0xffff, pReq);
-    clipGetCompletedRequest(&rc, &pc, &cbActual, &pReqRet);
+    tstClipGetCompletedRequest(&rc, &pc, &cbActual, &pReqRet);
     RTTEST_CHECK_MSG(hTest, rc == VERR_NOT_IMPLEMENTED,
                      (hTest, "Returned %Rrc instead of VERR_NOT_IMPLEMENTED\n",
@@ -2940 +3024 @@
     /*** Targets failure from X11 ***/
     RTTestSub(hTest, "X11 targets conversion failure");
-    clipSetSelectionValues("UTF8_STRING", XA_STRING, "hello world",
-                           sizeof("hello world"), 8);
-    clipSetTargetsFailure();
+    tstClipSetSelectionValues("UTF8_STRING", XA_STRING, "hello world",
+                              sizeof("hello world"), 8);
+    tstClipSetTargetsFailure();
     Atom atom = XA_STRING;
     long unsigned int cLen = 0;
     int format = 8;
-    clipConvertX11Targets(NULL, (XtPointer) pCtx, NULL, &atom, NULL, &cLen,
+    clipConvertX11TargetsCallback(NULL, (XtPointer) pCtx, NULL, &atom, NULL, &cLen,
                           &format);
-    RTTEST_CHECK_MSG(hTest, clipQueryFormats() == 0,
+    RTTEST_CHECK_MSG(hTest, tstClipQueryFormats() == 0,
                      (hTest, "Wrong targets reported: %02X\n",
-                      clipQueryFormats()));
+                      tstClipQueryFormats()));
 
     /*** X11 text format conversion ***/
     RTTestSub(hTest, "handling of X11 selection targets");
-    RTTEST_CHECK_MSG(hTest, clipTestTextFormatConversion(pCtx),
+    RTTEST_CHECK_MSG(hTest, tstClipTextFormatConversion(pCtx),
                      (hTest, "failed to select the right X11 text formats\n"));
 
-    /*** Utf-8 from VBox ***/
-    RTTestSub(hTest, "reading Utf-8 from VBox");
+    /*** UTF-8 from VBox ***/
+    RTTestSub(hTest, "reading UTF-8 from VBox");
     /* Simple test */
-    clipSetVBoxUtf16(pCtx, VINF_SUCCESS, "hello world",
-                     sizeof("hello world") * 2);
-    testStringFromVBox(hTest, pCtx, "UTF8_STRING",
-                       clipGetAtom(pCtx, "UTF8_STRING"), "hello world");
+    tstClipSetVBoxUtf16(pCtx, VINF_SUCCESS, "hello world",
+                        sizeof("hello world") * 2);
+    tstStringFromVBox(hTest, pCtx, "UTF8_STRING",
+                      clipGetAtom(pCtx, "UTF8_STRING"), "hello world");
     /* With an embedded carriage return */
-    clipSetVBoxUtf16(pCtx, VINF_SUCCESS, "hello\r\nworld",
-                     sizeof("hello\r\nworld") * 2);
-    testStringFromVBox(hTest, pCtx, "text/plain;charset=UTF-8",
-                       clipGetAtom(pCtx, "text/plain;charset=UTF-8"),
-                       "hello\nworld");
+    tstClipSetVBoxUtf16(pCtx, VINF_SUCCESS, "hello\r\nworld",
+                        sizeof("hello\r\nworld") * 2);
+    tstStringFromVBox(hTest, pCtx, "text/plain;charset=UTF-8",
+                      clipGetAtom(pCtx, "text/plain;charset=UTF-8"),
+                      "hello\nworld");
     /* With an embedded CRCRLF */
-    clipSetVBoxUtf16(pCtx, VINF_SUCCESS, "hello\r\r\nworld",
-                     sizeof("hello\r\r\nworld") * 2);
-    testStringFromVBox(hTest, pCtx, "text/plain;charset=UTF-8",
-                       clipGetAtom(pCtx, "text/plain;charset=UTF-8"),
-                       "hello\r\nworld");
+    tstClipSetVBoxUtf16(pCtx, VINF_SUCCESS, "hello\r\r\nworld",
+                        sizeof("hello\r\r\nworld") * 2);
+    tstStringFromVBox(hTest, pCtx, "text/plain;charset=UTF-8",
+                      clipGetAtom(pCtx, "text/plain;charset=UTF-8"),
+                      "hello\r\nworld");
     /* With an embedded CRLFCR */
-    clipSetVBoxUtf16(pCtx, VINF_SUCCESS, "hello\r\n\rworld",
-                     sizeof("hello\r\n\rworld") * 2);
-    testStringFromVBox(hTest, pCtx, "text/plain;charset=UTF-8",
-                       clipGetAtom(pCtx, "text/plain;charset=UTF-8"),
-                       "hello\n\rworld");
+    tstClipSetVBoxUtf16(pCtx, VINF_SUCCESS, "hello\r\n\rworld",
+                        sizeof("hello\r\n\rworld") * 2);
+    tstStringFromVBox(hTest, pCtx, "text/plain;charset=UTF-8",
+                      clipGetAtom(pCtx, "text/plain;charset=UTF-8"),
+                      "hello\n\rworld");
     /* An empty string */
-    clipSetVBoxUtf16(pCtx, VINF_SUCCESS, "", 2);
-    testStringFromVBox(hTest, pCtx, "text/plain;charset=utf-8",
-                       clipGetAtom(pCtx, "text/plain;charset=utf-8"), "");
-    /* With an embedded Utf-8 character. */
-    clipSetVBoxUtf16(pCtx, VINF_SUCCESS, "100\xE2\x82\xAC" /* 100 Euro */,
-                     10);
-    testStringFromVBox(hTest, pCtx, "STRING",
-                       clipGetAtom(pCtx, "STRING"), "100\xE2\x82\xAC");
+    tstClipSetVBoxUtf16(pCtx, VINF_SUCCESS, "", 2);
+    tstStringFromVBox(hTest, pCtx, "text/plain;charset=utf-8",
+                      clipGetAtom(pCtx, "text/plain;charset=utf-8"), "");
+    /* With an embedded UTF-8 character. */
+    tstClipSetVBoxUtf16(pCtx, VINF_SUCCESS, "100\xE2\x82\xAC" /* 100 Euro */,
+                        10);
+    tstStringFromVBox(hTest, pCtx, "STRING",
+                      clipGetAtom(pCtx, "STRING"), "100\xE2\x82\xAC");
     /* A non-zero-terminated string */
-    clipSetVBoxUtf16(pCtx, VINF_SUCCESS, "hello world",
-                     sizeof("hello world") * 2 - 2);
-    testStringFromVBox(hTest, pCtx, "TEXT", clipGetAtom(pCtx, "TEXT"),
-                       "hello world");
+    tstClipSetVBoxUtf16(pCtx, VINF_SUCCESS, "hello world",
+                        sizeof("hello world") * 2 - 2);
+    tstStringFromVBox(hTest, pCtx, "TEXT", clipGetAtom(pCtx, "TEXT"),
+                     "hello world");
 
     /*** Timeout from VBox ***/
     RTTestSub(hTest, "reading from VBox with timeout");
-    clipEmptyVBox(pCtx, VERR_TIMEOUT);
-    testStringFromVBoxFailed(hTest, pCtx, "UTF8_STRING");
+    tstClipEmptyVBox(pCtx, VERR_TIMEOUT);
+    tstStringFromVBoxFailed(hTest, pCtx, "UTF8_STRING");
 
     /*** No data in VBox clipboard ***/
     RTTestSub(hTest, "an empty VBox clipboard");
-    clipSetSelectionValues("TEXT", XA_STRING, "", sizeof(""), 8);
-    clipEmptyVBox(pCtx, VINF_SUCCESS);
+    tstClipSetSelectionValues("TEXT", XA_STRING, "", sizeof(""), 8);
+    tstClipEmptyVBox(pCtx, VINF_SUCCESS);
     RTTEST_CHECK_MSG(hTest, g_ownsSel,
                      (hTest, "VBox grabbed the clipboard with no data and we ignored it\n"));
-    testStringFromVBoxFailed(hTest, pCtx, "UTF8_STRING");
+    tstStringFromVBoxFailed(hTest, pCtx, "UTF8_STRING");
 
     /*** An unknown VBox format ***/
     RTTestSub(hTest, "reading an unknown VBox format");
-    clipSetSelectionValues("TEXT", XA_STRING, "", sizeof(""), 8);
-    clipSetVBoxUtf16(pCtx, VINF_SUCCESS, "", 2);
+    tstClipSetSelectionValues("TEXT", XA_STRING, "", sizeof(""), 8);
+    tstClipSetVBoxUtf16(pCtx, VINF_SUCCESS, "", 2);
     ClipAnnounceFormatToX11(pCtx, 0xa0000);
     RTTEST_CHECK_MSG(hTest, g_ownsSel,
                      (hTest, "VBox grabbed the clipboard with unknown data and we ignored it\n"));
-    testStringFromVBoxFailed(hTest, pCtx, "UTF8_STRING");
+    tstStringFromVBoxFailed(hTest, pCtx, "UTF8_STRING");
 
     /*** VBox requests a bad format ***/
     RTTestSub(hTest, "recovery from a bad format request");
-    testBadFormatRequestFromHost(hTest, pCtx);
+    tstBadFormatRequestFromHost(hTest, pCtx);
 
     rc = ClipStopX11(pCtx);
@@ -3036 +3120 @@
     RTTestSub(hTest, "reading from X11, headless clipboard");
     /* Simple test */
-    clipSetVBoxUtf16(pCtx, VINF_SUCCESS, "",
-                     sizeof("") * 2);
-    clipSetSelectionValues("UTF8_STRING", XA_STRING, "hello world",
-                           sizeof("hello world"), 8);
-    testNoX11(pCtx, "reading from X11, headless clipboard");
+    tstClipSetVBoxUtf16(pCtx, VINF_SUCCESS, "",
+                        sizeof("") * 2);
+    tstClipSetSelectionValues("UTF8_STRING", XA_STRING, "hello world",
+                              sizeof("hello world"), 8);
+    tstNoX11(pCtx, "reading from X11, headless clipboard");
 
     /*** Read from VBox ***/
     RTTestSub(hTest, "reading from VBox, headless clipboard");
     /* Simple test */
-    clipEmptyVBox(pCtx, VERR_WRONG_ORDER);
-    clipSetSelectionValues("TEXT", XA_STRING, "", sizeof(""), 8);
-    clipSetVBoxUtf16(pCtx, VINF_SUCCESS, "hello world",
-                     sizeof("hello world") * 2);
-    testNoSelectionOwnership(pCtx, "reading from VBox, headless clipboard");
+    tstClipEmptyVBox(pCtx, VERR_WRONG_ORDER);
+    tstClipSetSelectionValues("TEXT", XA_STRING, "", sizeof(""), 8);
+    tstClipSetVBoxUtf16(pCtx, VINF_SUCCESS, "hello world",
+                        sizeof("hello world") * 2);
+    tstNoSelectionOwnership(pCtx, "reading from VBox, headless clipboard");
 
     rc = ClipStopX11(pCtx);