[client] cosmetics/naming cleanup

2026-08-22 15:11:31 +00:00 · 2026-08-15 01:34:40 +10:00
parent c11842a43c
commit 97b249b49b
18 changed files with 630 additions and 633 deletions
--- a/client/displayservers/Wayland/clipboard.c
+++ b/client/displayservers/Wayland/clipboard.c
@@ -339,11 +339,11 @@ static void fileImportCallback(uint32_t events, void * opaque)
    wlCb.fileImport = NULL;
  LG_UNLOCK(wlCb.lock);
  if (current && (!complete ||
-      !lgClipboardFiles_setLocal(import->mime,
+      !clipboardFiles_setLocal(import->mime,
        import->data, import->size)))
  {
-    lgClipboardFiles_clearLocal();
-    lgClipboard_release();
+    clipboardFiles_clearLocal();
+    clipboard_release();
  }
  if (current)
    waylandPollUnregister(import->fd);
@@ -536,7 +536,7 @@ static void dataDeviceHandleSelection(void * opaque,
  {
    const LG_ClipboardRequest request = read->request;
    clipboardReadRetire(read);
-    lgClipboard_abort(request);
+    clipboard_abort(request);
  }
  if (oldImport)
    waylandPollUnregister(oldImport->fd);
@@ -548,12 +548,12 @@ static void dataDeviceHandleSelection(void * opaque,
  {
    if (!fileImportStart(offer, wlCb.mimetypes[LG_CLIPBOARD_DATA_FILES]))
    {
-      lgClipboardFiles_clearLocal();
-      lgClipboard_release();
+      clipboardFiles_clearLocal();
+      clipboard_release();
    }
  }
  else
-    lgClipboard_notifyTypes(types, idx);
+    clipboard_notifyTypes(types, idx);
 }

 static void dataDeviceHandleEnter(void * data, struct wl_data_device * device,
@@ -676,17 +676,17 @@ static enum ClipboardReadCallResult clipboardReadCall(
  switch (operation)
  {
    case CLIPBOARD_READ_BEGIN:
-      result = lgClipboard_dataBegin(
+      result = clipboard_dataBegin(
          request, type, LG_CLIPBOARD_SIZE_UNKNOWN);
      break;

    case CLIPBOARD_READ_CHUNK:
-      result = lgClipboard_dataChunk(
+      result = clipboard_dataChunk(
          request, offset, data->buffer, pending);
      break;

    case CLIPBOARD_READ_END:
-      result = lgClipboard_dataEnd(request, offset);
+      result = clipboard_dataEnd(request, offset);
      break;

    default:
@@ -755,7 +755,7 @@ static void clipboardReadCallback(uint32_t events, void * opaque)
  if (events & EPOLLERR)
  {
    if (clipboardReadClaim(data))
-      lgClipboard_abort(data->request);
+      clipboard_abort(data->request);
    return;
  }

@@ -810,7 +810,7 @@ static void clipboardReadCallback(uint32_t events, void * opaque)
        return;
      DEBUG_ERROR("Failed to read from clipboard: %s", strerror(readError));
      if (clipboardReadClaim(data))
-        lgClipboard_abort(data->request);
+        clipboard_abort(data->request);
      return;
    }
    if (!haveOperation)
@@ -866,17 +866,17 @@ static void waylandCBInvalidateLocal(enum ClipboardInvalidateMode mode)
  if (notifyProvider)
  {
    if (read)
-      lgClipboard_abort(request);
-    lgClipboard_release();
+      clipboard_abort(request);
+    clipboard_release();
  }
  LG_UNLOCK(wlCb.lock);

  if (import)
    waylandPollUnregister(import->fd);
-  lgClipboardFiles_clearLocal();
+  clipboardFiles_clearLocal();

  if (read && !notifyProvider)
-    lgClipboard_abort(request);
+    clipboard_abort(request);

  if (offer)
    wl_data_offer_destroy(offer);
@@ -899,7 +899,7 @@ void waylandCBRequest(LG_ClipboardRequest request, LG_ClipboardData type)
  if (pipe(fds) < 0)
  {
    DEBUG_ERROR("Failed to get a clipboard pipe: %s", strerror(errno));
-    lgClipboard_abort(request);
+    clipboard_abort(request);
    return;
  }
  const int readFlags   = fcntl(fds[0], F_GETFL);
@@ -913,7 +913,7 @@ void waylandCBRequest(LG_ClipboardRequest request, LG_ClipboardData type)
    DEBUG_ERROR("Failed to configure clipboard pipe: %s", strerror(errno));
    close(fds[0]);
    close(fds[1]);
-    lgClipboard_abort(request);
+    clipboard_abort(request);
    return;
  }

@@ -923,7 +923,7 @@ void waylandCBRequest(LG_ClipboardRequest request, LG_ClipboardData type)
    DEBUG_ERROR("Failed to allocate memory to read clipboard");
    close(fds[0]);
    close(fds[1]);
-    lgClipboard_abort(request);
+    clipboard_abort(request);
    return;
  }

@@ -956,7 +956,7 @@ void waylandCBRequest(LG_ClipboardRequest request, LG_ClipboardData type)
  {
    const LG_ClipboardRequest oldRequest = old->request;
    clipboardReadRetire(old);
-    lgClipboard_abort(oldRequest);
+    clipboard_abort(oldRequest);
  }
  if (!registered)
  {
@@ -964,7 +964,7 @@ void waylandCBRequest(LG_ClipboardRequest request, LG_ClipboardData type)
      DEBUG_ERROR("Failed to register clipboard read into epoll: %s",
          strerror(errno));
    clipboardReadCleanup(data);
-    lgClipboard_abort(request);
+    clipboard_abort(request);
    return;
  }
 }
@@ -1005,7 +1005,7 @@ void waylandCBRequestReady(LG_ClipboardRequest request)
  {
    const LG_ClipboardRequest id = failed->request;
    clipboardReadRetire(failed);
-    lgClipboard_abort(id);
+    clipboard_abort(id);
  }
 }

@@ -1192,7 +1192,7 @@ struct ClipboardFileWrite
 static void fileTransferDestroy(struct WCBTransfer * transfer)
 {
  if (transfer->filePresentation)
-    lgClipboardFiles_remotePresentationRelease(transfer->filePresentation);
+    clipboardFiles_remotePresentationRelease(transfer->filePresentation);
  free(transfer->fileUri);
  free(transfer->fileGnome);
  free(transfer->fileKde);
@@ -1216,7 +1216,7 @@ static void clipboardFileWriteCleanup(void * opaque)
 {
  struct ClipboardFileWrite * write = opaque;
  if (write->complete && write->deliversUri)
-    lgClipboardFiles_remotePresentationDelivered(
+    clipboardFiles_remotePresentationDelivered(
        write->transfer->filePresentation);
  close(write->fd);
  free(write->data);
@@ -1369,7 +1369,7 @@ static void clipboardWriteCallback(uint32_t events, void * opaque)
  const LG_ClipboardRequest request = data->request;
  LG_UNLOCK(data->lock);
  if (ready)
-    lgClipboard_requestReady(request);
+    clipboard_requestReady(request);
  return;

 error:
@@ -1391,7 +1391,7 @@ error:
  if (fd >= 0)
    waylandPollUnregister(fd);
  if (errorReady)
-    lgClipboard_requestReady(errorRequest);
+    clipboard_requestReady(errorRequest);
 }

 static void dataSourceHandleTarget(void * data, struct wl_data_source * source,
@@ -1451,7 +1451,7 @@ static void dataSourceHandleSend(void * data, struct wl_data_source * source,
      LG_LOCK(data->lock);
      data->requesting = true;
      LG_UNLOCK(data->lock);
-      const bool result = lgClipboard_requestStream(transfer->type,
+      const bool result = clipboard_requestStream(transfer->type,
          &clipboardWriteStream, data, &data->request);

      int retireFd = -1;
@@ -1529,16 +1529,16 @@ static bool waylandCBPublish(LG_ClipboardData type)
  transfer->next      = NULL;
  if (type == LG_CLIPBOARD_DATA_FILES)
    transfer->filePresentation =
-      lgClipboardFiles_remotePresentationAcquire();
+      clipboardFiles_remotePresentationAcquire();
  if (type == LG_CLIPBOARD_DATA_FILES &&
      (!transfer->filePresentation ||
-       !lgClipboardFiles_getRemotePresentation(transfer->filePresentation,
+       !clipboardFiles_getRemotePresentation(transfer->filePresentation,
          "text/uri-list",
          &transfer->fileUri, &transfer->fileUriSize) ||
-       !lgClipboardFiles_getRemotePresentation(transfer->filePresentation,
+       !clipboardFiles_getRemotePresentation(transfer->filePresentation,
          "x-special/gnome-copied-files",
          &transfer->fileGnome, &transfer->fileGnomeSize) ||
-       !lgClipboardFiles_getRemotePresentation(transfer->filePresentation,
+       !clipboardFiles_getRemotePresentation(transfer->filePresentation,
          "application/x-kde-cutselection",
          &transfer->fileKde, &transfer->fileKdeSize)))
  {
@@ -1628,7 +1628,7 @@ void waylandCBFree(void)
  clipboardReadRetire(read);
  if (import)
    waylandPollUnregister(import->fd);
-  lgClipboardFiles_clearLocal();
+  clipboardFiles_clearLocal();
  if (offer)
    wl_data_offer_destroy(offer);
  if (dndOffer && dndOffer != offer)
--- a/client/displayservers/X11/clipboard.c
+++ b/client/displayservers/X11/clipboard.c
@@ -227,12 +227,12 @@ bool x11CBEventThread(const XEvent * xe)
                NULL, 0);
            XFlush(x11.display);
            if (write->event.xselection.target != x11cb.aFileKde)
-              lgClipboardFiles_remotePresentationDelivered(
+              clipboardFiles_remotePresentationDelivered(
                  write->filePresentation);
            const uint64_t presentation = write->filePresentation;
            writeRemoveNL(write);
            LG_UNLOCK(x11cb.lock);
-            lgClipboardFiles_remotePresentationRelease(presentation);
+            clipboardFiles_remotePresentationRelease(presentation);
            free(write->fileData);
            free(write);
            return true;
@@ -249,7 +249,7 @@ bool x11CBEventThread(const XEvent * xe)
        if (write)
        {
          if (request != LG_CLIPBOARD_REQUEST_INVALID)
-            lgClipboard_requestReady(request);
+            clipboard_requestReady(request);
          return true;
        }
      }
@@ -517,9 +517,9 @@ static void x11CBSelectionRequest(const XSelectionRequestEvent e)
    if (available)
    {
      writePresentation =
-        lgClipboardFiles_remotePresentationAcquire();
+        clipboardFiles_remotePresentationAcquire();
      available = writePresentation == presentation &&
-        lgClipboardFiles_getRemotePresentation(writePresentation,
+        clipboardFiles_getRemotePresentation(writePresentation,
          fileMime, &data, &size);
    }
    LG_UNLOCK(x11cb.lock);
@@ -527,7 +527,7 @@ static void x11CBSelectionRequest(const XSelectionRequestEvent e)
    {
      free(data);
      if (writePresentation)
-        lgClipboardFiles_remotePresentationRelease(writePresentation);
+        clipboardFiles_remotePresentationRelease(writePresentation);
      goto nodata;
    }

@@ -535,7 +535,7 @@ static void x11CBSelectionRequest(const XSelectionRequestEvent e)
    if (!write)
    {
      free(data);
-      lgClipboardFiles_remotePresentationRelease(writePresentation);
+      clipboardFiles_remotePresentationRelease(writePresentation);
      DEBUG_ERROR("out of memory");
      goto nodata;
    }
@@ -579,7 +579,7 @@ static void x11CBSelectionRequest(const XSelectionRequestEvent e)
    if (duplicate)
    {
      free(write->fileData);
-      lgClipboardFiles_remotePresentationRelease(
+      clipboardFiles_remotePresentationRelease(
          write->filePresentation);
      free(write);
      goto nodata;
@@ -627,7 +627,7 @@ static void x11CBSelectionRequest(const XSelectionRequestEvent e)
        goto nodata;
      }

-      const bool result = lgClipboard_requestStream(requestType,
+      const bool result = clipboard_requestStream(requestType,
          &x11CBWriteStream, write, &write->request);
      LG_LOCK(x11cb.lock);
      const bool linked = writeLinkedNL(write);
@@ -682,7 +682,7 @@ static void x11CBSelectionClear(const XSelectionClearEvent e)
  LG_UNLOCK(x11cb.lock);

  if (presentation)
-    lgClipboardFiles_remotePresentationRelease(presentation);
+    clipboardFiles_remotePresentationRelease(presentation);
 }

 /* x11cb.lock must be held. */
@@ -817,7 +817,7 @@ static void cancelFileWrites(
      XChangeProperty(x11.display, writes->event.xselection.requestor,
          writes->event.xselection.property,
          writes->event.xselection.target, 8, PropModeReplace, NULL, 0);
-    lgClipboardFiles_remotePresentationRelease(
+    clipboardFiles_remotePresentationRelease(
        writes->filePresentation);
    free(writes->fileData);
    free(writes);
@@ -889,10 +889,10 @@ static bool startFileImport(Atom target)
 static void finishFileImport(struct X11ClipboardFileImport import,
    const void * data, size_t size)
 {
-  if (!lgClipboardFiles_setLocal(import.mime, data, size))
+  if (!clipboardFiles_setLocal(import.mime, data, size))
  {
-    lgClipboardFiles_clearLocal();
-    lgClipboard_release();
+    clipboardFiles_clearLocal();
+    clipboard_release();
  }
  free(import.data);
 }
@@ -923,7 +923,7 @@ static bool x11CBFileImportSelectionNotify(const XSelectionEvent e)
    if (data)
      XFree(data);
    free(failed.data);
-    lgClipboard_release();
+    clipboard_release();
    return true;
  }

@@ -936,7 +936,7 @@ static bool x11CBFileImportSelectionNotify(const XSelectionEvent e)
      if (data)
        XFree(data);
      free(failed.data);
-      lgClipboard_release();
+      clipboard_release();
      return true;
    }
    x11cb.fileImport.incremental = true;
@@ -954,7 +954,7 @@ static bool x11CBFileImportSelectionNotify(const XSelectionEvent e)
  else
  {
    free(import.data);
-    lgClipboard_release();
+    clipboard_release();
  }
  if (data)
    XFree(data);
@@ -993,7 +993,7 @@ readProperty:
    if (data)
      XFree(data);
    free(failed.data);
-    lgClipboard_release();
+    clipboard_release();
    return;
  }

@@ -1019,7 +1019,7 @@ readProperty:
      const struct X11ClipboardFileImport failed = takeFileImportNL();
      LG_UNLOCK(x11cb.lock);
      free(failed.data);
-      lgClipboard_release();
+      clipboard_release();
      return;
    }
    x11cb.fileImport.propertyOffset += (long)units;
@@ -1069,15 +1069,15 @@ static enum X11ClipboardReadCallResult x11CBReadCallNL(
  switch (operation)
  {
    case X11_CLIPBOARD_READ_BEGIN:
-      result = lgClipboard_dataBegin(request, type, sizeHint);
+      result = clipboard_dataBegin(request, type, sizeHint);
      break;

    case X11_CLIPBOARD_READ_CHUNK:
-      result = lgClipboard_dataChunk(request, offset, data, size);
+      result = clipboard_dataChunk(request, offset, data, size);
      break;

    case X11_CLIPBOARD_READ_END:
-      result = lgClipboard_dataEnd(request, offset);
+      result = clipboard_dataEnd(request, offset);
      break;

    default:
@@ -1151,7 +1151,7 @@ readProperty:
    const struct X11ClipboardRead read = clearReadNL();
    LG_UNLOCK(x11cb.lock);
    free(read.pending);
-    lgClipboard_abort(read.request);
+    clipboard_abort(read.request);
    return;
  }

@@ -1170,7 +1170,7 @@ readProperty:
    if (data)
      XFree(data);
    free(read.pending);
-    lgClipboard_abort(read.request);
+    clipboard_abort(read.request);
    return;
  }

@@ -1206,7 +1206,7 @@ readProperty:
    LG_UNLOCK(x11cb.lock);
    XFree(data);
    free(read.pending);
-    lgClipboard_abort(read.request);
+    clipboard_abort(read.request);
    return;
  }

@@ -1217,7 +1217,7 @@ readProperty:
    LG_UNLOCK(x11cb.lock);
    XFree(data);
    free(read.pending);
-    lgClipboard_abort(read.request);
+    clipboard_abort(read.request);
    return;
  }
  memcpy(copy, data, itemCount);
@@ -1261,7 +1261,7 @@ readProperty:
      const struct X11ClipboardRead read = clearReadNL();
      LG_UNLOCK(x11cb.lock);
      free(read.pending);
-      lgClipboard_abort(read.request);
+      clipboard_abort(read.request);
      return;
    }
    goto readProperty;
@@ -1300,11 +1300,11 @@ static void x11CBXFixesSelectionNotify(const XFixesSelectionNotifyEvent e)
    XFlush(x11.display);
    LG_UNLOCK(x11cb.lock);
    if (oldRequest != LG_CLIPBOARD_REQUEST_INVALID)
-      lgClipboard_abort(oldRequest);
+      clipboard_abort(oldRequest);
    if (presentation)
-      lgClipboardFiles_remotePresentationRelease(presentation);
-    lgClipboardFiles_clearLocal();
-    lgClipboard_release();
+      clipboardFiles_remotePresentationRelease(presentation);
+    clipboardFiles_clearLocal();
+    clipboard_release();
    return;
  }

@@ -1319,11 +1319,11 @@ static void x11CBXFixesSelectionNotify(const XFixesSelectionNotifyEvent e)
    XFlush(x11.display);
    LG_UNLOCK(x11cb.lock);
    if (oldRequest != LG_CLIPBOARD_REQUEST_INVALID)
-      lgClipboard_abort(oldRequest);
+      clipboard_abort(oldRequest);
    if (presentation)
-      lgClipboardFiles_remotePresentationRelease(presentation);
-    lgClipboardFiles_clearLocal();
-    lgClipboard_release();
+      clipboardFiles_remotePresentationRelease(presentation);
+    clipboardFiles_clearLocal();
+    clipboard_release();
    return;
  }

@@ -1339,10 +1339,10 @@ static void x11CBXFixesSelectionNotify(const XFixesSelectionNotifyEvent e)
  LG_UNLOCK(x11cb.lock);

  if (oldRequest != LG_CLIPBOARD_REQUEST_INVALID)
-    lgClipboard_abort(oldRequest);
+    clipboard_abort(oldRequest);
  if (presentation)
-    lgClipboardFiles_remotePresentationRelease(presentation);
-  lgClipboardFiles_clearLocal();
+    clipboardFiles_remotePresentationRelease(presentation);
+  clipboardFiles_clearLocal();
 }

 static void x11CBSelectionNotify(const XSelectionEvent e)
@@ -1365,7 +1365,7 @@ static void x11CBSelectionNotify(const XSelectionEvent e)
    {
      clearTargetsNL();
      LG_UNLOCK(x11cb.lock);
-      lgClipboard_release();
+      clipboard_release();
      return;
    }

@@ -1384,7 +1384,7 @@ static void x11CBSelectionNotify(const XSelectionEvent e)
    {
      clearTargetsNL();
      LG_UNLOCK(x11cb.lock);
-      lgClipboard_release();
+      clipboard_release();
      return;
    }
    clearTargetsNL();
@@ -1395,7 +1395,7 @@ static void x11CBSelectionNotify(const XSelectionEvent e)
    // an array of padded 64-bit values
    if (!data || format != 32)
    {
-      lgClipboard_release();
+      clipboard_release();
      goto out;
    }

@@ -1421,9 +1421,9 @@ static void x11CBSelectionNotify(const XSelectionEvent e)

    if (fileTarget != None)
    {
-      lgClipboardFiles_clearLocal();
+      clipboardFiles_clearLocal();
      if (!startFileImport(fileTarget))
-        lgClipboard_release();
+        clipboard_release();
      goto out;
    }

@@ -1435,7 +1435,7 @@ static void x11CBSelectionNotify(const XSelectionEvent e)
          break;
        }

-    lgClipboard_notifyTypes(types, typeCount);
+    clipboard_notifyTypes(types, typeCount);
    goto out;
  }
  LG_UNLOCK(x11cb.lock);
@@ -1451,7 +1451,7 @@ static void x11CBSelectionNotify(const XSelectionEvent e)
  {
    const LG_ClipboardRequest request = cancelReadNL(true);
    LG_UNLOCK(x11cb.lock);
-    lgClipboard_abort(request);
+    clipboard_abort(request);
    return;
  }

@@ -1470,7 +1470,7 @@ static void x11CBSelectionNotify(const XSelectionEvent e)
  {
    const LG_ClipboardRequest request = cancelReadNL(true);
    LG_UNLOCK(x11cb.lock);
-    lgClipboard_abort(request);
+    clipboard_abort(request);
    return;
  }

@@ -1482,7 +1482,7 @@ static void x11CBSelectionNotify(const XSelectionEvent e)
      LG_UNLOCK(x11cb.lock);
      if (data)
        XFree(data);
-      lgClipboard_abort(request);
+      clipboard_abort(request);
      return;
    }

@@ -1543,11 +1543,11 @@ static void x11CBSelectionNotify(const XSelectionEvent e)
  if (!valid)
  {
    DEBUG_WARN("Invalid clipboard data");
-    lgClipboard_abort(request);
+    clipboard_abort(request);
    goto out;
  }

-  lgClipboard_data(request, dataType, data, itemCount);
+  clipboard_data(request, dataType, data, itemCount);

 out:
  if (data)
@@ -1557,7 +1557,7 @@ out:
 void x11CBNotice(LG_ClipboardData type)
 {
  const uint64_t nextPresentation = type == LG_CLIPBOARD_DATA_FILES ?
-    lgClipboardFiles_remotePresentationAcquire() : 0;
+    clipboardFiles_remotePresentationAcquire() : 0;
  LG_LOCK(x11cb.lock);
  const LG_ClipboardRequest oldRequest = x11cb.read.window ?
    cancelReadNL(true) : LG_CLIPBOARD_REQUEST_INVALID;
@@ -1573,10 +1573,10 @@ void x11CBNotice(LG_ClipboardData type)
  XFlush(x11.display);
  LG_UNLOCK(x11cb.lock);
  if (oldRequest != LG_CLIPBOARD_REQUEST_INVALID)
-    lgClipboard_abort(oldRequest);
+    clipboard_abort(oldRequest);
  if (oldPresentation)
-    lgClipboardFiles_remotePresentationRelease(oldPresentation);
-  lgClipboardFiles_clearLocal();
+    clipboardFiles_remotePresentationRelease(oldPresentation);
+  clipboardFiles_clearLocal();
 }

 void x11CBRelease(void)
@@ -1593,7 +1593,7 @@ void x11CBRelease(void)
  XFlush(x11.display);
  LG_UNLOCK(x11cb.lock);
  if (presentation)
-    lgClipboardFiles_remotePresentationRelease(presentation);
+    clipboardFiles_remotePresentationRelease(presentation);
 }

 void x11CBFree(void)
@@ -1609,9 +1609,9 @@ void x11CBFree(void)
  LG_UNLOCK(x11cb.lock);

  if (request != LG_CLIPBOARD_REQUEST_INVALID)
-    lgClipboard_abort(request);
+    clipboard_abort(request);
  cancelFileWrites(writes, true);
-  lgClipboardFiles_clearLocal();
+  clipboardFiles_clearLocal();
 }

 void x11CBRequest(LG_ClipboardRequest request, LG_ClipboardData type)
@@ -1627,8 +1627,8 @@ void x11CBRequest(LG_ClipboardRequest request, LG_ClipboardData type)
  {
    LG_UNLOCK(x11cb.lock);
    if (oldRequest != LG_CLIPBOARD_REQUEST_INVALID)
-      lgClipboard_abort(oldRequest);
-    lgClipboard_abort(request);
+      clipboard_abort(oldRequest);
+    clipboard_abort(request);
    return;
  }

@@ -1638,8 +1638,8 @@ void x11CBRequest(LG_ClipboardRequest request, LG_ClipboardData type)
  {
    LG_UNLOCK(x11cb.lock);
    if (oldRequest != LG_CLIPBOARD_REQUEST_INVALID)
-      lgClipboard_abort(oldRequest);
-    lgClipboard_abort(request);
+      clipboard_abort(oldRequest);
+    clipboard_abort(request);
    return;
  }

@@ -1661,7 +1661,7 @@ void x11CBRequest(LG_ClipboardRequest request, LG_ClipboardData type)
  LG_UNLOCK(x11cb.lock);

  if (oldRequest != LG_CLIPBOARD_REQUEST_INVALID)
-    lgClipboard_abort(oldRequest);
+    clipboard_abort(oldRequest);
 }

 void x11CBRequestReady(LG_ClipboardRequest request)
@@ -1706,7 +1706,7 @@ void x11CBRequestReady(LG_ClipboardRequest request)
    {
      const LG_ClipboardRequest abort = cancelReadNL(true);
      LG_UNLOCK(x11cb.lock);
-      lgClipboard_abort(abort);
+      clipboard_abort(abort);
      return;
    }
    memcpy(pending, x11cb.read.pending, pendingSize);
@@ -1767,7 +1767,7 @@ void x11CBRequestReady(LG_ClipboardRequest request)
        const struct X11ClipboardRead read = clearReadNL();
        LG_UNLOCK(x11cb.lock);
        free(read.pending);
-        lgClipboard_abort(read.request);
+        clipboard_abort(read.request);
        return;
      }
      processProperty = true;
--- a/client/include/core/clipboard.h
+++ b/client/include/core/clipboard.h
@@ -23,55 +23,55 @@

 #include "interface/clipboard.h"

-bool lgClipboard_init(void);
-void lgClipboard_free(void);
-void lgClipboard_setLocalAvailable(bool available);
+bool clipboard_init(void);
+void clipboard_free(void);
+void clipboard_setLocalAvailable(bool available);

-void lgClipboard_setFallback(const LG_ClipboardOps * ops, void * opaque);
+void clipboard_setFallback(const LG_ClipboardOps * ops, void * opaque);
 /* Drop functions remove a dead endpoint without invoking it. */
-void lgClipboard_dropFallback(void);
-void lgClipboard_setTransport(const LG_ClipboardOps * ops, void * opaque);
-void lgClipboard_dropTransport(void);
+void clipboard_dropFallback(void);
+void clipboard_setTransport(const LG_ClipboardOps * ops, void * opaque);
+void clipboard_dropTransport(void);

-void lgClipboard_release(void);
-void lgClipboard_notifyTypes(
+void clipboard_release(void);
+void clipboard_notifyTypes(
    const LG_ClipboardData types[], size_t count);
-void lgClipboard_notifyFiles(uint64_t dataset);
-LG_ClipboardResult lgClipboard_dataBegin(LG_ClipboardRequest request,
+void clipboard_notifyFiles(uint64_t dataset);
+LG_ClipboardResult clipboard_dataBegin(LG_ClipboardRequest request,
    LG_ClipboardData type, uint64_t sizeHint);
-LG_ClipboardResult lgClipboard_dataChunk(LG_ClipboardRequest request,
+LG_ClipboardResult clipboard_dataChunk(LG_ClipboardRequest request,
    uint64_t offset, const void * data, size_t size);
-LG_ClipboardResult lgClipboard_dataEnd(LG_ClipboardRequest request,
+LG_ClipboardResult clipboard_dataEnd(LG_ClipboardRequest request,
    uint64_t finalSize);
-void lgClipboard_data(LG_ClipboardRequest request,
+void clipboard_data(LG_ClipboardRequest request,
    LG_ClipboardData type, const void * data, size_t size);
-void lgClipboard_abort(LG_ClipboardRequest request);
+void clipboard_abort(LG_ClipboardRequest request);
 /* request is published before provider dispatch. Its storage must remain
 * valid until this function returns and may be observed by stream callbacks
 * before then. */
-bool lgClipboard_requestStream(LG_ClipboardData type,
+bool clipboard_requestStream(LG_ClipboardData type,
    const LG_ClipboardStreamOps * stream, void * opaque,
    LG_ClipboardRequest * request);
-bool lgClipboard_requestReady(LG_ClipboardRequest request);
-bool lgClipboard_request(LG_ClipboardData type,
+bool clipboard_requestReady(LG_ClipboardRequest request);
+bool clipboard_request(LG_ClipboardData type,
    LG_ClipboardReplyFn replyFn, void * opaque);

 /* File-dataset transport entry points used by clipboard_files.c. */
-bool lgClipboard_fileAcquire(uint64_t dataset, uint64_t acquisition);
-bool lgClipboard_fileAcquired(uint64_t dataset, uint64_t acquisition,
+bool clipboard_fileAcquire(uint64_t dataset, uint64_t acquisition);
+bool clipboard_fileAcquired(uint64_t dataset, uint64_t acquisition,
    LG_ClipboardFileError error);
-bool lgClipboard_fileRelease(uint64_t dataset, uint64_t acquisition);
-bool lgClipboard_fileRequest(const LG_ClipboardFileRequest * request);
-LG_ClipboardResult lgClipboard_fileDataBegin(
+bool clipboard_fileRelease(uint64_t dataset, uint64_t acquisition);
+bool clipboard_fileRequest(const LG_ClipboardFileRequest * request);
+LG_ClipboardResult clipboard_fileDataBegin(
    const LG_ClipboardFileRequest * request, uint64_t sizeHint);
-LG_ClipboardResult lgClipboard_fileDataChunk(
+LG_ClipboardResult clipboard_fileDataChunk(
    const LG_ClipboardFileRequest * request, uint64_t responseOffset,
    const void * data, size_t size, bool end);
-LG_ClipboardResult lgClipboard_fileDataEnd(
+LG_ClipboardResult clipboard_fileDataEnd(
    const LG_ClipboardFileRequest * request, uint64_t finalSize);
-bool lgClipboard_fileCancel(uint64_t dataset, uint64_t request,
+bool clipboard_fileCancel(uint64_t dataset, uint64_t request,
    LG_ClipboardFileError reason);
-void lgClipboard_fileRemoteReady(uint64_t dataset);
-void lgClipboard_fileRemoteFailed(uint64_t dataset);
+void clipboard_fileRemoteReady(uint64_t dataset);
+void clipboard_fileRemoteFailed(uint64_t dataset);

 #endif
--- a/client/include/core/clipboard_files.h
+++ b/client/include/core/clipboard_files.h
@@ -23,63 +23,63 @@

 #include "interface/clipboard.h"

-bool lgClipboardFiles_init(void);
-void lgClipboardFiles_free(void);
+bool clipboardFiles_init(void);
+void clipboardFiles_free(void);

 /* Desktop backends install a local file selection after reading one of the
 * standard URI clipboard representations. The payload is copied. */
-bool lgClipboardFiles_setLocal(const char * mime,
+bool clipboardFiles_setLocal(const char * mime,
    const void * data, size_t size);
-void lgClipboardFiles_clearLocal(void);
+void clipboardFiles_clearLocal(void);

 /* Returns an allocated desktop representation for the current guest offer. */
-bool lgClipboardFiles_getRemote(const char * mime,
+bool clipboardFiles_getRemote(const char * mime,
    char ** data, size_t * size);
-uint64_t lgClipboardFiles_remotePresentationAcquire(void);
-bool lgClipboardFiles_getRemotePresentation(uint64_t presentation,
+uint64_t clipboardFiles_remotePresentationAcquire(void);
+bool clipboardFiles_getRemotePresentation(uint64_t presentation,
    const char * mime, char ** data, size_t * size);
-void lgClipboardFiles_remotePresentationDelivered(uint64_t presentation);
-void lgClipboardFiles_remotePresentationRelease(uint64_t presentation);
-bool lgClipboardFiles_remoteReady(uint64_t dataset);
+void clipboardFiles_remotePresentationDelivered(uint64_t presentation);
+void clipboardFiles_remotePresentationRelease(uint64_t presentation);
+bool clipboardFiles_remoteReady(uint64_t dataset);

 /* Events delivered by the active clipboard transport. */
-bool lgClipboardFiles_remoteOffer(uint64_t dataset);
-void lgClipboardFiles_remoteClear(void);
-void lgClipboardFiles_providerUnavailable(void);
-void lgClipboardFiles_remoteAcquired(uint64_t dataset,
+bool clipboardFiles_remoteOffer(uint64_t dataset);
+void clipboardFiles_remoteClear(void);
+void clipboardFiles_providerUnavailable(void);
+void clipboardFiles_remoteAcquired(uint64_t dataset,
    uint64_t acquisition, LG_ClipboardFileError error);
-LG_ClipboardResult lgClipboardFiles_remoteDataBegin(
+LG_ClipboardResult clipboardFiles_remoteDataBegin(
    const LG_ClipboardFileRequest * request, uint64_t sizeHint);
-LG_ClipboardResult lgClipboardFiles_remoteDataChunk(
+LG_ClipboardResult clipboardFiles_remoteDataChunk(
    const LG_ClipboardFileRequest * request, uint64_t responseOffset,
    const void * data, size_t size);
-LG_ClipboardResult lgClipboardFiles_remoteDataEnd(
+LG_ClipboardResult clipboardFiles_remoteDataEnd(
    const LG_ClipboardFileRequest * request, uint64_t finalSize);
-void lgClipboardFiles_remoteCancel(uint64_t dataset,
+void clipboardFiles_remoteCancel(uint64_t dataset,
    uint64_t request, LG_ClipboardFileError reason);

-void lgClipboardFiles_localAcquire(uint64_t dataset,
+void clipboardFiles_localAcquire(uint64_t dataset,
    uint64_t acquisition);
-void lgClipboardFiles_localRelease(uint64_t dataset,
+void clipboardFiles_localRelease(uint64_t dataset,
    uint64_t acquisition);
-void lgClipboardFiles_localRequest(
+void clipboardFiles_localRequest(
    const LG_ClipboardFileRequest * request);
-void lgClipboardFiles_localCancel(uint64_t dataset,
+void clipboardFiles_localCancel(uint64_t dataset,
    uint64_t request, LG_ClipboardFileError reason);
-void lgClipboardFiles_localReady(uint64_t request);
+void clipboardFiles_localReady(uint64_t request);

 #ifdef ENABLE_TESTS
-bool lgClipboardFiles_testInit(uint64_t nonce);
-bool lgClipboardFiles_testFuseStopWake(void);
-bool lgClipboardFiles_testUnsentRemoteOwnership(void);
-size_t lgClipboardFiles_testRemoteDatasetCount(void);
-void lgClipboardFiles_testExpireRemoteDeliveries(void);
-bool lgClipboardFiles_testBeginRemoteLookup(uint64_t presentation);
-void lgClipboardFiles_testEndRemoteLookup(uint64_t presentation);
-bool lgClipboardFiles_testRemoteRead(uint64_t presentation,
+bool clipboardFiles_testInit(uint64_t nonce);
+bool clipboardFiles_testFuseStopWake(void);
+bool clipboardFiles_testUnsentRemoteOwnership(void);
+size_t clipboardFiles_testRemoteDatasetCount(void);
+void clipboardFiles_testExpireRemoteDeliveries(void);
+bool clipboardFiles_testBeginRemoteLookup(uint64_t presentation);
+void clipboardFiles_testEndRemoteLookup(uint64_t presentation);
+bool clipboardFiles_testRemoteRead(uint64_t presentation,
    uint64_t node, uint64_t offset, uint32_t length);
-void lgClipboardFiles_testForceLocalEof(void);
-bool lgClipboardFiles_testLocalRequest(
+void clipboardFiles_testForceLocalEof(void);
+bool clipboardFiles_testLocalRequest(
    const LG_ClipboardFileRequest * request);
 #endif

--- a/client/src/app.c
+++ b/client/src/app.c
@@ -130,7 +130,7 @@ void app_mouseTrace(const char * file, unsigned int line,
    return;

  flockfile(stderr);
-  debug_info(file, line, function, "Mouse %06" PRIu64 ": %s", seq,
+  debug_info(file, line, function, "Mouse %06lu: %s", seq,
      message);
  funlockfile(stderr);
 }
--- a/client/src/clipboard.c
+++ b/client/src/clipboard.c
@@ -389,7 +389,7 @@ static void resetRemote(void)
  LG_UNLOCK(clipboard.stateLock);
  LG_UNLOCK(clipboard.requestLock);

-  lgClipboardFiles_providerUnavailable();
+  clipboardFiles_providerUnavailable();

  LG_LOCK(clipboard.callbackLock);
  cancelRequestsNL(NULL, 0, true, LG_CLIPBOARD_CANCEL_UNAVAILABLE);
@@ -522,7 +522,7 @@ static void eventNotice(void * opaque,
  LG_UNLOCK(clipboard.stateLock);
  LG_UNLOCK(clipboard.requestLock);
  if (!hasFiles)
-    lgClipboardFiles_remoteClear();
+    clipboardFiles_remoteClear();
  LG_UNLOCK(clipboard.fileLock);

  LG_LOCK(clipboard.callbackLock);
@@ -545,7 +545,7 @@ static void eventNotice(void * opaque,
  if (notice && active)
  {
    if (type != LG_CLIPBOARD_DATA_FILES ||
-        lgClipboardFiles_remoteReady(fileDataset))
+        clipboardFiles_remoteReady(fileDataset))
      g_state.ds->cbNotice(type);
  }
  else if (release && active && g_state.ds->cbRelease)
@@ -948,7 +948,7 @@ static void eventRelease(void * opaque)
  LG_UNLOCK(clipboard.requestLock);

  LG_LOCK(clipboard.fileLock);
-  lgClipboardFiles_remoteClear();
+  clipboardFiles_remoteClear();
  LG_UNLOCK(clipboard.fileLock);

  LG_LOCK(clipboard.callbackLock);
@@ -1097,13 +1097,13 @@ static void eventFileOffer(void * opaque, uint64_t dataset)
  LG_LOCK(clipboard.stateLock);
  clipboard.remoteFileDataset = dataset;
  LG_UNLOCK(clipboard.stateLock);
-  if (!lgClipboardFiles_remoteOffer(dataset))
+  if (!clipboardFiles_remoteOffer(dataset))
  {
    LG_LOCK(clipboard.stateLock);
    if (clipboard.remoteFileDataset == dataset)
      clipboard.remoteFileDataset = 0;
    LG_UNLOCK(clipboard.stateLock);
-    lgClipboardFiles_remoteClear();
+    clipboardFiles_remoteClear();
  }
  LG_UNLOCK(clipboard.fileLock);
 }
@@ -1117,7 +1117,7 @@ static void eventFileAcquire(void * opaque, uint64_t dataset,
    LG_UNLOCK(clipboard.fileLock);
    return;
  }
-  lgClipboardFiles_localAcquire(dataset, acquisition);
+  clipboardFiles_localAcquire(dataset, acquisition);
  LG_UNLOCK(clipboard.fileLock);
 }

@@ -1130,7 +1130,7 @@ static void eventFileAcquired(void * opaque, uint64_t dataset,
    LG_UNLOCK(clipboard.fileLock);
    return;
  }
-  lgClipboardFiles_remoteAcquired(dataset, acquisition, error);
+  clipboardFiles_remoteAcquired(dataset, acquisition, error);
  LG_UNLOCK(clipboard.fileLock);
 }

@@ -1143,7 +1143,7 @@ static void eventFileRelease(void * opaque, uint64_t dataset,
    LG_UNLOCK(clipboard.fileLock);
    return;
  }
-  lgClipboardFiles_localRelease(dataset, acquisition);
+  clipboardFiles_localRelease(dataset, acquisition);
  LG_UNLOCK(clipboard.fileLock);
 }

@@ -1156,7 +1156,7 @@ static void eventFileRequest(void * opaque,
    LG_UNLOCK(clipboard.fileLock);
    return;
  }
-  lgClipboardFiles_localRequest(request);
+  clipboardFiles_localRequest(request);
  LG_UNLOCK(clipboard.fileLock);
 }

@@ -1170,7 +1170,7 @@ static LG_ClipboardResult eventFileDataBegin(void * opaque,
    return LG_CLIPBOARD_RESULT_FAILED;
  }
  const LG_ClipboardResult result =
-    lgClipboardFiles_remoteDataBegin(request, sizeHint);
+    clipboardFiles_remoteDataBegin(request, sizeHint);
  LG_UNLOCK(clipboard.fileLock);
  return result;
 }
@@ -1185,7 +1185,7 @@ static LG_ClipboardResult eventFileDataChunk(void * opaque,
    LG_UNLOCK(clipboard.fileLock);
    return LG_CLIPBOARD_RESULT_FAILED;
  }
-  const LG_ClipboardResult result = lgClipboardFiles_remoteDataChunk(
+  const LG_ClipboardResult result = clipboardFiles_remoteDataChunk(
      request, responseOffset, data, size);
  LG_UNLOCK(clipboard.fileLock);
  return result;
@@ -1201,7 +1201,7 @@ static LG_ClipboardResult eventFileDataEnd(void * opaque,
    return LG_CLIPBOARD_RESULT_FAILED;
  }
  const LG_ClipboardResult result =
-    lgClipboardFiles_remoteDataEnd(request, finalSize);
+    clipboardFiles_remoteDataEnd(request, finalSize);
  LG_UNLOCK(clipboard.fileLock);
  return result;
 }
@@ -1214,7 +1214,7 @@ static void eventFileDataReady(void * opaque, uint64_t request)
    LG_UNLOCK(clipboard.fileLock);
    return;
  }
-  lgClipboardFiles_localReady(request);
+  clipboardFiles_localReady(request);
  LG_UNLOCK(clipboard.fileLock);
 }

@@ -1227,8 +1227,8 @@ static void eventFileCancel(void * opaque, uint64_t dataset,
    LG_UNLOCK(clipboard.fileLock);
    return;
  }
-  lgClipboardFiles_remoteCancel(dataset, request, reason);
-  lgClipboardFiles_localCancel(dataset, request, reason);
+  clipboardFiles_remoteCancel(dataset, request, reason);
+  clipboardFiles_localCancel(dataset, request, reason);
  LG_UNLOCK(clipboard.fileLock);
 }

@@ -1386,7 +1386,7 @@ static void setBinding(ClipboardBinding * target,
  LG_UNLOCK(clipboard.registrationLock);
 }

-bool lgClipboard_init(void)
+bool clipboard_init(void)
 {
  memset(&clipboard, 0, sizeof(clipboard));
  LG_LOCK_INIT(clipboard.registrationLock);
@@ -1400,7 +1400,7 @@ bool lgClipboard_init(void)
  clipboard.remoteType        = LG_CLIPBOARD_DATA_NONE;
  clipboard.remoteRequestType = LG_CLIPBOARD_DATA_NONE;
  clipboard.requests          = ll_new();
-  if (!lgClipboardFiles_init())
+  if (!clipboardFiles_init())
  {
    DEBUG_ERROR("Failed to initialize clipboard file transfer");
    return false;
@@ -1408,12 +1408,12 @@ bool lgClipboard_init(void)
  return true;
 }

-void lgClipboard_free(void)
+void clipboard_free(void)
 {
-  lgClipboard_setLocalAvailable(false);
-  lgClipboard_setTransport(NULL, NULL);
-  lgClipboard_setFallback(NULL, NULL);
-  lgClipboardFiles_free();
+  clipboard_setLocalAvailable(false);
+  clipboard_setTransport(NULL, NULL);
+  clipboard_setFallback(NULL, NULL);
+  clipboardFiles_free();
  LG_LOCK(clipboard.callbackLock);
  cancelRequestsNL(NULL, 0, true, LG_CLIPBOARD_CANCEL_UNAVAILABLE);
  LG_UNLOCK(clipboard.callbackLock);
@@ -1433,7 +1433,7 @@ void lgClipboard_free(void)
  LG_LOCK_FREE(clipboard.registrationLock);
 }

-void lgClipboard_setLocalAvailable(bool available)
+void clipboard_setLocalAvailable(bool available)
 {
  bool notice;
  bool release;
@@ -1459,7 +1459,7 @@ void lgClipboard_setLocalAvailable(bool available)
  if (notice)
  {
    if (type != LG_CLIPBOARD_DATA_FILES ||
-        lgClipboardFiles_remoteReady(fileDataset))
+        clipboardFiles_remoteReady(fileDataset))
      g_state.ds->cbNotice(type);
  }
  if (!available)
@@ -1475,7 +1475,7 @@ void lgClipboard_setLocalAvailable(bool available)
  LG_UNLOCK(clipboard.callbackLock);
 }

-void lgClipboard_setFallback(const LG_ClipboardOps * ops, void * opaque)
+void clipboard_setFallback(const LG_ClipboardOps * ops, void * opaque)
 {
  setBinding(&clipboard.fallback,
      ops, opaque, fallbackStatusChanged);
@@ -1494,23 +1494,23 @@ static void dropBinding(ClipboardBinding * target)
  LG_UNLOCK(clipboard.registrationLock);
 }

-void lgClipboard_dropFallback(void)
+void clipboard_dropFallback(void)
 {
  dropBinding(&clipboard.fallback);
 }

-void lgClipboard_setTransport(const LG_ClipboardOps * ops, void * opaque)
+void clipboard_setTransport(const LG_ClipboardOps * ops, void * opaque)
 {
  setBinding(&clipboard.transport,
      ops, opaque, transportStatusChanged);
 }

-void lgClipboard_dropTransport(void)
+void clipboard_dropTransport(void)
 {
  dropBinding(&clipboard.transport);
 }

-void lgClipboard_release(void)
+void clipboard_release(void)
 {
  if (!g_params.clipboardToVM)
    return;
@@ -1530,14 +1530,14 @@ void lgClipboard_release(void)
  LG_UNLOCK(clipboard.writeLock);
 }

-void lgClipboard_notifyTypes(
+void clipboard_notifyTypes(
    const LG_ClipboardData types[], size_t count)
 {
  if (!g_params.clipboardToVM)
    return;
  if (count == 0)
  {
-    lgClipboard_release();
+    clipboard_release();
    return;
  }
  if (!types || count > LG_CLIPBOARD_DATA_NONE)
@@ -1564,7 +1564,7 @@ void lgClipboard_notifyTypes(
  LG_UNLOCK(clipboard.writeLock);
 }

-void lgClipboard_notifyFiles(uint64_t dataset)
+void clipboard_notifyFiles(uint64_t dataset)
 {
  if (!g_params.clipboardToVM || !dataset)
    return;
@@ -1827,7 +1827,7 @@ static LG_ClipboardResult pumpRemoteCompat(void)
  }
 }

-LG_ClipboardResult lgClipboard_dataBegin(LG_ClipboardRequest transfer,
+LG_ClipboardResult clipboard_dataBegin(LG_ClipboardRequest transfer,
    LG_ClipboardData type, uint64_t sizeHint)
 {
  if (!g_params.clipboardToVM ||
@@ -1846,7 +1846,7 @@ LG_ClipboardResult lgClipboard_dataBegin(LG_ClipboardRequest transfer,
  return result;
 }

-LG_ClipboardResult lgClipboard_dataChunk(LG_ClipboardRequest transfer,
+LG_ClipboardResult clipboard_dataChunk(LG_ClipboardRequest transfer,
    uint64_t offset, const void * data, size_t size)
 {
  if (!g_params.clipboardToVM ||
@@ -1865,7 +1865,7 @@ LG_ClipboardResult lgClipboard_dataChunk(LG_ClipboardRequest transfer,
  return result;
 }

-LG_ClipboardResult lgClipboard_dataEnd(LG_ClipboardRequest transfer,
+LG_ClipboardResult clipboard_dataEnd(LG_ClipboardRequest transfer,
    uint64_t finalSize)
 {
  if (!g_params.clipboardToVM ||
@@ -1884,7 +1884,7 @@ LG_ClipboardResult lgClipboard_dataEnd(LG_ClipboardRequest transfer,
  return result;
 }

-void lgClipboard_data(LG_ClipboardRequest transfer,
+void clipboard_data(LG_ClipboardRequest transfer,
    LG_ClipboardData type, const void * data, size_t size)
 {
  if (!g_params.clipboardToVM ||
@@ -1953,7 +1953,7 @@ void lgClipboard_data(LG_ClipboardRequest transfer,
    DEBUG_WARN("Failed to send remote clipboard data");
 }

-void lgClipboard_abort(LG_ClipboardRequest transfer)
+void clipboard_abort(LG_ClipboardRequest transfer)
 {
  if (!g_params.clipboardToVM ||
      transfer == LG_CLIPBOARD_REQUEST_INVALID)
@@ -2049,7 +2049,7 @@ static bool requestClipboard(LG_ClipboardData type,
  return false;
 }

-bool lgClipboard_requestStream(LG_ClipboardData type,
+bool clipboard_requestStream(LG_ClipboardData type,
    const LG_ClipboardStreamOps * stream, void * opaque,
    LG_ClipboardRequest * request)
 {
@@ -2058,7 +2058,7 @@ bool lgClipboard_requestStream(LG_ClipboardData type,
  return requestClipboard(type, NULL, stream, opaque, request);
 }

-bool lgClipboard_requestReady(LG_ClipboardRequest id)
+bool clipboard_requestReady(LG_ClipboardRequest id)
 {
  if (id == LG_CLIPBOARD_REQUEST_INVALID || !clipboard.requests)
    return false;
@@ -2116,7 +2116,7 @@ bool lgClipboard_requestReady(LG_ClipboardRequest id)
  return result;
 }

-bool lgClipboard_request(LG_ClipboardData type,
+bool clipboard_request(LG_ClipboardData type,
    LG_ClipboardReplyFn replyFn, void * opaque)
 {
  if (!replyFn)
@@ -2124,7 +2124,7 @@ bool lgClipboard_request(LG_ClipboardData type,
  return requestClipboard(type, replyFn, NULL, opaque, NULL);
 }

-bool lgClipboard_fileAcquire(uint64_t dataset, uint64_t acquisition)
+bool clipboard_fileAcquire(uint64_t dataset, uint64_t acquisition)
 {
  bool result = false;
  LG_LOCK_SHARED(clipboard.activeLock);
@@ -2135,7 +2135,7 @@ bool lgClipboard_fileAcquire(uint64_t dataset, uint64_t acquisition)
  return result;
 }

-bool lgClipboard_fileAcquired(uint64_t dataset, uint64_t acquisition,
+bool clipboard_fileAcquired(uint64_t dataset, uint64_t acquisition,
    LG_ClipboardFileError error)
 {
  bool result = false;
@@ -2147,7 +2147,7 @@ bool lgClipboard_fileAcquired(uint64_t dataset, uint64_t acquisition,
  return result;
 }

-bool lgClipboard_fileRelease(uint64_t dataset, uint64_t acquisition)
+bool clipboard_fileRelease(uint64_t dataset, uint64_t acquisition)
 {
  bool result = false;
  LG_LOCK_SHARED(clipboard.activeLock);
@@ -2158,7 +2158,7 @@ bool lgClipboard_fileRelease(uint64_t dataset, uint64_t acquisition)
  return result;
 }

-bool lgClipboard_fileRequest(const LG_ClipboardFileRequest * request)
+bool clipboard_fileRequest(const LG_ClipboardFileRequest * request)
 {
  bool result = false;
  LG_LOCK_SHARED(clipboard.activeLock);
@@ -2169,7 +2169,7 @@ bool lgClipboard_fileRequest(const LG_ClipboardFileRequest * request)
  return result;
 }

-LG_ClipboardResult lgClipboard_fileDataBegin(
+LG_ClipboardResult clipboard_fileDataBegin(
    const LG_ClipboardFileRequest * request, uint64_t sizeHint)
 {
  LG_ClipboardResult result = LG_CLIPBOARD_RESULT_FAILED;
@@ -2181,7 +2181,7 @@ LG_ClipboardResult lgClipboard_fileDataBegin(
  return result;
 }

-LG_ClipboardResult lgClipboard_fileDataChunk(
+LG_ClipboardResult clipboard_fileDataChunk(
    const LG_ClipboardFileRequest * request, uint64_t responseOffset,
    const void * data, size_t size, bool end)
 {
@@ -2194,7 +2194,7 @@ LG_ClipboardResult lgClipboard_fileDataChunk(
  return result;
 }

-LG_ClipboardResult lgClipboard_fileDataEnd(
+LG_ClipboardResult clipboard_fileDataEnd(
    const LG_ClipboardFileRequest * request, uint64_t finalSize)
 {
  LG_ClipboardResult result = LG_CLIPBOARD_RESULT_FAILED;
@@ -2206,7 +2206,7 @@ LG_ClipboardResult lgClipboard_fileDataEnd(
  return result;
 }

-bool lgClipboard_fileCancel(uint64_t dataset, uint64_t request,
+bool clipboard_fileCancel(uint64_t dataset, uint64_t request,
    LG_ClipboardFileError reason)
 {
  bool result = false;
@@ -2218,7 +2218,7 @@ bool lgClipboard_fileCancel(uint64_t dataset, uint64_t request,
  return result;
 }

-void lgClipboard_fileRemoteReady(uint64_t dataset)
+void clipboard_fileRemoteReady(uint64_t dataset)
 {
  LG_LOCK(clipboard.callbackLock);
  LG_LOCK(clipboard.stateLock);
@@ -2232,7 +2232,7 @@ void lgClipboard_fileRemoteReady(uint64_t dataset)
  LG_UNLOCK(clipboard.callbackLock);
 }

-void lgClipboard_fileRemoteFailed(uint64_t dataset)
+void clipboard_fileRemoteFailed(uint64_t dataset)
 {
  if (!dataset)
    return;
--- a/client/src/clipboard_files.c
+++ b/client/src/clipboard_files.c
@@ -503,13 +503,13 @@ static void performRemoteAction(struct RemoteAction action)
  switch (action.type)
  {
    case REMOTE_ACTION_CANCEL_ACQUISITION:
-      if (!lgClipboard_fileCancel(action.dataset, action.acquisition,
+      if (!clipboard_fileCancel(action.dataset, action.acquisition,
            LG_CLIPBOARD_FILE_ERROR_CANCELLED))
        DEBUG_WARN("Failed to cancel retired clipboard file acquisition");
      break;

    case REMOTE_ACTION_RELEASE_ACQUISITION:
-      if (!lgClipboard_fileRelease(action.dataset, action.acquisition))
+      if (!clipboard_fileRelease(action.dataset, action.acquisition))
        DEBUG_WARN("Failed to release retired clipboard file acquisition");
      break;

@@ -754,7 +754,7 @@ static void failRemoteRequest(struct RemoteRequest * request, int error)
    return;
  if (request->reply == REMOTE_REPLY_INITIAL)
    DEBUG_WARN("Remote clipboard file root list failed: "
-        "dataset=%" PRIu64 ", request=%" PRIu64 ", error=%d (%s)",
+        "dataset=%lu, request=%lu, error=%d (%s)",
        request->request.dataset, request->request.request,
        error, strerror(error));
  unregisterRemoteInterrupt(request);
@@ -768,7 +768,7 @@ static void failRemoteRequest(struct RemoteRequest * request, int error)
  freeRemoteRequest(request);
  performRemoteAction(action);
  if (failedDataset)
-    lgClipboard_fileRemoteFailed(failedDataset);
+    clipboard_fileRemoteFailed(failedDataset);
 }

 static void completeRemoteRequest(struct RemoteRequest * request)
@@ -1014,9 +1014,9 @@ static void finishRemoteRequest(struct RemoteRequest * request)
      if (current)
      {
        DEBUG_INFO("Remote clipboard file root list ready; publishing: "
-            "dataset=%" PRIu64 ", request=%" PRIu64,
+            "dataset=%lu, request=%lu",
            datasetId, requestId);
-        lgClipboard_fileRemoteReady(datasetId);
+        clipboard_fileRemoteReady(datasetId);
      }
      completeRemoteRequest(request);
      return;
@@ -1067,7 +1067,7 @@ static void interruptRemoteRequest(fuse_req_t fuseRequest, void * opaque)

  const LG_ClipboardFileRequest descriptor = request->request;
  if (request->transportStarted &&
-      !lgClipboard_fileCancel(descriptor.dataset, descriptor.request,
+      !clipboard_fileCancel(descriptor.dataset, descriptor.request,
        LG_CLIPBOARD_FILE_ERROR_CANCELLED))
    DEBUG_WARN("Failed to cancel interrupted clipboard file request");
  fuse_reply_err(fuseRequest, EINTR);
@@ -1142,7 +1142,7 @@ static bool requestRemote(struct RemoteDataset * dataset,
  struct RemoteRequest * live = files.remoteRequests;
  while (live && live != request)
    live = live->next;
-  const bool sent = live && lgClipboard_fileRequest(&descriptor);
+  const bool sent = live && clipboard_fileRequest(&descriptor);
  if (sent)
    request->transportStarted = true;
  LG_UNLOCK(files.lock);
@@ -2019,7 +2019,7 @@ static struct LocalNode * addLocalNode(struct LocalDataset * dataset,
  return node;
 }

-bool lgClipboardFiles_setLocal(const char * mime,
+bool clipboardFiles_setLocal(const char * mime,
    const void * data, size_t size)
 {
  if (!mime || (!data && size) ||
@@ -2099,7 +2099,7 @@ bool lgClipboardFiles_setLocal(const char * mime,
  const uint64_t datasetId = dataset->dataset;
  LG_UNLOCK(files.lock);
  freeLocalDataset(retired);
-  lgClipboard_notifyFiles(datasetId);
+  clipboard_notifyFiles(datasetId);
  return true;

 invalid:
@@ -2107,7 +2107,7 @@ invalid:
  return false;
 }

-void lgClipboardFiles_clearLocal(void)
+void clipboardFiles_clearLocal(void)
 {
  LG_LOCK(files.lock);
  struct LocalDataset * retired = NULL;
@@ -2206,7 +2206,7 @@ error:
  return false;
 }

-bool lgClipboardFiles_getRemote(const char * mime,
+bool clipboardFiles_getRemote(const char * mime,
    char ** data, size_t * size)
 {
  if (!mime || !data || !size)
@@ -2221,7 +2221,7 @@ bool lgClipboardFiles_getRemote(const char * mime,
  return result;
 }

-uint64_t lgClipboardFiles_remotePresentationAcquire(void)
+uint64_t clipboardFiles_remotePresentationAcquire(void)
 {
  LG_LOCK(files.lock);
  struct RemoteDataset * dataset = files.remoteCurrent;
@@ -2233,7 +2233,7 @@ uint64_t lgClipboardFiles_remotePresentationAcquire(void)
  return presentation;
 }

-bool lgClipboardFiles_getRemotePresentation(uint64_t presentation,
+bool clipboardFiles_getRemotePresentation(uint64_t presentation,
    const char * mime, char ** data, size_t * size)
 {
  if (!presentation || !mime || !data || !size)
@@ -2249,7 +2249,7 @@ bool lgClipboardFiles_getRemotePresentation(uint64_t presentation,
  return result;
 }

-void lgClipboardFiles_remotePresentationDelivered(uint64_t presentation)
+void clipboardFiles_remotePresentationDelivered(uint64_t presentation)
 {
  if (!presentation)
    return;
@@ -2276,7 +2276,7 @@ void lgClipboardFiles_remotePresentationDelivered(uint64_t presentation)
    reapRemoteDeliveries(true);
 }

-void lgClipboardFiles_remotePresentationRelease(uint64_t presentation)
+void clipboardFiles_remotePresentationRelease(uint64_t presentation)
 {
  if (!presentation)
    return;
@@ -2289,7 +2289,7 @@ void lgClipboardFiles_remotePresentationRelease(uint64_t presentation)
  performRemoteAction(action);
 }

-bool lgClipboardFiles_remoteReady(uint64_t dataset)
+bool clipboardFiles_remoteReady(uint64_t dataset)
 {
  LG_LOCK(files.lock);
  struct RemoteDataset * found = remoteDatasetByIdNL(dataset);
@@ -2314,16 +2314,16 @@ static void cancelRetiredInitialRequest(struct RemoteRequest * request)
    return;
  const LG_ClipboardFileRequest descriptor = request->request;
  if (request->transportStarted &&
-      !lgClipboard_fileCancel(descriptor.dataset, descriptor.request,
+      !clipboard_fileCancel(descriptor.dataset, descriptor.request,
        LG_CLIPBOARD_FILE_ERROR_CANCELLED))
    DEBUG_WARN("Failed to cancel retired clipboard file request");
  unregisterRemoteInterrupt(request);
  completeRemoteRequest(request);
 }

-bool lgClipboardFiles_remoteOffer(uint64_t datasetId)
+bool clipboardFiles_remoteOffer(uint64_t datasetId)
 {
-  DEBUG_INFO("Remote clipboard file offer received: dataset=%" PRIu64,
+  DEBUG_INFO("dataset=%lu",
      datasetId);
  if (!datasetId)
    return false;
@@ -2405,16 +2405,16 @@ bool lgClipboardFiles_remoteOffer(uint64_t datasetId)
  cancelRetiredInitialRequest(cancelled);
  performRemoteAction(previousAction);
  reapRemoteDeliveries(true);
-  if (!lgClipboard_fileAcquire(datasetId, acquisition))
+  if (!clipboard_fileAcquire(datasetId, acquisition))
  {
-    lgClipboardFiles_remoteCancel(datasetId, acquisition,
+    clipboardFiles_remoteCancel(datasetId, acquisition,
        LG_CLIPBOARD_FILE_ERROR_DISCONNECTED);
    return false;
  }
  return true;
 }

-void lgClipboardFiles_remoteClear(void)
+void clipboardFiles_remoteClear(void)
 {
  LG_LOCK(files.lock);
  struct RemoteDataset * previous = files.remoteCurrent;
@@ -2432,7 +2432,7 @@ void lgClipboardFiles_remoteClear(void)
  performRemoteAction(action);
 }

-void lgClipboardFiles_providerUnavailable(void)
+void clipboardFiles_providerUnavailable(void)
 {
  if (!files.initialized)
    return;
@@ -2509,7 +2509,7 @@ void lgClipboardFiles_providerUnavailable(void)
  }
 }

-void lgClipboardFiles_remoteAcquired(uint64_t datasetId,
+void clipboardFiles_remoteAcquired(uint64_t datasetId,
    uint64_t acquisition, LG_ClipboardFileError error)
 {
  LG_LOCK(files.lock);
@@ -2530,16 +2530,13 @@ void lgClipboardFiles_remoteAcquired(uint64_t datasetId,
    retireRemoteDatasetNL(dataset) : (struct RemoteAction) { 0 };
  LG_UNLOCK(files.lock);
  if (valid && error)
-    DEBUG_WARN("Remote clipboard file acquisition failed: "
-        "dataset=%" PRIu64 ", acquisition=%" PRIu64 ", error=%u (%s)",
+    DEBUG_WARN("failed: dataset=%lu, acquisition=%lu, error=%u (%s)",
        datasetId, acquisition, (unsigned)error, fileErrorName(error));
  else if (valid)
-    DEBUG_INFO("Remote clipboard file acquisition succeeded: "
-        "dataset=%" PRIu64 ", acquisition=%" PRIu64,
-        datasetId, acquisition);
+    DEBUG_INFO("dataset=%lu, acquisition=%lu", datasetId, acquisition);
  performRemoteAction(action);
  if (failedDataset)
-    lgClipboard_fileRemoteFailed(failedDataset);
+    clipboard_fileRemoteFailed(failedDataset);
  if (!pinned)
    return;
  if (!requestRemote(dataset, root, LG_CLIPBOARD_FILE_LIST,
@@ -2552,7 +2549,7 @@ void lgClipboardFiles_remoteAcquired(uint64_t datasetId,
    LG_UNLOCK(files.lock);
    performRemoteAction(failed);
    if (unsentDataset)
-      lgClipboard_fileRemoteFailed(unsentDataset);
+      clipboard_fileRemoteFailed(unsentDataset);
  }
  releaseRemoteOperation(dataset);
 }
@@ -2569,7 +2566,7 @@ static bool sameRemoteFileRequest(
    request->request.operation == descriptor->operation;
 }

-LG_ClipboardResult lgClipboardFiles_remoteDataBegin(
+LG_ClipboardResult clipboardFiles_remoteDataBegin(
    const LG_ClipboardFileRequest * descriptor, uint64_t sizeHint)
 {
  if (!descriptor)
@@ -2595,7 +2592,7 @@ LG_ClipboardResult lgClipboardFiles_remoteDataBegin(
    LG_CLIPBOARD_RESULT_FAILED;
 }

-LG_ClipboardResult lgClipboardFiles_remoteDataChunk(
+LG_ClipboardResult clipboardFiles_remoteDataChunk(
    const LG_ClipboardFileRequest * descriptor, uint64_t responseOffset,
    const void * data, size_t size)
 {
@@ -2629,7 +2626,7 @@ LG_ClipboardResult lgClipboardFiles_remoteDataChunk(
    LG_CLIPBOARD_RESULT_FAILED;
 }

-LG_ClipboardResult lgClipboardFiles_remoteDataEnd(
+LG_ClipboardResult clipboardFiles_remoteDataEnd(
    const LG_ClipboardFileRequest * descriptor, uint64_t finalSize)
 {
  if (!descriptor)
@@ -2653,7 +2650,7 @@ LG_ClipboardResult lgClipboardFiles_remoteDataEnd(
  return LG_CLIPBOARD_RESULT_ACCEPTED;
 }

-void lgClipboardFiles_remoteCancel(uint64_t dataset,
+void clipboardFiles_remoteCancel(uint64_t dataset,
    uint64_t requestId, LG_ClipboardFileError reason)
 {
  LG_LOCK(files.lock);
@@ -2682,13 +2679,13 @@ void lgClipboardFiles_remoteCancel(uint64_t dataset,
  LG_UNLOCK(files.lock);
  if (acquisition)
    DEBUG_WARN("Remote clipboard file acquisition failed: "
-        "dataset=%" PRIu64 ", acquisition=%" PRIu64 ", error=%u (%s)",
+        "dataset=%lu, acquisition=%lu, error=%u (%s)",
        dataset, requestId, (unsigned)reason, fileErrorName(reason));
  if (acquisition && !request)
  {
    performRemoteAction(action);
    if (failedDataset)
-      lgClipboard_fileRemoteFailed(failedDataset);
+      clipboard_fileRemoteFailed(failedDataset);
    return;
  }
  if (!request || request->request.dataset != dataset)
@@ -2696,16 +2693,16 @@ void lgClipboardFiles_remoteCancel(uint64_t dataset,
    failRemoteRequest(request, EIO);
    performRemoteAction(action);
    if (failedDataset)
-      lgClipboard_fileRemoteFailed(failedDataset);
+      clipboard_fileRemoteFailed(failedDataset);
    return;
  }
  failRemoteRequest(request, errnoFromFileError(reason));
  performRemoteAction(action);
  if (failedDataset)
-    lgClipboard_fileRemoteFailed(failedDataset);
+    clipboard_fileRemoteFailed(failedDataset);
 }

-void lgClipboardFiles_localAcquire(uint64_t wireDataset,
+void clipboardFiles_localAcquire(uint64_t wireDataset,
    uint64_t acquisition)
 {
  LG_ClipboardFileError error = LG_CLIPBOARD_FILE_ERROR_STALE;
@@ -2729,10 +2726,10 @@ void lgClipboardFiles_localAcquire(uint64_t wireDataset,
  LG_UNLOCK(files.lock);
  if (error)
    free(item);
-  lgClipboard_fileAcquired(wireDataset, acquisition, error);
+  clipboard_fileAcquired(wireDataset, acquisition, error);
 }

-void lgClipboardFiles_localRelease(uint64_t wireDataset,
+void clipboardFiles_localRelease(uint64_t wireDataset,
    uint64_t acquisition)
 {
  LG_LOCK(files.lock);
@@ -2774,14 +2771,14 @@ static bool sendJobCall(struct LocalJob * job, int operation,
    switch (operation)
    {
      case 0:
-        result = lgClipboard_fileDataBegin(&job->request, offset);
+        result = clipboard_fileDataBegin(&job->request, offset);
        break;
      case 1:
-        result = lgClipboard_fileDataChunk(
+        result = clipboard_fileDataChunk(
            &job->request, offset, data, size, end);
        break;
      default:
-        result = lgClipboard_fileDataEnd(&job->request, offset);
+        result = clipboard_fileDataEnd(&job->request, offset);
        break;
    }
    if (result == LG_CLIPBOARD_RESULT_ACCEPTED)
@@ -3256,7 +3253,7 @@ static int localWorker(void * opaque)
        localList(job) : localRead(job);
    if (error && error != LG_CLIPBOARD_FILE_ERROR_CANCELLED &&
        !atomic_load_explicit(&job->cancelled, memory_order_acquire))
-      lgClipboard_fileCancel(job->request.dataset,
+      clipboard_fileCancel(job->request.dataset,
          job->request.request, error);
    LG_LOCK(files.lock);
    struct LocalJob ** link = &files.activeJobs;
@@ -3275,7 +3272,7 @@ static int localWorker(void * opaque)
  }
 }

-void lgClipboardFiles_localRequest(
+void clipboardFiles_localRequest(
    const LG_ClipboardFileRequest * request)
 {
  if (!request || !request->request ||
@@ -3289,14 +3286,14 @@ void lgClipboardFiles_localRequest(
        request->length > (uint64_t)INT64_MAX - request->offset)))
  {
    if (request)
-      lgClipboard_fileCancel(request->dataset, request->request,
+      clipboard_fileCancel(request->dataset, request->request,
          LG_CLIPBOARD_FILE_ERROR_INVALID);
    return;
  }
  struct LocalJob * job = calloc(1, sizeof(*job));
  if (!job)
  {
-    lgClipboard_fileCancel(request->dataset, request->request,
+    clipboard_fileCancel(request->dataset, request->request,
        LG_CLIPBOARD_FILE_ERROR_NO_MEMORY);
    return;
  }
@@ -3304,7 +3301,7 @@ void lgClipboardFiles_localRequest(
  if (!job->ready)
  {
    free(job);
-    lgClipboard_fileCancel(request->dataset, request->request,
+    clipboard_fileCancel(request->dataset, request->request,
        LG_CLIPBOARD_FILE_ERROR_NO_MEMORY);
    return;
  }
@@ -3327,11 +3324,11 @@ void lgClipboardFiles_localRequest(
  }
  lgFreeEvent(job->ready);
  free(job);
-  lgClipboard_fileCancel(request->dataset, request->request,
+  clipboard_fileCancel(request->dataset, request->request,
      LG_CLIPBOARD_FILE_ERROR_STALE);
 }

-void lgClipboardFiles_localCancel(uint64_t dataset,
+void clipboardFiles_localCancel(uint64_t dataset,
    uint64_t request, LG_ClipboardFileError reason)
 {
  (void)reason;
@@ -3363,7 +3360,7 @@ void lgClipboardFiles_localCancel(uint64_t dataset,
  freeLocalDataset(retired);
 }

-void lgClipboardFiles_localReady(uint64_t request)
+void clipboardFiles_localReady(uint64_t request)
 {
  LG_LOCK(files.lock);
  for (struct LocalJob * job = files.activeJobs; job; job = job->next)
@@ -3397,9 +3394,9 @@ static void freeState(void)
  {
    struct RemoteDataset * next = remote->next;
    if (remote->acquired)
-      lgClipboard_fileRelease(remote->dataset, remote->acquisition);
+      clipboard_fileRelease(remote->dataset, remote->acquisition);
    else if (remote->acquiring)
-      lgClipboard_fileCancel(remote->dataset, remote->acquisition,
+      clipboard_fileCancel(remote->dataset, remote->acquisition,
          LG_CLIPBOARD_FILE_ERROR_CANCELLED);
    free(remote);
    remote = next;
@@ -3420,7 +3417,7 @@ static void freeState(void)
  }
 }

-bool lgClipboardFiles_init(void)
+bool clipboardFiles_init(void)
 {
  if (filesLockInitialized)
    return false;
@@ -3512,12 +3509,12 @@ bool lgClipboardFiles_init(void)
  return true;

 failed:
-  lgClipboardFiles_free();
+  clipboardFiles_free();
  return false;
 }

 #ifdef ENABLE_TESTS
-bool lgClipboardFiles_testFuseStopWake(void)
+bool clipboardFiles_testFuseStopWake(void)
 {
  const int stopFd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
  if (stopFd < 0)
@@ -3528,12 +3525,12 @@ bool lgClipboardFiles_testFuseStopWake(void)
  return result;
 }

-bool lgClipboardFiles_testUnsentRemoteOwnership(void)
+bool clipboardFiles_testUnsentRemoteOwnership(void)
 {
  return finishUnsentRemoteRequest(0);
 }

-bool lgClipboardFiles_testInit(uint64_t nonce)
+bool clipboardFiles_testInit(uint64_t nonce)
 {
  if (filesLockInitialized)
    return false;
@@ -3556,7 +3553,7 @@ bool lgClipboardFiles_testInit(uint64_t nonce)
  return true;
 }

-size_t lgClipboardFiles_testRemoteDatasetCount(void)
+size_t clipboardFiles_testRemoteDatasetCount(void)
 {
  if (!filesLockInitialized)
    return 0;
@@ -3569,7 +3566,7 @@ size_t lgClipboardFiles_testRemoteDatasetCount(void)
  return count;
 }

-void lgClipboardFiles_testExpireRemoteDeliveries(void)
+void clipboardFiles_testExpireRemoteDeliveries(void)
 {
  if (!filesLockInitialized)
    return;
@@ -3582,7 +3579,7 @@ void lgClipboardFiles_testExpireRemoteDeliveries(void)
  reapRemoteDeliveries(false);
 }

-bool lgClipboardFiles_testBeginRemoteLookup(uint64_t presentation)
+bool clipboardFiles_testBeginRemoteLookup(uint64_t presentation)
 {
  LG_LOCK(files.lock);
  struct RemoteDataset * dataset =
@@ -3593,7 +3590,7 @@ bool lgClipboardFiles_testBeginRemoteLookup(uint64_t presentation)
  return result;
 }

-void lgClipboardFiles_testEndRemoteLookup(uint64_t presentation)
+void clipboardFiles_testEndRemoteLookup(uint64_t presentation)
 {
  LG_LOCK(files.lock);
  struct RemoteDataset * dataset =
@@ -3605,7 +3602,7 @@ void lgClipboardFiles_testEndRemoteLookup(uint64_t presentation)
  performRemoteAction(action);
 }

-bool lgClipboardFiles_testRemoteRead(uint64_t presentation,
+bool clipboardFiles_testRemoteRead(uint64_t presentation,
    uint64_t nodeId, uint64_t offset, uint32_t length)
 {
  LG_LOCK(files.lock);
@@ -3625,12 +3622,12 @@ bool lgClipboardFiles_testRemoteRead(uint64_t presentation,
  return result;
 }

-void lgClipboardFiles_testForceLocalEof(void)
+void clipboardFiles_testForceLocalEof(void)
 {
  atomic_store_explicit(&forceLocalEof, true, memory_order_release);
 }

-bool lgClipboardFiles_testLocalRequest(
+bool clipboardFiles_testLocalRequest(
    const LG_ClipboardFileRequest * request)
 {
  if (!request ||
@@ -3652,7 +3649,7 @@ bool lgClipboardFiles_testLocalRequest(
    request->operation == LG_CLIPBOARD_FILE_LIST ?
    localList(&job) : localRead(&job);
  if (error && error != LG_CLIPBOARD_FILE_ERROR_CANCELLED)
-    lgClipboard_fileCancel(request->dataset, request->request, error);
+    clipboard_fileCancel(request->dataset, request->request, error);
  LG_LOCK(files.lock);
  if (job.dataset->references)
    --job.dataset->references;
@@ -3661,7 +3658,7 @@ bool lgClipboardFiles_testLocalRequest(
 }
 #endif

-void lgClipboardFiles_free(void)
+void clipboardFiles_free(void)
 {
  if (!filesLockInitialized)
    return;
--- a/client/src/main.c
+++ b/client/src/main.c
@@ -723,7 +723,7 @@ static void preSwapCallback(void * udata)
  if (!written)
    DEBUG_ERROR("Failed to write test capture to: %s", l_testCapture.path);
  else
-    DEBUG_INFO("Wrote test capture for frame %" PRIu64 " to: %s",
+    DEBUG_INFO("Wrote test capture for frame %lu to: %s",
        serial, l_testCapture.path);
  app_setState(APP_STATE_SHUTDOWN);
 #endif
@@ -1142,13 +1142,13 @@ static int renderThread(void * unused)
  {
    lgInput_setTransport(NULL, NULL);
    lgAudio_setTransport(NULL, NULL);
-    lgClipboard_setTransport(NULL, NULL);
+    clipboard_setTransport(NULL, NULL);
  }
  else
  {
    lgInput_dropTransport();
    lgAudio_dropTransport();
-    lgClipboard_dropTransport();
+    clipboard_dropTransport();
  }

  core_stopVideoThreads();
@@ -1206,7 +1206,7 @@ int main_cursorThread(void * unused)
      {
        lgInput_dropTransport();
        lgAudio_dropTransport();
-        lgClipboard_dropTransport();
+        clipboard_dropTransport();
        primaryLost();
      }
      else
@@ -1410,7 +1410,7 @@ int main_frameThread(void * unused)
      {
        lgInput_dropTransport();
        lgAudio_dropTransport();
-        lgClipboard_dropTransport();
+        clipboard_dropTransport();
        primaryLost();
      }
      else if (status == LG_TRANSPORT_END)
@@ -3322,7 +3322,7 @@ static int lg_run(void)
  frameTimingInit();
  lgInput_init();
  lgAudio_init();
-  if (!lgClipboard_init())
+  if (!clipboard_init())
    return -1;

 #ifdef ENABLE_TESTS
@@ -3654,7 +3654,7 @@ static int lg_run(void)
  g_state.ds->startup();
  const bool clipboardAvailable =
    g_state.ds->cbInit && g_state.ds->cbInit();
-  lgClipboard_setLocalAvailable(clipboardAvailable);
+  clipboard_setLocalAvailable(clipboardAvailable);

  if (g_params.captureOnStart)
    core_setGrab(true);
@@ -3876,7 +3876,7 @@ restart:
    g_state.transport.ops->getClipboardOps ?
      g_state.transport.ops->getClipboardOps(
          g_state.transport.handle, &clipboardOpaque) : NULL;
-  lgClipboard_setTransport(clipboardOps, clipboardOpaque);
+  clipboard_setTransport(clipboardOps, clipboardOpaque);

  DEBUG_INFO("Starting session");
  atomic_store_explicit(
@@ -3912,7 +3912,7 @@ restart:
    {
      lgInput_dropTransport();
      lgAudio_dropTransport();
-      lgClipboard_dropTransport();
+      clipboard_dropTransport();
      primaryLost();
      break;
    }
@@ -3942,7 +3942,7 @@ restart:
    videoSourceClearCursor(LG_VIDEO_SOURCE_PRIMARY);
    lgInput_dropTransport();
    lgAudio_dropTransport();
-    lgClipboard_dropTransport();
+    clipboard_dropTransport();
    g_state.transport.ops->disconnect(g_state.transport.handle);

    if (app_transitionState(APP_STATE_RESTART, APP_STATE_RUNNING))
@@ -3999,19 +3999,19 @@ static void lg_shutdown(void)
        g_state.transport.ops->sessionValid(g_state.transport.handle))
    {
      lgAudio_setTransport(NULL, NULL);
-      lgClipboard_setTransport(NULL, NULL);
+      clipboard_setTransport(NULL, NULL);
    }
    else
    {
      lgAudio_dropTransport();
-      lgClipboard_dropTransport();
+      clipboard_dropTransport();
    }
    lgTransport_destroy(&g_state.transport);
  }

  lgInput_free();
  lgAudio_free();
-  lgClipboard_setLocalAvailable(false);
+  clipboard_setLocalAvailable(false);

  if (e_startup)
  {
@@ -4030,7 +4030,7 @@ static void lg_shutdown(void)

  /* Clipboard sources own FUSE dataset references and are released by the
   * display server before the filesystem is unmounted. */
-  lgClipboard_free();
+  clipboard_free();

  // Input callbacks have stopped; the evdev state and overlays can go
  evdev_free();
--- a/client/src/transport_fallback.c
+++ b/client/src/transport_fallback.c
@@ -229,13 +229,13 @@ static void unpublishProviders(LG_TransportFallback * fallback, bool live)
  {
    lgInput_setFallback(NULL, NULL);
    lgAudio_setFallback(NULL, NULL);
-    lgClipboard_setFallback(NULL, NULL);
+    clipboard_setFallback(NULL, NULL);
  }
  else
  {
    lgInput_dropFallback();
    lgAudio_dropFallback();
-    lgClipboard_dropFallback();
+    clipboard_dropFallback();
  }
  fallback->providersPublished = false;
  LG_UNLOCK(fallback->providerLock);
@@ -322,7 +322,7 @@ static bool publishProviders(LG_TransportFallback * fallback)
    fallback->transport.ops->getClipboardOps ?
      fallback->transport.ops->getClipboardOps(
          fallback->transport.handle, &clipboardOpaque) : NULL;
-  lgClipboard_setFallback(clipboardOps, clipboardOpaque);
+  clipboard_setFallback(clipboardOps, clipboardOpaque);
  fallback->providersPublished = true;
  LG_UNLOCK_SHARED(fallback->lock);
  LG_UNLOCK(fallback->providerLock);
--- a/client/src/usb_audio.c
+++ b/client/src/usb_audio.c
@@ -1817,8 +1817,8 @@ static void reportPlaybackDebug(LG_USBAudio * audio)
      !audio->playbackInvalidPackets)
    return;

-  DEBUG_INFO("USB playback: concealed %" PRIu64
-      " packets, invalid %" PRIu64,
+  DEBUG_INFO("USB playback: concealed %lu"
+      " packets, invalid %lu",
      audio->playbackConcealedPackets,
      audio->playbackInvalidPackets);
  audio->playbackConcealedPackets = 0;
--- a/client/tests/clipboard_files_stub.c
+++ b/client/tests/clipboard_files_stub.c
@@ -20,97 +20,97 @@

 #include "core/clipboard_files.h"

-unsigned lgClipboardFilesStubRemoteOfferCount;
-unsigned lgClipboardFilesStubRemoteClearCount;
-uint64_t lgClipboardFilesStubRemoteDataset;
-bool lgClipboardFilesStubRemoteReady;
-bool lgClipboardFilesStubRemoteOfferResult = true;
+unsigned clipboardFilesStubRemoteOfferCount;
+unsigned clipboardFilesStubRemoteClearCount;
+uint64_t clipboardFilesStubRemoteDataset;
+bool clipboardFilesStubRemoteReady;
+bool clipboardFilesStubRemoteOfferResult = true;

-bool lgClipboardFiles_init(void) { return true; }
-void lgClipboardFiles_free(void) {}
-bool lgClipboardFiles_setLocal(const char * mime,
+bool clipboardFiles_init(void) { return true; }
+void clipboardFiles_free(void) {}
+bool clipboardFiles_setLocal(const char * mime,
    const void * data, size_t size)
 {
  (void)mime; (void)data; (void)size; return false;
 }
-void lgClipboardFiles_clearLocal(void) {}
-bool lgClipboardFiles_getRemote(const char * mime, char ** data, size_t * size)
+void clipboardFiles_clearLocal(void) {}
+bool clipboardFiles_getRemote(const char * mime, char ** data, size_t * size)
 {
  (void)mime; (void)data; (void)size; return false;
 }
-uint64_t lgClipboardFiles_remotePresentationAcquire(void) { return 0; }
-bool lgClipboardFiles_getRemotePresentation(uint64_t presentation,
+uint64_t clipboardFiles_remotePresentationAcquire(void) { return 0; }
+bool clipboardFiles_getRemotePresentation(uint64_t presentation,
    const char * mime, char ** data, size_t * size)
 {
  (void)presentation; (void)mime; (void)data; (void)size; return false;
 }
-void lgClipboardFiles_remotePresentationDelivered(uint64_t presentation)
+void clipboardFiles_remotePresentationDelivered(uint64_t presentation)
 {
  (void)presentation;
 }
-void lgClipboardFiles_remotePresentationRelease(uint64_t presentation)
+void clipboardFiles_remotePresentationRelease(uint64_t presentation)
 {
  (void)presentation;
 }
-bool lgClipboardFiles_remoteReady(uint64_t dataset)
+bool clipboardFiles_remoteReady(uint64_t dataset)
 {
-  return lgClipboardFilesStubRemoteReady &&
-    dataset == lgClipboardFilesStubRemoteDataset;
+  return clipboardFilesStubRemoteReady &&
+    dataset == clipboardFilesStubRemoteDataset;
 }
-bool lgClipboardFiles_remoteOffer(uint64_t dataset)
+bool clipboardFiles_remoteOffer(uint64_t dataset)
 {
-  ++lgClipboardFilesStubRemoteOfferCount;
-  lgClipboardFilesStubRemoteDataset = dataset;
-  return lgClipboardFilesStubRemoteOfferResult;
+  ++clipboardFilesStubRemoteOfferCount;
+  clipboardFilesStubRemoteDataset = dataset;
+  return clipboardFilesStubRemoteOfferResult;
 }
-void lgClipboardFiles_remoteClear(void)
+void clipboardFiles_remoteClear(void)
 {
-  ++lgClipboardFilesStubRemoteClearCount;
-  lgClipboardFilesStubRemoteDataset = 0;
+  ++clipboardFilesStubRemoteClearCount;
+  clipboardFilesStubRemoteDataset = 0;
 }
-void lgClipboardFiles_providerUnavailable(void) {}
-void lgClipboardFiles_remoteAcquired(uint64_t dataset,
+void clipboardFiles_providerUnavailable(void) {}
+void clipboardFiles_remoteAcquired(uint64_t dataset,
    uint64_t acquisition, LG_ClipboardFileError error)
 {
  (void)dataset; (void)acquisition; (void)error;
 }
-LG_ClipboardResult lgClipboardFiles_remoteDataBegin(
+LG_ClipboardResult clipboardFiles_remoteDataBegin(
    const LG_ClipboardFileRequest * request, uint64_t sizeHint)
 {
  (void)request; (void)sizeHint; return LG_CLIPBOARD_RESULT_FAILED;
 }
-LG_ClipboardResult lgClipboardFiles_remoteDataChunk(
+LG_ClipboardResult clipboardFiles_remoteDataChunk(
    const LG_ClipboardFileRequest * request, uint64_t offset,
    const void * data, size_t size)
 {
  (void)request; (void)offset; (void)data; (void)size;
  return LG_CLIPBOARD_RESULT_FAILED;
 }
-LG_ClipboardResult lgClipboardFiles_remoteDataEnd(
+LG_ClipboardResult clipboardFiles_remoteDataEnd(
    const LG_ClipboardFileRequest * request, uint64_t size)
 {
  (void)request; (void)size; return LG_CLIPBOARD_RESULT_FAILED;
 }
-void lgClipboardFiles_remoteCancel(uint64_t dataset,
+void clipboardFiles_remoteCancel(uint64_t dataset,
    uint64_t request, LG_ClipboardFileError reason)
 {
  (void)dataset; (void)request; (void)reason;
 }
-void lgClipboardFiles_localAcquire(uint64_t dataset, uint64_t acquisition)
+void clipboardFiles_localAcquire(uint64_t dataset, uint64_t acquisition)
 {
  (void)dataset; (void)acquisition;
 }
-void lgClipboardFiles_localRelease(uint64_t dataset, uint64_t acquisition)
+void clipboardFiles_localRelease(uint64_t dataset, uint64_t acquisition)
 {
  (void)dataset; (void)acquisition;
 }
-void lgClipboardFiles_localRequest(const LG_ClipboardFileRequest * request)
+void clipboardFiles_localRequest(const LG_ClipboardFileRequest * request)
 {
  (void)request;
 }
-void lgClipboardFiles_localCancel(uint64_t dataset,
+void clipboardFiles_localCancel(uint64_t dataset,
    uint64_t request, LG_ClipboardFileError reason)
 {
  (void)dataset; (void)request; (void)reason;
 }
-void lgClipboardFiles_localReady(uint64_t request) { (void)request; }
+void clipboardFiles_localReady(uint64_t request) { (void)request; }
--- a/client/tests/clipboard_files_test.c
+++ b/client/tests/clipboard_files_test.c
@@ -59,13 +59,13 @@ static uint64_t cancelledDataset;
 static uint64_t cancelledRequest;
 static LG_ClipboardFileError cancelledReason;

-void lgClipboard_notifyFiles(uint64_t dataset)
+void clipboard_notifyFiles(uint64_t dataset)
 {
  CHECK(notices < sizeof(datasets) / sizeof(datasets[0]));
  datasets[notices++] = dataset;
 }

-bool lgClipboard_fileAcquire(uint64_t dataset, uint64_t acquisition)
+bool clipboard_fileAcquire(uint64_t dataset, uint64_t acquisition)
 {
  ++acquireCount;
  acquiredDataset = dataset;
@@ -73,7 +73,7 @@ bool lgClipboard_fileAcquire(uint64_t dataset, uint64_t acquisition)
  return true;
 }

-bool lgClipboard_fileAcquired(uint64_t dataset, uint64_t acquisition,
+bool clipboard_fileAcquired(uint64_t dataset, uint64_t acquisition,
    LG_ClipboardFileError error)
 {
  (void)dataset;
@@ -82,7 +82,7 @@ bool lgClipboard_fileAcquired(uint64_t dataset, uint64_t acquisition,
  return false;
 }

-bool lgClipboard_fileRelease(uint64_t dataset, uint64_t acquisition)
+bool clipboard_fileRelease(uint64_t dataset, uint64_t acquisition)
 {
  ++releaseCount;
  releasedDataset = dataset;
@@ -90,7 +90,7 @@ bool lgClipboard_fileRelease(uint64_t dataset, uint64_t acquisition)
  return true;
 }

-bool lgClipboard_fileRequest(const LG_ClipboardFileRequest * request)
+bool clipboard_fileRequest(const LG_ClipboardFileRequest * request)
 {
  CHECK(request);
  ++requestCount;
@@ -98,7 +98,7 @@ bool lgClipboard_fileRequest(const LG_ClipboardFileRequest * request)
  return remoteRequestSucceeds;
 }

-LG_ClipboardResult lgClipboard_fileDataBegin(
+LG_ClipboardResult clipboard_fileDataBegin(
    const LG_ClipboardFileRequest * request, uint64_t sizeHint)
 {
  CHECK(request);
@@ -110,7 +110,7 @@ LG_ClipboardResult lgClipboard_fileDataBegin(
  return LG_CLIPBOARD_RESULT_ACCEPTED;
 }

-LG_ClipboardResult lgClipboard_fileDataChunk(
+LG_ClipboardResult clipboard_fileDataChunk(
    const LG_ClipboardFileRequest * request, uint64_t responseOffset,
    const void * data, size_t size, bool end)
 {
@@ -135,7 +135,7 @@ LG_ClipboardResult lgClipboard_fileDataChunk(
  return LG_CLIPBOARD_RESULT_ACCEPTED;
 }

-LG_ClipboardResult lgClipboard_fileDataEnd(
+LG_ClipboardResult clipboard_fileDataEnd(
    const LG_ClipboardFileRequest * request, uint64_t finalSize)
 {
  CHECK(request);
@@ -147,7 +147,7 @@ LG_ClipboardResult lgClipboard_fileDataEnd(
  return LG_CLIPBOARD_RESULT_ACCEPTED;
 }

-bool lgClipboard_fileCancel(uint64_t dataset, uint64_t request,
+bool clipboard_fileCancel(uint64_t dataset, uint64_t request,
    LG_ClipboardFileError reason)
 {
  ++cancelCount;
@@ -157,13 +157,13 @@ bool lgClipboard_fileCancel(uint64_t dataset, uint64_t request,
  return true;
 }

-void lgClipboard_fileRemoteReady(uint64_t dataset)
+void clipboard_fileRemoteReady(uint64_t dataset)
 {
  CHECK(dataset == acquiredDataset);
  ++remoteReadyCount;
 }

-void lgClipboard_fileRemoteFailed(uint64_t dataset)
+void clipboard_fileRemoteFailed(uint64_t dataset)
 {
  CHECK(dataset);
  ++remoteFailedCount;
@@ -191,7 +191,7 @@ static bool runLocalRequest(uint64_t dataset, uint64_t node,
    .length    = length,
    .operation = operation,
  };
-  const bool result = lgClipboardFiles_testLocalRequest(&request);
+  const bool result = clipboardFiles_testLocalRequest(&request);
  CHECK(!result || responseComplete);
  CHECK(!result || !responseSize || responseWireEnded);
  CHECK(result ? cancelCount == 0U : cancelCount == 1U);
@@ -251,40 +251,40 @@ static void testLocalLifecycle(void)
  CHECK(write(fd, "clipboard", 9) == 9);
  CHECK(close(fd) == 0);

-  CHECK(lgClipboardFiles_testInit(UINT64_C(0x1234000012340000)));
+  CHECK(clipboardFiles_testInit(UINT64_C(0x1234000012340000)));
  char uri[320];
  const int uriLength = snprintf(uri, sizeof(uri), "file://%s\r\n", path);
  CHECK(uriLength > 0 && (size_t)uriLength < sizeof(uri));
-  CHECK(lgClipboardFiles_setLocal(
+  CHECK(clipboardFiles_setLocal(
        "text/uri-list", uri, (size_t)uriLength));
  CHECK(notices == 1);
  CHECK(datasets[0] != 0);
  CHECK(kvmfrClipboardTransferFromClient(datasets[0]));

-  lgClipboardFiles_clearLocal();
+  clipboardFiles_clearLocal();
  char gnome[336];
  const int gnomeLength = snprintf(
      gnome, sizeof(gnome), "copy\nfile://%s\n", path);
  CHECK(gnomeLength > 0 && (size_t)gnomeLength < sizeof(gnome));
-  CHECK(lgClipboardFiles_setLocal("x-special/gnome-copied-files",
+  CHECK(clipboardFiles_setLocal("x-special/gnome-copied-files",
        gnome, (size_t)gnomeLength));
  CHECK(notices == 2);
  CHECK(datasets[1] != datasets[0]);

  static const char invalid[] = "file:///does/not/exist\n";
-  CHECK(!lgClipboardFiles_setLocal(
+  CHECK(!clipboardFiles_setLocal(
        "text/uri-list", invalid, sizeof(invalid) - 1U));
-  lgClipboardFiles_clearLocal();
-  lgClipboardFiles_free();
-  lgClipboardFiles_free();
+  clipboardFiles_clearLocal();
+  clipboardFiles_free();
+  clipboardFiles_free();

-  CHECK(lgClipboardFiles_testInit(UINT64_C(0x5678000056780000)));
-  CHECK(lgClipboardFiles_setLocal(
+  CHECK(clipboardFiles_testInit(UINT64_C(0x5678000056780000)));
+  CHECK(clipboardFiles_setLocal(
        "text/uri-list", uri, (size_t)uriLength));
  CHECK(notices == 3);
  CHECK(datasets[2] != datasets[0]);
  CHECK(datasets[2] != datasets[1]);
-  lgClipboardFiles_free();
+  clipboardFiles_free();

  CHECK(unlink(path) == 0);
  CHECK(rmdir(directory) == 0);
@@ -309,81 +309,81 @@ static void testLocalUriValidation(void)
  CHECK(symlink("item.txt", link) == 0);
  CHECK(symlink(".", alias) == 0);

-  CHECK(lgClipboardFiles_testInit(UINT64_C(0x684b2452684b2452)));
+  CHECK(clipboardFiles_testInit(UINT64_C(0x684b2452684b2452)));
  const unsigned before = notices;
  char uri[512];
  int length = snprintf(uri, sizeof(uri),
      "FILE://LOCALHOST%s/item%%20space.txt\r\n", directory);
  CHECK(length > 0 && (size_t)length < sizeof(uri));
-  CHECK(lgClipboardFiles_setLocal(
+  CHECK(clipboardFiles_setLocal(
        "text/uri-list", uri, (size_t)length));
-  lgClipboardFiles_clearLocal();
+  clipboardFiles_clearLocal();

  length = snprintf(uri, sizeof(uri), "file://%s%%\n", plain);
  CHECK(length > 0 && (size_t)length < sizeof(uri));
-  CHECK(!lgClipboardFiles_setLocal(
+  CHECK(!clipboardFiles_setLocal(
        "text/uri-list", uri, (size_t)length));
  length = snprintf(uri, sizeof(uri), "file://%s%%0\n", plain);
  CHECK(length > 0 && (size_t)length < sizeof(uri));
-  CHECK(!lgClipboardFiles_setLocal(
+  CHECK(!clipboardFiles_setLocal(
        "text/uri-list", uri, (size_t)length));
  length = snprintf(uri, sizeof(uri), "file://%s%%GG\n", plain);
  CHECK(length > 0 && (size_t)length < sizeof(uri));
-  CHECK(!lgClipboardFiles_setLocal(
+  CHECK(!clipboardFiles_setLocal(
        "text/uri-list", uri, (size_t)length));
  length = snprintf(uri, sizeof(uri), "file://%s%%00suffix\n", plain);
  CHECK(length > 0 && (size_t)length < sizeof(uri));
-  CHECK(!lgClipboardFiles_setLocal(
+  CHECK(!clipboardFiles_setLocal(
        "text/uri-list", uri, (size_t)length));
  length = snprintf(uri, sizeof(uri), "file://%s?query\n", plain);
  CHECK(length > 0 && (size_t)length < sizeof(uri));
-  CHECK(!lgClipboardFiles_setLocal(
+  CHECK(!clipboardFiles_setLocal(
        "text/uri-list", uri, (size_t)length));
  length = snprintf(uri, sizeof(uri), "file://%s#fragment\n", plain);
  CHECK(length > 0 && (size_t)length < sizeof(uri));
-  CHECK(!lgClipboardFiles_setLocal(
+  CHECK(!clipboardFiles_setLocal(
        "text/uri-list", uri, (size_t)length));
  length = snprintf(uri, sizeof(uri), "file://example.invalid%s\n", plain);
  CHECK(length > 0 && (size_t)length < sizeof(uri));
-  CHECK(!lgClipboardFiles_setLocal(
+  CHECK(!clipboardFiles_setLocal(
        "text/uri-list", uri, (size_t)length));
  static const char root[] = "file:///\n";
-  CHECK(!lgClipboardFiles_setLocal(
+  CHECK(!clipboardFiles_setLocal(
        "text/uri-list", root, sizeof(root) - 1U));
  length = snprintf(uri, sizeof(uri), "file://%s/\n", directory);
  CHECK(length > 0 && (size_t)length < sizeof(uri));
-  CHECK(lgClipboardFiles_setLocal(
+  CHECK(clipboardFiles_setLocal(
        "text/uri-list", uri, (size_t)length));
-  lgClipboardFiles_clearLocal();
+  clipboardFiles_clearLocal();
  length = snprintf(uri, sizeof(uri), "file://%s/./item.txt\n", directory);
  CHECK(length > 0 && (size_t)length < sizeof(uri));
-  CHECK(!lgClipboardFiles_setLocal(
+  CHECK(!clipboardFiles_setLocal(
        "text/uri-list", uri, (size_t)length));
  length = snprintf(uri, sizeof(uri), "file://%s//item.txt\n", directory);
  CHECK(length > 0 && (size_t)length < sizeof(uri));
-  CHECK(!lgClipboardFiles_setLocal(
+  CHECK(!clipboardFiles_setLocal(
        "text/uri-list", uri, (size_t)length));
  length = snprintf(uri, sizeof(uri), "file://%s\n", link);
  CHECK(length > 0 && (size_t)length < sizeof(uri));
-  CHECK(!lgClipboardFiles_setLocal(
+  CHECK(!clipboardFiles_setLocal(
        "text/uri-list", uri, (size_t)length));
  length = snprintf(uri, sizeof(uri),
      "file://%s/alias/item.txt\n", directory);
  CHECK(length > 0 && (size_t)length < sizeof(uri));
-  CHECK(!lgClipboardFiles_setLocal(
+  CHECK(!clipboardFiles_setLocal(
        "text/uri-list", uri, (size_t)length));
  length = snprintf(uri, sizeof(uri), "file://%s\n", spaced);
  CHECK(length > 0 && (size_t)length < sizeof(uri));
-  CHECK(!lgClipboardFiles_setLocal(
+  CHECK(!clipboardFiles_setLocal(
        "text/uri-list", uri, (size_t)length));
  length = snprintf(uri, sizeof(uri),
      "cutx\nfile://%s\n", plain);
  CHECK(length > 0 && (size_t)length < sizeof(uri));
-  CHECK(!lgClipboardFiles_setLocal(
+  CHECK(!clipboardFiles_setLocal(
        "x-special/gnome-copied-files", uri, (size_t)length));
  CHECK(notices == before + 2U);

-  lgClipboardFiles_free();
+  clipboardFiles_free();
  CHECK(unlink(alias) == 0);
  CHECK(unlink(link) == 0);
  CHECK(unlink(spaced) == 0);
@@ -404,12 +404,12 @@ static void testLocalSnapshot(void)
  createFile(stable, "stable");
  createFile(changed, "before");

-  CHECK(lgClipboardFiles_testInit(UINT64_C(0x1a72021b1a72021b)));
+  CHECK(clipboardFiles_testInit(UINT64_C(0x1a72021b1a72021b)));
  char uri[320];
  const int uriLength = snprintf(
      uri, sizeof(uri), "file://%s\r\n", directory);
  CHECK(uriLength > 0 && (size_t)uriLength < sizeof(uri));
-  CHECK(lgClipboardFiles_setLocal(
+  CHECK(clipboardFiles_setLocal(
        "text/uri-list", uri, (size_t)uriLength));
  const uint64_t dataset = datasets[notices - 1U];

@@ -441,7 +441,7 @@ static void testLocalSnapshot(void)
        LG_CLIPBOARD_FILE_READ, 0, (uint32_t)stableEntry.size));
  CHECK(responseSize == strlen("stable"));
  CHECK(!memcmp(responseData, "stable", responseSize));
-  lgClipboardFiles_testForceLocalEof();
+  clipboardFiles_testForceLocalEof();
  CHECK(!runLocalRequest(dataset, stableEntry.node,
        LG_CLIPBOARD_FILE_READ, 0, (uint32_t)stableEntry.size));
  CHECK(cancelledReason == LG_CLIPBOARD_FILE_ERROR_IO);
@@ -476,7 +476,7 @@ static void testLocalSnapshot(void)
        LG_CLIPBOARD_FILE_READ, 0, (uint32_t)stableEntry.size));
  CHECK(cancelledReason == LG_CLIPBOARD_FILE_ERROR_STALE);

-  lgClipboardFiles_free();
+  clipboardFiles_free();
  CHECK(unlink(replacement) == 0);
  CHECK(rmdir(directory) == 0);
  CHECK(unlink(movedStable) == 0);
@@ -500,12 +500,12 @@ static void testLocalUnsupportedEntry(void)
  CHECK(symlink("target.txt", link) == 0);
  CHECK(mkfifo(fifo, 0600) == 0);

-  CHECK(lgClipboardFiles_testInit(UINT64_C(0x62d1147362d11473)));
+  CHECK(clipboardFiles_testInit(UINT64_C(0x62d1147362d11473)));
  char uri[320];
  const int uriLength = snprintf(
      uri, sizeof(uri), "file://%s\r\n", directory);
  CHECK(uriLength > 0 && (size_t)uriLength < sizeof(uri));
-  CHECK(lgClipboardFiles_setLocal(
+  CHECK(clipboardFiles_setLocal(
        "text/uri-list", uri, (size_t)uriLength));
  const uint64_t dataset = datasets[notices - 1U];
  CHECK(runLocalRequest(dataset, KVMFR_CLIPBOARD_FILE_ROOT_NODE,
@@ -518,7 +518,7 @@ static void testLocalUnsupportedEntry(void)
        LG_CLIPBOARD_FILE_LIST, 0, 0));
  CHECK(cancelledReason == LG_CLIPBOARD_FILE_ERROR_NOT_SUPPORTED);

-  lgClipboardFiles_free();
+  clipboardFiles_free();
  CHECK(unlink(fifo) == 0);
  CHECK(unlink(link) == 0);
  CHECK(unlink(target) == 0);
@@ -530,12 +530,12 @@ static uint64_t completeRemoteOffer(uint64_t dataset, const char * name)
  const unsigned previousAcquires = acquireCount;
  const unsigned previousRequests = requestCount;
  const unsigned previousReady = remoteReadyCount;
-  CHECK(lgClipboardFiles_remoteOffer(dataset));
+  CHECK(clipboardFiles_remoteOffer(dataset));
  CHECK(acquireCount == previousAcquires + 1U);
  CHECK(acquiredDataset == dataset);
  const uint64_t acquisition = acquiredRequest;

-  lgClipboardFiles_remoteAcquired(dataset, acquisition,
+  clipboardFiles_remoteAcquired(dataset, acquisition,
      LG_CLIPBOARD_FILE_ERROR_NONE);
  CHECK(requestCount == previousRequests + 1U);
  CHECK(remoteRequest.dataset == dataset);
@@ -558,22 +558,22 @@ static uint64_t completeRemoteOffer(uint64_t dataset, const char * name)
  };
  memcpy(wire, &entry, sizeof(entry));
  memcpy(wire + sizeof(entry), name, nameLength);
-  CHECK(lgClipboardFiles_remoteDataBegin(
+  CHECK(clipboardFiles_remoteDataBegin(
        &remoteRequest, wireSize) == LG_CLIPBOARD_RESULT_ACCEPTED);
-  CHECK(lgClipboardFiles_remoteDataChunk(&remoteRequest, 0,
+  CHECK(clipboardFiles_remoteDataChunk(&remoteRequest, 0,
        wire, (size_t)wireSize) == LG_CLIPBOARD_RESULT_ACCEPTED);
-  CHECK(lgClipboardFiles_remoteDataEnd(
+  CHECK(clipboardFiles_remoteDataEnd(
        &remoteRequest, wireSize) == LG_CLIPBOARD_RESULT_ACCEPTED);
  free(wire);
  CHECK(remoteReadyCount == previousReady + 1U);
-  CHECK(lgClipboardFiles_remoteReady(dataset));
+  CHECK(clipboardFiles_remoteReady(dataset));
  return acquisition;
 }

 static uint64_t beginRemoteOffer(uint64_t dataset)
 {
  const unsigned previousAcquires = acquireCount;
-  CHECK(lgClipboardFiles_remoteOffer(dataset));
+  CHECK(clipboardFiles_remoteOffer(dataset));
  CHECK(acquireCount == previousAcquires + 1U);
  CHECK(acquiredDataset == dataset);
  return acquiredRequest;
@@ -584,7 +584,7 @@ static LG_ClipboardFileRequest beginRemoteList(uint64_t dataset,
 {
  const unsigned previousRequests = requestCount;
  *acquisition = beginRemoteOffer(dataset);
-  lgClipboardFiles_remoteAcquired(dataset, *acquisition,
+  clipboardFiles_remoteAcquired(dataset, *acquisition,
      LG_CLIPBOARD_FILE_ERROR_NONE);
  CHECK(requestCount == previousRequests + 1U);
  CHECK(remoteRequest.dataset == dataset);
@@ -601,12 +601,12 @@ static void checkRemoteFailure(uint64_t dataset,
  CHECK(releaseCount == previousReleases + (acquired ? 1U : 0U));
  if (acquired)
    CHECK(releasedDataset == dataset);
-  CHECK(lgClipboardFiles_testRemoteDatasetCount() == 0U);
+  CHECK(clipboardFiles_testRemoteDatasetCount() == 0U);
 }

 static void testRemoteFailures(void)
 {
-  CHECK(lgClipboardFiles_testInit(UINT64_C(0x7315000073150000)));
+  CHECK(clipboardFiles_testInit(UINT64_C(0x7315000073150000)));
  acquireCount = 0;
  releaseCount = 0;
  requestCount = 0;
@@ -619,7 +619,7 @@ static void testRemoteFailures(void)
  uint64_t acquisition = beginRemoteOffer(dataset);
  unsigned previousFailures = remoteFailedCount;
  unsigned previousReleases = releaseCount;
-  lgClipboardFiles_remoteAcquired(dataset, acquisition,
+  clipboardFiles_remoteAcquired(dataset, acquisition,
      LG_CLIPBOARD_FILE_ERROR_ACCESS);
  checkRemoteFailure(dataset, previousFailures, previousReleases, false);

@@ -627,7 +627,7 @@ static void testRemoteFailures(void)
  acquisition = beginRemoteOffer(dataset);
  previousFailures = remoteFailedCount;
  previousReleases = releaseCount;
-  lgClipboardFiles_remoteCancel(dataset, acquisition,
+  clipboardFiles_remoteCancel(dataset, acquisition,
      LG_CLIPBOARD_FILE_ERROR_CANCELLED);
  checkRemoteFailure(dataset, previousFailures, previousReleases, false);

@@ -635,7 +635,7 @@ static void testRemoteFailures(void)
  LG_ClipboardFileRequest request = beginRemoteList(dataset, &acquisition);
  previousFailures = remoteFailedCount;
  previousReleases = releaseCount;
-  lgClipboardFiles_remoteCancel(dataset, request.request,
+  clipboardFiles_remoteCancel(dataset, request.request,
      LG_CLIPBOARD_FILE_ERROR_CANCELLED);
  checkRemoteFailure(dataset, previousFailures, previousReleases, true);

@@ -644,7 +644,7 @@ static void testRemoteFailures(void)
  previousFailures = remoteFailedCount;
  previousReleases = releaseCount;
  remoteRequestSucceeds = false;
-  lgClipboardFiles_remoteAcquired(dataset, acquisition,
+  clipboardFiles_remoteAcquired(dataset, acquisition,
      LG_CLIPBOARD_FILE_ERROR_NONE);
  remoteRequestSucceeds = true;
  checkRemoteFailure(dataset, previousFailures, previousReleases, true);
@@ -655,27 +655,27 @@ static void testRemoteFailures(void)
  malformed.node += 1U;
  previousFailures = remoteFailedCount;
  previousReleases = releaseCount;
-  CHECK(lgClipboardFiles_remoteDataBegin(&malformed, 0) ==
+  CHECK(clipboardFiles_remoteDataBegin(&malformed, 0) ==
      LG_CLIPBOARD_RESULT_FAILED);
  checkRemoteFailure(dataset, previousFailures, previousReleases, true);

  dataset += 1U;
  request = beginRemoteList(dataset, &acquisition);
-  CHECK(lgClipboardFiles_remoteDataBegin(&request, 1) ==
+  CHECK(clipboardFiles_remoteDataBegin(&request, 1) ==
      LG_CLIPBOARD_RESULT_ACCEPTED);
  previousFailures = remoteFailedCount;
  previousReleases = releaseCount;
-  CHECK(lgClipboardFiles_remoteDataChunk(&request, 0, NULL, 1) ==
+  CHECK(clipboardFiles_remoteDataChunk(&request, 0, NULL, 1) ==
      LG_CLIPBOARD_RESULT_FAILED);
  checkRemoteFailure(dataset, previousFailures, previousReleases, true);

  dataset += 1U;
  request = beginRemoteList(dataset, &acquisition);
-  CHECK(lgClipboardFiles_remoteDataBegin(&request, 1) ==
+  CHECK(clipboardFiles_remoteDataBegin(&request, 1) ==
      LG_CLIPBOARD_RESULT_ACCEPTED);
  previousFailures = remoteFailedCount;
  previousReleases = releaseCount;
-  CHECK(lgClipboardFiles_remoteDataEnd(&request, 0) ==
+  CHECK(clipboardFiles_remoteDataEnd(&request, 0) ==
      LG_CLIPBOARD_RESULT_FAILED);
  checkRemoteFailure(dataset, previousFailures, previousReleases, true);

@@ -695,25 +695,25 @@ static void testRemoteFailures(void)
  };
  memcpy(wire, &entry, sizeof(entry));
  memcpy(wire + sizeof(entry), invalidName, sizeof(invalidName) - 1U);
-  CHECK(lgClipboardFiles_remoteDataBegin(&request, wireSize) ==
+  CHECK(clipboardFiles_remoteDataBegin(&request, wireSize) ==
      LG_CLIPBOARD_RESULT_ACCEPTED);
-  CHECK(lgClipboardFiles_remoteDataChunk(&request, 0, wire, wireSize) ==
+  CHECK(clipboardFiles_remoteDataChunk(&request, 0, wire, wireSize) ==
      LG_CLIPBOARD_RESULT_ACCEPTED);
  previousFailures = remoteFailedCount;
  previousReleases = releaseCount;
-  CHECK(lgClipboardFiles_remoteDataEnd(&request, wireSize) ==
+  CHECK(clipboardFiles_remoteDataEnd(&request, wireSize) ==
      LG_CLIPBOARD_RESULT_ACCEPTED);
  free(wire);
  checkRemoteFailure(dataset, previousFailures, previousReleases, true);

-  lgClipboardFiles_free();
+  clipboardFiles_free();
 }

 static void checkRemoteUri(uint64_t presentation, const char * name)
 {
  char * uri = NULL;
  size_t size = 0;
-  CHECK(lgClipboardFiles_getRemotePresentation(
+  CHECK(clipboardFiles_getRemotePresentation(
        presentation, "text/uri-list", &uri, &size));
  CHECK(uri);
  CHECK(size == strlen(uri));
@@ -733,7 +733,7 @@ static void * releasePresentation(void * opaque)
  ReleasePresentationTask * task = opaque;
  const int result = pthread_barrier_wait(task->barrier);
  CHECK(result == 0 || result == PTHREAD_BARRIER_SERIAL_THREAD);
-  lgClipboardFiles_remotePresentationRelease(task->presentation);
+  clipboardFiles_remotePresentationRelease(task->presentation);
  return NULL;
 }

@@ -759,9 +759,9 @@ static void releasePresentationConcurrently(uint64_t presentation)

 static void testRemoteLifecycle(void)
 {
-  CHECK(lgClipboardFiles_testFuseStopWake());
-  CHECK(lgClipboardFiles_testInit(UINT64_C(0x7311000073110000)));
-  CHECK(lgClipboardFiles_testUnsentRemoteOwnership());
+  CHECK(clipboardFiles_testFuseStopWake());
+  CHECK(clipboardFiles_testInit(UINT64_C(0x7311000073110000)));
+  CHECK(clipboardFiles_testUnsentRemoteOwnership());
  acquireCount = 0;
  releaseCount = 0;
  requestCount = 0;
@@ -772,59 +772,59 @@ static void testRemoteLifecycle(void)
    UINT64_C(0x73110001);
  const uint64_t first = completeRemoteOffer(firstDataset, "first.txt");

-  CHECK(lgClipboardFiles_testRemoteRead(first, 2, 0, 9));
+  CHECK(clipboardFiles_testRemoteRead(first, 2, 0, 9));
  LG_ClipboardFileRequest shortRead = remoteRequest;
-  CHECK(lgClipboardFiles_remoteDataBegin(&shortRead, 8) ==
+  CHECK(clipboardFiles_remoteDataBegin(&shortRead, 8) ==
      LG_CLIPBOARD_RESULT_FAILED);

-  CHECK(lgClipboardFiles_testRemoteRead(first, 2, 0, 9));
+  CHECK(clipboardFiles_testRemoteRead(first, 2, 0, 9));
  shortRead = remoteRequest;
-  CHECK(lgClipboardFiles_remoteDataBegin(&shortRead, 9) ==
+  CHECK(clipboardFiles_remoteDataBegin(&shortRead, 9) ==
      LG_CLIPBOARD_RESULT_ACCEPTED);
  const uint8_t shortData[8] = { 0 };
-  CHECK(lgClipboardFiles_remoteDataChunk(&shortRead, 0,
+  CHECK(clipboardFiles_remoteDataChunk(&shortRead, 0,
        shortData, sizeof(shortData)) == LG_CLIPBOARD_RESULT_ACCEPTED);
-  CHECK(lgClipboardFiles_remoteDataEnd(&shortRead, sizeof(shortData)) ==
+  CHECK(clipboardFiles_remoteDataEnd(&shortRead, sizeof(shortData)) ==
      LG_CLIPBOARD_RESULT_FAILED);

  const uint64_t firstPresentation =
-    lgClipboardFiles_remotePresentationAcquire();
+    clipboardFiles_remotePresentationAcquire();
  CHECK(firstPresentation == first);
  checkRemoteUri(firstPresentation, "first.txt");

  const uint64_t secondDataset = KVMFR_CLIPBOARD_TRANSFER_HELPER |
    UINT64_C(0x73110002);
  completeRemoteOffer(secondDataset, "second.txt");
-  CHECK(lgClipboardFiles_testRemoteDatasetCount() == 2U);
+  CHECK(clipboardFiles_testRemoteDatasetCount() == 2U);
  CHECK(releaseCount == 0U);
  checkRemoteUri(firstPresentation, "first.txt");
-  lgClipboardFiles_remotePresentationRelease(firstPresentation);
-  CHECK(lgClipboardFiles_testRemoteDatasetCount() == 1U);
+  clipboardFiles_remotePresentationRelease(firstPresentation);
+  CHECK(clipboardFiles_testRemoteDatasetCount() == 1U);
  CHECK(releaseCount == 1U);
  CHECK(releasedDataset == firstDataset);
  CHECK(releasedAcquisition == first);

  const uint64_t secondPresentation =
-    lgClipboardFiles_remotePresentationAcquire();
+    clipboardFiles_remotePresentationAcquire();
  CHECK(secondPresentation != 0);
  checkRemoteUri(secondPresentation, "second.txt");
-  lgClipboardFiles_remotePresentationDelivered(secondPresentation);
-  lgClipboardFiles_remotePresentationRelease(secondPresentation);
+  clipboardFiles_remotePresentationDelivered(secondPresentation);
+  clipboardFiles_remotePresentationRelease(secondPresentation);
  const uint64_t thirdDataset = KVMFR_CLIPBOARD_TRANSFER_HELPER |
    UINT64_C(0x73110003);
  completeRemoteOffer(thirdDataset, "third.txt");
-  CHECK(lgClipboardFiles_testRemoteDatasetCount() == 2U);
+  CHECK(clipboardFiles_testRemoteDatasetCount() == 2U);
  CHECK(releaseCount == 1U);
-  CHECK(lgClipboardFiles_testBeginRemoteLookup(secondPresentation));
-  lgClipboardFiles_testExpireRemoteDeliveries();
-  CHECK(lgClipboardFiles_testRemoteDatasetCount() == 2U);
+  CHECK(clipboardFiles_testBeginRemoteLookup(secondPresentation));
+  clipboardFiles_testExpireRemoteDeliveries();
+  CHECK(clipboardFiles_testRemoteDatasetCount() == 2U);
  CHECK(releaseCount == 1U);
-  lgClipboardFiles_testEndRemoteLookup(secondPresentation);
-  CHECK(lgClipboardFiles_testRemoteDatasetCount() == 1U);
+  clipboardFiles_testEndRemoteLookup(secondPresentation);
+  CHECK(clipboardFiles_testRemoteDatasetCount() == 1U);
  CHECK(releaseCount == 2U);
  CHECK(releasedDataset == secondDataset);
-  lgClipboardFiles_remoteClear();
-  CHECK(lgClipboardFiles_testRemoteDatasetCount() == 0U);
+  clipboardFiles_remoteClear();
+  CHECK(clipboardFiles_testRemoteDatasetCount() == 0U);
  CHECK(releaseCount == 3U);

  for (uint64_t i = 0; i < 10; ++i)
@@ -834,16 +834,16 @@ static void testRemoteLifecycle(void)
    const uint64_t acquisition =
      completeRemoteOffer(dataset, "grace.txt");
    const uint64_t presentation =
-      lgClipboardFiles_remotePresentationAcquire();
+      clipboardFiles_remotePresentationAcquire();
    CHECK(presentation == acquisition);
    checkRemoteUri(presentation, "grace.txt");
-    lgClipboardFiles_remotePresentationDelivered(presentation);
-    lgClipboardFiles_remotePresentationRelease(presentation);
-    CHECK(lgClipboardFiles_testRemoteDatasetCount() <= 5U);
+    clipboardFiles_remotePresentationDelivered(presentation);
+    clipboardFiles_remotePresentationRelease(presentation);
+    CHECK(clipboardFiles_testRemoteDatasetCount() <= 5U);
  }
-  lgClipboardFiles_remoteClear();
-  lgClipboardFiles_testExpireRemoteDeliveries();
-  CHECK(lgClipboardFiles_testRemoteDatasetCount() == 0U);
+  clipboardFiles_remoteClear();
+  clipboardFiles_testExpireRemoteDeliveries();
+  CHECK(clipboardFiles_testRemoteDatasetCount() == 0U);

  for (uint64_t i = 0; i < 16; ++i)
  {
@@ -852,7 +852,7 @@ static void testRemoteLifecycle(void)
    const uint64_t oldAcquisition =
      completeRemoteOffer(oldDataset, "old.txt");
    const uint64_t presentation =
-      lgClipboardFiles_remotePresentationAcquire();
+      clipboardFiles_remotePresentationAcquire();
    CHECK(presentation == oldAcquisition);
    const uint64_t currentDataset = oldDataset + 1U;
    completeRemoteOffer(currentDataset, "current.txt");
@@ -860,27 +860,27 @@ static void testRemoteLifecycle(void)
    releasePresentationConcurrently(presentation);
    CHECK(releaseCount == previousReleases + 1U);
    CHECK(releasedDataset == oldDataset);
-    CHECK(lgClipboardFiles_testRemoteDatasetCount() == 1U);
-    lgClipboardFiles_remoteClear();
-    CHECK(lgClipboardFiles_testRemoteDatasetCount() == 0U);
+    CHECK(clipboardFiles_testRemoteDatasetCount() == 1U);
+    clipboardFiles_remoteClear();
+    CHECK(clipboardFiles_testRemoteDatasetCount() == 0U);
  }

  const uint64_t pendingDataset = KVMFR_CLIPBOARD_TRANSFER_HELPER |
    UINT64_C(0x73140001);
-  CHECK(lgClipboardFiles_remoteOffer(pendingDataset));
+  CHECK(clipboardFiles_remoteOffer(pendingDataset));
  CHECK(acquiredDataset == pendingDataset);
  const uint64_t pendingAcquisition = acquiredRequest;
  const uint64_t replacementDataset = pendingDataset + 1U;
  const unsigned previousCancels = cancelCount;
-  CHECK(lgClipboardFiles_remoteOffer(replacementDataset));
+  CHECK(clipboardFiles_remoteOffer(replacementDataset));
  CHECK(cancelCount == previousCancels + 1U);
  CHECK(cancelledDataset == pendingDataset);
  CHECK(cancelledRequest == pendingAcquisition);
  CHECK(cancelledReason == LG_CLIPBOARD_FILE_ERROR_CANCELLED);
-  CHECK(lgClipboardFiles_testRemoteDatasetCount() == 1U);
-  lgClipboardFiles_remoteClear();
-  CHECK(lgClipboardFiles_testRemoteDatasetCount() == 0U);
-  lgClipboardFiles_free();
+  CHECK(clipboardFiles_testRemoteDatasetCount() == 1U);
+  clipboardFiles_remoteClear();
+  CHECK(clipboardFiles_testRemoteDatasetCount() == 0U);
+  clipboardFiles_free();
 }

 static int testMount(void)
@@ -889,8 +889,8 @@ static int testMount(void)
    return 77;
  if (!getenv("XDG_RUNTIME_DIR"))
    CHECK(setenv("XDG_RUNTIME_DIR", "/tmp", 1) == 0);
-  CHECK(lgClipboardFiles_init());
-  lgClipboardFiles_free();
+  CHECK(clipboardFiles_init());
+  clipboardFiles_free();
  return 0;
 }

--- a/client/tests/clipboard_test.c
+++ b/client/tests/clipboard_test.c
@@ -144,11 +144,11 @@ static struct Provider q;
 static struct Provider r;
 static struct Display  d;

-extern unsigned lgClipboardFilesStubRemoteOfferCount;
-extern unsigned lgClipboardFilesStubRemoteClearCount;
-extern uint64_t lgClipboardFilesStubRemoteDataset;
-extern bool lgClipboardFilesStubRemoteReady;
-extern bool lgClipboardFilesStubRemoteOfferResult;
+extern unsigned clipboardFilesStubRemoteOfferCount;
+extern unsigned clipboardFilesStubRemoteClearCount;
+extern uint64_t clipboardFilesStubRemoteDataset;
+extern bool clipboardFilesStubRemoteReady;
+extern bool clipboardFilesStubRemoteOfferResult;

 struct AppState  g_state;
 struct AppParams g_params;
@@ -457,14 +457,14 @@ static void dsRequest(LG_ClipboardRequest id, LG_ClipboardData type)
  d.reqId[no]            = id;
  d.reqType[no]          = type;
  if (d.autoData)
-    lgClipboard_data(id, d.autoType, d.autoBuf, d.autoSize);
+    clipboard_data(id, d.autoType, d.autoBuf, d.autoSize);
 }

 static void dsRequestReady(LG_ClipboardRequest id)
 {
  ++d.ready;
  if (d.autoBegin)
-    d.readyResult = lgClipboard_dataBegin(
+    d.readyResult = clipboard_dataBegin(
        id, LG_CLIPBOARD_DATA_TEXT, LG_CLIPBOARD_SIZE_UNKNOWN);
 }

@@ -512,21 +512,21 @@ static void init(void)
  atomic_init(&d.blockCancel, false);
  atomic_init(&d.cancelEntered, false);
  atomic_init(&d.releaseCancel, false);
-  lgClipboardFilesStubRemoteOfferCount = 0;
-  lgClipboardFilesStubRemoteClearCount = 0;
-  lgClipboardFilesStubRemoteDataset = 0;
-  lgClipboardFilesStubRemoteReady = false;
-  lgClipboardFilesStubRemoteOfferResult = true;
+  clipboardFilesStubRemoteOfferCount = 0;
+  clipboardFilesStubRemoteClearCount = 0;
+  clipboardFilesStubRemoteDataset = 0;
+  clipboardFilesStubRemoteReady = false;
+  clipboardFilesStubRemoteOfferResult = true;
  g_state.ds                  = &dsOps;
  g_params.clipboardToVM      = true;
  g_params.clipboardToLocal   = true;
-  CHECK(lgClipboard_init());
-  lgClipboard_setLocalAvailable(true);
+  CHECK(clipboard_init());
+  clipboard_setLocalAvailable(true);
 }

 static void bind(struct Provider * provider)
 {
-  lgClipboard_setFallback(&plainOps, provider);
+  clipboard_setFallback(&plainOps, provider);
  CHECK(provider->attach == 1);
 }

@@ -574,7 +574,7 @@ static void onReply(void * opaque, LG_ClipboardData type,
    CHECK(!buf);

  if (type != LG_CLIPBOARD_DATA_NONE && reply->next)
-    reply->nested = lgClipboard_request(
+    reply->nested = clipboard_request(
        LG_CLIPBOARD_DATA_TEXT, onReply, reply->next);
 }

@@ -589,13 +589,13 @@ static void testPreference(void)
 {
  init();
  const LG_ClipboardData types[] = { LG_CLIPBOARD_DATA_TEXT };
-  lgClipboard_notifyTypes(types, 1);
+  clipboard_notifyTypes(types, 1);

-  lgClipboard_setFallback(&statOps, &p);
+  clipboard_setFallback(&statOps, &p);
  CHECK(p.attach == 1);
  CHECK(p.notice == 1);

-  lgClipboard_setTransport(&statOps, &q);
+  clipboard_setTransport(&statOps, &q);
  CHECK(p.release == 1);
  CHECK(p.detach == 1);
  CHECK(q.attach == 1);
@@ -611,7 +611,7 @@ static void testPreference(void)
  const LG_ClipboardStatusFn staleFn = q.statFn;
  void * staleCtx = q.statCtx;
  CHECK(staleFn);
-  lgClipboard_dropTransport();
+  clipboard_dropTransport();
  CHECK(q.release == 0);
  CHECK(q.detach == 0);
  CHECK(p.attach == 2);
@@ -624,68 +624,68 @@ static void testPreference(void)
  staleFn(staleCtx, &stale);
  CHECK(p.attach == 2);

-  lgClipboard_setTransport(&statOps, &r);
+  clipboard_setTransport(&statOps, &r);
  CHECK(p.release == 2);
  CHECK(p.detach == 2);
  CHECK(r.attach == 1);
-  lgClipboard_setTransport(NULL, NULL);
+  clipboard_setTransport(NULL, NULL);
  CHECK(r.statClear == 1);
  CHECK(r.release == 1);
  CHECK(r.detach == 1);
  CHECK(p.attach == 3);

-  lgClipboard_free();
+  clipboard_free();
 }

 static void testFilePublication(void)
 {
  init();
-  lgClipboard_setFallback(&fileOps, &p);
+  clipboard_setFallback(&fileOps, &p);

  const uint64_t dataset = UINT64_C(0x123456789abcdef);
-  lgClipboard_notifyFiles(dataset);
+  clipboard_notifyFiles(dataset);
  CHECK(p.fileOffer == 1);
  CHECK(p.fileDataset[0] == dataset);

  const LG_ClipboardData files[] = { LG_CLIPBOARD_DATA_FILES };
-  lgClipboard_notifyTypes(files, 1);
+  clipboard_notifyTypes(files, 1);
  CHECK(p.notice == 0);
  CHECK(p.fileOffer == 1);

-  lgClipboard_setTransport(&plainOps, &r);
+  clipboard_setTransport(&plainOps, &r);
  CHECK(r.attach == 1);
  CHECK(r.release == 1);
  const uint64_t replacement = dataset + 1U;
-  lgClipboard_notifyFiles(replacement);
+  clipboard_notifyFiles(replacement);
  CHECK(r.release == 2);
-  lgClipboard_dropTransport();
+  clipboard_dropTransport();
  CHECK(p.attach == 2);
  CHECK(p.fileOffer == 2);
  CHECK(p.fileDataset[1] == replacement);

-  lgClipboard_setTransport(&fileOps, &q);
+  clipboard_setTransport(&fileOps, &q);
  CHECK(q.attach == 1);
  CHECK(q.fileOffer == 1);
  CHECK(q.fileDataset[0] == replacement);

-  lgClipboard_dropTransport();
+  clipboard_dropTransport();
  CHECK(p.attach == 3);
  CHECK(p.fileOffer == 3);
  CHECK(p.fileDataset[2] == replacement);

-  lgClipboard_free();
+  clipboard_free();
 }

 static void testFileReplacement(void)
 {
  init();
  bind(&p);
-  lgClipboardFilesStubRemoteReady = true;
+  clipboardFilesStubRemoteReady = true;

  const uint64_t first = UINT64_C(0x2000000000000001);
  p.ev->fileOffer(p.evCtx, first);
-  CHECK(lgClipboardFilesStubRemoteOfferCount == 1);
-  CHECK(lgClipboardFilesStubRemoteDataset == first);
+  CHECK(clipboardFilesStubRemoteOfferCount == 1);
+  CHECK(clipboardFilesStubRemoteDataset == first);
  const LG_ClipboardData files[] = { LG_CLIPBOARD_DATA_FILES };
  p.ev->notice(p.evCtx, files, 1);
  CHECK(d.notice == 1);
@@ -693,8 +693,8 @@ static void testFileReplacement(void)

  const LG_ClipboardData text[] = { LG_CLIPBOARD_DATA_TEXT };
  p.ev->notice(p.evCtx, text, 1);
-  CHECK(lgClipboardFilesStubRemoteClearCount == 1);
-  CHECK(lgClipboardFilesStubRemoteDataset == 0);
+  CHECK(clipboardFilesStubRemoteClearCount == 1);
+  CHECK(clipboardFilesStubRemoteDataset == 0);
  CHECK(d.notice == 2);
  CHECK(d.noticeType[1] == LG_CLIPBOARD_DATA_TEXT);

@@ -706,17 +706,17 @@ static void testFileReplacement(void)
    LG_CLIPBOARD_DATA_FILES,
  };
  p.ev->notice(p.evCtx, mixed, 2);
-  CHECK(lgClipboardFilesStubRemoteClearCount == 1);
-  CHECK(lgClipboardFilesStubRemoteDataset == mixedDataset);
+  CHECK(clipboardFilesStubRemoteClearCount == 1);
+  CHECK(clipboardFilesStubRemoteDataset == mixedDataset);
  CHECK(d.notice == 3);
  CHECK(d.noticeType[2] == LG_CLIPBOARD_DATA_FILES);

  p.ev->notice(p.evCtx, text, 1);
-  CHECK(lgClipboardFilesStubRemoteClearCount == 2);
-  CHECK(lgClipboardFilesStubRemoteDataset == 0);
+  CHECK(clipboardFilesStubRemoteClearCount == 2);
+  CHECK(clipboardFilesStubRemoteDataset == 0);
  CHECK(d.notice == 4);
  CHECK(d.noticeType[3] == LG_CLIPBOARD_DATA_TEXT);
-  lgClipboard_free();
+  clipboard_free();
 }

 static void testFileFailure(void)
@@ -742,37 +742,37 @@ static void testFileFailure(void)
  CHECK(d.notice == 1);
  CHECK(d.release == 0);

-  lgClipboard_fileRemoteFailed(first);
+  clipboard_fileRemoteFailed(first);
  CHECK(d.release == 0);
-  CHECK(lgClipboardFilesStubRemoteDataset == second);
+  CHECK(clipboardFilesStubRemoteDataset == second);

-  lgClipboard_fileRemoteFailed(second);
+  clipboard_fileRemoteFailed(second);
  CHECK(d.release == 1);
-  lgClipboard_fileRemoteFailed(second);
+  clipboard_fileRemoteFailed(second);
  CHECK(d.release == 1);

  p.ev->notice(p.evCtx, text, 1);
  CHECK(d.notice == 2);
-  lgClipboardFilesStubRemoteOfferResult = false;
-  const unsigned previousClears = lgClipboardFilesStubRemoteClearCount;
+  clipboardFilesStubRemoteOfferResult = false;
+  const unsigned previousClears = clipboardFilesStubRemoteClearCount;
  p.ev->fileOffer(p.evCtx, second + 1U);
-  CHECK(lgClipboardFilesStubRemoteClearCount == previousClears + 1U);
+  CHECK(clipboardFilesStubRemoteClearCount == previousClears + 1U);
  p.ev->notice(p.evCtx, files, 1);
  CHECK(d.notice == 2);
  CHECK(d.release == 2);

  p.ev->notice(p.evCtx, text, 1);
  CHECK(d.notice == 3);
-  lgClipboardFilesStubRemoteOfferResult = true;
+  clipboardFilesStubRemoteOfferResult = true;
  const uint64_t pending = second + 2U;
  p.ev->fileOffer(p.evCtx, pending);
-  lgClipboard_fileRemoteFailed(pending);
+  clipboard_fileRemoteFailed(pending);
  CHECK(d.release == 2);
  p.ev->notice(p.evCtx, files, 1);
  CHECK(d.notice == 3);
  CHECK(d.release == 3);

-  lgClipboard_free();
+  clipboard_free();
 }

 struct CallbackSerializationTask
@@ -784,7 +784,7 @@ struct CallbackSerializationTask
 static void * switchClipboardProvider(void * opaque)
 {
  struct CallbackSerializationTask * task = opaque;
-  lgClipboard_setTransport(&plainOps, &q);
+  clipboard_setTransport(&plainOps, &q);
  atomic_store_explicit(&task->switched, true, memory_order_release);
  return NULL;
 }
@@ -792,7 +792,7 @@ static void * switchClipboardProvider(void * opaque)
 static void * clearClipboardAvailability(void * opaque)
 {
  struct CallbackSerializationTask * task = opaque;
-  lgClipboard_setLocalAvailable(false);
+  clipboard_setLocalAvailable(false);
  atomic_store_explicit(
      &task->availabilityChanged, true, memory_order_release);
  return NULL;
@@ -814,7 +814,7 @@ static void testCallbackSerialization(void)
  init();
  bind(&p);
  const LG_ClipboardData text[] = { LG_CLIPBOARD_DATA_TEXT };
-  lgClipboard_notifyTypes(text, 1);
+  clipboard_notifyTypes(text, 1);
  CHECK(p.ev->request(p.evCtx, 1, LG_CLIPBOARD_DATA_TEXT));
  CHECK(d.request == 1);

@@ -842,7 +842,7 @@ static void testCallbackSerialization(void)
        &task.availabilityChanged, memory_order_acquire));
  CHECK(d.cancel == 1);
  CHECK(d.cancelReason == LG_CLIPBOARD_CANCEL_UNAVAILABLE);
-  lgClipboard_free();
+  clipboard_free();
 }

 static void testRequest(void)
@@ -857,8 +857,8 @@ static void testRequest(void)

  struct Reply a = { 0 };
  struct Reply b = { 0 };
-  CHECK(lgClipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &a));
-  CHECK(lgClipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &b));
+  CHECK(clipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &a));
+  CHECK(clipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &b));
  CHECK(p.request == 2);
  CHECK(p.reqId[0] != LG_CLIPBOARD_REQUEST_INVALID);
  CHECK(p.reqId[0] != p.reqId[1]);
@@ -880,7 +880,7 @@ static void testRequest(void)
  CHECK(b.size == sizeof(two));
  CHECK(memcmp(b.data, two, sizeof(two)) == 0);

-  lgClipboard_free();
+  clipboard_free();
 }

 static void testRemoteKeepsLocalRequest(void)
@@ -889,7 +889,7 @@ static void testRemoteKeepsLocalRequest(void)
  bind(&p);
  const LG_ClipboardData types[] = { LG_CLIPBOARD_DATA_TEXT };

-  lgClipboard_notifyTypes(types, 1);
+  clipboard_notifyTypes(types, 1);
  CHECK(p.notice == 1);

  g_params.clipboardToLocal = false;
@@ -898,7 +898,7 @@ static void testRemoteKeepsLocalRequest(void)

  /* A notice which is not published locally must not discard the local
   * clipboard advertised towards the guest. */
-  lgClipboard_setTransport(&plainOps, &q);
+  clipboard_setTransport(&plainOps, &q);
  CHECK(q.attach == 1);
  CHECK(q.notice == 1);
  CHECK(q.release == 0);
@@ -914,7 +914,7 @@ static void testRemoteKeepsLocalRequest(void)
  CHECK(d.request == 1);
  CHECK(d.reqType[0] == LG_CLIPBOARD_DATA_TEXT);

-  lgClipboard_free();
+  clipboard_free();
 }

 static void testPendingRemoteKeepsLocalRequest(void)
@@ -923,14 +923,14 @@ static void testPendingRemoteKeepsLocalRequest(void)
  bind(&p);
  const LG_ClipboardData types[] = { LG_CLIPBOARD_DATA_TEXT };

-  lgClipboard_notifyTypes(types, 1);
+  clipboard_notifyTypes(types, 1);
  CHECK(p.notice == 1);
-  lgClipboard_setLocalAvailable(false);
+  clipboard_setLocalAvailable(false);

  notice(&p, types, 1);
  CHECK(d.notice == 0);

-  lgClipboard_setLocalAvailable(true);
+  clipboard_setLocalAvailable(true);
  CHECK(d.notice == 1);

  /* Publishing a notice which arrived while the local clipboard was
@@ -939,7 +939,7 @@ static void testPendingRemoteKeepsLocalRequest(void)
  CHECK(d.request == 1);
  CHECK(d.reqType[0] == LG_CLIPBOARD_DATA_TEXT);

-  lgClipboard_free();
+  clipboard_free();
 }

 static void testInvalid(void)
@@ -954,12 +954,12 @@ static void testInvalid(void)

  const LG_ClipboardData types[] = { LG_CLIPBOARD_DATA_TEXT };
  notice(&p, types, 1);
-  CHECK(!lgClipboard_request(
+  CHECK(!clipboard_request(
      LG_CLIPBOARD_DATA_NONE, onReply, &(struct Reply) { 0 }));
-  CHECK(!lgClipboard_request(LG_CLIPBOARD_DATA_TEXT, NULL, NULL));
+  CHECK(!clipboard_request(LG_CLIPBOARD_DATA_TEXT, NULL, NULL));

  struct Reply empty = { 0 };
-  CHECK(lgClipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &empty));
+  CHECK(clipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &empty));
  remoteData(&p, LG_CLIPBOARD_REQUEST_INVALID,
      LG_CLIPBOARD_DATA_TEXT, NULL, 0);
  CHECK(empty.count == 0);
@@ -970,13 +970,13 @@ static void testInvalid(void)
  CHECK(empty.size == 0);

  struct Reply wrong = { 0 };
-  CHECK(lgClipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &wrong));
+  CHECK(clipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &wrong));
  remoteData(&p, p.reqId[p.request - 1],
      LG_CLIPBOARD_DATA_PNG, NULL, 0);
  checkNone(&wrong);

  struct Reply null = { 0 };
-  CHECK(lgClipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &null));
+  CHECK(clipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &null));
  remoteData(&p, p.reqId[p.request - 1],
      LG_CLIPBOARD_DATA_TEXT, NULL, 1);
  checkNone(&null);
@@ -984,7 +984,7 @@ static void testInvalid(void)
 #if SIZE_MAX > UINT32_MAX
  struct Reply large = { 0 };
  const uint8_t byte = 1;
-  CHECK(lgClipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &large));
+  CHECK(clipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &large));
  remoteData(&p, p.reqId[p.request - 1], LG_CLIPBOARD_DATA_TEXT,
      &byte, (size_t)UINT32_MAX + 1);
  checkNone(&large);
@@ -992,11 +992,11 @@ static void testInvalid(void)

  p.reqOK = false;
  struct Reply failed = { 0 };
-  CHECK(!lgClipboard_request(
+  CHECK(!clipboard_request(
      LG_CLIPBOARD_DATA_TEXT, onReply, &failed));
  CHECK(failed.count == 0);

-  lgClipboard_free();
+  clipboard_free();
 }

 static void testCancel(void)
@@ -1008,7 +1008,7 @@ static void testCancel(void)

  notice(&p, text, 1);
  struct Reply newer = { 0 };
-  CHECK(lgClipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &newer));
+  CHECK(clipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &newer));
  const LG_ClipboardRequest newerId = p.reqId[p.request - 1];
  notice(&p, png, 1);
  checkNone(&newer);
@@ -1016,7 +1016,7 @@ static void testCancel(void)
  CHECK(newer.count == 1);

  struct Reply released = { 0 };
-  CHECK(lgClipboard_request(LG_CLIPBOARD_DATA_PNG, onReply, &released));
+  CHECK(clipboard_request(LG_CLIPBOARD_DATA_PNG, onReply, &released));
  const LG_ClipboardRequest releaseId = p.reqId[p.request - 1];
  p.ev->release(p.evCtx);
  checkNone(&released);
@@ -1025,39 +1025,39 @@ static void testCancel(void)

  notice(&p, text, 1);
  struct Reply unavailable = { 0 };
-  CHECK(lgClipboard_request(
+  CHECK(clipboard_request(
      LG_CLIPBOARD_DATA_TEXT, onReply, &unavailable));
  const LG_ClipboardRequest unavailableId = p.reqId[p.request - 1];
-  lgClipboard_setLocalAvailable(false);
+  clipboard_setLocalAvailable(false);
  checkNone(&unavailable);
  remoteData(&p, unavailableId, LG_CLIPBOARD_DATA_TEXT, "x", 1);
  CHECK(unavailable.count == 1);

-  lgClipboard_setLocalAvailable(true);
+  clipboard_setLocalAvailable(true);
  notice(&p, text, 1);
  struct Reply switched = { 0 };
-  CHECK(lgClipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &switched));
+  CHECK(clipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &switched));
  const LG_ClipboardRequest switchedId = p.reqId[p.request - 1];
-  lgClipboard_setTransport(&plainOps, &q);
+  clipboard_setTransport(&plainOps, &q);
  checkNone(&switched);
  CHECK(p.oldEv);
  p.oldEv->data(p.oldCtx, switchedId, LG_CLIPBOARD_DATA_TEXT, "x", 1);
  CHECK(switched.count == 1);
  CHECK(d.release == 3);

-  lgClipboard_free();
+  clipboard_free();
 }

 static void testGeneration(void)
 {
  init();
  const LG_ClipboardData types[] = { LG_CLIPBOARD_DATA_TEXT };
-  lgClipboard_notifyTypes(types, 1);
-  lgClipboard_setFallback(&statOps, &p);
+  clipboard_notifyTypes(types, 1);
+  clipboard_setFallback(&statOps, &p);
  notice(&p, types, 1);

  struct Reply old = { 0 };
-  CHECK(lgClipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &old));
+  CHECK(clipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &old));
  const LG_ClipboardRequest oldId = p.reqId[p.request - 1];
  setStatus(&p, true, 2);
  checkNone(&old);
@@ -1069,7 +1069,7 @@ static void testGeneration(void)
  CHECK(old.count == 1);
  notice(&p, types, 1);
  struct Reply next = { 0 };
-  CHECK(lgClipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &next));
+  CHECK(clipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &next));
  remoteData(&p, p.reqId[p.request - 1],
      LG_CLIPBOARD_DATA_TEXT, "new", 3);
  CHECK(next.count == 1);
@@ -1077,7 +1077,7 @@ static void testGeneration(void)
  CHECK(next.size == 3);
  CHECK(memcmp(next.data, "new", 3) == 0);

-  lgClipboard_free();
+  clipboard_free();
 }

 static void testLocal(void)
@@ -1088,11 +1088,11 @@ static void testLocal(void)
  const LG_ClipboardData many[LG_CLIPBOARD_DATA_NONE + 1] = { 0 };
  const LG_ClipboardData types[] =
    { LG_CLIPBOARD_DATA_TEXT, LG_CLIPBOARD_DATA_PNG };
-  lgClipboard_notifyTypes(NULL, 1);
-  lgClipboard_notifyTypes(bad, 1);
-  lgClipboard_notifyTypes(many, LG_CLIPBOARD_DATA_NONE + 1);
+  clipboard_notifyTypes(NULL, 1);
+  clipboard_notifyTypes(bad, 1);
+  clipboard_notifyTypes(many, LG_CLIPBOARD_DATA_NONE + 1);
  CHECK(p.notice == 0);
-  lgClipboard_notifyTypes(types, 2);
+  clipboard_notifyTypes(types, 2);
  CHECK(p.notice == 1);

  CHECK(!p.ev->request(
@@ -1103,9 +1103,9 @@ static void testLocal(void)
  CHECK(!p.ev->request(p.evCtx, 41, LG_CLIPBOARD_DATA_PNG));

  const LG_ClipboardRequest first = d.reqId[0];
-  lgClipboard_data(first + 100, LG_CLIPBOARD_DATA_TEXT, "x", 1);
+  clipboard_data(first + 100, LG_CLIPBOARD_DATA_TEXT, "x", 1);
  CHECK(p.data == 0);
-  lgClipboard_data(first, LG_CLIPBOARD_DATA_PNG, "x", 1);
+  clipboard_data(first, LG_CLIPBOARD_DATA_PNG, "x", 1);
  CHECK(p.data == 1);
  CHECK(p.dataId[0] == 40);
  CHECK(p.dataType[0] == LG_CLIPBOARD_DATA_NONE);
@@ -1113,9 +1113,9 @@ static void testLocal(void)

  CHECK(p.ev->request(p.evCtx, 41, LG_CLIPBOARD_DATA_PNG));
  const LG_ClipboardRequest second = d.reqId[1];
-  lgClipboard_abort(second + 100);
+  clipboard_abort(second + 100);
  CHECK(p.data == 1);
-  lgClipboard_abort(second);
+  clipboard_abort(second);
  CHECK(p.data == 2);
  CHECK(p.dataId[1] == 41);
  CHECK(p.dataType[1] == LG_CLIPBOARD_DATA_NONE);
@@ -1123,16 +1123,16 @@ static void testLocal(void)
  CHECK(p.ev->request(p.evCtx, 42, LG_CLIPBOARD_DATA_TEXT));
  const LG_ClipboardRequest third = d.reqId[2];
  const uint8_t buf[] = { 5, 6, 7 };
-  lgClipboard_data(third, LG_CLIPBOARD_DATA_TEXT, buf, sizeof(buf));
+  clipboard_data(third, LG_CLIPBOARD_DATA_TEXT, buf, sizeof(buf));
  CHECK(p.data == 3);
  CHECK(p.dataId[2] == 42);
  CHECK(p.dataType[2] == LG_CLIPBOARD_DATA_TEXT);
  CHECK(p.dataSize[2] == sizeof(buf));
  CHECK(memcmp(p.dataBuf[2], buf, sizeof(buf)) == 0);
-  lgClipboard_data(third, LG_CLIPBOARD_DATA_TEXT, buf, sizeof(buf));
+  clipboard_data(third, LG_CLIPBOARD_DATA_TEXT, buf, sizeof(buf));
  CHECK(p.data == 3);

-  lgClipboard_free();
+  clipboard_free();
 }

 static void testReentrant(void)
@@ -1144,7 +1144,7 @@ static void testReentrant(void)

  struct Reply second = { 0 };
  struct Reply first  = { .next = &second };
-  CHECK(lgClipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &first));
+  CHECK(clipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &first));
  remoteData(&p, p.reqId[0], LG_CLIPBOARD_DATA_TEXT, "a", 1);
  CHECK(first.count == 1);
  CHECK(first.nested);
@@ -1152,7 +1152,7 @@ static void testReentrant(void)
  remoteData(&p, p.reqId[1], LG_CLIPBOARD_DATA_TEXT, "b", 1);
  CHECK(second.count == 1);

-  lgClipboard_notifyTypes(types, 1);
+  clipboard_notifyTypes(types, 1);
  d.autoData = true;
  d.autoType = LG_CLIPBOARD_DATA_TEXT;
  d.autoBuf  = "local";
@@ -1164,27 +1164,27 @@ static void testReentrant(void)
  CHECK(p.dataSize[0] == 5);
  CHECK(memcmp(p.dataBuf[0], "local", 5) == 0);

-  lgClipboard_free();
+  clipboard_free();
 }

 static void testStreamLocal(void)
 {
  init();
-  lgClipboard_setFallback(&streamOps, &p);
+  clipboard_setFallback(&streamOps, &p);
  const LG_ClipboardData types[] = { LG_CLIPBOARD_DATA_TEXT };
-  lgClipboard_notifyTypes(types, 1);
+  clipboard_notifyTypes(types, 1);

  CHECK(p.ev->request(p.evCtx, 40, LG_CLIPBOARD_DATA_TEXT));
  const LG_ClipboardRequest transfer = d.reqId[0];
-  CHECK(lgClipboard_dataBegin(transfer, LG_CLIPBOARD_DATA_TEXT,
+  CHECK(clipboard_dataBegin(transfer, LG_CLIPBOARD_DATA_TEXT,
      LG_CLIPBOARD_SIZE_UNKNOWN) == LG_CLIPBOARD_RESULT_ACCEPTED);
  const uint8_t first[] = { 1, 2 };
  const uint8_t second[] = { 3, 4, 5 };
-  CHECK(lgClipboard_dataChunk(transfer, 0, first, sizeof(first)) ==
+  CHECK(clipboard_dataChunk(transfer, 0, first, sizeof(first)) ==
      LG_CLIPBOARD_RESULT_ACCEPTED);
-  CHECK(lgClipboard_dataChunk(transfer, sizeof(first),
+  CHECK(clipboard_dataChunk(transfer, sizeof(first),
      second, sizeof(second)) == LG_CLIPBOARD_RESULT_ACCEPTED);
-  CHECK(lgClipboard_dataEnd(transfer,
+  CHECK(clipboard_dataEnd(transfer,
      sizeof(first) + sizeof(second)) == LG_CLIPBOARD_RESULT_ACCEPTED);
  CHECK(p.begin == 1);
  CHECK(p.streamId == 40);
@@ -1197,9 +1197,9 @@ static void testStreamLocal(void)

  CHECK(p.ev->request(p.evCtx, 41, LG_CLIPBOARD_DATA_TEXT));
  const LG_ClipboardRequest invalid = d.reqId[1];
-  CHECK(lgClipboard_dataBegin(invalid, LG_CLIPBOARD_DATA_TEXT, 1) ==
+  CHECK(clipboard_dataBegin(invalid, LG_CLIPBOARD_DATA_TEXT, 1) ==
      LG_CLIPBOARD_RESULT_ACCEPTED);
-  CHECK(lgClipboard_dataChunk(invalid, 1, first, 1) ==
+  CHECK(clipboard_dataChunk(invalid, 1, first, 1) ==
      LG_CLIPBOARD_RESULT_FAILED);
  CHECK(p.cancel == 1);
  CHECK(p.streamId == 41);
@@ -1210,20 +1210,20 @@ static void testStreamLocal(void)
  CHECK(d.cancel == 1);
  CHECK(d.cancelReason == LG_CLIPBOARD_CANCEL_REPLACED);

-  lgClipboard_free();
+  clipboard_free();
 }

 static void testStreamBlocked(void)
 {
  init();
-  lgClipboard_setFallback(&streamOps, &p);
+  clipboard_setFallback(&streamOps, &p);
  const LG_ClipboardData types[] = { LG_CLIPBOARD_DATA_TEXT };
-  lgClipboard_notifyTypes(types, 1);
+  clipboard_notifyTypes(types, 1);
  CHECK(p.ev->request(p.evCtx, 50, LG_CLIPBOARD_DATA_TEXT));

  p.beginResult = LG_CLIPBOARD_RESULT_BLOCKED;
  uint8_t data[] = { 7, 8, 9 };
-  lgClipboard_data(d.reqId[0], LG_CLIPBOARD_DATA_TEXT,
+  clipboard_data(d.reqId[0], LG_CLIPBOARD_DATA_TEXT,
      data, sizeof(data));
  CHECK(p.begin == 1);
  CHECK(p.chunk == 0);
@@ -1244,30 +1244,30 @@ static void testStreamBlocked(void)
  CHECK(p.ev->request(p.evCtx, 51, LG_CLIPBOARD_DATA_TEXT));
  const LG_ClipboardRequest transfer = d.reqId[1];
  p.beginResult = LG_CLIPBOARD_RESULT_BLOCKED;
-  CHECK(lgClipboard_dataBegin(transfer, LG_CLIPBOARD_DATA_TEXT,
+  CHECK(clipboard_dataBegin(transfer, LG_CLIPBOARD_DATA_TEXT,
      LG_CLIPBOARD_SIZE_UNKNOWN) == LG_CLIPBOARD_RESULT_BLOCKED);
  p.beginResult = LG_CLIPBOARD_RESULT_ACCEPTED;
  d.autoBegin = true;
  p.ev->dataReady(p.evCtx, 51);
  CHECK(d.ready == 1);
  CHECK(d.readyResult == LG_CLIPBOARD_RESULT_ACCEPTED);
-  CHECK(lgClipboard_dataEnd(transfer, 0) ==
+  CHECK(clipboard_dataEnd(transfer, 0) ==
      LG_CLIPBOARD_RESULT_ACCEPTED);

-  lgClipboard_free();
+  clipboard_free();
 }

 static void testStreamRemote(void)
 {
  init();
-  lgClipboard_setFallback(&streamOps, &p);
+  clipboard_setFallback(&streamOps, &p);
  const LG_ClipboardData types[] = { LG_CLIPBOARD_DATA_TEXT };
  notice(&p, types, 1);

  struct StreamSink sink = { 0 };
  initSink(&sink);
  LG_ClipboardRequest id;
-  CHECK(lgClipboard_requestStream(
+  CHECK(clipboard_requestStream(
      LG_CLIPBOARD_DATA_TEXT, &sinkOps, &sink, &id));
  CHECK(id == p.reqId[0]);
  CHECK(p.ev->dataBegin(p.evCtx, id, LG_CLIPBOARD_DATA_TEXT,
@@ -1281,7 +1281,7 @@ static void testStreamRemote(void)
      LG_CLIPBOARD_RESULT_BLOCKED);
  CHECK(sink.chunk == 1);
  sink.chunkResult = LG_CLIPBOARD_RESULT_ACCEPTED;
-  CHECK(lgClipboard_requestReady(id));
+  CHECK(clipboard_requestReady(id));
  CHECK(p.ready == 1);
  CHECK(p.streamId == id);
  CHECK(p.ev->dataChunk(p.evCtx, id, 0, data, sizeof(data)) ==
@@ -1295,19 +1295,19 @@ static void testStreamRemote(void)

  struct StreamSink cancel = { 0 };
  initSink(&cancel);
-  CHECK(lgClipboard_requestStream(
+  CHECK(clipboard_requestStream(
      LG_CLIPBOARD_DATA_TEXT, &sinkOps, &cancel, &id));
  p.ev->dataCancel(p.evCtx, id, LG_CLIPBOARD_CANCEL_ABORTED);
  CHECK(cancel.cancel == 1);
  CHECK(cancel.reason == LG_CLIPBOARD_CANCEL_ABORTED);

-  lgClipboard_free();
+  clipboard_free();
 }

 static void testRequestPublication(void)
 {
  init();
-  lgClipboard_setFallback(&streamOps, &p);
+  clipboard_setFallback(&streamOps, &p);
  const LG_ClipboardData types[] = { LG_CLIPBOARD_DATA_TEXT };
  notice(&p, types, 1);

@@ -1315,7 +1315,7 @@ static void testRequestPublication(void)
  initSink(&sink);
  sink.requireRequest = true;
  p.earlyBegin = true;
-  CHECK(lgClipboard_requestStream(LG_CLIPBOARD_DATA_TEXT,
+  CHECK(clipboard_requestStream(LG_CLIPBOARD_DATA_TEXT,
      &sinkOps, &sink, &sink.request));
  CHECK(sink.request == p.reqId[0]);
  CHECK(p.earlyResult == LG_CLIPBOARD_RESULT_ACCEPTED);
@@ -1324,7 +1324,7 @@ static void testRequestPublication(void)
      LG_CLIPBOARD_RESULT_ACCEPTED);
  CHECK(sink.end == 1);

-  lgClipboard_free();
+  clipboard_free();
 }

 static void testStreamLegacy(void)
@@ -1332,19 +1332,19 @@ static void testStreamLegacy(void)
  init();
  bind(&p);
  const LG_ClipboardData types[] = { LG_CLIPBOARD_DATA_TEXT };
-  lgClipboard_notifyTypes(types, 1);
+  clipboard_notifyTypes(types, 1);

  CHECK(p.ev->request(p.evCtx, 60, LG_CLIPBOARD_DATA_TEXT));
  const LG_ClipboardRequest transfer = d.reqId[0];
  const uint8_t first[] = { 2, 4 };
  const uint8_t second[] = { 6, 8 };
-  CHECK(lgClipboard_dataBegin(transfer, LG_CLIPBOARD_DATA_TEXT,
+  CHECK(clipboard_dataBegin(transfer, LG_CLIPBOARD_DATA_TEXT,
      LG_CLIPBOARD_SIZE_UNKNOWN) == LG_CLIPBOARD_RESULT_ACCEPTED);
-  CHECK(lgClipboard_dataChunk(transfer, 0, first, sizeof(first)) ==
+  CHECK(clipboard_dataChunk(transfer, 0, first, sizeof(first)) ==
      LG_CLIPBOARD_RESULT_ACCEPTED);
-  CHECK(lgClipboard_dataChunk(transfer, sizeof(first), second,
+  CHECK(clipboard_dataChunk(transfer, sizeof(first), second,
      sizeof(second)) == LG_CLIPBOARD_RESULT_ACCEPTED);
-  CHECK(lgClipboard_dataEnd(transfer, 4) ==
+  CHECK(clipboard_dataEnd(transfer, 4) ==
      LG_CLIPBOARD_RESULT_ACCEPTED);
  CHECK(p.data == 1);
  CHECK(p.dataId[0] == 60);
@@ -1357,7 +1357,7 @@ static void testStreamLegacy(void)
  initSink(&sink);
  sink.beginResult = LG_CLIPBOARD_RESULT_BLOCKED;
  LG_ClipboardRequest id;
-  CHECK(lgClipboard_requestStream(
+  CHECK(clipboard_requestStream(
      LG_CLIPBOARD_DATA_TEXT, &sinkOps, &sink, &id));
  const uint8_t remote[] = { 9, 8, 7 };
  remoteData(&p, id, LG_CLIPBOARD_DATA_TEXT, remote, sizeof(remote));
@@ -1365,7 +1365,7 @@ static void testStreamLegacy(void)
  CHECK(sink.chunk == 0);

  sink.beginResult = LG_CLIPBOARD_RESULT_ACCEPTED;
-  CHECK(lgClipboard_requestReady(id));
+  CHECK(clipboard_requestReady(id));
  CHECK(p.ready == 0);
  CHECK(sink.begin == 2);
  CHECK(sink.chunk == 1);
@@ -1373,7 +1373,7 @@ static void testStreamLegacy(void)
  CHECK(sink.size == sizeof(remote));
  CHECK(memcmp(sink.data, remote, sizeof(remote)) == 0);

-  lgClipboard_free();
+  clipboard_free();
 }

 struct Test
--- a/client/tests/spice_clipboard_test.c
+++ b/client/tests/spice_clipboard_test.c
@@ -143,15 +143,15 @@ static SpiceClipboard * setup(void)
  g_state.ds                = &displayOps;
  g_params.clipboardToVM    = true;
  g_params.clipboardToLocal = true;
-  CHECK(lgClipboard_init());
-  lgClipboard_setLocalAvailable(true);
-  lgClipboard_setFallback(spiceClipboard_getOps(), clipboard);
+  CHECK(clipboard_init());
+  clipboard_setLocalAvailable(true);
+  clipboard_setFallback(spiceClipboard_getOps(), clipboard);
  return clipboard;
 }

 static void teardown(SpiceClipboard ** clipboard)
 {
-  lgClipboard_free();
+  clipboard_free();
  spiceClipboard_setCallbackTarget(NULL);
  spiceClipboard_free(clipboard);
 }
@@ -160,22 +160,22 @@ static void testOutbound(void)
 {
  SpiceClipboard * clipboard = setup();
  const LG_ClipboardData types[] = { LG_CLIPBOARD_DATA_TEXT };
-  lgClipboard_notifyTypes(types, 1);
+  clipboard_notifyTypes(types, 1);
  CHECK(test.grab == 1);

  spiceClipboard_request(SPICE_DATA_TEXT);
  CHECK(test.localRequest != LG_CLIPBOARD_REQUEST_INVALID);
  const uint8_t first[]  = { 1, 2 };
  const uint8_t second[] = { 3, 4 };
-  CHECK(lgClipboard_dataBegin(test.localRequest,
+  CHECK(clipboard_dataBegin(test.localRequest,
      LG_CLIPBOARD_DATA_TEXT, LG_CLIPBOARD_SIZE_UNKNOWN) ==
      LG_CLIPBOARD_RESULT_ACCEPTED);
-  CHECK(lgClipboard_dataChunk(test.localRequest,
+  CHECK(clipboard_dataChunk(test.localRequest,
      0, first, sizeof(first)) == LG_CLIPBOARD_RESULT_ACCEPTED);
-  CHECK(lgClipboard_dataChunk(test.localRequest,
+  CHECK(clipboard_dataChunk(test.localRequest,
      sizeof(first), second, sizeof(second)) ==
      LG_CLIPBOARD_RESULT_ACCEPTED);
-  CHECK(lgClipboard_dataEnd(test.localRequest, 4) ==
+  CHECK(clipboard_dataEnd(test.localRequest, 4) ==
      LG_CLIPBOARD_RESULT_ACCEPTED);

  CHECK(test.dataStart == 1);
@@ -191,7 +191,7 @@ static void testInbound(void)
  SpiceClipboard * clipboard = setup();
  spiceClipboard_notice(SPICE_DATA_TEXT);
  CHECK(test.notice == 1);
-  CHECK(lgClipboard_request(LG_CLIPBOARD_DATA_TEXT, reply, NULL));
+  CHECK(clipboard_request(LG_CLIPBOARD_DATA_TEXT, reply, NULL));
  CHECK(test.request == 1);
  CHECK(test.requestType == SPICE_DATA_TEXT);

--- a/client/tests/transport_fallback_test.c
+++ b/client/tests/transport_fallback_test.c
@@ -400,12 +400,12 @@ void lgAudio_dropFallback(void)
 }
 #endif

-void lgClipboard_setFallback(const LG_ClipboardOps * ops, void * opaque)
+void clipboard_setFallback(const LG_ClipboardOps * ops, void * opaque)
 {
  setProvider(&pClipboard, ops, &clipboardOps, opaque);
 }

-void lgClipboard_dropFallback(void)
+void clipboard_dropFallback(void)
 {
  atomic_fetch_add(&pClipboard.drop, 1);
 }
--- a/client/tests/wayland_clipboard_test.c
+++ b/client/tests/wayland_clipboard_test.c
@@ -443,7 +443,7 @@ static void pollFire(unsigned int no, uint32_t events)
      pollCleanup(&rec.poll[i]);
 }

-void lgClipboard_notifyTypes(
+void clipboard_notifyTypes(
    const LG_ClipboardData types[], size_t count)
 {
  CHECK(rec.noticeN < ARRAY_LENGTH(rec.notice));
@@ -453,7 +453,7 @@ void lgClipboard_notifyTypes(
  notice->count = count;
 }

-void lgClipboard_release(void)
+void clipboard_release(void)
 {
  if (rec.expectReleaseLocked)
  {
@@ -464,13 +464,13 @@ void lgClipboard_release(void)
  ++rec.releaseN;
 }

-void lgClipboard_abort(LG_ClipboardRequest request)
+void clipboard_abort(LG_ClipboardRequest request)
 {
  CHECK(rec.abortN < ARRAY_LENGTH(rec.abort));
  rec.abort[rec.abortN++] = request;
 }

-void lgClipboard_data(LG_ClipboardRequest request,
+void clipboard_data(LG_ClipboardRequest request,
    LG_ClipboardData type, const void * data, size_t size)
 {
  CHECK(rec.dataN < ARRAY_LENGTH(rec.data));
@@ -482,7 +482,7 @@ void lgClipboard_data(LG_ClipboardRequest request,
  memcpy(notice->data, data, size);
 }

-LG_ClipboardResult lgClipboard_dataBegin(LG_ClipboardRequest request,
+LG_ClipboardResult clipboard_dataBegin(LG_ClipboardRequest request,
    LG_ClipboardData type, uint64_t sizeHint)
 {
  struct StreamNotice * stream = &rec.streamData;
@@ -493,7 +493,7 @@ LG_ClipboardResult lgClipboard_dataBegin(LG_ClipboardRequest request,
  return rec.beginResult;
 }

-LG_ClipboardResult lgClipboard_dataChunk(LG_ClipboardRequest request,
+LG_ClipboardResult clipboard_dataChunk(LG_ClipboardRequest request,
    uint64_t offset, const void * data, size_t size)
 {
  const LG_ClipboardResult result = rec.chunkResult;
@@ -518,7 +518,7 @@ LG_ClipboardResult lgClipboard_dataChunk(LG_ClipboardRequest request,
  return result;
 }

-LG_ClipboardResult lgClipboard_dataEnd(LG_ClipboardRequest request,
+LG_ClipboardResult clipboard_dataEnd(LG_ClipboardRequest request,
    uint64_t finalSize)
 {
  const LG_ClipboardResult result = rec.endResult;
@@ -535,7 +535,7 @@ LG_ClipboardResult lgClipboard_dataEnd(LG_ClipboardRequest request,
  return result;
 }

-bool lgClipboard_requestStream(LG_ClipboardData type,
+bool clipboard_requestStream(LG_ClipboardData type,
    const LG_ClipboardStreamOps * stream, void * opaque,
    LG_ClipboardRequest * request)
 {
@@ -562,14 +562,14 @@ bool lgClipboard_requestStream(LG_ClipboardData type,
  return rec.requestOK;
 }

-bool lgClipboard_requestReady(LG_ClipboardRequest request)
+bool clipboard_requestReady(LG_ClipboardRequest request)
 {
  CHECK(request == rec.requestId);
  ++rec.requestReadyN;
  return true;
 }

-bool lgClipboardFiles_setLocal(const char * mime,
+bool clipboardFiles_setLocal(const char * mime,
    const void * data, size_t size)
 {
  CHECK(mime);
@@ -583,18 +583,18 @@ bool lgClipboardFiles_setLocal(const char * mime,
  return rec.fileSetOK;
 }

-void lgClipboardFiles_clearLocal(void)
+void clipboardFiles_clearLocal(void)
 {
  ++rec.fileClearN;
 }

-uint64_t lgClipboardFiles_remotePresentationAcquire(void)
+uint64_t clipboardFiles_remotePresentationAcquire(void)
 {
  ++rec.presentationAcquireN;
  return rec.presentationOK ? 1000U + rec.presentationAcquireN : 0;
 }

-bool lgClipboardFiles_getRemotePresentation(uint64_t presentation,
+bool clipboardFiles_getRemotePresentation(uint64_t presentation,
    const char * mime, char ** data, size_t * size)
 {
  CHECK(presentation >= 1001U);
@@ -614,7 +614,7 @@ bool lgClipboardFiles_getRemotePresentation(uint64_t presentation,
  return true;
 }

-void lgClipboardFiles_remotePresentationDelivered(uint64_t presentation)
+void clipboardFiles_remotePresentationDelivered(uint64_t presentation)
 {
  CHECK(presentation);
  CHECK(rec.presentationDeliveredN <
@@ -622,7 +622,7 @@ void lgClipboardFiles_remotePresentationDelivered(uint64_t presentation)
  rec.presentationDelivered[rec.presentationDeliveredN++] = presentation;
 }

-void lgClipboardFiles_remotePresentationRelease(uint64_t presentation)
+void clipboardFiles_remotePresentationRelease(uint64_t presentation)
 {
  CHECK(presentation);
  CHECK(rec.presentationReleaseN <
--- a/client/tests/x11_clipboard_test.c
+++ b/client/tests/x11_clipboard_test.c
@@ -438,7 +438,7 @@ int XFree(void * data)
  return Success;
 }

-void lgClipboard_notifyTypes(
+void clipboard_notifyTypes(
    const LG_ClipboardData types[], size_t count)
 {
  CHECK(rec.noticeN < ARRAY_LENGTH(rec.notice));
@@ -448,7 +448,7 @@ void lgClipboard_notifyTypes(
  memcpy(notice->type, types, count * sizeof(*types));
 }

-void lgClipboard_data(LG_ClipboardRequest request,
+void clipboard_data(LG_ClipboardRequest request,
    LG_ClipboardData type, const void * data, size_t size)
 {
  CHECK(rec.dataN < ARRAY_LENGTH(rec.data));
@@ -462,7 +462,7 @@ void lgClipboard_data(LG_ClipboardRequest request,
    memcpy(notice->data, data, size);
 }

-LG_ClipboardResult lgClipboard_dataBegin(LG_ClipboardRequest request,
+LG_ClipboardResult clipboard_dataBegin(LG_ClipboardRequest request,
    LG_ClipboardData type, uint64_t sizeHint)
 {
  ++rec.streamBeginN;
@@ -481,7 +481,7 @@ LG_ClipboardResult lgClipboard_dataBegin(LG_ClipboardRequest request,
  return rec.beginResult;
 }

-LG_ClipboardResult lgClipboard_dataChunk(LG_ClipboardRequest request,
+LG_ClipboardResult clipboard_dataChunk(LG_ClipboardRequest request,
    uint64_t offset, const void * data, size_t size)
 {
  const LG_ClipboardResult result = rec.chunkResult;
@@ -519,7 +519,7 @@ LG_ClipboardResult lgClipboard_dataChunk(LG_ClipboardRequest request,
  return result;
 }

-LG_ClipboardResult lgClipboard_dataEnd(LG_ClipboardRequest request,
+LG_ClipboardResult clipboard_dataEnd(LG_ClipboardRequest request,
    uint64_t finalSize)
 {
  const LG_ClipboardResult result = rec.endResult;
@@ -540,18 +540,18 @@ LG_ClipboardResult lgClipboard_dataEnd(LG_ClipboardRequest request,
  return result;
 }

-void lgClipboard_abort(LG_ClipboardRequest request)
+void clipboard_abort(LG_ClipboardRequest request)
 {
  CHECK(rec.abortN < ARRAY_LENGTH(rec.abort));
  rec.abort[rec.abortN++] = request;
 }

-void lgClipboard_release(void)
+void clipboard_release(void)
 {
  ++rec.releaseN;
 }

-bool lgClipboard_requestStream(LG_ClipboardData type,
+bool clipboard_requestStream(LG_ClipboardData type,
    const LG_ClipboardStreamOps * stream, void * opaque,
    LG_ClipboardRequest * request)
 {
@@ -570,14 +570,14 @@ bool lgClipboard_requestStream(LG_ClipboardData type,
  return rec.requestOK;
 }

-bool lgClipboard_requestReady(LG_ClipboardRequest request)
+bool clipboard_requestReady(LG_ClipboardRequest request)
 {
  CHECK(request == rec.requestId);
  ++rec.requestReadyN;
  return true;
 }

-bool lgClipboardFiles_setLocal(const char * mime,
+bool clipboardFiles_setLocal(const char * mime,
    const void * data, size_t size)
 {
  CHECK(mime);
@@ -591,18 +591,18 @@ bool lgClipboardFiles_setLocal(const char * mime,
  return rec.fileSetOK;
 }

-void lgClipboardFiles_clearLocal(void)
+void clipboardFiles_clearLocal(void)
 {
  ++rec.fileClearN;
 }

-uint64_t lgClipboardFiles_remotePresentationAcquire(void)
+uint64_t clipboardFiles_remotePresentationAcquire(void)
 {
  ++rec.presentationAcquireN;
  return rec.presentationOK ? 2001U : 0;
 }

-bool lgClipboardFiles_getRemotePresentation(uint64_t presentation,
+bool clipboardFiles_getRemotePresentation(uint64_t presentation,
    const char * mime, char ** data, size_t * size)
 {
  CHECK(presentation >= 2001U);
@@ -622,7 +622,7 @@ bool lgClipboardFiles_getRemotePresentation(uint64_t presentation,
  return true;
 }

-void lgClipboardFiles_remotePresentationDelivered(uint64_t presentation)
+void clipboardFiles_remotePresentationDelivered(uint64_t presentation)
 {
  CHECK(presentation);
  CHECK(rec.presentationDeliveredN <
@@ -630,7 +630,7 @@ void lgClipboardFiles_remotePresentationDelivered(uint64_t presentation)
  rec.presentationDelivered[rec.presentationDeliveredN++] = presentation;
 }

-void lgClipboardFiles_remotePresentationRelease(uint64_t presentation)
+void clipboardFiles_remotePresentationRelease(uint64_t presentation)
 {
  CHECK(presentation);
  CHECK(rec.presentationReleaseN <
--- a/client/transports/LGMP/input.c
+++ b/client/transports/LGMP/input.c
@@ -750,15 +750,15 @@ static void logStats(const struct LGMPInputCounters * stats)
  const uint64_t ackAverage = stats->ackSamples ?
    stats->ackTotal / stats->ackSamples : 0;

-  DEBUG_TRACE("LGMP input: sent immediate/deferred %" PRIu64 "/%" PRIu64
-    ", queued %" PRIu64 " (high %u), initial busy/full %" PRIu64
-    "/%" PRIu64 ", retry busy/full %" PRIu64 "/%" PRIu64
-    ", coalesced relative/absolute %" PRIu64 "/%" PRIu64
-    ", motion rejected/evicted %" PRIu64 "/%" PRIu64
-    ", overflow failures/resets %" PRIu64 "/%" PRIu64
-    ", published claim/release/keepalive %" PRIu64 "/%" PRIu64
-    "/%" PRIu64 ", terminal failures %" PRIu64
-    ", LGMP ACK average/max %" PRIu64 "/%" PRIu64 " us (%" PRIu64
+  DEBUG_TRACE("LGMP input: sent immediate/deferred %lu/%lu"
+    ", queued %lu (high %u), initial busy/full %lu"
+    "/%lu, retry busy/full %lu/%lu"
+    ", coalesced relative/absolute %lu/%lu"
+    ", motion rejected/evicted %lu/%lu"
+    ", overflow failures/resets %lu/%lu"
+    ", published claim/release/keepalive %lu/%lu"
+    "/%lu, terminal failures %lu"
+    ", LGMP ACK average/max %lu/%lu us (%lu"
    " samples)", stats->immediateSends, stats->deferredSends,
    stats->localEnqueues, stats->pendingHighWater,
    stats->initialBusy, stats->initialFull, stats->retryBusy,