From 97b249b49be7d67ed7c4157e673846986b20ba75 Mon Sep 17 00:00:00 2001 From: Geoffrey McRae Date: Sat, 15 Aug 2026 01:34:40 +1000 Subject: [PATCH] [client] cosmetics/naming cleanup --- client/displayservers/Wayland/clipboard.c | 64 +++--- client/displayservers/X11/clipboard.c | 126 +++++------ client/include/core/clipboard.h | 56 ++--- client/include/core/clipboard_files.h | 66 +++--- client/src/app.c | 2 +- client/src/clipboard.c | 102 ++++----- client/src/clipboard_files.c | 137 ++++++----- client/src/main.c | 28 +-- client/src/transport_fallback.c | 6 +- client/src/usb_audio.c | 4 +- client/tests/clipboard_files_stub.c | 70 +++--- client/tests/clipboard_files_test.c | 236 +++++++++---------- client/tests/clipboard_test.c | 264 +++++++++++----------- client/tests/spice_clipboard_test.c | 20 +- client/tests/transport_fallback_test.c | 4 +- client/tests/wayland_clipboard_test.c | 30 +-- client/tests/x11_clipboard_test.c | 30 +-- client/transports/LGMP/input.c | 18 +- 18 files changed, 630 insertions(+), 633 deletions(-) diff --git a/client/displayservers/Wayland/clipboard.c b/client/displayservers/Wayland/clipboard.c index af52b896..98176987 100644 --- 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) diff --git a/client/displayservers/X11/clipboard.c b/client/displayservers/X11/clipboard.c index 6ad0f1e5..7a89eed2 100644 --- 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; diff --git a/client/include/core/clipboard.h b/client/include/core/clipboard.h index 92301ce9..82812c1c 100644 --- 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 diff --git a/client/include/core/clipboard_files.h b/client/include/core/clipboard_files.h index 87415972..75a4cce0 100644 --- 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 diff --git a/client/src/app.c b/client/src/app.c index afe60345..ec42a401 100644 --- 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); } diff --git a/client/src/clipboard.c b/client/src/clipboard.c index 83e023aa..a15edb3f 100644 --- 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; diff --git a/client/src/clipboard_files.c b/client/src/clipboard_files.c index 2e06da7a..7f992658 100644 --- 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; diff --git a/client/src/main.c b/client/src/main.c index 5aa80b39..ae21c4b7 100644 --- 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(); diff --git a/client/src/transport_fallback.c b/client/src/transport_fallback.c index 6963c0ad..c5755687 100644 --- 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); diff --git a/client/src/usb_audio.c b/client/src/usb_audio.c index 45a4b3f5..adbc6259 100644 --- 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; diff --git a/client/tests/clipboard_files_stub.c b/client/tests/clipboard_files_stub.c index 7ec3690e..b8d6a1fd 100644 --- 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; } diff --git a/client/tests/clipboard_files_test.c b/client/tests/clipboard_files_test.c index a6f47b1e..4eff6bcb 100644 --- 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; } diff --git a/client/tests/clipboard_test.c b/client/tests/clipboard_test.c index 3f6d48d0..3a2b4de2 100644 --- 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 diff --git a/client/tests/spice_clipboard_test.c b/client/tests/spice_clipboard_test.c index af0e9389..9458ad31 100644 --- 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); diff --git a/client/tests/transport_fallback_test.c b/client/tests/transport_fallback_test.c index 9b090d76..d2419242 100644 --- 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); } diff --git a/client/tests/wayland_clipboard_test.c b/client/tests/wayland_clipboard_test.c index 7ddca6c4..d71e9307 100644 --- 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 < diff --git a/client/tests/x11_clipboard_test.c b/client/tests/x11_clipboard_test.c index 384a14ea..4cb09f40 100644 --- 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 < diff --git a/client/transports/LGMP/input.c b/client/transports/LGMP/input.c index 29b164c4..8e922e3b 100644 --- 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,