FreeRDP
Loading...
Searching...
No Matches
xf_cliprdr.c
1
22#include <freerdp/config.h>
23
24#include <stdlib.h>
25#include <errno.h>
26
27#include <X11/Xlib.h>
28#include <X11/Xatom.h>
29
30#ifdef WITH_XFIXES
31#include <X11/extensions/Xfixes.h>
32#endif
33
34#include <winpr/crt.h>
35#include <winpr/assert.h>
36#include <winpr/image.h>
37#include <winpr/stream.h>
38#include <winpr/clipboard.h>
39#include <winpr/path.h>
40
41#include <freerdp/utils/signal.h>
42#include <freerdp/log.h>
43#include <freerdp/client/cliprdr.h>
44#include <freerdp/channels/channels.h>
45#include <freerdp/channels/cliprdr.h>
46
47#include <freerdp/client/client_cliprdr_file.h>
48
49#include "xf_cliprdr.h"
50#include "xf_event.h"
51#include "xf_utils.h"
52
53#define TAG CLIENT_TAG("x11.cliprdr")
54
55#define MAX_CLIPBOARD_FORMATS 255
56
57#define DEBUG_CLIPRDR(...) WLog_DBG(TAG, __VA_ARGS__)
58
59typedef struct
60{
61 Atom atom;
62 UINT32 formatToRequest;
63 UINT32 localFormat;
64 char* formatName;
65 BOOL isImage;
66} xfCliprdrFormat;
67
68typedef struct
69{
70 BYTE* data;
71 UINT32 data_length;
72} xfCachedData;
73
74typedef struct
75{
76 UINT32 localFormat;
77 UINT32 formatToRequest;
78 char* formatName;
79} RequestedFormat;
80
81struct xf_clipboard
82{
83 xfContext* xfc;
84 rdpChannels* channels;
85 CliprdrClientContext* context;
86
87 wClipboard* system;
88
89 Window root_window;
90 Atom clipboard_atom;
91 Atom property_atom;
92
93 Atom timestamp_property_atom;
94 Time selection_ownership_timestamp;
95
96 Atom raw_transfer_atom;
97 Atom raw_format_list_atom;
98
99 UINT32 numClientFormats;
100 xfCliprdrFormat clientFormats[20];
101
102 UINT32 numServerFormats;
103 CLIPRDR_FORMAT* serverFormats;
104
105 size_t numTargets;
106 Atom targets[20];
107
108 UINT32 requestedFormatId;
109
110 wHashTable* cachedData;
111 wHashTable* cachedRawData;
112
113 BOOL data_raw_format;
114
115 RequestedFormat* requestedFormat;
116
117 XSelectionEvent* respond;
118
119 Window owner;
120 BOOL sync;
121
122 /* INCR mechanism */
123 Atom incr_atom;
124 BOOL incr_starts;
125 BYTE* incr_data;
126 size_t incr_data_length;
127 long event_mask;
128
129 /* XFixes extension */
130 int xfixes_event_base;
131 int xfixes_error_base;
132 BOOL xfixes_supported;
133
134 /* last sent data */
135 CLIPRDR_FORMAT* lastSentFormats;
136 UINT32 lastSentNumFormats;
137 CliprdrFileContext* file;
138 BOOL isImageContent;
139};
140
141static const char mime_text_plain[] = "text/plain";
142static const char mime_uri_list[] = "text/uri-list";
143static const char mime_html[] = "text/html";
144static const char* mime_bitmap[] = { "image/bmp", "image/x-bmp", "image/x-MS-bmp",
145 "image/x-win-bitmap" };
146static const char mime_webp[] = "image/webp";
147static const char mime_png[] = "image/png";
148static const char mime_jpeg[] = "image/jpeg";
149static const char mime_tiff[] = "image/tiff";
150static const char* mime_images[] = { mime_webp, mime_png, mime_jpeg, mime_tiff };
151
152static const char mime_gnome_copied_files[] = "x-special/gnome-copied-files";
153static const char mime_mate_copied_files[] = "x-special/mate-copied-files";
154
155static const char type_FileGroupDescriptorW[] = "FileGroupDescriptorW";
156static const char type_HtmlFormat[] = "HTML Format";
157
158static void xf_cliprdr_clear_cached_data(xfClipboard* clipboard);
159static UINT xf_cliprdr_send_client_format_list(xfClipboard* clipboard, BOOL force);
160static void xf_cliprdr_set_selection_owner(xfContext* xfc, xfClipboard* clipboard, Time timestamp);
161
162static void requested_format_free(RequestedFormat** ppRequestedFormat)
163{
164 if (!ppRequestedFormat)
165 return;
166 if (!(*ppRequestedFormat))
167 return;
168
169 free((*ppRequestedFormat)->formatName);
170 free(*ppRequestedFormat);
171 *ppRequestedFormat = NULL;
172}
173
174static BOOL requested_format_replace(RequestedFormat** ppRequestedFormat, UINT32 remoteFormatId,
175 UINT32 localFormatId, const char* formatName)
176{
177 if (!ppRequestedFormat)
178 return FALSE;
179
180 requested_format_free(ppRequestedFormat);
181 RequestedFormat* requested = calloc(1, sizeof(RequestedFormat));
182 if (!requested)
183 return FALSE;
184 requested->localFormat = localFormatId;
185 requested->formatToRequest = remoteFormatId;
186 if (formatName)
187 {
188 requested->formatName = _strdup(formatName);
189 if (!requested->formatName)
190 {
191 free(requested);
192 return FALSE;
193 }
194 }
195
196 *ppRequestedFormat = requested;
197 return TRUE;
198}
199
200static void xf_cached_data_free(void* ptr)
201{
202 xfCachedData* cached_data = ptr;
203 if (!cached_data)
204 return;
205
206 free(cached_data->data);
207 free(cached_data);
208}
209
210static xfCachedData* xf_cached_data_new(BYTE* data, size_t data_length)
211{
212 if (data_length > UINT32_MAX)
213 return NULL;
214
215 xfCachedData* cached_data = calloc(1, sizeof(xfCachedData));
216 if (!cached_data)
217 return NULL;
218
219 cached_data->data = data;
220 cached_data->data_length = (UINT32)data_length;
221
222 return cached_data;
223}
224
225static xfCachedData* xf_cached_data_new_copy(const BYTE* data, size_t data_length)
226{
227 BYTE* copy = NULL;
228 if (data_length > 0)
229 {
230 copy = calloc(data_length + 1, sizeof(BYTE));
231 if (!copy)
232 return NULL;
233 memcpy(copy, data, data_length);
234 }
235
236 xfCachedData* cache = xf_cached_data_new(copy, data_length);
237 if (!cache)
238 free(copy);
239 return cache;
240}
241
242static void xf_clipboard_free_server_formats(xfClipboard* clipboard)
243{
244 WINPR_ASSERT(clipboard);
245 if (clipboard->serverFormats)
246 {
247 for (size_t i = 0; i < clipboard->numServerFormats; i++)
248 {
249 CLIPRDR_FORMAT* format = &clipboard->serverFormats[i];
250 free(format->formatName);
251 }
252
253 free(clipboard->serverFormats);
254 clipboard->serverFormats = NULL;
255 }
256}
257
258static BOOL xf_cliprdr_update_owner(xfClipboard* clipboard)
259{
260 WINPR_ASSERT(clipboard);
261
262 xfContext* xfc = clipboard->xfc;
263 WINPR_ASSERT(xfc);
264
265 if (!clipboard->sync)
266 return FALSE;
267
268 Window owner = LogDynAndXGetSelectionOwner(xfc->log, xfc->display, clipboard->clipboard_atom);
269 if (clipboard->owner == owner)
270 return FALSE;
271
272 clipboard->owner = owner;
273 return TRUE;
274}
275
276static void xf_cliprdr_check_owner(xfClipboard* clipboard)
277{
278 if (xf_cliprdr_update_owner(clipboard))
279 xf_cliprdr_send_client_format_list(clipboard, FALSE);
280}
281
282static BOOL xf_cliprdr_is_self_owned(xfClipboard* clipboard)
283{
284 xfContext* xfc = NULL;
285
286 WINPR_ASSERT(clipboard);
287
288 xfc = clipboard->xfc;
289 WINPR_ASSERT(xfc);
290 return LogDynAndXGetSelectionOwner(xfc->log, xfc->display, clipboard->clipboard_atom) ==
291 xfc->drawable;
292}
293
294static void xf_cliprdr_set_raw_transfer_enabled(xfClipboard* clipboard, BOOL enabled)
295{
296 UINT32 data = WINPR_ASSERTING_INT_CAST(uint32_t, enabled);
297 xfContext* xfc = NULL;
298
299 WINPR_ASSERT(clipboard);
300
301 xfc = clipboard->xfc;
302 WINPR_ASSERT(xfc);
303 LogDynAndXChangeProperty(xfc->log, xfc->display, xfc->drawable, clipboard->raw_transfer_atom,
304 XA_INTEGER, 32, PropModeReplace, (const BYTE*)&data, 1);
305}
306
307static BOOL xf_cliprdr_is_raw_transfer_available(xfClipboard* clipboard)
308{
309 Atom type = 0;
310 int format = 0;
311 int result = 0;
312 unsigned long length = 0;
313 unsigned long bytes_left = 0;
314 UINT32* data = NULL;
315 UINT32 is_enabled = 0;
316 Window owner = None;
317 xfContext* xfc = NULL;
318
319 WINPR_ASSERT(clipboard);
320
321 xfc = clipboard->xfc;
322 WINPR_ASSERT(xfc);
323
324 owner = LogDynAndXGetSelectionOwner(xfc->log, xfc->display, clipboard->clipboard_atom);
325
326 if (owner != None)
327 {
328 result = LogDynAndXGetWindowProperty(xfc->log, xfc->display, owner,
329 clipboard->raw_transfer_atom, 0, 4, 0, XA_INTEGER,
330 &type, &format, &length, &bytes_left, (BYTE**)&data);
331 }
332
333 if (data)
334 {
335 is_enabled = *data;
336 XFree(data);
337 }
338
339 if ((owner == None) || (owner == xfc->drawable))
340 return FALSE;
341
342 if (result != Success)
343 return FALSE;
344
345 return is_enabled ? TRUE : FALSE;
346}
347
348static BOOL xf_cliprdr_formats_equal(const CLIPRDR_FORMAT* server, const xfCliprdrFormat* client)
349{
350 WINPR_ASSERT(server);
351 WINPR_ASSERT(client);
352
353 if (server->formatName && client->formatName)
354 {
355 /* The server may be using short format names while we store them in full form. */
356 return (0 == strncmp(server->formatName, client->formatName, strlen(server->formatName)));
357 }
358
359 if (!server->formatName && !client->formatName)
360 {
361 return (server->formatId == client->formatToRequest);
362 }
363
364 return FALSE;
365}
366
367static const xfCliprdrFormat* xf_cliprdr_get_client_format_by_id(xfClipboard* clipboard,
368 UINT32 formatId)
369{
370 WINPR_ASSERT(clipboard);
371
372 const BOOL formatIsHtml = formatId == ClipboardGetFormatId(clipboard->system, type_HtmlFormat);
373 const BOOL fetchImage = clipboard->isImageContent && formatIsHtml;
374 for (size_t index = 0; index < clipboard->numClientFormats; index++)
375 {
376 const xfCliprdrFormat* format = &(clipboard->clientFormats[index]);
377
378 if (fetchImage && format->isImage)
379 return format;
380
381 if (format->formatToRequest == formatId)
382 return format;
383 }
384
385 return NULL;
386}
387
388static const xfCliprdrFormat* xf_cliprdr_get_client_format_by_atom(xfClipboard* clipboard,
389 Atom atom)
390{
391 WINPR_ASSERT(clipboard);
392
393 for (UINT32 i = 0; i < clipboard->numClientFormats; i++)
394 {
395 const xfCliprdrFormat* format = &(clipboard->clientFormats[i]);
396
397 if (format->atom == atom)
398 return format;
399 }
400
401 return NULL;
402}
403
404static const CLIPRDR_FORMAT* xf_cliprdr_get_server_format_by_atom(xfClipboard* clipboard, Atom atom)
405{
406 WINPR_ASSERT(clipboard);
407
408 for (size_t i = 0; i < clipboard->numClientFormats; i++)
409 {
410 const xfCliprdrFormat* client_format = &(clipboard->clientFormats[i]);
411
412 if (client_format->atom == atom)
413 {
414 for (size_t j = 0; j < clipboard->numServerFormats; j++)
415 {
416 const CLIPRDR_FORMAT* server_format = &(clipboard->serverFormats[j]);
417
418 if (xf_cliprdr_formats_equal(server_format, client_format))
419 return server_format;
420 }
421 }
422 }
423
424 return NULL;
425}
426
432static UINT xf_cliprdr_send_data_request(xfClipboard* clipboard, UINT32 formatId,
433 WINPR_ATTR_UNUSED const xfCliprdrFormat* cformat)
434{
435 CLIPRDR_FORMAT_DATA_REQUEST request = { 0 };
436 request.requestedFormatId = formatId;
437
438 DEBUG_CLIPRDR("requesting format 0x%08" PRIx32 " [%s] {local 0x%08" PRIx32 "} [%s]", formatId,
439 ClipboardGetFormatIdString(formatId), cformat->localFormat, cformat->formatName);
440
441 WINPR_ASSERT(clipboard);
442 WINPR_ASSERT(clipboard->context);
443 WINPR_ASSERT(clipboard->context->ClientFormatDataRequest);
444 return clipboard->context->ClientFormatDataRequest(clipboard->context, &request);
445}
446
452static UINT xf_cliprdr_send_data_response(xfClipboard* clipboard, const xfCliprdrFormat* format,
453 const BYTE* data, size_t size)
454{
455 CLIPRDR_FORMAT_DATA_RESPONSE response = { 0 };
456
457 WINPR_ASSERT(clipboard);
458
459 /* No request currently pending, do not send a response. */
460 if (clipboard->requestedFormatId == UINT32_MAX)
461 return CHANNEL_RC_OK;
462
463 if (size == 0)
464 {
465 if (format)
466 DEBUG_CLIPRDR("send CB_RESPONSE_FAIL response {format 0x%08" PRIx32
467 " [%s] {local 0x%08" PRIx32 "} [%s]",
468 format->formatToRequest,
469 ClipboardGetFormatIdString(format->formatToRequest), format->localFormat,
470 format->formatName);
471 else
472 DEBUG_CLIPRDR("send CB_RESPONSE_FAIL response");
473 }
474 else
475 {
476 WINPR_ASSERT(format);
477 DEBUG_CLIPRDR("send response format 0x%08" PRIx32 " [%s] {local 0x%08" PRIx32 " [%s]} [%s]",
478 format->formatToRequest, ClipboardGetFormatIdString(format->formatToRequest),
479 format->localFormat,
480 ClipboardGetFormatName(clipboard->system, format->localFormat),
481 format->formatName);
482 }
483 /* Request handled, reset to invalid */
484 clipboard->requestedFormatId = UINT32_MAX;
485
486 response.common.msgFlags = (data) ? CB_RESPONSE_OK : CB_RESPONSE_FAIL;
487
488 WINPR_ASSERT(size <= UINT32_MAX);
489 response.common.dataLen = (UINT32)size;
490 response.requestedFormatData = data;
491
492 WINPR_ASSERT(clipboard->context);
493 WINPR_ASSERT(clipboard->context->ClientFormatDataResponse);
494 return clipboard->context->ClientFormatDataResponse(clipboard->context, &response);
495}
496
497static wStream* xf_cliprdr_serialize_server_format_list(xfClipboard* clipboard)
498{
499 UINT32 formatCount = 0;
500 wStream* s = NULL;
501
502 WINPR_ASSERT(clipboard);
503
504 /* Typical MS Word format list is about 80 bytes long. */
505 if (!(s = Stream_New(NULL, 128)))
506 {
507 WLog_ERR(TAG, "failed to allocate serialized format list");
508 goto error;
509 }
510
511 /* If present, the last format is always synthetic CF_RAW. Do not include it. */
512 formatCount = (clipboard->numServerFormats > 0) ? clipboard->numServerFormats - 1 : 0;
513 Stream_Write_UINT32(s, formatCount);
514
515 for (UINT32 i = 0; i < formatCount; i++)
516 {
517 CLIPRDR_FORMAT* format = &clipboard->serverFormats[i];
518 size_t name_length = format->formatName ? strlen(format->formatName) : 0;
519
520 DEBUG_CLIPRDR("server announced 0x%08" PRIx32 " [%s][%s]", format->formatId,
521 ClipboardGetFormatIdString(format->formatId), format->formatName);
522 if (!Stream_EnsureRemainingCapacity(s, sizeof(UINT32) + name_length + 1))
523 {
524 WLog_ERR(TAG, "failed to expand serialized format list");
525 goto error;
526 }
527
528 Stream_Write_UINT32(s, format->formatId);
529
530 if (format->formatName)
531 Stream_Write(s, format->formatName, name_length);
532
533 Stream_Write_UINT8(s, '\0');
534 }
535
536 Stream_SealLength(s);
537 return s;
538error:
539 Stream_Free(s, TRUE);
540 return NULL;
541}
542
543static CLIPRDR_FORMAT* xf_cliprdr_parse_server_format_list(BYTE* data, size_t length,
544 UINT32* numFormats)
545{
546 wStream* s = NULL;
547 CLIPRDR_FORMAT* formats = NULL;
548
549 WINPR_ASSERT(data || (length == 0));
550 WINPR_ASSERT(numFormats);
551
552 if (!(s = Stream_New(data, length)))
553 {
554 WLog_ERR(TAG, "failed to allocate stream for parsing serialized format list");
555 goto error;
556 }
557
558 if (!Stream_CheckAndLogRequiredLength(TAG, s, sizeof(UINT32)))
559 goto error;
560
561 Stream_Read_UINT32(s, *numFormats);
562
563 if (*numFormats > MAX_CLIPBOARD_FORMATS)
564 {
565 WLog_ERR(TAG, "unexpectedly large number of formats: %" PRIu32 "", *numFormats);
566 goto error;
567 }
568
569 if (!(formats = (CLIPRDR_FORMAT*)calloc(*numFormats, sizeof(CLIPRDR_FORMAT))))
570 {
571 WLog_ERR(TAG, "failed to allocate format list");
572 goto error;
573 }
574
575 for (UINT32 i = 0; i < *numFormats; i++)
576 {
577 const char* formatName = NULL;
578 size_t formatNameLength = 0;
579
580 if (!Stream_CheckAndLogRequiredLength(TAG, s, sizeof(UINT32)))
581 goto error;
582
583 Stream_Read_UINT32(s, formats[i].formatId);
584 formatName = (const char*)Stream_Pointer(s);
585 formatNameLength = strnlen(formatName, Stream_GetRemainingLength(s));
586
587 if (formatNameLength == Stream_GetRemainingLength(s))
588 {
589 WLog_ERR(TAG, "missing terminating null byte, %" PRIuz " bytes left to read",
590 formatNameLength);
591 goto error;
592 }
593
594 formats[i].formatName = strndup(formatName, formatNameLength);
595 Stream_Seek(s, formatNameLength + 1);
596 }
597
598 Stream_Free(s, FALSE);
599 return formats;
600error:
601 Stream_Free(s, FALSE);
602 free(formats);
603 *numFormats = 0;
604 return NULL;
605}
606
607static void xf_cliprdr_free_formats(CLIPRDR_FORMAT* formats, UINT32 numFormats)
608{
609 WINPR_ASSERT(formats || (numFormats == 0));
610
611 for (UINT32 i = 0; i < numFormats; i++)
612 {
613 free(formats[i].formatName);
614 }
615
616 free(formats);
617}
618
619static CLIPRDR_FORMAT* xf_cliprdr_get_raw_server_formats(xfClipboard* clipboard, UINT32* numFormats)
620{
621 Atom type = None;
622 int format = 0;
623 unsigned long length = 0;
624 unsigned long remaining = 0;
625 BYTE* data = NULL;
626 CLIPRDR_FORMAT* formats = NULL;
627 xfContext* xfc = NULL;
628
629 WINPR_ASSERT(clipboard);
630 WINPR_ASSERT(numFormats);
631
632 xfc = clipboard->xfc;
633 WINPR_ASSERT(xfc);
634
635 *numFormats = 0;
636
637 Window owner = LogDynAndXGetSelectionOwner(xfc->log, xfc->display, clipboard->clipboard_atom);
638 LogDynAndXGetWindowProperty(xfc->log, xfc->display, owner, clipboard->raw_format_list_atom, 0,
639 4096, False, clipboard->raw_format_list_atom, &type, &format,
640 &length, &remaining, &data);
641
642 if (data && length > 0 && format == 8 && type == clipboard->raw_format_list_atom)
643 {
644 formats = xf_cliprdr_parse_server_format_list(data, length, numFormats);
645 }
646 else
647 {
648 WLog_ERR(TAG,
649 "failed to retrieve raw format list: data=%p, length=%lu, format=%d, type=%lu "
650 "(expected=%lu)",
651 (void*)data, length, format, (unsigned long)type,
652 (unsigned long)clipboard->raw_format_list_atom);
653 }
654
655 if (data)
656 XFree(data);
657
658 return formats;
659}
660
661static BOOL xf_cliprdr_should_add_format(const CLIPRDR_FORMAT* formats, size_t count,
662 const xfCliprdrFormat* xformat)
663{
664 WINPR_ASSERT(formats);
665
666 if (!xformat)
667 return FALSE;
668
669 for (size_t x = 0; x < count; x++)
670 {
671 const CLIPRDR_FORMAT* format = &formats[x];
672 if (format->formatId == xformat->formatToRequest)
673 return FALSE;
674 }
675 return TRUE;
676}
677
678static CLIPRDR_FORMAT* xf_cliprdr_get_formats_from_targets(xfClipboard* clipboard,
679 UINT32* numFormats)
680{
681 Atom atom = None;
682 BYTE* data = NULL;
683 int format_property = 0;
684 unsigned long proplength = 0;
685 unsigned long bytes_left = 0;
686 CLIPRDR_FORMAT* formats = NULL;
687
688 WINPR_ASSERT(clipboard);
689 WINPR_ASSERT(numFormats);
690
691 xfContext* xfc = clipboard->xfc;
692 WINPR_ASSERT(xfc);
693
694 *numFormats = 0;
695 LogDynAndXGetWindowProperty(xfc->log, xfc->display, xfc->drawable, clipboard->property_atom, 0,
696 200, 0, XA_ATOM, &atom, &format_property, &proplength, &bytes_left,
697 &data);
698
699 if (proplength > 0)
700 {
701 unsigned long length = proplength + 1;
702 if (!data)
703 {
704 WLog_ERR(TAG, "XGetWindowProperty set length = %lu but data is NULL", length);
705 goto out;
706 }
707
708 if (!(formats = (CLIPRDR_FORMAT*)calloc(length, sizeof(CLIPRDR_FORMAT))))
709 {
710 WLog_ERR(TAG, "failed to allocate %lu CLIPRDR_FORMAT structs", length);
711 goto out;
712 }
713 }
714
715 {
716 BOOL isImage = FALSE;
717 BOOL hasHtml = FALSE;
718 const uint32_t htmlFormatId = ClipboardRegisterFormat(clipboard->system, type_HtmlFormat);
719 for (unsigned long i = 0; i < proplength; i++)
720 {
721 Atom tatom = ((Atom*)data)[i];
722 const xfCliprdrFormat* format = xf_cliprdr_get_client_format_by_atom(clipboard, tatom);
723
724 if (xf_cliprdr_should_add_format(formats, *numFormats, format))
725 {
726 CLIPRDR_FORMAT* cformat = &formats[*numFormats];
727 cformat->formatId = format->formatToRequest;
728
729 /* We do not want to double register a format, so check if HTML was already
730 * registered.
731 */
732 if (cformat->formatId == htmlFormatId)
733 hasHtml = TRUE;
734
735 /* These are standard image types that will always be registered regardless of
736 * actual image format. */
737 if (cformat->formatId == CF_TIFF)
738 isImage = TRUE;
739 else if (cformat->formatId == CF_DIB)
740 isImage = TRUE;
741 else if (cformat->formatId == CF_DIBV5)
742 isImage = TRUE;
743
744 if (format->formatName)
745 {
746 cformat->formatName = _strdup(format->formatName);
747 WINPR_ASSERT(cformat->formatName);
748 }
749 else
750 cformat->formatName = NULL;
751
752 *numFormats += 1;
753 }
754 }
755
756 clipboard->isImageContent = isImage;
757 if (isImage && !hasHtml)
758 {
759 CLIPRDR_FORMAT* cformat = &formats[*numFormats];
760 cformat->formatId = htmlFormatId;
761 cformat->formatName = _strdup(type_HtmlFormat);
762
763 *numFormats += 1;
764 }
765 }
766out:
767
768 if (data)
769 XFree(data);
770
771 return formats;
772}
773
774static CLIPRDR_FORMAT* xf_cliprdr_get_client_formats(xfClipboard* clipboard, UINT32* numFormats)
775{
776 CLIPRDR_FORMAT* formats = NULL;
777
778 WINPR_ASSERT(clipboard);
779 WINPR_ASSERT(numFormats);
780
781 *numFormats = 0;
782
783 if (xf_cliprdr_is_raw_transfer_available(clipboard))
784 {
785 formats = xf_cliprdr_get_raw_server_formats(clipboard, numFormats);
786 }
787
788 if (*numFormats == 0)
789 {
790 xf_cliprdr_free_formats(formats, *numFormats);
791 formats = xf_cliprdr_get_formats_from_targets(clipboard, numFormats);
792 }
793
794 return formats;
795}
796
797static void xf_cliprdr_provide_server_format_list(xfClipboard* clipboard)
798{
799 wStream* formats = NULL;
800 xfContext* xfc = NULL;
801
802 WINPR_ASSERT(clipboard);
803
804 xfc = clipboard->xfc;
805 WINPR_ASSERT(xfc);
806
807 formats = xf_cliprdr_serialize_server_format_list(clipboard);
808
809 if (formats)
810 {
811 const size_t len = Stream_Length(formats);
812 WINPR_ASSERT(len <= INT32_MAX);
813 LogDynAndXChangeProperty(xfc->log, xfc->display, xfc->drawable,
814 clipboard->raw_format_list_atom, clipboard->raw_format_list_atom,
815 8, PropModeReplace, Stream_Buffer(formats), (int)len);
816 }
817 else
818 {
819 LogDynAndXDeleteProperty(xfc->log, xfc->display, xfc->drawable,
820 clipboard->raw_format_list_atom);
821 }
822
823 Stream_Free(formats, TRUE);
824}
825
826static BOOL xf_clipboard_format_equal(const CLIPRDR_FORMAT* a, const CLIPRDR_FORMAT* b)
827{
828 WINPR_ASSERT(a);
829 WINPR_ASSERT(b);
830
831 if (a->formatId != b->formatId)
832 return FALSE;
833 if (!a->formatName && !b->formatName)
834 return TRUE;
835 if (!a->formatName || !b->formatName)
836 return FALSE;
837 return strcmp(a->formatName, b->formatName) == 0;
838}
839
840static BOOL xf_clipboard_changed(xfClipboard* clipboard, const CLIPRDR_FORMAT* formats,
841 UINT32 numFormats)
842{
843 WINPR_ASSERT(clipboard);
844 WINPR_ASSERT(formats || (numFormats == 0));
845
846 if (clipboard->lastSentNumFormats != numFormats)
847 return TRUE;
848
849 for (UINT32 x = 0; x < numFormats; x++)
850 {
851 const CLIPRDR_FORMAT* cur = &clipboard->lastSentFormats[x];
852 BOOL contained = FALSE;
853 for (UINT32 y = 0; y < numFormats; y++)
854 {
855 if (xf_clipboard_format_equal(cur, &formats[y]))
856 {
857 contained = TRUE;
858 break;
859 }
860 }
861 if (!contained)
862 return TRUE;
863 }
864
865 return FALSE;
866}
867
868static void xf_clipboard_formats_free(xfClipboard* clipboard)
869{
870 WINPR_ASSERT(clipboard);
871
872 xf_cliprdr_free_formats(clipboard->lastSentFormats, clipboard->lastSentNumFormats);
873 clipboard->lastSentFormats = NULL;
874 clipboard->lastSentNumFormats = 0;
875}
876
877static BOOL xf_clipboard_copy_formats(xfClipboard* clipboard, const CLIPRDR_FORMAT* formats,
878 UINT32 numFormats)
879{
880 WINPR_ASSERT(clipboard);
881 WINPR_ASSERT(formats || (numFormats == 0));
882
883 xf_clipboard_formats_free(clipboard);
884 if (numFormats > 0)
885 clipboard->lastSentFormats = calloc(numFormats, sizeof(CLIPRDR_FORMAT));
886 if (!clipboard->lastSentFormats)
887 return FALSE;
888 clipboard->lastSentNumFormats = numFormats;
889 for (UINT32 x = 0; x < numFormats; x++)
890 {
891 CLIPRDR_FORMAT* lcur = &clipboard->lastSentFormats[x];
892 const CLIPRDR_FORMAT* cur = &formats[x];
893 *lcur = *cur;
894 if (cur->formatName)
895 lcur->formatName = _strdup(cur->formatName);
896 }
897 return FALSE;
898}
899
900static UINT xf_cliprdr_send_format_list(xfClipboard* clipboard, const CLIPRDR_FORMAT* formats,
901 UINT32 numFormats, BOOL force)
902{
903 union
904 {
905 const CLIPRDR_FORMAT* cpv;
906 CLIPRDR_FORMAT* pv;
907 } cnv = { .cpv = formats };
908 const CLIPRDR_FORMAT_LIST formatList = { .common.msgFlags = 0,
909 .numFormats = numFormats,
910 .formats = cnv.pv,
911 .common.msgType = CB_FORMAT_LIST };
912 UINT ret = 0;
913
914 WINPR_ASSERT(clipboard);
915 WINPR_ASSERT(formats || (numFormats == 0));
916
917 if (!force && !xf_clipboard_changed(clipboard, formats, numFormats))
918 return CHANNEL_RC_OK;
919
920#if defined(WITH_DEBUG_CLIPRDR)
921 for (UINT32 x = 0; x < numFormats; x++)
922 {
923 const CLIPRDR_FORMAT* format = &formats[x];
924 DEBUG_CLIPRDR("announcing format 0x%08" PRIx32 " [%s] [%s]", format->formatId,
925 ClipboardGetFormatIdString(format->formatId), format->formatName);
926 }
927#endif
928
929 xf_clipboard_copy_formats(clipboard, formats, numFormats);
930 /* Ensure all pending requests are answered. */
931 xf_cliprdr_send_data_response(clipboard, NULL, NULL, 0);
932
933 xf_cliprdr_clear_cached_data(clipboard);
934
935 ret = cliprdr_file_context_notify_new_client_format_list(clipboard->file);
936 if (ret)
937 return ret;
938
939 WINPR_ASSERT(clipboard->context);
940 WINPR_ASSERT(clipboard->context->ClientFormatList);
941 return clipboard->context->ClientFormatList(clipboard->context, &formatList);
942}
943
944static void xf_cliprdr_get_requested_targets(xfClipboard* clipboard)
945{
946 UINT32 numFormats = 0;
947 CLIPRDR_FORMAT* formats = xf_cliprdr_get_client_formats(clipboard, &numFormats);
948 xf_cliprdr_send_format_list(clipboard, formats, numFormats, FALSE);
949 xf_cliprdr_free_formats(formats, numFormats);
950}
951
952static void xf_cliprdr_process_requested_data(xfClipboard* clipboard, BOOL hasData,
953 const BYTE* data, size_t size)
954{
955 BOOL bSuccess = 0;
956 UINT32 SrcSize = 0;
957 UINT32 DstSize = 0;
958 INT64 srcFormatId = -1;
959 BYTE* pDstData = NULL;
960 const xfCliprdrFormat* format = NULL;
961
962 WINPR_ASSERT(clipboard);
963
964 if (clipboard->incr_starts && hasData)
965 return;
966
967 /* Reset incr_data_length, as we've reached the end of a possible incremental update.
968 * this ensures on next event that the buffer is not reused. */
969 clipboard->incr_data_length = 0;
970
971 format = xf_cliprdr_get_client_format_by_id(clipboard, clipboard->requestedFormatId);
972
973 if (!hasData || !data || !format)
974 {
975 xf_cliprdr_send_data_response(clipboard, format, NULL, 0);
976 return;
977 }
978
979 switch (format->formatToRequest)
980 {
981 case CF_RAW:
982 srcFormatId = CF_RAW;
983 break;
984
985 case CF_TEXT:
986 case CF_OEMTEXT:
987 case CF_UNICODETEXT:
988 srcFormatId = format->localFormat;
989 break;
990
991 default:
992 srcFormatId = format->localFormat;
993 break;
994 }
995
996 if (srcFormatId < 0)
997 {
998 xf_cliprdr_send_data_response(clipboard, format, NULL, 0);
999 return;
1000 }
1001
1002 ClipboardLock(clipboard->system);
1003 SrcSize = (UINT32)size;
1004 bSuccess = ClipboardSetData(clipboard->system, (UINT32)srcFormatId, data, SrcSize);
1005
1006 if (bSuccess)
1007 {
1008 DstSize = 0;
1009 pDstData =
1010 (BYTE*)ClipboardGetData(clipboard->system, clipboard->requestedFormatId, &DstSize);
1011 }
1012 ClipboardUnlock(clipboard->system);
1013
1014 if (!pDstData)
1015 {
1016 xf_cliprdr_send_data_response(clipboard, format, NULL, 0);
1017 return;
1018 }
1019
1020 /*
1021 * File lists require a bit of postprocessing to convert them from WinPR's FILDESCRIPTOR
1022 * format to CLIPRDR_FILELIST expected by the server.
1023 *
1024 * We check for "FileGroupDescriptorW" format being registered (i.e., nonzero) in order
1025 * to not process CF_RAW as a file list in case WinPR does not support file transfers.
1026 */
1027 ClipboardLock(clipboard->system);
1028 if (format->formatToRequest &&
1029 (format->formatToRequest ==
1030 ClipboardGetFormatId(clipboard->system, type_FileGroupDescriptorW)))
1031 {
1032 UINT error = NO_ERROR;
1033 FILEDESCRIPTORW* file_array = (FILEDESCRIPTORW*)pDstData;
1034 UINT32 file_count = DstSize / sizeof(FILEDESCRIPTORW);
1035 pDstData = NULL;
1036 DstSize = 0;
1037
1038 const UINT32 flags = cliprdr_file_context_remote_get_flags(clipboard->file);
1039 error = cliprdr_serialize_file_list_ex(flags, file_array, file_count, &pDstData, &DstSize);
1040
1041 if (error)
1042 WLog_ERR(TAG, "failed to serialize CLIPRDR_FILELIST: 0x%08X", error);
1043 else
1044 {
1045 UINT32 formatId = ClipboardGetFormatId(clipboard->system, mime_uri_list);
1046 UINT32 url_size = 0;
1047
1048 char* url = ClipboardGetData(clipboard->system, formatId, &url_size);
1049 cliprdr_file_context_update_client_data(clipboard->file, url, url_size);
1050 free(url);
1051 }
1052
1053 free(file_array);
1054 }
1055 ClipboardUnlock(clipboard->system);
1056
1057 xf_cliprdr_send_data_response(clipboard, format, pDstData, DstSize);
1058 free(pDstData);
1059}
1060
1061static BOOL xf_restore_input_flags(xfClipboard* clipboard)
1062{
1063 WINPR_ASSERT(clipboard);
1064
1065 xfContext* xfc = clipboard->xfc;
1066 WINPR_ASSERT(xfc);
1067
1068 if (clipboard->event_mask != 0)
1069 {
1070 XSelectInput(xfc->display, xfc->drawable, clipboard->event_mask);
1071 clipboard->event_mask = 0;
1072 }
1073 return TRUE;
1074}
1075
1076static BOOL append(xfClipboard* clipboard, const void* sdata, size_t length)
1077{
1078 WINPR_ASSERT(clipboard);
1079
1080 const size_t size = length + clipboard->incr_data_length + 2;
1081 BYTE* data = realloc(clipboard->incr_data, size);
1082 if (!data)
1083 return FALSE;
1084 clipboard->incr_data = data;
1085 memcpy(&data[clipboard->incr_data_length], sdata, length);
1086 clipboard->incr_data_length += length;
1087 clipboard->incr_data[clipboard->incr_data_length + 0] = '\0';
1088 clipboard->incr_data[clipboard->incr_data_length + 1] = '\0';
1089 return TRUE;
1090}
1091
1092static BOOL xf_cliprdr_stop_incr(xfClipboard* clipboard)
1093{
1094 clipboard->incr_starts = FALSE;
1095 clipboard->incr_data_length = 0;
1096 return xf_restore_input_flags(clipboard);
1097}
1098
1099static BOOL xf_cliprdr_get_requested_data(xfClipboard* clipboard, Atom target)
1100{
1101 WINPR_ASSERT(clipboard);
1102
1103 xfContext* xfc = clipboard->xfc;
1104 WINPR_ASSERT(xfc);
1105
1106 const xfCliprdrFormat* format =
1107 xf_cliprdr_get_client_format_by_id(clipboard, clipboard->requestedFormatId);
1108
1109 if (!format || (format->atom != target))
1110 {
1111 xf_cliprdr_send_data_response(clipboard, format, NULL, 0);
1112 return FALSE;
1113 }
1114
1115 Atom type = 0;
1116 BOOL has_data = FALSE;
1117 int format_property = 0;
1118 unsigned long length = 0;
1119 unsigned long total_bytes = 0;
1120 BYTE* property_data = NULL;
1121 const int rc = LogDynAndXGetWindowProperty(
1122 xfc->log, xfc->display, xfc->drawable, clipboard->property_atom, 0, 0, False, target, &type,
1123 &format_property, &length, &total_bytes, &property_data);
1124 if (rc != Success)
1125 {
1126 xf_cliprdr_send_data_response(clipboard, format, NULL, 0);
1127 return FALSE;
1128 }
1129
1130 size_t len = 0;
1131
1132 /* No data, empty return */
1133 if ((total_bytes <= 0) && !clipboard->incr_starts)
1134 {
1135 xf_cliprdr_stop_incr(clipboard);
1136 }
1137 /* We have to read incremental updates */
1138 else if (type == clipboard->incr_atom)
1139 {
1140 xf_cliprdr_stop_incr(clipboard);
1141 clipboard->incr_starts = TRUE;
1142 has_data = TRUE; /* data will follow in PropertyNotify event */
1143 }
1144 else
1145 {
1146 BYTE* incremental_data = NULL;
1147 unsigned long incremental_len = 0;
1148
1149 /* Incremental updates completed, pass data */
1150 len = clipboard->incr_data_length;
1151 if (total_bytes <= 0)
1152 {
1153 xf_cliprdr_stop_incr(clipboard);
1154 has_data = TRUE;
1155 }
1156 /* Read incremental data batch */
1157 else if (LogDynAndXGetWindowProperty(
1158 xfc->log, xfc->display, xfc->drawable, clipboard->property_atom, 0,
1159 WINPR_ASSERTING_INT_CAST(int32_t, total_bytes), False, target, &type,
1160 &format_property, &incremental_len, &length, &incremental_data) == Success)
1161 {
1162 has_data = append(clipboard, incremental_data, incremental_len);
1163 len = clipboard->incr_data_length;
1164 }
1165
1166 if (incremental_data)
1167 XFree(incremental_data);
1168 }
1169
1170 LogDynAndXDeleteProperty(xfc->log, xfc->display, xfc->drawable, clipboard->property_atom);
1171 xf_cliprdr_process_requested_data(clipboard, has_data, clipboard->incr_data, len);
1172
1173 return TRUE;
1174}
1175
1176static void xf_cliprdr_append_target(xfClipboard* clipboard, Atom target)
1177{
1178 WINPR_ASSERT(clipboard);
1179
1180 if (clipboard->numTargets >= ARRAYSIZE(clipboard->targets))
1181 return;
1182
1183 for (size_t i = 0; i < clipboard->numTargets; i++)
1184 {
1185 if (clipboard->targets[i] == target)
1186 return;
1187 }
1188
1189 clipboard->targets[clipboard->numTargets++] = target;
1190}
1191
1192static void xf_cliprdr_provide_targets(xfClipboard* clipboard, const XSelectionEvent* respond)
1193{
1194 xfContext* xfc = NULL;
1195
1196 WINPR_ASSERT(clipboard);
1197
1198 xfc = clipboard->xfc;
1199 WINPR_ASSERT(xfc);
1200
1201 if (respond->property != None)
1202 {
1203 WINPR_ASSERT(clipboard->numTargets <= INT32_MAX);
1204 LogDynAndXChangeProperty(xfc->log, xfc->display, respond->requestor, respond->property,
1205 XA_ATOM, 32, PropModeReplace, (const BYTE*)clipboard->targets,
1206 (int)clipboard->numTargets);
1207 }
1208}
1209
1210static void xf_cliprdr_provide_timestamp(xfClipboard* clipboard, const XSelectionEvent* respond)
1211{
1212 xfContext* xfc = NULL;
1213
1214 WINPR_ASSERT(clipboard);
1215
1216 xfc = clipboard->xfc;
1217 WINPR_ASSERT(xfc);
1218
1219 if (respond->property != None)
1220 {
1221 LogDynAndXChangeProperty(xfc->log, xfc->display, respond->requestor, respond->property,
1222 XA_INTEGER, 32, PropModeReplace,
1223 (const BYTE*)&clipboard->selection_ownership_timestamp, 1);
1224 }
1225}
1226
1227#define xf_cliprdr_provide_data(clipboard, respond, data, size) \
1228 xf_cliprdr_provide_data_((clipboard), (respond), (data), (size), __FILE__, __func__, __LINE__)
1229static void xf_cliprdr_provide_data_(xfClipboard* clipboard, const XSelectionEvent* respond,
1230 const BYTE* data, UINT32 size, const char* file,
1231 const char* fkt, size_t line)
1232{
1233 WINPR_ASSERT(clipboard);
1234
1235 xfContext* xfc = clipboard->xfc;
1236 WINPR_ASSERT(xfc);
1237
1238 if (respond->property != None)
1239 {
1240 LogDynAndXChangeProperty_ex(xfc->log, file, fkt, line, xfc->display, respond->requestor,
1241 respond->property, respond->target, 8, PropModeReplace, data,
1242 WINPR_ASSERTING_INT_CAST(int32_t, size));
1243 }
1244}
1245
1246static void log_selection_event(xfContext* xfc, const XEvent* event)
1247{
1248 const DWORD level = WLOG_TRACE;
1249 static wLog* _log_cached_ptr = NULL;
1250 if (!_log_cached_ptr)
1251 _log_cached_ptr = WLog_Get(TAG);
1252 if (WLog_IsLevelActive(_log_cached_ptr, level))
1253 {
1254
1255 switch (event->type)
1256 {
1257 case SelectionClear:
1258 {
1259 const XSelectionClearEvent* xevent = &event->xselectionclear;
1260 char* selection =
1261 Safe_XGetAtomName(_log_cached_ptr, xfc->display, xevent->selection);
1262 WLog_Print(_log_cached_ptr, level, "got event %s [selection %s]",
1263 x11_event_string(event->type), selection);
1264 XFree(selection);
1265 }
1266 break;
1267 case SelectionNotify:
1268 {
1269 const XSelectionEvent* xevent = &event->xselection;
1270 char* selection =
1271 Safe_XGetAtomName(_log_cached_ptr, xfc->display, xevent->selection);
1272 char* target = Safe_XGetAtomName(_log_cached_ptr, xfc->display, xevent->target);
1273 char* property = Safe_XGetAtomName(_log_cached_ptr, xfc->display, xevent->property);
1274 WLog_Print(_log_cached_ptr, level,
1275 "got event %s [selection %s, target %s, property %s]",
1276 x11_event_string(event->type), selection, target, property);
1277 XFree(selection);
1278 XFree(target);
1279 XFree(property);
1280 }
1281 break;
1282 case SelectionRequest:
1283 {
1284 const XSelectionRequestEvent* xevent = &event->xselectionrequest;
1285 char* selection =
1286 Safe_XGetAtomName(_log_cached_ptr, xfc->display, xevent->selection);
1287 char* target = Safe_XGetAtomName(_log_cached_ptr, xfc->display, xevent->target);
1288 char* property = Safe_XGetAtomName(_log_cached_ptr, xfc->display, xevent->property);
1289 WLog_Print(_log_cached_ptr, level,
1290 "got event %s [selection %s, target %s, property %s]",
1291 x11_event_string(event->type), selection, target, property);
1292 XFree(selection);
1293 XFree(target);
1294 XFree(property);
1295 }
1296 break;
1297 case PropertyNotify:
1298 {
1299 const XPropertyEvent* xevent = &event->xproperty;
1300 char* atom = Safe_XGetAtomName(_log_cached_ptr, xfc->display, xevent->atom);
1301 WLog_Print(_log_cached_ptr, level, "got event %s [atom %s]",
1302 x11_event_string(event->type), atom);
1303 XFree(atom);
1304 }
1305 break;
1306 default:
1307 break;
1308 }
1309 }
1310}
1311
1312static BOOL xf_cliprdr_process_selection_notify(xfClipboard* clipboard,
1313 const XSelectionEvent* xevent)
1314{
1315 WINPR_ASSERT(clipboard);
1316 WINPR_ASSERT(xevent);
1317
1318 if (xevent->target == clipboard->targets[1])
1319 {
1320 if (xevent->property == None)
1321 {
1322 xf_cliprdr_send_client_format_list(clipboard, FALSE);
1323 }
1324 else
1325 {
1326 xf_cliprdr_get_requested_targets(clipboard);
1327 }
1328
1329 return TRUE;
1330 }
1331 else
1332 {
1333 return xf_cliprdr_get_requested_data(clipboard, xevent->target);
1334 }
1335}
1336
1337void xf_cliprdr_clear_cached_data(xfClipboard* clipboard)
1338{
1339 WINPR_ASSERT(clipboard);
1340
1341 ClipboardLock(clipboard->system);
1342 ClipboardEmpty(clipboard->system);
1343
1344 HashTable_Clear(clipboard->cachedData);
1345 HashTable_Clear(clipboard->cachedRawData);
1346
1347 cliprdr_file_context_clear(clipboard->file);
1348
1349 xf_cliprdr_stop_incr(clipboard);
1350 ClipboardUnlock(clipboard->system);
1351}
1352
1353static void* format_to_cache_slot(UINT32 format)
1354{
1355 union
1356 {
1357 uintptr_t uptr;
1358 void* vptr;
1359 } cnv;
1360 cnv.uptr = 0x100000000ULL + format;
1361 return cnv.vptr;
1362}
1363
1364static UINT32 get_dst_format_id_for_local_request(xfClipboard* clipboard,
1365 const xfCliprdrFormat* format)
1366{
1367 UINT32 dstFormatId = 0;
1368
1369 WINPR_ASSERT(format);
1370
1371 if (!format->formatName)
1372 return format->localFormat;
1373
1374 ClipboardLock(clipboard->system);
1375 if (strcmp(format->formatName, type_HtmlFormat) == 0)
1376 dstFormatId = ClipboardGetFormatId(clipboard->system, mime_html);
1377 ClipboardUnlock(clipboard->system);
1378
1379 if (strcmp(format->formatName, type_FileGroupDescriptorW) == 0)
1380 dstFormatId = format->localFormat;
1381
1382 return dstFormatId;
1383}
1384
1385static void get_src_format_info_for_local_request(xfClipboard* clipboard,
1386 const xfCliprdrFormat* format,
1387 UINT32* srcFormatId, BOOL* nullTerminated)
1388{
1389 *srcFormatId = 0;
1390 *nullTerminated = FALSE;
1391
1392 if (format->formatName)
1393 {
1394 ClipboardLock(clipboard->system);
1395 if (strcmp(format->formatName, type_HtmlFormat) == 0)
1396 {
1397 *srcFormatId = ClipboardGetFormatId(clipboard->system, type_HtmlFormat);
1398 *nullTerminated = TRUE;
1399 }
1400 else if (strcmp(format->formatName, type_FileGroupDescriptorW) == 0)
1401 {
1402 *srcFormatId = ClipboardGetFormatId(clipboard->system, type_FileGroupDescriptorW);
1403 *nullTerminated = TRUE;
1404 }
1405 ClipboardUnlock(clipboard->system);
1406 }
1407 else
1408 {
1409 *srcFormatId = format->formatToRequest;
1410 switch (format->formatToRequest)
1411 {
1412 case CF_TEXT:
1413 case CF_OEMTEXT:
1414 case CF_UNICODETEXT:
1415 *nullTerminated = TRUE;
1416 break;
1417 case CF_DIB:
1418 *srcFormatId = CF_DIB;
1419 break;
1420 case CF_TIFF:
1421 *srcFormatId = CF_TIFF;
1422 break;
1423 default:
1424 break;
1425 }
1426 }
1427}
1428
1429static xfCachedData* convert_data_from_existing_raw_data(xfClipboard* clipboard,
1430 xfCachedData* cached_raw_data,
1431 UINT32 srcFormatId, BOOL nullTerminated,
1432 UINT32 dstFormatId)
1433{
1434 UINT32 dst_size = 0;
1435
1436 WINPR_ASSERT(clipboard);
1437 WINPR_ASSERT(cached_raw_data);
1438 WINPR_ASSERT(cached_raw_data->data);
1439
1440 ClipboardLock(clipboard->system);
1441 BOOL success = ClipboardSetData(clipboard->system, srcFormatId, cached_raw_data->data,
1442 cached_raw_data->data_length);
1443 if (!success)
1444 {
1445 WLog_WARN(TAG, "Failed to set clipboard data (formatId: %u, data: %p, data_length: %u)",
1446 srcFormatId, WINPR_CXX_COMPAT_CAST(const void*, cached_raw_data->data),
1447 cached_raw_data->data_length);
1448 ClipboardUnlock(clipboard->system);
1449 return NULL;
1450 }
1451
1452 BYTE* dst_data = ClipboardGetData(clipboard->system, dstFormatId, &dst_size);
1453 if (!dst_data)
1454 {
1455 WLog_WARN(TAG, "Failed to get converted clipboard data");
1456 ClipboardUnlock(clipboard->system);
1457 return NULL;
1458 }
1459 ClipboardUnlock(clipboard->system);
1460
1461 if (nullTerminated)
1462 {
1463 BYTE* nullTerminator = memchr(dst_data, '\0', dst_size);
1464 if (nullTerminator)
1465 {
1466 const intptr_t diff = nullTerminator - dst_data;
1467 WINPR_ASSERT(diff >= 0);
1468 WINPR_ASSERT(diff <= UINT32_MAX);
1469 dst_size = (UINT32)diff;
1470 }
1471 }
1472
1473 xfCachedData* cached_data = xf_cached_data_new(dst_data, dst_size);
1474 if (!cached_data)
1475 {
1476 WLog_WARN(TAG, "Failed to allocate cache entry");
1477 free(dst_data);
1478 return NULL;
1479 }
1480
1481 if (!HashTable_Insert(clipboard->cachedData, format_to_cache_slot(dstFormatId), cached_data))
1482 {
1483 WLog_WARN(TAG, "Failed to cache clipboard data");
1484 xf_cached_data_free(cached_data);
1485 return NULL;
1486 }
1487
1488 return cached_data;
1489}
1490
1491static BOOL xf_cliprdr_process_selection_request(xfClipboard* clipboard,
1492 const XSelectionRequestEvent* xevent)
1493{
1494 int fmt = 0;
1495 Atom type = 0;
1496 UINT32 formatId = 0;
1497 XSelectionEvent* respond = NULL;
1498 BYTE* data = NULL;
1499 BOOL delayRespond = 0;
1500 BOOL rawTransfer = 0;
1501 unsigned long length = 0;
1502 unsigned long bytes_left = 0;
1503 xfContext* xfc = NULL;
1504
1505 WINPR_ASSERT(clipboard);
1506 WINPR_ASSERT(xevent);
1507
1508 xfc = clipboard->xfc;
1509 WINPR_ASSERT(xfc);
1510
1511 if (xevent->owner != xfc->drawable)
1512 return FALSE;
1513
1514 delayRespond = FALSE;
1515
1516 if (!(respond = (XSelectionEvent*)calloc(1, sizeof(XSelectionEvent))))
1517 {
1518 WLog_ERR(TAG, "failed to allocate XEvent data");
1519 return FALSE;
1520 }
1521
1522 respond->property = None;
1523 respond->type = SelectionNotify;
1524 respond->display = xevent->display;
1525 respond->requestor = xevent->requestor;
1526 respond->selection = xevent->selection;
1527 respond->target = xevent->target;
1528 respond->time = xevent->time;
1529
1530 if (xevent->target == clipboard->targets[0]) /* TIMESTAMP */
1531 {
1532 /* Someone else requests the selection's timestamp */
1533 respond->property = xevent->property;
1534 xf_cliprdr_provide_timestamp(clipboard, respond);
1535 }
1536 else if (xevent->target == clipboard->targets[1]) /* TARGETS */
1537 {
1538 /* Someone else requests our available formats */
1539 respond->property = xevent->property;
1540 xf_cliprdr_provide_targets(clipboard, respond);
1541 }
1542 else
1543 {
1544 const CLIPRDR_FORMAT* format =
1545 xf_cliprdr_get_server_format_by_atom(clipboard, xevent->target);
1546 const xfCliprdrFormat* cformat =
1547 xf_cliprdr_get_client_format_by_atom(clipboard, xevent->target);
1548
1549 if (format && (xevent->requestor != xfc->drawable))
1550 {
1551 formatId = format->formatId;
1552 rawTransfer = FALSE;
1553 xfCachedData* cached_data = NULL;
1554
1555 if (formatId == CF_RAW)
1556 {
1557 if (LogDynAndXGetWindowProperty(
1558 xfc->log, xfc->display, xevent->requestor, clipboard->property_atom, 0, 4,
1559 0, XA_INTEGER, &type, &fmt, &length, &bytes_left, &data) != Success)
1560 {
1561 }
1562
1563 if (data)
1564 {
1565 rawTransfer = TRUE;
1566 CopyMemory(&formatId, data, 4);
1567 XFree(data);
1568 }
1569 }
1570
1571 const UINT32 dstFormatId = get_dst_format_id_for_local_request(clipboard, cformat);
1572 DEBUG_CLIPRDR("formatId: 0x%08" PRIx32 ", dstFormatId: 0x%08" PRIx32 "", formatId,
1573 dstFormatId);
1574
1575 if (!rawTransfer)
1576 cached_data = HashTable_GetItemValue(clipboard->cachedData,
1577 format_to_cache_slot(dstFormatId));
1578 else
1579 cached_data = HashTable_GetItemValue(clipboard->cachedRawData,
1580 format_to_cache_slot(formatId));
1581
1582 DEBUG_CLIPRDR("hasCachedData: %u, rawTransfer: %d", cached_data ? 1u : 0u, rawTransfer);
1583
1584 if (!cached_data && !rawTransfer)
1585 {
1586 UINT32 srcFormatId = 0;
1587 BOOL nullTerminated = FALSE;
1588 xfCachedData* cached_raw_data = NULL;
1589
1590 get_src_format_info_for_local_request(clipboard, cformat, &srcFormatId,
1591 &nullTerminated);
1592 cached_raw_data =
1593 HashTable_GetItemValue(clipboard->cachedRawData, (void*)(UINT_PTR)srcFormatId);
1594
1595 DEBUG_CLIPRDR("hasCachedRawData: %u, rawDataLength: %u", cached_raw_data ? 1u : 0u,
1596 cached_raw_data ? cached_raw_data->data_length : 0);
1597
1598 if (cached_raw_data && cached_raw_data->data_length != 0)
1599 cached_data = convert_data_from_existing_raw_data(
1600 clipboard, cached_raw_data, srcFormatId, nullTerminated, dstFormatId);
1601 }
1602
1603 DEBUG_CLIPRDR("hasCachedData: %u", cached_data ? 1u : 0u);
1604
1605 if (cached_data)
1606 {
1607 /* Cached clipboard data available. Send it now */
1608 respond->property = xevent->property;
1609
1610 // NOLINTNEXTLINE(clang-analyzer-unix.Malloc)
1611 xf_cliprdr_provide_data(clipboard, respond, cached_data->data,
1612 cached_data->data_length);
1613 }
1614 else if (clipboard->respond)
1615 {
1616 /* duplicate request */
1617 }
1618 else
1619 {
1620 WINPR_ASSERT(cformat);
1621
1626 respond->property = xevent->property;
1627 clipboard->respond = respond;
1628 requested_format_replace(&clipboard->requestedFormat, formatId, dstFormatId,
1629 cformat->formatName);
1630 clipboard->data_raw_format = rawTransfer;
1631 delayRespond = TRUE;
1632 xf_cliprdr_send_data_request(clipboard, formatId, cformat);
1633 }
1634 }
1635 }
1636
1637 if (!delayRespond)
1638 {
1639 union
1640 {
1641 XEvent* ev;
1642 XSelectionEvent* sev;
1643 } conv;
1644
1645 conv.sev = respond;
1646 LogDynAndXSendEvent(xfc->log, xfc->display, xevent->requestor, 0, 0, conv.ev);
1647 LogDynAndXFlush(xfc->log, xfc->display);
1648 free(respond);
1649 }
1650
1651 return TRUE;
1652}
1653
1654static BOOL xf_cliprdr_process_selection_clear(xfClipboard* clipboard,
1655 const XSelectionClearEvent* xevent)
1656{
1657 xfContext* xfc = NULL;
1658
1659 WINPR_ASSERT(clipboard);
1660 WINPR_ASSERT(xevent);
1661
1662 xfc = clipboard->xfc;
1663 WINPR_ASSERT(xfc);
1664
1665 WINPR_UNUSED(xevent);
1666
1667 if (xf_cliprdr_is_self_owned(clipboard))
1668 return FALSE;
1669
1670 LogDynAndXDeleteProperty(xfc->log, xfc->display, clipboard->root_window,
1671 clipboard->property_atom);
1672 return TRUE;
1673}
1674
1675static BOOL xf_cliprdr_process_property_notify(xfClipboard* clipboard, const XPropertyEvent* xevent)
1676{
1677 const xfCliprdrFormat* format = NULL;
1678 xfContext* xfc = NULL;
1679
1680 if (!clipboard)
1681 return TRUE;
1682
1683 xfc = clipboard->xfc;
1684 WINPR_ASSERT(xfc);
1685 WINPR_ASSERT(xevent);
1686
1687 if (xevent->atom == clipboard->timestamp_property_atom)
1688 {
1689 /* This is the response to the property change we did
1690 * in xf_cliprdr_prepare_to_set_selection_owner. Now
1691 * we can set ourselves as the selection owner. (See
1692 * comments in those functions below.) */
1693 xf_cliprdr_set_selection_owner(xfc, clipboard, xevent->time);
1694 return TRUE;
1695 }
1696
1697 if (xevent->atom != clipboard->property_atom)
1698 return FALSE; /* Not cliprdr-related */
1699
1700 if (xevent->window == clipboard->root_window)
1701 {
1702 xf_cliprdr_send_client_format_list(clipboard, FALSE);
1703 }
1704 else if ((xevent->window == xfc->drawable) && (xevent->state == PropertyNewValue) &&
1705 clipboard->incr_starts)
1706 {
1707 format = xf_cliprdr_get_client_format_by_id(clipboard, clipboard->requestedFormatId);
1708
1709 if (format)
1710 xf_cliprdr_get_requested_data(clipboard, format->atom);
1711 }
1712
1713 return TRUE;
1714}
1715
1716void xf_cliprdr_handle_xevent(xfContext* xfc, const XEvent* event)
1717{
1718 xfClipboard* clipboard = NULL;
1719
1720 if (!xfc || !event)
1721 return;
1722
1723 clipboard = xfc->clipboard;
1724
1725 if (!clipboard)
1726 return;
1727
1728#ifdef WITH_XFIXES
1729
1730 if (clipboard->xfixes_supported &&
1731 event->type == XFixesSelectionNotify + clipboard->xfixes_event_base)
1732 {
1733 const XFixesSelectionNotifyEvent* se = (const XFixesSelectionNotifyEvent*)event;
1734
1735 if (se->subtype == XFixesSetSelectionOwnerNotify)
1736 {
1737 if (se->selection != clipboard->clipboard_atom)
1738 return;
1739
1740 if (LogDynAndXGetSelectionOwner(xfc->log, xfc->display, se->selection) == xfc->drawable)
1741 return;
1742
1743 clipboard->owner = None;
1744 xf_cliprdr_check_owner(clipboard);
1745 }
1746
1747 return;
1748 }
1749
1750#endif
1751
1752 switch (event->type)
1753 {
1754 case SelectionNotify:
1755 log_selection_event(xfc, event);
1756 xf_cliprdr_process_selection_notify(clipboard, &event->xselection);
1757 break;
1758
1759 case SelectionRequest:
1760 log_selection_event(xfc, event);
1761 xf_cliprdr_process_selection_request(clipboard, &event->xselectionrequest);
1762 break;
1763
1764 case SelectionClear:
1765 log_selection_event(xfc, event);
1766 xf_cliprdr_process_selection_clear(clipboard, &event->xselectionclear);
1767 break;
1768
1769 case PropertyNotify:
1770 log_selection_event(xfc, event);
1771 xf_cliprdr_process_property_notify(clipboard, &event->xproperty);
1772 break;
1773
1774 case FocusIn:
1775 if (!clipboard->xfixes_supported)
1776 {
1777 xf_cliprdr_check_owner(clipboard);
1778 }
1779
1780 break;
1781 default:
1782 break;
1783 }
1784}
1785
1791static UINT xf_cliprdr_send_client_capabilities(xfClipboard* clipboard)
1792{
1793 CLIPRDR_CAPABILITIES capabilities = { 0 };
1794 CLIPRDR_GENERAL_CAPABILITY_SET generalCapabilitySet = { 0 };
1795
1796 WINPR_ASSERT(clipboard);
1797
1798 capabilities.cCapabilitiesSets = 1;
1799 capabilities.capabilitySets = (CLIPRDR_CAPABILITY_SET*)&(generalCapabilitySet);
1800 generalCapabilitySet.capabilitySetType = CB_CAPSTYPE_GENERAL;
1801 generalCapabilitySet.capabilitySetLength = 12;
1802 generalCapabilitySet.version = CB_CAPS_VERSION_2;
1803 generalCapabilitySet.generalFlags = CB_USE_LONG_FORMAT_NAMES;
1804
1805 WINPR_ASSERT(clipboard);
1806 generalCapabilitySet.generalFlags |= cliprdr_file_context_current_flags(clipboard->file);
1807
1808 WINPR_ASSERT(clipboard->context);
1809 WINPR_ASSERT(clipboard->context->ClientCapabilities);
1810 return clipboard->context->ClientCapabilities(clipboard->context, &capabilities);
1811}
1812
1818static UINT xf_cliprdr_send_client_format_list(xfClipboard* clipboard, BOOL force)
1819{
1820 WINPR_ASSERT(clipboard);
1821
1822 xfContext* xfc = clipboard->xfc;
1823 WINPR_ASSERT(xfc);
1824
1825 UINT32 numFormats = 0;
1826 CLIPRDR_FORMAT* formats = xf_cliprdr_get_client_formats(clipboard, &numFormats);
1827
1828 const UINT ret = xf_cliprdr_send_format_list(clipboard, formats, numFormats, force);
1829
1830 if (clipboard->owner && clipboard->owner != xfc->drawable)
1831 {
1832 /* Request the owner for TARGETS, and wait for SelectionNotify event */
1833 LogDynAndXConvertSelection(xfc->log, xfc->display, clipboard->clipboard_atom,
1834 clipboard->targets[1], clipboard->property_atom, xfc->drawable,
1835 CurrentTime);
1836 }
1837
1838 xf_cliprdr_free_formats(formats, numFormats);
1839
1840 return ret;
1841}
1842
1848static UINT xf_cliprdr_send_client_format_list_response(xfClipboard* clipboard, BOOL status)
1849{
1850 CLIPRDR_FORMAT_LIST_RESPONSE formatListResponse = { 0 };
1851
1852 formatListResponse.common.msgType = CB_FORMAT_LIST_RESPONSE;
1853 formatListResponse.common.msgFlags = status ? CB_RESPONSE_OK : CB_RESPONSE_FAIL;
1854 formatListResponse.common.dataLen = 0;
1855
1856 WINPR_ASSERT(clipboard);
1857 WINPR_ASSERT(clipboard->context);
1858 WINPR_ASSERT(clipboard->context->ClientFormatListResponse);
1859 return clipboard->context->ClientFormatListResponse(clipboard->context, &formatListResponse);
1860}
1861
1867static UINT xf_cliprdr_monitor_ready(CliprdrClientContext* context,
1868 const CLIPRDR_MONITOR_READY* monitorReady)
1869{
1870 UINT ret = 0;
1871 xfClipboard* clipboard = NULL;
1872
1873 WINPR_ASSERT(context);
1874 WINPR_ASSERT(monitorReady);
1875
1876 clipboard = cliprdr_file_context_get_context(context->custom);
1877 WINPR_ASSERT(clipboard);
1878
1879 WINPR_UNUSED(monitorReady);
1880
1881 if ((ret = xf_cliprdr_send_client_capabilities(clipboard)) != CHANNEL_RC_OK)
1882 return ret;
1883
1884 xf_clipboard_formats_free(clipboard);
1885
1886 if ((ret = xf_cliprdr_send_client_format_list(clipboard, TRUE)) != CHANNEL_RC_OK)
1887 return ret;
1888
1889 clipboard->sync = TRUE;
1890 return CHANNEL_RC_OK;
1891}
1892
1898static UINT xf_cliprdr_server_capabilities(CliprdrClientContext* context,
1899 const CLIPRDR_CAPABILITIES* capabilities)
1900{
1901 const CLIPRDR_GENERAL_CAPABILITY_SET* generalCaps = NULL;
1902 const BYTE* capsPtr = NULL;
1903 xfClipboard* clipboard = NULL;
1904
1905 WINPR_ASSERT(context);
1906 WINPR_ASSERT(capabilities);
1907
1908 clipboard = cliprdr_file_context_get_context(context->custom);
1909 WINPR_ASSERT(clipboard);
1910
1911 capsPtr = (const BYTE*)capabilities->capabilitySets;
1912 WINPR_ASSERT(capsPtr);
1913
1914 cliprdr_file_context_remote_set_flags(clipboard->file, 0);
1915
1916 for (UINT32 i = 0; i < capabilities->cCapabilitiesSets; i++)
1917 {
1918 const CLIPRDR_CAPABILITY_SET* caps = (const CLIPRDR_CAPABILITY_SET*)capsPtr;
1919
1920 if (caps->capabilitySetType == CB_CAPSTYPE_GENERAL)
1921 {
1922 generalCaps = (const CLIPRDR_GENERAL_CAPABILITY_SET*)caps;
1923
1924 cliprdr_file_context_remote_set_flags(clipboard->file, generalCaps->generalFlags);
1925 }
1926
1927 capsPtr += caps->capabilitySetLength;
1928 }
1929
1930 return CHANNEL_RC_OK;
1931}
1932
1933static void xf_cliprdr_prepare_to_set_selection_owner(xfContext* xfc, xfClipboard* clipboard)
1934{
1935 WINPR_ASSERT(xfc);
1936 WINPR_ASSERT(clipboard);
1937 /*
1938 * When you're writing to the selection in response to a
1939 * normal X event like a mouse click or keyboard action, you
1940 * get the selection timestamp by copying the time field out
1941 * of that X event. Here, we're doing it on our own
1942 * initiative, so we have to _request_ the X server time.
1943 *
1944 * There isn't a GetServerTime request in the X protocol, so I
1945 * work around it by setting a property on our own window, and
1946 * waiting for a PropertyNotify event to come back telling me
1947 * it's been done - which will have a timestamp we can use.
1948 */
1949
1950 /* We have to set the property to some value, but it doesn't
1951 * matter what. Set it to its own name, which we have here
1952 * anyway! */
1953 Atom value = clipboard->timestamp_property_atom;
1954
1955 LogDynAndXChangeProperty(xfc->log, xfc->display, xfc->drawable,
1956 clipboard->timestamp_property_atom, XA_ATOM, 32, PropModeReplace,
1957 (const BYTE*)&value, 1);
1958 LogDynAndXFlush(xfc->log, xfc->display);
1959}
1960
1961static void xf_cliprdr_set_selection_owner(xfContext* xfc, xfClipboard* clipboard, Time timestamp)
1962{
1963 WINPR_ASSERT(xfc);
1964 WINPR_ASSERT(clipboard);
1965 /*
1966 * Actually set ourselves up as the selection owner, now that
1967 * we have a timestamp to use.
1968 */
1969
1970 clipboard->selection_ownership_timestamp = timestamp;
1971 LogDynAndXSetSelectionOwner(xfc->log, xfc->display, clipboard->clipboard_atom, xfc->drawable,
1972 timestamp);
1973 LogDynAndXFlush(xfc->log, xfc->display);
1974}
1975
1981static UINT xf_cliprdr_server_format_list(CliprdrClientContext* context,
1982 const CLIPRDR_FORMAT_LIST* formatList)
1983{
1984 xfContext* xfc = NULL;
1985 UINT ret = 0;
1986 xfClipboard* clipboard = NULL;
1987
1988 WINPR_ASSERT(context);
1989 WINPR_ASSERT(formatList);
1990
1991 clipboard = cliprdr_file_context_get_context(context->custom);
1992 WINPR_ASSERT(clipboard);
1993
1994 xfc = clipboard->xfc;
1995 WINPR_ASSERT(xfc);
1996
1997 xf_lock_x11(xfc);
1998
1999 /* Clear the active SelectionRequest, as it is now invalid */
2000 free(clipboard->respond);
2001 clipboard->respond = NULL;
2002
2003 xf_clipboard_formats_free(clipboard);
2004 xf_cliprdr_clear_cached_data(clipboard);
2005 requested_format_free(&clipboard->requestedFormat);
2006
2007 xf_clipboard_free_server_formats(clipboard);
2008
2009 clipboard->numServerFormats = formatList->numFormats + 1; /* +1 for CF_RAW */
2010
2011 if (!(clipboard->serverFormats =
2012 (CLIPRDR_FORMAT*)calloc(clipboard->numServerFormats, sizeof(CLIPRDR_FORMAT))))
2013 {
2014 WLog_ERR(TAG, "failed to allocate %" PRIu32 " CLIPRDR_FORMAT structs",
2015 clipboard->numServerFormats);
2016 ret = CHANNEL_RC_NO_MEMORY;
2017 goto out;
2018 }
2019
2020 for (size_t i = 0; i < formatList->numFormats; i++)
2021 {
2022 const CLIPRDR_FORMAT* format = &formatList->formats[i];
2023 CLIPRDR_FORMAT* srvFormat = &clipboard->serverFormats[i];
2024
2025 srvFormat->formatId = format->formatId;
2026
2027 if (format->formatName)
2028 {
2029 srvFormat->formatName = _strdup(format->formatName);
2030
2031 if (!srvFormat->formatName)
2032 {
2033 for (UINT32 k = 0; k < i; k++)
2034 free(clipboard->serverFormats[k].formatName);
2035
2036 clipboard->numServerFormats = 0;
2037 free(clipboard->serverFormats);
2038 clipboard->serverFormats = NULL;
2039 ret = CHANNEL_RC_NO_MEMORY;
2040 goto out;
2041 }
2042 }
2043 }
2044
2045 ClipboardLock(clipboard->system);
2046 ret = cliprdr_file_context_notify_new_server_format_list(clipboard->file);
2047 ClipboardUnlock(clipboard->system);
2048 if (ret)
2049 goto out;
2050
2051 /* CF_RAW is always implicitly supported by the server */
2052 {
2053 CLIPRDR_FORMAT* format = &clipboard->serverFormats[formatList->numFormats];
2054 format->formatId = CF_RAW;
2055 format->formatName = NULL;
2056 }
2057 xf_cliprdr_provide_server_format_list(clipboard);
2058 clipboard->numTargets = 2;
2059
2060 for (size_t i = 0; i < formatList->numFormats; i++)
2061 {
2062 const CLIPRDR_FORMAT* format = &formatList->formats[i];
2063
2064 for (size_t j = 0; j < clipboard->numClientFormats; j++)
2065 {
2066 const xfCliprdrFormat* clientFormat = &clipboard->clientFormats[j];
2067 if (xf_cliprdr_formats_equal(format, clientFormat))
2068 {
2069 if ((clientFormat->formatName != NULL) &&
2070 (strcmp(type_FileGroupDescriptorW, clientFormat->formatName) == 0))
2071 {
2072 if (!cliprdr_file_context_has_local_support(clipboard->file))
2073 continue;
2074 }
2075 xf_cliprdr_append_target(clipboard, clientFormat->atom);
2076 }
2077 }
2078 }
2079
2080 ret = xf_cliprdr_send_client_format_list_response(clipboard, TRUE);
2081 if (xfc->remote_app)
2082 xf_cliprdr_set_selection_owner(xfc, clipboard, CurrentTime);
2083 else
2084 xf_cliprdr_prepare_to_set_selection_owner(xfc, clipboard);
2085
2086out:
2087 xf_unlock_x11(xfc);
2088
2089 return ret;
2090}
2091
2097static UINT xf_cliprdr_server_format_list_response(
2098 WINPR_ATTR_UNUSED CliprdrClientContext* context,
2099 WINPR_ATTR_UNUSED const CLIPRDR_FORMAT_LIST_RESPONSE* formatListResponse)
2100{
2101 WINPR_ASSERT(context);
2102 WINPR_ASSERT(formatListResponse);
2103 // xfClipboard* clipboard = (xfClipboard*) context->custom;
2104 return CHANNEL_RC_OK;
2105}
2106
2112static UINT
2113xf_cliprdr_server_format_data_request(CliprdrClientContext* context,
2114 const CLIPRDR_FORMAT_DATA_REQUEST* formatDataRequest)
2115{
2116 const xfCliprdrFormat* format = NULL;
2117
2118 WINPR_ASSERT(context);
2119 WINPR_ASSERT(formatDataRequest);
2120
2121 xfClipboard* clipboard = cliprdr_file_context_get_context(context->custom);
2122 WINPR_ASSERT(clipboard);
2123
2124 xfContext* xfc = clipboard->xfc;
2125 WINPR_ASSERT(xfc);
2126
2127 const uint32_t formatId = formatDataRequest->requestedFormatId;
2128
2129 const BOOL rawTransfer = xf_cliprdr_is_raw_transfer_available(clipboard);
2130
2131 if (rawTransfer)
2132 {
2133 format = xf_cliprdr_get_client_format_by_id(clipboard, CF_RAW);
2134 LogDynAndXChangeProperty(xfc->log, xfc->display, xfc->drawable, clipboard->property_atom,
2135 XA_INTEGER, 32, PropModeReplace, (const BYTE*)&formatId, 1);
2136 }
2137 else
2138 format = xf_cliprdr_get_client_format_by_id(clipboard, formatId);
2139
2140 clipboard->requestedFormatId = rawTransfer ? CF_RAW : formatId;
2141 if (!format)
2142 return xf_cliprdr_send_data_response(clipboard, format, NULL, 0);
2143
2144 DEBUG_CLIPRDR("requested format 0x%08" PRIx32 " [%s] {local 0x%08" PRIx32 " [%s]} [%s]",
2145 format->formatToRequest, ClipboardGetFormatIdString(format->formatToRequest),
2146 format->localFormat,
2147 ClipboardGetFormatName(clipboard->system, format->localFormat),
2148 format->formatName);
2149 LogDynAndXConvertSelection(xfc->log, xfc->display, clipboard->clipboard_atom, format->atom,
2150 clipboard->property_atom, xfc->drawable, CurrentTime);
2151 LogDynAndXFlush(xfc->log, xfc->display);
2152 /* After this point, we expect a SelectionNotify event from the clipboard owner. */
2153 return CHANNEL_RC_OK;
2154}
2155
2161static UINT
2162xf_cliprdr_server_format_data_response(CliprdrClientContext* context,
2163 const CLIPRDR_FORMAT_DATA_RESPONSE* formatDataResponse)
2164{
2165 BOOL bSuccess = 0;
2166 BYTE* pDstData = NULL;
2167 UINT32 DstSize = 0;
2168 UINT32 SrcSize = 0;
2169 UINT32 srcFormatId = 0;
2170 UINT32 dstFormatId = 0;
2171 BOOL nullTerminated = FALSE;
2172 xfCachedData* cached_data = NULL;
2173
2174 WINPR_ASSERT(context);
2175 WINPR_ASSERT(formatDataResponse);
2176
2177 xfClipboard* clipboard = cliprdr_file_context_get_context(context->custom);
2178 WINPR_ASSERT(clipboard);
2179
2180 xfContext* xfc = clipboard->xfc;
2181 WINPR_ASSERT(xfc);
2182
2183 const UINT32 size = formatDataResponse->common.dataLen;
2184 const BYTE* data = formatDataResponse->requestedFormatData;
2185
2186 if (formatDataResponse->common.msgFlags == CB_RESPONSE_FAIL)
2187 {
2188 WLog_WARN(TAG, "Format Data Response PDU msgFlags is CB_RESPONSE_FAIL");
2189 free(clipboard->respond);
2190 clipboard->respond = NULL;
2191 return CHANNEL_RC_OK;
2192 }
2193
2194 if (!clipboard->respond)
2195 return CHANNEL_RC_OK;
2196
2197 const RequestedFormat* format = clipboard->requestedFormat;
2198 if (clipboard->data_raw_format)
2199 {
2200 srcFormatId = CF_RAW;
2201 dstFormatId = CF_RAW;
2202 }
2203 else if (!format)
2204 return ERROR_INTERNAL_ERROR;
2205 else if (format->formatName)
2206 {
2207 dstFormatId = format->localFormat;
2208
2209 ClipboardLock(clipboard->system);
2210 if (strcmp(format->formatName, type_HtmlFormat) == 0)
2211 {
2212 srcFormatId = ClipboardGetFormatId(clipboard->system, type_HtmlFormat);
2213 dstFormatId = ClipboardGetFormatId(clipboard->system, mime_html);
2214 nullTerminated = TRUE;
2215 }
2216
2217 if (strcmp(format->formatName, type_FileGroupDescriptorW) == 0)
2218 {
2219 if (!cliprdr_file_context_update_server_data(clipboard->file, clipboard->system, data,
2220 size))
2221 WLog_WARN(TAG, "failed to update file descriptors");
2222
2223 srcFormatId = ClipboardGetFormatId(clipboard->system, type_FileGroupDescriptorW);
2224 const xfCliprdrFormat* dstTargetFormat =
2225 xf_cliprdr_get_client_format_by_atom(clipboard, clipboard->respond->target);
2226 if (!dstTargetFormat)
2227 {
2228 dstFormatId = ClipboardGetFormatId(clipboard->system, mime_uri_list);
2229 }
2230 else
2231 {
2232 dstFormatId = dstTargetFormat->localFormat;
2233 }
2234
2235 nullTerminated = TRUE;
2236 }
2237 ClipboardUnlock(clipboard->system);
2238 }
2239 else
2240 {
2241 srcFormatId = format->formatToRequest;
2242 dstFormatId = format->localFormat;
2243 switch (format->formatToRequest)
2244 {
2245 case CF_TEXT:
2246 nullTerminated = TRUE;
2247 break;
2248
2249 case CF_OEMTEXT:
2250 nullTerminated = TRUE;
2251 break;
2252
2253 case CF_UNICODETEXT:
2254 nullTerminated = TRUE;
2255 break;
2256
2257 case CF_DIB:
2258 srcFormatId = CF_DIB;
2259 break;
2260
2261 case CF_TIFF:
2262 srcFormatId = CF_TIFF;
2263 break;
2264
2265 default:
2266 break;
2267 }
2268 }
2269
2270 DEBUG_CLIPRDR("requested format 0x%08" PRIx32 " [%s] {local 0x%08" PRIx32 " [%s]} [%s]",
2271 format->formatToRequest, ClipboardGetFormatIdString(format->formatToRequest),
2272 format->localFormat,
2273 ClipboardGetFormatName(clipboard->system, format->localFormat),
2274 format->formatName);
2275 SrcSize = size;
2276
2277 DEBUG_CLIPRDR("srcFormatId: 0x%08" PRIx32 ", dstFormatId: 0x%08" PRIx32 "", srcFormatId,
2278 dstFormatId);
2279
2280 ClipboardLock(clipboard->system);
2281 bSuccess = ClipboardSetData(clipboard->system, srcFormatId, data, SrcSize);
2282
2283 BOOL willQuit = FALSE;
2284 if (bSuccess)
2285 {
2286 if (SrcSize == 0)
2287 {
2288 WLog_DBG(TAG, "skipping, empty data detected!");
2289 free(clipboard->respond);
2290 clipboard->respond = NULL;
2291 willQuit = TRUE;
2292 }
2293 else
2294 {
2295 pDstData = (BYTE*)ClipboardGetData(clipboard->system, dstFormatId, &DstSize);
2296
2297 if (!pDstData)
2298 {
2299 WLog_WARN(TAG, "failed to get clipboard data in format %s [source format %s]",
2300 ClipboardGetFormatName(clipboard->system, dstFormatId),
2301 ClipboardGetFormatName(clipboard->system, srcFormatId));
2302 }
2303
2304 if (nullTerminated && pDstData)
2305 {
2306 BYTE* nullTerminator = memchr(pDstData, '\0', DstSize);
2307 if (nullTerminator)
2308 {
2309 const intptr_t diff = nullTerminator - pDstData;
2310 WINPR_ASSERT(diff >= 0);
2311 WINPR_ASSERT(diff <= UINT32_MAX);
2312 DstSize = (UINT32)diff;
2313 }
2314 }
2315 }
2316 }
2317 ClipboardUnlock(clipboard->system);
2318 if (willQuit)
2319 return CHANNEL_RC_OK;
2320
2321 /* Cache converted and original data to avoid doing a possibly costly
2322 * conversion again on subsequent requests */
2323 if (pDstData)
2324 {
2325 cached_data = xf_cached_data_new(pDstData, DstSize);
2326 if (!cached_data)
2327 {
2328 WLog_WARN(TAG, "Failed to allocate cache entry");
2329 free(pDstData);
2330 return CHANNEL_RC_OK;
2331 }
2332 if (!HashTable_Insert(clipboard->cachedData, format_to_cache_slot(dstFormatId),
2333 cached_data))
2334 {
2335 WLog_WARN(TAG, "Failed to cache clipboard data");
2336 xf_cached_data_free(cached_data);
2337 return CHANNEL_RC_OK;
2338 }
2339 }
2340
2341 /* We have to copy the original data again, as pSrcData is now owned
2342 * by clipboard->system. Memory allocation failure is not fatal here
2343 * as this is only a cached value. */
2344 {
2345 // clipboard->cachedData owns cached_data
2346 // NOLINTNEXTLINE(clang-analyzer-unix.Malloc
2347 xfCachedData* cached_raw_data = xf_cached_data_new_copy(data, size);
2348 if (!cached_raw_data)
2349 WLog_WARN(TAG, "Failed to allocate cache entry");
2350 else
2351 {
2352 if (!HashTable_Insert(clipboard->cachedRawData, (void*)(UINT_PTR)srcFormatId,
2353 cached_raw_data))
2354 {
2355 WLog_WARN(TAG, "Failed to cache clipboard data");
2356 xf_cached_data_free(cached_raw_data);
2357 }
2358 }
2359 }
2360
2361 // clipboard->cachedRawData owns cached_raw_data
2362 // NOLINTNEXTLINE(clang-analyzer-unix.Malloc)
2363 xf_cliprdr_provide_data(clipboard, clipboard->respond, pDstData, DstSize);
2364 {
2365 union
2366 {
2367 XEvent* ev;
2368 XSelectionEvent* sev;
2369 } conv;
2370
2371 conv.sev = clipboard->respond;
2372
2373 LogDynAndXSendEvent(xfc->log, xfc->display, clipboard->respond->requestor, 0, 0, conv.ev);
2374 LogDynAndXFlush(xfc->log, xfc->display);
2375 }
2376 free(clipboard->respond);
2377 clipboard->respond = NULL;
2378 return CHANNEL_RC_OK;
2379}
2380
2381static BOOL xf_cliprdr_is_valid_unix_filename(LPCWSTR filename)
2382{
2383 if (!filename)
2384 return FALSE;
2385
2386 if (filename[0] == L'\0')
2387 return FALSE;
2388
2389 /* Reserved characters */
2390 for (const WCHAR* c = filename; *c; ++c)
2391 {
2392 if (*c == L'/')
2393 return FALSE;
2394 }
2395
2396 return TRUE;
2397}
2398
2399xfClipboard* xf_clipboard_new(xfContext* xfc, BOOL relieveFilenameRestriction)
2400{
2401 int n = 0;
2402 rdpChannels* channels = NULL;
2403 xfClipboard* clipboard = NULL;
2404 const char* selectionAtom = NULL;
2405 xfCliprdrFormat* clientFormat = NULL;
2406 wObject* obj = NULL;
2407
2408 WINPR_ASSERT(xfc);
2409 WINPR_ASSERT(xfc->common.context.settings);
2410
2411 if (!(clipboard = (xfClipboard*)calloc(1, sizeof(xfClipboard))))
2412 {
2413 WLog_ERR(TAG, "failed to allocate xfClipboard data");
2414 return NULL;
2415 }
2416
2417 clipboard->file = cliprdr_file_context_new(clipboard);
2418 if (!clipboard->file)
2419 goto fail;
2420
2421 xfc->clipboard = clipboard;
2422 clipboard->xfc = xfc;
2423 channels = xfc->common.context.channels;
2424 clipboard->channels = channels;
2425 clipboard->system = ClipboardCreate();
2426 clipboard->requestedFormatId = UINT32_MAX;
2427 clipboard->root_window = DefaultRootWindow(xfc->display);
2428
2429 selectionAtom =
2430 freerdp_settings_get_string(xfc->common.context.settings, FreeRDP_ClipboardUseSelection);
2431 if (!selectionAtom)
2432 selectionAtom = "CLIPBOARD";
2433
2434 clipboard->clipboard_atom = Logging_XInternAtom(xfc->log, xfc->display, selectionAtom, FALSE);
2435
2436 if (clipboard->clipboard_atom == None)
2437 {
2438 WLog_ERR(TAG, "unable to get %s atom", selectionAtom);
2439 goto fail;
2440 }
2441
2442 clipboard->timestamp_property_atom =
2443 Logging_XInternAtom(xfc->log, xfc->display, "_FREERDP_TIMESTAMP_PROPERTY", FALSE);
2444 clipboard->property_atom =
2445 Logging_XInternAtom(xfc->log, xfc->display, "_FREERDP_CLIPRDR", FALSE);
2446 clipboard->raw_transfer_atom =
2447 Logging_XInternAtom(xfc->log, xfc->display, "_FREERDP_CLIPRDR_RAW", FALSE);
2448 clipboard->raw_format_list_atom =
2449 Logging_XInternAtom(xfc->log, xfc->display, "_FREERDP_CLIPRDR_FORMATS", FALSE);
2450 xf_cliprdr_set_raw_transfer_enabled(clipboard, TRUE);
2451 XSelectInput(xfc->display, clipboard->root_window, PropertyChangeMask);
2452#ifdef WITH_XFIXES
2453
2454 if (XFixesQueryExtension(xfc->display, &clipboard->xfixes_event_base,
2455 &clipboard->xfixes_error_base))
2456 {
2457 int xfmajor = 0;
2458 int xfminor = 0;
2459
2460 if (XFixesQueryVersion(xfc->display, &xfmajor, &xfminor))
2461 {
2462 XFixesSelectSelectionInput(xfc->display, clipboard->root_window,
2463 clipboard->clipboard_atom,
2464 XFixesSetSelectionOwnerNotifyMask);
2465 clipboard->xfixes_supported = TRUE;
2466 }
2467 else
2468 {
2469 WLog_ERR(TAG, "Error querying X Fixes extension version");
2470 }
2471 }
2472 else
2473 {
2474 WLog_ERR(TAG, "Error loading X Fixes extension");
2475 }
2476
2477#else
2478 WLog_ERR(
2479 TAG,
2480 "Warning: Using clipboard redirection without XFIXES extension is strongly discouraged!");
2481#endif
2482 clientFormat = &clipboard->clientFormats[n++];
2483 clientFormat->atom = Logging_XInternAtom(xfc->log, xfc->display, "_FREERDP_RAW", False);
2484 clientFormat->localFormat = clientFormat->formatToRequest = CF_RAW;
2485
2486 clientFormat = &clipboard->clientFormats[n++];
2487 clientFormat->atom = Logging_XInternAtom(xfc->log, xfc->display, "UTF8_STRING", False);
2488 clientFormat->formatToRequest = CF_UNICODETEXT;
2489 clientFormat->localFormat = ClipboardGetFormatId(xfc->clipboard->system, mime_text_plain);
2490
2491 clientFormat = &clipboard->clientFormats[n++];
2492 clientFormat->atom = XA_STRING;
2493 clientFormat->formatToRequest = CF_TEXT;
2494 clientFormat->localFormat = ClipboardGetFormatId(xfc->clipboard->system, mime_text_plain);
2495
2496 clientFormat = &clipboard->clientFormats[n++];
2497 clientFormat->atom = Logging_XInternAtom(xfc->log, xfc->display, mime_tiff, False);
2498 clientFormat->formatToRequest = clientFormat->localFormat = CF_TIFF;
2499
2500 for (size_t x = 0; x < ARRAYSIZE(mime_bitmap); x++)
2501 {
2502 const char* mime_bmp = mime_bitmap[x];
2503 const DWORD format = ClipboardGetFormatId(xfc->clipboard->system, mime_bmp);
2504 if (format == 0)
2505 {
2506 WLog_DBG(TAG, "skipping local bitmap format %s [NOT SUPPORTED]", mime_bmp);
2507 continue;
2508 }
2509
2510 WLog_DBG(TAG, "register local bitmap format %s [0x%08" PRIx32 "]", mime_bmp, format);
2511 clientFormat = &clipboard->clientFormats[n++];
2512 clientFormat->localFormat = format;
2513 clientFormat->atom = Logging_XInternAtom(xfc->log, xfc->display, mime_bmp, False);
2514 clientFormat->formatToRequest = CF_DIB;
2515 clientFormat->isImage = TRUE;
2516 }
2517
2518 for (size_t x = 0; x < ARRAYSIZE(mime_images); x++)
2519 {
2520 const char* mime_bmp = mime_images[x];
2521 const DWORD format = ClipboardGetFormatId(xfc->clipboard->system, mime_bmp);
2522 if (format == 0)
2523 {
2524 WLog_DBG(TAG, "skipping local bitmap format %s [NOT SUPPORTED]", mime_bmp);
2525 continue;
2526 }
2527
2528 WLog_DBG(TAG, "register local bitmap format %s [0x%08" PRIx32 "]", mime_bmp, format);
2529 clientFormat = &clipboard->clientFormats[n++];
2530 clientFormat->localFormat = format;
2531 clientFormat->atom = Logging_XInternAtom(xfc->log, xfc->display, mime_bmp, False);
2532 clientFormat->formatToRequest = CF_DIB;
2533 clientFormat->isImage = TRUE;
2534 }
2535
2536 clientFormat = &clipboard->clientFormats[n++];
2537 clientFormat->atom = Logging_XInternAtom(xfc->log, xfc->display, mime_html, False);
2538 clientFormat->formatToRequest = ClipboardGetFormatId(xfc->clipboard->system, type_HtmlFormat);
2539 clientFormat->localFormat = ClipboardGetFormatId(xfc->clipboard->system, mime_html);
2540 clientFormat->formatName = _strdup(type_HtmlFormat);
2541
2542 if (!clientFormat->formatName)
2543 goto fail;
2544
2545 clientFormat = &clipboard->clientFormats[n++];
2546
2547 /*
2548 * Existence of registered format IDs for file formats does not guarantee that they are
2549 * in fact supported by wClipboard (as further initialization may have failed after format
2550 * registration). However, they are definitely not supported if there are no registered
2551 * formats. In this case we should not list file formats in TARGETS.
2552 */
2553 {
2554 const UINT32 fgid = ClipboardGetFormatId(clipboard->system, type_FileGroupDescriptorW);
2555 {
2556 const UINT32 uid = ClipboardGetFormatId(clipboard->system, mime_uri_list);
2557 if (uid)
2558 {
2559 cliprdr_file_context_set_locally_available(clipboard->file, TRUE);
2560 clientFormat->atom =
2561 Logging_XInternAtom(xfc->log, xfc->display, mime_uri_list, False);
2562 clientFormat->localFormat = uid;
2563 clientFormat->formatToRequest = fgid;
2564 clientFormat->formatName = _strdup(type_FileGroupDescriptorW);
2565
2566 if (!clientFormat->formatName)
2567 goto fail;
2568
2569 clientFormat = &clipboard->clientFormats[n++];
2570 }
2571 }
2572
2573 {
2574 const UINT32 gid = ClipboardGetFormatId(clipboard->system, mime_gnome_copied_files);
2575 if (gid != 0)
2576 {
2577 cliprdr_file_context_set_locally_available(clipboard->file, TRUE);
2578 clientFormat->atom =
2579 Logging_XInternAtom(xfc->log, xfc->display, mime_gnome_copied_files, False);
2580 clientFormat->localFormat = gid;
2581 clientFormat->formatToRequest = fgid;
2582 clientFormat->formatName = _strdup(type_FileGroupDescriptorW);
2583
2584 if (!clientFormat->formatName)
2585 goto fail;
2586
2587 clientFormat = &clipboard->clientFormats[n++];
2588 }
2589 }
2590
2591 {
2592 const UINT32 mid = ClipboardGetFormatId(clipboard->system, mime_mate_copied_files);
2593 if (mid != 0)
2594 {
2595 cliprdr_file_context_set_locally_available(clipboard->file, TRUE);
2596 clientFormat->atom =
2597 Logging_XInternAtom(xfc->log, xfc->display, mime_mate_copied_files, False);
2598 clientFormat->localFormat = mid;
2599 clientFormat->formatToRequest = fgid;
2600 clientFormat->formatName = _strdup(type_FileGroupDescriptorW);
2601
2602 if (!clientFormat->formatName)
2603 goto fail;
2604 }
2605 }
2606 }
2607
2608 clipboard->numClientFormats = WINPR_ASSERTING_INT_CAST(uint32_t, n);
2609 clipboard->targets[0] = Logging_XInternAtom(xfc->log, xfc->display, "TIMESTAMP", FALSE);
2610 clipboard->targets[1] = Logging_XInternAtom(xfc->log, xfc->display, "TARGETS", FALSE);
2611 clipboard->numTargets = 2;
2612 clipboard->incr_atom = Logging_XInternAtom(xfc->log, xfc->display, "INCR", FALSE);
2613
2614 if (relieveFilenameRestriction)
2615 {
2616 WLog_DBG(TAG, "Relieving CLIPRDR filename restriction");
2617 ClipboardGetDelegate(clipboard->system)->IsFileNameComponentValid =
2618 xf_cliprdr_is_valid_unix_filename;
2619 }
2620
2621 clipboard->cachedData = HashTable_New(TRUE);
2622 if (!clipboard->cachedData)
2623 goto fail;
2624
2625 obj = HashTable_ValueObject(clipboard->cachedData);
2626 obj->fnObjectFree = xf_cached_data_free;
2627
2628 clipboard->cachedRawData = HashTable_New(TRUE);
2629 if (!clipboard->cachedRawData)
2630 goto fail;
2631
2632 obj = HashTable_ValueObject(clipboard->cachedRawData);
2633 obj->fnObjectFree = xf_cached_data_free;
2634
2635 return clipboard;
2636
2637fail:
2638 WINPR_PRAGMA_DIAG_PUSH
2639 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
2640 xf_clipboard_free(clipboard);
2641 WINPR_PRAGMA_DIAG_POP
2642 return NULL;
2643}
2644
2645void xf_clipboard_free(xfClipboard* clipboard)
2646{
2647 if (!clipboard)
2648 return;
2649
2650 xf_clipboard_free_server_formats(clipboard);
2651
2652 if (clipboard->numClientFormats)
2653 {
2654 for (UINT32 i = 0; i < clipboard->numClientFormats; i++)
2655 {
2656 xfCliprdrFormat* format = &clipboard->clientFormats[i];
2657 free(format->formatName);
2658 }
2659 }
2660
2661 cliprdr_file_context_free(clipboard->file);
2662
2663 ClipboardDestroy(clipboard->system);
2664 xf_clipboard_formats_free(clipboard);
2665 HashTable_Free(clipboard->cachedRawData);
2666 HashTable_Free(clipboard->cachedData);
2667 requested_format_free(&clipboard->requestedFormat);
2668 free(clipboard->respond);
2669 free(clipboard->incr_data);
2670 free(clipboard);
2671}
2672
2673void xf_cliprdr_init(xfContext* xfc, CliprdrClientContext* cliprdr)
2674{
2675 WINPR_ASSERT(xfc);
2676 WINPR_ASSERT(cliprdr);
2677
2678 xfc->cliprdr = cliprdr;
2679 xfc->clipboard->context = cliprdr;
2680
2681 cliprdr->MonitorReady = xf_cliprdr_monitor_ready;
2682 cliprdr->ServerCapabilities = xf_cliprdr_server_capabilities;
2683 cliprdr->ServerFormatList = xf_cliprdr_server_format_list;
2684 cliprdr->ServerFormatListResponse = xf_cliprdr_server_format_list_response;
2685 cliprdr->ServerFormatDataRequest = xf_cliprdr_server_format_data_request;
2686 cliprdr->ServerFormatDataResponse = xf_cliprdr_server_format_data_response;
2687
2688 cliprdr_file_context_init(xfc->clipboard->file, cliprdr);
2689}
2690
2691void xf_cliprdr_uninit(xfContext* xfc, CliprdrClientContext* cliprdr)
2692{
2693 WINPR_ASSERT(xfc);
2694 WINPR_ASSERT(cliprdr);
2695
2696 xfc->cliprdr = NULL;
2697
2698 if (xfc->clipboard)
2699 {
2700 ClipboardLock(xfc->clipboard->system);
2701 cliprdr_file_context_uninit(xfc->clipboard->file, cliprdr);
2702 ClipboardUnlock(xfc->clipboard->system);
2703 xfc->clipboard->context = NULL;
2704 }
2705}
freerdp_settings_get_string
FREERDP_API const char * freerdp_settings_get_string(const rdpSettings *settings, FreeRDP_Settings_Keys_String id)
Returns a immutable string settings value.
CLIPRDR_CAPABILITIES
Definition channels/cliprdr.h:120
CLIPRDR_CAPABILITY_SET
Definition channels/cliprdr.h:105
CLIPRDR_FORMAT_DATA_REQUEST
Definition channels/cliprdr.h:173
CLIPRDR_FORMAT_DATA_RESPONSE
Definition channels/cliprdr.h:180
CLIPRDR_FORMAT_LIST_RESPONSE
Definition channels/cliprdr.h:154
CLIPRDR_FORMAT_LIST
Definition channels/cliprdr.h:146
CLIPRDR_FORMAT
Definition channels/cliprdr.h:140
CLIPRDR_GENERAL_CAPABILITY_SET
Definition channels/cliprdr.h:111
CLIPRDR_MONITOR_READY
Definition channels/cliprdr.h:128
wObject
This struct contains function pointer to initialize/free objects.
Definition collections.h:57