Changeset 19152 in vbox for trunk/src/VBox

Timestamp:

Apr 23, 2009 9:23:45 PM (16 years ago)

Author:

vboxsync

Message:

HostServices and GuestHost/X11 clipboard: lots of changes, see defect 3621 comment 41

Location:

trunk/src/VBox

Files:

• GuestHost/SharedClipboard/x11-clipboard.cpp (modified) (39 diffs)
• HostServices/SharedClipboard/x11-clipboard.cpp (modified) (13 diffs)

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

@@ -23 +23 @@
 #define LOG_GROUP LOG_GROUP_SHARED_CLIPBOARD
 
+#include <errno.h>
 #include <vector>
+
+#include <unistd.h>
 
 #ifdef RT_OS_SOLARIS
@@ -103 +106 @@
     std::vector<VBOXCLIPBOARDFORMAT> formatList;
 
-    /** Does VBox or X11 currently own the clipboard? */
-    volatile enum g_eOwner eOwner;
+    /** Does VBox currently own the clipboard?  If so, we don't need to poll
+     * X11 for supported formats. */
+    bool fOwnsClipboard;
 
     /** What is the best text format X11 has to offer?  INVALID for none. */
@@ -110 +114 @@
     /** Atom corresponding to the X11 text format */
     Atom atomX11TextFormat;
-    /** What is the best bitmap format X11 has to offer?  INVALID for none. */
+    /** What is the best bitmap format X11 has to offer?  INVALID for none.
+     */
     g_eClipboardFormats X11BitmapFormat;
     /** Atom corresponding to the X11 Bitmap format */
@@ -121 +126 @@
      * to invalidate it. */
     bool notifyVBox;
-
-    /** Since the clipboard data moves asynchronously, we use an event
-     * semaphore to wait for it.  When a function issues a request for
-     * clipboard data it must wait for this semaphore, which is triggered
-     * when the data arrives. */
-    RTSEMEVENT waitForData;
+    /** Cache of the last unicode data that we received */
+    void *pvUnicodeCache;
+    /** Size of the unicode data in the cache */
+    uint32_t cbUnicodeCache;
+    /** When we wish the clipboard to exit, we have to wake up the event
+     * loop.  We do this by writing into a pipe.  This end of the pipe is
+     * the end that another thread can write to. */
+    int wakeupPipeWrite;
+    /** The reader end of the pipe */
+    int wakeupPipeRead;
 };
 
@@ -248 +257 @@
  *        the X11 clipboard.
  */
-static void vboxClipboardGetUtf8FromX11(VBOXCLIPBOARDCONTEXTX11 *pCtx,
-                                        XtPointer pValue, unsigned cbSrcLen,
-                                        void *pv, unsigned cb,
-                                        uint32_t *pcbActual)
+static int vboxClipboardGetUtf8FromX11(VBOXCLIPBOARDCONTEXTX11 *pCtx,
+                                       XtPointer pValue, unsigned cbSrcLen,
+                                       void *pv, unsigned cb,
+                                       uint32_t *pcbActual)
 {
     size_t cwSrcLen;
@@ -267 +276 @@
     XtFree(reinterpret_cast<char *>(pValue));
     RTUtf16Free(pu16SrcText);
-    RTSemEventSignal(pCtx->waitForData);
-    LogFlowFunc(("Returning.  Status is %Rrc\n", rc));
+    LogFlowFunc(("Returning %Rrc\n", rc));
+    return rc;
 }
 
@@ -285 +294 @@
  *        the X11 clipboard.
  */
-static void vboxClipboardGetCTextFromX11(VBOXCLIPBOARDCONTEXTX11 *pCtx,
-                                         XtPointer pValue, unsigned cbSrcLen,
-                                         void *pv, unsigned cb,
-                                         uint32_t *pcbActual)
+static int vboxClipboardGetCTextFromX11(VBOXCLIPBOARDCONTEXTX11 *pCtx,
+                                        XtPointer pValue, unsigned cbSrcLen,
+                                        void *pv, unsigned cb,
+                                        uint32_t *pcbActual)
 {
     size_t cwSrcLen;
@@ -335 +344 @@
         XFreeStringList(ppu8SrcText);
     RTUtf16Free(pu16SrcText);
-    LogFlowFunc(("Returning.  Status is %Rrc\n", rc));
-    RTSemEventSignal(pCtx->waitForData);
+    LogFlowFunc(("Returning %Rrc\n", rc));
+    return rc;
 }
 
@@ -353 +362 @@
  *        the X11 clipboard.
  */
-static void vboxClipboardGetLatin1FromX11(VBOXCLIPBOARDCONTEXTX11 *pCtx,
-                                          XtPointer pValue,
-                                          unsigned cbSourceLen, void *pv,
-                                          unsigned cb, uint32_t *pcbActual)
+static int vboxClipboardGetLatin1FromX11(VBOXCLIPBOARDCONTEXTX11 *pCtx,
+                                         XtPointer pValue,
+                                         unsigned cbSourceLen, void *pv,
+                                         unsigned cb, uint32_t *pcbActual)
 {
     unsigned cwDestLen = cbSourceLen + 1;
@@ -392 +401 @@
     }
     XtFree(reinterpret_cast<char *>(pValue));
-    RTSemEventSignal(pCtx->waitForData);
-    LogFlowFunc(("Returning.  Status is %Rrc\n", rc));
+    LogFlowFunc(("Returning %Rrc\n", rc));
+    return rc;
 }
 
@@ -412 +421 @@
         = reinterpret_cast<VBOXCLIPBOARDREQUEST *>(pClientData);
     VBOXCLIPBOARDCONTEXTX11 *pCtx = pRequest->pCtx;
+    if (pCtx->fOwnsClipboard == true)
+    {
+        /* We don't want to request data from ourselves! */
+        pRequest->rc = VERR_NO_DATA;
+        RTSemEventSignal(pRequest->finished);
+        return;
+    }
     pRequest->rc = VINF_SUCCESS;
     LogFlowFunc(("pClientData=%p, *pcLen=%lu, *piFormat=%d\n", pClientData,
@@ -422 +438 @@
     {
         pRequest->rc = VERR_TIMEOUT;
-        RTSemEventSignal(pCtx->waitForData);
+        RTSemEventSignal(pRequest->finished);
         return;
     }
@@ -429 +445 @@
     {
         pRequest->rc = VERR_NO_DATA;
-        RTSemEventSignal(pCtx->waitForData);
+        RTSemEventSignal(pRequest->finished);
         return;
     }
@@ -436 +452 @@
     {
     case CTEXT:
-        vboxClipboardGetCTextFromX11(pCtx, pValue, cTextLen, pRequest->pv,
-                                     pRequest->cb, pRequest->pcbActual);
+        pRequest->rc = vboxClipboardGetCTextFromX11(pCtx, pValue, cTextLen,
+                                                    pRequest->pv,
+                                                    pRequest->cb,
+                                                    pRequest->pcbActual);
+        RTSemEventSignal(pRequest->finished);
         break;
     case UTF8:
@@ -448 +467 @@
             && (RTStrUniLenEx(pu8SourceText, *pcLen, &cStringLen) == VINF_SUCCESS))
         {
-            vboxClipboardGetUtf8FromX11(pCtx, pValue, cTextLen, pRequest->pv,
-                                     pRequest->cb, pRequest->pcbActual);
+            pRequest->rc = vboxClipboardGetUtf8FromX11(pCtx, pValue,
+                                                       cTextLen,
+                                                       pRequest->pv,
+                                                       pRequest->cb,
+                                                       pRequest->pcbActual);
+            RTSemEventSignal(pRequest->finished);
             break;
         }
         else
         {
-            vboxClipboardGetLatin1FromX11(pCtx, pValue, cTextLen,
-                                          pRequest->pv, pRequest->cb,
-                                          pRequest->pcbActual);
+            pRequest->rc = vboxClipboardGetLatin1FromX11(pCtx, pValue,
+                                                         cTextLen,
+                                                         pRequest->pv,
+                                                         pRequest->cb,
+                                                        pRequest->pcbActual);
+            RTSemEventSignal(pRequest->finished);
             break;
         }
@@ -464 +490 @@
         XtFree(reinterpret_cast<char *>(pValue));
         pRequest->rc = VERR_INVALID_PARAMETER;
-        RTSemEventSignal(pCtx->waitForData);
+        RTSemEventSignal(pRequest->finished);
         return;
     }
@@ -493 +519 @@
 
     Log3 (("%s: called\n", __PRETTY_FUNCTION__));
-    if (*atomType == XT_CONVERT_FAIL) /* timeout */
-    {
-        LogFunc (("reading clipboard from host, X toolkit failed to convert the selection\n"));
+    if (   (*atomType == XT_CONVERT_FAIL) /* timeout */
+        || (pCtx->fOwnsClipboard == true) /* VBox currently owns the
+                                           * clipboard */
+       )
+    {
         pCtx->atomX11TextFormat = None;
         pCtx->X11TextFormat = INVALID;
@@ -576 +604 @@
             reinterpret_cast<VBOXCLIPBOARDCONTEXTX11 *>(pUserData);
     Log3 (("%s: called\n", __PRETTY_FUNCTION__));
-    /* Get the current clipboard contents */
-    if ((pCtx->eOwner != VB))
+    /* Get the current clipboard contents if we don't own it ourselves */
+    if (!pCtx->fOwnsClipboard)
     {
         Log3 (("%s: requesting the targets that the host clipboard offers\n",
@@ -642 +670 @@
         vboxClipboardRemoveContext(pCtx);
         XtDestroyWidget(pCtx->widget);
-        pCtx->widget = NULL;
-    }
+    }
+    pCtx->widget = NULL;
     if (pCtx->appContext)
-    {
         XtDestroyApplicationContext(pCtx->appContext);
-        pCtx->appContext = NULL;
-    }
+    pCtx->appContext = NULL;
+    if (pCtx->wakeupPipeRead != 0)
+        close(pCtx->wakeupPipeRead);
+    if (pCtx->wakeupPipeWrite != 0)
+        close(pCtx->wakeupPipeWrite);
+    pCtx->wakeupPipeRead = 0;
+    pCtx->wakeupPipeWrite = 0;
+}
+
+/** Worker function for stopping the clipboard which runs on the event
+ * thread. */
+static void vboxClipboardStopWorker(XtPointer pUserData, int * /* source */,
+                                    XtInputId * /* id */)
+{
+    
+    VBOXCLIPBOARDCONTEXTX11 *pCtx = (VBOXCLIPBOARDCONTEXTX11 *)pUserData;
+
+    /* This might mean that we are getting stopped twice. */
+    Assert(pCtx->widget != NULL);
+
+    /* Set the termination flag to tell the Xt event loop to exit.  We
+     * reiterate that any outstanding requests from the X11 event loop to
+     * the VBox part *must* have returned before we do this. */
+    XtAppSetExitFlag(pCtx->appContext);
+    pCtx->fOwnsClipboard = false;
+    pCtx->X11TextFormat = INVALID;
+    pCtx->X11BitmapFormat = INVALID;
 }
 
@@ -721 +773 @@
                                    VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
     }
+    /* Create the pipes */
+    int pipes[2];
+    if (!pipe(pipes))
+    {
+        pCtx->wakeupPipeRead = pipes[0];
+        pCtx->wakeupPipeWrite = pipes[1];
+        XtAppAddInput(pCtx->appContext, pCtx->wakeupPipeRead,
+                      (XtPointer) XtInputReadMask, vboxClipboardStopWorker,
+                      (XtPointer) pCtx);
+    }
+    else
+        rc = RTErrConvertFromErrno(errno);
     if (RT_FAILURE(rc))
         vboxClipboardUninitX11(pCtx);
@@ -770 +834 @@
     LogRel(("Initializing X11 clipboard backend\n"));
     if (pCtx)
-    {
         pCtx->pFrontend = pFrontend;
-        RTSemEventCreate(&pCtx->waitForData);
-    }
     return pCtx;
 }
@@ -793 +854 @@
      * memory. */
     Assert(pCtx->widget == NULL);
-    RTSemEventDestroy(pCtx->waitForData);
 }
 
 /**
  * Announce to the X11 backend that we are ready to start.
- * @param  owner who is the initial clipboard owner
- */
-int VBoxX11ClipboardStartX11(VBOXCLIPBOARDCONTEXTX11 *pCtx,
-                             bool fOwnsClipboard)
+ */
+int VBoxX11ClipboardStartX11(VBOXCLIPBOARDCONTEXTX11 *pCtx)
 {
     int rc = VINF_SUCCESS;
@@ -821 +879 @@
     if (RT_SUCCESS(rc))
     {
-        if (fOwnsClipboard)
-        {
-            pCtx->eOwner = X11;
-            pCtx->notifyVBox = true;
-        }
-        else
-        {
-            /** @todo Check whether the guest gets a format announcement at
-              *       startup. */
-            pCtx->eOwner = NONE;
-            VBoxX11ClipboardAnnounceVBoxFormat(pCtx, 0);
-        }
+        pCtx->fOwnsClipboard = false;
+        pCtx->notifyVBox = true;
     }
     return rc;
 }
 
-/**
- * Called when the VBox may have fallen out of sync with the backend.
- * @note  X11 backend code
- */
-void VBoxX11ClipboardRequestSyncX11(VBOXCLIPBOARDCONTEXTX11 *pCtx)
-{
-    /*
-     * Immediately return if we are not connected to the host X server.
-     */
-    if (!g_fHaveX11)
-        return;
-    pCtx->notifyVBox = true;
-}
+/** String written to the wakeup pipe. */
+#define WAKE_UP_STRING      "WakeUp!"
+/** Length of the string written. */
+#define WAKE_UP_STRING_LEN  ( sizeof(WAKE_UP_STRING) - 1 )
 
 /**
@@ -863 +902 @@
     int rc, rcThread;
     unsigned count = 0;
-    XEvent ev;
     /*
      * Immediately return if we are not connected to the host X server.
@@ -870 +908 @@
         return VINF_SUCCESS;
 
-    /* This might mean that we are getting stopped twice. */
-    AssertReturn(pCtx->widget != NULL, VERR_WRONG_ORDER);
     LogRelFunc(("stopping the shared clipboard X11 backend\n"));
-
-    /* Set the termination flag to tell the Xt event loop to exit.  We
-     * reiterate that any outstanding requests from the X11 event loop to
-     * the VBox part *must* have returned before we do this. */
-    XtAppSetExitFlag(pCtx->appContext);
-    /* Wake up the event loop */
-    memset(&ev, 0, sizeof(ev));
-    ev.xclient.type = ClientMessage;
-    ev.xclient.format = 8;
-    XSendEvent(XtDisplay(pCtx->widget), XtWindow(pCtx->widget), false, 0, &ev);
-    XFlush(XtDisplay(pCtx->widget));
-    pCtx->eOwner = NONE;
-    pCtx->X11TextFormat = INVALID;
-    pCtx->X11BitmapFormat = INVALID;
+    /* Write to the "stop" pipe */
+    rc = write(pCtx->wakeupPipeWrite, WAKE_UP_STRING, WAKE_UP_STRING_LEN);
     do
     {
@@ -965 +989 @@
     *piFormatReturn = 32;
     return true;
+}
+
+/** This is a wrapper around VBoxX11ClipboardReadVBoxData that will cache the
+ * data returned.  This is unfortunately necessary, because if the other side
+ * of the shared clipboard is also an X11 system, it may send a format
+ * announcement message every time its clipboard is read, for reasons that
+ * are explained elsewhere.  Unfortunately, some applications on our side
+ * like to read the clipboard several times in short succession in different
+ * formats.  This can fail if it collides with a format announcement message.
+ * @todo any ideas about how to do this better are welcome.
+ */
+static int vboxClipboardReadVBoxData (VBOXCLIPBOARDCONTEXTX11 *pCtx,
+                               uint32_t u32Format, void **ppv,
+                               uint32_t *pcb)
+{
+    int rc = VINF_SUCCESS;
+    LogFlowFunc(("pCtx=%p, u32Format=%02X, ppv=%p, pcb=%p\n", pCtx,
+                 u32Format, ppv, pcb));
+    if (u32Format == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+    {
+        if (pCtx->pvUnicodeCache == NULL)
+            rc = VBoxX11ClipboardReadVBoxData(pCtx->pFrontend, u32Format,
+                                              &pCtx->pvUnicodeCache,
+                                              &pCtx->cbUnicodeCache);
+        if (RT_SUCCESS(rc))
+        {
+            *ppv = RTMemDup(pCtx->pvUnicodeCache, pCtx->cbUnicodeCache);
+            *pcb = pCtx->cbUnicodeCache;
+            if (*ppv == NULL)
+                rc = VERR_NO_MEMORY;
+        }
+    }
+    else
+        rc = VBoxX11ClipboardReadVBoxData(pCtx->pFrontend, u32Format,
+                                          ppv, pcb);
+    LogFlowFunc(("returning %Rrc\n", rc));
+    if (RT_SUCCESS(rc))
+        LogFlowFunc(("*ppv=%.*ls, *pcb=%u\n", *pcb, *ppv, *pcb));
+    return rc;
 }
 
@@ -1004 +1067 @@
     LogFlowFunc (("called\n"));
     /* Read the clipboard data from the guest. */
-    rc = VBoxX11ClipboardReadVBoxData(pCtx->pFrontend, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT, &pvVBox, &cbVBox);
+    rc = vboxClipboardReadVBoxData(pCtx,
+                                   VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT,
+                                   &pvVBox, &cbVBox);
     if ((rc != VINF_SUCCESS) || (cbVBox == 0))
     {
-        /* If VBoxX11ClipboardReadVBoxData fails then pClient may be invalid */
-        LogRelFunc (("VBoxX11ClipboardReadVBoxData returned %Rrc%s\n", rc,
+        /* If vboxClipboardReadVBoxData fails then we may be terminating */
+        LogRelFunc (("vboxClipboardReadVBoxData returned %Rrc%s\n", rc,
                      RT_SUCCESS(rc) ? ", cbVBox == 0" :  ""));
         RTMemFree(pvVBox);
@@ -1113 +1178 @@
     LogFlowFunc (("called\n"));
     /* Read the clipboard data from the guest. */
-    rc = VBoxX11ClipboardReadVBoxData(pCtx->pFrontend, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT, &pvVBox, &cbVBox);
+    rc = vboxClipboardReadVBoxData(pCtx,
+                                   VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT,
+                                   &pvVBox, &cbVBox);
     if ((rc != VINF_SUCCESS) || (cbVBox == 0))
     {
-        /* If VBoxX11ClipboardReadVBoxData fails then pClient may be invalid */
-        LogRelFunc (("VBoxX11ClipboardReadVBoxData returned %Rrc%s\n", rc,
+        /* If vboxClipboardReadVBoxData fails then we may be terminating */
+        LogRelFunc (("vboxClipboardReadVBoxData returned %Rrc%s\n", rc,
                       RT_SUCCESS(rc) ? ", cbVBox == 0" :  ""));
         RTMemFree(pvVBox);
@@ -1219 +1286 @@
     LogFlowFunc(("\n"));
     /* Drop requests that we receive too late. */
-    if (pCtx->eOwner != VB)
+    if (!pCtx->fOwnsClipboard)
         return false;
     if (   (*atomSelection != pCtx->atomClipboard)
@@ -1285 +1352 @@
 {
     VBOXCLIPBOARDCONTEXTX11 *pCtx = vboxClipboardFindContext(widget);
-    LogFlowFunc (("called, giving VBox clipboard ownership\n"));
-    pCtx->eOwner = X11;
+    LogFlowFunc (("called, giving X11 clipboard ownership\n"));
+    /* These should be set to the right values as soon as we start polling */
+    pCtx->X11TextFormat = INVALID;
+    pCtx->X11BitmapFormat = INVALID;
+    pCtx->fOwnsClipboard = false;
     pCtx->notifyVBox = true;
+}
+
+/** Structure used to pass information about formats that VBox supports */
+typedef struct _VBOXCLIPBOARDFORMATS
+{
+    /** Context information for the X11 clipboard */
+    VBOXCLIPBOARDCONTEXTX11 *pCtx;
+    /** Formats supported by VBox */
+    uint32_t formats;
+} VBOXCLIPBOARDFORMATS;
+
+/** Worker function for VBoxX11ClipboardAnnounceVBoxFormat which runs on the
+ * event thread. */
+static void vboxClipboardAnnounceWorker(XtPointer pUserData,
+                                        XtIntervalId * /* interval */)
+{
+    /* Extract and free the user data */
+    VBOXCLIPBOARDFORMATS *pFormats = (VBOXCLIPBOARDFORMATS *)pUserData;
+    VBOXCLIPBOARDCONTEXTX11 *pCtx = pFormats->pCtx;
+    uint32_t u32Formats = pFormats->formats;
+    RTMemFree(pFormats);
+    LogFlowFunc (("u32Formats=%d\n", u32Formats));
+    pCtx->vboxFormats = u32Formats;
+    /* Invalidate the clipboard cache */
+    if (pCtx->pvUnicodeCache != NULL)
+    {
+        RTMemFree(pCtx->pvUnicodeCache);
+        pCtx->pvUnicodeCache = NULL;
+    }
+    if (u32Formats == 0)
+    {
+        /* This is just an automatism, not a genuine anouncement */
+        XtDisownSelection(pCtx->widget, pCtx->atomClipboard, CurrentTime);
+        pCtx->fOwnsClipboard = false;
+        LogFlowFunc(("returning\n"));
+        return;
+    }
+    Log2 (("%s: giving the guest clipboard ownership\n", __PRETTY_FUNCTION__));
+    if (XtOwnSelection(pCtx->widget, pCtx->atomClipboard, CurrentTime,
+                       vboxClipboardConvertForX11, vboxClipboardReturnToX11,
+                       0) == True)
+    {
+        pCtx->fOwnsClipboard = true;
+        /* Grab the middle-button paste selection too. */
+        XtOwnSelection(pCtx->widget, pCtx->atomPrimary, CurrentTime,
+                       vboxClipboardConvertForX11, NULL, 0);
+    }
+    else
+    {
+        /* Another X11 client claimed the clipboard just after us, so let it
+         * go again. */
+        Log2 (("%s: returning clipboard ownership to the X11\n",
+               __PRETTY_FUNCTION__));
+        /* VBox thinks it currently owns the clipboard, so we must notify it
+         * as soon as we know what formats X11 has to offer. */
+        pCtx->notifyVBox = true;
+        pCtx->fOwnsClipboard = false;
+    }
+    LogFlowFunc(("returning\n"));
 }
 
@@ -1304 +1433 @@
     if (!g_fHaveX11)
         return;
-
-    LogFlowFunc (("u32Formats=%d\n", u32Formats));
-    pCtx->vboxFormats = u32Formats;
-    if (u32Formats == 0)
-    {
-        /* This is just an automatism, not a genuine anouncement */
-        XtDisownSelection(pCtx->widget, pCtx->atomClipboard, CurrentTime);
-        pCtx->eOwner = NONE;
-        LogFlowFunc(("returning\n"));
-        return;
-    }
-    Log2 (("%s: giving the guest clipboard ownership\n", __PRETTY_FUNCTION__));
-    pCtx->eOwner = VB;
-    pCtx->X11TextFormat = INVALID;
-    pCtx->X11BitmapFormat = INVALID;
-    if (XtOwnSelection(pCtx->widget, pCtx->atomClipboard, CurrentTime,
-                       vboxClipboardConvertForX11, vboxClipboardReturnToX11,
-                       0) != True)
-    {
-        Log2 (("%s: returning clipboard ownership to the host\n", __PRETTY_FUNCTION__));
-        /* We set this so that the guest gets notified when we take the clipboard, even if no
-          guest formats are found which we understand. */
-        pCtx->notifyVBox = true;
-        pCtx->eOwner = X11;
-    }
-    XtOwnSelection(pCtx->widget, pCtx->atomPrimary, CurrentTime, vboxClipboardConvertForX11,
-                   NULL, 0);
-    LogFlowFunc(("returning\n"));
-
+    /* This must be freed by the worker callback */
+    VBOXCLIPBOARDFORMATS *pFormats =
+        (VBOXCLIPBOARDFORMATS *) RTMemAlloc(sizeof(VBOXCLIPBOARDFORMATS));
+    if (pFormats != NULL)  /* if it is we will soon have other problems */
+    {
+        pFormats->pCtx = pCtx;
+        pFormats->formats = u32Formats;
+        XtAppAddTimeOut(pCtx->appContext, 0, vboxClipboardAnnounceWorker,
+                        (XtPointer) pFormats);
+    }
+}
+
+/** Worker function for VBoxX11ClipboardReadX11Data which runs on the event
+ * thread. */
+static void vboxClipboardReadX11Worker(XtPointer pUserData,
+                                       XtIntervalId * /* interval */)
+{
+    VBOXCLIPBOARDREQUEST *pRequest = (VBOXCLIPBOARDREQUEST *)pUserData;
+    VBOXCLIPBOARDCONTEXTX11 *pCtx = pRequest->pCtx;
+    LogFlowFunc (("u32Format = %d, cb = %d\n", pRequest->format,
+                  pRequest->cb));
+
+    int rc = VINF_SUCCESS;
+    /* Set this to start with, just in case */
+    *pRequest->pcbActual = 0;
+    /* Do not continue if we already own the clipboard */
+    if (pCtx->fOwnsClipboard == true)
+        rc = VERR_NO_DATA;  /** @todo should this be VINF? */
+    else
+    {
+        /*
+         * VBox wants to read data in the given format.
+         */
+        if (pRequest->format == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+        {
+            if (pCtx->atomX11TextFormat == None)
+                /* 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 */
+                XtGetSelectionValue(pCtx->widget, pCtx->atomClipboard,
+                                    pCtx->atomX11TextFormat,
+                                    vboxClipboardGetDataFromX11,
+                                    reinterpret_cast<XtPointer>(pRequest),
+                                    CurrentTime);
+        }
+        else
+            rc = VERR_NOT_IMPLEMENTED;
+    }
+    if (RT_FAILURE(rc))
+    {
+        pRequest->rc = rc;
+        /* The clipboard callback was never scheduled, so we must signal
+         * that the request processing is finished ourselves. */
+        RTSemEventSignal(pRequest->finished);
+    }
+    LogFlowFunc(("status %Rrc\n", rc));
 }
 
@@ -1346 +1504 @@
  */
 int VBoxX11ClipboardReadX11Data(VBOXCLIPBOARDCONTEXTX11 *pCtx,
-                                uint32_t u32Format,
-                                VBOXCLIPBOARDREQUEST *pRequest)
-{
+                                uint32_t u32Format, void *pv, uint32_t cb,
+                                uint32_t *pcbActual)
+{
+    /* Initially set the size of the data read to zero in case we fail
+     * somewhere or X11 is not available. */
+    *pcbActual = 0;
+
     /*
      * Immediately return if we are not connected to the host X server.
      */
     if (!g_fHaveX11)
-    {
-        /* no data available */
-        *pRequest->pcbActual = 0;
-        pRequest->rc = VINF_SUCCESS;
         return VINF_SUCCESS;
-    }
-
-    LogFlowFunc (("u32Format = %d, cb = %d\n", u32Format, pRequest->cb));
-    pRequest->rc = VERR_WRONG_ORDER;
-
-    /*
-     * VBox wants to read data in the given format.
-     */
-    if (u32Format == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
-    {
-        if (pCtx->X11TextFormat == INVALID)
-        {
-            /* No data available. */
-            *pRequest->pcbActual = 0;
-            return VERR_NO_DATA;  /* VBox thinks we have data and we don't */
-        }
-        /* Initially set the size of the data read to zero in case we fail
-         * somewhere. */
-        *pRequest->pcbActual = 0;
-        /* Send out a request for the data to the current clipboard owner */
-        XtGetSelectionValue(pCtx->widget, pCtx->atomClipboard,
-                            pCtx->atomX11TextFormat,
-                            vboxClipboardGetDataFromX11,
-                            reinterpret_cast<XtPointer>(pRequest),
-                            CurrentTime);
-        /* When the data arrives, the vboxClipboardGetDataFromX11 callback
-        * will be called.  The callback will signal the event semaphore when
-        * it has processed the data for us. */
-
-        int rc = RTSemEventWait(pCtx->waitForData, RT_INDEFINITE_WAIT);
-        if (RT_FAILURE(rc))
-            return rc;
-    }
-    else
-    {
-        return VERR_NOT_IMPLEMENTED;
-    }
-    LogFlowFunc(("returning %Rrc\n", pRequest->rc));
-    return pRequest->rc;
+
+    VBOXCLIPBOARDREQUEST request;
+    request.rc = VERR_WRONG_ORDER;
+    request.pv = pv;
+    request.cb = cb;
+    request.pcbActual = pcbActual;
+    request.format = u32Format;
+    request.pCtx = pCtx;
+    /* The worker function will signal this when it has finished. */
+    int rc = RTSemEventCreate(&request.finished);
+    if (RT_SUCCESS(rc))
+    {
+        /* We use this to schedule a worker function on the event thread. */
+        XtAppAddTimeOut(pCtx->appContext, 0, vboxClipboardReadX11Worker,
+                        (XtPointer) &request);
+        rc = RTSemEventWait(request.finished, RT_INDEFINITE_WAIT);
+        if (RT_SUCCESS(rc))
+            rc = request.rc;
+        RTSemEventDestroy(request.finished);
+    }
+    return rc;
 }
 
@@ -1529 +1669 @@
     char pc[256];
     uint32_t cbActual;
-    VBOXCLIPBOARDREQUEST request = {(void *) pc, sizeof(pc),
-                                    &cbActual, VINF_SUCCESS, g_pCtxTestX11};
     RTPrintf("tstClipboardX11:  TESTING a request for an invalid data format\n");
-    int rc = VBoxX11ClipboardReadX11Data(g_pCtxTestX11,
-                                         0xffff, &request);
+    int rc = VBoxX11ClipboardReadX11Data(g_pCtxTestX11, 0xffff, (void *) pc,
+                                         sizeof(pc), &cbActual);
     RTPrintf("Returned %Rrc - %s\n", rc,
              rc == VERR_NOT_IMPLEMENTED ? "SUCCESS" : "FAILURE");
@@ -1539 +1677 @@
         fSuccess = false;
     RTPrintf("tstClipboardX11:  TESTING a request for data from an empty clipboard\n");
+    VBoxX11ClipboardAnnounceVBoxFormat(g_pCtxTestX11,
+                                      VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
+    VBoxX11ClipboardAnnounceVBoxFormat(g_pCtxTestX11,
+                                       0);
     rc = VBoxX11ClipboardReadX11Data(g_pCtxTestX11,
-                         VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT, &request);
+                                     VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT,
+                                     (void *) pc, sizeof(pc), &cbActual);
     RTPrintf("Returned %Rrc - %s\n", rc,
              rc == VERR_NO_DATA ? "SUCCESS" : "FAILURE");
@@ -1557 +1700 @@
     char pc[256];
     uint32_t cbActual;
-    VBOXCLIPBOARDREQUEST request = {(void *) pc, pData->cchBuffer,
-                                    &cbActual, VINF_SUCCESS, g_pCtxTestX11};
     for (int i = 0; (i < MAX_ATTEMPTS) && !fSuccess; ++i)
     {
+        VBoxX11ClipboardAnnounceVBoxFormat(g_pCtxTestVBox,
+                                      VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
         int rc = VBoxX11ClipboardReadX11Data(g_pCtxTestX11,
-                        VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT, &request);
-        AssertReturn(RT_SUCCESS(rc), 1);
+                        VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT,
+                                             (void *) pc, sizeof(pc),
+                                             &cbActual);
+        AssertRCReturn(rc, 1);
         /* Did we expect and get an overflow? */
         if (   RT_SUCCESS(rc)
@@ -1596 +1741 @@
     int rc = VINF_SUCCESS;
     int status = 0;
-    /* We can't reasonably test anything without an X session, so just
-     * continue. */
+    /* We can't test anything without an X session, so just return success
+     * in that case. */
     if (!RTEnvGet("DISPLAY"))
         return 0;
-    g_debugClipboard = true;
     RTR3Init();
     g_pCtxTestX11 = VBoxX11ClipboardConstructX11(NULL);
     g_pCtxTestVBox =
         VBoxX11ClipboardConstructX11((VBOXCLIPBOARDCONTEXT *)g_pCtxTestX11);
-    rc = VBoxX11ClipboardStartX11(g_pCtxTestVBox, false);
+    rc = VBoxX11ClipboardStartX11(g_pCtxTestVBox);
     AssertRCReturn(rc, 1);
     bool fSuccess = false;
@@ -1612 +1756 @@
     for (unsigned i = 0; (i < MAX_ATTEMPTS) && !fSuccess; ++i)
     {
-        rc = VBoxX11ClipboardStartX11(g_pCtxTestX11, false);
+        rc = VBoxX11ClipboardStartX11(g_pCtxTestX11);
         AssertRCReturn(rc, 1);
         fSuccess = testInvalid();
@@ -1624 +1768 @@
     if (!fSuccess)
         status = 1;
-    rc = VBoxX11ClipboardStartX11(g_pCtxTestX11, true);
+    rc = VBoxX11ClipboardStartX11(g_pCtxTestX11);
     AssertRCReturn(rc, 1);
     /* Claim the clipboard and make sure we get it */
@@ -1657 +1801 @@
         char pc[256];
         uint32_t cbActual;
-        VBOXCLIPBOARDREQUEST request = {(void *) pc, sizeof(pc),
-                                        &cbActual, VINF_SUCCESS,
-                                        g_pCtxTestX11};
+        VBoxX11ClipboardAnnounceVBoxFormat(g_pCtxTestVBox,
+                                      VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
         rc = VBoxX11ClipboardReadX11Data(g_pCtxTestX11,
-                    VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT, &request);
+                    VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT,
+                                         (void *) pc, sizeof(pc), &cbActual);
         AssertMsg(   RT_SUCCESS(rc)
                   || (rc == VERR_TIMEOUT)

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

@@ -21 +21 @@
  */
 
+#define LOG_GROUP LOG_GROUP_SHARED_CLIPBOARD
+
 #include <string.h>
 
-#include <iprt/asm.h>        /* For atomic operations */
 #include <iprt/assert.h>
+#include <iprt/critsect.h>
 #include <iprt/mem.h>
 #include <iprt/semaphore.h>
@@ -32 +34 @@
 
 #include "VBoxClipboard.h"
+
+/** A request for clipboard data from VBox */
+typedef struct _VBOXCLIPBOARDREQFROMVBOX
+{
+    /** Data received */
+    void *pv;
+    /** The size of the data */
+    uint32_t cb;
+    /** Format of the data */
+    uint32_t format;
+    /** A semaphore for waiting for the data */
+    RTSEMEVENT finished;
+} VBOXCLIPBOARDREQFROMVBOX;
 
 /** Global context information used by the host glue for the X11 clipboard
@@ -37 +52 @@
 struct _VBOXCLIPBOARDCONTEXT
 {
-    /** Since the clipboard data moves asynchronously, we use an event
-     * semaphore to wait for it.  When a function issues a request for
-     * clipboard data it must wait for this semaphore, which is triggered
-     * when the data arrives. */
-    RTSEMEVENT waitForData;
-    /** Who (if anyone) is currently waiting for data?  Used for sanity
-     * checks when data arrives. */
-    volatile uint32_t waiter;
     /** This mutex is grabbed during any critical operations on the clipboard
      * which might clash with others. */
-    RTSEMMUTEX clipboardMutex;
-
+    RTCRITSECT clipboardMutex;
+    /** The currently pending request for data from VBox.  NULL if there is
+     * no request pending.  The protocol for completing a request is to grab
+     * the critical section, check that @a pReq is not NULL, fill in the data
+     * fields and set @a pReq to NULL.  The protocol for cancelling a pending
+     * request is to grab the critical section and set pReq to NULL.
+     * It is an error if a request arrives while another one is pending, and
+     * the backend is responsible for ensuring that this does not happen. */
+    VBOXCLIPBOARDREQFROMVBOX *pReq;
+    
     /** Pointer to the opaque X11 backend structure */
     VBOXCLIPBOARDCONTEXTX11 *pBackend;
-    /** Pointer to the client data structure */
+    /** Pointer to the VBox host client data structure. */
     VBOXCLIPBOARDCLIENTDATA *pClient;
+    /** We set this when we start shutting down as a hint not to post any new
+     * requests. */
+    bool fShuttingDown;
 };
 
-/* Only one client is supported. There seems to be no need for more clients. 
- */
-static VBOXCLIPBOARDCONTEXT g_ctxHost;
+static int vboxClipboardWaitForReq(VBOXCLIPBOARDCONTEXT *pCtx,
+                                   VBOXCLIPBOARDREQFROMVBOX *pReq,
+                                   uint32_t u32Format)
+{
+    int rc = VINF_SUCCESS;
+    LogFlowFunc(("pCtx=%p, pReq=%p, u32Format=%02X\n", pCtx, pReq, u32Format));
+    /* Request data from VBox */
+    vboxSvcClipboardReportMsg(pCtx->pClient,
+                              VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
+                              u32Format);
+    /* Which will signal us when it is ready.  We use a timeout here
+     * because we can't be sure that the guest will behave correctly.
+     */
+    rc = RTSemEventWait(pReq->finished, CLIPBOARD_TIMEOUT);
+    /* If the request hasn't yet completed then we cancel it.  We use
+     * the critical section to prevent these operations colliding. */
+    RTCritSectEnter(&pCtx->clipboardMutex);
+    /* The data may have arrived between the semaphore timing out and
+     * our grabbing the mutex. */
+    if (rc == VERR_TIMEOUT && pReq->pv != NULL)
+        rc = VINF_SUCCESS;
+    if (pCtx->pReq == pReq)
+        pCtx->pReq = NULL;
+    Assert(pCtx->pReq == NULL);
+    RTCritSectLeave(&pCtx->clipboardMutex);
+    LogFlowFunc(("returning %Rrc\n", rc));
+    return rc;
+}
+
+/** Post a request for clipboard data to VBox/the guest and wait for it to be
+ * completed. */
+static int vboxClipboardPostAndWaitForReq(VBOXCLIPBOARDCONTEXT *pCtx,
+                                          VBOXCLIPBOARDREQFROMVBOX *pReq,
+                                          uint32_t u32Format)
+{
+    int rc = VINF_SUCCESS;
+    LogFlowFunc(("pCtx=%p, pReq=%p, u32Format=%02X\n", pCtx, pReq,
+                 u32Format));
+    /* Start by "posting" the request for the next invocation of
+     * vboxClipboardWriteData. */
+    RTCritSectEnter(&pCtx->clipboardMutex);
+    if (pCtx->pReq != NULL)
+    {
+        /* This would be a violation of the protocol, see the comments in the
+         * context structure definition. */
+        Assert(false);
+        rc = VERR_WRONG_ORDER;
+    }
+    else
+        pCtx->pReq = pReq;
+    RTCritSectLeave(&pCtx->clipboardMutex);
+    if (RT_SUCCESS(rc))
+        rc = vboxClipboardWaitForReq(pCtx, pReq, u32Format);
+    LogFlowFunc(("returning %Rrc\n", rc));
+    return rc;
+}
 
 /**
@@ -74 +145 @@
                                    uint32_t *pcb)
 {
-    volatile VBOXCLIPBOARDCLIENTDATA *pClient = pCtx->pClient;
-
-    LogFlowFunc(("u32Format=%02X\n", u32Format));
-    /* Zero our output parameters */
-    *ppv = NULL;
-    *pcb = 0;
-    if (pClient == NULL)
-    {
-        /* This can legitimately happen if we disconnect during a request for
-         * data from X11. */
+    VBOXCLIPBOARDREQFROMVBOX request = { NULL };
+
+    LogFlowFunc(("pCtx=%p, u32Format=%02X, ppv=%p, pcb=%p\n", pCtx,
+                 u32Format, ppv, pcb));
+    if (pCtx->fShuttingDown)
+    {
+        /* The shared clipboard is disconnecting. */
         LogFunc(("host requested guest clipboard data after guest had disconnected.\n"));
-        VBoxX11ClipboardAnnounceVBoxFormat(pCtx->pBackend, 0);
-        pCtx->waiter = NONE;
-        return VERR_TIMEOUT;
-    }
-    /* Assert that no other transfer is in process (requests are serialised)
-     * and that the last transfer cleaned up properly. */
-    AssertLogRelReturn(   pClient->data.pv == NULL
-                       && pClient->data.cb == 0
-                       && pClient->data.u32Format == 0,
-                       VERR_WRONG_ORDER
-                      );
-    /* No one else (X11 or VBox) should currently be waiting.  The first because
-     * requests from X11 are serialised and the second because VBox previously
-     * grabbed the clipboard, so it should not be waiting for data from us. */
-    AssertLogRelReturn (ASMAtomicCmpXchgU32(&pCtx->waiter, X11, NONE), VERR_DEADLOCK);
-    /* Request data from VBox */
-    vboxSvcClipboardReportMsg(pCtx->pClient,
-                              VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
-                              u32Format);
-    /* Which will signal us when it is ready.  We use a timeout here because
-     * we can't be sure that the guest will behave correctly. */
-    int rc = RTSemEventWait(pCtx->waitForData, CLIPBOARDTIMEOUT);
-    if (rc == VERR_TIMEOUT)
-        rc = VINF_SUCCESS;  /* Timeout handling follows. */
-    /* Now we have a potential race between the HGCM thread delivering the data
-     * and our setting waiter to NONE to say that we are no longer waiting for
-     * it.  We solve this as follows: both of these operations are done under
-     * the clipboard mutex.  The HGCM thread will only deliver the data if we
-     * are still waiting after it acquires the mutex.  After we release the
-     * mutex, we finally do our check to see whether the data was delivered. */
-    RTSemMutexRequest(g_ctxHost.clipboardMutex, RT_INDEFINITE_WAIT);
-    pCtx->waiter = NONE;
-    RTSemMutexRelease(g_ctxHost.clipboardMutex);
-    AssertLogRelRCSuccess(rc);
-    if (RT_FAILURE(rc))
-    {
-        /* I believe this should not happen.  Wait until the assertions arrive
-         * to prove the contrary. */
-        RTMemFree(pClient->data.pv);
-        g_ctxHost.pClient->data.pv = 0;
-        g_ctxHost.pClient->data.cb = 0;
-        g_ctxHost.pClient->data.u32Format = 0;
-        vboxClipboardFormatAnnounce(NULL, 0);
-        return rc;
-    }
-    if (pClient->data.pv == NULL)
-        return VERR_TIMEOUT;
-    LogFlowFunc(("wait completed.  Returning.\n"));
-    *ppv = pClient->data.pv;
-    *pcb = pClient->data.cb;
-    g_ctxHost.pClient->data.pv = 0;
-    g_ctxHost.pClient->data.cb = 0;
-    g_ctxHost.pClient->data.u32Format = 0;
-    return VINF_SUCCESS;
+        return VERR_WRONG_ORDER;
+    }
+    int rc = RTSemEventCreate(&request.finished);
+    if (RT_SUCCESS(rc))
+    {
+        rc = vboxClipboardPostAndWaitForReq(pCtx, &request,
+                                            u32Format);
+        RTSemEventDestroy(request.finished);
+    }
+    if (RT_SUCCESS(rc))
+    {
+        *ppv = request.pv;
+        *pcb = request.cb;
+    }
+    LogFlowFunc(("returning %Rrc\n", rc));
+    if (RT_SUCCESS(rc))
+        LogFlowFunc(("*ppv=%.*ls, *pcb=%u\n", *pcb / 2, *ppv, *pcb));
+    return rc;
 }
 
@@ -150 +182 @@
                                       uint32_t u32Formats)
 {
+    LogFlowFunc(("called.  pCtx=%p, u32Formats=%02X\n", pCtx, u32Formats));
     vboxSvcClipboardReportMsg(pCtx->pClient,
                               VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS,
@@ -161 +194 @@
 int vboxClipboardInit (void)
 {
-    int rc = VINF_SUCCESS;
-    VBOXCLIPBOARDCONTEXTX11 *pBackend = NULL;
-
-    LogRel(("Initializing host clipboard service\n"));
-    RTSemEventCreate(&g_ctxHost.waitForData);
-    RTSemMutexCreate(&g_ctxHost.clipboardMutex);
-    pBackend = VBoxX11ClipboardConstructX11(&g_ctxHost);
-    if (pBackend == NULL)
-    {
-        RTSemEventDestroy(g_ctxHost.waitForData);
-        RTSemMutexDestroy(g_ctxHost.clipboardMutex);
-        LogRel(("Failed to start the host shared clipboard service, out of memory.\n"));
-        rc = VERR_NO_MEMORY;
-    }
-    else
-        g_ctxHost.pBackend = pBackend;
-    return rc;
+    return VINF_SUCCESS;
 }
 
@@ -186 +203 @@
 void vboxClipboardDestroy (void)
 {
-    int rc = VINF_SUCCESS;
-    LogRelFunc(("shutting down host clipboard\n"));
-    VBoxX11ClipboardDestructX11(g_ctxHost.pBackend);
-    /* We can safely destroy these as the backend has exited
-     * successfully and no other calls from the host code should be
-     * forthcoming. */
-    RTSemEventDestroy(g_ctxHost.waitForData);
-    RTSemMutexDestroy(g_ctxHost.clipboardMutex);
+
 }
 
@@ -205 +215 @@
 {
     int rc = VINF_SUCCESS;
-    LogFlowFunc(("\n"));
-    /* Only one client is supported for now */
-    AssertLogRelReturn(g_ctxHost.pClient == 0, VERR_NOT_SUPPORTED);
-    pClient->pCtx = &g_ctxHost;
-    pClient->pCtx->pClient = pClient;
-    /** The pClient pointer is a dummy anyway, as we only support a single
-     * client at a time. */
-    rc = VBoxX11ClipboardStartX11(g_ctxHost.pBackend,
-                                  true /* fOwnClipboard */);
+    VBOXCLIPBOARDCONTEXTX11 *pBackend = NULL;
+
+    LogRel(("Starting host clipboard service\n"));
+    VBOXCLIPBOARDCONTEXT *pCtx =
+        (VBOXCLIPBOARDCONTEXT *) RTMemAllocZ(sizeof(VBOXCLIPBOARDCONTEXT));
+    if (!pCtx)
+        rc = VERR_NO_MEMORY;
+    else
+    {
+        RTCritSectInit(&pCtx->clipboardMutex);
+        pBackend = VBoxX11ClipboardConstructX11(pCtx);
+        if (pBackend == NULL)
+            rc = VERR_NO_MEMORY;
+        else
+        {
+            pCtx->pBackend = pBackend;
+            pClient->pCtx = pCtx;
+            pCtx->pClient = pClient;
+            rc = VBoxX11ClipboardStartX11(pBackend);
+        }
+        if (RT_FAILURE(rc) && pBackend)
+            VBoxX11ClipboardStopX11(pCtx->pBackend);
+        if (RT_FAILURE(rc))
+            RTCritSectDelete(&pCtx->clipboardMutex);
+    }
+    if (RT_FAILURE(rc))
+    {
+        RTMemFree(pCtx);
+        LogRel(("Failed to initialise the shared clipboard\n"));
+    }
+    LogFlowFunc(("returning %Rrc\n", rc));
     return rc;
 }
@@ -224 +256 @@
 int vboxClipboardSync (VBOXCLIPBOARDCLIENTDATA *pClient)
 {
-
-    /* On a Linux host, the guest should never synchronise/cache its
-     * clipboard contents, as we have no way of reliably telling when the
-     * host clipboard data changes.  So instead of synchronising, we tell
-     * the guest to empty its clipboard, and we set the cached flag so that
-     * we report formats to the guest next time we poll for them. */
-    /** @note  This has been changed so that the message is sent even if
-     *         X11 is not available. */
-    vboxSvcClipboardReportMsg (g_ctxHost.pClient,
+    /* Tell the guest we have no data in case X11 is not available.  If
+     * there is data in the host clipboard it will automatically be sent to
+     * the guest when the clipboard starts up. */
+    vboxSvcClipboardReportMsg (pClient,
                                VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS, 0);
-    VBoxX11ClipboardRequestSyncX11(g_ctxHost.pBackend);
-
     return VINF_SUCCESS;
 }
@@ -243 +268 @@
  * @note  Host glue code
  */
-void vboxClipboardDisconnect (VBOXCLIPBOARDCLIENTDATA *)
+void vboxClipboardDisconnect (VBOXCLIPBOARDCLIENTDATA *pClient)
 {
     LogFlow(("vboxClipboardDisconnect\n"));
 
-    RTSemMutexRequest(g_ctxHost.clipboardMutex, RT_INDEFINITE_WAIT);
+    LogRel(("Stopping the host clipboard service\n"));
+    VBOXCLIPBOARDCONTEXT *pCtx = pClient->pCtx;
     /* Drop the reference to the client, in case it is still there.  This
      * will cause any outstanding clipboard data requests from X11 to fail
      * immediately. */
-    g_ctxHost.pClient = NULL;
-    /* The backend may be waiting for data from VBox.  At this point it is no
-     * longer going to arrive, and we must release it to allow the event
-     * loop to terminate.  In this case the buffer where VBox would have
-     * written the clipboard data will still be empty and we will just
-     * return "no data" to the backend.  Any subsequent attempts to get the
-     * data from VBox will fail immediately as the client reference is gone.
-     */
-    /** @note  This has been made unconditional, as it should do no harm
-     *         even if we are not waiting. */
-    RTSemEventSignal(g_ctxHost.waitForData);
-    int rc = VBoxX11ClipboardStopX11(g_ctxHost.pBackend);
+    pCtx->fShuttingDown = true;
+    /* If there is a currently pending request, release it immediately. */
+    vboxClipboardWriteData(pClient, NULL, 0, 0);
+    int rc = VBoxX11ClipboardStopX11(pCtx->pBackend);
     /** @todo handle this slightly more reasonably, or be really sure
      *        it won't go wrong. */
     AssertRC(rc);
-    RTSemMutexRelease(g_ctxHost.clipboardMutex);
+    if (RT_SUCCESS(rc))  /* And if not? */
+    {
+        VBoxX11ClipboardDestructX11(pCtx->pBackend);
+        RTCritSectDelete(&pCtx->clipboardMutex);
+        RTMemFree(pCtx);
+    }
 }
 
@@ -276 +299 @@
  * @note  Host glue code
  */
-void vboxClipboardFormatAnnounce (VBOXCLIPBOARDCLIENTDATA *pClient, uint32_t u32Formats)
-{
-    VBoxX11ClipboardAnnounceVBoxFormat (g_ctxHost.pBackend, u32Formats);
+void vboxClipboardFormatAnnounce (VBOXCLIPBOARDCLIENTDATA *pClient,
+                                  uint32_t u32Formats)
+{
+    LogFlowFunc(("called.  pClient=%p, u32Formats=%02X\n", pClient,
+                 u32Formats));
+    VBoxX11ClipboardAnnounceVBoxFormat (pClient->pCtx->pBackend, u32Formats);
 }
 
@@ -295 +321 @@
                            uint32_t *pcbActual)
 {
-    int rc = VINF_SUCCESS;
-    VBOXCLIPBOARDREQUEST request;
-    /* No one else (VBox or X11) should currently be waiting.  The first
-     * because requests from VBox are serialised and the second because X11
-     * previously grabbed the clipboard, so it should not be waiting for
-     * data from us. */
-    AssertLogRelReturn (ASMAtomicCmpXchgU32(&g_ctxHost.waiter, VB, NONE),
-                        VERR_DEADLOCK);
-    request.pv = pv;
-    request.cb = cb;
-    request.pcbActual = pcbActual;
-    request.pCtx = g_ctxHost.pBackend;
-    rc = VBoxX11ClipboardReadX11Data(g_ctxHost.pBackend, u32Format, &request);
-    g_ctxHost.waiter = NONE;
+    LogFlowFunc(("pClient=%p, u32Format=%02X, pv=%p, cb=%u, pcbActual=%p",
+                 pClient, u32Format, pv, cb, pcbActual));
+    int rc = VBoxX11ClipboardReadX11Data(pClient->pCtx->pBackend, u32Format,
+                                         pv, cb, pcbActual);
+    LogFlowFunc(("returning %Rrc\n", rc));
+    if (RT_SUCCESS(rc))
+        LogFlowFunc(("*pv=%.*ls, *pcbActual=%u\n", *pcbActual / 2, pv,
+                     *pcbActual));
     return rc;
 }
@@ -324 +344 @@
                              void *pv, uint32_t cb, uint32_t u32Format)
 {
-/* Assume that if this gets called at all then the X11 backend is running. */
-#if 0
-    if (!g_fHaveX11)
-        return;
-#endif
-
-    LogFlowFunc (("called\n"));
-
-    /* Assert that no other transfer is in process (requests are serialised)
-     * or has not cleaned up properly. */
-    AssertLogRelReturnVoid (   pClient->data.pv == NULL
-                            && pClient->data.cb == 0
-                            && pClient->data.u32Format == 0);
-
-    /* Grab the mutex and check that X11 is still waiting for the data before
-     * delivering it.  See the explanation in VBoxX11ClipboardReadVBoxData. */
-    RTSemMutexRequest(g_ctxHost.clipboardMutex, RT_INDEFINITE_WAIT);
-    if (g_ctxHost.waiter == X11 && cb > 0)
-    {
-        pClient->data.pv = RTMemAlloc (cb);
-
-        if (pClient->data.pv)
+    LogFlowFunc (("called.  pClient=%p, pv=%p (%.*ls), cb=%u, u32Format=%02X\n",
+                  pClient, pv, cb / 2, pv, cb, u32Format));
+
+    VBOXCLIPBOARDCONTEXT *pCtx = pClient->pCtx;
+    /* Grab the mutex and check whether there is a pending request for data.
+     */
+    RTCritSectEnter(&pCtx->clipboardMutex);
+    VBOXCLIPBOARDREQFROMVBOX *pReq = pCtx->pReq;
+    if (pReq != NULL)
+    {
+        if (cb > 0)
         {
-            memcpy (pClient->data.pv, pv, cb);
-            pClient->data.cb = cb;
-            pClient->data.u32Format = u32Format;
+            pReq->pv = RTMemDup(pv, cb);
+            if (pReq->pv != NULL)  /* NULL may also mean no memory... */
+            {
+                pReq->cb = cb;
+                pReq->format = u32Format;
+            }            
         }
-    }
-    RTSemMutexRelease(g_ctxHost.clipboardMutex);
-
-    RTSemEventSignal(g_ctxHost.waitForData);
-}
-
+        /* Signal that the request has been completed. */
+        RTSemEventSignal(pReq->finished);
+    }
+    pCtx->pReq = NULL;
+    RTCritSectLeave(&pCtx->clipboardMutex);
+}