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 size_t pos = 0;
83 BOOL status = 0;
84 UINT32 dataLen = 0;
85 ULONG written = 0;
86
87 WINPR_ASSERT(cliprdr);
88
89 pos = Stream_GetPosition(s);
90 if ((pos < 8) || (pos > UINT32_MAX))
91 {
92 rc = ERROR_NO_DATA;
93 goto fail;
94 }
95
96 dataLen = (UINT32)(pos - 8);
97 if (!Stream_SetPosition(s, 4))
98 goto fail;
99 Stream_Write_UINT32(s, dataLen);
100
101 WINPR_ASSERT(pos <= UINT32_MAX);
102 status = WTSVirtualChannelWrite(cliprdr->ChannelHandle, Stream_BufferAs(s, char), (UINT32)pos,
103 &written);
104 rc = status ? CHANNEL_RC_OK : ERROR_INTERNAL_ERROR;
105fail:
106 Stream_Free(s, TRUE);
107 return rc;
108}
109
115static UINT cliprdr_server_capabilities(CliprdrServerContext* context,
116 const CLIPRDR_CAPABILITIES* capabilities)
117{
118 size_t offset = 0;
119
120 WINPR_ASSERT(context);
121 WINPR_ASSERT(capabilities);
122
123 CliprdrServerPrivate* cliprdr = (CliprdrServerPrivate*)context->handle;
124
125 if (capabilities->common.msgType != CB_CLIP_CAPS)
126 WLog_WARN(TAG, "called with invalid type %08" PRIx32, capabilities->common.msgType);
127
128 if (capabilities->cCapabilitiesSets > UINT16_MAX)
129 {
130 WLog_ERR(TAG, "Invalid number of capability sets in clipboard caps");
131 return ERROR_INVALID_PARAMETER;
132 }
133
134 wStream* s = cliprdr_packet_new(CB_CLIP_CAPS, 0, 4 + CB_CAPSTYPE_GENERAL_LEN);
135
136 if (!s)
137 {
138 WLog_ERR(TAG, "cliprdr_packet_new failed!");
139 return ERROR_INTERNAL_ERROR;
140 }
141
142 Stream_Write_UINT16(s,
143 (UINT16)capabilities->cCapabilitiesSets); /* cCapabilitiesSets (2 bytes) */
144 Stream_Write_UINT16(s, 0); /* pad1 (2 bytes) */
145 for (UINT32 x = 0; x < capabilities->cCapabilitiesSets; x++)
146 {
147 const CLIPRDR_CAPABILITY_SET* cap =
148 (const CLIPRDR_CAPABILITY_SET*)(((const BYTE*)capabilities->capabilitySets) + offset);
149 offset += cap->capabilitySetLength;
150
151 switch (cap->capabilitySetType)
152 {
153 case CB_CAPSTYPE_GENERAL:
154 {
155 const CLIPRDR_GENERAL_CAPABILITY_SET* generalCapabilitySet =
156 (const CLIPRDR_GENERAL_CAPABILITY_SET*)cap;
157 Stream_Write_UINT16(
158 s, generalCapabilitySet->capabilitySetType); /* capabilitySetType (2 bytes) */
159 Stream_Write_UINT16(
160 s, generalCapabilitySet->capabilitySetLength); /* lengthCapability (2 bytes) */
161 Stream_Write_UINT32(s, generalCapabilitySet->version); /* version (4 bytes) */
162 Stream_Write_UINT32(
163 s, generalCapabilitySet->generalFlags); /* generalFlags (4 bytes) */
164 }
165 break;
166
167 default:
168 WLog_WARN(TAG, "Unknown capability set type %08" PRIx16, cap->capabilitySetType);
169 if (!Stream_SafeSeek(s, cap->capabilitySetLength))
170 {
171 WLog_ERR(TAG, "short stream");
172 Stream_Free(s, TRUE);
173 return ERROR_NO_DATA;
174 }
175 break;
176 }
177 }
178 WLog_DBG(TAG, "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 wStream* s = nullptr;
191 CliprdrServerPrivate* cliprdr = nullptr;
192
193 WINPR_ASSERT(context);
194 WINPR_ASSERT(monitorReady);
195
196 cliprdr = (CliprdrServerPrivate*)context->handle;
197
198 if (monitorReady->common.msgType != CB_MONITOR_READY)
199 WLog_WARN(TAG, "called with invalid type %08" PRIx32, monitorReady->common.msgType);
200
201 s = cliprdr_packet_new(CB_MONITOR_READY, monitorReady->common.msgFlags,
202 monitorReady->common.dataLen);
203
204 if (!s)
205 {
206 WLog_ERR(TAG, "cliprdr_packet_new failed!");
207 return ERROR_INTERNAL_ERROR;
208 }
209
210 WLog_DBG(TAG, "ServerMonitorReady");
211 return cliprdr_server_packet_send(cliprdr, s);
212}
213
219static UINT cliprdr_server_format_list(CliprdrServerContext* context,
220 const CLIPRDR_FORMAT_LIST* formatList)
221{
222 wStream* s = nullptr;
223 CliprdrServerPrivate* cliprdr = nullptr;
224
225 WINPR_ASSERT(context);
226 WINPR_ASSERT(formatList);
227
228 cliprdr = (CliprdrServerPrivate*)context->handle;
229
230 s = cliprdr_packet_format_list_new(formatList, context->useLongFormatNames, FALSE);
231 if (!s)
232 {
233 WLog_ERR(TAG, "cliprdr_packet_format_list_new failed!");
234 return ERROR_INTERNAL_ERROR;
235 }
236
237 WLog_DBG(TAG, "ServerFormatList: numFormats: %" PRIu32 "", formatList->numFormats);
238 return cliprdr_server_packet_send(cliprdr, s);
239}
240
246static UINT
247cliprdr_server_format_list_response(CliprdrServerContext* context,
248 const CLIPRDR_FORMAT_LIST_RESPONSE* formatListResponse)
249{
250 wStream* s = nullptr;
251 CliprdrServerPrivate* cliprdr = nullptr;
252
253 WINPR_ASSERT(context);
254 WINPR_ASSERT(formatListResponse);
255
256 cliprdr = (CliprdrServerPrivate*)context->handle;
257 if (formatListResponse->common.msgType != CB_FORMAT_LIST_RESPONSE)
258 WLog_WARN(TAG, "called with invalid type %08" PRIx32, formatListResponse->common.msgType);
259
260 s = cliprdr_packet_new(CB_FORMAT_LIST_RESPONSE, formatListResponse->common.msgFlags,
261 formatListResponse->common.dataLen);
262
263 if (!s)
264 {
265 WLog_ERR(TAG, "cliprdr_packet_new failed!");
266 return ERROR_INTERNAL_ERROR;
267 }
268
269 WLog_DBG(TAG, "ServerFormatListResponse");
270 return cliprdr_server_packet_send(cliprdr, s);
271}
272
278static UINT cliprdr_server_lock_clipboard_data(CliprdrServerContext* context,
279 const CLIPRDR_LOCK_CLIPBOARD_DATA* lockClipboardData)
280{
281 wStream* s = nullptr;
282 CliprdrServerPrivate* cliprdr = nullptr;
283
284 WINPR_ASSERT(context);
285 WINPR_ASSERT(lockClipboardData);
286
287 cliprdr = (CliprdrServerPrivate*)context->handle;
288 if (lockClipboardData->common.msgType != CB_LOCK_CLIPDATA)
289 WLog_WARN(TAG, "called with invalid type %08" PRIx32, lockClipboardData->common.msgType);
290
291 s = cliprdr_packet_lock_clipdata_new(lockClipboardData);
292 if (!s)
293 {
294 WLog_ERR(TAG, "cliprdr_packet_lock_clipdata_new failed!");
295 return ERROR_INTERNAL_ERROR;
296 }
297
298 WLog_DBG(TAG, "ServerLockClipboardData: clipDataId: 0x%08" PRIX32 "",
299 lockClipboardData->clipDataId);
300 return cliprdr_server_packet_send(cliprdr, s);
301}
302
308static UINT
309cliprdr_server_unlock_clipboard_data(CliprdrServerContext* context,
310 const CLIPRDR_UNLOCK_CLIPBOARD_DATA* unlockClipboardData)
311{
312 wStream* s = nullptr;
313 CliprdrServerPrivate* cliprdr = nullptr;
314
315 WINPR_ASSERT(context);
316 WINPR_ASSERT(unlockClipboardData);
317
318 cliprdr = (CliprdrServerPrivate*)context->handle;
319 if (unlockClipboardData->common.msgType != CB_UNLOCK_CLIPDATA)
320 WLog_WARN(TAG, "called with invalid type %08" PRIx32, unlockClipboardData->common.msgType);
321
322 s = cliprdr_packet_unlock_clipdata_new(unlockClipboardData);
323
324 if (!s)
325 {
326 WLog_ERR(TAG, "cliprdr_packet_unlock_clipdata_new failed!");
327 return ERROR_INTERNAL_ERROR;
328 }
329
330 WLog_DBG(TAG, "ServerUnlockClipboardData: clipDataId: 0x%08" PRIX32 "",
331 unlockClipboardData->clipDataId);
332 return cliprdr_server_packet_send(cliprdr, s);
333}
334
340static UINT cliprdr_server_format_data_request(CliprdrServerContext* context,
341 const CLIPRDR_FORMAT_DATA_REQUEST* formatDataRequest)
342{
343 wStream* s = nullptr;
344 CliprdrServerPrivate* cliprdr = nullptr;
345
346 WINPR_ASSERT(context);
347 WINPR_ASSERT(formatDataRequest);
348
349 cliprdr = (CliprdrServerPrivate*)context->handle;
350 if (formatDataRequest->common.msgType != CB_FORMAT_DATA_REQUEST)
351 WLog_WARN(TAG, "called with invalid type %08" PRIx32, formatDataRequest->common.msgType);
352
353 s = cliprdr_packet_new(CB_FORMAT_DATA_REQUEST, formatDataRequest->common.msgFlags,
354 formatDataRequest->common.dataLen);
355
356 if (!s)
357 {
358 WLog_ERR(TAG, "cliprdr_packet_new failed!");
359 return ERROR_INTERNAL_ERROR;
360 }
361
362 Stream_Write_UINT32(s, formatDataRequest->requestedFormatId); /* requestedFormatId (4 bytes) */
363 WLog_DBG(TAG, "ClientFormatDataRequest");
364 return cliprdr_server_packet_send(cliprdr, s);
365}
366
372static UINT
373cliprdr_server_format_data_response(CliprdrServerContext* context,
374 const CLIPRDR_FORMAT_DATA_RESPONSE* formatDataResponse)
375{
376 wStream* s = nullptr;
377 CliprdrServerPrivate* cliprdr = nullptr;
378
379 WINPR_ASSERT(context);
380 WINPR_ASSERT(formatDataResponse);
381
382 cliprdr = (CliprdrServerPrivate*)context->handle;
383
384 if (formatDataResponse->common.msgType != CB_FORMAT_DATA_RESPONSE)
385 WLog_WARN(TAG, "called with invalid type %08" PRIx32, formatDataResponse->common.msgType);
386
387 s = cliprdr_packet_new(CB_FORMAT_DATA_RESPONSE, formatDataResponse->common.msgFlags,
388 formatDataResponse->common.dataLen);
389
390 if (!s)
391 {
392 WLog_ERR(TAG, "cliprdr_packet_new failed!");
393 return ERROR_INTERNAL_ERROR;
394 }
395
396 Stream_Write(s, formatDataResponse->requestedFormatData, formatDataResponse->common.dataLen);
397 WLog_DBG(TAG, "ServerFormatDataResponse");
398 return cliprdr_server_packet_send(cliprdr, s);
399}
400
406static UINT
407cliprdr_server_file_contents_request(CliprdrServerContext* context,
408 const CLIPRDR_FILE_CONTENTS_REQUEST* fileContentsRequest)
409{
410 wStream* s = nullptr;
411 CliprdrServerPrivate* cliprdr = nullptr;
412
413 WINPR_ASSERT(context);
414 WINPR_ASSERT(fileContentsRequest);
415
416 cliprdr = (CliprdrServerPrivate*)context->handle;
417
418 if (fileContentsRequest->common.msgType != CB_FILECONTENTS_REQUEST)
419 WLog_WARN(TAG, "called with invalid type %08" PRIx32, fileContentsRequest->common.msgType);
420
421 s = cliprdr_packet_file_contents_request_new(fileContentsRequest);
422 if (!s)
423 {
424 WLog_ERR(TAG, "cliprdr_packet_file_contents_request_new failed!");
425 return ERROR_INTERNAL_ERROR;
426 }
427
428 WLog_DBG(TAG, "ServerFileContentsRequest: streamId: 0x%08" PRIX32 "",
429 fileContentsRequest->streamId);
430 return cliprdr_server_packet_send(cliprdr, s);
431}
432
438static UINT
439cliprdr_server_file_contents_response(CliprdrServerContext* context,
440 const CLIPRDR_FILE_CONTENTS_RESPONSE* fileContentsResponse)
441{
442 wStream* s = nullptr;
443 CliprdrServerPrivate* cliprdr = nullptr;
444
445 WINPR_ASSERT(context);
446 WINPR_ASSERT(fileContentsResponse);
447
448 cliprdr = (CliprdrServerPrivate*)context->handle;
449
450 if (fileContentsResponse->common.msgType != CB_FILECONTENTS_RESPONSE)
451 WLog_WARN(TAG, "called with invalid type %08" PRIx32, fileContentsResponse->common.msgType);
452
453 s = cliprdr_packet_file_contents_response_new(fileContentsResponse);
454 if (!s)
455 {
456 WLog_ERR(TAG, "cliprdr_packet_file_contents_response_new failed!");
457 return ERROR_INTERNAL_ERROR;
458 }
459
460 WLog_DBG(TAG, "ServerFileContentsResponse: streamId: 0x%08" PRIX32 "",
461 fileContentsResponse->streamId);
462 return cliprdr_server_packet_send(cliprdr, s);
463}
464
470static UINT cliprdr_server_receive_general_capability(CliprdrServerContext* context, wStream* s,
471 CLIPRDR_GENERAL_CAPABILITY_SET* cap_set)
472{
473 WINPR_ASSERT(context);
474 WINPR_ASSERT(cap_set);
475
476 if (cap_set->capabilitySetLength != sizeof(CLIPRDR_GENERAL_CAPABILITY_SET))
477 {
478 WLog_ERR(TAG,
479 "invalid capabilitySetLength %" PRIu16 " != %" PRIuz
480 " (capabilitySetType=CB_CAPSTYPE_GENERAL)",
481 cap_set->capabilitySetLength, sizeof(CLIPRDR_GENERAL_CAPABILITY_SET));
482 return ERROR_INVALID_DATA;
483 }
484
485 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
486 return ERROR_INVALID_DATA;
487
488 Stream_Read_UINT32(s, cap_set->version); /* version (4 bytes) */
489 Stream_Read_UINT32(s, cap_set->generalFlags); /* generalFlags (4 bytes) */
490
491 if (context->useLongFormatNames)
492 context->useLongFormatNames = (cap_set->generalFlags & CB_USE_LONG_FORMAT_NAMES) != 0;
493
494 if (context->streamFileClipEnabled)
495 context->streamFileClipEnabled = (cap_set->generalFlags & CB_STREAM_FILECLIP_ENABLED) != 0;
496
497 if (context->fileClipNoFilePaths)
498 context->fileClipNoFilePaths = (cap_set->generalFlags & CB_FILECLIP_NO_FILE_PATHS) != 0;
499
500 if (context->canLockClipData)
501 context->canLockClipData = (cap_set->generalFlags & CB_CAN_LOCK_CLIPDATA) != 0;
502
503 if (context->hasHugeFileSupport)
504 context->hasHugeFileSupport = (cap_set->generalFlags & CB_HUGE_FILE_SUPPORT_ENABLED) != 0;
505
506 return CHANNEL_RC_OK;
507}
508
509WINPR_ATTR_NODISCARD
510static BOOL cliprdr_capabilities_contain_capset(const CLIPRDR_CAPABILITIES* capabilities,
511 const CLIPRDR_CAPABILITY_SET* capset)
512{
513 WINPR_ASSERT(capabilities);
514
515 const BYTE* offset = (const BYTE*)capabilities->capabilitySets;
516 for (UINT32 x = 0; x < capabilities->cCapabilitiesSets; x++)
517 {
518 const CLIPRDR_CAPABILITY_SET* cur = (const CLIPRDR_CAPABILITY_SET*)offset;
519 offset += cur->capabilitySetLength;
520
521 if (cur->capabilitySetType == capset->capabilitySetType)
522 {
523 WLog_ERR(TAG, "duplicate CLIPRDR_CAPABILITY_SET %" PRIu16, cur->capabilitySetType);
524 return TRUE;
525 }
526 }
527 return FALSE;
528}
529
535static UINT cliprdr_server_receive_capabilities(CliprdrServerContext* context, wStream* s,
536 const CLIPRDR_HEADER* header)
537{
538 UINT error = ERROR_INVALID_DATA;
539 size_t cap_sets_size = 0;
540 CLIPRDR_CAPABILITIES capabilities = WINPR_C_ARRAY_INIT;
541
542 WINPR_ASSERT(context);
543 WINPR_UNUSED(header);
544
545 WLog_DBG(TAG, "CliprdrClientCapabilities");
546 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
547 return ERROR_INVALID_DATA;
548
549 const UINT16 cCapabilitiesSets = Stream_Get_UINT16(s); /* cCapabilitiesSets (2 bytes) */
550 Stream_Seek_UINT16(s); /* pad1 (2 bytes) */
551
552 for (size_t index = 0; index < cCapabilitiesSets; index++)
553 {
554 const size_t cap_set_offset = cap_sets_size;
555 if (!Stream_CheckAndLogRequiredLength(TAG, s, sizeof(CLIPRDR_CAPABILITY_SET)))
556 goto out;
557 const UINT16 capabilitySetType = Stream_Get_UINT16(s); /* capabilitySetType (2 bytes) */
558 const UINT16 capabilitySetLength = Stream_Get_UINT16(s); /* capabilitySetLength (2 bytes) */
559
560 if (capabilitySetLength < sizeof(CLIPRDR_CAPABILITY_SET))
561 {
562 WLog_ERR(TAG,
563 "invalid capabilitySetLength %" PRIu16 " < %" PRIuz
564 " (capabilitySetType=%" PRIu16 ")",
565 capabilitySetLength, sizeof(CLIPRDR_CAPABILITY_SET), capabilitySetType);
566 goto out;
567 }
568
569 if (!Stream_CheckAndLogRequiredLength(
570 TAG, s, (size_t)capabilitySetLength - sizeof(CLIPRDR_CAPABILITY_SET)))
571 goto out;
572
573 cap_sets_size += capabilitySetLength;
574
575 CLIPRDR_CAPABILITY_SET* tmp = realloc(capabilities.capabilitySets, cap_sets_size);
576 if (tmp == nullptr)
577 {
578 WLog_ERR(TAG, "capabilities.capabilitySets realloc failed!");
579 free(capabilities.capabilitySets);
580 return CHANNEL_RC_NO_MEMORY;
581 }
582
583 capabilities.capabilitySets = tmp;
584
585 CLIPRDR_CAPABILITY_SET* capSet =
586 (CLIPRDR_CAPABILITY_SET*)(((BYTE*)capabilities.capabilitySets) + cap_set_offset);
587
588 capSet->capabilitySetType = capabilitySetType;
589 capSet->capabilitySetLength = capabilitySetLength;
590
591 if (cliprdr_capabilities_contain_capset(&capabilities, capSet))
592 goto out;
593
594 capabilities.cCapabilitiesSets++;
595
596 switch (capSet->capabilitySetType)
597 {
598 case CB_CAPSTYPE_GENERAL:
599 error = cliprdr_server_receive_general_capability(
600 context, s, (CLIPRDR_GENERAL_CAPABILITY_SET*)capSet);
601 if (error)
602 {
603 WLog_ERR(TAG,
604 "cliprdr_server_receive_general_capability failed with error %" PRIu32
605 "",
606 error);
607 goto out;
608 }
609 break;
610
611 default:
612 WLog_ERR(TAG, "unknown cliprdr capability set: %" PRIu16 "",
613 capSet->capabilitySetType);
614 goto out;
615 }
616 }
617
618 error = CHANNEL_RC_OK;
619 IFCALLRET(context->ClientCapabilities, error, context, &capabilities);
620out:
621 free(capabilities.capabilitySets);
622 return error;
623}
624
630static UINT cliprdr_server_receive_temporary_directory(CliprdrServerContext* context, wStream* s,
631 const CLIPRDR_HEADER* header)
632{
633 size_t length = 0;
634 CLIPRDR_TEMP_DIRECTORY tempDirectory = WINPR_C_ARRAY_INIT;
635 CliprdrServerPrivate* cliprdr = nullptr;
636 UINT error = CHANNEL_RC_OK;
637
638 WINPR_ASSERT(context);
639 WINPR_UNUSED(header);
640
641 cliprdr = (CliprdrServerPrivate*)context->handle;
642 WINPR_ASSERT(cliprdr);
643
644 if (!Stream_CheckAndLogRequiredLength(TAG, s,
645 ARRAYSIZE(cliprdr->temporaryDirectory) * sizeof(WCHAR)))
646 return CHANNEL_RC_NO_MEMORY;
647
648 const WCHAR* wszTempDir = Stream_ConstPointer(s);
649
650 if (wszTempDir[ARRAYSIZE(cliprdr->temporaryDirectory) - 1] != 0)
651 {
652 WLog_ERR(TAG, "wszTempDir[259] was not 0");
653 return ERROR_INVALID_DATA;
654 }
655
656 if (ConvertWCharNToUtf8(wszTempDir, ARRAYSIZE(cliprdr->temporaryDirectory),
657 cliprdr->temporaryDirectory,
658 ARRAYSIZE(cliprdr->temporaryDirectory)) < 0)
659 {
660 WLog_ERR(TAG, "failed to convert temporary directory name");
661 return ERROR_INVALID_DATA;
662 }
663
664 length = strnlen(cliprdr->temporaryDirectory, ARRAYSIZE(cliprdr->temporaryDirectory));
665
666 if (length >= ARRAYSIZE(cliprdr->temporaryDirectory))
667 length = ARRAYSIZE(cliprdr->temporaryDirectory) - 1;
668
669 CopyMemory(tempDirectory.szTempDir, cliprdr->temporaryDirectory, length);
670 tempDirectory.szTempDir[length] = '\0';
671 WLog_DBG(TAG, "CliprdrTemporaryDirectory: %s", cliprdr->temporaryDirectory);
672 IFCALLRET(context->TempDirectory, error, context, &tempDirectory);
673
674 if (error)
675 WLog_ERR(TAG, "TempDirectory failed with error %" PRIu32 "!", error);
676
677 return error;
678}
679
685static UINT cliprdr_server_receive_format_list(CliprdrServerContext* context, wStream* s,
686 const CLIPRDR_HEADER* header)
687{
688 CLIPRDR_FORMAT_LIST formatList = WINPR_C_ARRAY_INIT;
689 UINT error = CHANNEL_RC_OK;
690
691 WINPR_ASSERT(context);
692 WINPR_ASSERT(header);
693
694 formatList.common.msgType = CB_FORMAT_LIST;
695 formatList.common.msgFlags = header->msgFlags;
696 formatList.common.dataLen = header->dataLen;
697
698 wLog* log = WLog_Get(TAG);
699 if ((error = cliprdr_read_format_list(log, s, &formatList, context->useLongFormatNames)))
700 goto out;
701
702 WLog_Print(log, WLOG_DEBUG, "ClientFormatList: numFormats: %" PRIu32 "", formatList.numFormats);
703 IFCALLRET(context->ClientFormatList, error, context, &formatList);
704
705 if (error)
706 WLog_Print(log, WLOG_ERROR, "ClientFormatList failed with error %" PRIu32 "!", error);
707
708out:
709 cliprdr_free_format_list(&formatList);
710 return error;
711}
712
718static UINT cliprdr_server_receive_format_list_response(CliprdrServerContext* context, wStream* s,
719 const CLIPRDR_HEADER* header)
720{
721 CLIPRDR_FORMAT_LIST_RESPONSE formatListResponse = WINPR_C_ARRAY_INIT;
722 UINT error = CHANNEL_RC_OK;
723
724 WINPR_ASSERT(context);
725 WINPR_ASSERT(header);
726
727 WINPR_UNUSED(s);
728 WLog_DBG(TAG, "CliprdrClientFormatListResponse");
729 formatListResponse.common.msgType = CB_FORMAT_LIST_RESPONSE;
730 formatListResponse.common.msgFlags = header->msgFlags;
731 formatListResponse.common.dataLen = header->dataLen;
732 IFCALLRET(context->ClientFormatListResponse, error, context, &formatListResponse);
733
734 if (error)
735 WLog_ERR(TAG, "ClientFormatListResponse failed with error %" PRIu32 "!", error);
736
737 return error;
738}
739
745static UINT cliprdr_server_receive_lock_clipdata(CliprdrServerContext* context, wStream* s,
746 const CLIPRDR_HEADER* header)
747{
748 CLIPRDR_LOCK_CLIPBOARD_DATA lockClipboardData = WINPR_C_ARRAY_INIT;
749 UINT error = CHANNEL_RC_OK;
750
751 WINPR_ASSERT(context);
752 WINPR_ASSERT(header);
753
754 WLog_DBG(TAG, "CliprdrClientLockClipData");
755
756 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
757 return ERROR_INVALID_DATA;
758
759 lockClipboardData.common.msgType = CB_LOCK_CLIPDATA;
760 lockClipboardData.common.msgFlags = header->msgFlags;
761 lockClipboardData.common.dataLen = header->dataLen;
762 Stream_Read_UINT32(s, lockClipboardData.clipDataId); /* clipDataId (4 bytes) */
763 IFCALLRET(context->ClientLockClipboardData, error, context, &lockClipboardData);
764
765 if (error)
766 WLog_ERR(TAG, "ClientLockClipboardData failed with error %" PRIu32 "!", error);
767
768 return error;
769}
770
776static UINT cliprdr_server_receive_unlock_clipdata(CliprdrServerContext* context, wStream* s,
777 const CLIPRDR_HEADER* header)
778{
779 CLIPRDR_UNLOCK_CLIPBOARD_DATA unlockClipboardData = WINPR_C_ARRAY_INIT;
780 UINT error = CHANNEL_RC_OK;
781
782 WINPR_ASSERT(context);
783 WINPR_ASSERT(header);
784
785 WLog_DBG(TAG, "CliprdrClientUnlockClipData");
786
787 unlockClipboardData.common.msgType = CB_UNLOCK_CLIPDATA;
788 unlockClipboardData.common.msgFlags = header->msgFlags;
789 unlockClipboardData.common.dataLen = header->dataLen;
790
791 if ((error = cliprdr_read_unlock_clipdata(s, &unlockClipboardData)))
792 return error;
793
794 IFCALLRET(context->ClientUnlockClipboardData, error, context, &unlockClipboardData);
795
796 if (error)
797 WLog_ERR(TAG, "ClientUnlockClipboardData failed with error %" PRIu32 "!", error);
798
799 return error;
800}
801
807static UINT cliprdr_server_receive_format_data_request(CliprdrServerContext* context, wStream* s,
808 const CLIPRDR_HEADER* header)
809{
810 CLIPRDR_FORMAT_DATA_REQUEST formatDataRequest = WINPR_C_ARRAY_INIT;
811 UINT error = CHANNEL_RC_OK;
812
813 WINPR_ASSERT(context);
814 WINPR_ASSERT(header);
815
816 WLog_DBG(TAG, "CliprdrClientFormatDataRequest");
817 formatDataRequest.common.msgType = CB_FORMAT_DATA_REQUEST;
818 formatDataRequest.common.msgFlags = header->msgFlags;
819 formatDataRequest.common.dataLen = header->dataLen;
820
821 if ((error = cliprdr_read_format_data_request(s, &formatDataRequest)))
822 return error;
823
824 context->lastRequestedFormatId = formatDataRequest.requestedFormatId;
825 IFCALLRET(context->ClientFormatDataRequest, error, context, &formatDataRequest);
826
827 if (error)
828 WLog_ERR(TAG, "ClientFormatDataRequest failed with error %" PRIu32 "!", error);
829
830 return error;
831}
832
838static UINT cliprdr_server_receive_format_data_response(CliprdrServerContext* context, wStream* s,
839 const CLIPRDR_HEADER* header)
840{
841 CLIPRDR_FORMAT_DATA_RESPONSE formatDataResponse = WINPR_C_ARRAY_INIT;
842 UINT error = CHANNEL_RC_OK;
843
844 WINPR_ASSERT(context);
845 WINPR_ASSERT(header);
846
847 WLog_DBG(TAG, "CliprdrClientFormatDataResponse");
848 formatDataResponse.common.msgType = CB_FORMAT_DATA_RESPONSE;
849 formatDataResponse.common.msgFlags = header->msgFlags;
850 formatDataResponse.common.dataLen = header->dataLen;
851
852 if ((error = cliprdr_read_format_data_response(s, &formatDataResponse)))
853 return error;
854
855 IFCALLRET(context->ClientFormatDataResponse, error, context, &formatDataResponse);
856
857 if (error)
858 WLog_ERR(TAG, "ClientFormatDataResponse failed with error %" PRIu32 "!", error);
859
860 return error;
861}
862
868static UINT cliprdr_server_receive_filecontents_request(CliprdrServerContext* context, wStream* s,
869 const CLIPRDR_HEADER* header)
870{
871 CLIPRDR_FILE_CONTENTS_REQUEST request = WINPR_C_ARRAY_INIT;
872 UINT error = CHANNEL_RC_OK;
873
874 WINPR_ASSERT(context);
875 WINPR_ASSERT(header);
876
877 WLog_DBG(TAG, "CliprdrClientFileContentsRequest");
878 request.common.msgType = CB_FILECONTENTS_REQUEST;
879 request.common.msgFlags = header->msgFlags;
880 request.common.dataLen = header->dataLen;
881
882 if ((error = cliprdr_read_file_contents_request(s, &request)))
883 return error;
884
885 if (!context->hasHugeFileSupport)
886 {
887 if (request.nPositionHigh > 0)
888 return ERROR_INVALID_DATA;
889 if ((UINT64)request.nPositionLow + request.cbRequested > UINT32_MAX)
890 return ERROR_INVALID_DATA;
891 }
892 IFCALLRET(context->ClientFileContentsRequest, error, context, &request);
893
894 if (error)
895 WLog_ERR(TAG, "ClientFileContentsRequest failed with error %" PRIu32 "!", error);
896
897 return error;
898}
899
905static UINT cliprdr_server_receive_filecontents_response(CliprdrServerContext* context, wStream* s,
906 const CLIPRDR_HEADER* header)
907{
908 CLIPRDR_FILE_CONTENTS_RESPONSE response = WINPR_C_ARRAY_INIT;
909 UINT error = CHANNEL_RC_OK;
910
911 WINPR_ASSERT(context);
912 WINPR_ASSERT(header);
913
914 WLog_DBG(TAG, "CliprdrClientFileContentsResponse");
915
916 response.common.msgType = CB_FILECONTENTS_RESPONSE;
917 response.common.msgFlags = header->msgFlags;
918 response.common.dataLen = header->dataLen;
919
920 if ((error = cliprdr_read_file_contents_response(s, &response)))
921 return error;
922
923 IFCALLRET(context->ClientFileContentsResponse, error, context, &response);
924
925 if (error)
926 WLog_ERR(TAG, "ClientFileContentsResponse failed with error %" PRIu32 "!", error);
927
928 return error;
929}
930
936static UINT cliprdr_server_receive_pdu(CliprdrServerContext* context, wStream* s,
937 const CLIPRDR_HEADER* header)
938{
939 UINT error = 0;
940
941 WINPR_ASSERT(context);
942 WINPR_ASSERT(header);
943
944 char buffer1[64] = WINPR_C_ARRAY_INIT;
945 char buffer2[64] = WINPR_C_ARRAY_INIT;
946 WLog_DBG(TAG, "CliprdrServerReceivePdu: msgType: %s, msgFlags: %s dataLen: %" PRIu32 "",
947 CB_MSG_TYPE_STRING(header->msgType, buffer1, sizeof(buffer1)),
948 CB_MSG_FLAGS_STRING(header->msgFlags, buffer2, sizeof(buffer2)), header->dataLen);
949
950 switch (header->msgType)
951 {
952 case CB_CLIP_CAPS:
953 if ((error = cliprdr_server_receive_capabilities(context, s, header)))
954 WLog_ERR(TAG, "cliprdr_server_receive_capabilities failed with error %" PRIu32 "!",
955 error);
956
957 break;
958
959 case CB_TEMP_DIRECTORY:
960 if ((error = cliprdr_server_receive_temporary_directory(context, s, header)))
961 WLog_ERR(TAG,
962 "cliprdr_server_receive_temporary_directory failed with error %" PRIu32
963 "!",
964 error);
965
966 break;
967
968 case CB_FORMAT_LIST:
969 if ((error = cliprdr_server_receive_format_list(context, s, header)))
970 WLog_ERR(TAG, "cliprdr_server_receive_format_list failed with error %" PRIu32 "!",
971 error);
972
973 break;
974
975 case CB_FORMAT_LIST_RESPONSE:
976 if ((error = cliprdr_server_receive_format_list_response(context, s, header)))
977 WLog_ERR(TAG,
978 "cliprdr_server_receive_format_list_response failed with error %" PRIu32
979 "!",
980 error);
981
982 break;
983
984 case CB_LOCK_CLIPDATA:
985 if ((error = cliprdr_server_receive_lock_clipdata(context, s, header)))
986 WLog_ERR(TAG, "cliprdr_server_receive_lock_clipdata failed with error %" PRIu32 "!",
987 error);
988
989 break;
990
991 case CB_UNLOCK_CLIPDATA:
992 if ((error = cliprdr_server_receive_unlock_clipdata(context, s, header)))
993 WLog_ERR(TAG,
994 "cliprdr_server_receive_unlock_clipdata failed with error %" PRIu32 "!",
995 error);
996
997 break;
998
999 case CB_FORMAT_DATA_REQUEST:
1000 if ((error = cliprdr_server_receive_format_data_request(context, s, header)))
1001 WLog_ERR(TAG,
1002 "cliprdr_server_receive_format_data_request failed with error %" PRIu32
1003 "!",
1004 error);
1005
1006 break;
1007
1008 case CB_FORMAT_DATA_RESPONSE:
1009 if ((error = cliprdr_server_receive_format_data_response(context, s, header)))
1010 WLog_ERR(TAG,
1011 "cliprdr_server_receive_format_data_response failed with error %" PRIu32
1012 "!",
1013 error);
1014
1015 break;
1016
1017 case CB_FILECONTENTS_REQUEST:
1018 if ((error = cliprdr_server_receive_filecontents_request(context, s, header)))
1019 WLog_ERR(TAG,
1020 "cliprdr_server_receive_filecontents_request failed with error %" PRIu32
1021 "!",
1022 error);
1023
1024 break;
1025
1026 case CB_FILECONTENTS_RESPONSE:
1027 if ((error = cliprdr_server_receive_filecontents_response(context, s, header)))
1028 WLog_ERR(TAG,
1029 "cliprdr_server_receive_filecontents_response failed with error %" PRIu32
1030 "!",
1031 error);
1032
1033 break;
1034
1035 default:
1036 error = ERROR_INVALID_DATA;
1037 WLog_ERR(TAG, "Unexpected clipboard PDU type: %" PRIu16 "", header->msgType);
1038 break;
1039 }
1040
1041 return error;
1042}
1043
1049static UINT cliprdr_server_init(CliprdrServerContext* context)
1050{
1051 UINT32 generalFlags = 0;
1052 CLIPRDR_GENERAL_CAPABILITY_SET generalCapabilitySet = WINPR_C_ARRAY_INIT;
1053 UINT error = 0;
1054 CLIPRDR_MONITOR_READY monitorReady = WINPR_C_ARRAY_INIT;
1055 CLIPRDR_CAPABILITIES capabilities = WINPR_C_ARRAY_INIT;
1056
1057 WINPR_ASSERT(context);
1058
1059 monitorReady.common.msgType = CB_MONITOR_READY;
1060 capabilities.common.msgType = CB_CLIP_CAPS;
1061
1062 if (context->useLongFormatNames)
1063 generalFlags |= CB_USE_LONG_FORMAT_NAMES;
1064
1065 if (context->streamFileClipEnabled)
1066 generalFlags |= CB_STREAM_FILECLIP_ENABLED;
1067
1068 if (context->fileClipNoFilePaths)
1069 generalFlags |= CB_FILECLIP_NO_FILE_PATHS;
1070
1071 if (context->canLockClipData)
1072 generalFlags |= CB_CAN_LOCK_CLIPDATA;
1073
1074 if (context->hasHugeFileSupport)
1075 generalFlags |= CB_HUGE_FILE_SUPPORT_ENABLED;
1076
1077 capabilities.common.msgType = CB_CLIP_CAPS;
1078 capabilities.common.msgFlags = 0;
1079 capabilities.common.dataLen = 4 + CB_CAPSTYPE_GENERAL_LEN;
1080 capabilities.cCapabilitiesSets = 1;
1081 capabilities.capabilitySets = (CLIPRDR_CAPABILITY_SET*)&generalCapabilitySet;
1082 generalCapabilitySet.capabilitySetType = CB_CAPSTYPE_GENERAL;
1083 generalCapabilitySet.capabilitySetLength = CB_CAPSTYPE_GENERAL_LEN;
1084 generalCapabilitySet.version = CB_CAPS_VERSION_2;
1085 generalCapabilitySet.generalFlags = generalFlags;
1086
1087 if ((error = context->ServerCapabilities(context, &capabilities)))
1088 {
1089 WLog_ERR(TAG, "ServerCapabilities failed with error %" PRIu32 "!", error);
1090 return error;
1091 }
1092
1093 if ((error = context->MonitorReady(context, &monitorReady)))
1094 {
1095 WLog_ERR(TAG, "MonitorReady failed with error %" PRIu32 "!", error);
1096 return error;
1097 }
1098
1099 return error;
1100}
1101
1107static UINT cliprdr_server_read(CliprdrServerContext* context)
1108{
1109 wStream* s = nullptr;
1110 size_t position = 0;
1111 DWORD BytesToRead = 0;
1112 DWORD BytesReturned = 0;
1113 CLIPRDR_HEADER header = WINPR_C_ARRAY_INIT;
1114 CliprdrServerPrivate* cliprdr = nullptr;
1115 UINT error = 0;
1116 DWORD status = 0;
1117
1118 WINPR_ASSERT(context);
1119
1120 cliprdr = (CliprdrServerPrivate*)context->handle;
1121 WINPR_ASSERT(cliprdr);
1122
1123 s = cliprdr->s;
1124
1125 if (Stream_GetPosition(s) < CLIPRDR_HEADER_LENGTH)
1126 {
1127 BytesReturned = 0;
1128 BytesToRead = (UINT32)(CLIPRDR_HEADER_LENGTH - Stream_GetPosition(s));
1129 status = WaitForSingleObject(cliprdr->ChannelEvent, 0);
1130
1131 if (status == WAIT_FAILED)
1132 {
1133 error = GetLastError();
1134 WLog_ERR(TAG, "WaitForSingleObject failed with error %" PRIu32 "", error);
1135 return error;
1136 }
1137
1138 if (status == WAIT_TIMEOUT)
1139 return CHANNEL_RC_OK;
1140
1141 if (!WTSVirtualChannelRead(cliprdr->ChannelHandle, 0, Stream_Pointer(s), BytesToRead,
1142 &BytesReturned))
1143 {
1144 WLog_ERR(TAG, "WTSVirtualChannelRead failed!");
1145 return ERROR_INTERNAL_ERROR;
1146 }
1147
1148 Stream_Seek(s, BytesReturned);
1149 }
1150
1151 if (Stream_GetPosition(s) >= CLIPRDR_HEADER_LENGTH)
1152 {
1153 position = Stream_GetPosition(s);
1154 Stream_ResetPosition(s);
1155 Stream_Read_UINT16(s, header.msgType); /* msgType (2 bytes) */
1156 Stream_Read_UINT16(s, header.msgFlags); /* msgFlags (2 bytes) */
1157 Stream_Read_UINT32(s, header.dataLen); /* dataLen (4 bytes) */
1158
1159 if (!Stream_EnsureRemainingCapacity(s, header.dataLen))
1160 {
1161 WLog_ERR(TAG, "Stream_EnsureCapacity failed!");
1162 return CHANNEL_RC_NO_MEMORY;
1163 }
1164
1165 if (!Stream_SetPosition(s, position))
1166 return ERROR_INVALID_DATA;
1167
1168 if (Stream_GetPosition(s) < (header.dataLen + CLIPRDR_HEADER_LENGTH))
1169 {
1170 BytesReturned = 0;
1171 BytesToRead =
1172 (UINT32)((header.dataLen + CLIPRDR_HEADER_LENGTH) - Stream_GetPosition(s));
1173 status = WaitForSingleObject(cliprdr->ChannelEvent, 0);
1174
1175 if (status == WAIT_FAILED)
1176 {
1177 error = GetLastError();
1178 WLog_ERR(TAG, "WaitForSingleObject failed with error %" PRIu32 "", error);
1179 return error;
1180 }
1181
1182 if (status == WAIT_TIMEOUT)
1183 return CHANNEL_RC_OK;
1184
1185 if (!WTSVirtualChannelRead(cliprdr->ChannelHandle, 0, Stream_Pointer(s), BytesToRead,
1186 &BytesReturned))
1187 {
1188 WLog_ERR(TAG, "WTSVirtualChannelRead failed!");
1189 return ERROR_INTERNAL_ERROR;
1190 }
1191
1192 Stream_Seek(s, BytesReturned);
1193 }
1194
1195 if (Stream_GetPosition(s) >= (header.dataLen + CLIPRDR_HEADER_LENGTH))
1196 {
1197 if (!Stream_SetPosition(s, (header.dataLen + CLIPRDR_HEADER_LENGTH)))
1198 return ERROR_INVALID_DATA;
1199 Stream_SealLength(s);
1200 if (!Stream_SetPosition(s, CLIPRDR_HEADER_LENGTH))
1201 return ERROR_INVALID_DATA;
1202
1203 if ((error = cliprdr_server_receive_pdu(context, s, &header)))
1204 {
1205 WLog_ERR(TAG, "cliprdr_server_receive_pdu failed with error code %" PRIu32 "!",
1206 error);
1207 return error;
1208 }
1209
1210 Stream_ResetPosition(s);
1211 /* check for trailing zero bytes */
1212 status = WaitForSingleObject(cliprdr->ChannelEvent, 0);
1213
1214 if (status == WAIT_FAILED)
1215 {
1216 error = GetLastError();
1217 WLog_ERR(TAG, "WaitForSingleObject failed with error %" PRIu32 "", error);
1218 return error;
1219 }
1220
1221 if (status == WAIT_TIMEOUT)
1222 return CHANNEL_RC_OK;
1223
1224 BytesReturned = 0;
1225 BytesToRead = 4;
1226
1227 if (!WTSVirtualChannelRead(cliprdr->ChannelHandle, 0, Stream_Pointer(s), BytesToRead,
1228 &BytesReturned))
1229 {
1230 WLog_ERR(TAG, "WTSVirtualChannelRead failed!");
1231 return ERROR_INTERNAL_ERROR;
1232 }
1233
1234 if (BytesReturned == 4)
1235 {
1236 Stream_Read_UINT16(s, header.msgType); /* msgType (2 bytes) */
1237 Stream_Read_UINT16(s, header.msgFlags); /* msgFlags (2 bytes) */
1238
1239 if (!header.msgType)
1240 {
1241 /* ignore trailing bytes */
1242 Stream_ResetPosition(s);
1243 }
1244 }
1245 else
1246 {
1247 Stream_Seek(s, BytesReturned);
1248 }
1249 }
1250 }
1251
1252 return CHANNEL_RC_OK;
1253}
1254
1255static DWORD WINAPI cliprdr_server_thread(LPVOID arg)
1256{
1257 DWORD status = 0;
1258 DWORD nCount = 0;
1259 HANDLE events[MAXIMUM_WAIT_OBJECTS] = WINPR_C_ARRAY_INIT;
1260 HANDLE ChannelEvent = nullptr;
1261 CliprdrServerContext* context = (CliprdrServerContext*)arg;
1262 CliprdrServerPrivate* cliprdr = nullptr;
1263 UINT error = CHANNEL_RC_OK;
1264
1265 WINPR_ASSERT(context);
1266
1267 cliprdr = (CliprdrServerPrivate*)context->handle;
1268 WINPR_ASSERT(cliprdr);
1269
1270 ChannelEvent = context->GetEventHandle(context);
1271
1272 events[nCount++] = cliprdr->StopEvent;
1273 events[nCount++] = ChannelEvent;
1274
1275 if (context->autoInitializationSequence)
1276 {
1277 if ((error = cliprdr_server_init(context)))
1278 {
1279 WLog_ERR(TAG, "cliprdr_server_init failed with error %" PRIu32 "!", error);
1280 goto out;
1281 }
1282 }
1283
1284 while (1)
1285 {
1286 status = WaitForMultipleObjects(nCount, events, FALSE, INFINITE);
1287
1288 if (status == WAIT_FAILED)
1289 {
1290 error = GetLastError();
1291 WLog_ERR(TAG, "WaitForMultipleObjects failed with error %" PRIu32 "", error);
1292 goto out;
1293 }
1294
1295 status = WaitForSingleObject(cliprdr->StopEvent, 0);
1296
1297 if (status == WAIT_FAILED)
1298 {
1299 error = GetLastError();
1300 WLog_ERR(TAG, "WaitForSingleObject failed with error %" PRIu32 "", error);
1301 goto out;
1302 }
1303
1304 if (status == WAIT_OBJECT_0)
1305 break;
1306
1307 status = WaitForSingleObject(ChannelEvent, 0);
1308
1309 if (status == WAIT_FAILED)
1310 {
1311 error = GetLastError();
1312 WLog_ERR(TAG, "WaitForSingleObject failed with error %" PRIu32 "", error);
1313 goto out;
1314 }
1315
1316 if (status == WAIT_OBJECT_0)
1317 {
1318 if ((error = context->CheckEventHandle(context)))
1319 {
1320 WLog_ERR(TAG, "CheckEventHandle failed with error %" PRIu32 "!", error);
1321 break;
1322 }
1323 }
1324 }
1325
1326out:
1327
1328 if (error && context->rdpcontext)
1329 setChannelError(context->rdpcontext, error, "cliprdr_server_thread reported an error");
1330
1331 ExitThread(error);
1332 return error;
1333}
1334
1340static UINT cliprdr_server_open(CliprdrServerContext* context)
1341{
1342 void* buffer = nullptr;
1343 DWORD BytesReturned = 0;
1344 CliprdrServerPrivate* cliprdr = nullptr;
1345
1346 WINPR_ASSERT(context);
1347
1348 cliprdr = (CliprdrServerPrivate*)context->handle;
1349 WINPR_ASSERT(cliprdr);
1350
1351 cliprdr->ChannelHandle =
1352 WTSVirtualChannelOpen(cliprdr->vcm, WTS_CURRENT_SESSION, CLIPRDR_SVC_CHANNEL_NAME);
1353
1354 if (!cliprdr->ChannelHandle)
1355 {
1356 WLog_ERR(TAG, "WTSVirtualChannelOpen for cliprdr failed!");
1357 return ERROR_INTERNAL_ERROR;
1358 }
1359
1360 cliprdr->ChannelEvent = nullptr;
1361
1362 if (WTSVirtualChannelQuery(cliprdr->ChannelHandle, WTSVirtualEventHandle, &buffer,
1363 &BytesReturned))
1364 {
1365 if (BytesReturned != sizeof(HANDLE))
1366 {
1367 WLog_ERR(TAG, "BytesReturned has not size of HANDLE!");
1368 return ERROR_INTERNAL_ERROR;
1369 }
1370
1371 cliprdr->ChannelEvent = *(HANDLE*)buffer;
1372 WTSFreeMemory(buffer);
1373 }
1374
1375 if (!cliprdr->ChannelEvent)
1376 {
1377 WLog_ERR(TAG, "WTSVirtualChannelQuery for cliprdr failed!");
1378 return ERROR_INTERNAL_ERROR;
1379 }
1380
1381 return CHANNEL_RC_OK;
1382}
1383
1389static UINT cliprdr_server_close(CliprdrServerContext* context)
1390{
1391 CliprdrServerPrivate* cliprdr = nullptr;
1392
1393 WINPR_ASSERT(context);
1394
1395 cliprdr = (CliprdrServerPrivate*)context->handle;
1396 WINPR_ASSERT(cliprdr);
1397
1398 if (cliprdr->ChannelHandle)
1399 {
1400 (void)WTSVirtualChannelClose(cliprdr->ChannelHandle);
1401 cliprdr->ChannelHandle = nullptr;
1402 }
1403
1404 return CHANNEL_RC_OK;
1405}
1406
1412static UINT cliprdr_server_start(CliprdrServerContext* context)
1413{
1414 UINT error = 0;
1415 CliprdrServerPrivate* cliprdr = nullptr;
1416
1417 WINPR_ASSERT(context);
1418
1419 cliprdr = (CliprdrServerPrivate*)context->handle;
1420 WINPR_ASSERT(cliprdr);
1421
1422 if (!cliprdr->ChannelHandle)
1423 {
1424 if ((error = context->Open(context)))
1425 {
1426 WLog_ERR(TAG, "Open failed!");
1427 return error;
1428 }
1429 }
1430
1431 if (!(cliprdr->StopEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr)))
1432 {
1433 WLog_ERR(TAG, "CreateEvent failed!");
1434 return ERROR_INTERNAL_ERROR;
1435 }
1436
1437 if (!(cliprdr->Thread =
1438 CreateThread(nullptr, 0, cliprdr_server_thread, (void*)context, 0, nullptr)))
1439 {
1440 WLog_ERR(TAG, "CreateThread failed!");
1441 (void)CloseHandle(cliprdr->StopEvent);
1442 cliprdr->StopEvent = nullptr;
1443 return ERROR_INTERNAL_ERROR;
1444 }
1445
1446 return CHANNEL_RC_OK;
1447}
1448
1454static UINT cliprdr_server_stop(CliprdrServerContext* context)
1455{
1456 UINT error = CHANNEL_RC_OK;
1457 CliprdrServerPrivate* cliprdr = nullptr;
1458
1459 WINPR_ASSERT(context);
1460
1461 cliprdr = (CliprdrServerPrivate*)context->handle;
1462 WINPR_ASSERT(cliprdr);
1463
1464 if (cliprdr->StopEvent)
1465 {
1466 (void)SetEvent(cliprdr->StopEvent);
1467
1468 if (WaitForSingleObject(cliprdr->Thread, INFINITE) == WAIT_FAILED)
1469 {
1470 error = GetLastError();
1471 WLog_ERR(TAG, "WaitForSingleObject failed with error %" PRIu32 "", error);
1472 return error;
1473 }
1474
1475 (void)CloseHandle(cliprdr->Thread);
1476 (void)CloseHandle(cliprdr->StopEvent);
1477 }
1478
1479 if (cliprdr->ChannelHandle)
1480 return context->Close(context);
1481
1482 return error;
1483}
1484
1485static HANDLE cliprdr_server_get_event_handle(CliprdrServerContext* context)
1486{
1487 CliprdrServerPrivate* cliprdr = nullptr;
1488
1489 WINPR_ASSERT(context);
1490
1491 cliprdr = (CliprdrServerPrivate*)context->handle;
1492 WINPR_ASSERT(cliprdr);
1493 return cliprdr->ChannelEvent;
1494}
1495
1501static UINT cliprdr_server_check_event_handle(CliprdrServerContext* context)
1502{
1503 return cliprdr_server_read(context);
1504}
1505
1506CliprdrServerContext* cliprdr_server_context_new(HANDLE vcm)
1507{
1508 CliprdrServerPrivate* cliprdr = nullptr;
1509 CliprdrServerContext* context = (CliprdrServerContext*)calloc(1, sizeof(CliprdrServerContext));
1510
1511 if (context)
1512 {
1513 context->autoInitializationSequence = TRUE;
1514 context->Open = cliprdr_server_open;
1515 context->Close = cliprdr_server_close;
1516 context->Start = cliprdr_server_start;
1517 context->Stop = cliprdr_server_stop;
1518 context->GetEventHandle = cliprdr_server_get_event_handle;
1519 context->CheckEventHandle = cliprdr_server_check_event_handle;
1520 context->ServerCapabilities = cliprdr_server_capabilities;
1521 context->MonitorReady = cliprdr_server_monitor_ready;
1522 context->ServerFormatList = cliprdr_server_format_list;
1523 context->ServerFormatListResponse = cliprdr_server_format_list_response;
1524 context->ServerLockClipboardData = cliprdr_server_lock_clipboard_data;
1525 context->ServerUnlockClipboardData = cliprdr_server_unlock_clipboard_data;
1526 context->ServerFormatDataRequest = cliprdr_server_format_data_request;
1527 context->ServerFormatDataResponse = cliprdr_server_format_data_response;
1528 context->ServerFileContentsRequest = cliprdr_server_file_contents_request;
1529 context->ServerFileContentsResponse = cliprdr_server_file_contents_response;
1530 cliprdr = context->handle = (CliprdrServerPrivate*)calloc(1, sizeof(CliprdrServerPrivate));
1531
1532 if (cliprdr)
1533 {
1534 cliprdr->vcm = vcm;
1535 cliprdr->s = Stream_New(nullptr, 4096);
1536
1537 if (!cliprdr->s)
1538 {
1539 WLog_ERR(TAG, "Stream_New failed!");
1540 free(context->handle);
1541 free(context);
1542 return nullptr;
1543 }
1544 }
1545 else
1546 {
1547 WLog_ERR(TAG, "calloc failed!");
1548 free(context);
1549 return nullptr;
1550 }
1551 }
1552
1553 return context;
1554}
1555
1556void cliprdr_server_context_free(CliprdrServerContext* context)
1557{
1558 CliprdrServerPrivate* cliprdr = nullptr;
1559
1560 if (!context)
1561 return;
1562
1563 cliprdr = (CliprdrServerPrivate*)context->handle;
1564
1565 if (cliprdr)
1566 {
1567 Stream_Free(cliprdr->s, TRUE);
1568 }
1569
1570 free(context->handle);
1571 free(context);
1572}
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