FreeRDP
Loading...
Searching...
No Matches
wf_cliprdr.c
1
23#include <freerdp/config.h>
24
25#define CINTERFACE
26#define COBJMACROS
27
28#include <ole2.h>
29#include <shlobj.h>
30#include <windows.h>
31#include <winuser.h>
32
33#include <winpr/assert.h>
34#include <winpr/library.h>
35
36#include <winpr/crt.h>
37#include <winpr/tchar.h>
38#include <winpr/stream.h>
39
40#include <freerdp/log.h>
41#include <freerdp/client/cliprdr.h>
42
43#include <strsafe.h>
44
45#include "wf_cliprdr.h"
46
47#define TAG CLIENT_TAG("windows")
48
49#ifdef WITH_DEBUG_CLIPRDR
50#define DEBUG_CLIPRDR(...) WLog_DBG(TAG, __VA_ARGS__)
51#else
52#define DEBUG_CLIPRDR(...) \
53 do \
54 { \
55 } while (0)
56#endif
57
58typedef BOOL(WINAPI* fnAddClipboardFormatListener)(HWND hwnd);
59typedef BOOL(WINAPI* fnRemoveClipboardFormatListener)(HWND hwnd);
60typedef BOOL(WINAPI* fnGetUpdatedClipboardFormats)(PUINT lpuiFormats, UINT cFormats,
61 PUINT pcFormatsOut);
62
63typedef struct
64{
65 UINT32 remote_format_id;
66 UINT32 local_format_id;
67 WCHAR* name;
68} formatMapping;
69
70typedef struct
71{
72 IEnumFORMATETC iEnumFORMATETC;
73
74 LONG m_lRefCount;
75 LONG m_nIndex;
76 LONG m_nNumFormats;
77 FORMATETC* m_pFormatEtc;
78} CliprdrEnumFORMATETC;
79
80typedef struct
81{
82 IStream iStream;
83
84 LONG m_lRefCount;
85 ULONG m_lIndex;
86 ULARGE_INTEGER m_lSize;
87 ULARGE_INTEGER m_lOffset;
88 FILEDESCRIPTORW m_Dsc;
89 void* m_pData;
90} CliprdrStream;
91
92typedef struct
93{
94 IDataObject iDataObject;
95
96 LONG m_lRefCount;
97 FORMATETC* m_pFormatEtc;
98 STGMEDIUM* m_pStgMedium;
99 ULONG m_nNumFormats;
100 ULONG m_nStreams;
101 IStream** m_pStream;
102 void* m_pData;
103} CliprdrDataObject;
104
105typedef struct
106{
107 wfContext* wfc;
108 rdpChannels* channels;
109 CliprdrClientContext* context;
110
111 BOOL sync;
112 UINT32 capabilities;
113
114 size_t map_size;
115 size_t map_capacity;
116 formatMapping* format_mappings;
117
118 UINT32 requestedFormatId;
119
120 HWND hwnd;
121 HANDLE hmem;
122 HANDLE thread;
123 HANDLE response_data_event;
124
125 LPDATAOBJECT data_obj;
126 ULONG req_fsize;
127 char* req_fdata;
128 HANDLE req_fevent;
129
130 size_t nFiles;
131 size_t file_array_size;
132 WCHAR** file_names;
133 FILEDESCRIPTORW** fileDescriptor;
134
135 BOOL legacyApi;
136 HMODULE hUser32;
137 HWND hWndNextViewer;
138 fnAddClipboardFormatListener AddClipboardFormatListener;
139 fnRemoveClipboardFormatListener RemoveClipboardFormatListener;
140 fnGetUpdatedClipboardFormats GetUpdatedClipboardFormats;
141} wfClipboard;
142
143#define WM_CLIPRDR_MESSAGE (WM_USER + 156)
144#define OLE_SETCLIPBOARD 1
145
146static BOOL wf_create_file_obj(wfClipboard* cliprdrrdr, IDataObject** ppDataObject);
147static void wf_destroy_file_obj(IDataObject* instance);
148static UINT32 get_remote_format_id(wfClipboard* clipboard, UINT32 local_format);
149static UINT cliprdr_send_data_request(wfClipboard* clipboard, UINT32 format);
150static UINT cliprdr_send_lock(wfClipboard* clipboard);
151static UINT cliprdr_send_unlock(wfClipboard* clipboard);
152static UINT cliprdr_send_request_filecontents(wfClipboard* clipboard, const void* streamid,
153 ULONG index, UINT32 flag, UINT64 position,
154 ULONG request);
155
156static void CliprdrDataObject_Delete(CliprdrDataObject* instance);
157
158static CliprdrEnumFORMATETC* CliprdrEnumFORMATETC_New(ULONG nFormats, FORMATETC* pFormatEtc);
159static void CliprdrEnumFORMATETC_Delete(CliprdrEnumFORMATETC* instance);
160
161static void CliprdrStream_Delete(CliprdrStream* instance);
162
163static BOOL try_open_clipboard(HWND hwnd)
164{
165 for (size_t x = 0; x < 10; x++)
166 {
167 if (OpenClipboard(hwnd))
168 return TRUE;
169 Sleep(10);
170 }
171 return FALSE;
172}
173
178static HRESULT STDMETHODCALLTYPE CliprdrStream_QueryInterface(IStream* This, REFIID riid,
179 void** ppvObject)
180{
181 if (IsEqualIID(riid, &IID_IStream) || IsEqualIID(riid, &IID_IUnknown))
182 {
183 IStream_AddRef(This);
184 *ppvObject = This;
185 return S_OK;
186 }
187 else
188 {
189 *ppvObject = 0;
190 return E_NOINTERFACE;
191 }
192}
193
194static ULONG STDMETHODCALLTYPE CliprdrStream_AddRef(IStream* This)
195{
196 CliprdrStream* instance = (CliprdrStream*)This;
197
198 if (!instance)
199 return 0;
200
201 return InterlockedIncrement(&instance->m_lRefCount);
202}
203
204static ULONG STDMETHODCALLTYPE CliprdrStream_Release(IStream* This)
205{
206 LONG count;
207 CliprdrStream* instance = (CliprdrStream*)This;
208
209 if (!instance)
210 return 0;
211
212 count = InterlockedDecrement(&instance->m_lRefCount);
213
214 if (count == 0)
215 {
216 CliprdrStream_Delete(instance);
217 return 0;
218 }
219 else
220 {
221 return count;
222 }
223}
224
225static HRESULT STDMETHODCALLTYPE CliprdrStream_Read(IStream* This, void* pv, ULONG cb,
226 ULONG* pcbRead)
227{
228 CliprdrStream* instance = (CliprdrStream*)This;
229
230 if (!pv || !pcbRead || !instance)
231 return E_INVALIDARG;
232
233 wfClipboard* clipboard = (wfClipboard*)instance->m_pData;
234 *pcbRead = 0;
235
236 if (instance->m_lOffset.QuadPart >= instance->m_lSize.QuadPart)
237 return S_FALSE;
238
239 const int ret =
240 cliprdr_send_request_filecontents(clipboard, (void*)This, instance->m_lIndex,
241 FILECONTENTS_RANGE, instance->m_lOffset.QuadPart, cb);
242
243 if (ret < 0)
244 return E_FAIL;
245
246 if (clipboard->req_fsize > cb)
247 return E_FAIL;
248
249 if (clipboard->req_fdata)
250 {
251 CopyMemory(pv, clipboard->req_fdata, clipboard->req_fsize);
252 free(clipboard->req_fdata);
253 }
254
255 *pcbRead = clipboard->req_fsize;
256 instance->m_lOffset.QuadPart += clipboard->req_fsize;
257
258 if (clipboard->req_fsize < cb)
259 return S_FALSE;
260
261 return S_OK;
262}
263
264static HRESULT STDMETHODCALLTYPE CliprdrStream_Write(IStream* This, const void* pv, ULONG cb,
265 ULONG* pcbWritten)
266{
267 (void)This;
268 (void)pv;
269 (void)cb;
270 (void)pcbWritten;
271 return STG_E_ACCESSDENIED;
272}
273
274static HRESULT STDMETHODCALLTYPE CliprdrStream_Seek(IStream* This, LARGE_INTEGER dlibMove,
275 DWORD dwOrigin, ULARGE_INTEGER* plibNewPosition)
276{
277 ULONGLONG newoffset;
278 CliprdrStream* instance = (CliprdrStream*)This;
279
280 if (!instance)
281 return E_INVALIDARG;
282
283 newoffset = instance->m_lOffset.QuadPart;
284
285 switch (dwOrigin)
286 {
287 case STREAM_SEEK_SET:
288 newoffset = dlibMove.QuadPart;
289 break;
290
291 case STREAM_SEEK_CUR:
292 newoffset += dlibMove.QuadPart;
293 break;
294
295 case STREAM_SEEK_END:
296 newoffset = instance->m_lSize.QuadPart + dlibMove.QuadPart;
297 break;
298
299 default:
300 return E_INVALIDARG;
301 }
302
303 if (newoffset < 0 || newoffset >= instance->m_lSize.QuadPart)
304 return E_FAIL;
305
306 instance->m_lOffset.QuadPart = newoffset;
307
308 if (plibNewPosition)
309 plibNewPosition->QuadPart = instance->m_lOffset.QuadPart;
310
311 return S_OK;
312}
313
314static HRESULT STDMETHODCALLTYPE CliprdrStream_SetSize(IStream* This, ULARGE_INTEGER libNewSize)
315{
316 (void)This;
317 (void)libNewSize;
318 return E_NOTIMPL;
319}
320
321static HRESULT STDMETHODCALLTYPE CliprdrStream_CopyTo(IStream* This, IStream* pstm,
322 ULARGE_INTEGER cb, ULARGE_INTEGER* pcbRead,
323 ULARGE_INTEGER* pcbWritten)
324{
325 (void)This;
326 (void)pstm;
327 (void)cb;
328 (void)pcbRead;
329 (void)pcbWritten;
330 return E_NOTIMPL;
331}
332
333static HRESULT STDMETHODCALLTYPE CliprdrStream_Commit(IStream* This, DWORD grfCommitFlags)
334{
335 (void)This;
336 (void)grfCommitFlags;
337 return E_NOTIMPL;
338}
339
340static HRESULT STDMETHODCALLTYPE CliprdrStream_Revert(IStream* This)
341{
342 (void)This;
343 return E_NOTIMPL;
344}
345
346static HRESULT STDMETHODCALLTYPE CliprdrStream_LockRegion(IStream* This, ULARGE_INTEGER libOffset,
347 ULARGE_INTEGER cb, DWORD dwLockType)
348{
349 (void)This;
350 (void)libOffset;
351 (void)cb;
352 (void)dwLockType;
353 return E_NOTIMPL;
354}
355
356static HRESULT STDMETHODCALLTYPE CliprdrStream_UnlockRegion(IStream* This, ULARGE_INTEGER libOffset,
357 ULARGE_INTEGER cb, DWORD dwLockType)
358{
359 (void)This;
360 (void)libOffset;
361 (void)cb;
362 (void)dwLockType;
363 return E_NOTIMPL;
364}
365
366static HRESULT STDMETHODCALLTYPE CliprdrStream_Stat(IStream* This, STATSTG* pstatstg,
367 DWORD grfStatFlag)
368{
369 CliprdrStream* instance = (CliprdrStream*)This;
370
371 if (!instance)
372 return E_INVALIDARG;
373
374 if (pstatstg == nullptr)
375 return STG_E_INVALIDPOINTER;
376
377 ZeroMemory(pstatstg, sizeof(STATSTG));
378
379 switch (grfStatFlag)
380 {
381 case STATFLAG_DEFAULT:
382 return STG_E_INSUFFICIENTMEMORY;
383
384 case STATFLAG_NONAME:
385 pstatstg->cbSize.QuadPart = instance->m_lSize.QuadPart;
386 pstatstg->grfLocksSupported = LOCK_EXCLUSIVE;
387 pstatstg->grfMode = GENERIC_READ;
388 pstatstg->grfStateBits = 0;
389 pstatstg->type = STGTY_STREAM;
390 break;
391
392 case STATFLAG_NOOPEN:
393 return STG_E_INVALIDFLAG;
394
395 default:
396 return STG_E_INVALIDFLAG;
397 }
398
399 return S_OK;
400}
401
402static HRESULT STDMETHODCALLTYPE CliprdrStream_Clone(IStream* This, IStream** ppstm)
403{
404 (void)This;
405 (void)ppstm;
406 return E_NOTIMPL;
407}
408
409static CliprdrStream* CliprdrStream_New(ULONG index, void* pData, const FILEDESCRIPTORW* dsc)
410{
411 IStream* iStream;
412 BOOL success = FALSE;
413 BOOL isDir = FALSE;
414 CliprdrStream* instance;
415 wfClipboard* clipboard = (wfClipboard*)pData;
416 instance = (CliprdrStream*)calloc(1, sizeof(CliprdrStream));
417
418 if (instance)
419 {
420 instance->m_Dsc = *dsc;
421 iStream = &instance->iStream;
422 iStream->lpVtbl = (IStreamVtbl*)calloc(1, sizeof(IStreamVtbl));
423
424 if (iStream->lpVtbl)
425 {
426 iStream->lpVtbl->QueryInterface = CliprdrStream_QueryInterface;
427 iStream->lpVtbl->AddRef = CliprdrStream_AddRef;
428 iStream->lpVtbl->Release = CliprdrStream_Release;
429 iStream->lpVtbl->Read = CliprdrStream_Read;
430 iStream->lpVtbl->Write = CliprdrStream_Write;
431 iStream->lpVtbl->Seek = CliprdrStream_Seek;
432 iStream->lpVtbl->SetSize = CliprdrStream_SetSize;
433 iStream->lpVtbl->CopyTo = CliprdrStream_CopyTo;
434 iStream->lpVtbl->Commit = CliprdrStream_Commit;
435 iStream->lpVtbl->Revert = CliprdrStream_Revert;
436 iStream->lpVtbl->LockRegion = CliprdrStream_LockRegion;
437 iStream->lpVtbl->UnlockRegion = CliprdrStream_UnlockRegion;
438 iStream->lpVtbl->Stat = CliprdrStream_Stat;
439 iStream->lpVtbl->Clone = CliprdrStream_Clone;
440 instance->m_lRefCount = 1;
441 instance->m_lIndex = index;
442 instance->m_pData = pData;
443 instance->m_lOffset.QuadPart = 0;
444
445 if (instance->m_Dsc.dwFlags & FD_ATTRIBUTES)
446 {
447 if (instance->m_Dsc.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
448 isDir = TRUE;
449 }
450
451 if (((instance->m_Dsc.dwFlags & FD_FILESIZE) == 0) && !isDir)
452 {
453 /* get content size of this stream */
454 if (cliprdr_send_request_filecontents(clipboard, (void*)instance,
455 instance->m_lIndex, FILECONTENTS_SIZE, 0,
456 8) == CHANNEL_RC_OK)
457 {
458 success = TRUE;
459 }
460
461 if (clipboard->req_fsize < 8)
462 success = FALSE;
463 else
464 instance->m_lSize.QuadPart = *((LONGLONG*)clipboard->req_fdata);
465 free(clipboard->req_fdata);
466 }
467 else
468 {
469 instance->m_lSize.QuadPart =
470 ((UINT64)instance->m_Dsc.nFileSizeHigh << 32) | instance->m_Dsc.nFileSizeLow;
471 success = TRUE;
472 }
473 }
474 }
475
476 if (!success)
477 {
478 CliprdrStream_Delete(instance);
479 instance = nullptr;
480 }
481
482 return instance;
483}
484
485void CliprdrStream_Delete(CliprdrStream* instance)
486{
487 if (instance)
488 {
489 free(instance->iStream.lpVtbl);
490 free(instance);
491 }
492}
493
498static LONG cliprdr_lookup_format(CliprdrDataObject* instance, FORMATETC* pFormatEtc)
499{
500 if (!instance || !pFormatEtc)
501 return -1;
502
503 for (ULONG i = 0; i < instance->m_nNumFormats; i++)
504 {
505 if ((pFormatEtc->tymed & instance->m_pFormatEtc[i].tymed) &&
506 pFormatEtc->cfFormat == instance->m_pFormatEtc[i].cfFormat &&
507 pFormatEtc->dwAspect & instance->m_pFormatEtc[i].dwAspect)
508 {
509 return (LONG)i;
510 }
511 }
512
513 return -1;
514}
515
516static HRESULT STDMETHODCALLTYPE CliprdrDataObject_QueryInterface(IDataObject* This, REFIID riid,
517 void** ppvObject)
518{
519 (void)This;
520
521 if (!ppvObject)
522 return E_INVALIDARG;
523
524 if (IsEqualIID(riid, &IID_IDataObject) || IsEqualIID(riid, &IID_IUnknown))
525 {
526 IDataObject_AddRef(This);
527 *ppvObject = This;
528 return S_OK;
529 }
530 else
531 {
532 *ppvObject = 0;
533 return E_NOINTERFACE;
534 }
535}
536
537static ULONG STDMETHODCALLTYPE CliprdrDataObject_AddRef(IDataObject* This)
538{
539 CliprdrDataObject* instance = (CliprdrDataObject*)This;
540
541 if (!instance)
542 return E_INVALIDARG;
543
544 return InterlockedIncrement(&instance->m_lRefCount);
545}
546
547static ULONG STDMETHODCALLTYPE CliprdrDataObject_Release(IDataObject* This)
548{
549 LONG count;
550 CliprdrDataObject* instance = (CliprdrDataObject*)This;
551
552 if (!instance)
553 return E_INVALIDARG;
554
555 count = InterlockedDecrement(&instance->m_lRefCount);
556
557 if (count == 0)
558 {
559 CliprdrDataObject_Delete(instance);
560 return 0;
561 }
562 else
563 return count;
564}
565
566static HRESULT STDMETHODCALLTYPE CliprdrDataObject_GetData(IDataObject* This, FORMATETC* pFormatEtc,
567 STGMEDIUM* pMedium)
568{
569 LONG idx;
570 CliprdrDataObject* instance = (CliprdrDataObject*)This;
571 wfClipboard* clipboard;
572
573 if (!pFormatEtc || !pMedium || !instance)
574 return E_INVALIDARG;
575
576 clipboard = (wfClipboard*)instance->m_pData;
577
578 if (!clipboard)
579 return E_INVALIDARG;
580
581 if ((idx = cliprdr_lookup_format(instance, pFormatEtc)) == -1)
582 return DV_E_FORMATETC;
583
584 pMedium->tymed = instance->m_pFormatEtc[idx].tymed;
585 pMedium->pUnkForRelease = 0;
586
587 if (instance->m_pFormatEtc[idx].cfFormat == RegisterClipboardFormat(CFSTR_FILEDESCRIPTORW))
588 {
589 FILEGROUPDESCRIPTOR* dsc;
590 DWORD remote = get_remote_format_id(clipboard, instance->m_pFormatEtc[idx].cfFormat);
591
592 if (cliprdr_send_data_request(clipboard, remote) != 0)
593 return E_UNEXPECTED;
594
595 pMedium->u.hGlobal = clipboard->hmem;
596 /* points to a FILEGROUPDESCRIPTOR structure */
597 /* GlobalLock returns a pointer to the first byte of the memory block,
598 * in which is a FILEGROUPDESCRIPTOR structure, whose first UINT member
599 * is the number of FILEDESCRIPTOR's */
600 dsc = (FILEGROUPDESCRIPTOR*)GlobalLock(clipboard->hmem);
601 instance->m_nStreams = dsc->cItems;
602 GlobalUnlock(clipboard->hmem);
603
604 if (instance->m_nStreams > 0)
605 {
606 if (!instance->m_pStream)
607 {
608 instance->m_pStream = (LPSTREAM*)calloc(instance->m_nStreams, sizeof(LPSTREAM));
609
610 if (instance->m_pStream)
611 {
612 for (ULONG i = 0; i < instance->m_nStreams; i++)
613 {
614 instance->m_pStream[i] =
615 (IStream*)CliprdrStream_New(i, clipboard, &dsc->fgd[i]);
616
617 if (!instance->m_pStream[i])
618 return E_OUTOFMEMORY;
619 }
620 }
621 }
622 }
623
624 if (!instance->m_pStream)
625 {
626 if (clipboard->hmem)
627 {
628 GlobalFree(clipboard->hmem);
629 clipboard->hmem = nullptr;
630 }
631
632 pMedium->u.hGlobal = nullptr;
633 return E_OUTOFMEMORY;
634 }
635 }
636 else if (instance->m_pFormatEtc[idx].cfFormat == RegisterClipboardFormat(CFSTR_FILECONTENTS))
637 {
638 if ((pFormatEtc->lindex >= 0) && ((ULONG)pFormatEtc->lindex < instance->m_nStreams))
639 {
640 pMedium->u.pstm = instance->m_pStream[pFormatEtc->lindex];
641 IDataObject_AddRef(instance->m_pStream[pFormatEtc->lindex]);
642 }
643 else
644 return E_INVALIDARG;
645 }
646 else
647 return E_UNEXPECTED;
648
649 return S_OK;
650}
651
652static HRESULT STDMETHODCALLTYPE CliprdrDataObject_GetDataHere(IDataObject* This,
653 FORMATETC* pformatetc,
654 STGMEDIUM* pmedium)
655{
656 (void)This;
657 (void)pformatetc;
658 (void)pmedium;
659 return E_NOTIMPL;
660}
661
662static HRESULT STDMETHODCALLTYPE CliprdrDataObject_QueryGetData(IDataObject* This,
663 FORMATETC* pformatetc)
664{
665 CliprdrDataObject* instance = (CliprdrDataObject*)This;
666
667 if (!pformatetc)
668 return E_INVALIDARG;
669
670 if (cliprdr_lookup_format(instance, pformatetc) == -1)
671 return DV_E_FORMATETC;
672
673 return S_OK;
674}
675
676static HRESULT STDMETHODCALLTYPE CliprdrDataObject_GetCanonicalFormatEtc(IDataObject* This,
677 FORMATETC* pformatectIn,
678 FORMATETC* pformatetcOut)
679{
680 (void)This;
681 (void)pformatectIn;
682
683 if (!pformatetcOut)
684 return E_INVALIDARG;
685
686 pformatetcOut->ptd = nullptr;
687 return E_NOTIMPL;
688}
689
690static HRESULT STDMETHODCALLTYPE CliprdrDataObject_SetData(IDataObject* This, FORMATETC* pformatetc,
691 STGMEDIUM* pmedium, BOOL fRelease)
692{
693 (void)This;
694 (void)pformatetc;
695 (void)pmedium;
696 (void)fRelease;
697 return E_NOTIMPL;
698}
699
700static HRESULT STDMETHODCALLTYPE CliprdrDataObject_EnumFormatEtc(IDataObject* This,
701 DWORD dwDirection,
702 IEnumFORMATETC** ppenumFormatEtc)
703{
704 CliprdrDataObject* instance = (CliprdrDataObject*)This;
705
706 if (!instance || !ppenumFormatEtc)
707 return E_INVALIDARG;
708
709 if (dwDirection == DATADIR_GET)
710 {
711 *ppenumFormatEtc = (IEnumFORMATETC*)CliprdrEnumFORMATETC_New(instance->m_nNumFormats,
712 instance->m_pFormatEtc);
713 return (*ppenumFormatEtc) ? S_OK : E_OUTOFMEMORY;
714 }
715 else
716 {
717 return E_NOTIMPL;
718 }
719}
720
721static HRESULT STDMETHODCALLTYPE CliprdrDataObject_DAdvise(IDataObject* This, FORMATETC* pformatetc,
722 DWORD advf, IAdviseSink* pAdvSink,
723 DWORD* pdwConnection)
724{
725 (void)This;
726 (void)pformatetc;
727 (void)advf;
728 (void)pAdvSink;
729 (void)pdwConnection;
730 return OLE_E_ADVISENOTSUPPORTED;
731}
732
733static HRESULT STDMETHODCALLTYPE CliprdrDataObject_DUnadvise(IDataObject* This, DWORD dwConnection)
734{
735 (void)This;
736 (void)dwConnection;
737 return OLE_E_ADVISENOTSUPPORTED;
738}
739
740static HRESULT STDMETHODCALLTYPE CliprdrDataObject_EnumDAdvise(IDataObject* This,
741 IEnumSTATDATA** ppenumAdvise)
742{
743 (void)This;
744 (void)ppenumAdvise;
745 return OLE_E_ADVISENOTSUPPORTED;
746}
747
748static CliprdrDataObject* CliprdrDataObject_New(FORMATETC* fmtetc, STGMEDIUM* stgmed, ULONG count,
749 void* data)
750{
751 CliprdrDataObject* instance;
752 IDataObject* iDataObject;
753 instance = (CliprdrDataObject*)calloc(1, sizeof(CliprdrDataObject));
754
755 if (!instance)
756 goto error;
757
758 iDataObject = &instance->iDataObject;
759 iDataObject->lpVtbl = (IDataObjectVtbl*)calloc(1, sizeof(IDataObjectVtbl));
760
761 if (!iDataObject->lpVtbl)
762 goto error;
763
764 iDataObject->lpVtbl->QueryInterface = CliprdrDataObject_QueryInterface;
765 iDataObject->lpVtbl->AddRef = CliprdrDataObject_AddRef;
766 iDataObject->lpVtbl->Release = CliprdrDataObject_Release;
767 iDataObject->lpVtbl->GetData = CliprdrDataObject_GetData;
768 iDataObject->lpVtbl->GetDataHere = CliprdrDataObject_GetDataHere;
769 iDataObject->lpVtbl->QueryGetData = CliprdrDataObject_QueryGetData;
770 iDataObject->lpVtbl->GetCanonicalFormatEtc = CliprdrDataObject_GetCanonicalFormatEtc;
771 iDataObject->lpVtbl->SetData = CliprdrDataObject_SetData;
772 iDataObject->lpVtbl->EnumFormatEtc = CliprdrDataObject_EnumFormatEtc;
773 iDataObject->lpVtbl->DAdvise = CliprdrDataObject_DAdvise;
774 iDataObject->lpVtbl->DUnadvise = CliprdrDataObject_DUnadvise;
775 iDataObject->lpVtbl->EnumDAdvise = CliprdrDataObject_EnumDAdvise;
776 instance->m_lRefCount = 1;
777 instance->m_nNumFormats = count;
778 instance->m_pData = data;
779 instance->m_nStreams = 0;
780 instance->m_pStream = nullptr;
781
782 if (count > 0)
783 {
784 instance->m_pFormatEtc = (FORMATETC*)calloc(count, sizeof(FORMATETC));
785
786 if (!instance->m_pFormatEtc)
787 goto error;
788
789 instance->m_pStgMedium = (STGMEDIUM*)calloc(count, sizeof(STGMEDIUM));
790
791 if (!instance->m_pStgMedium)
792 goto error;
793
794 for (ULONG i = 0; i < count; i++)
795 {
796 instance->m_pFormatEtc[i] = fmtetc[i];
797 instance->m_pStgMedium[i] = stgmed[i];
798 }
799 }
800
801 return instance;
802error:
803 CliprdrDataObject_Delete(instance);
804 return nullptr;
805}
806
807void CliprdrDataObject_Delete(CliprdrDataObject* instance)
808{
809 if (instance)
810 {
811 free(instance->iDataObject.lpVtbl);
812 free(instance->m_pFormatEtc);
813 free(instance->m_pStgMedium);
814
815 if (instance->m_pStream)
816 {
817 for (ULONG i = 0; i < instance->m_nStreams; i++)
818 CliprdrStream_Release(instance->m_pStream[i]);
819
820 free(instance->m_pStream);
821 }
822
823 free(instance);
824 }
825}
826
827static BOOL wf_create_file_obj(wfClipboard* clipboard, IDataObject** ppDataObject)
828{
829 FORMATETC fmtetc[2] = WINPR_C_ARRAY_INIT;
830 STGMEDIUM stgmeds[2] = WINPR_C_ARRAY_INIT;
831
832 if (!ppDataObject)
833 return FALSE;
834
835 fmtetc[0].cfFormat = RegisterClipboardFormat(CFSTR_FILEDESCRIPTORW);
836 fmtetc[0].dwAspect = DVASPECT_CONTENT;
837
838 fmtetc[0].tymed = TYMED_HGLOBAL;
839 stgmeds[0].tymed = TYMED_HGLOBAL;
840
841 fmtetc[1].cfFormat = RegisterClipboardFormat(CFSTR_FILECONTENTS);
842 fmtetc[1].dwAspect = DVASPECT_CONTENT;
843
844 fmtetc[1].tymed = TYMED_ISTREAM;
845 stgmeds[1].tymed = TYMED_ISTREAM;
846
847 *ppDataObject = (IDataObject*)CliprdrDataObject_New(fmtetc, stgmeds, 2, clipboard);
848 return (*ppDataObject) ? TRUE : FALSE;
849}
850
851static void wf_destroy_file_obj(IDataObject* instance)
852{
853 if (instance)
854 IDataObject_Release(instance);
855}
856
861static void cliprdr_format_deep_copy(FORMATETC* dest, FORMATETC* source)
862{
863 *dest = *source;
864
865 if (source->ptd)
866 {
867 dest->ptd = (DVTARGETDEVICE*)CoTaskMemAlloc(sizeof(DVTARGETDEVICE));
868
869 if (dest->ptd)
870 *(dest->ptd) = *(source->ptd);
871 }
872}
873
874static HRESULT STDMETHODCALLTYPE CliprdrEnumFORMATETC_QueryInterface(IEnumFORMATETC* This,
875 REFIID riid, void** ppvObject)
876{
877 (void)This;
878
879 if (IsEqualIID(riid, &IID_IEnumFORMATETC) || IsEqualIID(riid, &IID_IUnknown))
880 {
881 IEnumFORMATETC_AddRef(This);
882 *ppvObject = This;
883 return S_OK;
884 }
885 else
886 {
887 *ppvObject = 0;
888 return E_NOINTERFACE;
889 }
890}
891
892static ULONG STDMETHODCALLTYPE CliprdrEnumFORMATETC_AddRef(IEnumFORMATETC* This)
893{
894 CliprdrEnumFORMATETC* instance = (CliprdrEnumFORMATETC*)This;
895
896 if (!instance)
897 return 0;
898
899 return InterlockedIncrement(&instance->m_lRefCount);
900}
901
902static ULONG STDMETHODCALLTYPE CliprdrEnumFORMATETC_Release(IEnumFORMATETC* This)
903{
904 LONG count;
905 CliprdrEnumFORMATETC* instance = (CliprdrEnumFORMATETC*)This;
906
907 if (!instance)
908 return 0;
909
910 count = InterlockedDecrement(&instance->m_lRefCount);
911
912 if (count == 0)
913 {
914 CliprdrEnumFORMATETC_Delete(instance);
915 return 0;
916 }
917 else
918 {
919 return count;
920 }
921}
922
923static HRESULT STDMETHODCALLTYPE CliprdrEnumFORMATETC_Next(IEnumFORMATETC* This, ULONG celt,
924 FORMATETC* rgelt, ULONG* pceltFetched)
925{
926 ULONG copied = 0;
927 CliprdrEnumFORMATETC* instance = (CliprdrEnumFORMATETC*)This;
928
929 if (!instance || !celt || !rgelt)
930 return E_INVALIDARG;
931
932 while ((instance->m_nIndex < instance->m_nNumFormats) && (copied < celt))
933 {
934 cliprdr_format_deep_copy(&rgelt[copied++], &instance->m_pFormatEtc[instance->m_nIndex++]);
935 }
936
937 if (pceltFetched != 0)
938 *pceltFetched = copied;
939
940 return (copied == celt) ? S_OK : E_FAIL;
941}
942
943static HRESULT STDMETHODCALLTYPE CliprdrEnumFORMATETC_Skip(IEnumFORMATETC* This, ULONG celt)
944{
945 CliprdrEnumFORMATETC* instance = (CliprdrEnumFORMATETC*)This;
946
947 if (!instance)
948 return E_INVALIDARG;
949
950 if (instance->m_nIndex + (LONG)celt > instance->m_nNumFormats)
951 return E_FAIL;
952
953 instance->m_nIndex += celt;
954 return S_OK;
955}
956
957static HRESULT STDMETHODCALLTYPE CliprdrEnumFORMATETC_Reset(IEnumFORMATETC* This)
958{
959 CliprdrEnumFORMATETC* instance = (CliprdrEnumFORMATETC*)This;
960
961 if (!instance)
962 return E_INVALIDARG;
963
964 instance->m_nIndex = 0;
965 return S_OK;
966}
967
968static HRESULT STDMETHODCALLTYPE CliprdrEnumFORMATETC_Clone(IEnumFORMATETC* This,
969 IEnumFORMATETC** ppEnum)
970{
971 CliprdrEnumFORMATETC* instance = (CliprdrEnumFORMATETC*)This;
972
973 if (!instance || !ppEnum)
974 return E_INVALIDARG;
975
976 *ppEnum =
977 (IEnumFORMATETC*)CliprdrEnumFORMATETC_New(instance->m_nNumFormats, instance->m_pFormatEtc);
978
979 if (!*ppEnum)
980 return E_OUTOFMEMORY;
981
982 ((CliprdrEnumFORMATETC*)*ppEnum)->m_nIndex = instance->m_nIndex;
983 return S_OK;
984}
985
986CliprdrEnumFORMATETC* CliprdrEnumFORMATETC_New(ULONG nFormats, FORMATETC* pFormatEtc)
987{
988 CliprdrEnumFORMATETC* instance;
989 IEnumFORMATETC* iEnumFORMATETC;
990
991 if ((nFormats != 0) && !pFormatEtc)
992 return nullptr;
993
994 instance = (CliprdrEnumFORMATETC*)calloc(1, sizeof(CliprdrEnumFORMATETC));
995
996 if (!instance)
997 goto error;
998
999 iEnumFORMATETC = &instance->iEnumFORMATETC;
1000 iEnumFORMATETC->lpVtbl = (IEnumFORMATETCVtbl*)calloc(1, sizeof(IEnumFORMATETCVtbl));
1001
1002 if (!iEnumFORMATETC->lpVtbl)
1003 goto error;
1004
1005 iEnumFORMATETC->lpVtbl->QueryInterface = CliprdrEnumFORMATETC_QueryInterface;
1006 iEnumFORMATETC->lpVtbl->AddRef = CliprdrEnumFORMATETC_AddRef;
1007 iEnumFORMATETC->lpVtbl->Release = CliprdrEnumFORMATETC_Release;
1008 iEnumFORMATETC->lpVtbl->Next = CliprdrEnumFORMATETC_Next;
1009 iEnumFORMATETC->lpVtbl->Skip = CliprdrEnumFORMATETC_Skip;
1010 iEnumFORMATETC->lpVtbl->Reset = CliprdrEnumFORMATETC_Reset;
1011 iEnumFORMATETC->lpVtbl->Clone = CliprdrEnumFORMATETC_Clone;
1012 instance->m_lRefCount = 1;
1013 instance->m_nIndex = 0;
1014 instance->m_nNumFormats = nFormats;
1015
1016 if (nFormats > 0)
1017 {
1018 instance->m_pFormatEtc = (FORMATETC*)calloc(nFormats, sizeof(FORMATETC));
1019
1020 if (!instance->m_pFormatEtc)
1021 goto error;
1022
1023 for (ULONG i = 0; i < nFormats; i++)
1024 cliprdr_format_deep_copy(&instance->m_pFormatEtc[i], &pFormatEtc[i]);
1025 }
1026
1027 return instance;
1028error:
1029 CliprdrEnumFORMATETC_Delete(instance);
1030 return nullptr;
1031}
1032
1033void CliprdrEnumFORMATETC_Delete(CliprdrEnumFORMATETC* instance)
1034{
1035 if (instance)
1036 {
1037 free(instance->iEnumFORMATETC.lpVtbl);
1038
1039 if (instance->m_pFormatEtc)
1040 {
1041 for (LONG i = 0; i < instance->m_nNumFormats; i++)
1042 {
1043 if (instance->m_pFormatEtc[i].ptd)
1044 CoTaskMemFree(instance->m_pFormatEtc[i].ptd);
1045 }
1046
1047 free(instance->m_pFormatEtc);
1048 }
1049
1050 free(instance);
1051 }
1052}
1053
1054/***********************************************************************************/
1055
1056static UINT32 get_local_format_id_by_name(wfClipboard* clipboard, const TCHAR* format_name)
1057{
1058 formatMapping* map;
1059 WCHAR* unicode_name;
1060#if !defined(UNICODE)
1061 size_t size;
1062#endif
1063
1064 if (!clipboard || !format_name)
1065 return 0;
1066
1067#if defined(UNICODE)
1068 unicode_name = _wcsdup(format_name);
1069#else
1070 size = _tcslen(format_name);
1071 unicode_name = calloc(size + 1, sizeof(WCHAR));
1072
1073 if (!unicode_name)
1074 return 0;
1075
1076 MultiByteToWideChar(CP_OEMCP, 0, format_name, strlen(format_name), unicode_name, size);
1077#endif
1078
1079 if (!unicode_name)
1080 return 0;
1081
1082 for (size_t i = 0; i < clipboard->map_size; i++)
1083 {
1084 map = &clipboard->format_mappings[i];
1085
1086 if (map->name)
1087 {
1088 if (wcscmp(map->name, unicode_name) == 0)
1089 {
1090 free(unicode_name);
1091 return map->local_format_id;
1092 }
1093 }
1094 }
1095
1096 free(unicode_name);
1097 return 0;
1098}
1099
1100static inline BOOL file_transferring(wfClipboard* clipboard)
1101{
1102 return get_local_format_id_by_name(clipboard, CFSTR_FILEDESCRIPTORW) ? TRUE : FALSE;
1103}
1104
1105static UINT32 get_remote_format_id(wfClipboard* clipboard, UINT32 local_format)
1106{
1107 formatMapping* map;
1108
1109 if (!clipboard)
1110 return 0;
1111
1112 for (UINT32 i = 0; i < clipboard->map_size; i++)
1113 {
1114 map = &clipboard->format_mappings[i];
1115
1116 if (map->local_format_id == local_format)
1117 return map->remote_format_id;
1118 }
1119
1120 return local_format;
1121}
1122
1123static void map_ensure_capacity(wfClipboard* clipboard)
1124{
1125 if (!clipboard)
1126 return;
1127
1128 if (clipboard->map_size >= clipboard->map_capacity)
1129 {
1130 size_t new_size = clipboard->map_capacity;
1131 do
1132 {
1133 WINPR_ASSERT(new_size <= SIZE_MAX - 128ull);
1134 new_size += 128ull;
1135 } while (new_size <= clipboard->map_size);
1136 formatMapping* new_map =
1137 (formatMapping*)realloc(clipboard->format_mappings, sizeof(formatMapping) * new_size);
1138
1139 if (!new_map)
1140 return;
1141
1142 clipboard->format_mappings = new_map;
1143 clipboard->map_capacity = new_size;
1144 }
1145}
1146
1147static BOOL clear_format_map(wfClipboard* clipboard)
1148{
1149 formatMapping* map;
1150
1151 if (!clipboard)
1152 return FALSE;
1153
1154 if (clipboard->format_mappings)
1155 {
1156 for (size_t i = 0; i < clipboard->map_capacity; i++)
1157 {
1158 map = &clipboard->format_mappings[i];
1159 map->remote_format_id = 0;
1160 map->local_format_id = 0;
1161 free(map->name);
1162 map->name = nullptr;
1163 }
1164 }
1165
1166 clipboard->map_size = 0;
1167 return TRUE;
1168}
1169
1170static UINT cliprdr_send_tempdir(wfClipboard* clipboard)
1171{
1172 CLIPRDR_TEMP_DIRECTORY tempDirectory;
1173
1174 if (!clipboard)
1175 return -1;
1176
1177 if (GetEnvironmentVariableA("TEMP", tempDirectory.szTempDir, sizeof(tempDirectory.szTempDir)) ==
1178 0)
1179 return -1;
1180
1181 return clipboard->context->TempDirectory(clipboard->context, &tempDirectory);
1182}
1183
1184static BOOL cliprdr_GetUpdatedClipboardFormats(wfClipboard* clipboard, PUINT lpuiFormats,
1185 UINT cFormats, PUINT pcFormatsOut)
1186{
1187 UINT index = 0;
1188 UINT format = 0;
1189 BOOL clipboardOpen = FALSE;
1190
1191 if (!clipboard->legacyApi)
1192 return clipboard->GetUpdatedClipboardFormats(lpuiFormats, cFormats, pcFormatsOut);
1193
1194 clipboardOpen = try_open_clipboard(clipboard->hwnd);
1195
1196 if (!clipboardOpen)
1197 {
1198 *pcFormatsOut = 0;
1199 return TRUE; /* Other app holding clipboard */
1200 }
1201
1202 while (index < cFormats)
1203 {
1204 format = EnumClipboardFormats(format);
1205
1206 if (!format)
1207 break;
1208
1209 lpuiFormats[index] = format;
1210 index++;
1211 }
1212
1213 *pcFormatsOut = index;
1214 CloseClipboard();
1215 return TRUE;
1216}
1217
1218static UINT cliprdr_send_format_list(wfClipboard* clipboard)
1219{
1220 UINT rc;
1221 int count = 0;
1222 UINT32 numFormats = 0;
1223 UINT32 formatId = 0;
1224 char formatName[1024];
1225 CLIPRDR_FORMAT* formats = nullptr;
1226 CLIPRDR_FORMAT_LIST formatList = WINPR_C_ARRAY_INIT;
1227
1228 if (!clipboard)
1229 return ERROR_INTERNAL_ERROR;
1230
1231 /* Ignore if other app is holding clipboard */
1232 if (try_open_clipboard(clipboard->hwnd))
1233 {
1234 count = CountClipboardFormats();
1235 numFormats = (UINT32)count;
1236 formats = (CLIPRDR_FORMAT*)calloc(numFormats, sizeof(CLIPRDR_FORMAT));
1237
1238 if (!formats)
1239 {
1240 CloseClipboard();
1241 return CHANNEL_RC_NO_MEMORY;
1242 }
1243
1244 {
1245 UINT32 index = 0;
1246
1247 if (IsClipboardFormatAvailable(CF_HDROP))
1248 {
1249 formats[index++].formatId = RegisterClipboardFormat(CFSTR_FILEDESCRIPTORW);
1250 formats[index++].formatId = RegisterClipboardFormat(CFSTR_FILECONTENTS);
1251 }
1252 else
1253 {
1254 while ((formatId = EnumClipboardFormats(formatId)) != 0)
1255 formats[index++].formatId = formatId;
1256 }
1257
1258 numFormats = index;
1259 }
1260
1261 if (!CloseClipboard())
1262 {
1263 free(formats);
1264 return ERROR_INTERNAL_ERROR;
1265 }
1266
1267 for (UINT index = 0; index < numFormats; index++)
1268 {
1269 if (GetClipboardFormatNameA(formats[index].formatId, formatName, sizeof(formatName)))
1270 {
1271 formats[index].formatName = _strdup(formatName);
1272 }
1273 }
1274 }
1275
1276 formatList.numFormats = numFormats;
1277 formatList.formats = formats;
1278 formatList.common.msgType = CB_FORMAT_LIST;
1279 rc = clipboard->context->ClientFormatList(clipboard->context, &formatList);
1280
1281 for (UINT index = 0; index < numFormats; index++)
1282 free(formats[index].formatName);
1283
1284 free(formats);
1285 return rc;
1286}
1287
1288static UINT cliprdr_send_data_request(wfClipboard* clipboard, UINT32 formatId)
1289{
1290 UINT rc;
1291 UINT32 remoteFormatId;
1292 CLIPRDR_FORMAT_DATA_REQUEST formatDataRequest;
1293
1294 if (!clipboard || !clipboard->context || !clipboard->context->ClientFormatDataRequest)
1295 return ERROR_INTERNAL_ERROR;
1296
1297 remoteFormatId = get_remote_format_id(clipboard, formatId);
1298
1299 formatDataRequest.requestedFormatId = remoteFormatId;
1300 clipboard->requestedFormatId = formatId;
1301 rc = clipboard->context->ClientFormatDataRequest(clipboard->context, &formatDataRequest);
1302
1303 if (WaitForSingleObject(clipboard->response_data_event, INFINITE) != WAIT_OBJECT_0)
1304 rc = ERROR_INTERNAL_ERROR;
1305 else if (!ResetEvent(clipboard->response_data_event))
1306 rc = ERROR_INTERNAL_ERROR;
1307
1308 return rc;
1309}
1310
1311UINT cliprdr_send_request_filecontents(wfClipboard* clipboard, const void* streamid, ULONG index,
1312 UINT32 flag, UINT64 position, ULONG nreq)
1313{
1314 UINT rc;
1315 CLIPRDR_FILE_CONTENTS_REQUEST fileContentsRequest;
1316
1317 if (!clipboard || !clipboard->context || !clipboard->context->ClientFileContentsRequest)
1318 return ERROR_INTERNAL_ERROR;
1319
1320 fileContentsRequest.streamId = (UINT32)(ULONG_PTR)streamid;
1321 fileContentsRequest.listIndex = index;
1322 fileContentsRequest.dwFlags = flag;
1323 fileContentsRequest.nPositionLow = position & 0xFFFFFFFF;
1324 fileContentsRequest.nPositionHigh = (position >> 32) & 0xFFFFFFFF;
1325 fileContentsRequest.cbRequested = nreq;
1326 fileContentsRequest.clipDataId = 0;
1327 fileContentsRequest.common.msgFlags = 0;
1328 rc = clipboard->context->ClientFileContentsRequest(clipboard->context, &fileContentsRequest);
1329
1330 if (WaitForSingleObject(clipboard->req_fevent, INFINITE) != WAIT_OBJECT_0)
1331 rc = ERROR_INTERNAL_ERROR;
1332 else if (!ResetEvent(clipboard->req_fevent))
1333 rc = ERROR_INTERNAL_ERROR;
1334
1335 if (nreq != clipboard->req_fsize)
1336 rc = ERROR_INVALID_DATA;
1337 return rc;
1338}
1339
1340static UINT cliprdr_send_response_filecontents(wfClipboard* clipboard, UINT32 streamId, UINT32 size,
1341 BYTE* data)
1342{
1343 CLIPRDR_FILE_CONTENTS_RESPONSE fileContentsResponse = WINPR_C_ARRAY_INIT;
1344
1345 if (!clipboard || !clipboard->context || !clipboard->context->ClientFileContentsResponse)
1346 return ERROR_INTERNAL_ERROR;
1347
1348 fileContentsResponse.streamId = streamId;
1349 fileContentsResponse.cbRequested = size;
1350 fileContentsResponse.requestedData = data;
1351 fileContentsResponse.common.msgFlags = CB_RESPONSE_OK;
1352 return clipboard->context->ClientFileContentsResponse(clipboard->context,
1353 &fileContentsResponse);
1354}
1355
1356static LRESULT CALLBACK cliprdr_proc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
1357{
1358 static wfClipboard* clipboard = nullptr;
1359
1360 switch (Msg)
1361 {
1362 case WM_CREATE:
1363 DEBUG_CLIPRDR("info: WM_CREATE");
1364 clipboard = (wfClipboard*)((CREATESTRUCT*)lParam)->lpCreateParams;
1365 clipboard->hwnd = hWnd;
1366
1367 if (!clipboard->legacyApi)
1368 clipboard->AddClipboardFormatListener(hWnd);
1369 else
1370 clipboard->hWndNextViewer = SetClipboardViewer(hWnd);
1371
1372 break;
1373
1374 case WM_CLOSE:
1375 DEBUG_CLIPRDR("info: WM_CLOSE");
1376
1377 if (!clipboard->legacyApi)
1378 clipboard->RemoveClipboardFormatListener(hWnd);
1379
1380 break;
1381
1382 case WM_DESTROY:
1383 if (clipboard->legacyApi)
1384 ChangeClipboardChain(hWnd, clipboard->hWndNextViewer);
1385
1386 break;
1387
1388 case WM_CLIPBOARDUPDATE:
1389 DEBUG_CLIPRDR("info: WM_CLIPBOARDUPDATE");
1390
1391 if (clipboard->sync)
1392 {
1393 if ((GetClipboardOwner() != clipboard->hwnd) &&
1394 (S_FALSE == OleIsCurrentClipboard(clipboard->data_obj)))
1395 {
1396 if (clipboard->hmem)
1397 {
1398 GlobalFree(clipboard->hmem);
1399 clipboard->hmem = nullptr;
1400 }
1401
1402 cliprdr_send_format_list(clipboard);
1403 }
1404 }
1405
1406 break;
1407
1408 case WM_RENDERALLFORMATS:
1409 DEBUG_CLIPRDR("info: WM_RENDERALLFORMATS");
1410
1411 /* discard all contexts in clipboard */
1412 if (!try_open_clipboard(clipboard->hwnd))
1413 {
1414 DEBUG_CLIPRDR("OpenClipboard failed with 0x%x", GetLastError());
1415 break;
1416 }
1417
1418 EmptyClipboard();
1419 CloseClipboard();
1420 break;
1421
1422 case WM_RENDERFORMAT:
1423 DEBUG_CLIPRDR("info: WM_RENDERFORMAT");
1424
1425 if (cliprdr_send_data_request(clipboard, (UINT32)wParam) != 0)
1426 {
1427 DEBUG_CLIPRDR("error: cliprdr_send_data_request failed.");
1428 break;
1429 }
1430
1431 if (!SetClipboardData((UINT)wParam, clipboard->hmem))
1432 {
1433 DEBUG_CLIPRDR("SetClipboardData failed with 0x%x", GetLastError());
1434
1435 if (clipboard->hmem)
1436 {
1437 GlobalFree(clipboard->hmem);
1438 clipboard->hmem = nullptr;
1439 }
1440 }
1441
1442 /* Note: GlobalFree() is not needed when success */
1443 break;
1444
1445 case WM_DRAWCLIPBOARD:
1446 if (clipboard->legacyApi)
1447 {
1448 if ((GetClipboardOwner() != clipboard->hwnd) &&
1449 (S_FALSE == OleIsCurrentClipboard(clipboard->data_obj)))
1450 {
1451 cliprdr_send_format_list(clipboard);
1452 }
1453
1454 SendMessage(clipboard->hWndNextViewer, Msg, wParam, lParam);
1455 }
1456
1457 break;
1458
1459 case WM_CHANGECBCHAIN:
1460 if (clipboard->legacyApi)
1461 {
1462 HWND hWndCurrViewer = (HWND)wParam;
1463 HWND hWndNextViewer = (HWND)lParam;
1464
1465 if (hWndCurrViewer == clipboard->hWndNextViewer)
1466 clipboard->hWndNextViewer = hWndNextViewer;
1467 else if (clipboard->hWndNextViewer)
1468 SendMessage(clipboard->hWndNextViewer, Msg, wParam, lParam);
1469 }
1470
1471 break;
1472
1473 case WM_CLIPRDR_MESSAGE:
1474 DEBUG_CLIPRDR("info: WM_CLIPRDR_MESSAGE");
1475
1476 switch (wParam)
1477 {
1478 case OLE_SETCLIPBOARD:
1479 DEBUG_CLIPRDR("info: OLE_SETCLIPBOARD");
1480
1481 if (wf_create_file_obj(clipboard, &clipboard->data_obj))
1482 {
1483 if (OleSetClipboard(clipboard->data_obj) != S_OK)
1484 {
1485 wf_destroy_file_obj(clipboard->data_obj);
1486 clipboard->data_obj = nullptr;
1487 }
1488 }
1489
1490 break;
1491
1492 default:
1493 break;
1494 }
1495
1496 break;
1497
1498 case WM_DESTROYCLIPBOARD:
1499 case WM_ASKCBFORMATNAME:
1500 case WM_HSCROLLCLIPBOARD:
1501 case WM_PAINTCLIPBOARD:
1502 case WM_SIZECLIPBOARD:
1503 case WM_VSCROLLCLIPBOARD:
1504 default:
1505 return DefWindowProc(hWnd, Msg, wParam, lParam);
1506 }
1507
1508 return 0;
1509}
1510
1511static int create_cliprdr_window(wfClipboard* clipboard)
1512{
1513 WNDCLASSEX wnd_cls = WINPR_C_ARRAY_INIT;
1514
1515 wnd_cls.cbSize = sizeof(WNDCLASSEX);
1516 wnd_cls.style = CS_OWNDC;
1517 wnd_cls.lpfnWndProc = cliprdr_proc;
1518 wnd_cls.cbClsExtra = 0;
1519 wnd_cls.cbWndExtra = 0;
1520 wnd_cls.hIcon = nullptr;
1521 wnd_cls.hCursor = nullptr;
1522 wnd_cls.hbrBackground = nullptr;
1523 wnd_cls.lpszMenuName = nullptr;
1524 wnd_cls.lpszClassName = _T("ClipboardHiddenMessageProcessor");
1525 wnd_cls.hInstance = GetModuleHandle(nullptr);
1526 wnd_cls.hIconSm = nullptr;
1527 RegisterClassEx(&wnd_cls);
1528 clipboard->hwnd =
1529 CreateWindowEx(WS_EX_LEFT, _T("ClipboardHiddenMessageProcessor"), _T("rdpclip"), 0, 0, 0, 0,
1530 0, HWND_MESSAGE, nullptr, GetModuleHandle(nullptr), clipboard);
1531
1532 if (!clipboard->hwnd)
1533 {
1534 DEBUG_CLIPRDR("error: CreateWindowEx failed with %x.", GetLastError());
1535 return -1;
1536 }
1537
1538 return 0;
1539}
1540
1541static DWORD WINAPI cliprdr_thread_func(LPVOID arg)
1542{
1543 int ret;
1544 MSG msg;
1545 BOOL mcode;
1546 wfClipboard* clipboard = (wfClipboard*)arg;
1547 OleInitialize(0);
1548
1549 if ((ret = create_cliprdr_window(clipboard)) != 0)
1550 {
1551 OleUninitialize();
1552 DEBUG_CLIPRDR("error: create clipboard window failed.");
1553 return 0;
1554 }
1555
1556 while ((mcode = GetMessage(&msg, 0, 0, 0)) != 0)
1557 {
1558 if (mcode == -1)
1559 {
1560 DEBUG_CLIPRDR("error: clipboard thread GetMessage failed.");
1561 break;
1562 }
1563 else
1564 {
1565 TranslateMessage(&msg);
1566 DispatchMessage(&msg);
1567 }
1568 }
1569
1570 OleUninitialize();
1571 return 0;
1572}
1573
1574static void clear_file_array(wfClipboard* clipboard)
1575{
1576 if (!clipboard)
1577 return;
1578
1579 /* clear file_names array */
1580 if (clipboard->file_names)
1581 {
1582 for (size_t i = 0; i < clipboard->nFiles; i++)
1583 {
1584 free(clipboard->file_names[i]);
1585 clipboard->file_names[i] = nullptr;
1586 }
1587
1588 free(clipboard->file_names);
1589 clipboard->file_names = nullptr;
1590 }
1591
1592 /* clear fileDescriptor array */
1593 if (clipboard->fileDescriptor)
1594 {
1595 for (size_t i = 0; i < clipboard->nFiles; i++)
1596 {
1597 free(clipboard->fileDescriptor[i]);
1598 clipboard->fileDescriptor[i] = nullptr;
1599 }
1600
1601 free(clipboard->fileDescriptor);
1602 clipboard->fileDescriptor = nullptr;
1603 }
1604
1605 clipboard->file_array_size = 0;
1606 clipboard->nFiles = 0;
1607}
1608
1609static BOOL wf_cliprdr_get_file_contents(WCHAR* file_name, BYTE* buffer, LONG positionLow,
1610 LONG positionHigh, DWORD nRequested, DWORD* puSize)
1611{
1612 BOOL res = FALSE;
1613 HANDLE hFile;
1614 DWORD nGet, rc;
1615
1616 if (!file_name || !buffer || !puSize)
1617 {
1618 WLog_ERR(TAG, "get file contents Invalid Arguments.");
1619 return FALSE;
1620 }
1621
1622 hFile = CreateFileW(file_name, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING,
1623 FILE_ATTRIBUTE_NORMAL | FILE_FLAG_BACKUP_SEMANTICS, nullptr);
1624
1625 if (hFile == INVALID_HANDLE_VALUE)
1626 return FALSE;
1627
1628 rc = SetFilePointer(hFile, positionLow, &positionHigh, FILE_BEGIN);
1629
1630 if (rc == INVALID_SET_FILE_POINTER)
1631 goto error;
1632
1633 if (!ReadFile(hFile, buffer, nRequested, &nGet, nullptr))
1634 {
1635 DEBUG_CLIPRDR("ReadFile failed with 0x%08lX.", GetLastError());
1636 goto error;
1637 }
1638
1639 res = TRUE;
1640error:
1641
1642 if (!CloseHandle(hFile))
1643 res = FALSE;
1644
1645 if (res)
1646 *puSize = nGet;
1647
1648 return res;
1649}
1650
1651/* path_name has a '\' at the end. e.g. c:\newfolder\, file_name is c:\newfolder\new.txt */
1652static FILEDESCRIPTORW* wf_cliprdr_get_file_descriptor(WCHAR* file_name, size_t pathLen)
1653{
1654 HANDLE hFile;
1655 FILEDESCRIPTORW* fd;
1656 fd = (FILEDESCRIPTORW*)calloc(1, sizeof(FILEDESCRIPTORW));
1657
1658 if (!fd)
1659 return nullptr;
1660
1661 hFile = CreateFileW(file_name, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING,
1662 FILE_ATTRIBUTE_NORMAL | FILE_FLAG_BACKUP_SEMANTICS, nullptr);
1663
1664 if (hFile == INVALID_HANDLE_VALUE)
1665 {
1666 free(fd);
1667 return nullptr;
1668 }
1669
1670 fd->dwFlags = FD_ATTRIBUTES | FD_FILESIZE | FD_WRITESTIME | FD_PROGRESSUI;
1671 fd->dwFileAttributes = GetFileAttributes(file_name);
1672
1673 if (!GetFileTime(hFile, nullptr, nullptr, &fd->ftLastWriteTime))
1674 {
1675 fd->dwFlags &= ~FD_WRITESTIME;
1676 }
1677
1678 fd->nFileSizeLow = GetFileSize(hFile, &fd->nFileSizeHigh);
1679 wcscpy_s(fd->cFileName, sizeof(fd->cFileName) / 2, file_name + pathLen);
1680 (void)CloseHandle(hFile);
1681 return fd;
1682}
1683
1684static BOOL wf_cliprdr_array_ensure_capacity(wfClipboard* clipboard)
1685{
1686 if (!clipboard)
1687 return FALSE;
1688
1689 if (clipboard->nFiles == clipboard->file_array_size)
1690 {
1691 size_t new_size;
1692 FILEDESCRIPTORW** new_fd;
1693 WCHAR** new_name;
1694 new_size = (clipboard->file_array_size + 1) * 2;
1695 new_fd = (FILEDESCRIPTORW**)realloc(clipboard->fileDescriptor,
1696 new_size * sizeof(FILEDESCRIPTORW*));
1697
1698 if (new_fd)
1699 clipboard->fileDescriptor = new_fd;
1700
1701 new_name = (WCHAR**)realloc(clipboard->file_names, new_size * sizeof(WCHAR*));
1702
1703 if (new_name)
1704 clipboard->file_names = new_name;
1705
1706 if (!new_fd || !new_name)
1707 return FALSE;
1708
1709 clipboard->file_array_size = new_size;
1710 }
1711
1712 return TRUE;
1713}
1714
1715static BOOL wf_cliprdr_add_to_file_arrays(wfClipboard* clipboard, WCHAR* full_file_name,
1716 size_t pathLen)
1717{
1718 if (!wf_cliprdr_array_ensure_capacity(clipboard))
1719 return FALSE;
1720
1721 /* add to name array */
1722 clipboard->file_names[clipboard->nFiles] = (LPWSTR)malloc(MAX_PATH * 2);
1723
1724 if (!clipboard->file_names[clipboard->nFiles])
1725 return FALSE;
1726
1727 wcscpy_s(clipboard->file_names[clipboard->nFiles], MAX_PATH, full_file_name);
1728 /* add to descriptor array */
1729 clipboard->fileDescriptor[clipboard->nFiles] =
1730 wf_cliprdr_get_file_descriptor(full_file_name, pathLen);
1731
1732 if (!clipboard->fileDescriptor[clipboard->nFiles])
1733 {
1734 free(clipboard->file_names[clipboard->nFiles]);
1735 return FALSE;
1736 }
1737
1738 clipboard->nFiles++;
1739 return TRUE;
1740}
1741
1742static BOOL wf_cliprdr_traverse_directory(wfClipboard* clipboard, WCHAR* Dir, size_t pathLen)
1743{
1744 HANDLE hFind;
1745 WCHAR DirSpec[MAX_PATH];
1746 WIN32_FIND_DATA FindFileData;
1747
1748 if (!clipboard || !Dir)
1749 return FALSE;
1750
1751 StringCchCopy(DirSpec, MAX_PATH, Dir);
1752 StringCchCat(DirSpec, MAX_PATH, TEXT("\\*"));
1753 hFind = FindFirstFile(DirSpec, &FindFileData);
1754
1755 if (hFind == INVALID_HANDLE_VALUE)
1756 {
1757 DEBUG_CLIPRDR("FindFirstFile failed with 0x%x.", GetLastError());
1758 return FALSE;
1759 }
1760
1761 while (FindNextFile(hFind, &FindFileData))
1762 {
1763 if ((((FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0) &&
1764 (wcscmp(FindFileData.cFileName, _T(".")) == 0)) ||
1765 (wcscmp(FindFileData.cFileName, _T("..")) == 0))
1766 {
1767 continue;
1768 }
1769
1770 if ((FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0)
1771 {
1772 WCHAR DirAdd[MAX_PATH];
1773 StringCchCopy(DirAdd, MAX_PATH, Dir);
1774 StringCchCat(DirAdd, MAX_PATH, _T("\\"));
1775 StringCchCat(DirAdd, MAX_PATH, FindFileData.cFileName);
1776
1777 if (!wf_cliprdr_add_to_file_arrays(clipboard, DirAdd, pathLen))
1778 return FALSE;
1779
1780 if (!wf_cliprdr_traverse_directory(clipboard, DirAdd, pathLen))
1781 return FALSE;
1782 }
1783 else
1784 {
1785 WCHAR fileName[MAX_PATH];
1786 StringCchCopy(fileName, MAX_PATH, Dir);
1787 StringCchCat(fileName, MAX_PATH, _T("\\"));
1788 StringCchCat(fileName, MAX_PATH, FindFileData.cFileName);
1789
1790 if (!wf_cliprdr_add_to_file_arrays(clipboard, fileName, pathLen))
1791 return FALSE;
1792 }
1793 }
1794
1795 FindClose(hFind);
1796 return TRUE;
1797}
1798
1799static UINT wf_cliprdr_send_client_capabilities(wfClipboard* clipboard)
1800{
1801 CLIPRDR_CAPABILITIES capabilities;
1802 CLIPRDR_GENERAL_CAPABILITY_SET generalCapabilitySet;
1803
1804 if (!clipboard || !clipboard->context || !clipboard->context->ClientCapabilities)
1805 return ERROR_INTERNAL_ERROR;
1806
1807 capabilities.cCapabilitiesSets = 1;
1808 capabilities.capabilitySets = (CLIPRDR_CAPABILITY_SET*)&(generalCapabilitySet);
1809 generalCapabilitySet.capabilitySetType = CB_CAPSTYPE_GENERAL;
1810 generalCapabilitySet.capabilitySetLength = 12;
1811 generalCapabilitySet.version = CB_CAPS_VERSION_2;
1812 generalCapabilitySet.generalFlags =
1813 CB_USE_LONG_FORMAT_NAMES | CB_STREAM_FILECLIP_ENABLED | CB_FILECLIP_NO_FILE_PATHS;
1814 return clipboard->context->ClientCapabilities(clipboard->context, &capabilities);
1815}
1816
1822static UINT wf_cliprdr_monitor_ready(CliprdrClientContext* context,
1823 const CLIPRDR_MONITOR_READY* monitorReady)
1824{
1825 UINT rc;
1826 wfClipboard* clipboard = (wfClipboard*)context->custom;
1827
1828 if (!context || !monitorReady)
1829 return ERROR_INTERNAL_ERROR;
1830
1831 clipboard->sync = TRUE;
1832 rc = wf_cliprdr_send_client_capabilities(clipboard);
1833
1834 if (rc != CHANNEL_RC_OK)
1835 return rc;
1836
1837 return cliprdr_send_format_list(clipboard);
1838}
1839
1845static UINT wf_cliprdr_server_capabilities(CliprdrClientContext* context,
1846 const CLIPRDR_CAPABILITIES* capabilities)
1847{
1848 CLIPRDR_CAPABILITY_SET* capabilitySet;
1849 wfClipboard* clipboard = (wfClipboard*)context->custom;
1850
1851 if (!context || !capabilities)
1852 return ERROR_INTERNAL_ERROR;
1853
1854 for (UINT32 index = 0; index < capabilities->cCapabilitiesSets; index++)
1855 {
1856 capabilitySet = &(capabilities->capabilitySets[index]);
1857
1858 if ((capabilitySet->capabilitySetType == CB_CAPSTYPE_GENERAL) &&
1859 (capabilitySet->capabilitySetLength >= CB_CAPSTYPE_GENERAL_LEN))
1860 {
1861 CLIPRDR_GENERAL_CAPABILITY_SET* generalCapabilitySet =
1862 (CLIPRDR_GENERAL_CAPABILITY_SET*)capabilitySet;
1863 clipboard->capabilities = generalCapabilitySet->generalFlags;
1864 break;
1865 }
1866 }
1867
1868 return CHANNEL_RC_OK;
1869}
1870
1876static UINT wf_cliprdr_server_format_list(CliprdrClientContext* context,
1877 const CLIPRDR_FORMAT_LIST* formatList)
1878{
1879 UINT rc = ERROR_INTERNAL_ERROR;
1880 formatMapping* mapping;
1881 CLIPRDR_FORMAT* format;
1882 wfClipboard* clipboard = (wfClipboard*)context->custom;
1883
1884 if (!clear_format_map(clipboard))
1885 return ERROR_INTERNAL_ERROR;
1886
1887 for (UINT32 i = 0; i < formatList->numFormats; i++)
1888 {
1889 format = &(formatList->formats[i]);
1890 mapping = &(clipboard->format_mappings[i]);
1891 mapping->remote_format_id = format->formatId;
1892
1893 if (format->formatName)
1894 {
1895 mapping->name = ConvertUtf8ToWCharAlloc(format->formatName, nullptr);
1896
1897 if (mapping->name)
1898 mapping->local_format_id = RegisterClipboardFormatW((LPWSTR)mapping->name);
1899 }
1900 else
1901 {
1902 mapping->name = nullptr;
1903 mapping->local_format_id = mapping->remote_format_id;
1904 }
1905
1906 clipboard->map_size++;
1907 map_ensure_capacity(clipboard);
1908 }
1909
1910 if (file_transferring(clipboard))
1911 {
1912 if (PostMessage(clipboard->hwnd, WM_CLIPRDR_MESSAGE, OLE_SETCLIPBOARD, 0))
1913 rc = CHANNEL_RC_OK;
1914 }
1915 else
1916 {
1917 if (!try_open_clipboard(clipboard->hwnd))
1918 return CHANNEL_RC_OK; /* Ignore, other app holding clipboard */
1919
1920 if (EmptyClipboard())
1921 {
1922 for (UINT32 i = 0; i < (UINT32)clipboard->map_size; i++)
1923 SetClipboardData(clipboard->format_mappings[i].local_format_id, nullptr);
1924
1925 rc = CHANNEL_RC_OK;
1926 }
1927
1928 if (!CloseClipboard() && GetLastError())
1929 return ERROR_INTERNAL_ERROR;
1930 }
1931
1932 return rc;
1933}
1934
1940static UINT
1941wf_cliprdr_server_format_list_response(CliprdrClientContext* context,
1942 const CLIPRDR_FORMAT_LIST_RESPONSE* formatListResponse)
1943{
1944 (void)context;
1945 (void)formatListResponse;
1946
1947 if (formatListResponse->common.msgFlags != CB_RESPONSE_OK)
1948 WLog_WARN(TAG, "format list update failed");
1949
1950 return CHANNEL_RC_OK;
1951}
1952
1958static UINT
1959wf_cliprdr_server_lock_clipboard_data(CliprdrClientContext* context,
1960 const CLIPRDR_LOCK_CLIPBOARD_DATA* lockClipboardData)
1961{
1962 (void)context;
1963 (void)lockClipboardData;
1964 return CHANNEL_RC_OK;
1965}
1966
1972static UINT
1973wf_cliprdr_server_unlock_clipboard_data(CliprdrClientContext* context,
1974 const CLIPRDR_UNLOCK_CLIPBOARD_DATA* unlockClipboardData)
1975{
1976 (void)context;
1977 (void)unlockClipboardData;
1978 return CHANNEL_RC_OK;
1979}
1980
1981static BOOL wf_cliprdr_process_filename(wfClipboard* clipboard, WCHAR* wFileName, size_t str_len)
1982{
1983 size_t pathLen;
1984 size_t offset = str_len;
1985
1986 if (!clipboard || !wFileName)
1987 return FALSE;
1988
1989 /* find the last '\' in full file name */
1990 while (offset > 0)
1991 {
1992 if (wFileName[offset] == L'\\')
1993 break;
1994 else
1995 offset--;
1996 }
1997
1998 pathLen = offset + 1;
1999
2000 if (!wf_cliprdr_add_to_file_arrays(clipboard, wFileName, pathLen))
2001 return FALSE;
2002
2003 if ((clipboard->fileDescriptor[clipboard->nFiles - 1]->dwFileAttributes &
2004 FILE_ATTRIBUTE_DIRECTORY) != 0)
2005 {
2006 /* this is a directory */
2007 if (!wf_cliprdr_traverse_directory(clipboard, wFileName, pathLen))
2008 return FALSE;
2009 }
2010
2011 return TRUE;
2012}
2013
2014static SSIZE_T wf_cliprdr_tryopen(wfClipboard* clipboard, UINT32 requestedFormatId, BYTE** pData)
2015{
2016 SSIZE_T rc = -1;
2017 WINPR_ASSERT(clipboard);
2018 WINPR_ASSERT(pData);
2019
2020 *pData = nullptr;
2021
2022 /* Ignore if other app is holding the clipboard */
2023 if (!try_open_clipboard(clipboard->hwnd))
2024 return 0;
2025
2026 HANDLE hClipdata = GetClipboardData(requestedFormatId);
2027
2028 if (!hClipdata)
2029 goto fail;
2030
2031 char* globlemem = (char*)GlobalLock(hClipdata);
2032 const SSIZE_T size = GlobalSize(hClipdata);
2033 if (size <= 0)
2034 goto unlock;
2035
2036 BYTE* buff = malloc(size);
2037 if (buff == nullptr)
2038 goto fail;
2039 CopyMemory(buff, globlemem, size);
2040 *pData = buff;
2041 rc = size;
2042
2043unlock:
2044 GlobalUnlock(hClipdata);
2045
2046fail:
2047 CloseClipboard();
2048
2049 return rc;
2050}
2051
2052static SSIZE_T wf_cliprdr_get_filedescriptor(wfClipboard* clipboard, BYTE** pData)
2053{
2054 WINPR_ASSERT(clipboard);
2055 WINPR_ASSERT(pData);
2056
2057 SSIZE_T rc = -1;
2058 LPDATAOBJECT dataObj = nullptr;
2059 FORMATETC format_etc = WINPR_C_ARRAY_INIT;
2060 STGMEDIUM stg_medium = WINPR_C_ARRAY_INIT;
2061
2062 *pData = nullptr;
2063
2064 HRESULT result = OleGetClipboard(&dataObj);
2065 if (FAILED(result))
2066 return -1;
2067
2068 /* get DROPFILES struct from OLE */
2069 format_etc.cfFormat = CF_HDROP;
2070 format_etc.tymed = TYMED_HGLOBAL;
2071 format_etc.dwAspect = 1;
2072 format_etc.lindex = -1;
2073 result = IDataObject_GetData(dataObj, &format_etc, &stg_medium);
2074
2075 if (FAILED(result))
2076 {
2077 DEBUG_CLIPRDR("dataObj->GetData failed.");
2078 goto exit;
2079 }
2080
2081 HGLOBAL hdl = stg_medium.u.hGlobal;
2082 DROPFILES* dropFiles = (DROPFILES*)GlobalLock(hdl);
2083
2084 if (!dropFiles)
2085 {
2086 ReleaseStgMedium(&stg_medium);
2087 clipboard->nFiles = 0;
2088 goto exit;
2089 }
2090
2091 clear_file_array(clipboard);
2092
2093 if (dropFiles->fWide)
2094 {
2095 /* dropFiles contains file names */
2096 size_t len = 0;
2097 for (WCHAR* wFileName = (WCHAR*)((char*)dropFiles + dropFiles->pFiles);
2098 (len = wcslen(wFileName)) > 0; wFileName += len + 1)
2099 {
2100 wf_cliprdr_process_filename(clipboard, wFileName, wcslen(wFileName));
2101 }
2102 }
2103 else
2104 {
2105 size_t len = 0;
2106 for (char* p = (char*)((char*)dropFiles + dropFiles->pFiles); (len = strlen(p)) > 0;
2107 p += len + 1, clipboard->nFiles++)
2108 {
2109 const int ilen = WINPR_ASSERTING_INT_CAST(int, len);
2110 const int cchWideChar = MultiByteToWideChar(CP_ACP, MB_COMPOSITE, p, ilen, nullptr, 0);
2111 WCHAR* wFileName = (LPWSTR)calloc(cchWideChar, sizeof(WCHAR));
2112 MultiByteToWideChar(CP_ACP, MB_COMPOSITE, p, ilen, wFileName, cchWideChar);
2113 wf_cliprdr_process_filename(clipboard, wFileName, cchWideChar);
2114 free(wFileName);
2115 }
2116 }
2117
2118 GlobalUnlock(hdl);
2119 ReleaseStgMedium(&stg_medium);
2120exit:
2121{
2122 const size_t size = 4ull + clipboard->nFiles * sizeof(FILEDESCRIPTORW);
2123 FILEGROUPDESCRIPTORW* groupDsc = (FILEGROUPDESCRIPTORW*)calloc(size, 1);
2124
2125 if (groupDsc)
2126 {
2127 groupDsc->cItems = WINPR_ASSERTING_INT_CAST(UINT, clipboard->nFiles);
2128
2129 for (size_t i = 0; i < clipboard->nFiles; i++)
2130 {
2131 if (clipboard->fileDescriptor[i])
2132 groupDsc->fgd[i] = *clipboard->fileDescriptor[i];
2133 }
2134
2135 *pData = (BYTE*)groupDsc;
2136 rc = size;
2137 }
2138}
2139
2140 IDataObject_Release(dataObj);
2141 return rc;
2142}
2143
2149static UINT
2150wf_cliprdr_server_format_data_request(CliprdrClientContext* context,
2151 const CLIPRDR_FORMAT_DATA_REQUEST* formatDataRequest)
2152{
2153 if (!context || !formatDataRequest)
2154 return ERROR_INTERNAL_ERROR;
2155
2156 wfClipboard* clipboard = (wfClipboard*)context->custom;
2157
2158 if (!clipboard)
2159 return ERROR_INTERNAL_ERROR;
2160
2161 const UINT32 requestedFormatId = formatDataRequest->requestedFormatId;
2162 BYTE* requestedFormatData = nullptr;
2163 SSIZE_T res = 0;
2164 if (requestedFormatId == RegisterClipboardFormat(CFSTR_FILEDESCRIPTORW))
2165 {
2166 res = wf_cliprdr_get_filedescriptor(clipboard, &requestedFormatData);
2167 }
2168 else
2169 {
2170 res = wf_cliprdr_tryopen(clipboard, requestedFormatId, &requestedFormatData);
2171 }
2172
2173 UINT rc = ERROR_INTERNAL_ERROR;
2174 if (res >= 0)
2175 {
2176 const CLIPRDR_FORMAT_DATA_RESPONSE response = {
2177 .common = { .msgType = CB_FORMAT_DATA_RESPONSE,
2178 .msgFlags = CB_RESPONSE_OK,
2179 .dataLen = (uint32_t)res },
2180 .requestedFormatData = requestedFormatData
2181 };
2182
2183 rc = clipboard->context->ClientFormatDataResponse(clipboard->context, &response);
2184 }
2185 else
2186 {
2187 const CLIPRDR_FORMAT_DATA_RESPONSE response = { .common = { .msgType =
2188 CB_FORMAT_DATA_RESPONSE,
2189 .msgFlags = CB_RESPONSE_FAIL,
2190 .dataLen = 0 },
2191 .requestedFormatData = nullptr };
2192
2193 rc = clipboard->context->ClientFormatDataResponse(clipboard->context, &response);
2194 }
2195
2196 free(requestedFormatData);
2197 return rc;
2198}
2199
2205static UINT
2206wf_cliprdr_server_format_data_response(CliprdrClientContext* context,
2207 const CLIPRDR_FORMAT_DATA_RESPONSE* formatDataResponse)
2208{
2209 BYTE* data;
2210 HANDLE hMem;
2211 wfClipboard* clipboard;
2212
2213 if (!context || !formatDataResponse)
2214 return ERROR_INTERNAL_ERROR;
2215
2216 clipboard = (wfClipboard*)context->custom;
2217
2218 if (!clipboard)
2219 return ERROR_INTERNAL_ERROR;
2220
2221 if (formatDataResponse->common.msgFlags != CB_RESPONSE_OK)
2222 {
2223 clipboard->hmem = nullptr;
2224
2225 if (!SetEvent(clipboard->response_data_event))
2226 return ERROR_INTERNAL_ERROR;
2227
2228 return CHANNEL_RC_OK;
2229 }
2230
2231 hMem = GlobalAlloc(GMEM_MOVEABLE, formatDataResponse->common.dataLen);
2232
2233 if (!hMem)
2234 return ERROR_INTERNAL_ERROR;
2235
2236 data = (BYTE*)GlobalLock(hMem);
2237
2238 if (!data)
2239 {
2240 GlobalFree(hMem);
2241 return ERROR_INTERNAL_ERROR;
2242 }
2243
2244 CopyMemory(data, formatDataResponse->requestedFormatData, formatDataResponse->common.dataLen);
2245
2246 if (!GlobalUnlock(hMem) && GetLastError())
2247 {
2248 GlobalFree(hMem);
2249 return ERROR_INTERNAL_ERROR;
2250 }
2251
2252 clipboard->hmem = hMem;
2253
2254 if (!SetEvent(clipboard->response_data_event))
2255 return ERROR_INTERNAL_ERROR;
2256
2257 return CHANNEL_RC_OK;
2258}
2259
2265static UINT
2266wf_cliprdr_server_file_contents_request(CliprdrClientContext* context,
2267 const CLIPRDR_FILE_CONTENTS_REQUEST* fileContentsRequest)
2268{
2269 DWORD uSize = 0;
2270 BYTE* pData = nullptr;
2271 HRESULT hRet = S_OK;
2272 FORMATETC vFormatEtc = WINPR_C_ARRAY_INIT;
2273 LPDATAOBJECT pDataObj = nullptr;
2274 STGMEDIUM vStgMedium = WINPR_C_ARRAY_INIT;
2275 BOOL bIsStreamFile = TRUE;
2276 static LPSTREAM pStreamStc = nullptr;
2277 static UINT32 uStreamIdStc = 0;
2278 wfClipboard* clipboard;
2279 UINT rc = ERROR_INTERNAL_ERROR;
2280 UINT sRc;
2281 UINT32 cbRequested;
2282
2283 if (!context || !fileContentsRequest)
2284 return ERROR_INTERNAL_ERROR;
2285
2286 clipboard = (wfClipboard*)context->custom;
2287
2288 if (!clipboard)
2289 return ERROR_INTERNAL_ERROR;
2290
2291 cbRequested = fileContentsRequest->cbRequested;
2292 if (fileContentsRequest->dwFlags == FILECONTENTS_SIZE)
2293 cbRequested = sizeof(UINT64);
2294
2295 pData = (BYTE*)calloc(1, cbRequested);
2296
2297 if (!pData)
2298 goto error;
2299
2300 hRet = OleGetClipboard(&pDataObj);
2301
2302 if (FAILED(hRet))
2303 {
2304 WLog_ERR(TAG, "filecontents: get ole clipboard failed.");
2305 goto error;
2306 }
2307
2308 vFormatEtc.cfFormat = RegisterClipboardFormat(CFSTR_FILECONTENTS);
2309 vFormatEtc.tymed = TYMED_ISTREAM;
2310 vFormatEtc.dwAspect = 1;
2311 vFormatEtc.lindex = fileContentsRequest->listIndex;
2312 vFormatEtc.ptd = nullptr;
2313
2314 if ((uStreamIdStc != fileContentsRequest->streamId) || !pStreamStc)
2315 {
2316 LPENUMFORMATETC pEnumFormatEtc;
2317 ULONG CeltFetched;
2318 FORMATETC vFormatEtc2;
2319
2320 if (pStreamStc)
2321 {
2322 IStream_Release(pStreamStc);
2323 pStreamStc = nullptr;
2324 }
2325
2326 bIsStreamFile = FALSE;
2327 hRet = IDataObject_EnumFormatEtc(pDataObj, DATADIR_GET, &pEnumFormatEtc);
2328
2329 if (hRet == S_OK)
2330 {
2331 do
2332 {
2333 hRet = IEnumFORMATETC_Next(pEnumFormatEtc, 1, &vFormatEtc2, &CeltFetched);
2334
2335 if (hRet == S_OK)
2336 {
2337 if (vFormatEtc2.cfFormat == RegisterClipboardFormat(CFSTR_FILECONTENTS))
2338 {
2339 hRet = IDataObject_GetData(pDataObj, &vFormatEtc, &vStgMedium);
2340
2341 if (hRet == S_OK)
2342 {
2343 pStreamStc = vStgMedium.u.pstm;
2344 uStreamIdStc = fileContentsRequest->streamId;
2345 bIsStreamFile = TRUE;
2346 }
2347
2348 break;
2349 }
2350 }
2351 } while (hRet == S_OK);
2352 }
2353 }
2354
2355 if (bIsStreamFile == TRUE)
2356 {
2357 if (fileContentsRequest->dwFlags == FILECONTENTS_SIZE)
2358 {
2359 STATSTG vStatStg = WINPR_C_ARRAY_INIT;
2360 hRet = IStream_Stat(pStreamStc, &vStatStg, STATFLAG_NONAME);
2361
2362 if (hRet == S_OK)
2363 {
2364 *((UINT32*)&pData[0]) = vStatStg.cbSize.QuadPart & 0xFFFFFFFF;
2365 *((UINT32*)&pData[4]) = (vStatStg.cbSize.QuadPart >> 32) & 0xFFFFFFFF;
2366 uSize = cbRequested;
2367 }
2368 }
2369 else if (fileContentsRequest->dwFlags == FILECONTENTS_RANGE)
2370 {
2371 LARGE_INTEGER dlibMove;
2372 ULARGE_INTEGER dlibNewPosition;
2373 dlibMove.QuadPart = (INT64)(((UINT64)fileContentsRequest->nPositionHigh << 32) |
2374 fileContentsRequest->nPositionLow);
2375 hRet = IStream_Seek(pStreamStc, dlibMove, STREAM_SEEK_SET, &dlibNewPosition);
2376
2377 if (SUCCEEDED(hRet))
2378 hRet = IStream_Read(pStreamStc, pData, cbRequested, (PULONG)&uSize);
2379 }
2380 }
2381 else
2382 {
2383 if (fileContentsRequest->dwFlags == FILECONTENTS_SIZE)
2384 {
2385 if (clipboard->nFiles <= fileContentsRequest->listIndex)
2386 goto error;
2387 *((UINT32*)&pData[0]) =
2388 clipboard->fileDescriptor[fileContentsRequest->listIndex]->nFileSizeLow;
2389 *((UINT32*)&pData[4]) =
2390 clipboard->fileDescriptor[fileContentsRequest->listIndex]->nFileSizeHigh;
2391 uSize = cbRequested;
2392 }
2393 else if (fileContentsRequest->dwFlags == FILECONTENTS_RANGE)
2394 {
2395 BOOL bRet;
2396 if (clipboard->nFiles <= fileContentsRequest->listIndex)
2397 goto error;
2398 bRet = wf_cliprdr_get_file_contents(
2399 clipboard->file_names[fileContentsRequest->listIndex], pData,
2400 fileContentsRequest->nPositionLow, fileContentsRequest->nPositionHigh, cbRequested,
2401 &uSize);
2402
2403 if (bRet == FALSE)
2404 {
2405 WLog_ERR(TAG, "get file contents failed.");
2406 uSize = 0;
2407 goto error;
2408 }
2409 }
2410 }
2411
2412 rc = CHANNEL_RC_OK;
2413error:
2414
2415 if (pDataObj)
2416 IDataObject_Release(pDataObj);
2417
2418 if (uSize == 0)
2419 {
2420 free(pData);
2421 pData = nullptr;
2422 }
2423
2424 sRc =
2425 cliprdr_send_response_filecontents(clipboard, fileContentsRequest->streamId, uSize, pData);
2426 free(pData);
2427
2428 if (sRc != CHANNEL_RC_OK)
2429 return sRc;
2430
2431 return rc;
2432}
2433
2439static UINT
2440wf_cliprdr_server_file_contents_response(CliprdrClientContext* context,
2441 const CLIPRDR_FILE_CONTENTS_RESPONSE* fileContentsResponse)
2442{
2443 if (!context || !fileContentsResponse)
2444 return ERROR_INTERNAL_ERROR;
2445
2446 if (fileContentsResponse->common.msgFlags != CB_RESPONSE_OK)
2447 return E_FAIL;
2448
2449 wfClipboard* clipboard = (wfClipboard*)context->custom;
2450
2451 if (!clipboard)
2452 return ERROR_INTERNAL_ERROR;
2453
2454 clipboard->req_fsize = fileContentsResponse->cbRequested;
2455 clipboard->req_fdata = (char*)malloc(fileContentsResponse->cbRequested);
2456
2457 if (!clipboard->req_fdata)
2458 return ERROR_INTERNAL_ERROR;
2459
2460 CopyMemory(clipboard->req_fdata, fileContentsResponse->requestedData,
2461 fileContentsResponse->cbRequested);
2462
2463 if (!SetEvent(clipboard->req_fevent))
2464 {
2465 free(clipboard->req_fdata);
2466 return ERROR_INTERNAL_ERROR;
2467 }
2468
2469 return CHANNEL_RC_OK;
2470}
2471
2472BOOL wf_cliprdr_init(wfContext* wfc, CliprdrClientContext* cliprdr)
2473{
2474 wfClipboard* clipboard;
2475 rdpContext* context = (rdpContext*)wfc;
2476
2477 if (!context || !cliprdr)
2478 return FALSE;
2479
2480 wfc->clipboard = (wfClipboard*)calloc(1, sizeof(wfClipboard));
2481
2482 if (!wfc->clipboard)
2483 return FALSE;
2484
2485 clipboard = wfc->clipboard;
2486 clipboard->wfc = wfc;
2487 clipboard->context = cliprdr;
2488 clipboard->channels = context->channels;
2489 clipboard->sync = FALSE;
2490 clipboard->map_capacity = 32;
2491 clipboard->map_size = 0;
2492 clipboard->hUser32 = LoadLibraryA("user32.dll");
2493
2494 if (clipboard->hUser32)
2495 {
2496 clipboard->AddClipboardFormatListener = GetProcAddressAs(
2497 clipboard->hUser32, "AddClipboardFormatListener", fnAddClipboardFormatListener);
2498 clipboard->RemoveClipboardFormatListener = GetProcAddressAs(
2499 clipboard->hUser32, "RemoveClipboardFormatListener", fnRemoveClipboardFormatListener);
2500 clipboard->GetUpdatedClipboardFormats = GetProcAddressAs(
2501 clipboard->hUser32, "GetUpdatedClipboardFormats", fnGetUpdatedClipboardFormats);
2502 }
2503
2504 if (!(clipboard->hUser32 && clipboard->AddClipboardFormatListener &&
2505 clipboard->RemoveClipboardFormatListener && clipboard->GetUpdatedClipboardFormats))
2506 clipboard->legacyApi = TRUE;
2507
2508 if (!(clipboard->format_mappings =
2509 (formatMapping*)calloc(clipboard->map_capacity, sizeof(formatMapping))))
2510 goto error;
2511
2512 if (!(clipboard->response_data_event = CreateEvent(nullptr, TRUE, FALSE, nullptr)))
2513 goto error;
2514
2515 if (!(clipboard->req_fevent = CreateEvent(nullptr, TRUE, FALSE, nullptr)))
2516 goto error;
2517
2518 if (!(clipboard->thread = CreateThread(nullptr, 0, cliprdr_thread_func, clipboard, 0, nullptr)))
2519 goto error;
2520
2521 cliprdr->MonitorReady = wf_cliprdr_monitor_ready;
2522 cliprdr->ServerCapabilities = wf_cliprdr_server_capabilities;
2523 cliprdr->ServerFormatList = wf_cliprdr_server_format_list;
2524 cliprdr->ServerFormatListResponse = wf_cliprdr_server_format_list_response;
2525 cliprdr->ServerLockClipboardData = wf_cliprdr_server_lock_clipboard_data;
2526 cliprdr->ServerUnlockClipboardData = wf_cliprdr_server_unlock_clipboard_data;
2527 cliprdr->ServerFormatDataRequest = wf_cliprdr_server_format_data_request;
2528 cliprdr->ServerFormatDataResponse = wf_cliprdr_server_format_data_response;
2529 cliprdr->ServerFileContentsRequest = wf_cliprdr_server_file_contents_request;
2530 cliprdr->ServerFileContentsResponse = wf_cliprdr_server_file_contents_response;
2531 cliprdr->custom = (void*)wfc->clipboard;
2532 return TRUE;
2533error:
2534 wf_cliprdr_uninit(wfc, cliprdr);
2535 return FALSE;
2536}
2537
2538BOOL wf_cliprdr_uninit(wfContext* wfc, CliprdrClientContext* cliprdr)
2539{
2540 wfClipboard* clipboard;
2541
2542 if (!wfc || !cliprdr)
2543 return FALSE;
2544
2545 clipboard = wfc->clipboard;
2546
2547 if (!clipboard)
2548 return FALSE;
2549
2550 cliprdr->custom = nullptr;
2551
2552 if (clipboard->hwnd)
2553 PostMessage(clipboard->hwnd, WM_QUIT, 0, 0);
2554
2555 if (clipboard->thread)
2556 {
2557 (void)WaitForSingleObject(clipboard->thread, INFINITE);
2558 (void)CloseHandle(clipboard->thread);
2559 }
2560
2561 if (clipboard->response_data_event)
2562 (void)CloseHandle(clipboard->response_data_event);
2563
2564 if (clipboard->req_fevent)
2565 (void)CloseHandle(clipboard->req_fevent);
2566
2567 clear_file_array(clipboard);
2568 clear_format_map(clipboard);
2569 free(clipboard->format_mappings);
2570 free(clipboard);
2571 return TRUE;
2572}
CLIPRDR_CAPABILITIES
Definition channels/cliprdr.h:120
CLIPRDR_CAPABILITY_SET
Definition channels/cliprdr.h:105
CLIPRDR_FILE_CONTENTS_REQUEST
Definition channels/cliprdr.h:187
CLIPRDR_FILE_CONTENTS_RESPONSE
Definition channels/cliprdr.h:201
CLIPRDR_FORMAT_DATA_REQUEST
Definition channels/cliprdr.h:173
CLIPRDR_FORMAT_DATA_RESPONSE
Definition channels/cliprdr.h:180
CLIPRDR_FORMAT_LIST_RESPONSE
Definition channels/cliprdr.h:154
CLIPRDR_FORMAT_LIST
Definition channels/cliprdr.h:146
CLIPRDR_FORMAT
Definition channels/cliprdr.h:140
CLIPRDR_GENERAL_CAPABILITY_SET
Definition channels/cliprdr.h:111
CLIPRDR_LOCK_CLIPBOARD_DATA
Definition channels/cliprdr.h:159
CLIPRDR_MONITOR_READY
Definition channels/cliprdr.h:128
CLIPRDR_TEMP_DIRECTORY
Definition channels/cliprdr.h:133
CLIPRDR_UNLOCK_CLIPBOARD_DATA
Definition channels/cliprdr.h:166
LARGE_INTEGER
Definition wtypes.h:318
ULARGE_INTEGER
Definition wtypes.h:301