FreeRDP
Loading...
Searching...
No Matches
client/cliprdr_main.c
1
23#include <freerdp/config.h>
24
25#include <winpr/wtypes.h>
26#include <winpr/assert.h>
27#include <winpr/crt.h>
28#include <winpr/print.h>
29#include <winpr/clipboard.h>
30
31#include <freerdp/types.h>
32#include <freerdp/constants.h>
33#include <freerdp/freerdp.h>
34#include <freerdp/client/cliprdr.h>
35
36#include "../../../channels/client/addin.h"
37
38#include "cliprdr_main.h"
39#include "cliprdr_format.h"
40#include "../cliprdr_common.h"
41
42const char type_FileGroupDescriptorW[] = "FileGroupDescriptorW";
43const char type_FileContents[] = "FileContents";
44
45CliprdrClientContext* cliprdr_get_client_interface(cliprdrPlugin* cliprdr)
46{
47 CliprdrClientContext* pInterface = nullptr;
48
49 if (!cliprdr)
50 return nullptr;
51
52 pInterface = (CliprdrClientContext*)cliprdr->channelEntryPoints.pInterface;
53 return pInterface;
54}
55
61static UINT cliprdr_packet_send(cliprdrPlugin* cliprdr, wStream* s)
62{
63 UINT status = ERROR_INVALID_DATA;
64
65 WINPR_ASSERT(cliprdr);
66 WINPR_ASSERT(s);
67
68 const size_t pos = Stream_GetPosition(s);
69 WINPR_ASSERT(pos >= 8ULL);
70 WINPR_ASSERT(pos <= UINT32_MAX - 8);
71
72 const uint32_t dataLen = WINPR_ASSERTING_INT_CAST(uint32_t, pos - 8UL);
73
74 if (!Stream_SetPosition(s, 4))
75 goto fail;
76 Stream_Write_UINT32(s, dataLen);
77 if (!Stream_SetPosition(s, pos))
78 goto fail;
79
80 WLog_Print(cliprdr->log, WLOG_DEBUG, "Cliprdr Sending (%" PRIuz " bytes)", pos);
81
82 if (!cliprdr)
83 status = CHANNEL_RC_BAD_INIT_HANDLE;
84 else
85 {
86 WINPR_ASSERT(cliprdr->channelEntryPoints.pVirtualChannelWriteEx);
87 status = cliprdr->channelEntryPoints.pVirtualChannelWriteEx(
88 cliprdr->InitHandle, cliprdr->OpenHandle, Stream_Buffer(s),
89 (UINT32)Stream_GetPosition(s), s);
90 }
91
92fail:
93 if (status != CHANNEL_RC_OK)
94 {
95 Stream_Free(s, TRUE);
96 WLog_Print(cliprdr->log, WLOG_ERROR, "VirtualChannelWrite failed with %s [%08" PRIX32 "]",
97 WTSErrorToString(status), status);
98 }
99
100 return status;
101}
102
103UINT cliprdr_send_error_response(cliprdrPlugin* cliprdr, UINT16 type)
104{
105 wStream* s = cliprdr_packet_new(type, CB_RESPONSE_FAIL, 0);
106 if (!s)
107 {
108 WLog_Print(cliprdr->log, WLOG_ERROR, "cliprdr_packet_new failed!");
109 return ERROR_OUTOFMEMORY;
110 }
111
112 return cliprdr_packet_send(cliprdr, s);
113}
114
115static void cliprdr_print_general_capability_flags(wLog* log, UINT32 flags)
116{
117 WLog_Print(log, WLOG_DEBUG, "generalFlags (0x%08" PRIX32 ") {", flags);
118
119 if (flags & CB_USE_LONG_FORMAT_NAMES)
120 WLog_Print(log, WLOG_DEBUG, "\tCB_USE_LONG_FORMAT_NAMES");
121
122 if (flags & CB_STREAM_FILECLIP_ENABLED)
123 WLog_Print(log, WLOG_DEBUG, "\tCB_STREAM_FILECLIP_ENABLED");
124
125 if (flags & CB_FILECLIP_NO_FILE_PATHS)
126 WLog_Print(log, WLOG_DEBUG, "\tCB_FILECLIP_NO_FILE_PATHS");
127
128 if (flags & CB_CAN_LOCK_CLIPDATA)
129 WLog_Print(log, WLOG_DEBUG, "\tCB_CAN_LOCK_CLIPDATA");
130
131 if (flags & CB_HUGE_FILE_SUPPORT_ENABLED)
132 WLog_Print(log, WLOG_DEBUG, "\tCB_HUGE_FILE_SUPPORT_ENABLED");
133
134 WLog_Print(log, WLOG_DEBUG, "}");
135}
136
142static UINT cliprdr_process_general_capability(cliprdrPlugin* cliprdr, wStream* s)
143{
144 UINT32 version = 0;
145 UINT32 generalFlags = 0;
146 CLIPRDR_CAPABILITIES capabilities = WINPR_C_ARRAY_INIT;
147 CLIPRDR_GENERAL_CAPABILITY_SET generalCapabilitySet = WINPR_C_ARRAY_INIT;
148 CliprdrClientContext* context = cliprdr_get_client_interface(cliprdr);
149 UINT error = CHANNEL_RC_OK;
150
151 WINPR_ASSERT(cliprdr);
152 WINPR_ASSERT(s);
153
154 if (!context)
155 {
156 WLog_Print(cliprdr->log, WLOG_ERROR, "cliprdr_get_client_interface failed!");
157 return ERROR_INTERNAL_ERROR;
158 }
159
160 if (!Stream_CheckAndLogRequiredLengthWLog(cliprdr->log, s, 8))
161 return ERROR_INVALID_DATA;
162
163 Stream_Read_UINT32(s, version); /* version (4 bytes) */
164 Stream_Read_UINT32(s, generalFlags); /* generalFlags (4 bytes) */
165 WLog_Print(cliprdr->log, WLOG_DEBUG, "Version: %" PRIu32 "", version);
166
167 cliprdr_print_general_capability_flags(cliprdr->log, generalFlags);
168
169 cliprdr->useLongFormatNames = (generalFlags & CB_USE_LONG_FORMAT_NAMES) != 0;
170 cliprdr->streamFileClipEnabled = (generalFlags & CB_STREAM_FILECLIP_ENABLED) != 0;
171 cliprdr->fileClipNoFilePaths = (generalFlags & CB_FILECLIP_NO_FILE_PATHS) != 0;
172 cliprdr->canLockClipData = (generalFlags & CB_CAN_LOCK_CLIPDATA) != 0;
173 cliprdr->hasHugeFileSupport = (generalFlags & CB_HUGE_FILE_SUPPORT_ENABLED) != 0;
174 cliprdr->capabilitiesReceived = TRUE;
175
176 capabilities.common.msgType = CB_CLIP_CAPS;
177 capabilities.cCapabilitiesSets = 1;
178 capabilities.capabilitySets = (CLIPRDR_CAPABILITY_SET*)&(generalCapabilitySet);
179 generalCapabilitySet.capabilitySetType = CB_CAPSTYPE_GENERAL;
180 generalCapabilitySet.capabilitySetLength = 12;
181 generalCapabilitySet.version = version;
182 generalCapabilitySet.generalFlags = generalFlags;
183 IFCALLRET(context->ServerCapabilities, error, context, &capabilities);
184
185 if (error)
186 WLog_Print(cliprdr->log, WLOG_ERROR, "ServerCapabilities failed with error %" PRIu32 "!",
187 error);
188
189 return error;
190}
191
197static UINT cliprdr_process_clip_caps(cliprdrPlugin* cliprdr, wStream* s,
198 WINPR_ATTR_UNUSED UINT32 length,
199 WINPR_ATTR_UNUSED UINT16 flags)
200{
201 UINT16 lengthCapability = 0;
202 UINT16 cCapabilitiesSets = 0;
203 UINT16 capabilitySetType = 0;
204 UINT error = CHANNEL_RC_OK;
205
206 WINPR_ASSERT(cliprdr);
207 WINPR_ASSERT(s);
208
209 if (!Stream_CheckAndLogRequiredLengthWLog(cliprdr->log, s, 4))
210 return ERROR_INVALID_DATA;
211
212 Stream_Read_UINT16(s, cCapabilitiesSets); /* cCapabilitiesSets (2 bytes) */
213 Stream_Seek_UINT16(s); /* pad1 (2 bytes) */
214 WLog_Print(cliprdr->log, WLOG_DEBUG, "ServerCapabilities");
215
216 for (UINT16 index = 0; index < cCapabilitiesSets; index++)
217 {
218 if (!Stream_CheckAndLogRequiredLengthWLog(cliprdr->log, s, 4))
219 return ERROR_INVALID_DATA;
220
221 Stream_Read_UINT16(s, capabilitySetType); /* capabilitySetType (2 bytes) */
222 Stream_Read_UINT16(s, lengthCapability); /* lengthCapability (2 bytes) */
223
224 if ((lengthCapability < 4) ||
225 (!Stream_CheckAndLogRequiredLengthWLog(cliprdr->log, s, lengthCapability - 4U)))
226 return ERROR_INVALID_DATA;
227
228 switch (capabilitySetType)
229 {
230 case CB_CAPSTYPE_GENERAL:
231 if ((error = cliprdr_process_general_capability(cliprdr, s)))
232 {
233 WLog_Print(cliprdr->log, WLOG_ERROR,
234 "cliprdr_process_general_capability failed with error %" PRIu32 "!",
235 error);
236 return error;
237 }
238
239 break;
240
241 default:
242 WLog_Print(cliprdr->log, WLOG_ERROR, "unknown cliprdr capability set: %" PRIu16 "",
243 capabilitySetType);
244 return CHANNEL_RC_BAD_PROC;
245 }
246 }
247
248 return error;
249}
250
256static UINT cliprdr_process_monitor_ready(cliprdrPlugin* cliprdr, WINPR_ATTR_UNUSED wStream* s,
257 UINT32 length, UINT16 flags)
258{
259 CLIPRDR_MONITOR_READY monitorReady = WINPR_C_ARRAY_INIT;
260 CliprdrClientContext* context = cliprdr_get_client_interface(cliprdr);
261 UINT error = CHANNEL_RC_OK;
262
263 WINPR_ASSERT(cliprdr);
264 WINPR_ASSERT(s);
265
266 WLog_Print(cliprdr->log, WLOG_DEBUG, "MonitorReady");
267
268 if (!cliprdr->capabilitiesReceived)
269 {
276 cliprdr->useLongFormatNames = FALSE;
277 cliprdr->streamFileClipEnabled = FALSE;
278 cliprdr->fileClipNoFilePaths = TRUE;
279 cliprdr->canLockClipData = FALSE;
280 }
281
282 monitorReady.common.msgType = CB_MONITOR_READY;
283 monitorReady.common.msgFlags = flags;
284 monitorReady.common.dataLen = length;
285 IFCALLRET(context->MonitorReady, error, context, &monitorReady);
286
287 if (error)
288 WLog_Print(cliprdr->log, WLOG_ERROR, "MonitorReady failed with error %" PRIu32 "!", error);
289
290 return error;
291}
292
298static UINT cliprdr_process_filecontents_request(cliprdrPlugin* cliprdr, wStream* s, UINT32 length,
299 UINT16 flags)
300{
301 CLIPRDR_FILE_CONTENTS_REQUEST request = WINPR_C_ARRAY_INIT;
302 CliprdrClientContext* context = cliprdr_get_client_interface(cliprdr);
303 UINT error = CHANNEL_RC_OK;
304
305 WINPR_ASSERT(cliprdr);
306 WINPR_ASSERT(s);
307
308 WLog_Print(cliprdr->log, WLOG_DEBUG, "FileContentsRequest");
309
310 request.common.msgType = CB_FILECONTENTS_REQUEST;
311 request.common.msgFlags = flags;
312 request.common.dataLen = length;
313
314 if ((error = cliprdr_read_file_contents_request(s, &request)))
315 return error;
316
317 const UINT32 mask =
318 freerdp_settings_get_uint32(context->rdpcontext->settings, FreeRDP_ClipboardFeatureMask);
319 if ((mask & (CLIPRDR_FLAG_LOCAL_TO_REMOTE_FILES)) == 0)
320 {
321 WLog_Print(cliprdr->log, WLOG_WARN, "local -> remote file copy disabled, ignoring request");
322 return cliprdr_send_error_response(cliprdr, CB_FILECONTENTS_RESPONSE);
323 }
324 IFCALLRET(context->ServerFileContentsRequest, error, context, &request);
325
326 if (error)
327 WLog_Print(cliprdr->log, WLOG_ERROR,
328 "ServerFileContentsRequest failed with error %" PRIu32 "!", error);
329
330 return error;
331}
332
338static UINT cliprdr_process_filecontents_response(cliprdrPlugin* cliprdr, wStream* s, UINT32 length,
339 UINT16 flags)
340{
341 CLIPRDR_FILE_CONTENTS_RESPONSE response = WINPR_C_ARRAY_INIT;
342 CliprdrClientContext* context = cliprdr_get_client_interface(cliprdr);
343 UINT error = CHANNEL_RC_OK;
344
345 WINPR_ASSERT(cliprdr);
346 WINPR_ASSERT(s);
347
348 WLog_Print(cliprdr->log, WLOG_DEBUG, "FileContentsResponse");
349
350 response.common.msgType = CB_FILECONTENTS_RESPONSE;
351 response.common.msgFlags = flags;
352 response.common.dataLen = length;
353
354 if ((error = cliprdr_read_file_contents_response(s, &response)))
355 return error;
356
357 IFCALLRET(context->ServerFileContentsResponse, error, context, &response);
358
359 if (error)
360 WLog_Print(cliprdr->log, WLOG_ERROR,
361 "ServerFileContentsResponse failed with error %" PRIu32 "!", error);
362
363 return error;
364}
365
371static UINT cliprdr_process_lock_clipdata(cliprdrPlugin* cliprdr, wStream* s, UINT32 length,
372 UINT16 flags)
373{
374 CLIPRDR_LOCK_CLIPBOARD_DATA lockClipboardData = WINPR_C_ARRAY_INIT;
375 CliprdrClientContext* context = cliprdr_get_client_interface(cliprdr);
376 UINT error = CHANNEL_RC_OK;
377
378 WINPR_ASSERT(cliprdr);
379 WINPR_ASSERT(s);
380
381 WLog_Print(cliprdr->log, WLOG_DEBUG, "LockClipData");
382
383 if (!Stream_CheckAndLogRequiredLengthWLog(cliprdr->log, s, 4))
384 return ERROR_INVALID_DATA;
385
386 lockClipboardData.common.msgType = CB_LOCK_CLIPDATA;
387 lockClipboardData.common.msgFlags = flags;
388 lockClipboardData.common.dataLen = length;
389 Stream_Read_UINT32(s, lockClipboardData.clipDataId); /* clipDataId (4 bytes) */
390 IFCALLRET(context->ServerLockClipboardData, error, context, &lockClipboardData);
391
392 if (error)
393 WLog_Print(cliprdr->log, WLOG_ERROR,
394 "ServerLockClipboardData failed with error %" PRIu32 "!", error);
395
396 return error;
397}
398
404static UINT cliprdr_process_unlock_clipdata(cliprdrPlugin* cliprdr, wStream* s, UINT32 length,
405 UINT16 flags)
406{
407 CLIPRDR_UNLOCK_CLIPBOARD_DATA unlockClipboardData = WINPR_C_ARRAY_INIT;
408 CliprdrClientContext* context = cliprdr_get_client_interface(cliprdr);
409 UINT error = CHANNEL_RC_OK;
410
411 WINPR_ASSERT(cliprdr);
412 WINPR_ASSERT(s);
413
414 WLog_Print(cliprdr->log, WLOG_DEBUG, "UnlockClipData");
415
416 if ((error = cliprdr_read_unlock_clipdata(s, &unlockClipboardData)))
417 return error;
418
419 unlockClipboardData.common.msgType = CB_UNLOCK_CLIPDATA;
420 unlockClipboardData.common.msgFlags = flags;
421 unlockClipboardData.common.dataLen = length;
422
423 IFCALLRET(context->ServerUnlockClipboardData, error, context, &unlockClipboardData);
424
425 if (error)
426 WLog_Print(cliprdr->log, WLOG_ERROR,
427 "ServerUnlockClipboardData failed with error %" PRIu32 "!", error);
428
429 return error;
430}
431
437static UINT cliprdr_order_recv(LPVOID userdata, wStream* s)
438{
439 cliprdrPlugin* cliprdr = userdata;
440 UINT16 msgType = 0;
441 UINT16 msgFlags = 0;
442 UINT32 dataLen = 0;
443 UINT error = 0;
444
445 WINPR_ASSERT(cliprdr);
446 WINPR_ASSERT(s);
447
448 if (!Stream_CheckAndLogRequiredLengthWLog(cliprdr->log, s, 8))
449 return ERROR_INVALID_DATA;
450
451 Stream_Read_UINT16(s, msgType); /* msgType (2 bytes) */
452 Stream_Read_UINT16(s, msgFlags); /* msgFlags (2 bytes) */
453 Stream_Read_UINT32(s, dataLen); /* dataLen (4 bytes) */
454
455 if (!Stream_CheckAndLogRequiredLengthWLog(cliprdr->log, s, dataLen))
456 return ERROR_INVALID_DATA;
457
458 char buffer1[64] = WINPR_C_ARRAY_INIT;
459 char buffer2[64] = WINPR_C_ARRAY_INIT;
460 WLog_Print(cliprdr->log, WLOG_DEBUG,
461 "msgType: %s (%" PRIu16 "), msgFlags: %s dataLen: %" PRIu32 "",
462 CB_MSG_TYPE_STRING(msgType, buffer1, sizeof(buffer1)), msgType,
463 CB_MSG_FLAGS_STRING(msgFlags, buffer2, sizeof(buffer2)), dataLen);
464
465 switch (msgType)
466 {
467 case CB_CLIP_CAPS:
468 if ((error = cliprdr_process_clip_caps(cliprdr, s, dataLen, msgFlags)))
469 WLog_Print(cliprdr->log, WLOG_ERROR,
470 "cliprdr_process_clip_caps failed with error %" PRIu32 "!", error);
471
472 break;
473
474 case CB_MONITOR_READY:
475 if ((error = cliprdr_process_monitor_ready(cliprdr, s, dataLen, msgFlags)))
476 WLog_Print(cliprdr->log, WLOG_ERROR,
477 "cliprdr_process_monitor_ready failed with error %" PRIu32 "!", error);
478
479 break;
480
481 case CB_FORMAT_LIST:
482 if ((error = cliprdr_process_format_list(cliprdr, s, dataLen, msgFlags)))
483 WLog_Print(cliprdr->log, WLOG_ERROR,
484 "cliprdr_process_format_list failed with error %" PRIu32 "!", error);
485
486 break;
487
488 case CB_FORMAT_LIST_RESPONSE:
489 if ((error = cliprdr_process_format_list_response(cliprdr, s, dataLen, msgFlags)))
490 WLog_Print(cliprdr->log, WLOG_ERROR,
491 "cliprdr_process_format_list_response failed with error %" PRIu32 "!",
492 error);
493
494 break;
495
496 case CB_FORMAT_DATA_REQUEST:
497 if ((error = cliprdr_process_format_data_request(cliprdr, s, dataLen, msgFlags)))
498 WLog_Print(cliprdr->log, WLOG_ERROR,
499 "cliprdr_process_format_data_request failed with error %" PRIu32 "!",
500 error);
501
502 break;
503
504 case CB_FORMAT_DATA_RESPONSE:
505 if ((error = cliprdr_process_format_data_response(cliprdr, s, dataLen, msgFlags)))
506 WLog_Print(cliprdr->log, WLOG_ERROR,
507 "cliprdr_process_format_data_response failed with error %" PRIu32 "!",
508 error);
509
510 break;
511
512 case CB_FILECONTENTS_REQUEST:
513 if ((error = cliprdr_process_filecontents_request(cliprdr, s, dataLen, msgFlags)))
514 WLog_Print(cliprdr->log, WLOG_ERROR,
515 "cliprdr_process_filecontents_request failed with error %" PRIu32 "!",
516 error);
517
518 break;
519
520 case CB_FILECONTENTS_RESPONSE:
521 if ((error = cliprdr_process_filecontents_response(cliprdr, s, dataLen, msgFlags)))
522 WLog_Print(cliprdr->log, WLOG_ERROR,
523 "cliprdr_process_filecontents_response failed with error %" PRIu32 "!",
524 error);
525
526 break;
527
528 case CB_LOCK_CLIPDATA:
529 if ((error = cliprdr_process_lock_clipdata(cliprdr, s, dataLen, msgFlags)))
530 WLog_Print(cliprdr->log, WLOG_ERROR,
531 "cliprdr_process_lock_clipdata failed with error %" PRIu32 "!", error);
532
533 break;
534
535 case CB_UNLOCK_CLIPDATA:
536 if ((error = cliprdr_process_unlock_clipdata(cliprdr, s, dataLen, msgFlags)))
537 WLog_Print(cliprdr->log, WLOG_ERROR,
538 "cliprdr_process_unlock_clipdata failed with error %" PRIu32 "!", error);
539
540 break;
541
542 default:
543 error = CHANNEL_RC_BAD_PROC;
544 WLog_Print(cliprdr->log, WLOG_ERROR, "unknown msgType %" PRIu16 "", msgType);
545 break;
546 }
547
548 Stream_Free(s, TRUE);
549 return error;
550}
551
561static UINT cliprdr_client_capabilities(CliprdrClientContext* context,
562 const CLIPRDR_CAPABILITIES* capabilities)
563{
564 wStream* s = nullptr;
565 UINT32 flags = 0;
566 const CLIPRDR_GENERAL_CAPABILITY_SET* generalCapabilitySet = nullptr;
567 cliprdrPlugin* cliprdr = nullptr;
568
569 WINPR_ASSERT(context);
570
571 cliprdr = (cliprdrPlugin*)context->handle;
572 WINPR_ASSERT(cliprdr);
573
574 s = cliprdr_packet_new(CB_CLIP_CAPS, 0, 4 + CB_CAPSTYPE_GENERAL_LEN);
575
576 if (!s)
577 {
578 WLog_Print(cliprdr->log, WLOG_ERROR, "cliprdr_packet_new failed!");
579 return ERROR_INTERNAL_ERROR;
580 }
581
582 Stream_Write_UINT16(s, 1); /* cCapabilitiesSets */
583 Stream_Write_UINT16(s, 0); /* pad1 */
584 generalCapabilitySet = WINPR_PACKED_ALIGN_CAST(const CLIPRDR_GENERAL_CAPABILITY_SET*,
585 capabilities->capabilitySets);
586 Stream_Write_UINT16(s, generalCapabilitySet->capabilitySetType); /* capabilitySetType */
587 Stream_Write_UINT16(s, generalCapabilitySet->capabilitySetLength); /* lengthCapability */
588 Stream_Write_UINT32(s, generalCapabilitySet->version); /* version */
589 flags = generalCapabilitySet->generalFlags;
590
591 /* Client capabilities are sent in response to server capabilities.
592 * -> Do not request features the server does not support.
593 * -> Update clipboard context feature state to what was agreed upon.
594 */
595 if (!cliprdr->useLongFormatNames)
596 flags &= (uint32_t)~CB_USE_LONG_FORMAT_NAMES;
597 if (!cliprdr->streamFileClipEnabled)
598 flags &= (uint32_t)~CB_STREAM_FILECLIP_ENABLED;
599 if (!cliprdr->fileClipNoFilePaths)
600 flags &= (uint32_t)~CB_FILECLIP_NO_FILE_PATHS;
601 if (!cliprdr->canLockClipData)
602 flags &= (uint32_t)~CB_CAN_LOCK_CLIPDATA;
603 if (!cliprdr->hasHugeFileSupport)
604 flags &= (uint32_t)~CB_HUGE_FILE_SUPPORT_ENABLED;
605
606 cliprdr->useLongFormatNames = (flags & CB_USE_LONG_FORMAT_NAMES) != 0;
607 cliprdr->streamFileClipEnabled = (flags & CB_STREAM_FILECLIP_ENABLED) != 0;
608 cliprdr->fileClipNoFilePaths = (flags & CB_FILECLIP_NO_FILE_PATHS) != 0;
609 cliprdr->canLockClipData = (flags & CB_CAN_LOCK_CLIPDATA) != 0;
610 cliprdr->hasHugeFileSupport = (flags & CB_HUGE_FILE_SUPPORT_ENABLED) != 0;
611
612 Stream_Write_UINT32(s, flags); /* generalFlags */
613 WLog_Print(cliprdr->log, WLOG_DEBUG, "ClientCapabilities");
614
615 cliprdr->initialFormatListSent = FALSE;
616
617 return cliprdr_packet_send(cliprdr, s);
618}
619
625static UINT cliprdr_temp_directory(CliprdrClientContext* context,
626 const CLIPRDR_TEMP_DIRECTORY* tempDirectory)
627{
628 wStream* s = nullptr;
629 cliprdrPlugin* cliprdr = nullptr;
630
631 WINPR_ASSERT(context);
632 WINPR_ASSERT(tempDirectory);
633
634 cliprdr = (cliprdrPlugin*)context->handle;
635 WINPR_ASSERT(cliprdr);
636
637 const size_t tmpDirCharLen = sizeof(tempDirectory->szTempDir) / sizeof(WCHAR);
638 s = cliprdr_packet_new(CB_TEMP_DIRECTORY, 0, tmpDirCharLen * sizeof(WCHAR));
639
640 if (!s)
641 {
642 WLog_Print(cliprdr->log, WLOG_ERROR, "cliprdr_packet_new failed!");
643 return ERROR_INTERNAL_ERROR;
644 }
645
646 if (Stream_Write_UTF16_String_From_UTF8(s, tmpDirCharLen - 1, tempDirectory->szTempDir,
647 ARRAYSIZE(tempDirectory->szTempDir), TRUE) < 0)
648 {
649 Stream_Free(s, TRUE);
650 return ERROR_INTERNAL_ERROR;
651 }
652 /* Path must be 260 UTF16 characters with '\0' termination.
653 * ensure this here */
654 Stream_Write_UINT16(s, 0);
655
656 WLog_Print(cliprdr->log, WLOG_DEBUG, "TempDirectory: %s", tempDirectory->szTempDir);
657 return cliprdr_packet_send(cliprdr, s);
658}
659
665static UINT cliprdr_client_format_list(CliprdrClientContext* context,
666 const CLIPRDR_FORMAT_LIST* formatList)
667{
668 wStream* s = nullptr;
669 cliprdrPlugin* cliprdr = nullptr;
670
671 WINPR_ASSERT(context);
672 WINPR_ASSERT(formatList);
673
674 cliprdr = (cliprdrPlugin*)context->handle;
675 WINPR_ASSERT(cliprdr);
676
677 {
678 const UINT32 mask = CB_RESPONSE_OK | CB_RESPONSE_FAIL;
679 if ((formatList->common.msgFlags & mask) != 0)
680 WLog_Print(cliprdr->log, WLOG_WARN,
681 "Sending clipboard request with invalid flags msgFlags = 0x%08" PRIx32
682 ". Correct in your client!",
683 formatList->common.msgFlags & mask);
684 }
685
686 const UINT32 mask =
687 freerdp_settings_get_uint32(context->rdpcontext->settings, FreeRDP_ClipboardFeatureMask);
688 CLIPRDR_FORMAT_LIST filterList = cliprdr_filter_format_list(
689 formatList, mask, CLIPRDR_FLAG_LOCAL_TO_REMOTE | CLIPRDR_FLAG_LOCAL_TO_REMOTE_FILES);
690
691 /* Allow initial format list from monitor ready, but ignore later attempts */
692 if ((filterList.numFormats == 0) && cliprdr->initialFormatListSent)
693 {
694 cliprdr_free_format_list(&filterList);
695 return CHANNEL_RC_OK;
696 }
697 cliprdr->initialFormatListSent = TRUE;
698
699 const uint32_t level = WLOG_DEBUG;
700 if (WLog_IsLevelActive(cliprdr->log, level))
701 {
702 WLog_Print(cliprdr->log, level, "ClientFormatList: numFormats: %" PRIu32 "",
703 formatList->numFormats);
704 for (size_t x = 0; x < filterList.numFormats; x++)
705 {
706 const CLIPRDR_FORMAT* format = &filterList.formats[x];
707 WLog_Print(cliprdr->log, level, "[%" PRIuz "]: id=0x%08" PRIx32 " [%s|%s]", x,
708 format->formatId, ClipboardGetFormatIdString(format->formatId),
709 format->formatName);
710 }
711 }
712
713 s = cliprdr_packet_format_list_new(&filterList, cliprdr->useLongFormatNames, FALSE);
714 cliprdr_free_format_list(&filterList);
715
716 if (!s)
717 {
718 WLog_Print(cliprdr->log, WLOG_ERROR, "cliprdr_packet_format_list_new failed!");
719 return ERROR_INTERNAL_ERROR;
720 }
721
722 return cliprdr_packet_send(cliprdr, s);
723}
724
730static UINT
731cliprdr_client_format_list_response(CliprdrClientContext* context,
732 const CLIPRDR_FORMAT_LIST_RESPONSE* formatListResponse)
733{
734 wStream* s = nullptr;
735 cliprdrPlugin* cliprdr = nullptr;
736
737 WINPR_ASSERT(context);
738 WINPR_ASSERT(formatListResponse);
739
740 cliprdr = (cliprdrPlugin*)context->handle;
741 WINPR_ASSERT(cliprdr);
742
743 s = cliprdr_packet_new(CB_FORMAT_LIST_RESPONSE, formatListResponse->common.msgFlags, 0);
744
745 if (!s)
746 {
747 WLog_Print(cliprdr->log, WLOG_ERROR, "cliprdr_packet_new failed!");
748 return ERROR_INTERNAL_ERROR;
749 }
750
751 WLog_Print(cliprdr->log, WLOG_DEBUG, "ClientFormatListResponse");
752 return cliprdr_packet_send(cliprdr, s);
753}
754
760static UINT cliprdr_client_lock_clipboard_data(CliprdrClientContext* context,
761 const CLIPRDR_LOCK_CLIPBOARD_DATA* lockClipboardData)
762{
763 wStream* s = nullptr;
764 cliprdrPlugin* cliprdr = nullptr;
765
766 WINPR_ASSERT(context);
767 WINPR_ASSERT(lockClipboardData);
768
769 cliprdr = (cliprdrPlugin*)context->handle;
770 WINPR_ASSERT(cliprdr);
771
772 s = cliprdr_packet_lock_clipdata_new(lockClipboardData);
773
774 if (!s)
775 {
776 WLog_Print(cliprdr->log, WLOG_ERROR, "cliprdr_packet_lock_clipdata_new failed!");
777 return ERROR_INTERNAL_ERROR;
778 }
779
780 WLog_Print(cliprdr->log, WLOG_DEBUG, "ClientLockClipboardData: clipDataId: 0x%08" PRIX32 "",
781 lockClipboardData->clipDataId);
782 return cliprdr_packet_send(cliprdr, s);
783}
784
790static UINT
791cliprdr_client_unlock_clipboard_data(CliprdrClientContext* context,
792 const CLIPRDR_UNLOCK_CLIPBOARD_DATA* unlockClipboardData)
793{
794 wStream* s = nullptr;
795 cliprdrPlugin* cliprdr = nullptr;
796
797 WINPR_ASSERT(context);
798 WINPR_ASSERT(unlockClipboardData);
799
800 cliprdr = (cliprdrPlugin*)context->handle;
801 WINPR_ASSERT(cliprdr);
802
803 s = cliprdr_packet_unlock_clipdata_new(unlockClipboardData);
804
805 if (!s)
806 {
807 WLog_Print(cliprdr->log, WLOG_ERROR, "cliprdr_packet_unlock_clipdata_new failed!");
808 return ERROR_INTERNAL_ERROR;
809 }
810
811 WLog_Print(cliprdr->log, WLOG_DEBUG, "ClientUnlockClipboardData: clipDataId: 0x%08" PRIX32 "",
812 unlockClipboardData->clipDataId);
813 return cliprdr_packet_send(cliprdr, s);
814}
815
821static UINT cliprdr_client_format_data_request(CliprdrClientContext* context,
822 const CLIPRDR_FORMAT_DATA_REQUEST* formatDataRequest)
823{
824 WINPR_ASSERT(context);
825 WINPR_ASSERT(formatDataRequest);
826
827 cliprdrPlugin* cliprdr = (cliprdrPlugin*)context->handle;
828 WINPR_ASSERT(cliprdr);
829
830 const UINT32 mask =
831 freerdp_settings_get_uint32(context->rdpcontext->settings, FreeRDP_ClipboardFeatureMask);
832 if ((mask & (CLIPRDR_FLAG_REMOTE_TO_LOCAL | CLIPRDR_FLAG_REMOTE_TO_LOCAL_FILES)) == 0)
833 {
834 WLog_Print(cliprdr->log, WLOG_WARN, "remote -> local copy disabled, ignoring request");
835 return CHANNEL_RC_OK;
836 }
837
838 wStream* s = cliprdr_packet_new(CB_FORMAT_DATA_REQUEST, 0, 4);
839 if (!s)
840 {
841 WLog_Print(cliprdr->log, WLOG_ERROR, "cliprdr_packet_new failed!");
842 return ERROR_INTERNAL_ERROR;
843 }
844
845 Stream_Write_UINT32(s, formatDataRequest->requestedFormatId); /* requestedFormatId (4 bytes) */
846 WLog_Print(cliprdr->log, WLOG_DEBUG, "ClientFormatDataRequest(0x%08" PRIx32 " [%s])",
847 formatDataRequest->requestedFormatId,
848 ClipboardGetFormatIdString(formatDataRequest->requestedFormatId));
849 return cliprdr_packet_send(cliprdr, s);
850}
851
857static UINT
858cliprdr_client_format_data_response(CliprdrClientContext* context,
859 const CLIPRDR_FORMAT_DATA_RESPONSE* formatDataResponse)
860{
861 WINPR_ASSERT(context);
862 WINPR_ASSERT(formatDataResponse);
863
864 cliprdrPlugin* cliprdr = (cliprdrPlugin*)context->handle;
865 WINPR_ASSERT(cliprdr);
866
867 WINPR_ASSERT(
868 (freerdp_settings_get_uint32(context->rdpcontext->settings, FreeRDP_ClipboardFeatureMask) &
869 (CLIPRDR_FLAG_LOCAL_TO_REMOTE | CLIPRDR_FLAG_LOCAL_TO_REMOTE_FILES)) != 0);
870
871 wStream* s = cliprdr_packet_new(CB_FORMAT_DATA_RESPONSE, formatDataResponse->common.msgFlags,
872 formatDataResponse->common.dataLen);
873
874 if (!s)
875 {
876 WLog_Print(cliprdr->log, WLOG_ERROR, "cliprdr_packet_new failed!");
877 return ERROR_INTERNAL_ERROR;
878 }
879
880 Stream_Write(s, formatDataResponse->requestedFormatData, formatDataResponse->common.dataLen);
881 WLog_Print(cliprdr->log, WLOG_DEBUG, "ClientFormatDataResponse");
882 return cliprdr_packet_send(cliprdr, s);
883}
884
890static UINT
891cliprdr_client_file_contents_request(CliprdrClientContext* context,
892 const CLIPRDR_FILE_CONTENTS_REQUEST* fileContentsRequest)
893{
894 wStream* s = nullptr;
895
896 WINPR_ASSERT(context);
897 WINPR_ASSERT(fileContentsRequest);
898
899 cliprdrPlugin* cliprdr = (cliprdrPlugin*)context->handle;
900 if (!cliprdr)
901 return ERROR_INTERNAL_ERROR;
902
903 const UINT32 mask =
904 freerdp_settings_get_uint32(context->rdpcontext->settings, FreeRDP_ClipboardFeatureMask);
905 if ((mask & CLIPRDR_FLAG_REMOTE_TO_LOCAL_FILES) == 0)
906 {
907 WLog_Print(cliprdr->log, WLOG_WARN, "remote -> local file copy disabled, ignoring request");
908 return CHANNEL_RC_OK;
909 }
910
911 if (!cliprdr->hasHugeFileSupport)
912 {
913 if (((UINT64)fileContentsRequest->cbRequested + fileContentsRequest->nPositionLow) >
914 UINT32_MAX)
915 return ERROR_INVALID_PARAMETER;
916 if (fileContentsRequest->nPositionHigh != 0)
917 return ERROR_INVALID_PARAMETER;
918 }
919
920 s = cliprdr_packet_file_contents_request_new(fileContentsRequest);
921
922 if (!s)
923 {
924 WLog_Print(cliprdr->log, WLOG_ERROR, "cliprdr_packet_file_contents_request_new failed!");
925 return ERROR_INTERNAL_ERROR;
926 }
927
928 WLog_Print(cliprdr->log, WLOG_DEBUG, "ClientFileContentsRequest: streamId: 0x%08" PRIX32 "",
929 fileContentsRequest->streamId);
930 return cliprdr_packet_send(cliprdr, s);
931}
932
938static UINT
939cliprdr_client_file_contents_response(CliprdrClientContext* context,
940 const CLIPRDR_FILE_CONTENTS_RESPONSE* fileContentsResponse)
941{
942 wStream* s = nullptr;
943 cliprdrPlugin* cliprdr = nullptr;
944
945 WINPR_ASSERT(context);
946 WINPR_ASSERT(fileContentsResponse);
947
948 cliprdr = (cliprdrPlugin*)context->handle;
949 WINPR_ASSERT(cliprdr);
950
951 const UINT32 mask =
952 freerdp_settings_get_uint32(context->rdpcontext->settings, FreeRDP_ClipboardFeatureMask);
953 if ((mask & CLIPRDR_FLAG_LOCAL_TO_REMOTE_FILES) == 0)
954 return cliprdr_send_error_response(cliprdr, CB_FILECONTENTS_RESPONSE);
955
956 s = cliprdr_packet_file_contents_response_new(fileContentsResponse);
957
958 if (!s)
959 {
960 WLog_Print(cliprdr->log, WLOG_ERROR, "cliprdr_packet_file_contents_response_new failed!");
961 return ERROR_INTERNAL_ERROR;
962 }
963
964 WLog_Print(cliprdr->log, WLOG_DEBUG, "ClientFileContentsResponse: streamId: 0x%08" PRIX32 "",
965 fileContentsResponse->streamId);
966 return cliprdr_packet_send(cliprdr, s);
967}
968
969static VOID VCAPITYPE cliprdr_virtual_channel_open_event_ex(LPVOID lpUserParam, DWORD openHandle,
970 UINT event, LPVOID pData,
971 UINT32 dataLength, UINT32 totalLength,
972 UINT32 dataFlags)
973{
974 UINT error = CHANNEL_RC_OK;
975 cliprdrPlugin* cliprdr = (cliprdrPlugin*)lpUserParam;
976 WINPR_ASSERT(cliprdr);
977
978 switch (event)
979 {
980 case CHANNEL_EVENT_DATA_RECEIVED:
981 if (cliprdr->OpenHandle != openHandle)
982 {
983 WLog_Print(cliprdr->log, WLOG_ERROR, "error no match");
984 return;
985 }
986 if ((error = channel_client_post_message(cliprdr->MsgsHandle, pData, dataLength,
987 totalLength, dataFlags)))
988 WLog_Print(cliprdr->log, WLOG_ERROR, "failed with error %" PRIu32 "", error);
989
990 break;
991
992 case CHANNEL_EVENT_WRITE_CANCELLED:
993 case CHANNEL_EVENT_WRITE_COMPLETE:
994 {
995 wStream* s = (wStream*)pData;
996 Stream_Free(s, TRUE);
997 }
998 break;
999
1000 case CHANNEL_EVENT_USER:
1001 break;
1002 default:
1003 break;
1004 }
1005
1006 if (error && cliprdr->context->rdpcontext)
1007 setChannelError(cliprdr->context->rdpcontext, error,
1008 "cliprdr_virtual_channel_open_event_ex reported an error");
1009}
1010
1016static UINT cliprdr_virtual_channel_event_connected(cliprdrPlugin* cliprdr,
1017 WINPR_ATTR_UNUSED LPVOID pData,
1018 WINPR_ATTR_UNUSED UINT32 dataLength)
1019{
1020 DWORD status = 0;
1021 WINPR_ASSERT(cliprdr);
1022 WINPR_ASSERT(cliprdr->context);
1023
1024 WINPR_ASSERT(cliprdr->channelEntryPoints.pVirtualChannelOpenEx);
1025 status = cliprdr->channelEntryPoints.pVirtualChannelOpenEx(
1026 cliprdr->InitHandle, &cliprdr->OpenHandle, cliprdr->channelDef.name,
1027 cliprdr_virtual_channel_open_event_ex);
1028 if (status != CHANNEL_RC_OK)
1029 return status;
1030
1031 cliprdr->MsgsHandle = channel_client_create_handler(
1032 cliprdr->context->rdpcontext, cliprdr, cliprdr_order_recv, CLIPRDR_SVC_CHANNEL_NAME);
1033 if (!cliprdr->MsgsHandle)
1034 return ERROR_INTERNAL_ERROR;
1035
1036 return status;
1037}
1038
1044static UINT cliprdr_virtual_channel_event_disconnected(cliprdrPlugin* cliprdr)
1045{
1046 UINT rc = 0;
1047
1048 WINPR_ASSERT(cliprdr);
1049
1050 channel_client_quit_handler(cliprdr->MsgsHandle);
1051 cliprdr->MsgsHandle = nullptr;
1052
1053 if (cliprdr->OpenHandle == 0)
1054 return CHANNEL_RC_OK;
1055
1056 WINPR_ASSERT(cliprdr->channelEntryPoints.pVirtualChannelCloseEx);
1057 rc = cliprdr->channelEntryPoints.pVirtualChannelCloseEx(cliprdr->InitHandle,
1058 cliprdr->OpenHandle);
1059
1060 if (CHANNEL_RC_OK != rc)
1061 {
1062 WLog_Print(cliprdr->log, WLOG_ERROR, "pVirtualChannelClose failed with %s [%08" PRIX32 "]",
1063 WTSErrorToString(rc), rc);
1064 return rc;
1065 }
1066
1067 cliprdr->OpenHandle = 0;
1068
1069 return CHANNEL_RC_OK;
1070}
1071
1077static UINT cliprdr_virtual_channel_event_terminated(cliprdrPlugin* cliprdr)
1078{
1079 WINPR_ASSERT(cliprdr);
1080
1081 cliprdr->InitHandle = nullptr;
1082 free(cliprdr->context);
1083 free(cliprdr);
1084 return CHANNEL_RC_OK;
1085}
1086
1087static VOID VCAPITYPE cliprdr_virtual_channel_init_event_ex(LPVOID lpUserParam, LPVOID pInitHandle,
1088 UINT event, LPVOID pData,
1089 UINT dataLength)
1090{
1091 UINT error = CHANNEL_RC_OK;
1092 cliprdrPlugin* cliprdr = (cliprdrPlugin*)lpUserParam;
1093 WINPR_ASSERT(cliprdr);
1094
1095 if (cliprdr->InitHandle != pInitHandle)
1096 {
1097 WLog_Print(cliprdr->log, WLOG_ERROR, "error no match");
1098 return;
1099 }
1100
1101 switch (event)
1102 {
1103 case CHANNEL_EVENT_CONNECTED:
1104 if ((error = cliprdr_virtual_channel_event_connected(cliprdr, pData, dataLength)))
1105 WLog_Print(cliprdr->log, WLOG_ERROR,
1106 "cliprdr_virtual_channel_event_connected failed with error %" PRIu32 "!",
1107 error);
1108
1109 break;
1110
1111 case CHANNEL_EVENT_DISCONNECTED:
1112 if ((error = cliprdr_virtual_channel_event_disconnected(cliprdr)))
1113 WLog_Print(cliprdr->log, WLOG_ERROR,
1114 "cliprdr_virtual_channel_event_disconnected failed with error %" PRIu32
1115 "!",
1116 error);
1117
1118 break;
1119
1120 case CHANNEL_EVENT_TERMINATED:
1121 if ((error = cliprdr_virtual_channel_event_terminated(cliprdr)))
1122 WLog_Print(cliprdr->log, WLOG_ERROR,
1123 "cliprdr_virtual_channel_event_terminated failed with error %" PRIu32
1124 "!",
1125 error);
1126 break;
1127 default:
1128 break;
1129 }
1130
1131 if (error && cliprdr->context->rdpcontext)
1132 setChannelError(cliprdr->context->rdpcontext, error,
1133 "cliprdr_virtual_channel_init_event reported an error");
1134}
1135
1136/* cliprdr is always built-in */
1137#define VirtualChannelEntryEx cliprdr_VirtualChannelEntryEx
1138
1139FREERDP_ENTRY_POINT(BOOL VCAPITYPE VirtualChannelEntryEx(PCHANNEL_ENTRY_POINTS_EX pEntryPoints,
1140 PVOID pInitHandle))
1141{
1142 UINT rc = 0;
1143 CHANNEL_ENTRY_POINTS_FREERDP_EX* pEntryPointsEx = nullptr;
1144 cliprdrPlugin* cliprdr = (cliprdrPlugin*)calloc(1, sizeof(cliprdrPlugin));
1145
1146 wLog* log = WLog_Get(CHANNELS_TAG("cliprdr.client"));
1147 WINPR_ASSERT(log);
1148
1149 if (!cliprdr)
1150 {
1151 WLog_Print(log, WLOG_ERROR, "calloc failed!");
1152 return FALSE;
1153 }
1154
1155 cliprdr->log = log;
1156 cliprdr->channelDef.options = CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP |
1157 CHANNEL_OPTION_COMPRESS_RDP | CHANNEL_OPTION_SHOW_PROTOCOL;
1158 (void)sprintf_s(cliprdr->channelDef.name, ARRAYSIZE(cliprdr->channelDef.name),
1159 CLIPRDR_SVC_CHANNEL_NAME);
1160 pEntryPointsEx = (CHANNEL_ENTRY_POINTS_FREERDP_EX*)pEntryPoints;
1161 WINPR_ASSERT(pEntryPointsEx);
1162
1163 if ((pEntryPointsEx->cbSize >= sizeof(CHANNEL_ENTRY_POINTS_FREERDP_EX)) &&
1164 (pEntryPointsEx->MagicNumber == FREERDP_CHANNEL_MAGIC_NUMBER))
1165 {
1166 CliprdrClientContext* context =
1167 (CliprdrClientContext*)calloc(1, sizeof(CliprdrClientContext));
1168
1169 if (!context)
1170 {
1171 WLog_Print(cliprdr->log, WLOG_ERROR, "calloc failed!");
1172 free(cliprdr);
1173 return FALSE;
1174 }
1175
1176 context->handle = (void*)cliprdr;
1177 context->custom = nullptr;
1178 context->ClientCapabilities = cliprdr_client_capabilities;
1179 context->TempDirectory = cliprdr_temp_directory;
1180 context->ClientFormatList = cliprdr_client_format_list;
1181 context->ClientFormatListResponse = cliprdr_client_format_list_response;
1182 context->ClientLockClipboardData = cliprdr_client_lock_clipboard_data;
1183 context->ClientUnlockClipboardData = cliprdr_client_unlock_clipboard_data;
1184 context->ClientFormatDataRequest = cliprdr_client_format_data_request;
1185 context->ClientFormatDataResponse = cliprdr_client_format_data_response;
1186 context->ClientFileContentsRequest = cliprdr_client_file_contents_request;
1187 context->ClientFileContentsResponse = cliprdr_client_file_contents_response;
1188 cliprdr->context = context;
1189 context->rdpcontext = pEntryPointsEx->context;
1190 }
1191
1192 WLog_Print(cliprdr->log, WLOG_DEBUG, "VirtualChannelEntryEx");
1193 CopyMemory(&(cliprdr->channelEntryPoints), pEntryPoints,
1194 sizeof(CHANNEL_ENTRY_POINTS_FREERDP_EX));
1195 cliprdr->InitHandle = pInitHandle;
1196 rc = cliprdr->channelEntryPoints.pVirtualChannelInitEx(
1197 cliprdr, cliprdr->context, pInitHandle, &cliprdr->channelDef, 1,
1198 VIRTUAL_CHANNEL_VERSION_WIN2000, cliprdr_virtual_channel_init_event_ex);
1199
1200 if (CHANNEL_RC_OK != rc)
1201 {
1202 WLog_Print(cliprdr->log, WLOG_ERROR, "pVirtualChannelInit failed with %s [%08" PRIX32 "]",
1203 WTSErrorToString(rc), rc);
1204 free(cliprdr->context);
1205 free(cliprdr);
1206 return FALSE;
1207 }
1208
1209 cliprdr->channelEntryPoints.pInterface = cliprdr->context;
1210 return TRUE;
1211}
freerdp_settings_get_uint32
WINPR_ATTR_NODISCARD FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.
CHANNEL_ENTRY_POINTS_FREERDP_EX
Definition svc.h:60
CLIPRDR_CAPABILITIES
Definition channels/cliprdr.h:120
CLIPRDR_CAPABILITY_SET
Definition channels/cliprdr.h:105
CLIPRDR_FILE_CONTENTS_REQUEST
Definition channels/cliprdr.h:187
CLIPRDR_FILE_CONTENTS_RESPONSE
Definition channels/cliprdr.h:201
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_LOCK_CLIPBOARD_DATA
Definition channels/cliprdr.h:159
CLIPRDR_MONITOR_READY
Definition channels/cliprdr.h:128
CLIPRDR_TEMP_DIRECTORY
Definition channels/cliprdr.h:133
CLIPRDR_UNLOCK_CLIPBOARD_DATA
Definition channels/cliprdr.h:166