40#include <winpr/assert.h>
41#include <winpr/cast.h>
42#include <winpr/clipboard.h>
43#include <winpr/collections.h>
44#include <winpr/image.h>
45#include <winpr/synch.h>
46#include <winpr/sysinfo.h>
47#include <winpr/user.h>
49#include <freerdp/log.h>
52#include "shadow_cliprdr.h"
54#define TAG SERVER_TAG("shadow.clipboard")
56#if defined(CHANNEL_CLIPRDR_SERVER)
59#define SHADOW_CLIPBOARD_LIST_WAIT_MS 1000
62#define SHADOW_CLIPBOARD_FETCH_TIMEOUT_MS 10000
64#define SHADOW_CLIPBOARD_MIME_HTML "text/html"
65#define SHADOW_CLIPBOARD_FORMAT_HTML "HTML Format"
68#define SHADOW_CLIPBOARD_MAX_OFFER 16
72 rdpShadowClient* client;
79 rdpShadowClient* client;
87 rdpShadowClient* client;
95} ShadowClipboardFetch;
97struct rdp_shadow_clipboard
99 rdpShadowServer* server;
100 CRITICAL_SECTION lock;
108 size_t nSessionMimes;
111 rdpShadowClient* owner;
112 CLIPRDR_FORMAT* ownerFormats;
113 UINT32 nOwnerFormats;
121static const char*
const shadow_clipboard_text_mimes[] = {
"text/plain;charset=utf-8",
122 "UTF8_STRING",
"text/plain" };
124static const UINT32 shadow_clipboard_image_formats[] = { WINPR_IMAGE_PNG, WINPR_IMAGE_BITMAP,
125 WINPR_IMAGE_WEBP, WINPR_IMAGE_JPEG };
127static void shadow_clipboard_read_free(
void* obj)
129 ShadowClipboardRead* read = obj;
136static void shadow_clipboard_formats_free(
CLIPRDR_FORMAT* formats, UINT32 count)
140 for (UINT32 x = 0; x < count; x++)
141 free(formats[x].formatName);
145static void shadow_clipboard_mimes_free(
char** mimes,
size_t count)
149 for (
size_t x = 0; x < count; x++)
155static rdpShadowSubsystem* shadow_clipboard_subsystem(
const rdpShadowClipboard* clipboard)
157 WINPR_ASSERT(clipboard);
158 WINPR_ASSERT(clipboard->server);
159 return clipboard->server->subsystem;
163static ShadowClipboardPeer* shadow_clipboard_peer(rdpShadowClipboard* clipboard,
164 const rdpShadowClient* client)
166 WINPR_ASSERT(clipboard);
168 const size_t count = ArrayList_Count(clipboard->peers);
169 for (
size_t x = 0; x < count; x++)
171 ShadowClipboardPeer* peer = ArrayList_GetItem(clipboard->peers, x);
172 if (peer && (peer->client == client))
179static BOOL shadow_clipboard_session_has(
const rdpShadowClipboard* clipboard,
const char* mime)
181 WINPR_ASSERT(clipboard);
184 for (
size_t x = 0; x < clipboard->nSessionMimes; x++)
186 if (strcmp(clipboard->sessionMimes[x], mime) == 0)
194static const char* shadow_clipboard_session_mime(
const rdpShadowClipboard* clipboard,
197 WINPR_ASSERT(clipboard);
199 if ((formatId == CF_UNICODETEXT) || (formatId == CF_TEXT) || (formatId == CF_OEMTEXT))
201 for (
size_t x = 0; x < ARRAYSIZE(shadow_clipboard_text_mimes); x++)
203 if (shadow_clipboard_session_has(clipboard, shadow_clipboard_text_mimes[x]))
204 return shadow_clipboard_text_mimes[x];
207 else if ((formatId == CF_DIB) || (formatId == CF_DIBV5))
209 for (
size_t x = 0; x < ARRAYSIZE(shadow_clipboard_image_formats); x++)
211 const UINT32 image = shadow_clipboard_image_formats[x];
212 const char* mime = winpr_image_format_mime(image);
213 if (mime && winpr_image_format_is_supported(image) &&
214 shadow_clipboard_session_has(clipboard, mime))
218 else if ((formatId == clipboard->htmlId) &&
219 shadow_clipboard_session_has(clipboard, SHADOW_CLIPBOARD_MIME_HTML))
220 return SHADOW_CLIPBOARD_MIME_HTML;
226static UINT shadow_clipboard_send_list(
const rdpShadowClipboard* clipboard, rdpShadowClient* client)
228 WINPR_ASSERT(clipboard);
229 WINPR_ASSERT(client);
230 WINPR_ASSERT(client->cliprdr);
232 char htmlName[] = SHADOW_CLIPBOARD_FORMAT_HTML;
236 if (shadow_clipboard_session_mime(clipboard, CF_UNICODETEXT))
237 formats[count++].formatId = CF_UNICODETEXT;
238 if (shadow_clipboard_session_mime(clipboard, clipboard->htmlId))
240 formats[count].formatId = clipboard->htmlId;
241 formats[count++].formatName = htmlName;
243 if (shadow_clipboard_session_mime(clipboard, CF_DIB))
244 formats[count++].formatId = CF_DIB;
247 list.common.msgType = CB_FORMAT_LIST;
248 list.numFormats = count;
249 list.formats = formats;
250 return client->cliprdr->ServerFormatList(client->cliprdr, &list);
254static void shadow_clipboard_announce(rdpShadowClipboard* clipboard,
const rdpShadowClient* except)
256 WINPR_ASSERT(clipboard);
258 const size_t count = ArrayList_Count(clipboard->peers);
259 for (
size_t x = 0; x < count; x++)
261 const ShadowClipboardPeer* peer = ArrayList_GetItem(clipboard->peers, x);
262 if (!peer || !peer->ready || (peer->client == except) || !peer->client->mayInteract)
265 const UINT rc = shadow_clipboard_send_list(clipboard, peer->client);
266 if (rc != CHANNEL_RC_OK)
267 WLog_WARN(TAG,
"ServerFormatList failed with %" PRIu32, rc);
273static BYTE* shadow_clipboard_convert(rdpShadowClipboard* clipboard, UINT32 sourceId,
274 UINT32 targetId,
const BYTE* data,
size_t size,
277 WINPR_ASSERT(clipboard);
278 WINPR_ASSERT(pConverted);
281 if (!data || (size == 0) || (size > SHADOW_CLIPBOARD_MAX_SIZE))
284 if (!ClipboardEmpty(clipboard->convert))
286 const BOOL stored = ClipboardSetData(clipboard->convert, sourceId, data,
287 WINPR_ASSERTING_INT_CAST(UINT32, size));
290 return ClipboardGetData(clipboard->convert, targetId, pConverted);
293static void shadow_clipboard_respond(CliprdrServerContext* cliprdr,
const BYTE* data, UINT32 size)
295 WINPR_ASSERT(cliprdr);
298 response.common.msgType = CB_FORMAT_DATA_RESPONSE;
299 response.common.msgFlags = data ? CB_RESPONSE_OK : CB_RESPONSE_FAIL;
300 response.common.dataLen = data ? size : 0;
301 response.requestedFormatData = data;
303 const UINT rc = cliprdr->ServerFormatDataResponse(cliprdr, &response);
304 if (rc != CHANNEL_RC_OK)
305 WLog_WARN(TAG,
"ServerFormatDataResponse failed with %" PRIu32, rc);
309static void shadow_clipboard_read_next(rdpShadowClipboard* clipboard)
311 WINPR_ASSERT(clipboard);
313 while (!clipboard->readBusy && (ArrayList_Count(clipboard->reads) > 0))
315 ShadowClipboardRead* read = ArrayList_GetItem(clipboard->reads, 0);
318 rdpShadowSubsystem* subsystem = shadow_clipboard_subsystem(clipboard);
319 if (read->client && subsystem->ClipboardRead(subsystem, read->mime))
321 clipboard->readBusy = TRUE;
326 shadow_clipboard_respond(read->client->cliprdr,
nullptr, 0);
327 if (!ArrayList_RemoveAt(clipboard->reads, 0))
332static void shadow_clipboard_provide(rdpShadowClipboard* clipboard, UINT32 request,
333 const BYTE* data,
size_t size)
335 WINPR_ASSERT(clipboard);
337 rdpShadowSubsystem* subsystem = shadow_clipboard_subsystem(clipboard);
338 if (!subsystem->ClipboardProvide(subsystem, request, data, size))
339 WLog_WARN(TAG,
"the subsystem did not take the data of request %" PRIu32, request);
343static void shadow_clipboard_fetch_next(rdpShadowClipboard* clipboard)
345 WINPR_ASSERT(clipboard);
347 while (!clipboard->fetchBusy && (ArrayList_Count(clipboard->fetches) > 0))
349 ShadowClipboardFetch* fetch = ArrayList_GetItem(clipboard->fetches, 0);
351 WINPR_ASSERT(fetch->client);
352 WINPR_ASSERT(fetch->client->cliprdr);
355 request.common.msgType = CB_FORMAT_DATA_REQUEST;
356 request.common.dataLen = 4;
357 request.requestedFormatId = fetch->formatId;
359 CliprdrServerContext* cliprdr = fetch->client->cliprdr;
360 const UINT rc = cliprdr->ServerFormatDataRequest(cliprdr, &request);
361 if (rc == CHANNEL_RC_OK)
363 fetch->sent = GetTickCount64();
364 clipboard->fetchBusy = TRUE;
368 WLog_WARN(TAG,
"ServerFormatDataRequest failed with %" PRIu32, rc);
369 shadow_clipboard_provide(clipboard, fetch->request,
nullptr, 0);
370 if (!ArrayList_RemoveAt(clipboard->fetches, 0))
377static void shadow_clipboard_cancel_fetches(rdpShadowClipboard* clipboard,
378 const rdpShadowClient* gone)
380 WINPR_ASSERT(clipboard);
382 for (
size_t x = ArrayList_Count(clipboard->fetches); x > 0; x--)
384 const size_t index = x - 1;
385 ShadowClipboardFetch* fetch = ArrayList_GetItem(clipboard->fetches, index);
388 const BOOL atClient = (index == 0) && clipboard->fetchBusy;
389 if (atClient && (fetch->client != gone))
391 if (!fetch->canceled)
392 shadow_clipboard_provide(clipboard, fetch->request,
nullptr, 0);
393 fetch->canceled = TRUE;
398 clipboard->fetchBusy = FALSE;
399 if (!fetch->canceled)
400 shadow_clipboard_provide(clipboard, fetch->request,
nullptr, 0);
401 if (!ArrayList_RemoveAt(clipboard->fetches, index))
402 WLog_WARN(TAG,
"cannot drop a clipboard request");
406static void shadow_clipboard_clear_owner(rdpShadowClipboard* clipboard)
408 WINPR_ASSERT(clipboard);
410 shadow_clipboard_formats_free(clipboard->ownerFormats, clipboard->nOwnerFormats);
411 clipboard->ownerFormats =
nullptr;
412 clipboard->nOwnerFormats = 0;
413 clipboard->owner =
nullptr;
417static void shadow_clipboard_release_owner(rdpShadowClipboard* clipboard)
419 WINPR_ASSERT(clipboard);
421 shadow_clipboard_clear_owner(clipboard);
423 rdpShadowSubsystem* subsystem = shadow_clipboard_subsystem(clipboard);
424 if (!subsystem->ClipboardOffer(subsystem,
nullptr, 0))
425 WLog_WARN(TAG,
"the session keeps a clipboard nobody serves");
430 UINT32 count, UINT32 formatId,
433 for (UINT32 x = 0; x < count; x++)
438 if (format->formatName && (strcmp(format->formatName, name) == 0))
441 else if (format->formatId == formatId)
451 const UINT32 ids[] = { CF_UNICODETEXT, CF_TEXT, CF_OEMTEXT };
452 for (
size_t x = 0; x < ARRAYSIZE(ids); x++)
455 shadow_clipboard_find_format(formats, count, ids[x],
nullptr);
466 const CLIPRDR_FORMAT* format = shadow_clipboard_find_format(formats, count, CF_DIB,
nullptr);
469 return shadow_clipboard_find_format(formats, count, CF_DIBV5,
nullptr);
474static size_t shadow_clipboard_list_mimes(
const CLIPRDR_FORMAT* formats, UINT32 count,
475 const char* mimes[SHADOW_CLIPBOARD_MAX_OFFER])
479 if (shadow_clipboard_owner_text(formats, count))
481 for (
size_t x = 0; x < ARRAYSIZE(shadow_clipboard_text_mimes); x++)
482 mimes[offered++] = shadow_clipboard_text_mimes[x];
485 if (shadow_clipboard_find_format(formats, count, 0, SHADOW_CLIPBOARD_FORMAT_HTML))
486 mimes[offered++] = SHADOW_CLIPBOARD_MIME_HTML;
488 if (shadow_clipboard_owner_image(formats, count))
490 for (
size_t x = 0; x < ARRAYSIZE(shadow_clipboard_image_formats); x++)
492 const UINT32 image = shadow_clipboard_image_formats[x];
493 const char* mime = winpr_image_format_mime(image);
494 if (mime && winpr_image_format_is_supported(image))
495 mimes[offered++] = mime;
499 WINPR_ASSERT(offered <= SHADOW_CLIPBOARD_MAX_OFFER);
504static BOOL shadow_clipboard_set_owner(rdpShadowClipboard* clipboard, rdpShadowClient* client,
508 WINPR_ASSERT(clipboard);
509 WINPR_ASSERT(client);
516 for (UINT32 x = 0; x < list->numFormats; x++)
519 formats[x].formatId = format->formatId;
520 if (format->formatName)
522 formats[x].formatName = _strdup(format->formatName);
523 if (!formats[x].formatName)
525 shadow_clipboard_formats_free(formats, list->numFormats);
531 shadow_clipboard_cancel_fetches(clipboard,
nullptr);
532 shadow_clipboard_clear_owner(clipboard);
533 clipboard->owner = client;
534 clipboard->ownerFormats = formats;
535 clipboard->nOwnerFormats = list->numFormats;
537 shadow_clipboard_mimes_free(clipboard->sessionMimes, clipboard->nSessionMimes);
538 clipboard->sessionMimes =
nullptr;
539 clipboard->nSessionMimes = 0;
541 shadow_clipboard_announce(clipboard, client);
543 rdpShadowSubsystem* subsystem = shadow_clipboard_subsystem(clipboard);
544 return subsystem->ClipboardOffer(subsystem, mimes, count);
548static UINT shadow_clipboard_client_format_list(CliprdrServerContext* context,
551 WINPR_ASSERT(context);
554 rdpShadowClient* client = context->custom;
555 WINPR_ASSERT(client);
558 response.common.msgType = CB_FORMAT_LIST_RESPONSE;
559 response.common.msgFlags = CB_RESPONSE_OK;
560 const UINT rc = context->ServerFormatListResponse(context, &response);
561 if (rc != CHANNEL_RC_OK)
564 rdpShadowClipboard* clipboard = client->server->clipboard;
565 WINPR_ASSERT(clipboard);
567 EnterCriticalSection(&clipboard->lock);
568 ShadowClipboardPeer* peer = shadow_clipboard_peer(clipboard, client);
569 if (peer && client->mayInteract)
571 const BOOL first = !peer->ready;
574 const char* mimes[SHADOW_CLIPBOARD_MAX_OFFER] = WINPR_C_ARRAY_INIT;
575 const size_t count = shadow_clipboard_list_mimes(list->formats, list->numFormats, mimes);
578 if (!shadow_clipboard_set_owner(clipboard, client, list, mimes, count))
579 WLog_WARN(TAG,
"the session did not take the client's clipboard");
581 else if (clipboard->owner == client)
584 shadow_clipboard_cancel_fetches(clipboard,
nullptr);
585 shadow_clipboard_release_owner(clipboard);
587 else if (first && (clipboard->nSessionMimes > 0))
590 const UINT sent = shadow_clipboard_send_list(clipboard, client);
591 if (sent != CHANNEL_RC_OK)
592 WLog_WARN(TAG,
"ServerFormatList failed with %" PRIu32, sent);
595 LeaveCriticalSection(&clipboard->lock);
596 return CHANNEL_RC_OK;
605static UINT shadow_clipboard_client_capabilities(CliprdrServerContext* context,
608 WINPR_ASSERT(context);
610 rdpShadowClient* client = context->custom;
611 WINPR_ASSERT(client);
612 rdpShadowClipboard* clipboard = client->server->clipboard;
613 WINPR_ASSERT(clipboard);
616 WaitForSingleObject(context->GetEventHandle(context), SHADOW_CLIPBOARD_LIST_WAIT_MS);
617 if (waited != WAIT_TIMEOUT)
618 return CHANNEL_RC_OK;
620 EnterCriticalSection(&clipboard->lock);
621 ShadowClipboardPeer* peer = shadow_clipboard_peer(clipboard, client);
622 if (peer && !peer->ready && client->mayInteract)
625 if (clipboard->nSessionMimes > 0)
627 const UINT sent = shadow_clipboard_send_list(clipboard, client);
628 if (sent != CHANNEL_RC_OK)
629 WLog_WARN(TAG,
"ServerFormatList failed with %" PRIu32, sent);
632 LeaveCriticalSection(&clipboard->lock);
633 return CHANNEL_RC_OK;
637static UINT shadow_clipboard_client_data_request(CliprdrServerContext* context,
640 WINPR_ASSERT(context);
641 WINPR_ASSERT(request);
643 rdpShadowClient* client = context->custom;
644 WINPR_ASSERT(client);
645 rdpShadowClipboard* clipboard = client->server->clipboard;
646 WINPR_ASSERT(clipboard);
649 EnterCriticalSection(&clipboard->lock);
650 const char* mime = shadow_clipboard_session_mime(clipboard, request->requestedFormatId);
651 if (mime && client->mayInteract && shadow_clipboard_peer(clipboard, client))
653 ShadowClipboardRead* read = calloc(1,
sizeof(ShadowClipboardRead));
656 read->client = client;
657 read->formatId = request->requestedFormatId;
658 read->mime = _strdup(mime);
659 queued = read->mime && ArrayList_Append(clipboard->reads, read);
661 shadow_clipboard_read_free(read);
667 shadow_clipboard_read_next(clipboard);
668 LeaveCriticalSection(&clipboard->lock);
671 shadow_clipboard_respond(context,
nullptr, 0);
672 return CHANNEL_RC_OK;
676static UINT shadow_clipboard_client_data_response(CliprdrServerContext* context,
679 WINPR_ASSERT(context);
680 WINPR_ASSERT(response);
682 rdpShadowClient* client = context->custom;
683 WINPR_ASSERT(client);
684 rdpShadowClipboard* clipboard = client->server->clipboard;
685 WINPR_ASSERT(clipboard);
687 EnterCriticalSection(&clipboard->lock);
688 ShadowClipboardFetch* fetch =
689 clipboard->fetchBusy ? ArrayList_GetItem(clipboard->fetches, 0) : nullptr;
690 if (fetch && (fetch->client == client))
692 clipboard->fetchBusy = FALSE;
694 if (!fetch->canceled)
696 const BOOL ok = (response->common.msgFlags & CB_RESPONSE_OK) != 0;
698 BYTE* data =
nullptr;
700 data = shadow_clipboard_convert(clipboard, fetch->sourceId, fetch->mimeId,
701 response->requestedFormatData,
702 response->common.dataLen, &size);
703 WLog_DBG(TAG,
"client data: %" PRIu32
" bytes, %" PRIu32
" for the session",
704 response->common.dataLen, size);
707 if (data && fetch->text)
708 size = WINPR_ASSERTING_INT_CAST(UINT32, strnlen((
const char*)data, size));
709 shadow_clipboard_provide(clipboard, fetch->request, data, size);
713 if (!ArrayList_RemoveAt(clipboard->fetches, 0))
714 WLog_WARN(TAG,
"cannot drop a clipboard request");
715 shadow_clipboard_fetch_next(clipboard);
717 LeaveCriticalSection(&clipboard->lock);
718 return CHANNEL_RC_OK;
723BOOL shadow_clipboard_session_changed(rdpShadowServer* server,
const char*
const* mimeTypes,
726 WINPR_ASSERT(server);
727 WINPR_ASSERT(mimeTypes || (count == 0));
729#if defined(CHANNEL_CLIPRDR_SERVER)
730 rdpShadowClipboard* clipboard = server->clipboard;
734 char** mimes =
nullptr;
737 mimes = (
char**)calloc(count,
sizeof(
char*));
740 for (
size_t x = 0; x < count; x++)
742 mimes[x] = _strdup(mimeTypes[x]);
745 shadow_clipboard_mimes_free(mimes, count);
751 EnterCriticalSection(&clipboard->lock);
752 shadow_clipboard_cancel_fetches(clipboard,
nullptr);
753 shadow_clipboard_clear_owner(clipboard);
754 shadow_clipboard_mimes_free(clipboard->sessionMimes, clipboard->nSessionMimes);
755 clipboard->sessionMimes = mimes;
756 clipboard->nSessionMimes = count;
757 shadow_clipboard_announce(clipboard,
nullptr);
758 LeaveCriticalSection(&clipboard->lock);
765BOOL shadow_clipboard_session_data(rdpShadowServer* server,
const BYTE* data,
size_t size)
767 WINPR_ASSERT(server);
769#if defined(CHANNEL_CLIPRDR_SERVER)
770 rdpShadowClipboard* clipboard = server->clipboard;
775 EnterCriticalSection(&clipboard->lock);
776 const ShadowClipboardRead* read =
777 clipboard->readBusy ? ArrayList_GetItem(clipboard->reads, 0) : nullptr;
781 clipboard->readBusy = FALSE;
785 const UINT32 mimeId = ClipboardRegisterFormat(clipboard->convert, read->mime);
786 UINT32 converted = 0;
788 shadow_clipboard_convert(clipboard, mimeId, read->formatId, data, size, &converted);
789 WLog_DBG(TAG,
"session data: %" PRIuz
" bytes of %s, %" PRIu32
" for the client", size,
790 read->mime, converted);
791 shadow_clipboard_respond(read->client->cliprdr, payload, converted);
795 if (!ArrayList_RemoveAt(clipboard->reads, 0))
796 WLog_WARN(TAG,
"cannot drop a clipboard read");
797 shadow_clipboard_read_next(clipboard);
799 LeaveCriticalSection(&clipboard->lock);
808BOOL shadow_clipboard_session_request(rdpShadowServer* server, UINT32 request,
const char* mimeType)
810 WINPR_ASSERT(server);
811 WINPR_ASSERT(mimeType);
813#if defined(CHANNEL_CLIPRDR_SERVER)
814 rdpShadowClipboard* clipboard = server->clipboard;
818 EnterCriticalSection(&clipboard->lock);
821 ShadowClipboardFetch* first =
822 clipboard->fetchBusy ? ArrayList_GetItem(clipboard->fetches, 0) : nullptr;
823 if (first && (GetTickCount64() - first->sent >= SHADOW_CLIPBOARD_FETCH_TIMEOUT_MS))
825 WLog_WARN(TAG,
"no clipboard data from the client");
826 clipboard->fetchBusy = FALSE;
827 if (!first->canceled)
828 shadow_clipboard_provide(clipboard, first->request,
nullptr, 0);
829 if (!ArrayList_RemoveAt(clipboard->fetches, 0))
830 WLog_WARN(TAG,
"cannot drop a clipboard request");
834 if (clipboard->owner)
837 const UINT32 count = clipboard->nOwnerFormats;
838 if (strcmp(mimeType, SHADOW_CLIPBOARD_MIME_HTML) == 0)
839 source = shadow_clipboard_find_format(formats, count, 0, SHADOW_CLIPBOARD_FORMAT_HTML);
840 else if (strncmp(mimeType,
"image/", 6) == 0)
841 source = shadow_clipboard_owner_image(formats, count);
843 source = shadow_clipboard_owner_text(formats, count);
849 ShadowClipboardFetch* fetch = calloc(1,
sizeof(ShadowClipboardFetch));
852 fetch->client = clipboard->owner;
853 fetch->request = request;
854 fetch->formatId = source->formatId;
855 fetch->sourceId = source->formatName
856 ? ClipboardRegisterFormat(clipboard->convert, source->formatName)
858 fetch->mimeId = ClipboardRegisterFormat(clipboard->convert, mimeType);
859 fetch->text = strncmp(mimeType,
"image/", 6) != 0;
860 queued = ArrayList_Append(clipboard->fetches, fetch);
868 shadow_clipboard_fetch_next(clipboard);
870 shadow_clipboard_provide(clipboard, request,
nullptr, 0);
871 LeaveCriticalSection(&clipboard->lock);
874 WINPR_UNUSED(request);
879#if defined(CHANNEL_CLIPRDR_SERVER)
881rdpShadowClipboard* shadow_clipboard_new(rdpShadowServer* server)
883 WINPR_ASSERT(server);
885 rdpShadowClipboard* clipboard = calloc(1,
sizeof(rdpShadowClipboard));
889 clipboard->server = server;
890 if (!InitializeCriticalSectionAndSpinCount(&clipboard->lock, 4000))
896 clipboard->convert = ClipboardCreate();
897 clipboard->peers = ArrayList_New(FALSE);
898 clipboard->reads = ArrayList_New(FALSE);
899 clipboard->fetches = ArrayList_New(FALSE);
900 if (!clipboard->convert || !clipboard->peers || !clipboard->reads || !clipboard->fetches)
903 wObject* peers = ArrayList_Object(clipboard->peers);
906 wObject* reads = ArrayList_Object(clipboard->reads);
909 wObject* fetches = ArrayList_Object(clipboard->fetches);
910 WINPR_ASSERT(fetches);
913 clipboard->htmlId = ClipboardRegisterFormat(clipboard->convert, SHADOW_CLIPBOARD_FORMAT_HTML);
914 if (clipboard->htmlId == 0)
919 shadow_clipboard_free(clipboard);
923void shadow_clipboard_free(rdpShadowClipboard* clipboard)
928 ArrayList_Free(clipboard->fetches);
929 ArrayList_Free(clipboard->reads);
930 ArrayList_Free(clipboard->peers);
931 shadow_clipboard_formats_free(clipboard->ownerFormats, clipboard->nOwnerFormats);
932 shadow_clipboard_mimes_free(clipboard->sessionMimes, clipboard->nSessionMimes);
933 ClipboardDestroy(clipboard->convert);
934 DeleteCriticalSection(&clipboard->lock);
938int shadow_client_cliprdr_init(rdpShadowClient* client)
940 WINPR_ASSERT(client);
941 WINPR_ASSERT(client->server);
943 rdpShadowClipboard* clipboard = client->server->clipboard;
944 const rdpShadowSubsystem* subsystem = client->subsystem;
945 WINPR_ASSERT(subsystem);
947 if (!clipboard || !subsystem->ClipboardOffer || !subsystem->ClipboardRead ||
948 !subsystem->ClipboardProvide)
951 CliprdrServerContext* cliprdr = cliprdr_server_context_new(client->vcm);
955 cliprdr->custom = client;
956 cliprdr->rdpcontext = &client->context;
957 cliprdr->autoInitializationSequence = TRUE;
958 cliprdr->useLongFormatNames = TRUE;
959 cliprdr->ClientCapabilities = shadow_clipboard_client_capabilities;
960 cliprdr->ClientFormatList = shadow_clipboard_client_format_list;
961 cliprdr->ClientFormatDataRequest = shadow_clipboard_client_data_request;
962 cliprdr->ClientFormatDataResponse = shadow_clipboard_client_data_response;
964 ShadowClipboardPeer* peer = calloc(1,
sizeof(ShadowClipboardPeer));
967 cliprdr_server_context_free(cliprdr);
970 peer->client = client;
971 client->cliprdr = cliprdr;
973 EnterCriticalSection(&clipboard->lock);
974 const BOOL added = ArrayList_Append(clipboard->peers, peer);
975 LeaveCriticalSection(&clipboard->lock);
979 client->cliprdr =
nullptr;
980 cliprdr_server_context_free(cliprdr);
985 const UINT rc = cliprdr->Start(cliprdr);
986 if (rc != CHANNEL_RC_OK)
988 WLog_ERR(TAG,
"cannot start the clipboard channel: %" PRIu32, rc);
994void shadow_client_cliprdr_uninit(rdpShadowClient* client)
996 WINPR_ASSERT(client);
997 WINPR_ASSERT(client->server);
999 CliprdrServerContext* cliprdr = client->cliprdr;
1003 rdpShadowClipboard* clipboard = client->server->clipboard;
1004 WINPR_ASSERT(clipboard);
1006 EnterCriticalSection(&clipboard->lock);
1007 ShadowClipboardPeer* peer = shadow_clipboard_peer(clipboard, client);
1008 if (peer && !ArrayList_Remove(clipboard->peers, peer))
1009 WLog_WARN(TAG,
"cannot drop a client of the clipboard");
1011 for (
size_t x = ArrayList_Count(clipboard->reads); x > 0; x--)
1013 const size_t index = x - 1;
1014 ShadowClipboardRead* read = ArrayList_GetItem(clipboard->reads, index);
1016 if (read->client != client)
1020 if ((index == 0) && clipboard->readBusy)
1021 read->client =
nullptr;
1022 else if (!ArrayList_RemoveAt(clipboard->reads, index))
1023 WLog_WARN(TAG,
"cannot drop a clipboard read");
1026 if (clipboard->owner == client)
1028 shadow_clipboard_cancel_fetches(clipboard, client);
1029 shadow_clipboard_release_owner(clipboard);
1031 else if (clipboard->fetchBusy)
1034 const ShadowClipboardFetch* fetch = ArrayList_GetItem(clipboard->fetches, 0);
1035 if (fetch && (fetch->client == client))
1037 clipboard->fetchBusy = FALSE;
1038 if (!ArrayList_RemoveAt(clipboard->fetches, 0))
1039 WLog_WARN(TAG,
"cannot drop a clipboard request");
1040 shadow_clipboard_fetch_next(clipboard);
1043 LeaveCriticalSection(&clipboard->lock);
1046 const UINT rc = cliprdr->Stop(cliprdr);
1047 if (rc != CHANNEL_RC_OK)
1048 WLog_WARN(TAG,
"cannot stop the clipboard channel: %" PRIu32, rc);
1049 cliprdr_server_context_free(cliprdr);
1050 client->cliprdr =
nullptr;
1055rdpShadowClipboard* shadow_clipboard_new(WINPR_ATTR_UNUSED rdpShadowServer* server)
1060void shadow_clipboard_free(WINPR_ATTR_UNUSED rdpShadowClipboard* clipboard)
1064int shadow_client_cliprdr_init(WINPR_ATTR_UNUSED rdpShadowClient* client)
1069void shadow_client_cliprdr_uninit(WINPR_ATTR_UNUSED rdpShadowClient* client)
This struct contains function pointer to initialize/free objects.
OBJECT_FREE_FN fnObjectFree