FreeRDP
Loading...
Searching...
No Matches
server/cliprdr_main.c
1
22#include <freerdp/config.h>
23
24#include <winpr/crt.h>
25#include <winpr/assert.h>
26#include <winpr/print.h>
27#include <winpr/stream.h>
28
29#include <freerdp/freerdp.h>
30#include <freerdp/channels/log.h>
31#include "cliprdr_main.h"
32#include "../cliprdr_common.h"
33
79static UINT cliprdr_server_packet_send(CliprdrServerPrivate* cliprdr, wStream* s)
80{
81 UINT rc = 0;
82 BOOL status = 0;
83 ULONG written = 0;
84
85 WINPR_ASSERT(cliprdr);
86
87 const size_t pos = Stream_GetPosition(s);
88 if ((pos < 8) || (pos > UINT32_MAX))
89 {
90 rc = ERROR_NO_DATA;
91 goto fail;
92 }
93
94 const UINT32 dataLen = (UINT32)(pos - 8);
95 if (!Stream_SetPosition(s, 4))
96 goto fail;
97 Stream_Write_UINT32(s, dataLen);
98
99 WINPR_ASSERT(pos <= UINT32_MAX);
100 status = WTSVirtualChannelWrite(cliprdr->ChannelHandle, Stream_BufferAs(s, char), (UINT32)pos,
101 &written);
102 rc = status ? CHANNEL_RC_OK : ERROR_INTERNAL_ERROR;
103fail:
104 Stream_Free(s, TRUE);
105 return rc;
106}
107
113static UINT cliprdr_server_capabilities(CliprdrServerContext* context,
114 const CLIPRDR_CAPABILITIES* capabilities)
115{
116 size_t offset = 0;
117
118 WINPR_ASSERT(context);
119 WINPR_ASSERT(capabilities);
120
121 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
122
123 if (capabilities->common.msgType != CB_CLIP_CAPS)
124 WLog_Print(cliprdr->log, WLOG_WARN, "called with invalid type %08" PRIx32,
125 capabilities->common.msgType);
126
127 if (capabilities->cCapabilitiesSets > UINT16_MAX)
128 {
129 WLog_Print(cliprdr->log, WLOG_ERROR, "Invalid number of capability sets in clipboard caps");
130 return ERROR_INVALID_PARAMETER;
131 }
132
133 wStream* s = cliprdr_packet_new(CB_CLIP_CAPS, 0, 4 + CB_CAPSTYPE_GENERAL_LEN);
134
135 if (!s)
136 {
137 WLog_Print(cliprdr->log, WLOG_ERROR, "cliprdr_packet_new failed!");
138 return ERROR_INTERNAL_ERROR;
139 }
140
141 Stream_Write_UINT16(s,
142 (UINT16)capabilities->cCapabilitiesSets); /* cCapabilitiesSets (2 bytes) */
143 Stream_Write_UINT16(s, 0); /* pad1 (2 bytes) */
144 for (UINT32 x = 0; x < capabilities->cCapabilitiesSets; x++)
145 {
146 const CLIPRDR_CAPABILITY_SET* cap = WINPR_PACKED_ALIGN_CAST(
147 const CLIPRDR_CAPABILITY_SET*, (((const BYTE*)capabilities->capabilitySets) + offset));
148 offset += cap->capabilitySetLength;
149
150 switch (cap->capabilitySetType)
151 {
152 case CB_CAPSTYPE_GENERAL:
153 {
154 const CLIPRDR_GENERAL_CAPABILITY_SET* generalCapabilitySet =
155 WINPR_PACKED_ALIGN_CAST(const CLIPRDR_GENERAL_CAPABILITY_SET*, cap);
156 Stream_Write_UINT16(
157 s, generalCapabilitySet->capabilitySetType); /* capabilitySetType (2 bytes) */
158 Stream_Write_UINT16(
159 s, generalCapabilitySet->capabilitySetLength); /* lengthCapability (2 bytes) */
160 Stream_Write_UINT32(s, generalCapabilitySet->version); /* version (4 bytes) */
161 Stream_Write_UINT32(
162 s, generalCapabilitySet->generalFlags); /* generalFlags (4 bytes) */
163 }
164 break;
165
166 default:
167 WLog_Print(cliprdr->log, WLOG_WARN, "Unknown capability set type %08" PRIx16,
168 cap->capabilitySetType);
169 if (!Stream_SafeZero(s, cap->capabilitySetLength))
170 {
171 WLog_Print(cliprdr->log, WLOG_ERROR, "short stream");
172 Stream_Free(s, TRUE);
173 return ERROR_NO_DATA;
174 }
175 break;
176 }
177 }
178 WLog_Print(cliprdr->log, WLOG_DEBUG, "ServerCapabilities");
179 return cliprdr_server_packet_send(cliprdr, s);
180}
181
187static UINT cliprdr_server_monitor_ready(CliprdrServerContext* context,
188 const CLIPRDR_MONITOR_READY* monitorReady)
189{
190 WINPR_ASSERT(context);
191 WINPR_ASSERT(monitorReady);
192
193 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
194
195 if (monitorReady->common.msgType != CB_MONITOR_READY)
196 WLog_Print(cliprdr->log, WLOG_WARN, "called with invalid type %08" PRIx32,
197 monitorReady->common.msgType);
198
199 wStream* s = cliprdr_packet_new(CB_MONITOR_READY, monitorReady->common.msgFlags,
200 monitorReady->common.dataLen);
201
202 if (!s)
203 {
204 WLog_Print(cliprdr->log, WLOG_ERROR, "cliprdr_packet_new failed!");
205 return ERROR_INTERNAL_ERROR;
206 }
207
208 WLog_Print(cliprdr->log, WLOG_DEBUG, "ServerMonitorReady");
209 return cliprdr_server_packet_send(cliprdr, s);
210}
211
217static UINT cliprdr_server_format_list(CliprdrServerContext* context,
218 const CLIPRDR_FORMAT_LIST* formatList)
219{
220 WINPR_ASSERT(context);
221 WINPR_ASSERT(formatList);
222
223 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
224
225 wStream* s = cliprdr_packet_format_list_new(formatList, context->useLongFormatNames, FALSE);
226 if (!s)
227 {
228 WLog_Print(cliprdr->log, WLOG_ERROR, "cliprdr_packet_format_list_new failed!");
229 return ERROR_INTERNAL_ERROR;
230 }
231
232 WLog_Print(cliprdr->log, WLOG_DEBUG, "ServerFormatList: numFormats: %" PRIu32 "",
233 formatList->numFormats);
234 return cliprdr_server_packet_send(cliprdr, s);
235}
236
242static UINT
243cliprdr_server_format_list_response(CliprdrServerContext* context,
244 const CLIPRDR_FORMAT_LIST_RESPONSE* formatListResponse)
245{
246 WINPR_ASSERT(context);
247 WINPR_ASSERT(formatListResponse);
248
249 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
250 if (formatListResponse->common.msgType != CB_FORMAT_LIST_RESPONSE)
251 WLog_Print(cliprdr->log, WLOG_WARN, "called with invalid type %08" PRIx32,
252 formatListResponse->common.msgType);
253
254 wStream* s = cliprdr_packet_new(CB_FORMAT_LIST_RESPONSE, formatListResponse->common.msgFlags,
255 formatListResponse->common.dataLen);
256
257 if (!s)
258 {
259 WLog_Print(cliprdr->log, WLOG_ERROR, "cliprdr_packet_new failed!");
260 return ERROR_INTERNAL_ERROR;
261 }
262
263 WLog_Print(cliprdr->log, WLOG_DEBUG, "ServerFormatListResponse");
264 return cliprdr_server_packet_send(cliprdr, s);
265}
266
272static UINT cliprdr_server_lock_clipboard_data(CliprdrServerContext* context,
273 const CLIPRDR_LOCK_CLIPBOARD_DATA* lockClipboardData)
274{
275 WINPR_ASSERT(context);
276 WINPR_ASSERT(lockClipboardData);
277
278 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
279 if (lockClipboardData->common.msgType != CB_LOCK_CLIPDATA)
280 WLog_Print(cliprdr->log, WLOG_WARN, "called with invalid type %08" PRIx32,
281 lockClipboardData->common.msgType);
282
283 wStream* s = cliprdr_packet_lock_clipdata_new(lockClipboardData);
284 if (!s)
285 {
286 WLog_Print(cliprdr->log, WLOG_ERROR, "cliprdr_packet_lock_clipdata_new failed!");
287 return ERROR_INTERNAL_ERROR;
288 }
289
290 WLog_Print(cliprdr->log, WLOG_DEBUG, "ServerLockClipboardData: clipDataId: 0x%08" PRIX32 "",
291 lockClipboardData->clipDataId);
292 return cliprdr_server_packet_send(cliprdr, s);
293}
294
300static UINT
301cliprdr_server_unlock_clipboard_data(CliprdrServerContext* context,
302 const CLIPRDR_UNLOCK_CLIPBOARD_DATA* unlockClipboardData)
303{
304 WINPR_ASSERT(context);
305 WINPR_ASSERT(unlockClipboardData);
306
307 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
308 if (unlockClipboardData->common.msgType != CB_UNLOCK_CLIPDATA)
309 WLog_Print(cliprdr->log, WLOG_WARN, "called with invalid type %08" PRIx32,
310 unlockClipboardData->common.msgType);
311
312 wStream* s = cliprdr_packet_unlock_clipdata_new(unlockClipboardData);
313
314 if (!s)
315 {
316 WLog_Print(cliprdr->log, WLOG_ERROR, "cliprdr_packet_unlock_clipdata_new failed!");
317 return ERROR_INTERNAL_ERROR;
318 }
319
320 WLog_Print(cliprdr->log, WLOG_DEBUG, "ServerUnlockClipboardData: clipDataId: 0x%08" PRIX32 "",
321 unlockClipboardData->clipDataId);
322 return cliprdr_server_packet_send(cliprdr, s);
323}
324
330static UINT cliprdr_server_format_data_request(CliprdrServerContext* context,
331 const CLIPRDR_FORMAT_DATA_REQUEST* formatDataRequest)
332{
333 WINPR_ASSERT(context);
334 WINPR_ASSERT(formatDataRequest);
335
336 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
337 if (formatDataRequest->common.msgType != CB_FORMAT_DATA_REQUEST)
338 WLog_Print(cliprdr->log, WLOG_WARN, "called with invalid type %08" PRIx32,
339 formatDataRequest->common.msgType);
340
341 /* payload is always one UINT32, hardcode size like the client-side sender */
342 wStream* s = cliprdr_packet_new(CB_FORMAT_DATA_REQUEST, 0, 4);
343
344 if (!s)
345 {
346 WLog_Print(cliprdr->log, WLOG_ERROR, "cliprdr_packet_new failed!");
347 return ERROR_INTERNAL_ERROR;
348 }
349
350 Stream_Write_UINT32(s, formatDataRequest->requestedFormatId); /* requestedFormatId (4 bytes) */
351 WLog_Print(cliprdr->log, WLOG_DEBUG, "ClientFormatDataRequest");
352 return cliprdr_server_packet_send(cliprdr, s);
353}
354
360static UINT
361cliprdr_server_format_data_response(CliprdrServerContext* context,
362 const CLIPRDR_FORMAT_DATA_RESPONSE* formatDataResponse)
363{
364 WINPR_ASSERT(context);
365 WINPR_ASSERT(formatDataResponse);
366
367 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
368
369 if (formatDataResponse->common.msgType != CB_FORMAT_DATA_RESPONSE)
370 WLog_Print(cliprdr->log, WLOG_WARN, "called with invalid type %08" PRIx32,
371 formatDataResponse->common.msgType);
372
373 wStream* s = cliprdr_packet_new(CB_FORMAT_DATA_RESPONSE, formatDataResponse->common.msgFlags,
374 formatDataResponse->common.dataLen);
375
376 if (!s)
377 {
378 WLog_Print(cliprdr->log, WLOG_ERROR, "cliprdr_packet_new failed!");
379 return ERROR_INTERNAL_ERROR;
380 }
381
382 Stream_Write(s, formatDataResponse->requestedFormatData, formatDataResponse->common.dataLen);
383 WLog_Print(cliprdr->log, WLOG_DEBUG, "ServerFormatDataResponse");
384 return cliprdr_server_packet_send(cliprdr, s);
385}
386
392static UINT
393cliprdr_server_file_contents_request(CliprdrServerContext* context,
394 const CLIPRDR_FILE_CONTENTS_REQUEST* fileContentsRequest)
395{
396 WINPR_ASSERT(context);
397 WINPR_ASSERT(fileContentsRequest);
398
399 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
400
401 if (fileContentsRequest->common.msgType != CB_FILECONTENTS_REQUEST)
402 WLog_Print(cliprdr->log, WLOG_WARN, "called with invalid type %08" PRIx32,
403 fileContentsRequest->common.msgType);
404
405 wStream* s = cliprdr_packet_file_contents_request_new(fileContentsRequest);
406 if (!s)
407 {
408 WLog_Print(cliprdr->log, WLOG_ERROR, "cliprdr_packet_file_contents_request_new failed!");
409 return ERROR_INTERNAL_ERROR;
410 }
411
412 WLog_Print(cliprdr->log, WLOG_DEBUG, "ServerFileContentsRequest: streamId: 0x%08" PRIX32 "",
413 fileContentsRequest->streamId);
414 return cliprdr_server_packet_send(cliprdr, s);
415}
416
422static UINT
423cliprdr_server_file_contents_response(CliprdrServerContext* context,
424 const CLIPRDR_FILE_CONTENTS_RESPONSE* fileContentsResponse)
425{
426 WINPR_ASSERT(context);
427 WINPR_ASSERT(fileContentsResponse);
428
429 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
430 WINPR_ASSERT(cliprdr);
431
432 if (fileContentsResponse->common.msgType != CB_FILECONTENTS_RESPONSE)
433 WLog_Print(cliprdr->log, WLOG_WARN, "called with invalid type %08" PRIx32,
434 fileContentsResponse->common.msgType);
435
436 wStream* s = cliprdr_packet_file_contents_response_new(fileContentsResponse);
437 if (!s)
438 {
439 WLog_Print(cliprdr->log, WLOG_ERROR, "cliprdr_packet_file_contents_response_new failed!");
440 return ERROR_INTERNAL_ERROR;
441 }
442
443 WLog_Print(cliprdr->log, WLOG_DEBUG, "ServerFileContentsResponse: streamId: 0x%08" PRIX32 "",
444 fileContentsResponse->streamId);
445 return cliprdr_server_packet_send(cliprdr, s);
446}
447
453static UINT cliprdr_server_receive_general_capability(CliprdrServerContext* context, wStream* s,
454 CLIPRDR_GENERAL_CAPABILITY_SET* cap_set)
455{
456 WINPR_ASSERT(context);
457 WINPR_ASSERT(cap_set);
458
459 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
460 WINPR_ASSERT(cliprdr);
461
462 if (cap_set->capabilitySetLength != sizeof(CLIPRDR_GENERAL_CAPABILITY_SET))
463 {
464 WLog_Print(cliprdr->log, WLOG_ERROR,
465 "invalid capabilitySetLength %" PRIu16 " != %" PRIuz
466 " (capabilitySetType=CB_CAPSTYPE_GENERAL)",
467 cap_set->capabilitySetLength, sizeof(CLIPRDR_GENERAL_CAPABILITY_SET));
468 return ERROR_INVALID_DATA;
469 }
470
471 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
472 return ERROR_INVALID_DATA;
473
474 Stream_Read_UINT32(s, cap_set->version); /* version (4 bytes) */
475 Stream_Read_UINT32(s, cap_set->generalFlags); /* generalFlags (4 bytes) */
476
477 if (context->useLongFormatNames)
478 context->useLongFormatNames = (cap_set->generalFlags & CB_USE_LONG_FORMAT_NAMES) != 0;
479
480 if (context->streamFileClipEnabled)
481 context->streamFileClipEnabled = (cap_set->generalFlags & CB_STREAM_FILECLIP_ENABLED) != 0;
482
483 if (context->fileClipNoFilePaths)
484 context->fileClipNoFilePaths = (cap_set->generalFlags & CB_FILECLIP_NO_FILE_PATHS) != 0;
485
486 if (context->canLockClipData)
487 context->canLockClipData = (cap_set->generalFlags & CB_CAN_LOCK_CLIPDATA) != 0;
488
489 if (context->hasHugeFileSupport)
490 context->hasHugeFileSupport = (cap_set->generalFlags & CB_HUGE_FILE_SUPPORT_ENABLED) != 0;
491
492 return CHANNEL_RC_OK;
493}
494
495WINPR_ATTR_NODISCARD
496static BOOL cliprdr_capabilities_contain_capset(wLog* log, const CLIPRDR_CAPABILITIES* capabilities,
497 size_t capabilitiesSize,
498 const CLIPRDR_CAPABILITY_SET* capset)
499{
500 WINPR_ASSERT(capabilities);
501
502 const BYTE* offset = (const BYTE*)capabilities->capabilitySets;
503 size_t byteOffset = 0;
504 for (UINT32 x = 0; x < capabilities->cCapabilitiesSets; x++)
505 {
506 const CLIPRDR_CAPABILITY_SET* cur =
507 WINPR_PACKED_ALIGN_CAST(const CLIPRDR_CAPABILITY_SET*, offset);
508 byteOffset += cur->capabilitySetLength;
509 if (byteOffset > capabilitiesSize)
510 return FALSE;
511
512 offset += cur->capabilitySetLength;
513
514 if (cur->capabilitySetType == capset->capabilitySetType)
515 {
516 WLog_Print(log, WLOG_ERROR, "duplicate CLIPRDR_CAPABILITY_SET %" PRIu16,
517 cur->capabilitySetType);
518 return TRUE;
519 }
520 }
521 return FALSE;
522}
523
529static UINT cliprdr_server_receive_capabilities(CliprdrServerContext* context, wStream* s,
530 const CLIPRDR_HEADER* header)
531{
532 UINT error = ERROR_INVALID_DATA;
533 size_t cap_sets_size = 0;
534 CLIPRDR_CAPABILITIES capabilities = WINPR_C_ARRAY_INIT;
535
536 WINPR_ASSERT(context);
537 WINPR_UNUSED(header);
538
539 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
540 WINPR_ASSERT(cliprdr);
541
542 WLog_Print(cliprdr->log, WLOG_DEBUG, "CliprdrClientCapabilities");
543 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
544 return ERROR_INVALID_DATA;
545
546 const UINT16 cCapabilitiesSets = Stream_Get_UINT16(s); /* cCapabilitiesSets (2 bytes) */
547 Stream_Seek_UINT16(s); /* pad1 (2 bytes) */
548
549 for (size_t index = 0; index < cCapabilitiesSets; index++)
550 {
551 const size_t cap_set_offset = cap_sets_size;
552 if (!Stream_CheckAndLogRequiredLength(TAG, s, sizeof(CLIPRDR_CAPABILITY_SET)))
553 goto out;
554 const UINT16 capabilitySetType = Stream_Get_UINT16(s); /* capabilitySetType (2 bytes) */
555 const UINT16 capabilitySetLength = Stream_Get_UINT16(s); /* capabilitySetLength (2 bytes) */
556
557 if (capabilitySetLength < sizeof(CLIPRDR_CAPABILITY_SET))
558 {
559 WLog_Print(cliprdr->log, WLOG_ERROR,
560 "invalid capabilitySetLength %" PRIu16 " < %" PRIuz
561 " (capabilitySetType=%" PRIu16 ")",
562 capabilitySetLength, sizeof(CLIPRDR_CAPABILITY_SET), capabilitySetType);
563 goto out;
564 }
565
566 if (!Stream_CheckAndLogRequiredLength(
567 TAG, s, (size_t)capabilitySetLength - sizeof(CLIPRDR_CAPABILITY_SET)))
568 goto out;
569
570 cap_sets_size += capabilitySetLength;
571
572 CLIPRDR_CAPABILITY_SET* tmp = realloc(capabilities.capabilitySets, cap_sets_size);
573 if (tmp == nullptr)
574 {
575 WLog_Print(cliprdr->log, WLOG_ERROR, "capabilities.capabilitySets realloc failed!");
576 free(capabilities.capabilitySets);
577 return CHANNEL_RC_NO_MEMORY;
578 }
579
580 capabilities.capabilitySets = tmp;
581
582 CLIPRDR_CAPABILITY_SET* capSet = WINPR_PACKED_ALIGN_CAST(
583 CLIPRDR_CAPABILITY_SET*, (((BYTE*)capabilities.capabilitySets) + cap_set_offset));
584
585 capSet->capabilitySetType = capabilitySetType;
586 capSet->capabilitySetLength = capabilitySetLength;
587
588 if (cliprdr_capabilities_contain_capset(cliprdr->log, &capabilities, cap_sets_size, capSet))
589 goto out;
590
591 capabilities.cCapabilitiesSets++;
592
593 switch (capSet->capabilitySetType)
594 {
595 case CB_CAPSTYPE_GENERAL:
596 error = cliprdr_server_receive_general_capability(
597 context, s, WINPR_PACKED_ALIGN_CAST(CLIPRDR_GENERAL_CAPABILITY_SET*, capSet));
598 if (error)
599 {
600 WLog_Print(
601 cliprdr->log, WLOG_ERROR,
602 "cliprdr_server_receive_general_capability failed with error %" PRIu32 "",
603 error);
604 goto out;
605 }
606 break;
607
608 default:
609 WLog_Print(cliprdr->log, WLOG_ERROR, "unknown cliprdr capability set: %" PRIu16 "",
610 capSet->capabilitySetType);
611 goto out;
612 }
613 }
614
615 error = CHANNEL_RC_OK;
616 IFCALLRET(context->ClientCapabilities, error, context, &capabilities);
617out:
618 free(capabilities.capabilitySets);
619 return error;
620}
621
627static UINT cliprdr_server_receive_temporary_directory(CliprdrServerContext* context, wStream* s,
628 const CLIPRDR_HEADER* header)
629{
630 UINT error = CHANNEL_RC_OK;
631
632 WINPR_ASSERT(context);
633 WINPR_UNUSED(header);
634
635 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
636 WINPR_ASSERT(cliprdr);
637
638 if (!Stream_CheckAndLogRequiredLength(TAG, s,
639 ARRAYSIZE(cliprdr->temporaryDirectory) * sizeof(WCHAR)))
640 return CHANNEL_RC_NO_MEMORY;
641
642 const WCHAR* wszTempDir = Stream_ConstPointer(s);
643
644 if (wszTempDir[ARRAYSIZE(cliprdr->temporaryDirectory) - 1] != 0)
645 {
646 WLog_Print(cliprdr->log, WLOG_ERROR, "wszTempDir[259] was not 0");
647 return ERROR_INVALID_DATA;
648 }
649
650 if (ConvertWCharNToUtf8(wszTempDir, ARRAYSIZE(cliprdr->temporaryDirectory),
651 cliprdr->temporaryDirectory,
652 ARRAYSIZE(cliprdr->temporaryDirectory)) < 0)
653 {
654 WLog_Print(cliprdr->log, WLOG_ERROR, "failed to convert temporary directory name");
655 return ERROR_INVALID_DATA;
656 }
657
658 size_t length = strnlen(cliprdr->temporaryDirectory, ARRAYSIZE(cliprdr->temporaryDirectory));
659
660 if (length >= ARRAYSIZE(cliprdr->temporaryDirectory))
661 length = ARRAYSIZE(cliprdr->temporaryDirectory) - 1;
662
663 CLIPRDR_TEMP_DIRECTORY tempDirectory = WINPR_C_ARRAY_INIT;
664 CopyMemory(tempDirectory.szTempDir, cliprdr->temporaryDirectory, length);
665 tempDirectory.szTempDir[length] = '\0';
666 WLog_Print(cliprdr->log, WLOG_DEBUG, "CliprdrTemporaryDirectory: %s",
667 cliprdr->temporaryDirectory);
668 IFCALLRET(context->TempDirectory, error, context, &tempDirectory);
669
670 if (error)
671 WLog_Print(cliprdr->log, WLOG_ERROR, "TempDirectory failed with error %" PRIu32 "!", error);
672
673 return error;
674}
675
681static UINT cliprdr_server_receive_format_list(CliprdrServerContext* context, wStream* s,
682 const CLIPRDR_HEADER* header)
683{
684 UINT error = CHANNEL_RC_OK;
685
686 WINPR_ASSERT(context);
687 WINPR_ASSERT(header);
688
689 CLIPRDR_FORMAT_LIST formatList = { .common = { .msgType = CB_FORMAT_LIST,
690 .msgFlags = header->msgFlags,
691 .dataLen = header->dataLen },
692 .numFormats = 0,
693 .formats = nullptr };
694 wLog* log = WLog_Get(TAG);
695 if ((error = cliprdr_read_format_list(log, s, &formatList, context->useLongFormatNames)))
696 goto out;
697
698 WLog_Print(log, WLOG_DEBUG, "ClientFormatList: numFormats: %" PRIu32 "", formatList.numFormats);
699 IFCALLRET(context->ClientFormatList, error, context, &formatList);
700
701 if (error)
702 WLog_Print(log, WLOG_ERROR, "ClientFormatList failed with error %" PRIu32 "!", error);
703
704out:
705 cliprdr_free_format_list(&formatList);
706 return error;
707}
708
714static UINT cliprdr_server_receive_format_list_response(CliprdrServerContext* context, wStream* s,
715 const CLIPRDR_HEADER* header)
716{
717 UINT error = CHANNEL_RC_OK;
718
719 WINPR_ASSERT(context);
720 WINPR_ASSERT(header);
721
722 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
723 WINPR_ASSERT(cliprdr);
724
725 WINPR_UNUSED(s);
726 WLog_Print(cliprdr->log, WLOG_DEBUG, "CliprdrClientFormatListResponse");
727
728 CLIPRDR_FORMAT_LIST_RESPONSE formatListResponse = { .common = { .msgType =
729 CB_FORMAT_LIST_RESPONSE,
730 .msgFlags = header->msgFlags,
731 .dataLen = header->dataLen } };
732 IFCALLRET(context->ClientFormatListResponse, error, context, &formatListResponse);
733
734 if (error)
735 WLog_Print(cliprdr->log, WLOG_ERROR,
736 "ClientFormatListResponse failed with error %" PRIu32 "!", error);
737
738 return error;
739}
740
746static UINT cliprdr_server_receive_lock_clipdata(CliprdrServerContext* context, wStream* s,
747 const CLIPRDR_HEADER* header)
748{
749 UINT error = CHANNEL_RC_OK;
750
751 WINPR_ASSERT(context);
752 WINPR_ASSERT(header);
753
754 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
755 WINPR_ASSERT(cliprdr);
756
757 WLog_Print(cliprdr->log, WLOG_DEBUG, "CliprdrClientLockClipData");
758
759 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
760 return ERROR_INVALID_DATA;
761
762 CLIPRDR_LOCK_CLIPBOARD_DATA lockClipboardData = { .common = { .msgType = CB_LOCK_CLIPDATA,
763 .msgFlags = header->msgFlags,
764 .dataLen = header->dataLen },
765 .clipDataId = 0 };
766
767 Stream_Read_UINT32(s, lockClipboardData.clipDataId); /* clipDataId (4 bytes) */
768 IFCALLRET(context->ClientLockClipboardData, error, context, &lockClipboardData);
769
770 if (error)
771 WLog_Print(cliprdr->log, WLOG_ERROR,
772 "ClientLockClipboardData failed with error %" PRIu32 "!", error);
773
774 return error;
775}
776
782static UINT cliprdr_server_receive_unlock_clipdata(CliprdrServerContext* context, wStream* s,
783 const CLIPRDR_HEADER* header)
784{
785 WINPR_ASSERT(context);
786 WINPR_ASSERT(header);
787
788 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
789 WINPR_ASSERT(cliprdr);
790
791 WLog_Print(cliprdr->log, WLOG_DEBUG, "CliprdrClientUnlockClipData");
792
793 CLIPRDR_UNLOCK_CLIPBOARD_DATA unlockClipboardData = { .common = { .msgType = CB_UNLOCK_CLIPDATA,
794 .msgFlags = header->msgFlags,
795 .dataLen = header->dataLen },
796 .clipDataId = 0 };
797
798 UINT error = cliprdr_read_unlock_clipdata(s, &unlockClipboardData);
799 if (error)
800 return error;
801
802 IFCALLRET(context->ClientUnlockClipboardData, error, context, &unlockClipboardData);
803
804 if (error)
805 WLog_Print(cliprdr->log, WLOG_ERROR,
806 "ClientUnlockClipboardData failed with error %" PRIu32 "!", error);
807
808 return error;
809}
810
816static UINT cliprdr_server_receive_format_data_request(CliprdrServerContext* context, wStream* s,
817 const CLIPRDR_HEADER* header)
818{
819 WINPR_ASSERT(context);
820 WINPR_ASSERT(header);
821
822 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
823 WINPR_ASSERT(cliprdr);
824
825 WLog_Print(cliprdr->log, WLOG_DEBUG, "CliprdrClientFormatDataRequest");
826
827 CLIPRDR_FORMAT_DATA_REQUEST formatDataRequest = { .common = { .msgType = CB_FORMAT_DATA_REQUEST,
828 .msgFlags = header->msgFlags,
829 .dataLen = header->dataLen },
830 .requestedFormatId = 0 };
831
832 UINT error = cliprdr_read_format_data_request(s, &formatDataRequest);
833 if (error)
834 return error;
835
836 context->lastRequestedFormatId = formatDataRequest.requestedFormatId;
837 IFCALLRET(context->ClientFormatDataRequest, error, context, &formatDataRequest);
838
839 if (error)
840 WLog_Print(cliprdr->log, WLOG_ERROR,
841 "ClientFormatDataRequest failed with error %" PRIu32 "!", error);
842
843 return error;
844}
845
851static UINT cliprdr_server_receive_format_data_response(CliprdrServerContext* context, wStream* s,
852 const CLIPRDR_HEADER* header)
853{
854 WINPR_ASSERT(context);
855 WINPR_ASSERT(header);
856
857 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
858 WINPR_ASSERT(cliprdr);
859
860 WLog_Print(cliprdr->log, WLOG_DEBUG, "CliprdrClientFormatDataResponse");
861
862 CLIPRDR_FORMAT_DATA_RESPONSE formatDataResponse = { .common = { .msgType =
863 CB_FORMAT_DATA_RESPONSE,
864 .msgFlags = header->msgFlags,
865 .dataLen = header->dataLen },
866 .requestedFormatData = nullptr };
867
868 UINT error = cliprdr_read_format_data_response(s, &formatDataResponse);
869 if (error)
870 return error;
871
872 IFCALLRET(context->ClientFormatDataResponse, error, context, &formatDataResponse);
873
874 if (error)
875 WLog_Print(cliprdr->log, WLOG_ERROR,
876 "ClientFormatDataResponse failed with error %" PRIu32 "!", error);
877
878 return error;
879}
880
886static UINT cliprdr_server_receive_filecontents_request(CliprdrServerContext* context, wStream* s,
887 const CLIPRDR_HEADER* header)
888{
889 WINPR_ASSERT(context);
890 WINPR_ASSERT(header);
891
892 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
893 WINPR_ASSERT(cliprdr);
894
895 WLog_Print(cliprdr->log, WLOG_DEBUG, "CliprdrClientFileContentsRequest");
896
897 CLIPRDR_FILE_CONTENTS_REQUEST request = { .common = { .msgType = CB_FILECONTENTS_REQUEST,
898 .msgFlags = header->msgFlags,
899 .dataLen = header->dataLen },
900 .streamId = 0,
901 .listIndex = 0,
902 .dwFlags = 0,
903 .nPositionLow = 0,
904 .nPositionHigh = 0,
905 .cbRequested = 0,
906 .haveClipDataId = FALSE,
907 .clipDataId = 0 };
908
909 UINT error = cliprdr_read_file_contents_request(s, &request);
910 if (error)
911 return error;
912
913 if (!context->hasHugeFileSupport)
914 {
915 if (request.nPositionHigh > 0)
916 return ERROR_INVALID_DATA;
917 if ((UINT64)request.nPositionLow + request.cbRequested > UINT32_MAX)
918 return ERROR_INVALID_DATA;
919 }
920 IFCALLRET(context->ClientFileContentsRequest, error, context, &request);
921
922 if (error)
923 WLog_Print(cliprdr->log, WLOG_ERROR,
924 "ClientFileContentsRequest failed with error %" PRIu32 "!", error);
925
926 return error;
927}
928
934static UINT cliprdr_server_receive_filecontents_response(CliprdrServerContext* context, wStream* s,
935 const CLIPRDR_HEADER* header)
936{
937 UINT error = CHANNEL_RC_OK;
938
939 WINPR_ASSERT(context);
940 WINPR_ASSERT(header);
941
942 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
943 WINPR_ASSERT(cliprdr);
944
945 WLog_Print(cliprdr->log, WLOG_DEBUG, "CliprdrClientFileContentsResponse");
946
947 CLIPRDR_FILE_CONTENTS_RESPONSE response = { .common = { .msgType = CB_FILECONTENTS_RESPONSE,
948 .msgFlags = header->msgFlags,
949 .dataLen = header->dataLen },
950 .streamId = 0,
951 .cbRequested = 0,
952 .requestedData = nullptr };
953
954 if ((error = cliprdr_read_file_contents_response(s, &response)))
955 return error;
956
957 IFCALLRET(context->ClientFileContentsResponse, error, context, &response);
958
959 if (error)
960 WLog_Print(cliprdr->log, WLOG_ERROR,
961 "ClientFileContentsResponse failed with error %" PRIu32 "!", error);
962
963 return error;
964}
965
971static UINT cliprdr_server_receive_pdu(CliprdrServerContext* context, wStream* s,
972 const CLIPRDR_HEADER* header)
973{
974 UINT error = 0;
975
976 WINPR_ASSERT(context);
977 WINPR_ASSERT(header);
978
979 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
980 WINPR_ASSERT(cliprdr);
981
982 {
983 char buffer1[64] = WINPR_C_ARRAY_INIT;
984 char buffer2[64] = WINPR_C_ARRAY_INIT;
985 WLog_Print(cliprdr->log, WLOG_DEBUG,
986 "CliprdrServerReceivePdu: msgType: %s, msgFlags: %s dataLen: %" PRIu32 "",
987 CB_MSG_TYPE_STRING(header->msgType, buffer1, sizeof(buffer1)),
988 CB_MSG_FLAGS_STRING(header->msgFlags, buffer2, sizeof(buffer2)),
989 header->dataLen);
990 }
991
992 const size_t start = Stream_GetPosition(s);
993 switch (header->msgType)
994 {
995 case CB_CLIP_CAPS:
996 error = cliprdr_server_receive_capabilities(context, s, header);
997 break;
998
999 case CB_TEMP_DIRECTORY:
1000 error = cliprdr_server_receive_temporary_directory(context, s, header);
1001 break;
1002
1003 case CB_FORMAT_LIST:
1004 error = cliprdr_server_receive_format_list(context, s, header);
1005 break;
1006
1007 case CB_FORMAT_LIST_RESPONSE:
1008 error = cliprdr_server_receive_format_list_response(context, s, header);
1009 break;
1010
1011 case CB_LOCK_CLIPDATA:
1012 error = cliprdr_server_receive_lock_clipdata(context, s, header);
1013 break;
1014
1015 case CB_UNLOCK_CLIPDATA:
1016 error = cliprdr_server_receive_unlock_clipdata(context, s, header);
1017 break;
1018
1019 case CB_FORMAT_DATA_REQUEST:
1020 error = cliprdr_server_receive_format_data_request(context, s, header);
1021 break;
1022
1023 case CB_FORMAT_DATA_RESPONSE:
1024 error = cliprdr_server_receive_format_data_response(context, s, header);
1025 break;
1026
1027 case CB_FILECONTENTS_REQUEST:
1028 error = cliprdr_server_receive_filecontents_request(context, s, header);
1029 break;
1030
1031 case CB_FILECONTENTS_RESPONSE:
1032 error = cliprdr_server_receive_filecontents_response(context, s, header);
1033 break;
1034
1035 default:
1036 error = ERROR_INVALID_DATA;
1037 WLog_Print(cliprdr->log, WLOG_ERROR, "Unexpected clipboard PDU type: %" PRIu16 "",
1038 header->msgType);
1039 break;
1040 }
1041
1042 const size_t end = Stream_GetPosition(s);
1043 const size_t diff = end - start;
1044 if (diff != header->dataLen)
1045 {
1046 char buffer1[64] = WINPR_C_ARRAY_INIT;
1047 WLog_WARN(
1048 TAG, "[%s] Mismatch: header told length is %" PRIu32 ", but actually read %" PRIuz,
1049 CB_MSG_TYPE_STRING(header->msgType, buffer1, sizeof(buffer1)), header->dataLen, diff);
1050 }
1051
1052 const size_t rem = Stream_GetRemainingLength(s);
1053 if (rem > 0)
1054 {
1055 char buffer1[64] = WINPR_C_ARRAY_INIT;
1056 char buffer2[64] = WINPR_C_ARRAY_INIT;
1057 WLog_WARN(
1058 TAG, "msgType: %s, msgFlags: %s dataLen: %" PRIu32 ": %" PRIuz " bytes not parsed",
1059 CB_MSG_TYPE_STRING(header->msgType, buffer1, sizeof(buffer1)),
1060 CB_MSG_FLAGS_STRING(header->msgFlags, buffer2, sizeof(buffer2)), header->dataLen, rem);
1061 }
1062 return error;
1063}
1064
1070static UINT cliprdr_server_init(CliprdrServerContext* context)
1071{
1072 UINT32 generalFlags = 0;
1073 UINT error = 0;
1074 CLIPRDR_MONITOR_READY monitorReady = WINPR_C_ARRAY_INIT;
1075
1076 WINPR_ASSERT(context);
1077
1078 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
1079 WINPR_ASSERT(cliprdr);
1080
1081 monitorReady.common.msgType = CB_MONITOR_READY;
1082
1083 if (context->useLongFormatNames)
1084 generalFlags |= CB_USE_LONG_FORMAT_NAMES;
1085
1086 if (context->streamFileClipEnabled)
1087 generalFlags |= CB_STREAM_FILECLIP_ENABLED;
1088
1089 if (context->fileClipNoFilePaths)
1090 generalFlags |= CB_FILECLIP_NO_FILE_PATHS;
1091
1092 if (context->canLockClipData)
1093 generalFlags |= CB_CAN_LOCK_CLIPDATA;
1094
1095 if (context->hasHugeFileSupport)
1096 generalFlags |= CB_HUGE_FILE_SUPPORT_ENABLED;
1097
1098 CLIPRDR_GENERAL_CAPABILITY_SET generalCapabilitySet = { .capabilitySetType =
1099 CB_CAPSTYPE_GENERAL,
1100 .capabilitySetLength =
1101 CB_CAPSTYPE_GENERAL_LEN,
1102 .version = CB_CAPS_VERSION_2,
1103 .generalFlags = generalFlags };
1104
1105 CLIPRDR_CAPABILITIES capabilities = { .common = { .msgType = CB_CLIP_CAPS,
1106 .msgFlags = 0,
1107 .dataLen = 4 + CB_CAPSTYPE_GENERAL_LEN },
1108 .cCapabilitiesSets = 1,
1109 .capabilitySets =
1110 (CLIPRDR_CAPABILITY_SET*)&generalCapabilitySet };
1111
1112 if ((error = context->ServerCapabilities(context, &capabilities)))
1113 {
1114 WLog_Print(cliprdr->log, WLOG_ERROR, "ServerCapabilities failed with error %" PRIu32 "!",
1115 error);
1116 return error;
1117 }
1118
1119 if ((error = context->MonitorReady(context, &monitorReady)))
1120 {
1121 WLog_Print(cliprdr->log, WLOG_ERROR, "MonitorReady failed with error %" PRIu32 "!", error);
1122 return error;
1123 }
1124
1125 return error;
1126}
1127
1133static UINT cliprdr_server_read(CliprdrServerContext* context)
1134{
1135 WINPR_ASSERT(context);
1136
1137 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
1138 WINPR_ASSERT(cliprdr);
1139
1140 BOOL ok = FALSE;
1141 wStream* s = ChannelPduTracker_poll(cliprdr->channelPduTracker, &ok);
1142
1143 if (!ok)
1144 return ERROR_INVALID_DATA;
1145
1146 if (!s)
1147 return CHANNEL_RC_OK;
1148
1149 UINT ret = ERROR_INVALID_DATA;
1150 if (!Stream_CheckAndLogRequiredLengthWLog(cliprdr->log, s, 8))
1151 goto out;
1152
1153 const CLIPRDR_HEADER header = {
1154 .msgType = Stream_Get_UINT16(s), /* msgType (2 bytes) */
1155 .msgFlags = Stream_Get_UINT16(s), /* msgFlags (2 bytes) */
1156 .dataLen = Stream_Get_UINT32(s) /* dataLen (4 bytes) */
1157 };
1158
1159 if (!Stream_CheckAndLogRequiredLengthWLog(cliprdr->log, s, header.dataLen))
1160 goto out;
1161
1162 ret = cliprdr_server_receive_pdu(context, s, &header);
1163 if (ret != CHANNEL_RC_OK)
1164 {
1165 char buffer1[128] = WINPR_C_ARRAY_INIT;
1166 char buffer2[128] = WINPR_C_ARRAY_INIT;
1167 WLog_Print(cliprdr->log, WLOG_ERROR,
1168 "cliprdr_server_receive_pdu [%s|%s] failed with error code %" PRIu32 "!",
1169 CB_MSG_TYPE_STRING(header.msgType, buffer1, sizeof(buffer1)),
1170 CB_MSG_FLAGS_STRING(header.msgFlags, buffer2, sizeof(buffer2)), ret);
1171 }
1172
1173out:
1174 Stream_Release(s);
1175 return ret;
1176}
1177
1178static DWORD WINAPI cliprdr_server_thread(LPVOID arg)
1179{
1180 DWORD status = 0;
1181 DWORD nCount = 0;
1182 HANDLE events[MAXIMUM_WAIT_OBJECTS] = WINPR_C_ARRAY_INIT;
1183 CliprdrServerContext* context = (CliprdrServerContext*)arg;
1184 UINT error = CHANNEL_RC_OK;
1185
1186 WINPR_ASSERT(context);
1187
1188 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
1189 WINPR_ASSERT(cliprdr);
1190
1191 HANDLE ChannelEvent = context->GetEventHandle(context);
1192
1193 events[nCount++] = cliprdr->StopEvent;
1194 events[nCount++] = ChannelEvent;
1195
1196 if (context->autoInitializationSequence)
1197 {
1198 if ((error = cliprdr_server_init(context)))
1199 {
1200 WLog_Print(cliprdr->log, WLOG_ERROR,
1201 "cliprdr_server_init failed with error %" PRIu32 "!", error);
1202 goto out;
1203 }
1204 }
1205
1206 while (1)
1207 {
1208 status = WaitForMultipleObjects(nCount, events, FALSE, INFINITE);
1209
1210 if (status == WAIT_FAILED)
1211 {
1212 error = GetLastError();
1213 WLog_Print(cliprdr->log, WLOG_ERROR,
1214 "WaitForMultipleObjects failed with error %" PRIu32 "", error);
1215 goto out;
1216 }
1217
1218 status = WaitForSingleObject(cliprdr->StopEvent, 0);
1219
1220 if (status == WAIT_FAILED)
1221 {
1222 error = GetLastError();
1223 WLog_Print(cliprdr->log, WLOG_ERROR,
1224 "WaitForSingleObject failed with error %" PRIu32 "", error);
1225 goto out;
1226 }
1227
1228 if (status == WAIT_OBJECT_0)
1229 break;
1230
1231 status = WaitForSingleObject(ChannelEvent, 0);
1232
1233 if (status == WAIT_FAILED)
1234 {
1235 error = GetLastError();
1236 WLog_Print(cliprdr->log, WLOG_ERROR,
1237 "WaitForSingleObject failed with error %" PRIu32 "", error);
1238 goto out;
1239 }
1240
1241 if (status == WAIT_OBJECT_0)
1242 {
1243 if ((error = context->CheckEventHandle(context)))
1244 {
1245 WLog_Print(cliprdr->log, WLOG_ERROR,
1246 "CheckEventHandle failed with error %" PRIu32 "!", error);
1247 break;
1248 }
1249 }
1250 }
1251
1252out:
1253
1254 if (error && context->rdpcontext)
1255 setChannelError(context->rdpcontext, error, "cliprdr_server_thread reported an error");
1256
1257 ExitThread(error);
1258 return error;
1259}
1260
1266static UINT cliprdr_server_open(CliprdrServerContext* context)
1267{
1268 WINPR_ASSERT(context);
1269
1270 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
1271 WINPR_ASSERT(cliprdr);
1272
1273 PULONG pSessionId = nullptr;
1274 DWORD BytesReturned = 0;
1275
1276 if (!WTSQuerySessionInformationA(cliprdr->vcm, WTS_CURRENT_SESSION, WTSSessionId,
1277 (LPSTR*)&pSessionId, &BytesReturned))
1278 return CHANNEL_RC_BAD_CHANNEL;
1279
1280 DWORD SessionId = (DWORD)*pSessionId;
1281 WTSFreeMemory(pSessionId);
1282
1283 cliprdr->ChannelHandle =
1284 WTSVirtualChannelOpenEx(SessionId, CLIPRDR_SVC_CHANNEL_NAME, CHANNEL_OPTION_SHOW_PROTOCOL);
1285 if (!cliprdr->ChannelHandle)
1286 {
1287 WLog_Print(cliprdr->log, WLOG_ERROR, "WTSVirtualChannelOpen for cliprdr failed!");
1288 return ERROR_INTERNAL_ERROR;
1289 }
1290
1291 WINPR_ASSERT(cliprdr->channelPduTracker == nullptr);
1292 cliprdr->channelPduTracker = ChannelPduTracker_new(cliprdr->ChannelHandle);
1293 if (!cliprdr->channelPduTracker)
1294 {
1295 WLog_Print(cliprdr->log, WLOG_ERROR, "ChannelPduTracker_new for cliprdr failed!");
1296 return ERROR_INTERNAL_ERROR;
1297 }
1298
1299 cliprdr->ChannelEvent = nullptr;
1300
1301 void* buffer = nullptr;
1302
1303 if (WTSVirtualChannelQuery(cliprdr->ChannelHandle, WTSVirtualEventHandle, &buffer,
1304 &BytesReturned))
1305 {
1306 if (BytesReturned != sizeof(HANDLE))
1307 {
1308 WLog_Print(cliprdr->log, WLOG_ERROR, "BytesReturned has not size of HANDLE!");
1309 return ERROR_INTERNAL_ERROR;
1310 }
1311
1312 cliprdr->ChannelEvent = *(HANDLE*)buffer;
1313 WTSFreeMemory(buffer);
1314 }
1315
1316 if (!cliprdr->ChannelEvent)
1317 {
1318 WLog_Print(cliprdr->log, WLOG_ERROR, "WTSVirtualChannelQuery for cliprdr failed!");
1319 return ERROR_INTERNAL_ERROR;
1320 }
1321
1322 return CHANNEL_RC_OK;
1323}
1324
1330static UINT cliprdr_server_close(CliprdrServerContext* context)
1331{
1332 WINPR_ASSERT(context);
1333
1334 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
1335 WINPR_ASSERT(cliprdr);
1336
1337 ChannelPduTracker_free(cliprdr->channelPduTracker);
1338 cliprdr->channelPduTracker = nullptr;
1339
1340 if (cliprdr->ChannelHandle)
1341 {
1342 (void)WTSVirtualChannelClose(cliprdr->ChannelHandle);
1343 cliprdr->ChannelHandle = nullptr;
1344 }
1345
1346 return CHANNEL_RC_OK;
1347}
1348
1354static UINT cliprdr_server_start(CliprdrServerContext* context)
1355{
1356 UINT error = 0;
1357
1358 WINPR_ASSERT(context);
1359
1360 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
1361 WINPR_ASSERT(cliprdr);
1362
1363 if (!cliprdr->ChannelHandle)
1364 {
1365 error = context->Open(context);
1366 if (error)
1367 {
1368 WLog_Print(cliprdr->log, WLOG_ERROR, "Open failed!");
1369 return error;
1370 }
1371 }
1372
1373 cliprdr->StopEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr);
1374 if (!cliprdr->StopEvent)
1375 {
1376 WLog_Print(cliprdr->log, WLOG_ERROR, "CreateEvent failed!");
1377 return ERROR_INTERNAL_ERROR;
1378 }
1379
1380 cliprdr->Thread = CreateThread(nullptr, 0, cliprdr_server_thread, (void*)context, 0, nullptr);
1381 if (!cliprdr->Thread)
1382 {
1383 WLog_Print(cliprdr->log, WLOG_ERROR, "CreateThread failed!");
1384 (void)CloseHandle(cliprdr->StopEvent);
1385 cliprdr->StopEvent = nullptr;
1386 return ERROR_INTERNAL_ERROR;
1387 }
1388
1389 return CHANNEL_RC_OK;
1390}
1391
1397static UINT cliprdr_server_stop(CliprdrServerContext* context)
1398{
1399 UINT error = CHANNEL_RC_OK;
1400
1401 WINPR_ASSERT(context);
1402
1403 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
1404 WINPR_ASSERT(cliprdr);
1405
1406 if (cliprdr->StopEvent)
1407 {
1408 (void)SetEvent(cliprdr->StopEvent);
1409
1410 if (WaitForSingleObject(cliprdr->Thread, INFINITE) == WAIT_FAILED)
1411 {
1412 error = GetLastError();
1413 WLog_Print(cliprdr->log, WLOG_ERROR,
1414 "WaitForSingleObject failed with error %" PRIu32 "", error);
1415 return error;
1416 }
1417
1418 (void)CloseHandle(cliprdr->Thread);
1419 (void)CloseHandle(cliprdr->StopEvent);
1420 }
1421
1422 if (cliprdr->ChannelHandle)
1423 return context->Close(context);
1424
1425 return error;
1426}
1427
1428static HANDLE cliprdr_server_get_event_handle(CliprdrServerContext* context)
1429{
1430 WINPR_ASSERT(context);
1431
1432 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
1433 WINPR_ASSERT(cliprdr);
1434 return cliprdr->ChannelEvent;
1435}
1436
1442static UINT cliprdr_server_check_event_handle(CliprdrServerContext* context)
1443{
1444 return cliprdr_server_read(context);
1445}
1446
1447CliprdrServerContext* cliprdr_server_context_new(HANDLE vcm)
1448{
1449 CliprdrServerContext* context = (CliprdrServerContext*)calloc(1, sizeof(CliprdrServerContext));
1450
1451 if (!context)
1452 goto fail;
1453
1454 context->autoInitializationSequence = TRUE;
1455 context->Open = cliprdr_server_open;
1456 context->Close = cliprdr_server_close;
1457 context->Start = cliprdr_server_start;
1458 context->Stop = cliprdr_server_stop;
1459 context->GetEventHandle = cliprdr_server_get_event_handle;
1460 context->CheckEventHandle = cliprdr_server_check_event_handle;
1461 context->ServerCapabilities = cliprdr_server_capabilities;
1462 context->MonitorReady = cliprdr_server_monitor_ready;
1463 context->ServerFormatList = cliprdr_server_format_list;
1464 context->ServerFormatListResponse = cliprdr_server_format_list_response;
1465 context->ServerLockClipboardData = cliprdr_server_lock_clipboard_data;
1466 context->ServerUnlockClipboardData = cliprdr_server_unlock_clipboard_data;
1467 context->ServerFormatDataRequest = cliprdr_server_format_data_request;
1468 context->ServerFormatDataResponse = cliprdr_server_format_data_response;
1469 context->ServerFileContentsRequest = cliprdr_server_file_contents_request;
1470 context->ServerFileContentsResponse = cliprdr_server_file_contents_response;
1471
1472 CliprdrServerPrivate* cliprdr = context->handle =
1473 (CliprdrServerPrivate*)calloc(1, sizeof(CliprdrServerPrivate));
1474 if (!cliprdr)
1475 goto fail;
1476
1477 cliprdr->log = WLog_Get(TAG);
1478 cliprdr->vcm = vcm;
1479
1480 return context;
1481
1482fail:
1483 cliprdr_server_context_free(context);
1484 return nullptr;
1485}
1486
1487void cliprdr_server_context_free(CliprdrServerContext* context)
1488{
1489 if (!context)
1490 return;
1491
1492 free(context->handle);
1493 free(context);
1494}
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_GENERAL_CAPABILITY_SET
Definition channels/cliprdr.h:111
CLIPRDR_HEADER
Definition channels/cliprdr.h:98
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