[client] clipboard: add transport provider interface

Route clipboard exchange through a provider interface. Connected
transports take priority while SPICE remains the fallback.

Track asynchronous X11 and Wayland transfers by request, preserving
clipboard ownership across provider changes.

Use PureSpice clipboard status notifications for capability and
lifecycle updates.

client/displayservers/Wayland/clipboard.c

@@ -191,6 +191,44 @@ static bool hasImageMimetype(char ** mimetypes)
   return false;
 }
 
+/* wlCb.lock must be held. */
+static struct ClipboardRead * clipboardReadTakeCurrentNL(void)
+{
+  struct ClipboardRead * data = wlCb.currentRead;
+  if (!data)
+    return NULL;
+
+  wlCb.currentRead = NULL;
+  return data;
+}
+
+static void clipboardReadRetire(struct ClipboardRead * data)
+{
+  if (data)
+    waylandPollUnregister(data->fd);
+}
+
+static bool clipboardReadClaim(struct ClipboardRead * data)
+{
+  LG_LOCK(wlCb.lock);
+  const bool current = wlCb.currentRead == data;
+  if (current)
+    clipboardReadTakeCurrentNL();
+  LG_UNLOCK(wlCb.lock);
+
+  if (current)
+    clipboardReadRetire(data);
+  return current;
+}
+
+static void clipboardReadCleanup(void * opaque)
+{
+  struct ClipboardRead * data = opaque;
+  close(data->fd);
+  free(data->buf);
+  free(data);
+}
+
 // Destination client handlers.
 
 static void dataOfferHandleOffer(void * opaque, struct wl_data_offer * offer,
@@ -276,21 +314,36 @@ static void dataDeviceHandleSelection(void * opaque,
     return;
   }
 
-  wlCb.offer = offer;
-
-  for (enum LG_ClipboardData i = 0; i < LG_CLIPBOARD_DATA_NONE; ++i)
-    free(wlCb.mimetypes[i]);
-  memcpy(wlCb.mimetypes, extra->mimetypes, sizeof(wlCb.mimetypes));
-
-  wl_data_offer_set_user_data(offer, NULL);
-  free(extra);
-
   int idx = 0;
   enum LG_ClipboardData types[LG_CLIPBOARD_DATA_NONE];
   for (enum LG_ClipboardData i = 0; i < LG_CLIPBOARD_DATA_NONE; ++i)
-    if (wlCb.mimetypes[i])
+    if (extra->mimetypes[i])
       types[idx++] = i;
 
+  char * oldMimetypes[LG_CLIPBOARD_DATA_NONE];
+  LG_LOCK(wlCb.lock);
+  struct ClipboardRead * read = clipboardReadTakeCurrentNL();
+  struct wl_data_offer * oldOffer = wlCb.offer;
+  memcpy(oldMimetypes, wlCb.mimetypes, sizeof(oldMimetypes));
+  wlCb.offer = offer;
+  memcpy(wlCb.mimetypes, extra->mimetypes, sizeof(wlCb.mimetypes));
+  LG_UNLOCK(wlCb.lock);
+
+  wl_data_offer_set_user_data(offer, NULL);
+  memset(extra->mimetypes, 0, sizeof(extra->mimetypes));
+  free(extra);
+
+  if (read)
+  {
+    const LG_ClipboardRequest request = read->request;
+    clipboardReadRetire(read);
+    app_clipboardAbort(request);
+  }
+  if (oldOffer && oldOffer != offer)
+    wl_data_offer_destroy(oldOffer);
+  for (enum LG_ClipboardData i = 0; i < LG_CLIPBOARD_DATA_NONE; ++i)
+    free(oldMimetypes[i]);
+
   app_clipboardNotifyTypes(types, idx);
 }
 
@@ -340,8 +393,6 @@ static const struct wl_data_device_listener dataDeviceListener = {
 
 bool waylandCBInit(void)
 {
-  memset(&wlCb, 0, sizeof(wlCb));
-
   if (!wlWm.seat)
   {
     DEBUG_WARN("Clipboard unavailable without wl_seat");
@@ -370,37 +421,37 @@ bool waylandCBInit(void)
   return true;
 }
 
-static void clipboardReadCancel(struct ClipboardRead * data)
-{
-  waylandPollUnregister(data->fd);
-  close(data->fd);
-  free(data->buf);
-  free(data);
-  wlCb.currentRead = NULL;
-}
-
 static void clipboardReadCallback(uint32_t events, void * opaque)
 {
   struct ClipboardRead * data = opaque;
+  LG_LOCK(wlCb.lock);
+  const bool active = wlCb.currentRead == data;
+  LG_UNLOCK(wlCb.lock);
+  if (!active)
+    return;
+
   if (events & EPOLLERR)
   {
-    clipboardReadCancel(data);
+    if (clipboardReadClaim(data))
+      app_clipboardAbort(data->request);
     return;
   }
 
-  ssize_t result = read(data->fd, data->buf + data->numRead, data->size - data->numRead);
+  ssize_t result = read(data->fd,
+      data->buf + data->numRead, data->size - data->numRead);
   if (result < 0)
   {
     DEBUG_ERROR("Failed to read from clipboard: %s", strerror(errno));
-    clipboardReadCancel(data);
+    if (clipboardReadClaim(data))
+      app_clipboardAbort(data->request);
     return;
   }
 
   if (result == 0)
   {
-    app_clipboardNotifySize(data->type, data->numRead);
-    app_clipboardData(data->type, data->buf, data->numRead);
-    clipboardReadCancel(data);
+    if (clipboardReadClaim(data))
+      app_clipboardData(
+          data->request, data->type, data->buf, data->numRead);
     return;
   }
 
@@ -409,9 +460,11 @@ static void clipboardReadCallback(uint32_t events, void * opaque)
   {
     data->size *= 2;
     void * nbuf = realloc(data->buf, data->size);
-    if (!nbuf) {
+    if (!nbuf)
+    {
       DEBUG_ERROR("Failed to realloc clipboard buffer: %s", strerror(errno));
-      clipboardReadCancel(data);
+      if (clipboardReadClaim(data))
+        app_clipboardAbort(data->request);
       return;
     }
 
@@ -421,70 +474,103 @@ static void clipboardReadCallback(uint32_t events, void * opaque)
 
 void waylandCBInvalidate(void)
 {
-  if (wlCb.currentRead)
-    clipboardReadCancel(wlCb.currentRead);
+  char * mimetypes[LG_CLIPBOARD_DATA_NONE];
+  LG_LOCK(wlCb.lock);
+  struct ClipboardRead * read = clipboardReadTakeCurrentNL();
+  struct wl_data_offer * offer = wlCb.offer;
+  wlCb.offer = NULL;
+  memcpy(mimetypes, wlCb.mimetypes, sizeof(mimetypes));
+  memset(wlCb.mimetypes, 0, sizeof(wlCb.mimetypes));
+  LG_UNLOCK(wlCb.lock);
+
+  if (read)
+  {
+    const LG_ClipboardRequest request = read->request;
+    clipboardReadRetire(read);
+    app_clipboardAbort(request);
+  }
 
   app_clipboardRelease();
 
-  if (wlCb.offer)
-    wl_data_offer_destroy(wlCb.offer);
-  wlCb.offer = NULL;
+  if (offer)
+    wl_data_offer_destroy(offer);
+  for (enum LG_ClipboardData i = 0; i < LG_CLIPBOARD_DATA_NONE; ++i)
+    free(mimetypes[i]);
 }
 
-void waylandCBRequest(LG_ClipboardData type)
+void waylandCBRequest(LG_ClipboardRequest request, LG_ClipboardData type)
 {
-  if (!wlCb.offer || !wlCb.mimetypes[type])
-  {
-    app_clipboardRelease();
+  if (request == LG_CLIPBOARD_REQUEST_INVALID ||
+      type < LG_CLIPBOARD_DATA_TEXT || type >= LG_CLIPBOARD_DATA_NONE)
     return;
-  }
-
-  if (wlCb.currentRead)
-    clipboardReadCancel(wlCb.currentRead);
 
   int fds[2];
   if (pipe(fds) < 0)
   {
     DEBUG_ERROR("Failed to get a clipboard pipe: %s", strerror(errno));
-    abort();
+    app_clipboardAbort(request);
+    return;
   }
 
-  wl_data_offer_receive(wlCb.offer, wlCb.mimetypes[type], fds[1]);
-  close(fds[1]);
-
   struct ClipboardRead * data = malloc(sizeof(*data));
   if (!data)
   {
     DEBUG_ERROR("Failed to allocate memory to read clipboard");
     close(fds[0]);
+    close(fds[1]);
+    app_clipboardAbort(request);
     return;
   }
 
-  data->fd      = fds[0];
-  data->size    = 4096;
-  data->numRead = 0;
-  data->buf     = malloc(data->size);
-  data->offer   = wlCb.offer;
-  data->type    = type;
+  data->fd        = fds[0];
+  data->size      = 4096;
+  data->numRead   = 0;
+  data->buf       = malloc(data->size);
+  data->request   = request;
+  data->type      = type;
 
   if (!data->buf)
   {
     DEBUG_ERROR("Failed to allocate memory to receive clipboard data");
     close(data->fd);
+    close(fds[1]);
     free(data);
+    app_clipboardAbort(request);
     return;
   }
 
-  if (!waylandPollRegister(data->fd, clipboardReadCallback, data, EPOLLIN))
+  LG_LOCK(wlCb.lock);
+  struct ClipboardRead * old = clipboardReadTakeCurrentNL();
+  const bool available = wlCb.offer && wlCb.mimetypes[type];
+  if (available)
   {
-    DEBUG_ERROR("Failed to register clipboard read into epoll: %s", strerror(errno));
-    close(data->fd);
-    free(data->buf);
-    free(data);
+    wl_data_offer_receive(
+        wlCb.offer, wlCb.mimetypes[type], fds[1]);
+  }
+  close(fds[1]);
+
+  const bool registered = available &&
+    waylandPollRegisterWithCleanup(data->fd,
+        clipboardReadCallback, data, clipboardReadCleanup, EPOLLIN);
+  if (registered)
+    wlCb.currentRead = data;
+  LG_UNLOCK(wlCb.lock);
+
+  if (old)
+  {
+    const LG_ClipboardRequest oldRequest = old->request;
+    clipboardReadRetire(old);
+    app_clipboardAbort(oldRequest);
+  }
+  if (!registered)
+  {
+    if (available)
+      DEBUG_ERROR("Failed to register clipboard read into epoll: %s",
+          strerror(errno));
+    clipboardReadCleanup(data);
+    app_clipboardAbort(request);
     return;
   }
-
-  wlCb.currentRead = data;
 }
 
 struct ClipboardWrite
@@ -494,6 +580,14 @@ struct ClipboardWrite
   struct CountedBuffer * buffer;
 };
 
+static void clipboardWriteCleanup(void * opaque)
+{
+  struct ClipboardWrite * data = opaque;
+  close(data->fd);
+  countedBufferRelease(&data->buffer);
+  free(data);
+}
+
 static void clipboardWriteCallback(uint32_t events, void * opaque)
 {
   struct ClipboardWrite * data = opaque;
@@ -514,9 +608,6 @@ static void clipboardWriteCallback(uint32_t events, void * opaque)
 
 error:
   waylandPollUnregister(data->fd);
-  close(data->fd);
-  countedBufferRelease(&data->buffer);
-  free(data);
 }
 
 static void dataSourceHandleTarget(void * data, struct wl_data_source * source,
@@ -543,8 +634,12 @@ static void dataSourceHandleSend(void * data, struct wl_data_source * source,
     data->pos    = 0;
     data->buffer = transfer->data;
     countedBufferAddRef(transfer->data);
-    waylandPollRegister(fd, clipboardWriteCallback, data, EPOLLOUT);
-    return;
+    if (waylandPollRegisterWithCleanup(fd,
+          clipboardWriteCallback, data, clipboardWriteCleanup, EPOLLOUT))
+      return;
+
+    countedBufferRelease(&data->buffer);
+    free(data);
   }
 
 error:
@@ -567,7 +662,7 @@ static const struct wl_data_source_listener dataSourceListener = {
 };
 
 static void waylandCBReplyFn(void * opaque, LG_ClipboardData type,
-   	uint8_t * data, uint32_t size)
+    const uint8_t * data, uint32_t size)
 {
   if (type == LG_CLIPBOARD_DATA_NONE)
     return;
@@ -587,7 +682,8 @@ static void waylandCBReplyFn(void * opaque, LG_ClipboardData type,
     free(transfer);
     return;
   }
-  memcpy(transfer->data->data, data, size);
+  if (size)
+    memcpy(transfer->data->data, data, size);
 
   struct wl_data_source * source =
     wl_data_device_manager_create_data_source(wlWm.dataDeviceManager);
@@ -602,13 +698,38 @@ static void waylandCBReplyFn(void * opaque, LG_ClipboardData type,
 
 void waylandCBNotice(LG_ClipboardData type)
 {
-  wlCb.haveRequest = true;
-  wlCb.type        = type;
-  if (!app_clipboardRequest(waylandCBReplyFn, NULL))
-    DEBUG_ERROR("Failed to request SPICE clipboard data");
+  if (!app_clipboardRequest(type, waylandCBReplyFn, NULL))
+    DEBUG_ERROR("Failed to request remote clipboard data");
 }
 
 void waylandCBRelease(void)
 {
-  wlCb.haveRequest = false;
+}
+
+void waylandCBFree(void)
+{
+  char * mimetypes[LG_CLIPBOARD_DATA_NONE];
+  LG_LOCK(wlCb.lock);
+  struct ClipboardRead * read = clipboardReadTakeCurrentNL();
+  struct wl_data_offer * offer = wlCb.offer;
+  struct wl_data_offer * dndOffer = wlCb.dndOffer;
+  struct wl_data_device * dataDevice = wlCb.dataDevice;
+  wlCb.offer      = NULL;
+  wlCb.dndOffer   = NULL;
+  wlCb.dataDevice = NULL;
+  memcpy(mimetypes, wlCb.mimetypes, sizeof(mimetypes));
+  memset(wlCb.mimetypes, 0, sizeof(wlCb.mimetypes));
+  LG_UNLOCK(wlCb.lock);
+
+  clipboardReadRetire(read);
+  if (offer)
+    wl_data_offer_destroy(offer);
+  if (dndOffer && dndOffer != offer)
+    wl_data_offer_destroy(dndOffer);
+  if (dataDevice)
+    wl_data_device_release(dataDevice);
+  for (enum LG_ClipboardData i = 0; i < LG_CLIPBOARD_DATA_NONE; ++i)
+    free(mimetypes[i]);
+
+  LG_LOCK_FREE(wlCb.lock);
 }

client/displayservers/Wayland/desktops/libdecor/libdecor.c

@@ -263,7 +263,7 @@ void libdecor_pollWait(struct wl_display * display, int epollFd,
   for (int i = 0; i < count; ++i)
   {
     struct WaylandPoll * poll = events[i].data.ptr;
-    if (!poll->removed)
+    if (!atomic_load_explicit(&poll->removed, memory_order_acquire))
       poll->callback(events[i].events, poll->opaque);
   }
 }

client/displayservers/Wayland/desktops/xdg/xdg.c

@@ -300,7 +300,7 @@ void xdg_pollWait(struct wl_display * display, int epollFd,
   bool sawDisplay = false;
   for (int i = 0; i < count; ++i) {
     struct WaylandPoll * poll = events[i].data.ptr;
-    if (!poll->removed)
+    if (!atomic_load_explicit(&poll->removed, memory_order_acquire))
       poll->callback(events[i].events, poll->opaque);
     if (poll->fd == state.displayFd)
       sawDisplay = true;

client/displayservers/Wayland/poll.c

@@ -25,6 +25,7 @@
 
 #include <errno.h>
 #include <sys/epoll.h>
+#include <unistd.h>
 #include <wayland-client.h>
 
 #include "common/debug.h"
@@ -47,84 +48,150 @@ bool waylandPollInit(void)
   return wlWm.desktop->pollInit(wlWm.display);
 }
 
-void waylandWait(unsigned int time)
+static void waylandPollDestroyNode(struct WaylandPoll * node)
 {
-  wlWm.desktop->pollWait(wlWm.display, wlWm.epollFd, time);
-  INTERLOCKED_SECTION(wlWm.pollFreeLock,
-  {
-    struct WaylandPoll * node;
-    struct WaylandPoll * temp;
-    wl_list_for_each_safe(node, temp, &wlWm.pollFree, link)
-    {
-      wl_list_remove(&node->link);
-      free(node);
-    }
-  });
+  if (node->cleanup)
+    node->cleanup(node->opaque);
+  free(node);
 }
 
-static void waylandPollRemoveNode(struct WaylandPoll * node)
+static void waylandPollDestroyList(struct wl_list * list)
 {
-  INTERLOCKED_SECTION(wlWm.pollLock,
+  struct WaylandPoll * node;
+  struct WaylandPoll * temp;
+  wl_list_for_each_safe(node, temp, list, link)
   {
     wl_list_remove(&node->link);
-  });
+    waylandPollDestroyNode(node);
+  }
 }
 
-bool waylandPollRegister(int fd, WaylandPollCallback callback, void * opaque, uint32_t events)
+static void waylandPollTakeList(struct wl_list * source,
+    struct wl_list * destination)
+{
+  struct WaylandPoll * node;
+  struct WaylandPoll * temp;
+  wl_list_for_each_safe(node, temp, source, link)
+  {
+    wl_list_remove(&node->link);
+    wl_list_insert(destination, &node->link);
+  }
+}
+
+void waylandWait(unsigned int time)
+{
+  INTERLOCKED_SECTION(wlWm.pollFreeLock,
+  {
+    ++wlWm.pollWaiters;
+  });
+
+  wlWm.desktop->pollWait(wlWm.display, wlWm.epollFd, time);
+
+  struct wl_list retired;
+  wl_list_init(&retired);
+  INTERLOCKED_SECTION(wlWm.pollFreeLock,
+  {
+    if (--wlWm.pollWaiters == 0)
+      waylandPollTakeList(&wlWm.pollFree, &retired);
+  });
+  waylandPollDestroyList(&retired);
+}
+
+void waylandPollFree(void)
+{
+  if (wlWm.epollFd >= 0)
+  {
+    close(wlWm.epollFd);
+    wlWm.epollFd = -1;
+  }
+
+  struct wl_list active;
+  struct wl_list retired;
+  wl_list_init(&active);
+  wl_list_init(&retired);
+  INTERLOCKED_SECTION(wlWm.pollLock,
+  {
+    waylandPollTakeList(&wlWm.poll, &active);
+  });
+
+  INTERLOCKED_SECTION(wlWm.pollFreeLock,
+  {
+    waylandPollTakeList(&wlWm.pollFree, &retired);
+  });
+  waylandPollDestroyList(&active);
+  waylandPollDestroyList(&retired);
+
+  LG_LOCK_FREE(wlWm.pollFreeLock);
+  LG_LOCK_FREE(wlWm.pollLock);
+}
+
+bool waylandPollRegisterWithCleanup(int fd, WaylandPollCallback callback,
+    void * opaque, WaylandPollCleanup cleanup, uint32_t events)
 {
   struct WaylandPoll * node = malloc(sizeof(*node));
   if (!node)
     return false;
 
   node->fd       = fd;
-  node->removed  = false;
   node->callback = callback;
+  node->cleanup  = cleanup;
   node->opaque   = opaque;
+  atomic_init(&node->removed, false);
 
-  INTERLOCKED_SECTION(wlWm.pollLock,
-  {
-    wl_list_insert(&wlWm.poll, &node->link);
-  });
-
+  LG_LOCK(wlWm.pollLock);
   if (epoll_ctl(wlWm.epollFd, EPOLL_CTL_ADD, fd, &(struct epoll_event) {
     .events = events,
     .data = (epoll_data_t) { .ptr = node },
   }) < 0)
   {
-    waylandPollRemoveNode(node);
+    LG_UNLOCK(wlWm.pollLock);
     free(node);
     return false;
   }
+  wl_list_insert(&wlWm.poll, &node->link);
+  LG_UNLOCK(wlWm.pollLock);
 
   return true;
 }
 
+bool waylandPollRegister(int fd, WaylandPollCallback callback,
+    void * opaque, uint32_t events)
+{
+  return waylandPollRegisterWithCleanup(
+      fd, callback, opaque, NULL, events);
+}
+
 bool waylandPollUnregister(int fd)
 {
   struct WaylandPoll * node = NULL;
-  INTERLOCKED_SECTION(wlWm.pollLock,
+  LG_LOCK(wlWm.pollLock);
+  struct WaylandPoll * current;
+  wl_list_for_each(current, &wlWm.poll, link)
   {
-    wl_list_for_each(node, &wlWm.poll, link)
+    if (current->fd == fd)
     {
-      if (node->fd == fd)
-        break;
+      node = current;
+      atomic_store_explicit(
+          &node->removed, true, memory_order_release);
+      break;
     }
-  });
+  }
 
   if (!node)
   {
+    LG_UNLOCK(wlWm.pollLock);
     DEBUG_ERROR("Attempt to unregister a fd that was not registered: %d", fd);
     return false;
   }
 
-  node->removed = true;
   if (epoll_ctl(wlWm.epollFd, EPOLL_CTL_DEL, fd, NULL) < 0)
   {
-    DEBUG_ERROR("Failed to unregistered from epoll: %s", strerror(errno));
+    LG_UNLOCK(wlWm.pollLock);
+    DEBUG_ERROR("Failed to unregister from epoll: %s", strerror(errno));
     return false;
   }
-
-  waylandPollRemoveNode(node);
+  wl_list_remove(&node->link);
+  LG_UNLOCK(wlWm.pollLock);
 
   INTERLOCKED_SECTION(wlWm.pollFreeLock,
   {

client/displayservers/Wayland/wayland.c

@@ -108,9 +108,11 @@ static bool getCompositor(char * dst, size_t size)
 static bool waylandInit(const LG_DSInitParams params)
 {
   memset(&wlWm, 0, sizeof(wlWm));
+  memset(&wlCb, 0, sizeof(wlCb));
   LG_LOCK_INIT(wlWm.surfaceLock);
   LG_LOCK_INIT(wlWm.pendingHDRLock);
   LG_LOCK_INIT(wlWm.hdrLock);
+  LG_LOCK_INIT(wlCb.lock);
   wlWm.desktop        = WL_Desktops[0];
   atomic_init(&wlWm.lockActive, false);
   atomic_init(&wlWm.cmFeaturesDone, false);
@@ -207,6 +209,7 @@ static void waylandShutdown(void)
 
 static void waylandFree(void)
 {
+  waylandCBFree();
   waylandIdleFree();
   waylandPresentationFree();
   waylandWindowFree();
@@ -215,6 +218,7 @@ static void waylandFree(void)
   waylandColorMgmtFree();
   waylandRegistryFree();
   waylandCursorFree();
+  waylandPollFree();
   wl_display_disconnect(wlWm.display);
   LG_LOCK_FREE(wlWm.hdrLock);
   LG_LOCK_FREE(wlWm.pendingHDRLock);

client/displayservers/Wayland/wayland.h

@@ -59,14 +59,16 @@
 #include "motion.h"
 
 typedef void (*WaylandPollCallback)(uint32_t events, void * opaque);
+typedef void (*WaylandPollCleanup)(void * opaque);
 
 struct WaylandPoll
 {
-  int fd;
-  bool removed;
+  int                 fd;
+  atomic_bool         removed;
   WaylandPollCallback callback;
-  void * opaque;
-  struct wl_list link;
+  WaylandPollCleanup  cleanup;
+  void              * opaque;
+  struct wl_list      link;
 };
 
 struct OutputColorDescription;
@@ -273,40 +275,39 @@ struct WaylandDSState
 
   struct wl_list poll; // WaylandPoll::link
   struct wl_list pollFree; // WaylandPoll::link
-  LG_Lock pollLock;
-  LG_Lock pollFreeLock;
-  int epollFd;
-  int displayFd;
+  LG_Lock        pollLock;
+  LG_Lock        pollFreeLock;
+  unsigned int   pollWaiters;
+  int            epollFd;
+  int            displayFd;
 };
 
 struct WCBTransfer
 {
   struct CountedBuffer * data;
-  const char ** mimetypes;
+  const char           ** mimetypes;
 };
 
 struct ClipboardRead
 {
-  int fd;
-  size_t size;
-  size_t numRead;
-  uint8_t * buf;
-  enum LG_ClipboardData type;
-  struct wl_data_offer * offer;
+  int                    fd;
+  size_t                 size;
+  size_t                 numRead;
+  uint8_t              * buf;
+  LG_ClipboardRequest    request;
+  LG_ClipboardData       type;
 };
 
 struct WCBState
 {
   struct wl_data_device * dataDevice;
-  char lgMimetype[64];
+  char                    lgMimetype[64];
 
-  char * mimetypes[LG_CLIPBOARD_DATA_NONE];
+  char                 * mimetypes[LG_CLIPBOARD_DATA_NONE];
   struct wl_data_offer * offer;
   struct wl_data_offer * dndOffer;
 
-  bool haveRequest;
-  LG_ClipboardData type;
-
+  LG_Lock                lock;
   struct ClipboardRead * currentRead;
 };
 
@@ -320,7 +321,8 @@ void waylandActivationRequestActivation(void);
 
 // clipboard module
 bool waylandCBInit(void);
-void waylandCBRequest(LG_ClipboardData type);
+void waylandCBFree(void);
+void waylandCBRequest(LG_ClipboardRequest request, LG_ClipboardData type);
 void waylandCBNotice(LG_ClipboardData type);
 void waylandCBRelease(void);
 void waylandCBInvalidate(void);
@@ -407,8 +409,11 @@ void waylandOutputUpdateHDRWhiteLevel(void);
 
 // poll module
 bool waylandPollInit(void);
+void waylandPollFree(void);
 void waylandWait(unsigned int time);
 bool waylandPollRegister(int fd, WaylandPollCallback callback, void * opaque, uint32_t events);
+bool waylandPollRegisterWithCleanup(int fd, WaylandPollCallback callback,
+    void * opaque, WaylandPollCleanup cleanup, uint32_t events);
 bool waylandPollUnregister(int fd);
 
 // presentation module