ClipboardDataObjectImpl-win.cpp@ 98461

Last change on this file since 98461 was 98103, checked in by vboxsync, 2 years ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 31.5 KB

Line
1	/* $Id: ClipboardDataObjectImpl-win.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* ClipboardDataObjectImpl-win.cpp - Shared Clipboard IDataObject implementation.
4	*/
5
6	/*
7	* Copyright (C) 2019-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#define LOG_GROUP LOG_GROUP_SHARED_CLIPBOARD
33	#include <VBox/GuestHost/SharedClipboard-win.h>
34	#include <VBox/GuestHost/SharedClipboard-transfers.h>
35
36	#include <iprt/win/windows.h>
37	#include <iprt/win/shlobj.h>
38	#include <iprt/win/shlwapi.h>
39
40	#include <iprt/asm.h>
41	#include <iprt/err.h>
42	#include <iprt/path.h>
43	#include <iprt/semaphore.h>
44	#include <iprt/uri.h>
45	#include <iprt/utf16.h>
46
47	#include <iprt/errcore.h>
48	#include <VBox/log.h>
49
50	/** @todo Also handle Unicode entries.
51	* !!! WARNING: Buggy, doesn't work yet (some memory corruption / garbage in the file name descriptions) !!! */
52	//#define VBOX_CLIPBOARD_WITH_UNICODE_SUPPORT 1
53
54	SharedClipboardWinDataObject::SharedClipboardWinDataObject(PSHCLTRANSFER pTransfer,
55	LPFORMATETC pFormatEtc, LPSTGMEDIUM pStgMed, ULONG cFormats)
56	: m_enmStatus(Uninitialized)
57	, m_lRefCount(0)
58	, m_cFormats(0)
59	, m_pTransfer(pTransfer)
60	, m_pStream(NULL)
61	, m_uObjIdx(0)
62	, m_fRunning(false)
63	, m_EventListComplete(NIL_RTSEMEVENT)
64	, m_EventTransferComplete(NIL_RTSEMEVENT)
65	{
66	AssertPtr(m_pTransfer);
67
68	HRESULT hr;
69
70	ULONG cFixedFormats = 3; /* CFSTR_FILEDESCRIPTORA + CFSTR_FILECONTENTS + CFSTR_PERFORMEDDROPEFFECT */
71	#ifdef VBOX_CLIPBOARD_WITH_UNICODE_SUPPORT
72	cFixedFormats++; /* CFSTR_FILEDESCRIPTORW */
73	#endif
74	const ULONG cAllFormats = cFormats + cFixedFormats;
75
76	try
77	{
78	m_pFormatEtc = new FORMATETC[cAllFormats];
79	RT_BZERO(m_pFormatEtc, sizeof(FORMATETC) * cAllFormats);
80	m_pStgMedium = new STGMEDIUM[cAllFormats];
81	RT_BZERO(m_pStgMedium, sizeof(STGMEDIUM) * cAllFormats);
82
83	/** @todo Do we need CFSTR_FILENAME / CFSTR_SHELLIDLIST here? */
84
85	/*
86	* Register fixed formats.
87	*/
88	unsigned uIdx = 0;
89
90	LogFlowFunc(("Registering CFSTR_FILEDESCRIPTORA ...\n"));
91	m_cfFileDescriptorA = RegisterClipboardFormat(CFSTR_FILEDESCRIPTORA);
92	registerFormat(&m_pFormatEtc[uIdx++], m_cfFileDescriptorA);
93	#ifdef VBOX_CLIPBOARD_WITH_UNICODE_SUPPORT
94	LogFlowFunc(("Registering CFSTR_FILEDESCRIPTORW ...\n"));
95	m_cfFileDescriptorW = RegisterClipboardFormat(CFSTR_FILEDESCRIPTORW);
96	registerFormat(&m_pFormatEtc[uIdx++], m_cfFileDescriptorW);
97	#endif
98
99	/* IStream interface, implemented in ClipboardStreamImpl-win.cpp. */
100	LogFlowFunc(("Registering CFSTR_FILECONTENTS ...\n"));
101	m_cfFileContents = RegisterClipboardFormat(CFSTR_FILECONTENTS);
102	registerFormat(&m_pFormatEtc[uIdx++], m_cfFileContents, TYMED_ISTREAM, 0 /* lIndex */);
103
104	/* We want to know from the target what the outcome of the operation was to react accordingly (e.g. abort a transfer). */
105	LogFlowFunc(("Registering CFSTR_PERFORMEDDROPEFFECT ...\n"));
106	m_cfPerformedDropEffect = RegisterClipboardFormat(CFSTR_PERFORMEDDROPEFFECT);
107	registerFormat(&m_pFormatEtc[uIdx++], m_cfPerformedDropEffect, TYMED_HGLOBAL, -1 /* lIndex */, DVASPECT_CONTENT);
108
109	/*
110	* Registration of dynamic formats needed?
111	*/
112	LogFlowFunc(("%RU32 dynamic formats\n", cFormats));
113	if (cFormats)
114	{
115	AssertPtr(pFormatEtc);
116	AssertPtr(pStgMed);
117
118	for (ULONG i = 0; i < cFormats; i++)
119	{
120	LogFlowFunc(("Format %RU32: cfFormat=%RI16, tyMed=%RU32, dwAspect=%RU32\n",
121	i, pFormatEtc[i].cfFormat, pFormatEtc[i].tymed, pFormatEtc[i].dwAspect));
122	m_pFormatEtc[cFixedFormats + i] = pFormatEtc[i];
123	m_pStgMedium[cFixedFormats + i] = pStgMed[i];
124	}
125	}
126
127	hr = S_OK;
128	}
129	catch (std::bad_alloc &)
130	{
131	hr = E_OUTOFMEMORY;
132	}
133
134	if (SUCCEEDED(hr))
135	{
136	m_cFormats = cAllFormats;
137	m_enmStatus = Initialized;
138
139	int rc2 = RTSemEventCreate(&m_EventListComplete);
140	AssertRC(rc2);
141	rc2 = RTSemEventCreate(&m_EventTransferComplete);
142	AssertRC(rc2);
143	}
144
145	LogFlowFunc(("cAllFormats=%RU32, hr=%Rhrc\n", cAllFormats, hr));
146	}
147
148	SharedClipboardWinDataObject::~SharedClipboardWinDataObject(void)
149	{
150	LogFlowFuncEnter();
151
152	RTSemEventDestroy(m_EventListComplete);
153	m_EventListComplete = NIL_RTSEMEVENT;
154
155	RTSemEventDestroy(m_EventTransferComplete);
156	m_EventTransferComplete = NIL_RTSEMEVENT;
157
158	if (m_pStream)
159	m_pStream->Release();
160
161	if (m_pFormatEtc)
162	delete[] m_pFormatEtc;
163
164	if (m_pStgMedium)
165	delete[] m_pStgMedium;
166
167	LogFlowFunc(("mRefCount=%RI32\n", m_lRefCount));
168	}
169
170	/*
171	* IUnknown methods.
172	*/
173
174	STDMETHODIMP_(ULONG) SharedClipboardWinDataObject::AddRef(void)
175	{
176	LONG lCount = InterlockedIncrement(&m_lRefCount);
177	LogFlowFunc(("lCount=%RI32\n", lCount));
178	return lCount;
179	}
180
181	STDMETHODIMP_(ULONG) SharedClipboardWinDataObject::Release(void)
182	{
183	LONG lCount = InterlockedDecrement(&m_lRefCount);
184	LogFlowFunc(("lCount=%RI32\n", m_lRefCount));
185	if (lCount == 0)
186	{
187	delete this;
188	return 0;
189	}
190
191	return lCount;
192	}
193
194	STDMETHODIMP SharedClipboardWinDataObject::QueryInterface(REFIID iid, void **ppvObject)
195	{
196	AssertPtrReturn(ppvObject, E_INVALIDARG);
197
198	if ( iid == IID_IDataObject
199	\|\| iid == IID_IUnknown)
200	{
201	AddRef();
202	*ppvObject = this;
203	return S_OK;
204	}
205
206	*ppvObject = 0;
207	return E_NOINTERFACE;
208	}
209
210	/**
211	* Copies a chunk of data into a HGLOBAL object.
212	*
213	* @returns VBox status code.
214	* @param pvData Data to copy.
215	* @param cbData Size (in bytes) to copy.
216	* @param fFlags GlobalAlloc flags, used for allocating the HGLOBAL block.
217	* @param phGlobal Where to store the allocated HGLOBAL object.
218	*/
219	int SharedClipboardWinDataObject::copyToHGlobal(const void pvData, size_t cbData, UINT fFlags, HGLOBAL phGlobal)
220	{
221	AssertPtrReturn(phGlobal, VERR_INVALID_POINTER);
222
223	HGLOBAL hGlobal = GlobalAlloc(fFlags, cbData);
224	if (!hGlobal)
225	return VERR_NO_MEMORY;
226
227	void *pvAlloc = GlobalLock(hGlobal);
228	if (pvAlloc)
229	{
230	CopyMemory(pvAlloc, pvData, cbData);
231	GlobalUnlock(hGlobal);
232
233	*phGlobal = hGlobal;
234
235	return VINF_SUCCESS;
236	}
237
238	GlobalFree(hGlobal);
239	return VERR_ACCESS_DENIED;
240	}
241
242	/**
243	* Reads (handles) a specific directory reursively and inserts its entry into the
244	* objects's entry list.
245	*
246	* @returns VBox status code.
247	* @param pTransfer Shared Clipboard transfer object to handle.
248	* @param strDir Directory path to handle.
249	*/
250	int SharedClipboardWinDataObject::readDir(PSHCLTRANSFER pTransfer, const Utf8Str &strDir)
251	{
252	LogFlowFunc(("strDir=%s\n", strDir.c_str()));
253
254	SHCLLISTOPENPARMS openParmsList;
255	int rc = ShClTransferListOpenParmsInit(&openParmsList);
256	if (RT_SUCCESS(rc))
257	{
258	rc = RTStrCopy(openParmsList.pszPath, openParmsList.cbPath, strDir.c_str());
259	if (RT_SUCCESS(rc))
260	{
261	SHCLLISTHANDLE hList;
262	rc = ShClTransferListOpen(pTransfer, &openParmsList, &hList);
263	if (RT_SUCCESS(rc))
264	{
265	LogFlowFunc(("strDir=%s -> hList=%RU64\n", strDir.c_str(), hList));
266
267	SHCLLISTHDR hdrList;
268	rc = ShClTransferListGetHeader(pTransfer, hList, &hdrList);
269	if (RT_SUCCESS(rc))
270	{
271	LogFlowFunc(("cTotalObjects=%RU64, cbTotalSize=%RU64\n\n",
272	hdrList.cTotalObjects, hdrList.cbTotalSize));
273
274	for (uint64_t o = 0; o < hdrList.cTotalObjects; o++)
275	{
276	SHCLLISTENTRY entryList;
277	rc = ShClTransferListEntryInit(&entryList);
278	if (RT_SUCCESS(rc))
279	{
280	rc = ShClTransferListRead(pTransfer, hList, &entryList);
281	if (RT_SUCCESS(rc))
282	{
283	if (ShClTransferListEntryIsValid(&entryList))
284	{
285	PSHCLFSOBJINFO pFsObjInfo = (PSHCLFSOBJINFO)entryList.pvInfo;
286	Assert(entryList.cbInfo == sizeof(SHCLFSOBJINFO));
287
288	Utf8Str strPath = strDir + Utf8Str("\\") + Utf8Str(entryList.pszName);
289
290	LogFlowFunc(("\t%s (%RU64 bytes) -> %s\n",
291	entryList.pszName, pFsObjInfo->cbObject, strPath.c_str()));
292
293	if (RTFS_IS_DIRECTORY(pFsObjInfo->Attr.fMode))
294	{
295	FSOBJENTRY objEntry = { strPath.c_str(), *pFsObjInfo };
296
297	m_lstEntries.push_back(objEntry); /** @todo Can this throw? */
298
299	rc = readDir(pTransfer, strPath.c_str());
300	}
301	else if (RTFS_IS_FILE(pFsObjInfo->Attr.fMode))
302	{
303	FSOBJENTRY objEntry = { strPath.c_str(), *pFsObjInfo };
304
305	m_lstEntries.push_back(objEntry); /** @todo Can this throw? */
306	}
307	else
308	rc = VERR_NOT_SUPPORTED;
309
310	/** @todo Handle symlinks. */
311	}
312	else
313	rc = VERR_INVALID_PARAMETER;
314	}
315
316	ShClTransferListEntryDestroy(&entryList);
317	}
318
319	if ( RT_FAILURE(rc)
320	&& pTransfer->Thread.fStop)
321	break;
322	}
323	}
324
325	ShClTransferListClose(pTransfer, hList);
326	}
327	}
328
329	ShClTransferListOpenParmsDestroy(&openParmsList);
330	}
331
332	LogFlowFuncLeaveRC(rc);
333	return rc;
334	}
335
336	/**
337	* Thread for reading transfer data.
338	* The data object needs the (high level, root) transfer listing at the time of ::GetData(), so we need
339	* to block and wait until we have this data (via this thread) and continue.
340	*
341	* @returns VBox status code.
342	* @param ThreadSelf Thread handle. Unused at the moment.
343	* @param pvUser Pointer to user-provided data. Of type SharedClipboardWinDataObject.
344	*/
345	/* static */
346	DECLCALLBACK(int) SharedClipboardWinDataObject::readThread(RTTHREAD ThreadSelf, void *pvUser)
347	{
348	RT_NOREF(ThreadSelf);
349
350	LogFlowFuncEnter();
351
352	SharedClipboardWinDataObject pThis = (SharedClipboardWinDataObject )pvUser;
353
354	PSHCLTRANSFER pTransfer = pThis->m_pTransfer;
355	AssertPtr(pTransfer);
356
357	pTransfer->Thread.fStarted = true;
358	pTransfer->Thread.fStop = false;
359
360	RTThreadUserSignal(RTThreadSelf());
361
362	LogRel2(("Shared Clipboard: Calculating transfer ...\n"));
363
364	PSHCLROOTLIST pRootList;
365	int rc = ShClTransferRootsGet(pTransfer, &pRootList);
366	if (RT_SUCCESS(rc))
367	{
368	LogFlowFunc(("cRoots=%RU32\n\n", pRootList->Hdr.cRoots));
369
370	for (uint32_t i = 0; i < pRootList->Hdr.cRoots; i++)
371	{
372	PSHCLLISTENTRY pRootEntry = &pRootList->paEntries[i];
373	AssertPtr(pRootEntry);
374
375	Assert(pRootEntry->cbInfo == sizeof(SHCLFSOBJINFO));
376	PSHCLFSOBJINFO pFsObjInfo = (PSHCLFSOBJINFO)pRootEntry->pvInfo;
377
378	LogFlowFunc(("pszRoot=%s, fMode=0x%x\n", pRootEntry->pszName, pFsObjInfo->Attr.fMode));
379
380	if (RTFS_IS_DIRECTORY(pFsObjInfo->Attr.fMode))
381	{
382	FSOBJENTRY objEntry = { pRootEntry->pszName, *pFsObjInfo };
383
384	pThis->m_lstEntries.push_back(objEntry); /** @todo Can this throw? */
385
386	rc = pThis->readDir(pTransfer, pRootEntry->pszName);
387	}
388	else if (RTFS_IS_FILE(pFsObjInfo->Attr.fMode))
389	{
390	FSOBJENTRY objEntry = { pRootEntry->pszName, *pFsObjInfo };
391
392	pThis->m_lstEntries.push_back(objEntry); /** @todo Can this throw? */
393	}
394	else
395	rc = VERR_NOT_SUPPORTED;
396
397	if (ASMAtomicReadBool(&pTransfer->Thread.fStop))
398	{
399	LogRel2(("Shared Clipboard: Stopping transfer calculation ...\n"));
400	break;
401	}
402
403	if (RT_FAILURE(rc))
404	break;
405	}
406
407	ShClTransferRootListFree(pRootList);
408	pRootList = NULL;
409
410	if ( RT_SUCCESS(rc)
411	&& !ASMAtomicReadBool(&pTransfer->Thread.fStop))
412	{
413	LogRel2(("Shared Clipboard: Transfer calculation complete (%zu root entries)\n", pThis->m_lstEntries.size()));
414
415	/*
416	* Signal the "list complete" event so that this data object can return (valid) data via ::GetData().
417	* This in turn then will create IStream instances (by the OS) for each file system object to handle.
418	*/
419	int rc2 = RTSemEventSignal(pThis->m_EventListComplete);
420	AssertRC(rc2);
421
422	if (pThis->m_lstEntries.size())
423	{
424	LogRel2(("Shared Clipboard: Waiting for transfer to complete ...\n"));
425
426	LogFlowFunc(("Waiting for transfer to complete ...\n"));
427
428	/* Transferring stuff can take a while, so don't use any timeout here. */
429	rc2 = RTSemEventWait(pThis->m_EventTransferComplete, RT_INDEFINITE_WAIT);
430	AssertRC(rc2);
431
432	switch (pThis->m_enmStatus)
433	{
434	case Completed:
435	LogRel2(("Shared Clipboard: Transfer complete\n"));
436	break;
437
438	case Canceled:
439	LogRel2(("Shared Clipboard: Transfer canceled\n"));
440	break;
441
442	case Error:
443	LogRel2(("Shared Clipboard: Transfer error occurred\n"));
444	break;
445
446	default:
447	break;
448	}
449	}
450	else
451	LogRel(("Shared Clipboard: No transfer root entries found -- should not happen, please file a bug report\n"));
452	}
453	else if (RT_FAILURE(rc))
454	LogRel(("Shared Clipboard: Transfer failed with %Rrc\n", rc));
455	}
456
457	LogFlowFuncLeaveRC(rc);
458	return rc;
459	}
460
461	/**
462	* Creates a FILEGROUPDESCRIPTOR object from a given Shared Clipboard transfer and stores the result into an HGLOBAL object.
463	*
464	* @returns VBox status code.
465	* @param pTransfer Shared Clipboard transfer to create file grou desciprtor for.
466	* @param fUnicode Whether the FILEGROUPDESCRIPTOR object shall contain Unicode data or not.
467	* @param phGlobal Where to store the allocated HGLOBAL object on success.
468	*/
469	int SharedClipboardWinDataObject::createFileGroupDescriptorFromTransfer(PSHCLTRANSFER pTransfer,
470	bool fUnicode, HGLOBAL *phGlobal)
471	{
472	AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
473	AssertPtrReturn(phGlobal, VERR_INVALID_POINTER);
474
475	LogFlowFuncEnter();
476
477	const size_t cbFileGroupDescriptor = fUnicode ? sizeof(FILEGROUPDESCRIPTORW) : sizeof(FILEGROUPDESCRIPTORA);
478	const size_t cbFileDescriptor = fUnicode ? sizeof(FILEDESCRIPTORW) : sizeof(FILEDESCRIPTORA);
479
480	const UINT cItems = (UINT)m_lstEntries.size(); /** UINT vs. size_t. */
481	if (!cItems)
482	return VERR_NOT_FOUND;
483
484	UINT curIdx = 0; /* Current index of the handled file group descriptor (FGD). */
485
486	const size_t cbFGD = cbFileGroupDescriptor + (cbFileDescriptor * (cItems - 1));
487
488	LogFunc(("fUnicode=%RTbool, cItems=%u, cbFileDescriptor=%zu\n", fUnicode, cItems, cbFileDescriptor));
489
490	/* FILEGROUPDESCRIPTORA / FILEGROUPDESCRIPTOR matches except the cFileName member (TCHAR vs. WCHAR). */
491	FILEGROUPDESCRIPTOR pFGD = (FILEGROUPDESCRIPTOR )RTMemAllocZ(cbFGD);
492	if (!pFGD)
493	return VERR_NO_MEMORY;
494
495	int rc = VINF_SUCCESS;
496
497	pFGD->cItems = cItems;
498
499	char *pszFileSpec = NULL;
500
501	FsObjEntryList::const_iterator itRoot = m_lstEntries.begin();
502	while (itRoot != m_lstEntries.end())
503	{
504	FILEDESCRIPTOR *pFD = &pFGD->fgd[curIdx];
505	RT_BZERO(pFD, cbFileDescriptor);
506
507	const char *pszFile = itRoot->strPath.c_str();
508	AssertPtr(pszFile);
509
510	pszFileSpec = RTStrDup(pszFile);
511	AssertBreakStmt(pszFileSpec != NULL, rc = VERR_NO_MEMORY);
512
513	if (fUnicode)
514	{
515	PRTUTF16 pwszFileSpec;
516	rc = RTStrToUtf16(pszFileSpec, &pwszFileSpec);
517	if (RT_SUCCESS(rc))
518	{
519	rc = RTUtf16CopyEx((PRTUTF16 )pFD->cFileName, sizeof(pFD->cFileName) / sizeof(WCHAR),
520	pwszFileSpec, RTUtf16Len(pwszFileSpec));
521	RTUtf16Free(pwszFileSpec);
522
523	LogFlowFunc(("pFD->cFileNameW=%ls\n", pFD->cFileName));
524	}
525	}
526	else
527	{
528	rc = RTStrCopy(pFD->cFileName, sizeof(pFD->cFileName), pszFileSpec);
529	LogFlowFunc(("pFD->cFileNameA=%s\n", pFD->cFileName));
530	}
531
532	RTStrFree(pszFileSpec);
533	pszFileSpec = NULL;
534
535	if (RT_FAILURE(rc))
536	break;
537
538	pFD->dwFlags = FD_PROGRESSUI \| FD_ATTRIBUTES;
539	if (fUnicode) /** @todo Only >= Vista. */
540	pFD->dwFlags \|= FD_UNICODE;
541	pFD->dwFileAttributes = FILE_ATTRIBUTE_NORMAL;
542
543	const SHCLFSOBJINFO *pObjInfo = &itRoot->objInfo;
544
545	if (RTFS_IS_DIRECTORY(pObjInfo->Attr.fMode))
546	{
547	pFD->dwFileAttributes \|= FILE_ATTRIBUTE_DIRECTORY;
548	}
549	else if (RTFS_IS_FILE(pObjInfo->Attr.fMode))
550	{
551	pFD->dwFlags \|= FD_FILESIZE;
552
553	const uint64_t cbObjSize = pObjInfo->cbObject;
554
555	pFD->nFileSizeHigh = RT_HI_U32(cbObjSize);
556	pFD->nFileSizeLow = RT_LO_U32(cbObjSize);
557	}
558	else if (RTFS_IS_SYMLINK(pObjInfo->Attr.fMode))
559	{
560	/** @todo Implement. */
561	}
562	#if 0 /** @todo Implement this. */
563	pFD->dwFlags = FD_ATTRIBUTES \| FD_CREATETIME \| FD_ACCESSTIME \| FD_WRITESTIME \| FD_FILESIZE;
564	pFD->dwFileAttributes =
565	pFD->ftCreationTime =
566	pFD->ftLastAccessTime =
567	pFD->ftLastWriteTime =
568	#endif
569	++curIdx;
570	++itRoot;
571	}
572
573	if (pszFileSpec)
574	RTStrFree(pszFileSpec);
575
576	if (RT_SUCCESS(rc))
577	rc = copyToHGlobal(pFGD, cbFGD, GMEM_MOVEABLE, phGlobal);
578
579	RTMemFree(pFGD);
580
581	LogFlowFuncLeaveRC(rc);
582	return rc;
583	}
584
585	/**
586	* Retrieves the data stored in this object and store the result in
587	* pMedium.
588	*
589	* @return IPRT status code.
590	* @return HRESULT
591	* @param pFormatEtc
592	* @param pMedium
593	*/
594	STDMETHODIMP SharedClipboardWinDataObject::GetData(LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium)
595	{
596	AssertPtrReturn(pFormatEtc, DV_E_FORMATETC);
597	AssertPtrReturn(pMedium, DV_E_FORMATETC);
598
599	LogFlowFuncEnter();
600
601	LogFlowFunc(("lIndex=%RI32\n", pFormatEtc->lindex));
602
603	/*
604	* Initialize default values.
605	*/
606	RT_BZERO(pMedium, sizeof(STGMEDIUM));
607
608	HRESULT hr = DV_E_FORMATETC; /* Play safe. */
609
610	if ( pFormatEtc->cfFormat == m_cfFileDescriptorA
611	#ifdef VBOX_CLIPBOARD_WITH_UNICODE_SUPPORT
612	\|\| pFormatEtc->cfFormat == m_cfFileDescriptorW
613	#endif
614	)
615	{
616	const bool fUnicode = pFormatEtc->cfFormat == m_cfFileDescriptorW;
617
618	const uint32_t enmTransferStatus = ShClTransferGetStatus(m_pTransfer);
619	RT_NOREF(enmTransferStatus);
620
621	LogFlowFunc(("FormatIndex_FileDescriptor%s, enmTransferStatus=%s, m_fRunning=%RTbool\n",
622	fUnicode ? "W" : "A", ShClTransferStatusToStr(enmTransferStatus), m_fRunning));
623
624	int rc;
625
626	/* The caller can call GetData() several times, so make sure we don't do the same transfer multiple times. */
627	if (!m_fRunning)
628	{
629	/* Start the transfer asynchronously in a separate thread. */
630	rc = ShClTransferRun(m_pTransfer, &SharedClipboardWinDataObject::readThread, this);
631	if (RT_SUCCESS(rc))
632	{
633	m_fRunning = true;
634
635	/* Don't block for too long here, as this also will screw other apps running on the OS. */
636	LogFunc(("Waiting for listing to arrive ...\n"));
637	rc = RTSemEventWait(m_EventListComplete, 30 * 1000 /* 30s timeout */);
638	if (RT_SUCCESS(rc))
639	{
640	LogFunc(("Listing complete\n"));
641	}
642	}
643	}
644	else
645	rc = VINF_SUCCESS;
646
647	if (RT_SUCCESS(rc))
648	{
649	HGLOBAL hGlobal;
650	rc = createFileGroupDescriptorFromTransfer(m_pTransfer, fUnicode, &hGlobal);
651	if (RT_SUCCESS(rc))
652	{
653	pMedium->tymed = TYMED_HGLOBAL;
654	pMedium->hGlobal = hGlobal;
655	/* Note: hGlobal now is being owned by pMedium / the caller. */
656
657	hr = S_OK;
658	}
659	else /* We can't tell any better to the caller, unfortunately. */
660	hr = E_UNEXPECTED;
661	}
662
663	if (RT_FAILURE(rc))
664	LogRel(("Shared Clipboard: Data object unable to get data, rc=%Rrc\n", rc));
665	}
666
667	if (pFormatEtc->cfFormat == m_cfFileContents)
668	{
669	if ( pFormatEtc->lindex >= 0
670	&& (ULONG)pFormatEtc->lindex < m_lstEntries.size())
671	{
672	m_uObjIdx = pFormatEtc->lindex; /* lIndex of FormatEtc contains the actual index to the object being handled. */
673
674	FSOBJENTRY &fsObjEntry = m_lstEntries.at(m_uObjIdx);
675
676	LogFlowFunc(("FormatIndex_FileContents: m_uObjIdx=%u (entry '%s')\n", m_uObjIdx, fsObjEntry.strPath.c_str()));
677
678	LogRel2(("Shared Clipboard: Receiving object '%s' ...\n", fsObjEntry.strPath.c_str()));
679
680	/* Hand-in the provider so that our IStream implementation can continue working with it. */
681	hr = SharedClipboardWinStreamImpl::Create(this /* pParent */, m_pTransfer,
682	fsObjEntry.strPath.c_str()/* File name /, &fsObjEntry.objInfo / PSHCLFSOBJINFO */,
683	&m_pStream);
684	if (SUCCEEDED(hr))
685	{
686	/* Hand over the stream to the caller. */
687	pMedium->tymed = TYMED_ISTREAM;
688	pMedium->pstm = m_pStream;
689	}
690	}
691	}
692	else if (pFormatEtc->cfFormat == m_cfPerformedDropEffect)
693	{
694	HGLOBAL hGlobal = GlobalAlloc(GHND, sizeof(DWORD));
695
696	DWORD* pdwDropEffect = (DWORD*)GlobalLock(hGlobal);
697	*pdwDropEffect = DROPEFFECT_COPY;
698
699	GlobalUnlock(hGlobal);
700
701	pMedium->tymed = TYMED_HGLOBAL;
702	pMedium->hGlobal = hGlobal;
703	pMedium->pUnkForRelease = NULL;
704	}
705
706	if ( FAILED(hr)
707	&& hr != DV_E_FORMATETC) /* Can happen if the caller queries unknown / unhandled formats. */
708	{
709	LogRel(("Shared Clipboard: Error returning data from data object (%Rhrc)\n", hr));
710	}
711
712	LogFlowFunc(("hr=%Rhrc\n", hr));
713	return hr;
714	}
715
716	/**
717	* Only required for IStream / IStorage interfaces.
718	*
719	* @return IPRT status code.
720	* @return HRESULT
721	* @param pFormatEtc
722	* @param pMedium
723	*/
724	STDMETHODIMP SharedClipboardWinDataObject::GetDataHere(LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium)
725	{
726	RT_NOREF(pFormatEtc, pMedium);
727	LogFlowFunc(("\n"));
728	return E_NOTIMPL;
729	}
730
731	/**
732	* Query if this objects supports a specific format.
733	*
734	* @return IPRT status code.
735	* @return HRESULT
736	* @param pFormatEtc
737	*/
738	STDMETHODIMP SharedClipboardWinDataObject::QueryGetData(LPFORMATETC pFormatEtc)
739	{
740	LogFlowFunc(("\n"));
741	return lookupFormatEtc(pFormatEtc, NULL /* puIndex */) ? S_OK : DV_E_FORMATETC;
742	}
743
744	STDMETHODIMP SharedClipboardWinDataObject::GetCanonicalFormatEtc(LPFORMATETC pFormatEtc, LPFORMATETC pFormatEtcOut)
745	{
746	RT_NOREF(pFormatEtc);
747	LogFlowFunc(("\n"));
748
749	/* Set this to NULL in any case. */
750	pFormatEtcOut->ptd = NULL;
751	return E_NOTIMPL;
752	}
753
754	STDMETHODIMP SharedClipboardWinDataObject::SetData(LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium, BOOL fRelease)
755	{
756	if ( pFormatEtc == NULL
757	\|\| pMedium == NULL)
758	return E_INVALIDARG;
759
760	if (pFormatEtc->lindex != -1)
761	return DV_E_LINDEX;
762
763	if (pFormatEtc->tymed != TYMED_HGLOBAL)
764	return DV_E_TYMED;
765
766	if (pFormatEtc->dwAspect != DVASPECT_CONTENT)
767	return DV_E_DVASPECT;
768
769	LogFlowFunc(("cfFormat=%RU16, lookupFormatEtc=%RTbool\n",
770	pFormatEtc->cfFormat, lookupFormatEtc(pFormatEtc, NULL /* puIndex */)));
771
772	/* CFSTR_PERFORMEDDROPEFFECT is used by the drop target (caller of this IDataObject) to communicate
773	* the outcome of the overall operation. */
774	if ( pFormatEtc->cfFormat == m_cfPerformedDropEffect
775	&& pMedium->tymed == TYMED_HGLOBAL)
776	{
777	DWORD dwEffect = (DWORD )GlobalLock(pMedium->hGlobal);
778	GlobalUnlock(pMedium->hGlobal);
779
780	LogFlowFunc(("dwEffect=%RI32\n", dwEffect));
781
782	/* Did the user cancel the operation via UI (shell)? This also might happen when overwriting an existing file
783	* and the user doesn't want to allow this. */
784	if (dwEffect == DROPEFFECT_NONE)
785	{
786	LogRel2(("Shared Clipboard: Transfer canceled by user interaction\n"));
787
788	OnTransferCanceled();
789	}
790	/** @todo Detect move / overwrite actions here. */
791
792	if (fRelease)
793	ReleaseStgMedium(pMedium);
794
795	return S_OK;
796	}
797
798	return E_NOTIMPL;
799	}
800
801	STDMETHODIMP SharedClipboardWinDataObject::EnumFormatEtc(DWORD dwDirection, IEnumFORMATETC **ppEnumFormatEtc)
802	{
803	LogFlowFunc(("dwDirection=%RI32, mcFormats=%RI32, mpFormatEtc=%p\n", dwDirection, m_cFormats, m_pFormatEtc));
804
805	HRESULT hr;
806	if (dwDirection == DATADIR_GET)
807	hr = SharedClipboardWinEnumFormatEtc::CreateEnumFormatEtc(m_cFormats, m_pFormatEtc, ppEnumFormatEtc);
808	else
809	hr = E_NOTIMPL;
810
811	LogFlowFunc(("hr=%Rhrc\n", hr));
812	return hr;
813	}
814
815	STDMETHODIMP SharedClipboardWinDataObject::DAdvise(LPFORMATETC pFormatEtc, DWORD fAdvise, IAdviseSink pAdvSink, DWORD pdwConnection)
816	{
817	RT_NOREF(pFormatEtc, fAdvise, pAdvSink, pdwConnection);
818	return OLE_E_ADVISENOTSUPPORTED;
819	}
820
821	STDMETHODIMP SharedClipboardWinDataObject::DUnadvise(DWORD dwConnection)
822	{
823	RT_NOREF(dwConnection);
824	return OLE_E_ADVISENOTSUPPORTED;
825	}
826
827	STDMETHODIMP SharedClipboardWinDataObject::EnumDAdvise(IEnumSTATDATA **ppEnumAdvise)
828	{
829	RT_NOREF(ppEnumAdvise);
830	return OLE_E_ADVISENOTSUPPORTED;
831	}
832
833	#ifdef VBOX_WITH_SHARED_CLIPBOARD_WIN_ASYNC
834	/*
835	* IDataObjectAsyncCapability methods.
836	*/
837
838	STDMETHODIMP SharedClipboardWinDataObject::EndOperation(HRESULT hResult, IBindCtx *pbcReserved, DWORD dwEffects)
839	{
840	RT_NOREF(hResult, pbcReserved, dwEffects);
841	return E_NOTIMPL;
842	}
843
844	STDMETHODIMP SharedClipboardWinDataObject::GetAsyncMode(BOOL *pfIsOpAsync)
845	{
846	RT_NOREF(pfIsOpAsync);
847	return E_NOTIMPL;
848	}
849
850	STDMETHODIMP SharedClipboardWinDataObject::InOperation(BOOL *pfInAsyncOp)
851	{
852	RT_NOREF(pfInAsyncOp);
853	return E_NOTIMPL;
854	}
855
856	STDMETHODIMP SharedClipboardWinDataObject::SetAsyncMode(BOOL fDoOpAsync)
857	{
858	RT_NOREF(fDoOpAsync);
859	return E_NOTIMPL;
860	}
861
862	STDMETHODIMP SharedClipboardWinDataObject::StartOperation(IBindCtx *pbcReserved)
863	{
864	RT_NOREF(pbcReserved);
865	return E_NOTIMPL;
866	}
867	#endif /* VBOX_WITH_SHARED_CLIPBOARD_WIN_ASYNC */
868
869	/*
870	* Own stuff.
871	*/
872
873	int SharedClipboardWinDataObject::Init(void)
874	{
875	LogFlowFuncLeaveRC(VINF_SUCCESS);
876	return VINF_SUCCESS;
877	}
878
879	void SharedClipboardWinDataObject::OnTransferComplete(int rc /* = VINF_SUCESS */)
880	{
881	RT_NOREF(rc);
882
883	LogFlowFunc(("m_uObjIdx=%RU32 (total: %zu)\n", m_uObjIdx, m_lstEntries.size()));
884
885	if (RT_SUCCESS(rc))
886	{
887	const bool fComplete = m_uObjIdx == m_lstEntries.size() - 1 /* Object index is zero-based */;
888	if (fComplete)
889	{
890	m_enmStatus = Completed;
891	}
892	}
893	else
894	m_enmStatus = Error;
895
896	if (m_enmStatus != Initialized)
897	{
898	if (m_EventTransferComplete != NIL_RTSEMEVENT)
899	{
900	int rc2 = RTSemEventSignal(m_EventTransferComplete);
901	AssertRC(rc2);
902	}
903	}
904
905	LogFlowFuncLeaveRC(rc);
906	}
907
908	void SharedClipboardWinDataObject::OnTransferCanceled(void)
909	{
910	LogFlowFuncEnter();
911
912	m_enmStatus = Canceled;
913
914	if (m_EventTransferComplete != NIL_RTSEMEVENT)
915	{
916	int rc2 = RTSemEventSignal(m_EventTransferComplete);
917	AssertRC(rc2);
918	}
919
920	LogFlowFuncLeave();
921	}
922
923	/* static */
924	void SharedClipboardWinDataObject::logFormat(CLIPFORMAT fmt)
925	{
926	char szFormat[128];
927	if (GetClipboardFormatName(fmt, szFormat, sizeof(szFormat)))
928	{
929	LogFlowFunc(("clipFormat=%RI16 -> %s\n", fmt, szFormat));
930	}
931	else
932	LogFlowFunc(("clipFormat=%RI16 is unknown\n", fmt));
933	}
934
935	bool SharedClipboardWinDataObject::lookupFormatEtc(LPFORMATETC pFormatEtc, ULONG *puIndex)
936	{
937	AssertReturn(pFormatEtc, false);
938	/* puIndex is optional. */
939
940	for (ULONG i = 0; i < m_cFormats; i++)
941	{
942	if( (pFormatEtc->tymed & m_pFormatEtc[i].tymed)
943	&& pFormatEtc->cfFormat == m_pFormatEtc[i].cfFormat)
944	/* Note: Do not compare dwAspect here, as this can be dynamic, depending on how the object should be represented. */
945	//&& pFormatEtc->dwAspect == m_pFormatEtc[i].dwAspect)
946	{
947	LogRel2(("Shared Clipboard: Format found: tyMed=%RI32, cfFormat=%RI16, dwAspect=%RI32, ulIndex=%RU32\n",
948	pFormatEtc->tymed, pFormatEtc->cfFormat, pFormatEtc->dwAspect, i));
949	if (puIndex)
950	*puIndex = i;
951	return true;
952	}
953	}
954
955	LogRel2(("Shared Clipboard: Format NOT found: tyMed=%RI32, cfFormat=%RI16, dwAspect=%RI32\n",
956	pFormatEtc->tymed, pFormatEtc->cfFormat, pFormatEtc->dwAspect));
957
958	logFormat(pFormatEtc->cfFormat);
959
960	return false;
961	}
962
963	void SharedClipboardWinDataObject::registerFormat(LPFORMATETC pFormatEtc, CLIPFORMAT clipFormat,
964	TYMED tyMed, LONG lIndex, DWORD dwAspect,
965	DVTARGETDEVICE *pTargetDevice)
966	{
967	AssertPtr(pFormatEtc);
968
969	pFormatEtc->cfFormat = clipFormat;
970	pFormatEtc->tymed = tyMed;
971	pFormatEtc->lindex = lIndex;
972	pFormatEtc->dwAspect = dwAspect;
973	pFormatEtc->ptd = pTargetDevice;
974
975	LogFlowFunc(("Registered format=%ld\n", pFormatEtc->cfFormat));
976
977	logFormat(pFormatEtc->cfFormat);
978	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/GuestHost/SharedClipboard/ClipboardDataObjectImpl-win.cpp@ 98461

Download in other formats: