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 (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
477 return ERROR_INVALID_DATA;
478
479 Stream_Read_UINT32(s, cap_set->version); /* version (4 bytes) */
480 Stream_Read_UINT32(s, cap_set->generalFlags); /* generalFlags (4 bytes) */
481
482 if (context->useLongFormatNames)
483 context->useLongFormatNames = (cap_set->generalFlags & CB_USE_LONG_FORMAT_NAMES) != 0;
484
485 if (context->streamFileClipEnabled)
486 context->streamFileClipEnabled = (cap_set->generalFlags & CB_STREAM_FILECLIP_ENABLED) != 0;
487
488 if (context->fileClipNoFilePaths)
489 context->fileClipNoFilePaths = (cap_set->generalFlags & CB_FILECLIP_NO_FILE_PATHS) != 0;
490
491 if (context->canLockClipData)
492 context->canLockClipData = (cap_set->generalFlags & CB_CAN_LOCK_CLIPDATA) != 0;
493
494 if (context->hasHugeFileSupport)
495 context->hasHugeFileSupport = (cap_set->generalFlags & CB_HUGE_FILE_SUPPORT_ENABLED) != 0;
496
497 return CHANNEL_RC_OK;
498}
499
505static UINT cliprdr_server_receive_capabilities(CliprdrServerContext* context, wStream* s,
506 const CLIPRDR_HEADER* header)
507{
508 UINT16 capabilitySetType = 0;
509 UINT16 capabilitySetLength = 0;
510 UINT error = ERROR_INVALID_DATA;
511 size_t cap_sets_size = 0;
512 CLIPRDR_CAPABILITIES capabilities = WINPR_C_ARRAY_INIT;
513 CLIPRDR_CAPABILITY_SET* capSet = nullptr;
514
515 WINPR_ASSERT(context);
516 WINPR_UNUSED(header);
517
518 WLog_DBG(TAG, "CliprdrClientCapabilities");
519 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
520 return ERROR_INVALID_DATA;
521
522 Stream_Read_UINT16(s, capabilities.cCapabilitiesSets); /* cCapabilitiesSets (2 bytes) */
523 Stream_Seek_UINT16(s); /* pad1 (2 bytes) */
524
525 for (size_t index = 0; index < capabilities.cCapabilitiesSets; index++)
526 {
527 void* tmp = nullptr;
528 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
529 goto out;
530 Stream_Read_UINT16(s, capabilitySetType); /* capabilitySetType (2 bytes) */
531 Stream_Read_UINT16(s, capabilitySetLength); /* capabilitySetLength (2 bytes) */
532
533 cap_sets_size += capabilitySetLength;
534
535 if (cap_sets_size > 0)
536 tmp = realloc(capabilities.capabilitySets, cap_sets_size);
537 if (tmp == nullptr)
538 {
539 WLog_ERR(TAG, "capabilities.capabilitySets realloc failed!");
540 free(capabilities.capabilitySets);
541 return CHANNEL_RC_NO_MEMORY;
542 }
543
544 capabilities.capabilitySets = (CLIPRDR_CAPABILITY_SET*)tmp;
545
546 capSet = &(capabilities.capabilitySets[index]);
547
548 capSet->capabilitySetType = capabilitySetType;
549 capSet->capabilitySetLength = capabilitySetLength;
550
551 switch (capSet->capabilitySetType)
552 {
553 case CB_CAPSTYPE_GENERAL:
554 error = cliprdr_server_receive_general_capability(
555 context, s, (CLIPRDR_GENERAL_CAPABILITY_SET*)capSet);
556 if (error)
557 {
558 WLog_ERR(TAG,
559 "cliprdr_server_receive_general_capability failed with error %" PRIu32
560 "",
561 error);
562 goto out;
563 }
564 break;
565
566 default:
567 WLog_ERR(TAG, "unknown cliprdr capability set: %" PRIu16 "",
568 capSet->capabilitySetType);
569 goto out;
570 }
571 }
572
573 error = CHANNEL_RC_OK;
574 IFCALLRET(context->ClientCapabilities, error, context, &capabilities);
575out:
576 free(capabilities.capabilitySets);
577 return error;
578}
579
585static UINT cliprdr_server_receive_temporary_directory(CliprdrServerContext* context, wStream* s,
586 const CLIPRDR_HEADER* header)
587{
588 size_t length = 0;
589 CLIPRDR_TEMP_DIRECTORY tempDirectory = WINPR_C_ARRAY_INIT;
590 CliprdrServerPrivate* cliprdr = nullptr;
591 UINT error = CHANNEL_RC_OK;
592
593 WINPR_ASSERT(context);
594 WINPR_UNUSED(header);
595
596 cliprdr = (CliprdrServerPrivate*)context->handle;
597 WINPR_ASSERT(cliprdr);
598
599 if (!Stream_CheckAndLogRequiredLength(TAG, s,
600 ARRAYSIZE(cliprdr->temporaryDirectory) * sizeof(WCHAR)))
601 return CHANNEL_RC_NO_MEMORY;
602
603 const WCHAR* wszTempDir = Stream_ConstPointer(s);
604
605 if (wszTempDir[ARRAYSIZE(cliprdr->temporaryDirectory) - 1] != 0)
606 {
607 WLog_ERR(TAG, "wszTempDir[259] was not 0");
608 return ERROR_INVALID_DATA;
609 }
610
611 if (ConvertWCharNToUtf8(wszTempDir, ARRAYSIZE(cliprdr->temporaryDirectory),
612 cliprdr->temporaryDirectory,
613 ARRAYSIZE(cliprdr->temporaryDirectory)) < 0)
614 {
615 WLog_ERR(TAG, "failed to convert temporary directory name");
616 return ERROR_INVALID_DATA;
617 }
618
619 length = strnlen(cliprdr->temporaryDirectory, ARRAYSIZE(cliprdr->temporaryDirectory));
620
621 if (length >= ARRAYSIZE(cliprdr->temporaryDirectory))
622 length = ARRAYSIZE(cliprdr->temporaryDirectory) - 1;
623
624 CopyMemory(tempDirectory.szTempDir, cliprdr->temporaryDirectory, length);
625 tempDirectory.szTempDir[length] = '\0';
626 WLog_DBG(TAG, "CliprdrTemporaryDirectory: %s", cliprdr->temporaryDirectory);
627 IFCALLRET(context->TempDirectory, error, context, &tempDirectory);
628
629 if (error)
630 WLog_ERR(TAG, "TempDirectory failed with error %" PRIu32 "!", error);
631
632 return error;
633}
634
640static UINT cliprdr_server_receive_format_list(CliprdrServerContext* context, wStream* s,
641 const CLIPRDR_HEADER* header)
642{
643 CLIPRDR_FORMAT_LIST formatList = WINPR_C_ARRAY_INIT;
644 UINT error = CHANNEL_RC_OK;
645
646 WINPR_ASSERT(context);
647 WINPR_ASSERT(header);
648
649 formatList.common.msgType = CB_FORMAT_LIST;
650 formatList.common.msgFlags = header->msgFlags;
651 formatList.common.dataLen = header->dataLen;
652
653 wLog* log = WLog_Get(TAG);
654 if ((error = cliprdr_read_format_list(log, s, &formatList, context->useLongFormatNames)))
655 goto out;
656
657 WLog_Print(log, WLOG_DEBUG, "ClientFormatList: numFormats: %" PRIu32 "", formatList.numFormats);
658 IFCALLRET(context->ClientFormatList, error, context, &formatList);
659
660 if (error)
661 WLog_Print(log, WLOG_ERROR, "ClientFormatList failed with error %" PRIu32 "!", error);
662
663out:
664 cliprdr_free_format_list(&formatList);
665 return error;
666}
667
673static UINT cliprdr_server_receive_format_list_response(CliprdrServerContext* context, wStream* s,
674 const CLIPRDR_HEADER* header)
675{
676 CLIPRDR_FORMAT_LIST_RESPONSE formatListResponse = WINPR_C_ARRAY_INIT;
677 UINT error = CHANNEL_RC_OK;
678
679 WINPR_ASSERT(context);
680 WINPR_ASSERT(header);
681
682 WINPR_UNUSED(s);
683 WLog_DBG(TAG, "CliprdrClientFormatListResponse");
684 formatListResponse.common.msgType = CB_FORMAT_LIST_RESPONSE;
685 formatListResponse.common.msgFlags = header->msgFlags;
686 formatListResponse.common.dataLen = header->dataLen;
687 IFCALLRET(context->ClientFormatListResponse, error, context, &formatListResponse);
688
689 if (error)
690 WLog_ERR(TAG, "ClientFormatListResponse failed with error %" PRIu32 "!", error);
691
692 return error;
693}
694
700static UINT cliprdr_server_receive_lock_clipdata(CliprdrServerContext* context, wStream* s,
701 const CLIPRDR_HEADER* header)
702{
703 CLIPRDR_LOCK_CLIPBOARD_DATA lockClipboardData = WINPR_C_ARRAY_INIT;
704 UINT error = CHANNEL_RC_OK;
705
706 WINPR_ASSERT(context);
707 WINPR_ASSERT(header);
708
709 WLog_DBG(TAG, "CliprdrClientLockClipData");
710
711 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
712 return ERROR_INVALID_DATA;
713
714 lockClipboardData.common.msgType = CB_LOCK_CLIPDATA;
715 lockClipboardData.common.msgFlags = header->msgFlags;
716 lockClipboardData.common.dataLen = header->dataLen;
717 Stream_Read_UINT32(s, lockClipboardData.clipDataId); /* clipDataId (4 bytes) */
718 IFCALLRET(context->ClientLockClipboardData, error, context, &lockClipboardData);
719
720 if (error)
721 WLog_ERR(TAG, "ClientLockClipboardData failed with error %" PRIu32 "!", error);
722
723 return error;
724}
725
731static UINT cliprdr_server_receive_unlock_clipdata(CliprdrServerContext* context, wStream* s,
732 const CLIPRDR_HEADER* header)
733{
734 CLIPRDR_UNLOCK_CLIPBOARD_DATA unlockClipboardData = WINPR_C_ARRAY_INIT;
735 UINT error = CHANNEL_RC_OK;
736
737 WINPR_ASSERT(context);
738 WINPR_ASSERT(header);
739
740 WLog_DBG(TAG, "CliprdrClientUnlockClipData");
741
742 unlockClipboardData.common.msgType = CB_UNLOCK_CLIPDATA;
743 unlockClipboardData.common.msgFlags = header->msgFlags;
744 unlockClipboardData.common.dataLen = header->dataLen;
745
746 if ((error = cliprdr_read_unlock_clipdata(s, &unlockClipboardData)))
747 return error;
748
749 IFCALLRET(context->ClientUnlockClipboardData, error, context, &unlockClipboardData);
750
751 if (error)
752 WLog_ERR(TAG, "ClientUnlockClipboardData failed with error %" PRIu32 "!", error);
753
754 return error;
755}
756
762static UINT cliprdr_server_receive_format_data_request(CliprdrServerContext* context, wStream* s,
763 const CLIPRDR_HEADER* header)
764{
765 CLIPRDR_FORMAT_DATA_REQUEST formatDataRequest = WINPR_C_ARRAY_INIT;
766 UINT error = CHANNEL_RC_OK;
767
768 WINPR_ASSERT(context);
769 WINPR_ASSERT(header);
770
771 WLog_DBG(TAG, "CliprdrClientFormatDataRequest");
772 formatDataRequest.common.msgType = CB_FORMAT_DATA_REQUEST;
773 formatDataRequest.common.msgFlags = header->msgFlags;
774 formatDataRequest.common.dataLen = header->dataLen;
775
776 if ((error = cliprdr_read_format_data_request(s, &formatDataRequest)))
777 return error;
778
779 context->lastRequestedFormatId = formatDataRequest.requestedFormatId;
780 IFCALLRET(context->ClientFormatDataRequest, error, context, &formatDataRequest);
781
782 if (error)
783 WLog_ERR(TAG, "ClientFormatDataRequest failed with error %" PRIu32 "!", error);
784
785 return error;
786}
787
793static UINT cliprdr_server_receive_format_data_response(CliprdrServerContext* context, wStream* s,
794 const CLIPRDR_HEADER* header)
795{
796 CLIPRDR_FORMAT_DATA_RESPONSE formatDataResponse = WINPR_C_ARRAY_INIT;
797 UINT error = CHANNEL_RC_OK;
798
799 WINPR_ASSERT(context);
800 WINPR_ASSERT(header);
801
802 WLog_DBG(TAG, "CliprdrClientFormatDataResponse");
803 formatDataResponse.common.msgType = CB_FORMAT_DATA_RESPONSE;
804 formatDataResponse.common.msgFlags = header->msgFlags;
805 formatDataResponse.common.dataLen = header->dataLen;
806
807 if ((error = cliprdr_read_format_data_response(s, &formatDataResponse)))
808 return error;
809
810 IFCALLRET(context->ClientFormatDataResponse, error, context, &formatDataResponse);
811
812 if (error)
813 WLog_ERR(TAG, "ClientFormatDataResponse failed with error %" PRIu32 "!", error);
814
815 return error;
816}
817
823static UINT cliprdr_server_receive_filecontents_request(CliprdrServerContext* context, wStream* s,
824 const CLIPRDR_HEADER* header)
825{
826 CLIPRDR_FILE_CONTENTS_REQUEST request = WINPR_C_ARRAY_INIT;
827 UINT error = CHANNEL_RC_OK;
828
829 WINPR_ASSERT(context);
830 WINPR_ASSERT(header);
831
832 WLog_DBG(TAG, "CliprdrClientFileContentsRequest");
833 request.common.msgType = CB_FILECONTENTS_REQUEST;
834 request.common.msgFlags = header->msgFlags;
835 request.common.dataLen = header->dataLen;
836
837 if ((error = cliprdr_read_file_contents_request(s, &request)))
838 return error;
839
840 if (!context->hasHugeFileSupport)
841 {
842 if (request.nPositionHigh > 0)
843 return ERROR_INVALID_DATA;
844 if ((UINT64)request.nPositionLow + request.cbRequested > UINT32_MAX)
845 return ERROR_INVALID_DATA;
846 }
847 IFCALLRET(context->ClientFileContentsRequest, error, context, &request);
848
849 if (error)
850 WLog_ERR(TAG, "ClientFileContentsRequest failed with error %" PRIu32 "!", error);
851
852 return error;
853}
854
860static UINT cliprdr_server_receive_filecontents_response(CliprdrServerContext* context, wStream* s,
861 const CLIPRDR_HEADER* header)
862{
863 CLIPRDR_FILE_CONTENTS_RESPONSE response = WINPR_C_ARRAY_INIT;
864 UINT error = CHANNEL_RC_OK;
865
866 WINPR_ASSERT(context);
867 WINPR_ASSERT(header);
868
869 WLog_DBG(TAG, "CliprdrClientFileContentsResponse");
870
871 response.common.msgType = CB_FILECONTENTS_RESPONSE;
872 response.common.msgFlags = header->msgFlags;
873 response.common.dataLen = header->dataLen;
874
875 if ((error = cliprdr_read_file_contents_response(s, &response)))
876 return error;
877
878 IFCALLRET(context->ClientFileContentsResponse, error, context, &response);
879
880 if (error)
881 WLog_ERR(TAG, "ClientFileContentsResponse failed with error %" PRIu32 "!", error);
882
883 return error;
884}
885
891static UINT cliprdr_server_receive_pdu(CliprdrServerContext* context, wStream* s,
892 const CLIPRDR_HEADER* header)
893{
894 UINT error = 0;
895
896 WINPR_ASSERT(context);
897 WINPR_ASSERT(header);
898
899 char buffer1[64] = WINPR_C_ARRAY_INIT;
900 char buffer2[64] = WINPR_C_ARRAY_INIT;
901 WLog_DBG(TAG, "CliprdrServerReceivePdu: msgType: %s, msgFlags: %s dataLen: %" PRIu32 "",
902 CB_MSG_TYPE_STRING(header->msgType, buffer1, sizeof(buffer1)),
903 CB_MSG_FLAGS_STRING(header->msgFlags, buffer2, sizeof(buffer2)), header->dataLen);
904
905 switch (header->msgType)
906 {
907 case CB_CLIP_CAPS:
908 if ((error = cliprdr_server_receive_capabilities(context, s, header)))
909 WLog_ERR(TAG, "cliprdr_server_receive_capabilities failed with error %" PRIu32 "!",
910 error);
911
912 break;
913
914 case CB_TEMP_DIRECTORY:
915 if ((error = cliprdr_server_receive_temporary_directory(context, s, header)))
916 WLog_ERR(TAG,
917 "cliprdr_server_receive_temporary_directory failed with error %" PRIu32
918 "!",
919 error);
920
921 break;
922
923 case CB_FORMAT_LIST:
924 if ((error = cliprdr_server_receive_format_list(context, s, header)))
925 WLog_ERR(TAG, "cliprdr_server_receive_format_list failed with error %" PRIu32 "!",
926 error);
927
928 break;
929
930 case CB_FORMAT_LIST_RESPONSE:
931 if ((error = cliprdr_server_receive_format_list_response(context, s, header)))
932 WLog_ERR(TAG,
933 "cliprdr_server_receive_format_list_response failed with error %" PRIu32
934 "!",
935 error);
936
937 break;
938
939 case CB_LOCK_CLIPDATA:
940 if ((error = cliprdr_server_receive_lock_clipdata(context, s, header)))
941 WLog_ERR(TAG, "cliprdr_server_receive_lock_clipdata failed with error %" PRIu32 "!",
942 error);
943
944 break;
945
946 case CB_UNLOCK_CLIPDATA:
947 if ((error = cliprdr_server_receive_unlock_clipdata(context, s, header)))
948 WLog_ERR(TAG,
949 "cliprdr_server_receive_unlock_clipdata failed with error %" PRIu32 "!",
950 error);
951
952 break;
953
954 case CB_FORMAT_DATA_REQUEST:
955 if ((error = cliprdr_server_receive_format_data_request(context, s, header)))
956 WLog_ERR(TAG,
957 "cliprdr_server_receive_format_data_request failed with error %" PRIu32
958 "!",
959 error);
960
961 break;
962
963 case CB_FORMAT_DATA_RESPONSE:
964 if ((error = cliprdr_server_receive_format_data_response(context, s, header)))
965 WLog_ERR(TAG,
966 "cliprdr_server_receive_format_data_response failed with error %" PRIu32
967 "!",
968 error);
969
970 break;
971
972 case CB_FILECONTENTS_REQUEST:
973 if ((error = cliprdr_server_receive_filecontents_request(context, s, header)))
974 WLog_ERR(TAG,
975 "cliprdr_server_receive_filecontents_request failed with error %" PRIu32
976 "!",
977 error);
978
979 break;
980
981 case CB_FILECONTENTS_RESPONSE:
982 if ((error = cliprdr_server_receive_filecontents_response(context, s, header)))
983 WLog_ERR(TAG,
984 "cliprdr_server_receive_filecontents_response failed with error %" PRIu32
985 "!",
986 error);
987
988 break;
989
990 default:
991 error = ERROR_INVALID_DATA;
992 WLog_ERR(TAG, "Unexpected clipboard PDU type: %" PRIu16 "", header->msgType);
993 break;
994 }
995
996 return error;
997}
998
1004static UINT cliprdr_server_init(CliprdrServerContext* context)
1005{
1006 UINT32 generalFlags = 0;
1007 CLIPRDR_GENERAL_CAPABILITY_SET generalCapabilitySet = WINPR_C_ARRAY_INIT;
1008 UINT error = 0;
1009 CLIPRDR_MONITOR_READY monitorReady = WINPR_C_ARRAY_INIT;
1010 CLIPRDR_CAPABILITIES capabilities = WINPR_C_ARRAY_INIT;
1011
1012 WINPR_ASSERT(context);
1013
1014 monitorReady.common.msgType = CB_MONITOR_READY;
1015 capabilities.common.msgType = CB_CLIP_CAPS;
1016
1017 if (context->useLongFormatNames)
1018 generalFlags |= CB_USE_LONG_FORMAT_NAMES;
1019
1020 if (context->streamFileClipEnabled)
1021 generalFlags |= CB_STREAM_FILECLIP_ENABLED;
1022
1023 if (context->fileClipNoFilePaths)
1024 generalFlags |= CB_FILECLIP_NO_FILE_PATHS;
1025
1026 if (context->canLockClipData)
1027 generalFlags |= CB_CAN_LOCK_CLIPDATA;
1028
1029 if (context->hasHugeFileSupport)
1030 generalFlags |= CB_HUGE_FILE_SUPPORT_ENABLED;
1031
1032 capabilities.common.msgType = CB_CLIP_CAPS;
1033 capabilities.common.msgFlags = 0;
1034 capabilities.common.dataLen = 4 + CB_CAPSTYPE_GENERAL_LEN;
1035 capabilities.cCapabilitiesSets = 1;
1036 capabilities.capabilitySets = (CLIPRDR_CAPABILITY_SET*)&generalCapabilitySet;
1037 generalCapabilitySet.capabilitySetType = CB_CAPSTYPE_GENERAL;
1038 generalCapabilitySet.capabilitySetLength = CB_CAPSTYPE_GENERAL_LEN;
1039 generalCapabilitySet.version = CB_CAPS_VERSION_2;
1040 generalCapabilitySet.generalFlags = generalFlags;
1041
1042 if ((error = context->ServerCapabilities(context, &capabilities)))
1043 {
1044 WLog_ERR(TAG, "ServerCapabilities failed with error %" PRIu32 "!", error);
1045 return error;
1046 }
1047
1048 if ((error = context->MonitorReady(context, &monitorReady)))
1049 {
1050 WLog_ERR(TAG, "MonitorReady failed with error %" PRIu32 "!", error);
1051 return error;
1052 }
1053
1054 return error;
1055}
1056
1062static UINT cliprdr_server_read(CliprdrServerContext* context)
1063{
1064 wStream* s = nullptr;
1065 size_t position = 0;
1066 DWORD BytesToRead = 0;
1067 DWORD BytesReturned = 0;
1068 CLIPRDR_HEADER header = WINPR_C_ARRAY_INIT;
1069 CliprdrServerPrivate* cliprdr = nullptr;
1070 UINT error = 0;
1071 DWORD status = 0;
1072
1073 WINPR_ASSERT(context);
1074
1075 cliprdr = (CliprdrServerPrivate*)context->handle;
1076 WINPR_ASSERT(cliprdr);
1077
1078 s = cliprdr->s;
1079
1080 if (Stream_GetPosition(s) < CLIPRDR_HEADER_LENGTH)
1081 {
1082 BytesReturned = 0;
1083 BytesToRead = (UINT32)(CLIPRDR_HEADER_LENGTH - Stream_GetPosition(s));
1084 status = WaitForSingleObject(cliprdr->ChannelEvent, 0);
1085
1086 if (status == WAIT_FAILED)
1087 {
1088 error = GetLastError();
1089 WLog_ERR(TAG, "WaitForSingleObject failed with error %" PRIu32 "", error);
1090 return error;
1091 }
1092
1093 if (status == WAIT_TIMEOUT)
1094 return CHANNEL_RC_OK;
1095
1096 if (!WTSVirtualChannelRead(cliprdr->ChannelHandle, 0, Stream_Pointer(s), BytesToRead,
1097 &BytesReturned))
1098 {
1099 WLog_ERR(TAG, "WTSVirtualChannelRead failed!");
1100 return ERROR_INTERNAL_ERROR;
1101 }
1102
1103 Stream_Seek(s, BytesReturned);
1104 }
1105
1106 if (Stream_GetPosition(s) >= CLIPRDR_HEADER_LENGTH)
1107 {
1108 position = Stream_GetPosition(s);
1109 Stream_ResetPosition(s);
1110 Stream_Read_UINT16(s, header.msgType); /* msgType (2 bytes) */
1111 Stream_Read_UINT16(s, header.msgFlags); /* msgFlags (2 bytes) */
1112 Stream_Read_UINT32(s, header.dataLen); /* dataLen (4 bytes) */
1113
1114 if (!Stream_EnsureRemainingCapacity(s, header.dataLen))
1115 {
1116 WLog_ERR(TAG, "Stream_EnsureCapacity failed!");
1117 return CHANNEL_RC_NO_MEMORY;
1118 }
1119
1120 if (!Stream_SetPosition(s, position))
1121 return ERROR_INVALID_DATA;
1122
1123 if (Stream_GetPosition(s) < (header.dataLen + CLIPRDR_HEADER_LENGTH))
1124 {
1125 BytesReturned = 0;
1126 BytesToRead =
1127 (UINT32)((header.dataLen + CLIPRDR_HEADER_LENGTH) - Stream_GetPosition(s));
1128 status = WaitForSingleObject(cliprdr->ChannelEvent, 0);
1129
1130 if (status == WAIT_FAILED)
1131 {
1132 error = GetLastError();
1133 WLog_ERR(TAG, "WaitForSingleObject failed with error %" PRIu32 "", error);
1134 return error;
1135 }
1136
1137 if (status == WAIT_TIMEOUT)
1138 return CHANNEL_RC_OK;
1139
1140 if (!WTSVirtualChannelRead(cliprdr->ChannelHandle, 0, Stream_Pointer(s), BytesToRead,
1141 &BytesReturned))
1142 {
1143 WLog_ERR(TAG, "WTSVirtualChannelRead failed!");
1144 return ERROR_INTERNAL_ERROR;
1145 }
1146
1147 Stream_Seek(s, BytesReturned);
1148 }
1149
1150 if (Stream_GetPosition(s) >= (header.dataLen + CLIPRDR_HEADER_LENGTH))
1151 {
1152 if (!Stream_SetPosition(s, (header.dataLen + CLIPRDR_HEADER_LENGTH)))
1153 return ERROR_INVALID_DATA;
1154 Stream_SealLength(s);
1155 if (!Stream_SetPosition(s, CLIPRDR_HEADER_LENGTH))
1156 return ERROR_INVALID_DATA;
1157
1158 if ((error = cliprdr_server_receive_pdu(context, s, &header)))
1159 {
1160 WLog_ERR(TAG, "cliprdr_server_receive_pdu failed with error code %" PRIu32 "!",
1161 error);
1162 return error;
1163 }
1164
1165 Stream_ResetPosition(s);
1166 /* check for trailing zero bytes */
1167 status = WaitForSingleObject(cliprdr->ChannelEvent, 0);
1168
1169 if (status == WAIT_FAILED)
1170 {
1171 error = GetLastError();
1172 WLog_ERR(TAG, "WaitForSingleObject failed with error %" PRIu32 "", error);
1173 return error;
1174 }
1175
1176 if (status == WAIT_TIMEOUT)
1177 return CHANNEL_RC_OK;
1178
1179 BytesReturned = 0;
1180 BytesToRead = 4;
1181
1182 if (!WTSVirtualChannelRead(cliprdr->ChannelHandle, 0, Stream_Pointer(s), BytesToRead,
1183 &BytesReturned))
1184 {
1185 WLog_ERR(TAG, "WTSVirtualChannelRead failed!");
1186 return ERROR_INTERNAL_ERROR;
1187 }
1188
1189 if (BytesReturned == 4)
1190 {
1191 Stream_Read_UINT16(s, header.msgType); /* msgType (2 bytes) */
1192 Stream_Read_UINT16(s, header.msgFlags); /* msgFlags (2 bytes) */
1193
1194 if (!header.msgType)
1195 {
1196 /* ignore trailing bytes */
1197 Stream_ResetPosition(s);
1198 }
1199 }
1200 else
1201 {
1202 Stream_Seek(s, BytesReturned);
1203 }
1204 }
1205 }
1206
1207 return CHANNEL_RC_OK;
1208}
1209
1210static DWORD WINAPI cliprdr_server_thread(LPVOID arg)
1211{
1212 DWORD status = 0;
1213 DWORD nCount = 0;
1214 HANDLE events[MAXIMUM_WAIT_OBJECTS] = WINPR_C_ARRAY_INIT;
1215 HANDLE ChannelEvent = nullptr;
1216 CliprdrServerContext* context = (CliprdrServerContext*)arg;
1217 CliprdrServerPrivate* cliprdr = nullptr;
1218 UINT error = CHANNEL_RC_OK;
1219
1220 WINPR_ASSERT(context);
1221
1222 cliprdr = (CliprdrServerPrivate*)context->handle;
1223 WINPR_ASSERT(cliprdr);
1224
1225 ChannelEvent = context->GetEventHandle(context);
1226
1227 events[nCount++] = cliprdr->StopEvent;
1228 events[nCount++] = ChannelEvent;
1229
1230 if (context->autoInitializationSequence)
1231 {
1232 if ((error = cliprdr_server_init(context)))
1233 {
1234 WLog_ERR(TAG, "cliprdr_server_init failed with error %" PRIu32 "!", error);
1235 goto out;
1236 }
1237 }
1238
1239 while (1)
1240 {
1241 status = WaitForMultipleObjects(nCount, events, FALSE, INFINITE);
1242
1243 if (status == WAIT_FAILED)
1244 {
1245 error = GetLastError();
1246 WLog_ERR(TAG, "WaitForMultipleObjects failed with error %" PRIu32 "", error);
1247 goto out;
1248 }
1249
1250 status = WaitForSingleObject(cliprdr->StopEvent, 0);
1251
1252 if (status == WAIT_FAILED)
1253 {
1254 error = GetLastError();
1255 WLog_ERR(TAG, "WaitForSingleObject failed with error %" PRIu32 "", error);
1256 goto out;
1257 }
1258
1259 if (status == WAIT_OBJECT_0)
1260 break;
1261
1262 status = WaitForSingleObject(ChannelEvent, 0);
1263
1264 if (status == WAIT_FAILED)
1265 {
1266 error = GetLastError();
1267 WLog_ERR(TAG, "WaitForSingleObject failed with error %" PRIu32 "", error);
1268 goto out;
1269 }
1270
1271 if (status == WAIT_OBJECT_0)
1272 {
1273 if ((error = context->CheckEventHandle(context)))
1274 {
1275 WLog_ERR(TAG, "CheckEventHandle failed with error %" PRIu32 "!", error);
1276 break;
1277 }
1278 }
1279 }
1280
1281out:
1282
1283 if (error && context->rdpcontext)
1284 setChannelError(context->rdpcontext, error, "cliprdr_server_thread reported an error");
1285
1286 ExitThread(error);
1287 return error;
1288}
1289
1295static UINT cliprdr_server_open(CliprdrServerContext* context)
1296{
1297 void* buffer = nullptr;
1298 DWORD BytesReturned = 0;
1299 CliprdrServerPrivate* cliprdr = nullptr;
1300
1301 WINPR_ASSERT(context);
1302
1303 cliprdr = (CliprdrServerPrivate*)context->handle;
1304 WINPR_ASSERT(cliprdr);
1305
1306 cliprdr->ChannelHandle =
1307 WTSVirtualChannelOpen(cliprdr->vcm, WTS_CURRENT_SESSION, CLIPRDR_SVC_CHANNEL_NAME);
1308
1309 if (!cliprdr->ChannelHandle)
1310 {
1311 WLog_ERR(TAG, "WTSVirtualChannelOpen for cliprdr failed!");
1312 return ERROR_INTERNAL_ERROR;
1313 }
1314
1315 cliprdr->ChannelEvent = nullptr;
1316
1317 if (WTSVirtualChannelQuery(cliprdr->ChannelHandle, WTSVirtualEventHandle, &buffer,
1318 &BytesReturned))
1319 {
1320 if (BytesReturned != sizeof(HANDLE))
1321 {
1322 WLog_ERR(TAG, "BytesReturned has not size of HANDLE!");
1323 return ERROR_INTERNAL_ERROR;
1324 }
1325
1326 cliprdr->ChannelEvent = *(HANDLE*)buffer;
1327 WTSFreeMemory(buffer);
1328 }
1329
1330 if (!cliprdr->ChannelEvent)
1331 {
1332 WLog_ERR(TAG, "WTSVirtualChannelQuery for cliprdr failed!");
1333 return ERROR_INTERNAL_ERROR;
1334 }
1335
1336 return CHANNEL_RC_OK;
1337}
1338
1344static UINT cliprdr_server_close(CliprdrServerContext* context)
1345{
1346 CliprdrServerPrivate* cliprdr = nullptr;
1347
1348 WINPR_ASSERT(context);
1349
1350 cliprdr = (CliprdrServerPrivate*)context->handle;
1351 WINPR_ASSERT(cliprdr);
1352
1353 if (cliprdr->ChannelHandle)
1354 {
1355 (void)WTSVirtualChannelClose(cliprdr->ChannelHandle);
1356 cliprdr->ChannelHandle = nullptr;
1357 }
1358
1359 return CHANNEL_RC_OK;
1360}
1361
1367static UINT cliprdr_server_start(CliprdrServerContext* context)
1368{
1369 UINT error = 0;
1370 CliprdrServerPrivate* cliprdr = nullptr;
1371
1372 WINPR_ASSERT(context);
1373
1374 cliprdr = (CliprdrServerPrivate*)context->handle;
1375 WINPR_ASSERT(cliprdr);
1376
1377 if (!cliprdr->ChannelHandle)
1378 {
1379 if ((error = context->Open(context)))
1380 {
1381 WLog_ERR(TAG, "Open failed!");
1382 return error;
1383 }
1384 }
1385
1386 if (!(cliprdr->StopEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr)))
1387 {
1388 WLog_ERR(TAG, "CreateEvent failed!");
1389 return ERROR_INTERNAL_ERROR;
1390 }
1391
1392 if (!(cliprdr->Thread =
1393 CreateThread(nullptr, 0, cliprdr_server_thread, (void*)context, 0, nullptr)))
1394 {
1395 WLog_ERR(TAG, "CreateThread failed!");
1396 (void)CloseHandle(cliprdr->StopEvent);
1397 cliprdr->StopEvent = nullptr;
1398 return ERROR_INTERNAL_ERROR;
1399 }
1400
1401 return CHANNEL_RC_OK;
1402}
1403
1409static UINT cliprdr_server_stop(CliprdrServerContext* context)
1410{
1411 UINT error = CHANNEL_RC_OK;
1412 CliprdrServerPrivate* cliprdr = nullptr;
1413
1414 WINPR_ASSERT(context);
1415
1416 cliprdr = (CliprdrServerPrivate*)context->handle;
1417 WINPR_ASSERT(cliprdr);
1418
1419 if (cliprdr->StopEvent)
1420 {
1421 (void)SetEvent(cliprdr->StopEvent);
1422
1423 if (WaitForSingleObject(cliprdr->Thread, INFINITE) == WAIT_FAILED)
1424 {
1425 error = GetLastError();
1426 WLog_ERR(TAG, "WaitForSingleObject failed with error %" PRIu32 "", error);
1427 return error;
1428 }
1429
1430 (void)CloseHandle(cliprdr->Thread);
1431 (void)CloseHandle(cliprdr->StopEvent);
1432 }
1433
1434 if (cliprdr->ChannelHandle)
1435 return context->Close(context);
1436
1437 return error;
1438}
1439
1440static HANDLE cliprdr_server_get_event_handle(CliprdrServerContext* context)
1441{
1442 CliprdrServerPrivate* cliprdr = nullptr;
1443
1444 WINPR_ASSERT(context);
1445
1446 cliprdr = (CliprdrServerPrivate*)context->handle;
1447 WINPR_ASSERT(cliprdr);
1448 return cliprdr->ChannelEvent;
1449}
1450
1456static UINT cliprdr_server_check_event_handle(CliprdrServerContext* context)
1457{
1458 return cliprdr_server_read(context);
1459}
1460
1461CliprdrServerContext* cliprdr_server_context_new(HANDLE vcm)
1462{
1463 CliprdrServerPrivate* cliprdr = nullptr;
1464 CliprdrServerContext* context = (CliprdrServerContext*)calloc(1, sizeof(CliprdrServerContext));
1465
1466 if (context)
1467 {
1468 context->autoInitializationSequence = TRUE;
1469 context->Open = cliprdr_server_open;
1470 context->Close = cliprdr_server_close;
1471 context->Start = cliprdr_server_start;
1472 context->Stop = cliprdr_server_stop;
1473 context->GetEventHandle = cliprdr_server_get_event_handle;
1474 context->CheckEventHandle = cliprdr_server_check_event_handle;
1475 context->ServerCapabilities = cliprdr_server_capabilities;
1476 context->MonitorReady = cliprdr_server_monitor_ready;
1477 context->ServerFormatList = cliprdr_server_format_list;
1478 context->ServerFormatListResponse = cliprdr_server_format_list_response;
1479 context->ServerLockClipboardData = cliprdr_server_lock_clipboard_data;
1480 context->ServerUnlockClipboardData = cliprdr_server_unlock_clipboard_data;
1481 context->ServerFormatDataRequest = cliprdr_server_format_data_request;
1482 context->ServerFormatDataResponse = cliprdr_server_format_data_response;
1483 context->ServerFileContentsRequest = cliprdr_server_file_contents_request;
1484 context->ServerFileContentsResponse = cliprdr_server_file_contents_response;
1485 cliprdr = context->handle = (CliprdrServerPrivate*)calloc(1, sizeof(CliprdrServerPrivate));
1486
1487 if (cliprdr)
1488 {
1489 cliprdr->vcm = vcm;
1490 cliprdr->s = Stream_New(nullptr, 4096);
1491
1492 if (!cliprdr->s)
1493 {
1494 WLog_ERR(TAG, "Stream_New failed!");
1495 free(context->handle);
1496 free(context);
1497 return nullptr;
1498 }
1499 }
1500 else
1501 {
1502 WLog_ERR(TAG, "calloc failed!");
1503 free(context);
1504 return nullptr;
1505 }
1506 }
1507
1508 return context;
1509}
1510
1511void cliprdr_server_context_free(CliprdrServerContext* context)
1512{
1513 CliprdrServerPrivate* cliprdr = nullptr;
1514
1515 if (!context)
1516 return;
1517
1518 cliprdr = (CliprdrServerPrivate*)context->handle;
1519
1520 if (cliprdr)
1521 {
1522 Stream_Free(cliprdr->s, TRUE);
1523 }
1524
1525 free(context->handle);
1526 free(context);
1527}
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