Changeset 101878 in vbox

Timestamp:

Nov 6, 2023 3:36:24 PM (15 months ago)

Author:

vboxsync

Message:

Additions: X11/Wayland: Add initial support for clipboard sharing with Gnome and Plasma Wayland guests (not yet enabled), bugref:10194.

Location:

trunk

Files:

• include/VBox/GuestHost/clipboard-helper.h (modified) (1 diff)
• src/VBox/Additions/x11/VBoxClient/Makefile.kmk (modified) (7 diffs)
• src/VBox/Additions/x11/VBoxClient/VBoxClient.h (modified) (1 diff)
• src/VBox/Additions/x11/VBoxClient/main.cpp (modified) (1 diff)
• src/VBox/Additions/x11/VBoxClient/vboxwl.cpp (added)
• src/VBox/Additions/x11/VBoxClient/wayland-helper-dcp.cpp (modified) (6 diffs)
• src/VBox/Additions/x11/VBoxClient/wayland-helper-gtk.cpp (modified) (6 diffs)
• src/VBox/Additions/x11/VBoxClient/wayland-helper-ipc.cpp (added)
• src/VBox/Additions/x11/VBoxClient/wayland-helper-ipc.h (added)
• src/VBox/Additions/x11/VBoxClient/wayland-helper.cpp (added)
• src/VBox/Additions/x11/VBoxClient/wayland-helper.h (modified) (4 diffs)
• src/VBox/Additions/x11/VBoxClient/wayland.cpp (modified) (8 diffs)

trunk/include/VBox/GuestHost/clipboard-helper.h

@@ -44 +44 @@
 
 #include <VBox/GuestHost/SharedClipboard.h>
+
+/** Guest property which is set by GUI in order to notify guest about VM window focus change.  */
+#define VBOX_GUI_FOCUS_CHANGE_GUEST_PROP_NAME   "/VirtualBox/GuestAdd/GuiOnFocus"
 
 /** Constants needed for string conversions done by the Linux/Mac clipboard code. */

trunk/src/VBox/Additions/x11/VBoxClient/Makefile.kmk

@@ -48 +48 @@
 #
 PROGRAMS.linux += VBoxDRMClient
+
+ifdef VBOX_WITH_WAYLAND_ADDITIONS
+ PROGRAMS.linux += vboxwl
+endif
 
 # Common Guest / Host sources.
@@ -75 +79 @@
 ifdef VBOX_WITH_WAYLAND_ADDITIONS
  VBoxClient_DEFS += VBOX_WITH_WAYLAND_ADDITIONS
+ VBoxClient_INCS += ../wlInclude/
  VBoxClient_SOURCES += \
         wayland-helper-dcp.cpp \
         wayland-helper-gtk.cpp \
-        wayland.cpp
+        wayland-helper.cpp \
+        wayland.cpp \
+        wayland-helper-ipc.cpp \
+        ../wlInclude/wayland-protocol.c \
+        ../wlInclude/wlr-data-control-unstable-v1.c
 endif
 
@@ -117 +126 @@
  endif
 endif
+ifdef VBOX_WITH_WAYLAND_ADDITIONS
+ VBoxClient_LIBS.linux += glib-2.0
+ VBoxClient_LIBS.linux += gobject-2.0
+endif
 
 # XXX: -L comes from the template, but not rpath
@@ -185 +198 @@
         $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/clipboard-x11.cpp \
         clipboard.cpp \
+        clipboard-common.cpp \
         clipboard-x11.cpp
  ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
@@ -190 +204 @@
   VBoxClient_SOURCES += \
         $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/clipboard-transfers.cpp \
-        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardPath.cpp
+        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardPath.cpp \
+        $(PATH_ROOT)/src/VBox/GuestHost/common/mime-type-converter.cpp
   ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS_HTTP
    VBoxClient_DEFS    += VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS_HTTP
@@ -226 +241 @@
   VBOX_VBOXCLIENT_LIBXMU_VER = 6
   VBOX_VBOXCLIENT_LIBXRANDR_VER = 2
+  VBOX_VBOXCLIENT_LIBWAYLANDCLIENT_VER = 0
  endif
  ## Dynamic import no. 1: libX11.so
@@ -235 +251 @@
  ## Dynamic import no. 4: libXrandr.so
  $(evalcall2 def_libToLazyLoad,$(PATH_ROOT)/src/VBox/GuestHost/libXrandr.def,libXrandr,$(VBOX_VBOXCLIENT_LIBXRANDR_VER))
+ ## Dynamic import no. 5: libwayland-client.so
+ $(evalcall2 def_libToLazyLoad,$(PATH_ROOT)/src/VBox/GuestHost/libwayland-client.def,libwayland-client,$(VBOX_VBOXCLIENT_LIBWAYLANDCLIENT_VER))
+endif
+
+ifdef VBOX_WITH_WAYLAND_ADDITIONS
+ define def_libToLazyLoad2
+  vboxwl_SOURCES       += \
+        $$(vboxwl_0_OUTDIR)/$(2)LazyLoad.asm
+  vboxwl_CLEAN         += \
+        $$(vboxwl_0_OUTDIR)/$(2)LazyLoad.asm
+  $$$$(vboxwl_0_OUTDIR)/$(2)LazyLoad.asm: $$(PATH_ROOT)/src/VBox/GuestHost/$(2).def $(VBOX_DEF_2_LAZY_LOAD) | $$$$(dir $$@)
+        $$(call MSG_TOOL,VBoxDef2LazyLoad,$$(PATH_ROOT)/src/VBox/GuestHost/$(2).def,$$@)
+        $$(eval VBOX_VBOXWL_LIB_TO_LAZYLOAD_SUFF=$$$$(if $(3),$(SUFF_DLL).$(3),$(SUFF_DLL)))
+        $$(QUIET)$$(RM) -f -- "$$@"
+        $$(VBOX_DEF_2_LAZY_LOAD) --system --library $(2)$$(VBOX_VBOXWL_LIB_TO_LAZYLOAD_SUFF) --output "$$@" $$(PATH_ROOT)/src/VBox/GuestHost/$(2).def
+ endef
+
+ vboxwl_TEMPLATE = VBoxGuestR3Exe
+ vboxwl_DEFS += VBOX_WITH_SHARED_CLIPBOARD
+ ifdef VBOX_WITH_AUTOMATIC_DEFS_QUOTING
+  vboxwl_DEFS += VBOX_BUILD_TARGET="$(KBUILD_TARGET).$(KBUILD_TARGET_ARCH)"
+ else
+  vboxwl_DEFS += VBOX_BUILD_TARGET=\"$(KBUILD_TARGET).$(KBUILD_TARGET_ARCH)\"
+ endif
+ vboxwl_SOURCES = \
+        vboxwl.cpp \
+        logging.cpp \
+        clipboard-common.cpp \
+        wayland-helper-ipc.cpp \
+        wayland-helper.cpp \
+        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/clipboard-common.cpp \
+        $(PATH_ROOT)/src/VBox/GuestHost/common/mime-type-converter.cpp
+ vboxwl_SOURCES += $(VBOX_GH_SOURCES)
+
+ VBOX_VBOXWL_LIBWAYLANDCLIENT_VER = 0
+ VBOX_VBOXWL_LIBGTK3_VER = 0
+
+ ## Dynamic import no. 5: libwayland-client.so
+ $(evalcall2 def_libToLazyLoad2,$(PATH_ROOT)/src/VBox/GuestHost/libwayland-client.def,libwayland-client,$(VBOX_VBOXWL_LIBWAYLANDCLIENT_VER))
+ ## Dynamic import no. 6: libgtk-3.so
+ $(evalcall2 def_libToLazyLoad2,$(PATH_ROOT)/src/VBox/GuestHost/libgtk-3.def,libgtk-3,$(VBOX_VBOXWL_LIBGTK3_VER))
+
+ vboxwl_LIBS.linux += glib-2.0
+ vboxwl_LIBS.linux += gobject-2.0
+ vboxwl_LIBS.linux += gio-2.0
 endif
 

trunk/src/VBox/Additions/x11/VBoxClient/VBoxClient.h

@@ -38 +38 @@
 
 #include <VBox/GuestHost/DisplayServerType.h>
+
+/** A shortcut to log callback entering. */
+#define VBCL_LOG_CALLBACK VBClLogVerbose(3, "%s\n", __func__)
 
 int VBClShowNotify(const char *pszHeader, const char *pszBody);

trunk/src/VBox/Additions/x11/VBoxClient/main.cpp

@@ -206 +206 @@
 static void vboxClientSignalHandler(int iSignal)
 {
-    int rc = RTCritSectEnter(&g_csSignalHandler);
+    int rc;
+
+    /* On Wayland, SIGPIPE might be issued if compositor no longer wants
+     * to communicate. This should not be a reason for process termination. */
+    if (iSignal == SIGPIPE)
+        return;
+
+    rc = RTCritSectEnter(&g_csSignalHandler);
     if (RT_SUCCESS(rc))
     {

trunk/src/VBox/Additions/x11/VBoxClient/wayland-helper-dcp.cpp

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * Guest Additions - Wayland Desktop Environment helper which uses Data Control Protocol.
+ * Guest Additions - Data Control Protocol (DCP) helper for Wayland.
+ *
+ * This module implements Shared Clipboard support for Wayland guests
+ * using Data Control Protocol interface.
  */
 
@@ -26 +29 @@
  */
 
+#include <iprt/env.h>
+#include <iprt/assert.h>
+#include <iprt/string.h>
+#include <iprt/thread.h>
+
+#include <VBox/GuestHost/mime-type-converter.h>
+
+#include "VBoxClient.h"
+#include "clipboard.h"
 #include "wayland-helper.h"
+#include "wayland-helper-ipc.h"
+
+#include "wayland-client-protocol.h"
+#include "wlr-data-control-unstable-v1.h"
+
+/** Environment variable which points to which Wayland compositor we should connect.
+ * Must always be checked. */
+#define VBCL_ENV_WAYLAND_DISPLAY                            "WAYLAND_DISPLAY"
+
+/* Maximum length of Wayland interface name. */
+#define VBCL_WAYLAND_INTERFACE_NAME_MAX                     (64)
+/* Maximum waiting time interval for Wayland socket I/O to start. */
+#define VBCL_WAYLAND_IO_TIMEOUT_MS                          (500)
+
+/* Data chunk size when reading clipboard data from Wayland. */
+#define VBOX_WAYLAND_BUFFER_CHUNK_SIZE                      (_1M)
+/* Data chunk increment size to grow local buffer when it is not big enough. */
+#define VBOX_WAYLAND_BUFFER_CHUNK_INC_SIZE                  (_4M)
+/* Maximum length of clipboard buffer. */
+#define VBOX_WAYLAND_BUFFER_MAX                             (_16M)
+
+/** Minimum version numbers of Wayland interfaces we expect a compositor to provide. */
+#define VBCL_WAYLAND_DATA_DEVICE_MANAGER_VERSION_MIN        (3)
+#define VBCL_WAYLAND_SEAT_VERSION_MIN                       (5)
+#define VBCL_WAYLAND_ZWLR_DATA_CONTROL_MANAGER_VERSION_MIN  (1)
+
+/* A helper for matching interface and bind to it in registry callback.*/
+#define VBCL_WAYLAND_REGISTRY_ADD_MATCH(_pRegistry, _sIfaceName, _uIface, _iface_to_bind_to, _ctx_member, _ctx_member_type, _uVersion) \
+    if (RTStrNCmp(_sIfaceName, _iface_to_bind_to.name, VBCL_WAYLAND_INTERFACE_NAME_MAX) == 0) \
+    { \
+        if (! _ctx_member) \
+        { \
+            _ctx_member = \
+                (_ctx_member_type)wl_registry_bind(_pRegistry, _uIface, &_iface_to_bind_to, _uVersion); \
+            VBClLogVerbose(4, "binding to Wayland interface '%s' (%u) v%u\n", _iface_to_bind_to.name, _uIface, wl_proxy_get_version((struct wl_proxy *) _ctx_member)); \
+        } \
+        AssertPtrReturnVoid(_ctx_member); \
+    }
+
+/* Node of mime-types list. */
+typedef struct
+{
+    /** IPRT list node. */
+    RTLISTNODE  Node;
+    /** Data mime-type in string representation. */
+    char        *pszMimeType;
+} vbox_wl_dcp_mime_t;
+
+/**
+ * DCP session data.
+ *
+ * A structure which accumulates all the necessary data required to
+ * maintain session between host and Wayland for clipboard sharing. */
+typedef struct
+{
+    /** Generic VBoxClient Wayland session data (synchronization point). */
+    vbcl_wl_session_t Base;
+
+    /** Session data for clipboard sharing.
+     *
+     *  This data will be filled sequentially piece by piece by both
+     *  sides - host event loop and Wayland event loop until clipboard
+     *  buffer is obtained.
+     */
+    struct
+    {
+        /** List of mime-types which are being advertised by guest. */
+        vbox_wl_dcp_mime_t                      mimeTypesList;
+
+        /** Bitmask which represents list of clipboard formats which
+         *  are being advertised either by host or guest depending
+         *  on session type. */
+        vbcl::Waitable<volatile SHCLFORMATS>    fFmts;
+
+        /** Clipboard format which either host or guest wants to
+         *  obtain depending on session type. */
+        vbcl::Waitable<volatile SHCLFORMAT>     uFmt;
+
+        /** Clipboard buffer which contains requested data. */
+        vbcl::Waitable<volatile uint64_t>       pvClipboardBuf;
+
+        /** Size of clipboard buffer. */
+        vbcl::Waitable<volatile uint32_t>       cbClipboardBuf;
+    } clip;
+} vbox_wl_dcp_session_t;
+
+/**
+ * A set of objects required to handle clipboard sharing over
+ * Data Control Protocol. */
+typedef struct
+{
+    /** Wayland event loop thread. */
+    RTTHREAD                                    Thread;
+
+    /** A flag which indicates that Wayland event loop should terminate. */
+    volatile bool                               fShutdown;
+
+    /** Communication session between host event loop and Wayland. */
+    vbox_wl_dcp_session_t                       Session;
+
+    /** When set, incoming clipboard announcements will
+     *  be ignored. This flag is used in order to prevent a feedback
+     *  loop when host advertises clipboard data to Wayland. In this case,
+     *  Wayland will send the same advertisements back to us.  */
+    bool                                        fIngnoreWlClipIn;
+
+    /** A flag which indicates that host has announced new clipboard content
+    *   and now Wayland event loop thread should pass this information to
+    *   other Wayland clients. */
+    vbcl::Waitable<volatile bool>               fSendToGuest;
+
+    /** Connection handle to the host clipboard service. */
+    PVBGLR3SHCLCMDCTX                           pClipboardCtx;
+
+    /** Wayland compositor connection object. */
+    struct wl_display                           *pDisplay;
+
+    /** Wayland registry object. */
+    struct wl_registry                          *pRegistry;
+
+    /** Wayland Seat object. */
+    struct wl_seat                              *pSeat;
+
+    /** Wayland Data Device object. */
+    struct zwlr_data_control_device_v1          *pDataDevice;
+
+    /** Wayland Data Control Manager object. */
+    struct zwlr_data_control_manager_v1         *pDataControlManager;
+} vbox_wl_dcp_ctx_t;
+
+/** Data required to write clipboard content to Wayland. */
+struct vbcl_wl_dcp_write_ctx
+{
+    /** Content mime-type in string representation. */
+    const char *sMimeType;
+    /** Active file descriptor to write data into. */
+    int32_t fd;
+};
+
+/** Helper context. */
+static vbox_wl_dcp_ctx_t g_DcpCtx;
+
+static DECLCALLBACK(int) vbcl_wayland_hlp_dcp_hg_clip_report_join2_cb(vbcl_wl_session_type_t enmSessionType, void *pvUser);
+static DECLCALLBACK(int) vbcl_wayland_hlp_dcp_hg_clip_report_join3_cb(vbcl_wl_session_type_t enmSessionType, void *pvUser);
+
+
+/**********************************************************************************************************************************
+ * Wayland low level operations.
+ *********************************************************************************************************************************/
+
+
+/**
+ * A helper function which reallocates buffer to bigger size.
+ *
+ * This function will attempt to re-allocate specified buffer by cbChunk bytes.
+ * If failed, caller is responsible for freeing input buffer. On success, output
+ * buffer must be freed by caller.
+ *
+ * @returns IPRT status code.
+ * @param   pvBufIn             Previously allocated buffer which size needs to be increased.
+ * @param   cbBufIn             Size of input buffer.
+ * @param   cbChunk             Amount of bytes by which caller wants to increase buffer size.
+ * @param   cbMax               Maximum size of output buffer.
+ * @param   ppBufOut            Output buffer (must be freed by caller).
+ * @param   pcbBufOut           Size of output buffer.
+ */
+RTDECL(int) vbcl_wayland_hlp_dcp_grow_buffer(void *pvBufIn, size_t cbBufIn, size_t cbChunk, size_t cbMax,
+                                             void **ppBufOut, size_t *pcbBufOut)
+{
+    int rc = VERR_NO_MEMORY;
+
+    /* How many chunks were already added to the buffer. */
+    int cChunks = cbBufIn / cbChunk;
+    /* Size of a chunk to be added to already allocated buffer. */
+    size_t cbCurrentChunk = 0;
+
+    if (cbBufIn < cbMax)
+    {
+        void *pvBuf;
+
+        /* Calculate size of a chunk which can be added to already allocated memory
+         * in a way that resulting buffer size will not exceed cbMax. Always add
+         * the extra '\0' byte to the end of allocated area for safety reasons. */
+        cbCurrentChunk = RT_MIN(cbMax, cbChunk * (cChunks + 1)) - cbBufIn + 1;
+        pvBuf = RTMemReallocZ(pvBufIn, cbBufIn, cbBufIn + cbCurrentChunk);
+        if (RT_VALID_PTR(pvBuf))
+        {
+            LogRel(("Wayland: buffer size increased from %u to %u bytes\n", cbBufIn, cbBufIn + cbCurrentChunk));
+            *ppBufOut = pvBuf;
+            *pcbBufOut = cbBufIn + cbCurrentChunk;
+            rc = VINF_SUCCESS;
+        }
+        else
+        {
+            LogRel(("Wayland: unable to allocate buffer of size of %u bytes: no memory\n", cbBufIn + cbCurrentChunk));
+            rc = VERR_NO_MEMORY;
+        }
+    }
+    else
+    {
+        LogRel(("Shared Clipboard: unable to re-allocate buffer: size of %u bytes exceeded\n", cbMax));
+        rc = VERR_BUFFER_OVERFLOW;
+    }
+
+    return rc;
+}
+
+/**
+ * A helper function for reading from file descriptor until EOF.
+ *
+ * Reads clipboard data from Wayland via file descriptor.
+ *
+ * @returns IPRT status code.
+ * @param   fd                  A file descriptor to read data from.
+ * @param   ppvBuf              Newly allocated output buffer (must be freed by caller).
+ * @param   pcbBuf              Size of output buffer.
+ */
+RTDECL(int) vbcl_wayland_hlp_dcp_read_wl_fd(int fd, void **ppvBuf, size_t *pcbBuf)
+{
+    int rc = VERR_NO_MEMORY;
+
+    struct timeval tv;
+    fd_set rfds;
+
+    /* Amount of payload actually read from Wayland fd in bytes. */
+    size_t cbDst = 0;
+    /* Dynamically growing buffer to store Wayland clipboard. */
+    void *pvDst = NULL;
+    /* Number of bytes currently allocated to read entire
+     * Wayland buffer content (actual size of pvDst). */
+    size_t cbGrowingBuffer = 0;
+    /* Number of bytes read from Wayland fd per attempt. */
+    size_t cbRead = 0;
+
+    /* Start with allocating one chunk and grow buffer later if needed. */
+    cbGrowingBuffer = VBOX_WAYLAND_BUFFER_CHUNK_INC_SIZE + 1 /* '\0' */;
+    pvDst = RTMemAllocZ(cbGrowingBuffer);
+    if (RT_VALID_PTR(pvDst))
+    {
+        /* Read everything from given fd. */
+        while (1)
+        {
+            tv.tv_sec  = 0;
+            tv.tv_usec = VBCL_WAYLAND_IO_TIMEOUT_MS * 1000;
+
+            FD_ZERO(&rfds);
+            FD_SET(fd, &rfds);
+
+            /* Wait until data is available. */
+            if (select(fd + 1, &rfds, NULL, NULL, &tv) > 0)
+            {
+                /* Check if backing buffer size is big enough to store one more data chunk
+                 * read from fd. If not, try to increase buffer by size of chunk x 2. */
+                if (cbDst + VBOX_WAYLAND_BUFFER_CHUNK_SIZE > cbGrowingBuffer)
+                {
+                    void *pBufTmp = NULL;
+
+                    rc = vbcl_wayland_hlp_dcp_grow_buffer(
+                        pvDst, cbGrowingBuffer, VBOX_WAYLAND_BUFFER_CHUNK_INC_SIZE,
+                        VBOX_WAYLAND_BUFFER_MAX, &pBufTmp, &cbGrowingBuffer);
+
+                    if (RT_FAILURE(rc))
+                    {
+                        RTMemFree(pvDst);
+                        break;
+                    }
+                    else
+                        pvDst = pBufTmp;
+                }
+
+                /* Read all data from fd until EOF. */
+                cbRead = read(fd, (void *)((uint8_t *)pvDst + cbDst), VBOX_WAYLAND_BUFFER_CHUNK_SIZE);
+                if (cbRead > 0)
+                {
+                    LogRel(("Wayland: read chunk of %u bytes from Wayland\n", cbRead));
+                    cbDst += cbRead;
+                }
+                else
+                {
+                    /* EOF has been reached. */
+                    LogRel(("Wayland: read %u bytes from Wayland\n", cbDst));
+
+                    if (cbDst > 0)
+                    {
+                        rc = VINF_SUCCESS;
+                        *ppvBuf = pvDst;
+                        *pcbBuf = cbDst;
+                    }
+                    else
+                    {
+                        rc = VERR_NO_DATA;
+                        RTMemFree(pvDst);
+                    }
+
+                    break;
+                }
+            }
+            else
+            {
+                rc = VERR_TIMEOUT;
+                break;
+            }
+        }
+    }
+
+    return rc;
+}
+
+/**
+ * A helper function for writing to a file descriptor provided by Wayland.
+ *
+ * @returns IPRT status code.
+ * @param   fd                  A file descriptor to write data to.
+ * @param   ppvBuf              Data buffer.
+ * @param   pcbBuf              Size of data buffer.
+ */
+RTDECL(int) vbcl_wayland_hlp_dcp_write_wl_fd(int fd, void *pvBuf, size_t cbBuf)
+{
+    struct timeval tv;
+    fd_set wfds;
+
+    int rc = VINF_SUCCESS;
+
+    tv.tv_sec  = 0;
+    tv.tv_usec = VBCL_WAYLAND_IO_TIMEOUT_MS * 1000;
+
+    FD_ZERO(&wfds);
+    FD_SET(fd, &wfds);
+
+    /* Wait until data is available. */
+    if (select(fd + 1, NULL, &wfds, NULL, &tv) > 0)
+    {
+        if (FD_ISSET(fd, &wfds))
+        {
+            ssize_t cbWritten = write(fd, pvBuf, cbBuf);
+            if (cbWritten != (ssize_t)cbBuf)
+            {
+                VBClLogError("cannot write clipboard data, written %d out of %d bytes\n",
+                             cbWritten, cbBuf);
+                rc = VERR_PIPE_NOT_CONNECTED;
+            }
+            else
+                VBClLogVerbose(5, "written %u bytes to Wayland clipboard\n", cbWritten);
+        }
+        else
+        {
+            VBClLogError("cannot write fd\n");
+            rc = VERR_TIMEOUT;
+        }
+    }
+    else
+        rc = VERR_TIMEOUT;
+
+    return rc;
+}
+
+/**
+ * Read the next event from Wayland compositor.
+ *
+ * Implements custom reader function which can be interrupted
+ * on service termination request.
+ *
+ * @returns IPRT status code.
+ * @param   pCtx                Context data.
+ */
+static int vbcl_wayland_hlp_dcp_next_event(vbox_wl_dcp_ctx_t *pCtx)
+{
+    int rc = VINF_SUCCESS;
+
+    struct timeval tv;
+    fd_set rfds, efds;
+    int fd;
+
+    /* Instead of using wl_display_dispatch() directly, implement
+     * custom event loop handling as recommended in Wayland documentation.
+     * Thus, we can have a control over Wayland fd polling and in turn
+     * can request event loop thread to shutdown when needed. */
+
+    tv.tv_sec  = 0;
+    tv.tv_usec = VBCL_WAYLAND_IO_TIMEOUT_MS * 1000;
+
+    fd = wl_display_get_fd(pCtx->pDisplay);
+
+    FD_ZERO(&rfds);
+    FD_SET(fd, &rfds);
+
+    FD_ZERO(&efds);
+    FD_SET(fd, &efds);
+
+    while (wl_display_prepare_read(pCtx->pDisplay) != 0)
+        wl_display_dispatch(pCtx->pDisplay);
+
+    wl_display_flush(pCtx->pDisplay);
+
+    if (select(fd + 1, &rfds, NULL, &efds, &tv) > 0)
+        wl_display_read_events(pCtx->pDisplay);
+    else
+    {
+        wl_display_cancel_read(pCtx->pDisplay);
+        rc = VERR_TIMEOUT;
+    }
+
+    wl_display_dispatch_pending(pCtx->pDisplay);
+
+    return rc;
+}
+
+
+/**********************************************************************************************************************************
+ * Host Clipboard service callbacks.
+ *********************************************************************************************************************************/
+
+
+/**
+ * Release session resources.
+ *
+ * @returns IPRT status code.
+ * @param   pSession        Session data.
+ */
+static void vbcl_wayland_hlp_dcp_session_release(vbox_wl_dcp_session_t *pSession)
+{
+    void *pvData;
+
+    if (!RTListIsEmpty(&pSession->clip.mimeTypesList.Node))
+    {
+        vbox_wl_dcp_mime_t *pEntry, *pNextEntry;
+
+        RTListForEachSafe(&pSession->clip.mimeTypesList.Node, pEntry, pNextEntry, vbox_wl_dcp_mime_t, Node)
+        {
+            RTListNodeRemove(&pEntry->Node);
+            RTStrFree(pEntry->pszMimeType);
+            RTMemFree(pEntry);
+        }
+    }
+
+    pvData = (void *)pSession->clip.pvClipboardBuf.reset();
+    if (RT_VALID_PTR(pvData))
+        RTMemFree(pvData);
+}
+
+/**
+ * Initialize session.
+ *
+ * @returns IPRT status code.
+ * @param   pSession        Session data.
+ */
+static void vbcl_wayland_hlp_dcp_session_init(vbox_wl_dcp_session_t *pSession)
+{
+    RTListInit(&pSession->clip.mimeTypesList.Node);
+
+    pSession->clip.fFmts.init(VBOX_SHCL_FMT_NONE, VBCL_WAYLAND_VALUE_WAIT_TIMEOUT_MS);
+    pSession->clip.uFmt.init(VBOX_SHCL_FMT_NONE, VBCL_WAYLAND_VALUE_WAIT_TIMEOUT_MS);
+    pSession->clip.pvClipboardBuf.init(0, VBCL_WAYLAND_DATA_WAIT_TIMEOUT_MS);
+    pSession->clip.cbClipboardBuf.init(0, VBCL_WAYLAND_DATA_WAIT_TIMEOUT_MS);
+}
+
+/**
+ * Reset previously initialized session.
+ *
+ * @returns IPRT status code.
+ * @param   pSession        Session data.
+ */
+static void vbcl_wayland_hlp_dcp_session_prepare(vbox_wl_dcp_session_t *pSession)
+{
+    vbcl_wayland_hlp_dcp_session_release(pSession);
+    vbcl_wayland_hlp_dcp_session_init(pSession);
+#if 0
+    void *pvData;
+
+    if (!RTListIsEmpty(&pSession->clip.mimeTypesList.Node))
+    {
+        vbox_wl_dcp_mime_t *pEntry, *pNextEntry;
+
+        RTListForEachSafe(&pSession->clip.mimeTypesList.Node, pEntry, pNextEntry, vbox_wl_dcp_mime_t, Node)
+        {
+            RTListNodeRemove(&pEntry->Node);
+            RTStrFree(pEntry->pszMimeType);
+            RTMemFree(pEntry);
+        }
+    }
+
+    pvData = (void *)pSession->clip.pvClipboardBuf.reset();
+    if (RT_VALID_PTR(pvData))
+        RTMemFree(pvData);
+
+
+    RTListInit(&pSession->clip.mimeTypesList.Node);
+
+    pSession->clip.fFmts.init(VBOX_SHCL_FMT_NONE, VBCL_WAYLAND_VALUE_WAIT_TIMEOUT_MS);
+    pSession->clip.uFmt.init(VBOX_SHCL_FMT_NONE, VBCL_WAYLAND_VALUE_WAIT_TIMEOUT_MS);
+    pSession->clip.pvClipboardBuf.init(0, VBCL_WAYLAND_DATA_WAIT_TIMEOUT_MS);
+    pSession->clip.cbClipboardBuf.init(0, VBCL_WAYLAND_DATA_WAIT_TIMEOUT_MS);
+#endif
+}
+
+/**
+ * Session callback: Generic session initializer.
+ *
+ * This callback starts new session.
+ *
+ * @returns IPRT status code.
+ * @param   enmSessionType      Session type (unused).
+ * @param   pvUser              User data (unused).
+ */
+static DECLCALLBACK(int) vbcl_wayland_hlp_dcp_session_start_generic_cb(
+    vbcl_wl_session_type_t enmSessionType, void *pvUser)
+{
+    RT_NOREF(enmSessionType, pvUser);
+
+    VBCL_LOG_CALLBACK;
+
+    vbcl_wayland_hlp_dcp_session_prepare(&g_DcpCtx.Session);
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Wayland registry global handler.
+ *
+ * This callback is triggered when Wayland Registry listener is registered.
+ * Wayland client library will trigger it individually for each available global
+ * object.
+ *
+ * @param pvUser            Context data.
+ * @param pRegistry         Wayland Registry object.
+ * @param uName             Numeric name of the global object.
+ * @param sIface            Name of interface implemented by the object.
+ * @param uVersion          Interface version.
+ */
+static DECLCALLBACK(void) vbcl_wayland_hlp_dcp_registry_global_handler(
+    void *pvUser, struct wl_registry *pRegistry, uint32_t uName, const char *sIface, uint32_t uVersion)
+{
+    vbox_wl_dcp_ctx_t *pCtx = (vbox_wl_dcp_ctx_t *)pvUser;
+
+    RT_NOREF(pRegistry);
+    RT_NOREF(uVersion);
+
+    AssertPtrReturnVoid(pCtx);
+    AssertPtrReturnVoid(sIface);
+
+    /* Wrappers around 'if' statement. */
+         VBCL_WAYLAND_REGISTRY_ADD_MATCH(pRegistry, sIface, uName, wl_seat_interface,                       pCtx->pSeat,                struct wl_seat *,                       VBCL_WAYLAND_SEAT_VERSION_MIN)
+    else VBCL_WAYLAND_REGISTRY_ADD_MATCH(pRegistry, sIface, uName, zwlr_data_control_manager_v1_interface,  pCtx->pDataControlManager,  struct zwlr_data_control_manager_v1 *,  VBCL_WAYLAND_ZWLR_DATA_CONTROL_MANAGER_VERSION_MIN)
+    else
+        VBClLogVerbose(5, "ignoring Wayland interface %s\n", sIface);
+}
+
+/**
+ * Wayland registry global remove handler.
+ *
+ * Triggered when global object is removed from Wayland registry.
+ *
+ * @param pvUser            Context data.
+ * @param pRegistry         Wayland Registry object.
+ * @param uName             Numeric name of the global object.
+ */
+static DECLCALLBACK(void) vbcl_wayland_hlp_dcp_registry_global_remove_handler(
+    void *pvUser, struct wl_registry *pRegistry, uint32_t uName)
+{
+    RT_NOREF(pvUser);
+    RT_NOREF(pRegistry);
+    RT_NOREF(uName);
+}
+
+/** Wayland global registry callbacks. */
+static const struct wl_registry_listener g_vbcl_wayland_hlp_registry_cb =
+{
+    vbcl_wayland_hlp_dcp_registry_global_handler,       /* .global */
+    vbcl_wayland_hlp_dcp_registry_global_remove_handler /* .global_remove */
+};
+
+
+
+/**********************************************************************************************************************************
+ * Wayland Data Control Offer callbacks.
+ *********************************************************************************************************************************/
+
+
+/**
+ * Session callback: Collect clipboard format advertised by guest.
+ *
+ * This callback must be executed in context of Wayland event thread
+ * in order to be able to access Wayland clipboard content.
+ *
+ * This callback adds mime-type just advertised by Wayland into a list
+ * of mime-types which in turn later will be advertised to the host.
+ *
+ * @returns IPRT status code.
+ * @param   enmSessionType      Session type, must be verified as
+ *                              a consistency check.
+ * @param   pvUser              User data (Wayland mime-type).
+ */
+static DECLCALLBACK(int) vbcl_wayland_hlp_dcp_gh_add_fmt_cb(
+    vbcl_wl_session_type_t enmSessionType, void *pvUser)
+{
+    const char *sMimeType = (const char *)pvUser;
+    AssertPtrReturn(sMimeType, VERR_INVALID_PARAMETER);
+
+    SHCLFORMAT uFmt = VBoxMimeConvGetIdByMime(sMimeType);
+
+    int rc = (enmSessionType == VBCL_WL_CLIPBOARD_SESSION_TYPE_COPY_TO_HOST)
+             ? VINF_SUCCESS : VERR_WRONG_ORDER;
+
+    VBCL_LOG_CALLBACK;
+
+    if (RT_SUCCESS(rc))
+    {
+        if (uFmt != VBOX_SHCL_FMT_NONE)
+        {
+            vbox_wl_dcp_mime_t *pNode = (vbox_wl_dcp_mime_t *)RTMemAllocZ(sizeof(vbox_wl_dcp_mime_t));
+            if (RT_VALID_PTR(pNode))
+            {
+                pNode->pszMimeType = RTStrDup((char *)sMimeType);
+                if (RT_VALID_PTR(pNode->pszMimeType))
+                    RTListAppend(&g_DcpCtx.Session.clip.mimeTypesList.Node, &pNode->Node);
+                else
+                    RTMemFree(pNode);
+            }
+
+            if (   !RT_VALID_PTR(pNode)
+                || !RT_VALID_PTR(pNode->pszMimeType))
+            {
+                rc = VERR_NO_MEMORY;
+            }
+        }
+        else
+            rc = VERR_NO_DATA;
+    }
+
+    return rc;
+}
+
+
+/**
+ * Data Control Offer advertise callback.
+ *
+ * Triggered when other Wayland client advertises new clipboard content.
+ *
+ * @param pvUser            Context data.
+ * @param pOffer            Wayland Data Control Offer object.
+ * @param sMimeType         Mime-type of newly available clipboard data.
+ */
+static DECLCALLBACK(void) vbcl_wayland_hlp_dcp_data_control_offer_offer(
+    void *pvUser, struct zwlr_data_control_offer_v1 *pOffer, const char *sMimeType)
+{
+    vbox_wl_dcp_ctx_t *pCtx = (vbox_wl_dcp_ctx_t *)pvUser;
+    int rc;
+
+    RT_NOREF(pOffer);
+
+    VBCL_LOG_CALLBACK;
+
+    rc = vbcl_wayland_session_join(&pCtx->Session.Base,
+                                   &vbcl_wayland_hlp_dcp_gh_add_fmt_cb,
+                                   (void *)sMimeType);
+    if (RT_FAILURE(rc))
+        VBClLogError("cannot save formats announced by the guest, rc=%Rrc\n", rc);
+}
+
+/** Wayland Data Control Offer interface callbacks. */
+static const struct zwlr_data_control_offer_v1_listener g_data_control_offer_listener =
+{
+    vbcl_wayland_hlp_dcp_data_control_offer_offer,
+};
+
+
+/**********************************************************************************************************************************
+ * Wayland Data Control Device callbacks.
+ *********************************************************************************************************************************/
+
+
+/**
+ * Convert list of mime-types in string representation into bitmask of VBox formats.
+ *
+ * @returns Formats bitmask.
+ * @param   pList   List of mime-types in string representation.
+ */
+static SHCLFORMATS vbcl_wayland_hlp_dcp_match_formats(vbox_wl_dcp_mime_t *pList)
+{
+    SHCLFORMATS fFmts = VBOX_SHCL_FMT_NONE;
+
+    if (!RTListIsEmpty(&pList->Node))
+    {
+        vbox_wl_dcp_mime_t *pEntry;
+        RTListForEach(&pList->Node, pEntry, vbox_wl_dcp_mime_t, Node)
+        {
+            AssertPtrReturn(pEntry, VERR_INVALID_PARAMETER);
+            AssertPtrReturn(pEntry->pszMimeType, VERR_INVALID_PARAMETER);
+
+            fFmts |= VBoxMimeConvGetIdByMime(pEntry->pszMimeType);
+        }
+    }
+
+    return fFmts;
+}
+
+/**
+ * Find first matching clipboard mime-type for given format ID.
+ *
+ * @returns Matching mime-type in string representation or NULL if not found.
+ * @param   uFmt    Format in VBox representation to match.
+ * @param   pList   List of Wayland mime-types in string representation.
+ */
+static char *vbcl_wayland_hlp_dcp_match_mime_type(SHCLFORMAT uFmt, vbox_wl_dcp_mime_t *pList)
+{
+    char *pszMimeType = NULL;
+
+    if (!RTListIsEmpty(&pList->Node))
+    {
+        vbox_wl_dcp_mime_t *pEntry;
+        RTListForEach(&pList->Node, pEntry, vbox_wl_dcp_mime_t, Node)
+        {
+            AssertPtrReturn(pEntry, NULL);
+            AssertPtrReturn(pEntry->pszMimeType, NULL);
+
+            if (uFmt == VBoxMimeConvGetIdByMime(pEntry->pszMimeType))
+            {
+                pszMimeType = pEntry->pszMimeType;
+                break;
+            }
+        }
+    }
+
+    return pszMimeType;
+}
+
+/**
+ * Read clipboard buffer from Wayland in specified format.
+ *
+ * @returns IPRT status code.
+ * @param   pCtx            DCP context data.
+ * @param   pOffer          Data offer object.
+ * @param   pszMimeType     Requested mime-type in string representation.
+ */
+static int vbcl_wayland_hlp_dcp_receive_offer(
+    vbox_wl_dcp_ctx_t *pCtx, zwlr_data_control_offer_v1 *pOffer, SHCLFORMAT uFmt, char *pszMimeType)
+{
+    int rc = VERR_PIPE_NOT_CONNECTED;
+
+    int aFds[2];
+    void *pvBuf = NULL;
+    size_t cbBuf = 0;
+
+    RT_NOREF(uFmt);
+
+    if (pipe(aFds) == 0)
+    {
+        zwlr_data_control_offer_v1_receive(
+            (struct zwlr_data_control_offer_v1 *)pOffer, pszMimeType, aFds[1]);
+
+        close(aFds[1]);
+        wl_display_flush(pCtx->pDisplay);
+
+        rc = vbcl_wayland_hlp_dcp_read_wl_fd(aFds[0], &pvBuf, &cbBuf);
+        if (RT_SUCCESS(rc))
+        {
+            void *pvBufOut = NULL;
+            size_t cbBufOut = 0;
+
+            rc = VBoxMimeConvNativeToVBox(pszMimeType, pvBuf, cbBuf, &pvBufOut, &cbBufOut);
+            if (RT_SUCCESS(rc))
+            {
+                pCtx->Session.clip.pvClipboardBuf.set((uint64_t)pvBufOut);
+                pCtx->Session.clip.cbClipboardBuf.set((uint64_t)cbBufOut);
+            }
+
+            RTMemFree(pvBuf);
+        }
+    }
+    else
+        VBClLogError("cannot read mime-type '%s' from Wayland, rc=%Rrc\n", pszMimeType, rc);
+
+    return rc;
+}
+
+/**
+ * Session callback: Advertise clipboard to the host.
+ *
+ * This callback must be executed in context of Wayland event thread
+ * in order to be able to access Wayland clipboard content.
+ *
+ * This callback (1) coverts Wayland clipboard formats into VBox
+ * representation, (2) sets formats to the session, (3) waits for
+ * host to request clipboard data in certain format, and (4)
+ * receives Wayland clipboard in requested format.
+ *
+ * @returns IPRT status code.
+ * @param   enmSessionType      Session type, must be verified as
+ *                              a consistency check.
+ * @param   pvUser              User data (data offer object).
+ */
+static DECLCALLBACK(int) vbcl_wayland_hlp_dcp_gh_clip_report_cb(
+    vbcl_wl_session_type_t enmSessionType, void *pvUser)
+{
+    struct zwlr_data_control_offer_v1 *pOffer = (struct zwlr_data_control_offer_v1 *)pvUser;
+    SHCLFORMATS fFmts = VBOX_SHCL_FMT_NONE;
+
+    int rc = (enmSessionType == VBCL_WL_CLIPBOARD_SESSION_TYPE_COPY_TO_HOST)
+             ? VINF_SUCCESS : VERR_WRONG_ORDER;
+
+    AssertPtrReturn(pOffer, VERR_INVALID_PARAMETER);
+
+    VBCL_LOG_CALLBACK;
+
+    if (RT_SUCCESS(rc))
+    {
+        fFmts = vbcl_wayland_hlp_dcp_match_formats(&g_DcpCtx.Session.clip.mimeTypesList);
+        if (fFmts != VBOX_SHCL_FMT_NONE)
+        {
+            SHCLFORMAT uFmt;
+
+            g_DcpCtx.Session.clip.fFmts.set(fFmts);
+
+            if (RT_VALID_PTR(g_DcpCtx.pClipboardCtx))
+            {
+                rc = VbglR3ClipboardReportFormats(g_DcpCtx.pClipboardCtx->idClient, fFmts);
+                if (RT_SUCCESS(rc))
+                {
+                    uFmt = g_DcpCtx.Session.clip.uFmt.wait();
+                    if (uFmt != g_DcpCtx.Session.clip.uFmt.defaults())
+                    {
+                        char *pszMimeType =
+                            vbcl_wayland_hlp_dcp_match_mime_type(uFmt, &g_DcpCtx.Session.clip.mimeTypesList);
+
+                        if (RT_VALID_PTR(pszMimeType))
+                        {
+                            rc = vbcl_wayland_hlp_dcp_receive_offer(&g_DcpCtx, pOffer, uFmt, pszMimeType);
+
+                            VBClLogVerbose(5, "will send fmt=0x%x (%s) to the host\n", uFmt, pszMimeType);
+                        }
+                        else
+                            rc = VERR_NO_DATA;
+                    }
+                    else
+                        rc = VERR_TIMEOUT;
+                }
+                else
+                    VBClLogError("cannot report formats to host, rc=%Rrc\n", rc);
+            }
+            else
+            {
+                VBClLogVerbose(2, "cannot announce to guest, no host service connection yet\n");
+                rc = VERR_TRY_AGAIN;
+            }
+        }
+        else
+            rc = VERR_NO_DATA;
+
+        zwlr_data_control_offer_v1_destroy((struct zwlr_data_control_offer_v1 *)pOffer);
+
+        VBClLogVerbose(5, "announcing fFmts=0x%x to host, rc=%Rrc\n", fFmts, rc);
+    }
+
+    return rc;
+}
+
+/**
+ * Data Control Device offer callback.
+ *
+ * Triggered when other Wayland client advertises new clipboard content.
+ * When this callback is triggered, a new zwlr_data_control_offer_v1 object
+ * is created. This callback should setup listener callbacks for this object.
+ *
+ * @param pvUser            Context data.
+ * @param pDevice           Wayland Data Control Device object.
+ * @param pOffer            Wayland Data Control Offer object.
+ */
+static DECLCALLBACK(void) vbcl_wayland_hlp_dcp_data_device_data_offer(
+    void *pvUser, struct zwlr_data_control_device_v1 *pDevice, struct zwlr_data_control_offer_v1 *pOffer)
+{
+    vbox_wl_dcp_ctx_t *pCtx = (vbox_wl_dcp_ctx_t *)pvUser;
+    int rc;
+
+    RT_NOREF(pDevice);
+
+    VBCL_LOG_CALLBACK;
+
+    if (pCtx->fIngnoreWlClipIn)
+    {
+        VBClLogVerbose(5, "ignoring Wayland clipboard data offer, we advertising new clipboard ourselves\n");
+        return;
+    }
+
+    rc = vbcl_wayland_session_end(&pCtx->Session.Base, NULL, NULL);
+    if (RT_SUCCESS(rc))
+    {
+        rc = vbcl_wayland_session_start(&pCtx->Session.Base,
+                                        VBCL_WL_CLIPBOARD_SESSION_TYPE_COPY_TO_HOST,
+                                        &vbcl_wayland_hlp_dcp_session_start_generic_cb,
+                                        &pCtx->Session);
+        if (RT_SUCCESS(rc))
+        {
+            zwlr_data_control_offer_v1_add_listener(pOffer, &g_data_control_offer_listener, pvUser);
+
+            /* Receive all the advertised mime types. */
+            wl_display_roundtrip(pCtx->pDisplay);
+
+            /* Try to send an announcement to the host. */
+            rc = vbcl_wayland_session_join(&pCtx->Session.Base,
+                                           &vbcl_wayland_hlp_dcp_gh_clip_report_cb,
+                                           pOffer);
+        }
+        else
+            VBClLogError("unable to start session, rc=%Rrc\n", rc);
+    }
+    else
+        VBClLogError("unable to start session, previous session is still running, rc=%Rrc\n", rc);
+}
+
+/**
+ * Data Control Device selection callback.
+ *
+ * Triggered when Wayland client advertises new clipboard content.
+ * In this callback, actual clipboard data is received from Wayland client.
+ *
+ * @param pvUser            Context data.
+ * @param pDevice           Wayland Data Control Device object.
+ * @param pOffer            Wayland Data Control Offer object.
+ */
+static DECLCALLBACK(void) vbcl_wayland_hlp_dcp_data_device_selection(
+    void *pvUser, struct zwlr_data_control_device_v1 *pDevice, struct zwlr_data_control_offer_v1 *pOffer)
+{
+    RT_NOREF(pDevice, pvUser, pOffer);
+
+    VBCL_LOG_CALLBACK;
+}
+
+/**
+ * Data Control Device finished callback.
+ *
+ * Triggered when Data Control Device object is no longer valid and
+ * needs to be destroyed.
+ *
+ * @param pvUser            Context data.
+ * @param pDevice           Wayland Data Control Device object.
+ */
+static void vbcl_wayland_hlp_dcp_data_device_finished(
+    void *data, struct zwlr_data_control_device_v1 *pDevice)
+{
+    RT_NOREF(data);
+
+    VBCL_LOG_CALLBACK;
+
+    zwlr_data_control_device_v1_destroy(pDevice);
+}
+
+/**
+ * Data Control Device primary selection callback.
+ *
+ * Same as shcl_wl_data_control_device_selection, but triggered for
+ * primary selection case.
+ *
+ * @param pvUser            Context data.
+ * @param pDevice           Wayland Data Control Device object.
+ * @param pOffer            Wayland Data Control Offer object.
+ */
+static DECLCALLBACK(void) vbcl_wayland_hlp_dcp_data_device_primary_selection(
+    void *pvUser, struct zwlr_data_control_device_v1 *pDevice, struct zwlr_data_control_offer_v1 *pOffer)
+{
+    RT_NOREF(pDevice, pvUser, pOffer);
+
+    VBCL_LOG_CALLBACK;
+}
+
+
+/** Data Control Device interface callbacks. */
+static const struct zwlr_data_control_device_v1_listener g_data_device_listener =
+{
+    vbcl_wayland_hlp_dcp_data_device_data_offer,
+    vbcl_wayland_hlp_dcp_data_device_selection,
+    vbcl_wayland_hlp_dcp_data_device_finished,
+    vbcl_wayland_hlp_dcp_data_device_primary_selection,
+};
+
+
+/**********************************************************************************************************************************
+ * Wayland Data Control Source callbacks.
+ *********************************************************************************************************************************/
+
+/**
+ * Wayland data send callback.
+ *
+ * Triggered when other Wayland client wants to read clipboard
+ * data from us.
+ *
+ * @param pvUser            VBox private data.
+ * @param pSourceSource     Wayland Data Control Source object.
+ * @param sMimeType         A mime-type of requested data.
+ * @param fd                A file descriptor to write clipboard content into.
+ */
+static DECLCALLBACK(void) vbcl_wayland_hlp_dcp_data_source_send(
+    void *pvUser, struct zwlr_data_control_source_v1 *pDataSource,
+    const char *sMimeType, int32_t fd)
+{
+    vbox_wl_dcp_ctx_t *pCtx = (vbox_wl_dcp_ctx_t *)pvUser;
+    int rc;
+
+    struct vbcl_wl_dcp_write_ctx priv;
+
+    RT_NOREF(pDataSource);
+
+    VBCL_LOG_CALLBACK;
+
+    RT_ZERO(priv);
+
+    priv.sMimeType = sMimeType;
+    priv.fd = fd;
+
+    rc = vbcl_wayland_session_join(&pCtx->Session.Base,
+                                   &vbcl_wayland_hlp_dcp_hg_clip_report_join3_cb,
+                                   &priv);
+
+    VBClLogVerbose(5, "vbcl_wayland_hlp_dcp_data_source_send, rc=%Rrc\n", rc);
+    close(fd);
+}
+
+/**
+ * Wayland data canceled callback.
+ *
+ * Triggered when data source was replaced by another data source
+ * and no longer valid.
+ *
+ * @param pvData            VBox private data.
+ * @param pDataSource       Wayland Data Control Source object.
+ */
+static DECLCALLBACK(void) vbcl_wayland_hlp_dcp_data_source_cancelled(
+    void *pvData, struct zwlr_data_control_source_v1 *pDataSource)
+{
+    RT_NOREF(pvData);
+
+    VBCL_LOG_CALLBACK;
+
+    zwlr_data_control_source_v1_destroy(pDataSource);
+}
+
+
+/** Wayland Data Control Source interface callbacks. */
+static const struct zwlr_data_control_source_v1_listener g_data_source_listener =
+{
+    vbcl_wayland_hlp_dcp_data_source_send,
+    vbcl_wayland_hlp_dcp_data_source_cancelled,
+};
+
+
+/**********************************************************************************************************************************
+ * Helper specific code and session callbacks.
+ *********************************************************************************************************************************/
+
+
+/**
+ * Setup or reset helper context.
+ *
+ * This function is used on helper init and termination. In case of
+ * init, memory is not initialized yet, so it needs to be zeroed.
+ * In case of shutdown, memory is already initialized and previously
+ * allocated resources must be freed.
+ *
+ * @param pCtx              Context data.
+ * @param fShutdown         A flag to indicate if session resources
+ *                          need to be deallocated.
+ */
+static void vbcl_wayland_hlp_dcp_reset_ctx(vbox_wl_dcp_ctx_t *pCtx, bool fShutdown)
+{
+    pCtx->Thread = NIL_RTTHREAD;
+    pCtx->fShutdown = false;
+    pCtx->fIngnoreWlClipIn = false;
+    pCtx->fSendToGuest.init(false, VBCL_WAYLAND_VALUE_WAIT_TIMEOUT_MS);
+    pCtx->pClipboardCtx = NULL;
+    pCtx->pDisplay = NULL;
+    pCtx->pRegistry = NULL;
+    pCtx->pSeat = NULL;
+    pCtx->pDataDevice = NULL;
+    pCtx->pDataControlManager = NULL;
+
+    if (fShutdown)
+        vbcl_wayland_hlp_dcp_session_release(&pCtx->Session);
+
+    vbcl_wayland_hlp_dcp_session_init(&pCtx->Session);
+}
+
+/**
+ * Disconnect from Wayland compositor.
+ *
+ * Close connection, release resources and reset context data.
+ *
+ * @param pCtx              Context data.
+ */
+static void vbcl_wayland_hlp_dcp_disconnect(vbox_wl_dcp_ctx_t *pCtx)
+{
+    if (RT_VALID_PTR(pCtx->pDataControlManager))
+        zwlr_data_control_manager_v1_destroy(pCtx->pDataControlManager);
+
+    if (RT_VALID_PTR(pCtx->pDataDevice))
+        zwlr_data_control_device_v1_destroy(pCtx->pDataDevice);
+
+    if (RT_VALID_PTR(pCtx->pSeat))
+        wl_seat_destroy(pCtx->pSeat);
+
+    if (RT_VALID_PTR(pCtx->pRegistry))
+        wl_registry_destroy(pCtx->pRegistry);
+
+    if (RT_VALID_PTR(pCtx->pDisplay))
+        wl_display_disconnect(pCtx->pDisplay);
+
+    vbcl_wayland_hlp_dcp_reset_ctx(pCtx, true);
+}
+
+/**
+ * Connect to Wayland compositor.
+ *
+ * Establish connection, bind to all required interfaces.
+ *
+ * @returns TRUE on success, FALSE otherwise.
+ * @param   pCtx                Context data.
+ */
+static bool vbcl_wayland_hlp_dcp_connect(vbox_wl_dcp_ctx_t *pCtx)
+{
+    const char *csWaylandDisplay = RTEnvGet(VBCL_ENV_WAYLAND_DISPLAY);
+    bool fConnected = false;
+
+    if (RT_VALID_PTR(csWaylandDisplay))
+        pCtx->pDisplay = wl_display_connect(csWaylandDisplay);
+    else
+        VBClLogError("cannot connect to Wayland compositor "
+                     VBCL_ENV_WAYLAND_DISPLAY " environment variable not set\n");
+
+    if (RT_VALID_PTR(pCtx->pDisplay))
+    {
+        pCtx->pRegistry = wl_display_get_registry(pCtx->pDisplay);
+        if (RT_VALID_PTR(pCtx->pRegistry))
+        {
+            wl_registry_add_listener(pCtx->pRegistry, &g_vbcl_wayland_hlp_registry_cb, (void *)pCtx);
+            wl_display_roundtrip(pCtx->pDisplay);
+
+            if (RT_VALID_PTR(pCtx->pDataControlManager))
+            {
+                if (RT_VALID_PTR(pCtx->pSeat))
+                {
+                    pCtx->pDataDevice = zwlr_data_control_manager_v1_get_data_device(pCtx->pDataControlManager, pCtx->pSeat);
+                    if (RT_VALID_PTR(pCtx->pDataDevice))
+                    {
+                        if (RT_VALID_PTR(pCtx->pDataControlManager))
+                            fConnected = true;
+                        else
+                            VBClLogError("cannot get Wayland data control manager interface\n");
+                    }
+                    else
+                        VBClLogError("cannot get Wayland data device interface\n");
+                }
+                else
+                    VBClLogError("cannot get Wayland seat interface\n");
+            }
+            else
+                VBClLogError("cannot get Wayland device manager interface\n");
+        }
+        else
+            VBClLogError("cannot connect to Wayland registry\n");
+    }
+    else
+        VBClLogError("cannot connect to Wayland compositor\n");
+
+    if (!fConnected)
+        vbcl_wayland_hlp_dcp_disconnect(pCtx);
+
+    return fConnected;
+}
+
+
+/**
+ * Main loop for Wayland compositor events.
+ *
+ * All requests to Wayland compositor must be performed in context
+ * of this thread.
+ *
+ * @returns IPRT status code.
+ * @param   hThreadSelf         IPRT thread object.
+ * @param   pvUser              Context data.
+ */
+static DECLCALLBACK(int) vbcl_wayland_hlp_dcp_event_loop(RTTHREAD hThreadSelf, void *pvUser)
+{
+    vbox_wl_dcp_ctx_t *pCtx = (vbox_wl_dcp_ctx_t *)pvUser;
+    int rc = VERR_TRY_AGAIN;
+
+    if (vbcl_wayland_hlp_dcp_connect(pCtx))
+    {
+        /* Start listening Data Control Device interface. */
+        if (zwlr_data_control_device_v1_add_listener(pCtx->pDataDevice, &g_data_device_listener, (void *)pCtx) == 0)
+        {
+            /* Tell parent thread we are ready. */
+            RTThreadUserSignal(hThreadSelf);
+
+            while (1)
+            {
+                rc = vbcl_wayland_hlp_dcp_next_event(pCtx);
+                if (   rc != VERR_TIMEOUT
+                    && RT_FAILURE(rc))
+                {
+                    VBClLogError("cannot read event from Wayland, rc=%Rrc\n", rc);
+                }
+
+                if (pCtx->fSendToGuest.reset())
+                {
+                    rc = vbcl_wayland_session_join(&pCtx->Session.Base,
+                                                   &vbcl_wayland_hlp_dcp_hg_clip_report_join2_cb,
+                                                   NULL);
+                }
+
+                /* Handle graceful thread termination. */
+                if (pCtx->fShutdown)
+                {
+                    rc = VINF_SUCCESS;
+                    break;
+                }
+            }
+        }
+        else
+        {
+            rc = VERR_NOT_SUPPORTED;
+            VBClLogError("cannot subscribe to Data Control Device events\n");
+        }
+
+        vbcl_wayland_hlp_dcp_disconnect(pCtx);
+    }
+
+    /* Notify parent thread if we failed to start, so it won't be
+     * waiting 30 sec to figure this out. */
+    if (RT_FAILURE(rc))
+        RTThreadUserSignal(hThreadSelf);
+
+    return rc;
+}
 
 /**
@@ -33 +1276 @@
 static DECLCALLBACK(int) vbcl_wayland_hlp_dcp_probe(void)
 {
-    return VBOX_WAYLAND_HELPER_CAP_NONE;
+    vbox_wl_dcp_ctx_t probeCtx;
+    int fCaps = VBOX_WAYLAND_HELPER_CAP_NONE;
+    VBGHDISPLAYSERVERTYPE enmDisplayServerType = VBGHDisplayServerTypeDetect();
+
+    vbcl_wayland_hlp_dcp_reset_ctx(&probeCtx, false /* fShutdown */);
+    vbcl_wayland_session_init(&probeCtx.Session.Base);
+
+    if (VBGHDisplayServerTypeIsWaylandAvailable(enmDisplayServerType))
+    {
+        if (vbcl_wayland_hlp_dcp_connect(&probeCtx))
+        {
+            fCaps |= VBOX_WAYLAND_HELPER_CAP_CLIPBOARD;
+            vbcl_wayland_hlp_dcp_disconnect(&probeCtx);
+        }
+    }
+
+    return fCaps;
 }
 
@@ -41 +1300 @@
 RTDECL(int) vbcl_wayland_hlp_dcp_init(void)
 {
-    return VERR_NOT_SUPPORTED;
+    vbcl_wayland_hlp_dcp_reset_ctx(&g_DcpCtx, false /* fShutdown */);
+    vbcl_wayland_session_init(&g_DcpCtx.Session.Base);
+
+    return VBClClipboardThreadStart(&g_DcpCtx.Thread, vbcl_wayland_hlp_dcp_event_loop, "wl-dcp", &g_DcpCtx);
 }
 
@@ -49 +1311 @@
 RTDECL(int) vbcl_wayland_hlp_dcp_term(void)
 {
-    return VERR_NOT_SUPPORTED;
+    int rc;
+    int rcThread = 0;
+
+    /* Set termination flag. Wayland event loop should pick it up
+     * on the next iteration. */
+    g_DcpCtx.fShutdown = true;
+
+    /* Wait for Wayland event loop thread to shutdown. */
+    rc = RTThreadWait(g_DcpCtx.Thread, RT_MS_30SEC, &rcThread);
+    if (RT_SUCCESS(rc))
+        VBClLogInfo("Wayland event thread exited with status, rc=%Rrc\n", rcThread);
+    else
+        VBClLogError("unable to stop Wayland event thread, rc=%Rrc\n", rc);
+
+    return rc;
+}
+
+/**
+ * @interface_method_impl{VBCLWAYLANDHELPER,pfnSetClipboardCtx}
+ */
+static DECLCALLBACK(void) vbcl_wayland_hlp_dcp_set_clipboard_ctx(PVBGLR3SHCLCMDCTX pCtx)
+{
+    g_DcpCtx.pClipboardCtx = pCtx;
+}
+
+/**
+ * @interface_method_impl{VBCLWAYLANDHELPER,pfnPopup}
+ */
+static DECLCALLBACK(int) vbcl_wayland_hlp_dcp_popup(void)
+{
+    return VINF_SUCCESS;
+}
+
+/**
+ * Session callback: Copy clipboard to the guest.
+ *
+ * This callback must be executed in context of Wayland event thread
+ * in order to be able to inject clipboard content into Wayland. It is
+ * triggered when Wayland client already decided data in which format
+ * it wants to request.
+ *
+ * This callback (1) sets requested clipboard format to the session,
+ * (2) waits for clipboard data to be copied from the host, (3) converts
+ * host clipboard data into guest representation, and (4) sends clipboard
+ * to the guest by writing given file descriptor.
+ *
+ * @returns IPRT status code.
+ * @param   enmSessionType      Session type, must be verified as
+ *                              a consistency check.
+ * @param   pvUser              User data (Wayland I/O context).
+ */
+static DECLCALLBACK(int) vbcl_wayland_hlp_dcp_hg_clip_report_join3_cb(
+    vbcl_wl_session_type_t enmSessionType, void *pvUser)
+{
+    struct vbcl_wl_dcp_write_ctx *pPriv = (struct vbcl_wl_dcp_write_ctx *)pvUser;
+    AssertPtrReturn(pPriv, VERR_INVALID_PARAMETER);
+
+    void *pvBuf;
+    uint32_t cbBuf;
+
+    int rc = (enmSessionType == VBCL_WL_CLIPBOARD_SESSION_TYPE_COPY_TO_GUEST)
+             ? VINF_SUCCESS : VERR_WRONG_ORDER;
+
+    VBCL_LOG_CALLBACK;
+
+    if (RT_SUCCESS(rc))
+    {
+        if (RT_VALID_PTR(g_DcpCtx.pClipboardCtx))
+        {
+            /* Set requested format to the session. */
+            g_DcpCtx.Session.clip.uFmt.set(VBoxMimeConvGetIdByMime(pPriv->sMimeType));
+
+            /* Wait for data in requested format. */
+            pvBuf = (void *)g_DcpCtx.Session.clip.pvClipboardBuf.wait();
+            cbBuf = g_DcpCtx.Session.clip.cbClipboardBuf.wait();
+            if (   cbBuf != g_DcpCtx.Session.clip.cbClipboardBuf.defaults()
+                && pvBuf != (void *)g_DcpCtx.Session.clip.pvClipboardBuf.defaults())
+            {
+                void *pvBufOut;
+                size_t cbOut;
+
+                /* Convert clipboard data from VBox representation into guest format. */
+                rc = VBoxMimeConvVBoxToNative(pPriv->sMimeType, pvBuf, cbBuf, &pvBufOut, &cbOut);
+                if (RT_SUCCESS(rc))
+                {
+                    rc = vbcl_wayland_hlp_dcp_write_wl_fd(pPriv->fd, pvBufOut, cbOut);
+                    RTMemFree(pvBufOut);
+                }
+                else
+                    VBClLogError("cannot convert '%s' to native format, rc=%Rrc\n", rc);
+            }
+            else
+                rc = VERR_TIMEOUT;
+        }
+        else
+        {
+            VBClLogVerbose(2, "cannot send to guest, no host service connection yet\n");
+            rc = VERR_TRY_AGAIN;
+        }
+
+        g_DcpCtx.fIngnoreWlClipIn = false;
+    }
+
+    return rc;
+}
+
+/**
+ * Enumeration callback used for sending clipboard offers to Wayland client.
+ *
+ * When host announces its clipboard content, this call back is used in order
+ * to send corresponding offers to other Wayland clients.
+ *
+ * Callback must be executed in context of Wayland event thread.
+ *
+ * @param   pcszMimeType    Mime-type to advertise.
+ * @param   pvUser          User data (DCP data source object).
+ */
+static DECLCALLBACK(void) vbcl_wayland_hlp_dcp_send_offers(const char *pcszMimeType, void *pvUser)
+{
+    zwlr_data_control_source_v1 *pDataSource = (zwlr_data_control_source_v1 *)pvUser;
+    zwlr_data_control_source_v1_offer(pDataSource, pcszMimeType);
+}
+
+/**
+ * Session callback: Advertise clipboard to the guest.
+ *
+ * This callback must be executed in context of Wayland event thread
+ * in order to be able to inject clipboard content into Wayland.
+ *
+ * This callback (1) prevents Wayland event loop from processing
+ * incoming clipboard advertisements before sending any data to
+ * other Wayland clients (this is needed in order to avoid feedback
+ * loop from our own advertisements), (2) waits for the list of clipboard
+ * formats available on the host side (set by vbcl_wayland_hlp_dcp_hg_clip_report_join_cb),
+ * and (3) sends data offers for available host clipboard to other clients.
+ *
+ * @returns IPRT status code.
+ * @param   enmSessionType      Session type, must be verified as
+ *                              a consistency check.
+ * @param   pvUser              User data (unused).
+ */
+static DECLCALLBACK(int) vbcl_wayland_hlp_dcp_hg_clip_report_join2_cb(
+    vbcl_wl_session_type_t enmSessionType, void *pvUser)
+{
+    int rc = (enmSessionType == VBCL_WL_CLIPBOARD_SESSION_TYPE_COPY_TO_GUEST)
+             ? VINF_SUCCESS : VERR_WRONG_ORDER;
+
+    RT_NOREF(pvUser);
+
+    VBCL_LOG_CALLBACK;
+
+    if (RT_SUCCESS(rc))
+    {
+        g_DcpCtx.fIngnoreWlClipIn = true;
+
+        SHCLFORMATS fFmts = g_DcpCtx.Session.clip.fFmts.wait();
+        if (fFmts != g_DcpCtx.Session.clip.fFmts.defaults())
+        {
+            zwlr_data_control_source_v1 *pDataSource =
+            zwlr_data_control_manager_v1_create_data_source(g_DcpCtx.pDataControlManager);
+
+            if (RT_VALID_PTR(pDataSource))
+            {
+                zwlr_data_control_source_v1_add_listener(
+                    (struct zwlr_data_control_source_v1 *)pDataSource, &g_data_source_listener, &g_DcpCtx);
+
+                VBoxMimeConvEnumerateMimeById(fFmts,
+                                              vbcl_wayland_hlp_dcp_send_offers,
+                                              pDataSource);
+
+                zwlr_data_control_device_v1_set_selection(g_DcpCtx.pDataDevice, pDataSource);
+            }
+            else
+                rc = VERR_NO_MEMORY;
+        }
+        else
+            rc = VERR_NO_DATA;
+    }
+
+    return rc;
+}
+
+/**
+ * Session callback: Copy clipboard from the host.
+ *
+ * This callback (1) sets host clipboard formats list to the session,
+ * (2) asks Wayland event thread to advertise these formats to the guest,
+ * (3) waits for guest to request clipboard in specific format, (4) read
+ * host clipboard in this format, and (5) sets clipboard data to the session,
+ * so Wayland events thread can inject it into the guest.
+ *
+ * This callback should not return until clipboard data is read from
+ * the host or error occurred. It must block host events loop until
+ * current host event is fully processed.
+ *
+ * @returns IPRT status code.
+ * @param   enmSessionType      Session type, must be verified as
+ *                              a consistency check.
+ * @param   pvUser              User data (host clipboard formats).
+ */
+static DECLCALLBACK(int) vbcl_wayland_hlp_dcp_hg_clip_report_join_cb(
+    vbcl_wl_session_type_t enmSessionType, void *pvUser)
+{
+    SHCLFORMATS *pfFmts = (SHCLFORMATS *)pvUser;
+    AssertPtrReturn(pfFmts, VERR_INVALID_PARAMETER);
+
+    int rc = (enmSessionType == VBCL_WL_CLIPBOARD_SESSION_TYPE_COPY_TO_GUEST)
+             ? VINF_SUCCESS : VERR_WRONG_ORDER;
+
+    VBCL_LOG_CALLBACK;
+
+    if (RT_SUCCESS(rc))
+    {
+        SHCLFORMAT uFmt;
+        void *pvData;
+        uint32_t cbData;
+
+        /* Set list of host clipboard formats to the session. */
+        g_DcpCtx.Session.clip.fFmts.set(*pfFmts);
+
+        /* Ask Wayland event thread to advertise formats to the guest. */
+        g_DcpCtx.fSendToGuest.set(true);
+        RTThreadPoke(g_DcpCtx.Thread);
+
+        /* Wait for the guest to request certain clipboard format. */
+        uFmt = g_DcpCtx.Session.clip.uFmt.wait();
+        if (uFmt != g_DcpCtx.Session.clip.uFmt.defaults())
+        {
+            /* Read host clipboard in specified format. */
+            rc = VBClClipboardReadHostClipboard(g_DcpCtx.pClipboardCtx, uFmt, &pvData, &cbData);
+            if (RT_SUCCESS(rc))
+            {
+                /* Set clipboard data to the session. */
+                g_DcpCtx.Session.clip.pvClipboardBuf.set((uint64_t)pvData);
+                g_DcpCtx.Session.clip.cbClipboardBuf.set((uint64_t)cbData);
+            }
+        }
+        else
+            rc = VERR_TIMEOUT;
+
+    }
+
+    return rc;
+}
+
+/**
+ * @interface_method_impl{VBCLWAYLANDHELPER,pfnHGClipReport}
+ */
+static int vbcl_wayland_hlp_dcp_hg_clip_report(SHCLFORMATS fFormats)
+{
+    int rc = VERR_NO_DATA;
+
+    VBCL_LOG_CALLBACK;
+
+    if (fFormats != VBOX_SHCL_FMT_NONE)
+    {
+        rc = vbcl_wayland_session_end(&g_DcpCtx.Session.Base, NULL, NULL);
+        if (RT_SUCCESS(rc))
+        {
+            rc = vbcl_wayland_session_start(&g_DcpCtx.Session.Base,
+                                            VBCL_WL_CLIPBOARD_SESSION_TYPE_COPY_TO_GUEST,
+                                            &vbcl_wayland_hlp_dcp_session_start_generic_cb,
+                                            NULL);
+
+            if (RT_SUCCESS(rc))
+                rc = vbcl_wayland_session_join(&g_DcpCtx.Session.Base,
+                                               vbcl_wayland_hlp_dcp_hg_clip_report_join_cb,
+                                               &fFormats);
+        }
+        else
+            VBClLogError("unable to start session, previous session is still running rc=%Rrc\n", rc);
+    }
+
+    return rc;
+}
+
+/**
+ * Session callback: Copy clipboard to the host.
+ *
+ * This callback sets clipboard format to the session as requested
+ * by host, waits for guest clipboard data in requested format and
+ * sends data to the host.
+ *
+ * This callback should not return until clipboard data is sent to
+ * the host or error occurred. It must block host events loop until
+ * current host event is fully processed.
+ *
+ * @returns IPRT status code.
+ * @param   enmSessionType      Session type, must be verified as
+ *                              a consistency check.
+ * @param   pvUser              User data (requested format).
+ */
+static DECLCALLBACK(int) vbcl_wayland_hlp_dcp_gh_clip_read_join_cb(
+    vbcl_wl_session_type_t enmSessionType, void *pvUser)
+{
+    SHCLFORMAT *puFmt = (SHCLFORMAT *)pvUser;
+    AssertPtrReturn(puFmt, VERR_INVALID_PARAMETER);
+
+    int rc = (enmSessionType == VBCL_WL_CLIPBOARD_SESSION_TYPE_COPY_TO_HOST)
+             ? VINF_SUCCESS : VERR_WRONG_ORDER;
+
+    VBCL_LOG_CALLBACK;
+
+    if (RT_SUCCESS(rc))
+    {
+        void *pvData;
+        size_t cbData;
+
+        /* Store requested clipboard format to the session. */
+        g_DcpCtx.Session.clip.uFmt.set(*puFmt);
+
+        /* Wait for data in requested format. */
+        pvData = (void *)g_DcpCtx.Session.clip.pvClipboardBuf.wait();
+        cbData = g_DcpCtx.Session.clip.cbClipboardBuf.wait();
+        if (   cbData != g_DcpCtx.Session.clip.cbClipboardBuf.defaults()
+            && pvData != (void *)g_DcpCtx.Session.clip.pvClipboardBuf.defaults())
+        {
+            /* Send clipboard data to the host. */
+            rc = VbglR3ClipboardWriteDataEx(g_DcpCtx.pClipboardCtx, *puFmt, pvData, cbData);
+        }
+        else
+            rc = VERR_TIMEOUT;
+    }
+
+    return rc;
+}
+
+/**
+ * @interface_method_impl{VBCLWAYLANDHELPER,pfnGHClipRead}
+ */
+static int vbcl_wayland_hlp_dcp_gh_clip_read(SHCLFORMAT uFmt)
+{
+    int rc;
+
+    VBCL_LOG_CALLBACK;
+
+    rc = vbcl_wayland_session_join(&g_DcpCtx.Session.Base,
+                                   &vbcl_wayland_hlp_dcp_gh_clip_read_join_cb,
+                                   &uFmt);
+    return rc;
 }
 
@@ -55 +1656 @@
 const VBCLWAYLANDHELPER g_WaylandHelperDcp =
 {
-    "wayland-dcp",                  /* .pszName */
-    vbcl_wayland_hlp_dcp_probe,     /* .pfnProbe */
-    vbcl_wayland_hlp_dcp_init,      /* .pfnInit */
-    vbcl_wayland_hlp_dcp_term,      /* .pfnTerm */
+    "wayland-dcp",                              /* .pszName */
+    vbcl_wayland_hlp_dcp_probe,                 /* .pfnProbe */
+    vbcl_wayland_hlp_dcp_init,                  /* .pfnInit */
+    vbcl_wayland_hlp_dcp_term,                  /* .pfnTerm */
+    vbcl_wayland_hlp_dcp_set_clipboard_ctx,     /* .pfnSetClipboardCtx */
+    vbcl_wayland_hlp_dcp_popup,                 /* .pfnPopup */
+    vbcl_wayland_hlp_dcp_hg_clip_report,        /* .pfnHGClipReport */
+    vbcl_wayland_hlp_dcp_gh_clip_read,          /* .pfnGHClipRead */
 };

trunk/src/VBox/Additions/x11/VBoxClient/wayland-helper-gtk.cpp

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * Guest Additions - Wayland Desktop Environment helper which uses GTK library.
+ * Guest Additions - Gtk helper for Wayland.
+ *
+ * This module implements Shared Clipboard and Drag-n-Drop
+ * support for Wayland guests using Gtk library.
  */
 
@@ -26 +29 @@
  */
 
+#include <iprt/localipc.h>
+#include <iprt/rand.h>
+#include <iprt/semaphore.h>
+
+#include <VBox/GuestHost/DisplayServerType.h>
+#include <VBox/GuestHost/clipboard-helper.h>
+#include <VBox/GuestHost/mime-type-converter.h>
+
+#include "VBoxClient.h"
+#include "clipboard.h"
 #include "wayland-helper.h"
+#include "wayland-helper-ipc.h"
+
+#include "vbox-gtk.h"
+
+/** Gtk session data.
+ *
+ * A structure which accumulates all the necessary data required to
+ * maintain session between host and Wayland for clipboard sharing
+ * and drag-n-drop.*/
+typedef struct
+{
+    /* Generic VBoxClient Wayland session data (synchronization point). */
+    vbcl_wl_session_t                       Base;
+    /** Randomly generated session ID, should be used by
+     *  both VBoxClient and vboxwl tool. */
+    uint32_t                                uSessionId;
+    /** IPC connection flow control between VBoxClient and vboxwl tool. */
+    vbcl::ipc::clipboard::ClipboardIpc      *oClipboardIpc;
+    /** IPC connection handle. */
+    RTLOCALIPCSESSION                       hIpcSession;
+    /** Popup window process handle. */
+    RTPROCESS                               popupProc;
+} vbox_wl_gtk_ipc_session_t;
+
+/**
+ * A set of objects required to handle clipboard sharing over
+ * and drag-n-drop using Gtk library.. */
+typedef struct
+{
+    /** Wayland event loop thread. */
+    RTTHREAD                                Thread;
+
+    /** A flag which indicates that Wayland event loop should terminate. */
+    volatile bool                           fShutdown;
+
+    /** Communication session between host event loop and Wayland. */
+    vbox_wl_gtk_ipc_session_t               Session;
+
+    /** Connection to the host clipboard service. */
+    PVBGLR3SHCLCMDCTX                       pClipboardCtx;
+
+    /** Local IPC server object. */
+    RTLOCALIPCSERVER                        hIpcServer;
+} vbox_wl_gtk_ctx_t;
+
+/** Helper context. */
+static vbox_wl_gtk_ctx_t g_GtkCtx;
+
+/**
+ * Start popup process.
+ *
+ * @returns IPRT status code.
+ * @param   pSession    Session data.
+ */
+static int vbcl_wayland_hlp_gtk_session_popup(vbox_wl_gtk_ipc_session_t *pSession)
+{
+    int rc = VINF_SUCCESS;
+
+    /* Make sure valid session is in progress. */
+    AssertReturn(pSession->uSessionId > 0, VERR_INVALID_PARAMETER);
+
+    char *pszSessionId = RTStrAPrintf2("%u", pSession->uSessionId);
+    if (RT_VALID_PTR(pszSessionId))
+    {
+        /* List of vboxwl command line arguments.*/
+        const char *apszArgs[] =
+        {
+            VBOXWL_PATH,
+            NULL,
+            VBOXWL_ARG_SESSION_ID,
+            pszSessionId,
+            NULL,
+            NULL
+        };
+
+        /* Log verbosity level to be passed to vboxwl. */
+        char pszVerobsity[  VBOXWL_VERBOSITY_MAX
+                          + 2 /* add space for '-' and '\0' */];
+        RT_ZERO(pszVerobsity);
+
+        /* Select vboxwl action depending on session type. */
+        if      (pSession->Base.enmType == VBCL_WL_CLIPBOARD_SESSION_TYPE_COPY_TO_GUEST)
+            apszArgs[1] = VBOXWL_ARG_CLIP_HG_COPY;
+        else if (pSession->Base.enmType == VBCL_WL_CLIPBOARD_SESSION_TYPE_ANNOUNCE_TO_HOST)
+            apszArgs[1] = VBOXWL_ARG_CLIP_GH_ANNOUNCE;
+        else if (pSession->Base.enmType == VBCL_WL_CLIPBOARD_SESSION_TYPE_COPY_TO_HOST)
+            apszArgs[1] = VBOXWL_ARG_CLIP_GH_COPY;
+        else
+            rc = VERR_INVALID_PARAMETER;
+
+        /* Once VBoxClient was started with log verbosity level, pass the
+         * same verbosity level to vboxwl as well. */
+        if (   RT_SUCCESS(rc)
+            && g_cVerbosity > 0)
+        {
+            pszVerobsity[0] = '-';
+
+            memset(&pszVerobsity[1], 'v',
+                   RT_MIN(g_cVerbosity, VBOXWL_VERBOSITY_MAX));
+
+            /* Insert verbosity level into the rest of vboxwl
+             * command line arguments. */
+            apszArgs[4] = pszVerobsity;
+        }
+
+        /* Run vboxwl in background. */
+        if (RT_SUCCESS(rc))
+            rc = RTProcCreate(VBOXWL_PATH,
+                              apszArgs, RTENV_DEFAULT,
+                              RTPROC_FLAGS_SEARCH_PATH, &pSession->popupProc);
+
+        VBClLogVerbose(2, "start '%s' command [sid=%u]: rc=%Rrc\n",
+                       VBOXWL_PATH, pSession->uSessionId, rc);
+
+        RTStrFree(pszSessionId);
+    }
+    else
+        rc = VERR_NO_MEMORY;
+
+    return rc;
+}
+
+/**
+ * Prepare new session and start popup process.
+ *
+ * @returns IPRT status code.
+ * @param   pSession        Session data.
+ */
+static int vbcl_wayland_hlp_gtk_session_prepare(vbox_wl_gtk_ipc_session_t *pSession)
+{
+    int rc = VINF_SUCCESS;
+
+    /* Make sure there is no leftovers from previous session. */
+    Assert(pSession->uSessionId == 0);
+
+    /* Initialize session. */
+    pSession->uSessionId = RTRandU32Ex(1, 0xFFFFFFFF);
+
+    pSession->oClipboardIpc = new vbcl::ipc::clipboard::ClipboardIpc();
+    if (RT_VALID_PTR(pSession->oClipboardIpc))
+    {
+        pSession->oClipboardIpc->init(vbcl::ipc::FLOW_DIRECTION_SERVER,
+                                      pSession->uSessionId);
+    }
+    else
+        rc = VERR_NO_MEMORY;
+
+    /* Start helper tool. */
+    if (RT_SUCCESS(rc))
+    {
+        rc = vbcl_wayland_hlp_gtk_session_popup(pSession);
+        VBClLogVerbose(1, "session id=%u: started: rc=%Rrc\n",
+                       pSession->uSessionId, rc);
+    }
+
+    return rc;
+}
+
+/**
+ * Session callback: Generic session initializer.
+ *
+ * This callback starts new session.
+ *
+ * @returns IPRT status code.
+ * @param   enmSessionType      Session type (unused).
+ * @param   pvUser              User data (unused).
+ */
+static DECLCALLBACK(int) vbcl_wayland_hlp_gtk_session_start_generic_cb(
+    vbcl_wl_session_type_t enmSessionType, void *pvUser)
+{
+    RT_NOREF(enmSessionType, pvUser);
+
+    VBCL_LOG_CALLBACK;
+
+    return vbcl_wayland_hlp_gtk_session_prepare(&g_GtkCtx.Session);
+}
+
+/**
+ * Reset session, terminate popup process and free allocated resources.
+ *
+ * @returns IPRT status code.
+ * @param   enmSessionType      Session type (unused).
+ * @param   pvUser              User data (session to reset).
+ */
+static DECLCALLBACK(int) vbcl_wayland_hlp_gtk_session_end_cb(
+    vbcl_wl_session_type_t enmSessionType, void *pvUser)
+{
+    vbox_wl_gtk_ipc_session_t *pSession = (vbox_wl_gtk_ipc_session_t *)pvUser;
+    AssertPtrReturn(pSession, VERR_INVALID_PARAMETER);
+
+    int rc;
+
+    RT_NOREF(enmSessionType);
+
+    /* Make sure valid session is in progress. */
+    AssertReturn(pSession->uSessionId > 0, VERR_INVALID_PARAMETER);
+
+    rc = RTProcWait(pSession->popupProc, RTPROCWAIT_FLAGS_BLOCK, NULL);
+    if (RT_FAILURE(rc))
+        rc = RTProcTerminate(pSession->popupProc);
+    if (RT_FAILURE(rc))
+    {
+        VBClLogError("session %u: unable to stop popup window process: rc=%Rrc\n",
+                     pSession->uSessionId, rc);
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        pSession->uSessionId = 0;
+
+        pSession->oClipboardIpc->reset();
+        delete pSession->oClipboardIpc;
+    }
+
+    return rc;
+}
+
+/**
+ * Session callback: Handle sessions started by host events.
+ *
+ * @returns IPRT status code.
+ * @param   enmSessionType      Session type, must be verified as
+ *                              a consistency check.
+ * @param   pvUser              User data (IPC connection handle
+ *                              to vboxwl tool).
+ */
+static DECLCALLBACK(int) vbcl_wayland_hlp_gtk_worker_join_cb(
+    vbcl_wl_session_type_t enmSessionType, void *pvUser)
+{
+    PRTLOCALIPCSESSION phIpcSession = (RTLOCALIPCSESSION *)pvUser;
+    AssertPtrReturn(phIpcSession, VERR_INVALID_PARAMETER);
+
+    const vbcl::ipc::flow_t     *pFlow;
+
+    int rc = VINF_SUCCESS;
+
+    VBCL_LOG_CALLBACK;
+
+    /* Make sure valid session is in progress. */
+    AssertReturn(g_GtkCtx.Session.uSessionId > 0, VERR_INVALID_PARAMETER);
+
+    /* Select corresponding IPC flow depending on session type. */
+    if      (enmSessionType == VBCL_WL_CLIPBOARD_SESSION_TYPE_COPY_TO_GUEST)
+        pFlow = vbcl::ipc::clipboard::HGCopyFlow;
+    else if (enmSessionType == VBCL_WL_CLIPBOARD_SESSION_TYPE_ANNOUNCE_TO_HOST)
+        pFlow = vbcl::ipc::clipboard::GHAnnounceAndCopyFlow;
+    else if (enmSessionType == VBCL_WL_CLIPBOARD_SESSION_TYPE_COPY_TO_HOST)
+        pFlow = vbcl::ipc::clipboard::GHCopyFlow;
+    else
+        rc = VERR_INVALID_PARAMETER;
+
+    /* Proceed with selected flow. */
+    if (RT_SUCCESS(rc))
+        rc = g_GtkCtx.Session.oClipboardIpc->flow(pFlow, *phIpcSession);
+
+    return rc;
+}
+
+/**
+ * IPC server thread worker.
+ *
+ * @returns IPRT status code.
+ * @param   hThreadSelf     IPRT thread handle.
+ * @param   pvUser          Helper context data.
+ */
+static DECLCALLBACK(int) vbcl_wayland_hlp_gtk_worker(RTTHREAD hThreadSelf, void *pvUser)
+{
+    int rc;
+
+    vbox_wl_gtk_ctx_t *pCtx = (vbox_wl_gtk_ctx_t *)pvUser;
+    char szIpcServerName[128];
+
+    RTThreadUserSignal(hThreadSelf);
+
+    VBClLogVerbose(1, "starting IPC\n");
+
+    rc = vbcl_wayland_hlp_gtk_ipc_srv_name(szIpcServerName, sizeof(szIpcServerName));
+
+    if (RT_SUCCESS(rc))
+        rc = RTLocalIpcServerCreate(&pCtx->hIpcServer, szIpcServerName, 0);
+
+    if (RT_SUCCESS(rc))
+        rc = RTLocalIpcServerSetAccessMode(pCtx->hIpcServer, RTFS_UNIX_IRUSR | RTFS_UNIX_IWUSR);
+
+    if (RT_SUCCESS(rc))
+    {
+        VBClLogVerbose(1, "started IPC server '%s'\n", szIpcServerName);
+
+        vbcl_wayland_session_init(&pCtx->Session.Base);
+
+        while (!ASMAtomicReadBool(&pCtx->fShutdown))
+        {
+            RTLOCALIPCSESSION hClientSession;
+
+            rc = RTLocalIpcServerListen(pCtx->hIpcServer, &hClientSession);
+            if (RT_SUCCESS(rc))
+            {
+                RTUID uUid;
+
+                /* Authenticate remote user. Only allow connection from
+                 * process who belongs to the same UID. */
+                rc = RTLocalIpcSessionQueryUserId(hClientSession, &uUid);
+                if (RT_SUCCESS(rc))
+                {
+                    RTUID uLocalUID = geteuid();
+                    if (   uLocalUID != 0
+                        && uLocalUID == uUid)
+                    {
+                        VBClLogVerbose(1, "new IPC connection\n");
+
+                        rc = vbcl_wayland_session_join(&pCtx->Session.Base,
+                                                       &vbcl_wayland_hlp_gtk_worker_join_cb,
+                                                       &hClientSession);
+
+                        VBClLogVerbose(1, "IPC flow completed, rc=%Rrc\n", rc);
+
+                        rc = vbcl_wayland_session_end(&pCtx->Session.Base,
+                                                      &vbcl_wayland_hlp_gtk_session_end_cb,
+                                                      &pCtx->Session);
+                        VBClLogVerbose(1, "IPC session ended, rc=%Rrc\n", rc);
+
+                    }
+                    else
+                        VBClLogError("incoming IPC connection rejected: UID mismatch: %d/%d\n",
+                                     uLocalUID, uUid);
+                }
+                else
+                    VBClLogError("failed to get remote IPC UID, rc=%Rrc\n", rc);
+
+                RTLocalIpcSessionClose(hClientSession);
+            }
+            else if (rc != VERR_CANCELLED)
+                VBClLogVerbose(1, "IPC connection has failed, rc=%Rrc\n", rc);
+        }
+
+        rc = RTLocalIpcServerDestroy(pCtx->hIpcServer);
+    }
+    else
+        VBClLogError("failed to start IPC, rc=%Rrc\n", rc);
+
+    VBClLogVerbose(1, "IPC stopped\n");
+
+    return rc;
+}
 
 /**
@@ -33 +390 @@
 static DECLCALLBACK(int) vbcl_wayland_hlp_gtk_probe(void)
 {
-    return VBOX_WAYLAND_HELPER_CAP_NONE;
+    int fCaps = VBOX_WAYLAND_HELPER_CAP_NONE;
+
+    if (VBGHDisplayServerTypeIsGtkAvailable())
+        fCaps |= VBOX_WAYLAND_HELPER_CAP_CLIPBOARD;
+
+    return fCaps;
 }
 
@@ -41 +403 @@
 RTDECL(int) vbcl_wayland_hlp_gtk_init(void)
 {
-    return VERR_NOT_SUPPORTED;
+    VBCL_LOG_CALLBACK;
+
+    RT_ZERO(g_GtkCtx);
+
+    return VBClClipboardThreadStart(&g_GtkCtx.Thread, vbcl_wayland_hlp_gtk_worker, "wl-gtk-ipc", &g_GtkCtx);
 }
 
@@ -49 +415 @@
 RTDECL(int) vbcl_wayland_hlp_gtk_term(void)
 {
-    return VERR_NOT_SUPPORTED;
+    int rc;
+    int rcThread = 0;
+
+    /* Set termination flag. */
+    g_GtkCtx.fShutdown = true;
+
+    /* Cancel IPC loop. */
+    rc = RTLocalIpcServerCancel(g_GtkCtx.hIpcServer);
+    if (RT_FAILURE(rc))
+        VBClLogError("unable to notify IPC server about shutdown, rc=%Rrc\n", rc);
+
+    if (RT_SUCCESS(rc))
+    {
+        /* Wait for Gtk event loop thread to shutdown. */
+        rc = RTThreadWait(g_GtkCtx.Thread, RT_MS_30SEC, &rcThread);
+        VBClLogInfo("gtk event thread exited with status, rc=%Rrc\n", rcThread);
+    }
+    else
+        VBClLogError("unable to stop gtk thread, rc=%Rrc\n", rc);
+
+    return rc;
+}
+
+/**
+ * @interface_method_impl{VBCLWAYLANDHELPER,pfnSetClipboardCtx}
+ */
+static DECLCALLBACK(void) vbcl_wayland_hlp_gtk_set_clipboard_ctx(PVBGLR3SHCLCMDCTX pCtx)
+{
+    g_GtkCtx.pClipboardCtx = pCtx;
+}
+
+/**
+ * Session callback: Announce clipboard to the host.
+ *
+ * This callback (1) waits for the guest to report its clipboard content
+ * via IPC connection from vboxwl tool, and (2) reports these formats
+ * to the host.
+ *
+ * @returns IPRT status code.
+ * @param   enmSessionType      Session type, must be verified as
+ *                              a consistency check.
+ * @param   pvUser              User data (unused).
+ */
+static DECLCALLBACK(int) vbcl_wayland_hlp_gtk_popup_join_cb(
+    vbcl_wl_session_type_t enmSessionType, void *pvUser)
+{
+    int rc = (enmSessionType == VBCL_WL_CLIPBOARD_SESSION_TYPE_ANNOUNCE_TO_HOST)
+             ? VINF_SUCCESS : VERR_WRONG_ORDER;
+
+    RT_NOREF(pvUser);
+
+    VBCL_LOG_CALLBACK;
+
+    if (RT_SUCCESS(rc))
+    {
+        SHCLFORMATS fFmts = g_GtkCtx.Session.oClipboardIpc->m_fFmts.wait();
+        if (fFmts !=  g_GtkCtx.Session.oClipboardIpc->m_fFmts.defaults())
+            rc = VbglR3ClipboardReportFormats(g_GtkCtx.pClipboardCtx->idClient, fFmts);
+        else
+            rc = VERR_TIMEOUT;
+    }
+
+    return rc;
+}
+
+/**
+ * @interface_method_impl{VBCLWAYLANDHELPER,pfnPopup}
+ */
+static DECLCALLBACK(int) vbcl_wayland_hlp_gtk_popup(void)
+{
+    int rc;
+
+    VBCL_LOG_CALLBACK;
+
+    rc = vbcl_wayland_session_start(&g_GtkCtx.Session.Base,
+                                    VBCL_WL_CLIPBOARD_SESSION_TYPE_ANNOUNCE_TO_HOST,
+                                    &vbcl_wayland_hlp_gtk_session_start_generic_cb,
+                                    &g_GtkCtx.Session);
+    if (RT_SUCCESS(rc))
+    {
+        rc = vbcl_wayland_session_join(&g_GtkCtx.Session.Base,
+                                       &vbcl_wayland_hlp_gtk_popup_join_cb,
+                                       NULL);
+    }
+
+    return rc;
+}
+
+/**
+ * Session callback: Copy clipboard from the host.
+ *
+ * This callback (1) sets host clipboard formats list to the session,
+ * (2) waits for guest to request clipboard in specific format, (3) read
+ * host clipboard in this format, and (4) sets clipboard data to the session,
+ * so Gtk event thread can inject it into the guest.
+ *
+ * This callback should not return until clipboard data is read from
+ * the host or error occurred. It must block host events loop until
+ * current host event is fully processed.
+ *
+ * @returns IPRT status code.
+ * @param   enmSessionType      Session type, must be verified as
+ *                              a consistency check.
+ * @param   pvUser              User data (host clipboard formats).
+ */
+static DECLCALLBACK(int) vbcl_wayland_hlp_gtk_hg_clip_report_join_cb(
+    vbcl_wl_session_type_t enmSessionType, void *pvUser)
+{
+    SHCLFORMATS *pfFmts = (SHCLFORMATS *)pvUser;
+    AssertPtrReturn(pfFmts, VERR_INVALID_PARAMETER);
+
+    SHCLFORMAT uFmt;
+
+    int rc =   (enmSessionType == VBCL_WL_CLIPBOARD_SESSION_TYPE_COPY_TO_GUEST)
+             ? VINF_SUCCESS : VERR_WRONG_ORDER;
+
+    VBCL_LOG_CALLBACK;
+
+    if (RT_SUCCESS(rc))
+    {
+        g_GtkCtx.Session.oClipboardIpc->m_fFmts.set(*pfFmts);
+
+        uFmt = g_GtkCtx.Session.oClipboardIpc->m_uFmt.wait();
+        if (uFmt != g_GtkCtx.Session.oClipboardIpc->m_uFmt.defaults())
+        {
+            void *pvData;
+            uint32_t cbData;
+
+            rc = VBClClipboardReadHostClipboard(g_GtkCtx.pClipboardCtx, uFmt, &pvData, &cbData);
+            if (RT_SUCCESS(rc))
+            {
+                g_GtkCtx.Session.oClipboardIpc->m_pvClipboardBuf.set((uint64_t)pvData);
+                g_GtkCtx.Session.oClipboardIpc->m_cbClipboardBuf.set((uint64_t)cbData);
+            }
+        }
+        else
+            rc = VERR_TIMEOUT;
+    }
+
+    return rc;
+}
+
+/**
+ * @interface_method_impl{VBCLWAYLANDHELPER,pfnHGClipReport}
+ */
+static int vbcl_wayland_hlp_gtk_hg_clip_report(SHCLFORMATS fFormats)
+{
+    int rc = VERR_NO_DATA;
+
+    VBCL_LOG_CALLBACK;
+
+    if (fFormats != VBOX_SHCL_FMT_NONE)
+    {
+        rc = vbcl_wayland_session_start(&g_GtkCtx.Session.Base,
+                                        VBCL_WL_CLIPBOARD_SESSION_TYPE_COPY_TO_GUEST,
+                                        &vbcl_wayland_hlp_gtk_session_start_generic_cb,
+                                        &g_GtkCtx.Session);
+        if (RT_SUCCESS(rc))
+        {
+            rc = vbcl_wayland_session_join(&g_GtkCtx.Session.Base,
+                                           &vbcl_wayland_hlp_gtk_hg_clip_report_join_cb,
+                                           &fFormats);
+        }
+    }
+
+    return rc;
+}
+
+/**
+ * Session callback: Copy clipboard to the host.
+ *
+ * This callback sets clipboard format to the session as requested
+ * by host, waits for guest clipboard data in requested format and
+ * sends data to the host.
+ *
+ * This callback should not return until clipboard data is sent to
+ * the host or error occurred. It must block host events loop until
+ * current host event is fully processed.
+ *
+ * @returns IPRT status code.
+ * @param   enmSessionType      Session type, must be verified as
+ *                              a consistency check.
+ * @param   pvUser              User data (requested format).
+ */
+static DECLCALLBACK(int) vbcl_wayland_hlp_gtk_gh_clip_read_join_cb(
+    vbcl_wl_session_type_t enmSessionType, void *pvUser)
+{
+    SHCLFORMAT *puFmt = (SHCLFORMAT *)pvUser;
+    AssertPtrReturn(puFmt, VERR_INVALID_PARAMETER);
+
+    int rc = (   enmSessionType == VBCL_WL_CLIPBOARD_SESSION_TYPE_COPY_TO_HOST
+              || enmSessionType == VBCL_WL_CLIPBOARD_SESSION_TYPE_ANNOUNCE_TO_HOST)
+             ? VINF_SUCCESS : VERR_WRONG_ORDER;
+
+    VBCL_LOG_CALLBACK;
+
+    if (RT_SUCCESS(rc))
+    {
+        void *pvData;
+        uint32_t cbData;
+
+        /* Store requested clipboard format to the session. */
+        g_GtkCtx.Session.oClipboardIpc->m_uFmt.set(*puFmt);
+
+        /* Wait for data in requested format. */
+        pvData = (void *)g_GtkCtx.Session.oClipboardIpc->m_pvClipboardBuf.wait();
+        cbData = g_GtkCtx.Session.oClipboardIpc->m_cbClipboardBuf.wait();
+        if (   cbData != g_GtkCtx.Session.oClipboardIpc->m_cbClipboardBuf.defaults()
+            && pvData != (void *)g_GtkCtx.Session.oClipboardIpc->m_pvClipboardBuf.defaults())
+        {
+            /* Send clipboard data to the host. */
+            rc = VbglR3ClipboardWriteDataEx(g_GtkCtx.pClipboardCtx, *puFmt, pvData, cbData);
+        }
+        else
+            rc = VERR_TIMEOUT;
+    }
+
+    return rc;
+}
+
+/**
+ * @interface_method_impl{VBCLWAYLANDHELPER,pfnGHClipRead}
+ */
+static int vbcl_wayland_hlp_gtk_gh_clip_read(SHCLFORMAT uFmt)
+{
+    int rc = VINF_SUCCESS;
+
+    VBCL_LOG_CALLBACK;
+
+    if (uFmt != VBOX_SHCL_FMT_NONE)
+    {
+        VBClLogVerbose(2, "host wants fmt 0x%x\n", uFmt);
+
+        /* This callback can be called in two cases:
+         *
+         * 1. Guest has just announced a list of its clipboard
+         *    formats to the host, and vboxwl tool is still running,
+         *    IPC session is still active as well. In this case the
+         *    host can immediately ask for content in specified format.
+         *
+         * 2. Guest has already announced list of its clipboard
+         *    formats to the host some time ago, vboxwl tool is no
+         *    longer running and IPC session is not active. In this
+         *    case some app on the host side might want to read
+         *    clipboard in specific format.
+         *
+         * In case (2), we need to start new IPC session and restart
+         * vboxwl tool again
+         */
+        if (!vbcl_wayland_session_is_started(&g_GtkCtx.Session.Base))
+        {
+            rc = vbcl_wayland_session_start(&g_GtkCtx.Session.Base,
+                                            VBCL_WL_CLIPBOARD_SESSION_TYPE_COPY_TO_HOST,
+                                            &vbcl_wayland_hlp_gtk_session_start_generic_cb,
+                                            NULL);
+        }
+
+        if (RT_SUCCESS(rc))
+        {
+            rc = vbcl_wayland_session_join(&g_GtkCtx.Session.Base,
+                                           &vbcl_wayland_hlp_gtk_gh_clip_read_join_cb,
+                                           &uFmt);
+        }
+    }
+
+    VBClLogVerbose(2, "vbcl_wayland_hlp_gtk_gh_clip_read ended rc=%Rrc\n", rc);
+
+    return rc;
 }
 
@@ -55 +688 @@
 const VBCLWAYLANDHELPER g_WaylandHelperGtk =
 {
-    "wayland-gtk",                  /* .pszName */
-    vbcl_wayland_hlp_gtk_probe,     /* .pfnProbe */
-    vbcl_wayland_hlp_gtk_init,      /* .pfnInit */
-    vbcl_wayland_hlp_gtk_term,      /* .pfnTerm */
+    "wayland-gtk",                              /* .pszName */
+    vbcl_wayland_hlp_gtk_probe,                 /* .pfnProbe */
+    vbcl_wayland_hlp_gtk_init,                  /* .pfnInit */
+    vbcl_wayland_hlp_gtk_term,                  /* .pfnTerm */
+    vbcl_wayland_hlp_gtk_set_clipboard_ctx,     /* .pfnSetClipboardCtx */
+    vbcl_wayland_hlp_gtk_popup,                 /* .pfnPopup */
+    vbcl_wayland_hlp_gtk_hg_clip_report,        /* .pfnHGClipReport */
+    vbcl_wayland_hlp_gtk_gh_clip_read,          /* .pfnGHClipRead */
 };

trunk/src/VBox/Additions/x11/VBoxClient/wayland-helper.h

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * Guest Additions - Definitions for Wayland Desktop Environments helpers.
+ * Guest Additions - Definitions for Wayland helpers.
  */
 
@@ -32 +32 @@
 #endif
 
-#include <iprt/cdefs.h>
-#include <iprt/err.h>
-
+#include <iprt/asm.h>
+#include <iprt/time.h>
+
+#include <VBox/VBoxGuestLib.h>
+#include <VBox/GuestHost/clipboard-helper.h>
+
+#include "clipboard.h"
 
 /** Helper capabilities list. */
+
+/** Indicates that helper does not support any functionality (initializer). */
+#define VBOX_WAYLAND_HELPER_CAP_NONE            (0)
+/** Indicates that helper supported shared clipboard functionality. */
+#define VBOX_WAYLAND_HELPER_CAP_CLIPBOARD       RT_BIT(1)
+/** Indicates that helper supported drag-and-drop functionality. */
+#define VBOX_WAYLAND_HELPER_CAP_DND             RT_BIT(2)
+
+/** Default time interval to wait for value to arrive over IPC. */
+#define VBCL_WAYLAND_VALUE_WAIT_TIMEOUT_MS      (1000)
+/** Default time interval to wait for clipboard content to arrive over IPC. */
+#define VBCL_WAYLAND_DATA_WAIT_TIMEOUT_MS       (2000)
+/** Generic relax interval while polling value changes. */
+#define VBCL_WAYLAND_RELAX_INTERVAL_MS          (50)
+/** Maximum number of participants who can join session. */
+#define VBCL_WAYLAND_SESSION_USERS_MAX          (10)
+/** Value which determines if session structure was initialized. */
+#define VBCL_WAYLAND_SESSION_MAGIC              (0xDEADBEEF)
+
+/** Session states. */
 typedef enum
 {
-    /** Indicates that helper does not support any functionality (initializer). */
-    VBOX_WAYLAND_HELPER_CAP_NONE = 0,
-    /** Indicates that helper supported shared clipboard functionality. */
-    VBOX_WAYLAND_HELPER_CAP_CLIPBOARD,
-    /** Indicates that helper supported drag-and-drop functionality. */
-    VBOX_WAYLAND_HELPER_CAP_DND
-} vbox_wayland_helper_cap_t;
+    /** Session is not active. */
+    VBCL_WL_SESSION_STATE_IDLE,
+    /** Session is being initialized. */
+    VBCL_WL_SESSION_STATE_STARTING,
+    /** Session has started and now can be joined.  */
+    VBCL_WL_SESSION_STATE_STARTED,
+    /** Session is terminating. */
+    VBCL_WL_SESSION_STATE_TERMINATING
+} vbcl_wl_session_state_t;
+
+/** Session type.
+ *
+ * Type determines the purpose of session. It is
+ * also serves a sanity check purpose when different
+ * participants join session with certain intention.
+ * Session type can only be set when session is
+ * in STARTING state and reset when session is TERMINATING.
+ */
+typedef enum
+{
+    /** Initializer. */
+    VBCL_WL_SESSION_TYPE_INVALID,
+    /** Copy clipboard data to the guest. */
+    VBCL_WL_CLIPBOARD_SESSION_TYPE_COPY_TO_GUEST,
+    /** Announce clipboard formats to the host. */
+    VBCL_WL_CLIPBOARD_SESSION_TYPE_ANNOUNCE_TO_HOST,
+    /** Copy clipboard data to the host. */
+    VBCL_WL_CLIPBOARD_SESSION_TYPE_COPY_TO_HOST,
+} vbcl_wl_session_type_t;
+
+/** Session private data. */
+typedef struct
+{
+    /** Magic number which indicates if session
+     *  was previously initialized. */
+    volatile uint32_t u32Magic;
+
+    /** Session state, synchronization element. */
+    volatile vbcl_wl_session_state_t enmState;
+
+    /** Session type. */
+    vbcl_wl_session_type_t enmType;
+
+    /** Session description, used for logging purpose
+     *  to distinguish between operations flow. */
+    const char *pcszDesc;
+
+    /** Current number of session users. When session
+     *  switches into TERMINATING state, it will wait
+     *  number of participants to drop to 1 before releasing
+     * session resources and resetting internal data to
+     * default values. */
+    volatile uint32_t cUsers;
+} vbcl_wl_session_t;
+
+/** Session state change callback.
+ *
+ * Data which belongs to a session must be accessed from
+ * session callback only. It ensures session data integrity
+ * and prevents access to data when session is not yet
+ * initialized or already terminated.
+ *
+ * @returns IPRT status code.
+ * @param   enmSessionType      Session type, provided for consistency
+ *                              check to make sure given callback is
+ *                              intended to be triggered in context of
+ *                              given session type.
+ * @param   pvUser              Optional user data.
+ */
+typedef DECLCALLBACKTYPE(int, FNVBCLWLSESSIONCB, (vbcl_wl_session_type_t enmSessionType, void *pvUser));
+/** Pointer to FNVBCLWLSESSIONCB. */
+typedef FNVBCLWLSESSIONCB *PFNVBCLWLSESSIONCB;
 
 /**
@@ -61 +150 @@
      * which is compatible with the helper.
      *
-     * @returns Helpercapabilities bitmask as described by vbox_wayland_helper_cap_t.
+     * @returns Helpercapabilities bitmask as described by VBOX_WAYLAND_HELPER_CAP_XXX.
      */
     DECLCALLBACKMEMBER(int, pfnProbe, (void));
@@ -79 +168 @@
     DECLCALLBACKMEMBER(int, pfnTerm, (void));
 
+    /**
+     * Callback to set host clipboard connection handle.
+     *
+     * @param   pCtx    Host service connection context.
+     */
+    DECLCALLBACKMEMBER(void, pfnSetClipboardCtx, (PVBGLR3SHCLCMDCTX pCtx));
+
+    /**
+     * Callback to force guest to announce its clipboard content.
+     *
+     * @returns IPRT status code.
+     */
+    DECLCALLBACKMEMBER(int, pfnPopup, (void));
+
+    PFNHOSTCLIPREPORTFMTS pfnHGClipReport;
+    PFNHOSTCLIPREAD pfnGHClipRead;
+
 } VBCLWAYLANDHELPER;
+
+namespace vbcl
+{
+    /**
+     * This is abstract one-shot data type which can be set by writer and waited
+     * by reader in a thread-safe way.
+     *
+     * Method wait() will wait within predefined interval of time until
+     * value of this type will be changed to anything different from default
+     * value which is defined during initialization. Reader must compare
+     * returned value with what defaults() method returns in order to make
+     * sure that value was actually set by writer.
+     *
+     * Method reset() will atomically reset current value to defaults and
+     * return previous value. This is useful when writer has previously
+     * dynamically allocated chunk of memory and reader needs to deallocete
+     * it in the end.
+     */
+    template <class T> class Waitable
+    {
+        public:
+
+            Waitable()
+            {};
+
+            /**
+             * Initialize data type.
+             *
+             * @param   default_value   Default value, used while
+             *                          waiting for value change.
+             * @param   timeoutMs       Time interval to wait for
+             *                          value change before returning.
+             */
+            void init(T default_value, uint64_t timeoutMs)
+            {
+                m_Value = default_value;
+                m_Default = default_value;
+                m_TimeoutMs = timeoutMs;
+            }
+
+            /**
+             * Atomically set value.
+             *
+             * @param   value   Value to set.
+             */
+            void set(T value)
+            {
+                ASMAtomicWriteU64(&m_Value, value);
+            }
+
+            /**
+             * Atomically reset value to defaults and return previous value.
+             *
+             * @returns Value which was assigned before reset.
+             */
+            uint64_t reset()
+            {
+                return ASMAtomicXchgU64(&m_Value, m_Default);
+            }
+
+            /**
+             * Wait until value will be changed from defaults and return it.
+             *
+             * @returns Current value.
+             */
+            T wait()
+            {
+                uint64_t tsStart = RTTimeMilliTS();
+
+                while(   (RTTimeMilliTS() - tsStart) < m_TimeoutMs
+                      && (ASMAtomicReadU64(&m_Value)) == m_Default)
+                {
+                    RTThreadSleep(VBCL_WAYLAND_RELAX_INTERVAL_MS);
+                }
+
+                return m_Value;
+            }
+
+            /**
+             * Get default value which was set during initialization.
+             *
+             * @returns Default value.
+             */
+            T defaults()
+            {
+                return m_Default;
+            }
+
+        protected:
+
+            /** Value itself. */
+            uint64_t m_Value;
+            /** Default value. */
+            uint64_t m_Default;
+            /** Value change waiting timeout. */
+            uint64_t m_TimeoutMs;
+    };
+}
+
+/**
+ * Initialize session.
+ *
+ * This function should be called only once, during initialization step.
+ *
+ * @param   pSession    A pointer to session data.
+ */
+RTDECL(void) vbcl_wayland_session_init(vbcl_wl_session_t *pSession);
+
+/**
+ * Start new session.
+ *
+ * Attempt to change session state from IDLE to STARTED and
+ * execute initialization callback in between.  If current
+ * session state is different from IDLE, state transition will
+ * not be possible and error will be returned.
+ *
+ * @returns IPRT status code.
+ * @param   pSession    Session object.
+ * @param   enmType     Session type.
+ * @param   pfnStart    Initialization callback.
+ * @param   pvUser      User data to pass to initialization callback.
+ */
+RTDECL(int) vbcl_wayland_session_start(vbcl_wl_session_t *pSession,
+                                       vbcl_wl_session_type_t enmType,
+                                       PFNVBCLWLSESSIONCB pfnStart,
+                                       void *pvUser);
+
+/**
+ * Join session.
+ *
+ * Attempt to grab a reference to a session, execute provided
+ * callback while holding a reference and release reference.
+ * This function will fail if current session state is different
+ * from STARTED.
+ *
+ * @returns IPRT status code.
+ * @param   pSession    Session object.
+ * @param   pfnJoin     A callback to run while holding session reference.
+ * @param   pvUser      User data to pass to callback.
+ * @param   pcszCallee  Text tag which corresponds to calling function (only
+ *                      for logging)
+ */
+RTDECL(int) vbcl_wayland_session_join_ex(vbcl_wl_session_t *pSession,
+                                         PFNVBCLWLSESSIONCB pfnJoin, void *pvUser,
+                                         const char *pcszCallee);
+
+/**
+ * Join session (wrapper for vbcl_wayland_session_join_ex).
+ */
+#define vbcl_wayland_session_join(pSession, pfnJoin, pvUser) \
+    vbcl_wayland_session_join_ex(pSession, pfnJoin, pvUser, __func__)
+
+/**
+ * End session.
+ *
+ * Attempt to wait until session is no longer in use, execute
+ * terminating callback and reset session to IDLE state.
+ *
+ * @returns IPRT status code.
+ * @param   pSession    Session object.
+ * @param   pfnEnd      Termination callback.
+ * @param   pvUser      User data to pass to termination callback.
+ */
+RTDECL(int) vbcl_wayland_session_end(vbcl_wl_session_t *pSession,
+                                     PFNVBCLWLSESSIONCB pfnEnd, void *pvUser);
+
+/**
+ * Check if session was started.
+ *
+ * @returns True if session is started, False otherwise.
+ * @param   pSession    Session object.
+ */
+RTDECL(bool) vbcl_wayland_session_is_started(vbcl_wl_session_t *pSession);
 
 /** Wayland helper which uses GTK library. */

trunk/src/VBox/Additions/x11/VBoxClient/wayland.cpp

@@ -26 +26 @@
  */
 
+#include <iprt/asm.h>
+#include <iprt/thread.h>
+
+#include <VBox/HostServices/GuestPropertySvc.h>
+
 #include "VBoxClient.h"
+#include "clipboard.h"
 #include "wayland-helper.h"
+
+/** Polling interval for input focus monitoring task. */
+#define VBCL_WAYLAND_WAIT_HOST_FOCUS_TIMEOUT_MS     (250)
+/** Relax interval for input focus monitoring task. */
+#define VBCL_WAYLAND_WAIT_HOST_FOCUS_RELAX_MS       (100)
 
 /** List of available Wayland Desktop Environment helpers. Sorted in order of preference. */
 static const VBCLWAYLANDHELPER *g_apWaylandHelpers[] =
 {
+    &g_WaylandHelperDcp,    /* Device Control Protocol helper. */
     &g_WaylandHelperGtk,    /* GTK helper. */
-    &g_WaylandHelperDcp,    /* Device Control Protocol helper. */
     NULL,                   /* Terminate list. */
 };
 
+/** Global flag to tell service to go shutdown when needed. */
+static bool volatile g_fShutdown = false;
+
 /** Selected helpers for Clipboard and Drag-and-Drop. */
-static const VBCLWAYLANDHELPER *g_pWaylandHelperHelperClipboard = NULL;
-static const VBCLWAYLANDHELPER *g_pWaylandHelperHelperDnd       = NULL;
+static const VBCLWAYLANDHELPER *g_pWaylandHelperClipboard = NULL;
+static const VBCLWAYLANDHELPER *g_pWaylandHelperDnd       = NULL;
+
+/** Corresponding threads for host events handling. */
+static RTTHREAD g_ClipboardThread;
+static RTTHREAD g_DndThread;
+static RTTHREAD g_HostInputFocusThread;
+
+/**
+ * Worker for Shared Clipboard events from host.
+ *
+ * @returns IPRT status code.
+ * @param   hThreadSelf     IPRT thread handle.
+ * @param   pvUser          User data (unused).
+ */
+static DECLCALLBACK(int) vbclWaylandClipboardWorker(RTTHREAD hThreadSelf, void *pvUser)
+{
+    SHCLCONTEXT ctx;
+    int rc;
+
+    RT_NOREF(pvUser);
+
+    RT_ZERO(ctx);
+
+    /* Connect to the host service. */
+    rc = VbglR3ClipboardConnectEx(&ctx.CmdCtx, VBOX_SHCL_GF_0_CONTEXT_ID);
+    /* Notify parent thread. */
+    RTThreadUserSignal(hThreadSelf);
+
+    if (RT_SUCCESS(rc))
+    {
+        /* Provide helper with host clipboard service connection handle. */
+        g_pWaylandHelperClipboard->pfnSetClipboardCtx(&ctx.CmdCtx);
+
+        /* Process host events. */
+        while (!ASMAtomicReadBool(&g_fShutdown))
+        {
+            rc = VBClClipboardReadHostEvent(&ctx, g_pWaylandHelperClipboard->pfnHGClipReport,
+                                            g_pWaylandHelperClipboard->pfnGHClipRead);
+            if (RT_FAILURE(rc))
+            {
+                VBClLogInfo("cannot process host clipboard event, rc=%Rrc\n", rc);
+                RTThreadSleep(RT_MS_1SEC / 2);
+            }
+        }
+
+        VbglR3ClipboardDisconnectEx(&ctx.CmdCtx);
+    }
+
+    VBClLogVerbose(2, "clipboard thread, rc=%Rrc\n", rc);
+
+    return rc;
+}
+
+/**
+ * Worker for Drag-and-Drop events from host.
+ *
+ * @returns IPRT status code.
+ * @param   hThreadSelf     IPRT thread handle.
+ * @param   pvUser          User data (unused).
+ */
+static DECLCALLBACK(int) vbclWaylandDndWorker(RTTHREAD hThreadSelf, void *pvUser)
+{
+    RT_NOREF(pvUser);
+
+    RTThreadUserSignal(hThreadSelf);
+    return VINF_SUCCESS;
+}
+
+/**
+ * Worker for VM window focus change polling thread.
+ *
+ * Some Wayland helpers need to be notified about VM
+ * window focus change events. This is needed in order to
+ * ask about, for example, if guest clipboard content was
+ * changed since last user interaction. Such guest are not
+ * able to notify host about clipboard content change and
+ * needed to be asked implicitly.
+ *
+ * @returns IPRT status code.
+ * @param   hThreadSelf     IPRT thread handle.
+ * @param   pvUser          User data (unused).
+ */
+static DECLCALLBACK(int) vbclWaylandHostInputFocusWorker(RTTHREAD hThreadSelf, void *pvUser)
+{
+    int rc;
+
+    RT_NOREF(pvUser);
+
+    HGCMCLIENTID idClient;
+
+    rc = VbglR3GuestPropConnect(&idClient);
+
+    RTThreadUserSignal(hThreadSelf);
+
+    if (RT_SUCCESS(rc))
+    {
+        while (!ASMAtomicReadBool(&g_fShutdown))
+        {
+            static char achBuf[GUEST_PROP_MAX_NAME_LEN];
+            char *pszName = NULL;
+            char *pszValue = NULL;
+            char *pszFlags = NULL;
+            bool fWasDeleted = false;
+            uint64_t u64Timestamp = 0;
+
+            rc = VbglR3GuestPropWait(idClient, VBOX_GUI_FOCUS_CHANGE_GUEST_PROP_NAME, achBuf, sizeof(achBuf), u64Timestamp,
+                                     VBCL_WAYLAND_WAIT_HOST_FOCUS_TIMEOUT_MS, &pszName, &pszValue, &u64Timestamp,
+                                     &pszFlags, NULL, &fWasDeleted);
+            if (RT_SUCCESS(rc))
+            {
+                uint32_t fFlags = 0;
+
+                VBClLogVerbose(1, "guest property change: name: %s, val: %s, flags: %s, fWasDeleted: %RTbool\n",
+                               pszName, pszValue, pszFlags, fWasDeleted);
+
+                if (RT_SUCCESS(GuestPropValidateFlags(pszFlags, &fFlags)))
+                {
+                    if (RTStrNCmp(pszName, VBOX_GUI_FOCUS_CHANGE_GUEST_PROP_NAME, GUEST_PROP_MAX_NAME_LEN) == 0)
+                    {
+                        if (fFlags & GUEST_PROP_F_RDONLYGUEST)
+                        {
+                            if (RT_VALID_PTR(g_pWaylandHelperClipboard))
+                            {
+                                if (RTStrNCmp(pszValue, "0", GUEST_PROP_MAX_NAME_LEN) == 0)
+                                {
+                                    rc = g_pWaylandHelperClipboard->pfnPopup();
+                                    VBClLogVerbose(1, "trigger popup, rc=%Rrc\n", rc);
+                                }
+                            }
+                            else
+                                VBClLogVerbose(1, "will not trigger popup\n");
+                        }
+                        else
+                            VBClLogError("property has invalid attributes\n");
+                    }
+                    else
+                        VBClLogVerbose(1, "unknown property name '%s'\n", pszName);
+
+                } else
+                    VBClLogError("guest property change: name: %s, val: %s, flags: %s, fWasDeleted: %RTbool: bad flags\n",
+                                 pszName, pszValue, pszFlags, fWasDeleted);
+
+            } else if (   rc != VERR_TIMEOUT
+                     && rc != VERR_INTERRUPTED)
+            {
+                VBClLogError("error on waiting guest property notification, rc=%Rrc\n", rc);
+                RTThreadSleep(VBCL_WAYLAND_WAIT_HOST_FOCUS_RELAX_MS);
+            }
+        }
+    }
+
+    return rc;
+}
+
 
 /**
@@ -68 +235 @@
             /* Try Clipboard helper. */
             if (   fCaps & VBOX_WAYLAND_HELPER_CAP_CLIPBOARD
-                && !RT_VALID_PTR(g_pWaylandHelperHelperClipboard))
+                && !RT_VALID_PTR(g_pWaylandHelperClipboard))
             {
                 if (RT_VALID_PTR(g_apWaylandHelpers[idxHelper]->pfnInit))
@@ -74 +241 @@
                     rc = g_apWaylandHelpers[idxHelper]->pfnInit();
                     if (RT_SUCCESS(rc))
-                        g_pWaylandHelperHelperClipboard = g_apWaylandHelpers[idxHelper];
+                        g_pWaylandHelperClipboard = g_apWaylandHelpers[idxHelper];
                     else
-                        VBClLogError("Wayland helper '%s' cannot be initialized, skipping");
+                        VBClLogError("Wayland helper '%s' cannot be initialized, skipping\n",
+                                     g_apWaylandHelpers[idxHelper]->pszName);
                 }
+                else
+                    VBClLogVerbose(1, "Wayland helper '%s' has no initializer, skipping\n",
+                                   g_apWaylandHelpers[idxHelper]->pszName);
             }
 
             /* Try DnD helper. */
             if (   fCaps & VBOX_WAYLAND_HELPER_CAP_DND
-                && !RT_VALID_PTR(g_pWaylandHelperHelperDnd))
+                && !RT_VALID_PTR(g_pWaylandHelperDnd))
             {
                 if (RT_VALID_PTR(g_apWaylandHelpers[idxHelper]->pfnInit))
@@ -88 +259 @@
                     rc = g_apWaylandHelpers[idxHelper]->pfnInit();
                     if (RT_SUCCESS(rc))
-                        g_pWaylandHelperHelperDnd = g_apWaylandHelpers[idxHelper];
+                        g_pWaylandHelperDnd = g_apWaylandHelpers[idxHelper];
                     else
-                        VBClLogError("Wayland helper '%s' cannot be initialized, skipping");
+                        VBClLogError("Wayland helper '%s' cannot be initialized, skipping\n",
+                                     g_apWaylandHelpers[idxHelper]->pszName);
                 }
+                else
+                    VBClLogVerbose(1, "Wayland helper '%s' has no initializer, skipping\n",
+                                   g_apWaylandHelpers[idxHelper]->pszName);
             }
         }
 
         /* See if we found all the needed helpers. */
-        if (   RT_VALID_PTR(g_pWaylandHelperHelperClipboard)
-            && RT_VALID_PTR(g_pWaylandHelperHelperDnd))
+        if (   RT_VALID_PTR(g_pWaylandHelperClipboard)
+            && RT_VALID_PTR(g_pWaylandHelperDnd))
             break;
 
@@ -104 +279 @@
 
     /* Check result. */
-    if (RT_VALID_PTR(g_pWaylandHelperHelperClipboard))
-        VBClLogInfo("found Wayland Shared Clipboard helper '%s'\n", g_pWaylandHelperHelperClipboard->pszName);
+    if (RT_VALID_PTR(g_pWaylandHelperClipboard))
+        VBClLogInfo("found Wayland Shared Clipboard helper '%s'\n", g_pWaylandHelperClipboard->pszName);
     else
         VBClLogError("Wayland Shared Clipboard helper not found, clipboard sharing not possible\n");
 
     /* Check result. */
-    if (RT_VALID_PTR(g_pWaylandHelperHelperDnd))
-        VBClLogInfo("found Wayland Drag-and-Drop helper '%s'\n", g_pWaylandHelperHelperDnd->pszName);
+    if (RT_VALID_PTR(g_pWaylandHelperDnd))
+        VBClLogInfo("found Wayland Drag-and-Drop helper '%s'\n", g_pWaylandHelperDnd->pszName);
     else
         VBClLogError("Wayland Drag-and-Drop helper not found, drag-and-drop not possible\n");
@@ -123 +298 @@
 static DECLCALLBACK(int) vbclWaylandWorker(bool volatile *pfShutdown)
 {
+    int rc = VINF_SUCCESS;
+
     RT_NOREF(pfShutdown);
-    return VERR_NOT_SUPPORTED;
+
+    VBClLogVerbose(1, "starting wayland worker thread\n");
+
+    /* Start event loop for clipboard events processing from host. */
+    if (RT_VALID_PTR(g_pWaylandHelperClipboard))
+    {
+        rc = VBClClipboardThreadStart(&g_ClipboardThread, vbclWaylandClipboardWorker, "wl-clip", NULL);
+        VBClLogVerbose(1, "clipboard thread started, rc=%Rrc\n", rc);
+    }
+
+    /* Start event loop for DnD events processing from host. */
+    if (   RT_SUCCESS(rc)
+        && RT_VALID_PTR(g_pWaylandHelperDnd))
+    {
+        rc = VBClClipboardThreadStart(&g_DndThread, vbclWaylandDndWorker, "wl-dnd", NULL);
+        VBClLogVerbose(1, "DnD thread started, rc=%Rrc\n", rc);
+    }
+
+    /* Start polling host input focus events. */
+    if (RT_SUCCESS(rc))
+    {
+        rc = VBClClipboardThreadStart(&g_HostInputFocusThread, vbclWaylandHostInputFocusWorker, "wl-focus", NULL);
+        VBClLogVerbose(1, "host input focus polling thread started, rc=%Rrc\n", rc);
+    }
+
+    /* Notify parent thread that we are successfully started. */
+    RTThreadUserSignal(RTThreadSelf());
+
+    if (RT_SUCCESS(rc))
+    {
+        int rcThread = VINF_SUCCESS;
+
+        if (RT_VALID_PTR(g_pWaylandHelperClipboard))
+        {
+            rc = RTThreadWait(g_ClipboardThread, RT_INDEFINITE_WAIT, &rcThread);
+            VBClLogVerbose(1, "clipboard thread finished, rc=%Rrc, rcThread=%Rrc\n", rc, rcThread);
+        }
+
+        if (   RT_SUCCESS(rc)
+            && RT_VALID_PTR(g_pWaylandHelperDnd))
+        {
+            rc = RTThreadWait(g_DndThread, RT_INDEFINITE_WAIT, &rcThread);
+            VBClLogVerbose(1, "DnD thread finished, rc=%Rrc, rcThread=%Rrc\n", rc, rcThread);
+        }
+
+        if (RT_SUCCESS(rc))
+        {
+            rc = RTThreadWait(g_HostInputFocusThread, RT_INDEFINITE_WAIT, &rcThread);
+            VBClLogVerbose(1, "host input focus polling thread finished, rc=%Rrc, rcThread=%Rrc\n", rc, rcThread);
+        }
+    }
+
+    VBClLogVerbose(1, "wayland worker thread finished, rc=%Rrc\n", rc);
+
+    return rc;
 }
 
@@ -132 +363 @@
 static DECLCALLBACK(void) vbclWaylandStop(void)
 {
+    VBClLogVerbose(1, "terminating wayland service: clipboard & DnD host event loops\n");
+
+    /* This callback can be called twice (not good, needs to be fixed). Already was shut down? */
+    if (ASMAtomicReadBool(&g_fShutdown))
+        return;
+
+    ASMAtomicWriteBool(&g_fShutdown, true);
+
+    if (RT_VALID_PTR(g_pWaylandHelperClipboard))
+        RTThreadPoke(g_ClipboardThread);
+
+    if (RT_VALID_PTR(g_pWaylandHelperDnd))
+        RTThreadPoke(g_DndThread);
 }
 
@@ -139 +383 @@
 static DECLCALLBACK(int) vbclWaylandTerm(void)
 {
-    return VERR_NOT_SUPPORTED;
+    int rc = VINF_SUCCESS;
+
+    VBClLogVerbose(1, "shutting down wayland service: clipboard & DnD helpers\n");
+
+    if (   RT_VALID_PTR(g_pWaylandHelperClipboard)
+        && RT_VALID_PTR(g_pWaylandHelperClipboard->pfnTerm))
+        rc = g_pWaylandHelperClipboard->pfnTerm();
+
+    if (   RT_SUCCESS(rc)
+        && RT_VALID_PTR(g_pWaylandHelperDnd)
+        && RT_VALID_PTR(g_pWaylandHelperDnd->pfnTerm))
+        rc = g_pWaylandHelperDnd->pfnTerm();
+
+    return rc;
 }