clipboard-win.cpp@ 94490

Last change on this file since 94490 was 93401, checked in by vboxsync, 3 years ago
SharedClipboard/win: Fixed off by 2 calculation in SharedClipboardWinConvertMIMEToCFHTML as well as a testcase for it. Made SharedClipboardWinConvertCFHTMLToMIME accept zero length fragments because SharedClipboardWinConvertMIMEToCFHTML can produce them. bugref:10160
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 40.7 KB

Line
1	/* $Id: clipboard-win.cpp 93401 2022-01-21 23:41:27Z vboxsync $ */
2	/** @file
3	* Shared Clipboard: Windows-specific functions for clipboard handling.
4	*/
5
6	/*
7	* Copyright (C) 2006-2022 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	#define LOG_GROUP LOG_GROUP_SHARED_CLIPBOARD
19	#include <VBox/GuestHost/SharedClipboard.h>
20
21	#include <iprt/assert.h>
22	#include <iprt/errcore.h>
23	#include <iprt/ldr.h>
24	#include <iprt/mem.h>
25	#include <iprt/thread.h>
26	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
27	# include <iprt/win/windows.h>
28	# include <iprt/win/shlobj.h> /* For CFSTR_FILEDESCRIPTORXXX + CFSTR_FILECONTENTS. */
29	# include <iprt/utf16.h>
30	#endif
31
32	#include <VBox/log.h>
33
34	#include <VBox/HostServices/VBoxClipboardSvc.h>
35	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
36	# include <VBox/GuestHost/SharedClipboard-transfers.h>
37	#endif
38	#include <VBox/GuestHost/SharedClipboard-win.h>
39	#include <VBox/GuestHost/clipboard-helper.h>
40
41
42	/**
43	* Opens the clipboard of a specific window.
44	*
45	* @returns VBox status code.
46	* @param hWnd Handle of window to open clipboard for.
47	*/
48	int SharedClipboardWinOpen(HWND hWnd)
49	{
50	/* "OpenClipboard fails if another window has the clipboard open."
51	* So try a few times and wait up to 1 second.
52	*/
53	BOOL fOpened = FALSE;
54
55	LogFlowFunc(("hWnd=%p\n", hWnd));
56
57	int i = 0;
58	for (;;)
59	{
60	if (OpenClipboard(hWnd))
61	{
62	fOpened = TRUE;
63	break;
64	}
65
66	if (i >= 10) /* sleep interval = [1..512] ms */
67	break;
68
69	RTThreadSleep(1 << i);
70	++i;
71	}
72
73	#ifdef LOG_ENABLED
74	if (i > 0)
75	LogFlowFunc(("%d times tried to open clipboard\n", i + 1));
76	#endif
77
78	int rc;
79	if (fOpened)
80	rc = VINF_SUCCESS;
81	else
82	{
83	const DWORD dwLastErr = GetLastError();
84	rc = RTErrConvertFromWin32(dwLastErr);
85	LogRel(("Failed to open clipboard, rc=%Rrc (0x%x)\n", rc, dwLastErr));
86	}
87
88	return rc;
89	}
90
91	/**
92	* Closes the clipboard for the current thread.
93	*
94	* @returns VBox status code.
95	*/
96	int SharedClipboardWinClose(void)
97	{
98	int rc;
99
100	const BOOL fRc = CloseClipboard();
101	if (RT_UNLIKELY(!fRc))
102	{
103	const DWORD dwLastErr = GetLastError();
104	if (dwLastErr == ERROR_CLIPBOARD_NOT_OPEN)
105	{
106	rc = VINF_SUCCESS; /* Not important, so just report success instead. */
107	}
108	else
109	{
110	rc = RTErrConvertFromWin32(dwLastErr);
111	LogFunc(("Failed with %Rrc (0x%x)\n", rc, dwLastErr));
112	}
113	}
114	else
115	rc = VINF_SUCCESS;
116
117	LogFlowFuncLeaveRC(rc);
118	return rc;
119	}
120
121	/**
122	* Clears the clipboard for the current thread.
123	*
124	* @returns VBox status code.
125	*/
126	int SharedClipboardWinClear(void)
127	{
128	LogFlowFuncEnter();
129	if (EmptyClipboard())
130	return VINF_SUCCESS;
131
132	const DWORD dwLastErr = GetLastError();
133	AssertReturn(dwLastErr != ERROR_CLIPBOARD_NOT_OPEN, VERR_INVALID_STATE);
134
135	int rc = RTErrConvertFromWin32(dwLastErr);
136	LogFunc(("Failed with %Rrc (0x%x)\n", rc, dwLastErr));
137	return rc;
138	}
139
140	/**
141	* Initializes a Shared Clipboard Windows context.
142	*
143	* @returns VBox status code.
144	* @param pWinCtx Shared Clipboard Windows context to initialize.
145	*/
146	int SharedClipboardWinCtxInit(PSHCLWINCTX pWinCtx)
147	{
148	int rc = RTCritSectInit(&pWinCtx->CritSect);
149	if (RT_SUCCESS(rc))
150	{
151	/* Check that new Clipboard API is available. */
152	SharedClipboardWinCheckAndInitNewAPI(&pWinCtx->newAPI);
153	/* Do not check the rc, as the call might return VERR_SYMBOL_NOT_FOUND is the new API isn't available. */
154
155	pWinCtx->hWnd = NULL;
156	pWinCtx->hWndClipboardOwnerUs = NULL;
157	pWinCtx->hWndNextInChain = NULL;
158	}
159
160	LogFlowFuncLeaveRC(rc);
161	return rc;
162	}
163
164	/**
165	* Destroys a Shared Clipboard Windows context.
166	*
167	* @param pWinCtx Shared Clipboard Windows context to destroy.
168	*/
169	void SharedClipboardWinCtxDestroy(PSHCLWINCTX pWinCtx)
170	{
171	if (!pWinCtx)
172	return;
173
174	LogFlowFuncEnter();
175
176	if (RTCritSectIsInitialized(&pWinCtx->CritSect))
177	{
178	int rc2 = RTCritSectDelete(&pWinCtx->CritSect);
179	AssertRC(rc2);
180	}
181	}
182
183	/**
184	* Checks and initializes function pointer which are required for using
185	* the new clipboard API.
186	*
187	* @returns VBox status code, or VERR_SYMBOL_NOT_FOUND if the new API is not available.
188	* @param pAPI Where to store the retrieved function pointers.
189	* Will be set to NULL if the new API is not available.
190	*/
191	int SharedClipboardWinCheckAndInitNewAPI(PSHCLWINAPINEW pAPI)
192	{
193	RTLDRMOD hUser32 = NIL_RTLDRMOD;
194	int rc = RTLdrLoadSystem("User32.dll", /* fNoUnload = */ true, &hUser32);
195	if (RT_SUCCESS(rc))
196	{
197	rc = RTLdrGetSymbol(hUser32, "AddClipboardFormatListener", (void **)&pAPI->pfnAddClipboardFormatListener);
198	if (RT_SUCCESS(rc))
199	{
200	rc = RTLdrGetSymbol(hUser32, "RemoveClipboardFormatListener", (void **)&pAPI->pfnRemoveClipboardFormatListener);
201	}
202
203	RTLdrClose(hUser32);
204	}
205
206	if (RT_SUCCESS(rc))
207	{
208	LogRel(("Shared Clipboard: New Clipboard API enabled\n"));
209	}
210	else
211	{
212	RT_BZERO(pAPI, sizeof(SHCLWINAPINEW));
213	LogRel(("Shared Clipboard: New Clipboard API not available (%Rrc)\n", rc));
214	}
215
216	LogFlowFuncLeaveRC(rc);
217	return rc;
218	}
219
220	/**
221	* Returns if the new clipboard API is available or not.
222	*
223	* @returns @c true if the new API is available, or @c false if not.
224	* @param pAPI Structure used for checking if the new clipboard API is available or not.
225	*/
226	bool SharedClipboardWinIsNewAPI(PSHCLWINAPINEW pAPI)
227	{
228	if (!pAPI)
229	return false;
230	return pAPI->pfnAddClipboardFormatListener != NULL;
231	}
232
233	/**
234	* Adds ourselves into the chain of cliboard listeners.
235	*
236	* @returns VBox status code.
237	* @param pCtx Windows clipboard context to use to add ourselves.
238	*/
239	int SharedClipboardWinChainAdd(PSHCLWINCTX pCtx)
240	{
241	const PSHCLWINAPINEW pAPI = &pCtx->newAPI;
242
243	BOOL fRc;
244	if (SharedClipboardWinIsNewAPI(pAPI))
245	fRc = pAPI->pfnAddClipboardFormatListener(pCtx->hWnd);
246	else
247	{
248	SetLastError(NO_ERROR);
249	pCtx->hWndNextInChain = SetClipboardViewer(pCtx->hWnd);
250	fRc = pCtx->hWndNextInChain != NULL \|\| GetLastError() == NO_ERROR;
251	}
252
253	int rc = VINF_SUCCESS;
254
255	if (!fRc)
256	{
257	const DWORD dwLastErr = GetLastError();
258	rc = RTErrConvertFromWin32(dwLastErr);
259	LogFunc(("Failed with %Rrc (0x%x)\n", rc, dwLastErr));
260	}
261
262	return rc;
263	}
264
265	/**
266	* Remove ourselves from the chain of cliboard listeners
267	*
268	* @returns VBox status code.
269	* @param pCtx Windows clipboard context to use to remove ourselves.
270	*/
271	int SharedClipboardWinChainRemove(PSHCLWINCTX pCtx)
272	{
273	if (!pCtx->hWnd)
274	return VINF_SUCCESS;
275
276	const PSHCLWINAPINEW pAPI = &pCtx->newAPI;
277
278	BOOL fRc;
279	if (SharedClipboardWinIsNewAPI(pAPI))
280	{
281	fRc = pAPI->pfnRemoveClipboardFormatListener(pCtx->hWnd);
282	}
283	else
284	{
285	fRc = ChangeClipboardChain(pCtx->hWnd, pCtx->hWndNextInChain);
286	if (fRc)
287	pCtx->hWndNextInChain = NULL;
288	}
289
290	int rc = VINF_SUCCESS;
291
292	if (!fRc)
293	{
294	const DWORD dwLastErr = GetLastError();
295	rc = RTErrConvertFromWin32(dwLastErr);
296	LogFunc(("Failed with %Rrc (0x%x)\n", rc, dwLastErr));
297	}
298
299	return rc;
300	}
301
302	/**
303	* Callback which is invoked when we have successfully pinged ourselves down the
304	* clipboard chain. We simply unset a boolean flag to say that we are responding.
305	* There is a race if a ping returns after the next one is initiated, but nothing
306	* very bad is likely to happen.
307	*
308	* @param hWnd Window handle to use for this callback. Not used currently.
309	* @param uMsg Message to handle. Not used currently.
310	* @param dwData Pointer to user-provided data. Contains our Windows clipboard context.
311	* @param lResult Additional data to pass. Not used currently.
312	*/
313	VOID CALLBACK SharedClipboardWinChainPingProc(HWND hWnd, UINT uMsg, ULONG_PTR dwData, LRESULT lResult) RT_NOTHROW_DEF
314	{
315	RT_NOREF(hWnd);
316	RT_NOREF(uMsg);
317	RT_NOREF(lResult);
318
319	/** @todo r=andy Why not using SetWindowLongPtr for keeping the context? */
320	PSHCLWINCTX pCtx = (PSHCLWINCTX)dwData;
321	AssertPtrReturnVoid(pCtx);
322
323	pCtx->oldAPI.fCBChainPingInProcess = FALSE;
324	}
325
326	/**
327	* Passes a window message to the next window in the clipboard chain.
328	*
329	* @returns LRESULT
330	* @param pWinCtx Window context to use.
331	* @param msg Window message to pass.
332	* @param wParam WPARAM to pass.
333	* @param lParam LPARAM to pass.
334	*/
335	LRESULT SharedClipboardWinChainPassToNext(PSHCLWINCTX pWinCtx,
336	UINT msg, WPARAM wParam, LPARAM lParam)
337	{
338	LogFlowFuncEnter();
339
340	LRESULT lresultRc = 0;
341
342	if (pWinCtx->hWndNextInChain)
343	{
344	LogFunc(("hWndNextInChain=%p\n", pWinCtx->hWndNextInChain));
345
346	/* Pass the message to next window in the clipboard chain. */
347	DWORD_PTR dwResult;
348	lresultRc = SendMessageTimeout(pWinCtx->hWndNextInChain, msg, wParam, lParam, 0,
349	SHCL_WIN_CBCHAIN_TIMEOUT_MS, &dwResult);
350	if (!lresultRc)
351	lresultRc = dwResult;
352	}
353
354	LogFlowFunc(("lresultRc=%ld\n", lresultRc));
355	return lresultRc;
356	}
357
358	/**
359	* Converts a (registered or standard) Windows clipboard format to a VBox clipboard format.
360	*
361	* @returns Converted VBox clipboard format, or VBOX_SHCL_FMT_NONE if not found.
362	* @param uFormat Windows clipboard format to convert.
363	*/
364	SHCLFORMAT SharedClipboardWinClipboardFormatToVBox(UINT uFormat)
365	{
366	/* Insert the requested clipboard format data into the clipboard. */
367	SHCLFORMAT vboxFormat = VBOX_SHCL_FMT_NONE;
368
369	switch (uFormat)
370	{
371	case CF_UNICODETEXT:
372	vboxFormat = VBOX_SHCL_FMT_UNICODETEXT;
373	break;
374
375	case CF_DIB:
376	vboxFormat = VBOX_SHCL_FMT_BITMAP;
377	break;
378
379	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
380	/* CF_HDROP handles file system entries which are locally present
381	* on source for transferring to the target.
382	*
383	* This does not invoke any IDataObject / IStream implementations! */
384	case CF_HDROP:
385	vboxFormat = VBOX_SHCL_FMT_URI_LIST;
386	break;
387	#endif
388
389	default:
390	if (uFormat >= 0xC000) /** Formats registered with RegisterClipboardFormat() start at this index. */
391	{
392	TCHAR szFormatName[256]; /** @todo r=andy Do we need Unicode support here as well? */
393	int cActual = GetClipboardFormatName(uFormat, szFormatName, sizeof(szFormatName) / sizeof(TCHAR));
394	if (cActual)
395	{
396	LogFlowFunc(("uFormat=%u -> szFormatName=%s\n", uFormat, szFormatName));
397
398	if (RTStrCmp(szFormatName, SHCL_WIN_REGFMT_HTML) == 0)
399	vboxFormat = VBOX_SHCL_FMT_HTML;
400	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
401	/* These types invoke our IDataObject / IStream implementations. */
402	else if ( (RTStrCmp(szFormatName, CFSTR_FILEDESCRIPTORA) == 0)
403	\|\| (RTStrCmp(szFormatName, CFSTR_FILECONTENTS) == 0))
404	vboxFormat = VBOX_SHCL_FMT_URI_LIST;
405	/** @todo Do we need to handle CFSTR_FILEDESCRIPTORW here as well? */
406	#endif
407	}
408	}
409	break;
410	}
411
412	LogFlowFunc(("uFormat=%u -> vboxFormat=0x%x\n", uFormat, vboxFormat));
413	return vboxFormat;
414	}
415
416	/**
417	* Retrieves all supported clipboard formats of a specific clipboard.
418	*
419	* @returns VBox status code.
420	* @param pCtx Windows clipboard context to retrieve formats for.
421	* @param pfFormats Where to store the retrieved formats.
422	*/
423	int SharedClipboardWinGetFormats(PSHCLWINCTX pCtx, PSHCLFORMATS pfFormats)
424	{
425	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
426	AssertPtrReturn(pfFormats, VERR_INVALID_POINTER);
427
428	SHCLFORMATS fFormats = VBOX_SHCL_FMT_NONE;
429
430	/* Query list of available formats and report to host. */
431	int rc = SharedClipboardWinOpen(pCtx->hWnd);
432	if (RT_SUCCESS(rc))
433	{
434	UINT uCurFormat = 0; /* Must be set to zero for EnumClipboardFormats(). */
435	while ((uCurFormat = EnumClipboardFormats(uCurFormat)) != 0)
436	fFormats \|= SharedClipboardWinClipboardFormatToVBox(uCurFormat);
437
438	int rc2 = SharedClipboardWinClose();
439	AssertRC(rc2);
440	LogFlowFunc(("fFormats=%#x\n", fFormats));
441	}
442	else
443	LogFunc(("Failed with rc=%Rrc (fFormats=%#x)\n", rc, fFormats));
444
445	*pfFormats = fFormats;
446	return rc;
447	}
448
449	/**
450	* Extracts a field value from CF_HTML data.
451	*
452	* @returns VBox status code.
453	* @param pszSrc source in CF_HTML format.
454	* @param pszOption Name of CF_HTML field.
455	* @param puValue Where to return extracted value of CF_HTML field.
456	*/
457	int SharedClipboardWinGetCFHTMLHeaderValue(const char pszSrc, const char pszOption, uint32_t *puValue)
458	{
459	AssertPtrReturn(pszSrc, VERR_INVALID_POINTER);
460	AssertPtrReturn(pszOption, VERR_INVALID_POINTER);
461
462	int rc = VERR_INVALID_PARAMETER;
463
464	const char *pszOptionValue = RTStrStr(pszSrc, pszOption);
465	if (pszOptionValue)
466	{
467	size_t cchOption = strlen(pszOption);
468	Assert(cchOption);
469
470	rc = RTStrToUInt32Ex(pszOptionValue + cchOption, NULL, 10, puValue);
471	}
472	return rc;
473	}
474
475	/**
476	* Check that the source string contains CF_HTML struct.
477	*
478	* @returns @c true if the @a pszSource string is in CF_HTML format.
479	* @param pszSource Source string to check.
480	*/
481	bool SharedClipboardWinIsCFHTML(const char *pszSource)
482	{
483	return RTStrStr(pszSource, "Version:") != NULL
484	&& RTStrStr(pszSource, "StartHTML:") != NULL;
485	}
486
487	/**
488	* Converts clipboard data from CF_HTML format to MIME clipboard format.
489	*
490	* Returns allocated buffer that contains html converted to text/html mime type
491	*
492	* @returns VBox status code.
493	* @param pszSource The input.
494	* @param cch The length of the input.
495	* @param ppszOutput Where to return the result. Free using RTMemFree.
496	* @param pcbOutput Where to the return length of the result (bytes/chars).
497	*/
498	int SharedClipboardWinConvertCFHTMLToMIME(const char pszSource, const uint32_t cch, char ppszOutput, uint32_t pcbOutput)
499	{
500	Assert(pszSource);
501	Assert(cch);
502	Assert(ppszOutput);
503	Assert(pcbOutput);
504
505	uint32_t offStart;
506	int rc = SharedClipboardWinGetCFHTMLHeaderValue(pszSource, "StartFragment:", &offStart);
507	if (RT_SUCCESS(rc))
508	{
509	uint32_t offEnd;
510	rc = SharedClipboardWinGetCFHTMLHeaderValue(pszSource, "EndFragment:", &offEnd);
511	if (RT_SUCCESS(rc))
512	{
513	if ( offStart > 0
514	&& offEnd > 0
515	&& offEnd >= offStart
516	&& offEnd <= cch)
517	{
518	uint32_t cchSubStr = offEnd - offStart;
519	char pszResult = (char )RTMemAlloc(cchSubStr + 1);
520	if (pszResult)
521	{
522	rc = RTStrCopyEx(pszResult, cchSubStr + 1, pszSource + offStart, cchSubStr);
523	if (RT_SUCCESS(rc))
524	{
525	*ppszOutput = pszResult;
526	*pcbOutput = (uint32_t)(cchSubStr + 1);
527	rc = VINF_SUCCESS;
528	}
529	else
530	{
531	LogRelFlowFunc(("Error: Unknown CF_HTML format. Expected EndFragment. rc = %Rrc\n", rc));
532	RTMemFree(pszResult);
533	}
534	}
535	else
536	{
537	LogRelFlowFunc(("Error: Unknown CF_HTML format. Expected EndFragment\n"));
538	rc = VERR_NO_MEMORY;
539	}
540	}
541	else
542	{
543	LogRelFlowFunc(("Error: CF_HTML out of bounds - offStart=%#x offEnd=%#x cch=%#x\n", offStart, offEnd, cch));
544	rc = VERR_INVALID_PARAMETER;
545	}
546	}
547	else
548	{
549	LogRelFlowFunc(("Error: Unknown CF_HTML format. Expected EndFragment. rc = %Rrc\n", rc));
550	rc = VERR_INVALID_PARAMETER;
551	}
552	}
553	else
554	{
555	LogRelFlowFunc(("Error: Unknown CF_HTML format. Expected StartFragment. rc = %Rrc\n", rc));
556	rc = VERR_INVALID_PARAMETER;
557	}
558
559	return rc;
560	}
561
562	/**
563	* Converts source UTF-8 MIME HTML clipboard data to UTF-8 CF_HTML format.
564	*
565	* This is just encapsulation work, slapping a header on the data.
566	*
567	* It allocates [..]
568	*
569	* Calculations:
570	* Header length = format Length + (2*(10 - 5('%010d'))('digits')) - 2('%s') = format length + 8
571	* EndHtml = Header length + fragment length
572	* StartHtml = 105(constant)
573	* StartFragment = 141(constant) may vary if the header html content will be extended
574	* EndFragment = Header length + fragment length - 38(ending length)
575	*
576	* For more format details, check out:
577	* https://docs.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-developer/platform-apis/aa767917(v=vs.85)
578	*
579	* @returns VBox status code.
580	* @param pszSource Source buffer that contains utf-16 string in mime html format
581	* @param cb Size of source buffer in bytes
582	* @param ppszOutput Where to return the allocated output buffer to put converted UTF-8
583	* CF_HTML clipboard data. This function allocates memory for this.
584	* @param pcbOutput Where to return the size of allocated result buffer in bytes/chars, including zero terminator
585	*
586	* @note output buffer should be free using RTMemFree()
587	* @note Everything inside of fragment can be UTF8. Windows allows it. Everything in header should be Latin1.
588	*/
589	int SharedClipboardWinConvertMIMEToCFHTML(const char pszSource, size_t cb, char ppszOutput, uint32_t pcbOutput)
590	{
591	Assert(ppszOutput);
592	Assert(pcbOutput);
593	Assert(pszSource);
594	Assert(cb);
595
596	/*
597	* Check that input UTF-8 and properly zero terminated.
598	* Note! The zero termination may come earlier than 'cb' - 1, that's fine.
599	*/
600	int rc = RTStrValidateEncodingEx(pszSource, cb, RTSTR_VALIDATE_ENCODING_ZERO_TERMINATED);
601	if (RT_SUCCESS(rc))
602	{ /* likely */ }
603	else
604	{
605	LogRelFlowFunc(("Error: invalid source fragment. rc = %Rrc\n", rc));
606	return rc;
607	}
608	size_t const cchFragment = strlen(pszSource); /* Unfortunately the validator doesn't return the length. */
609
610	/*
611	* @StartHtml - Absolute offset of <html>
612	* @EndHtml - Size of the whole resulting text (excluding ending zero char)
613	* @StartFragment - Absolute position after <!--StartFragment-->
614	* @EndFragment - Absolute position of <!--EndFragment-->
615	*
616	* Note! The offset are zero padded to max width so we don't have any variations due to those.
617	* Note! All values includes CRLFs inserted into text.
618	*
619	* Calculations:
620	* Header length = Format sample length - 2 ('%s')
621	* EndHtml = Header length + fragment length
622	* StartHtml = 101(constant)
623	* StartFragment = 137(constant)
624	* EndFragment = Header length + fragment length - 38 (ending length)
625	*/
626	static const char s_szFormatSample[] =
627	/* 0: */ "Version:1.0\r\n"
628	/* 13: */ "StartHTML:000000101\r\n"
629	/* 34: */ "EndHTML:%0000009u\r\n" // END HTML = Header length + fragment length
630	/* 53: */ "StartFragment:000000137\r\n"
631	/* 78: */ "EndFragment:%0000009u\r\n"
632	/* 101: */ "<html>\r\n"
633	/* 109: */ "<body>\r\n"
634	/* 117: */ "<!--StartFragment-->"
635	/* 137: */ "%s"
636	/* 137+2: */ "<!--EndFragment-->\r\n"
637	/* 157+2: */ "</body>\r\n"
638	/* 166+2: */ "</html>\r\n"
639	/* 175+2: */ ;
640	AssertCompile(sizeof(s_szFormatSample) == 175 + 2 + 1);
641
642	/* Calculate parameters of the CF_HTML header */
643	size_t const cchHeader = sizeof(s_szFormatSample) - 2 /%s/ - 1 /'\0'/;
644	size_t const offEndHtml = cchHeader + cchFragment;
645	size_t const offEndFragment = cchHeader + cchFragment - 38; /* 175-137 = 38 */
646	char pszResult = (char )RTMemAlloc(offEndHtml + 1);
647	AssertLogRelReturn(pszResult, VERR_NO_MEMORY);
648
649	/* Format resulting CF_HTML string: */
650	size_t cchFormatted = RTStrPrintf(pszResult, offEndHtml + 1, s_szFormatSample, offEndHtml, offEndFragment, pszSource);
651	Assert(offEndHtml == cchFormatted);
652
653	#ifdef VBOX_STRICT
654	/*
655	* Check the calculations.
656	*/
657
658	/* check 'StartFragment:' value */
659	static const char s_szStartFragment[] = "<!--StartFragment-->";
660	const char *pszRealStartFragment = RTStrStr(pszResult, s_szStartFragment);
661	Assert(&pszRealStartFragment[sizeof(s_szStartFragment) - 1] - pszResult == 137);
662
663	/* check 'EndFragment:' value */
664	static const char s_szEndFragment[] = "<!--EndFragment-->";
665	const char *pszRealEndFragment = RTStrStr(pszResult, s_szEndFragment);
666	Assert((size_t)(pszRealEndFragment - pszResult) == offEndFragment);
667	#endif
668
669	*ppszOutput = pszResult;
670	*pcbOutput = (uint32_t)cchFormatted + 1;
671	Assert(*pcbOutput == cchFormatted + 1);
672
673	return VINF_SUCCESS;
674	}
675
676	/**
677	* Handles the WM_CHANGECBCHAIN code.
678	*
679	* @returns LRESULT
680	* @param pWinCtx Windows context to use.
681	* @param hWnd Window handle to use.
682	* @param msg Message ID to pass on.
683	* @param wParam wParam to pass on
684	* @param lParam lParam to pass on.
685	*/
686	LRESULT SharedClipboardWinHandleWMChangeCBChain(PSHCLWINCTX pWinCtx,
687	HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
688	{
689	LRESULT lresultRc = 0;
690
691	LogFlowFuncEnter();
692
693	if (SharedClipboardWinIsNewAPI(&pWinCtx->newAPI))
694	{
695	lresultRc = DefWindowProc(hWnd, msg, wParam, lParam);
696	}
697	else /* Old API */
698	{
699	HWND hwndRemoved = (HWND)wParam;
700	HWND hwndNext = (HWND)lParam;
701
702	if (hwndRemoved == pWinCtx->hWndNextInChain)
703	{
704	/* The window that was next to our in the chain is being removed.
705	* Relink to the new next window.
706	*/
707	pWinCtx->hWndNextInChain = hwndNext;
708	}
709	else
710	{
711	if (pWinCtx->hWndNextInChain)
712	{
713	/* Pass the message further. */
714	DWORD_PTR dwResult;
715	lresultRc = SendMessageTimeout(pWinCtx->hWndNextInChain, WM_CHANGECBCHAIN, wParam, lParam, 0,
716	SHCL_WIN_CBCHAIN_TIMEOUT_MS,
717	&dwResult);
718	if (!lresultRc)
719	lresultRc = (LRESULT)dwResult;
720	}
721	}
722	}
723
724	LogFlowFunc(("lresultRc=%ld\n", lresultRc));
725	return lresultRc;
726	}
727
728	/**
729	* Handles the WM_DESTROY code.
730	*
731	* @returns VBox status code.
732	* @param pWinCtx Windows context to use.
733	*/
734	int SharedClipboardWinHandleWMDestroy(PSHCLWINCTX pWinCtx)
735	{
736	LogFlowFuncEnter();
737
738	int rc = VINF_SUCCESS;
739
740	/* MS recommends to remove from Clipboard chain in this callback. */
741	SharedClipboardWinChainRemove(pWinCtx);
742
743	if (pWinCtx->oldAPI.timerRefresh)
744	{
745	Assert(pWinCtx->hWnd);
746	KillTimer(pWinCtx->hWnd, 0);
747	}
748
749	LogFlowFuncLeaveRC(rc);
750	return rc;
751	}
752
753	/**
754	* Handles the WM_RENDERALLFORMATS message.
755	*
756	* @returns VBox status code.
757	* @param pWinCtx Windows context to use.
758	* @param hWnd Window handle to use.
759	*/
760	int SharedClipboardWinHandleWMRenderAllFormats(PSHCLWINCTX pWinCtx, HWND hWnd)
761	{
762	RT_NOREF(pWinCtx);
763
764	LogFlowFuncEnter();
765
766	/* Do nothing. The clipboard formats will be unavailable now, because the
767	* windows is to be destroyed and therefore the guest side becomes inactive.
768	*/
769	int rc = SharedClipboardWinOpen(hWnd);
770	if (RT_SUCCESS(rc))
771	{
772	SharedClipboardWinClear();
773	SharedClipboardWinClose();
774	}
775
776	LogFlowFuncLeaveRC(rc);
777	return rc;
778	}
779
780	/**
781	* Handles the WM_TIMER code, which is needed if we're running with the so-called "old" Windows clipboard API.
782	* Does nothing if we're running with the "new" Windows API.
783	*
784	* @returns VBox status code.
785	* @param pWinCtx Windows context to use.
786	*/
787	int SharedClipboardWinHandleWMTimer(PSHCLWINCTX pWinCtx)
788	{
789	int rc = VINF_SUCCESS;
790
791	if (!SharedClipboardWinIsNewAPI(&pWinCtx->newAPI)) /* Only run when using the "old" Windows API. */
792	{
793	LogFlowFuncEnter();
794
795	HWND hViewer = GetClipboardViewer();
796
797	/* Re-register ourselves in the clipboard chain if our last ping
798	* timed out or there seems to be no valid chain. */
799	if (!hViewer \|\| pWinCtx->oldAPI.fCBChainPingInProcess)
800	{
801	SharedClipboardWinChainRemove(pWinCtx);
802	SharedClipboardWinChainAdd(pWinCtx);
803	}
804
805	/* Start a new ping by passing a dummy WM_CHANGECBCHAIN to be
806	* processed by ourselves to the chain. */
807	pWinCtx->oldAPI.fCBChainPingInProcess = TRUE;
808
809	hViewer = GetClipboardViewer();
810	if (hViewer)
811	SendMessageCallback(hViewer, WM_CHANGECBCHAIN, (WPARAM)pWinCtx->hWndNextInChain, (LPARAM)pWinCtx->hWndNextInChain,
812	SharedClipboardWinChainPingProc, (ULONG_PTR)pWinCtx);
813	}
814
815	LogFlowFuncLeaveRC(rc);
816	return rc;
817	}
818
819	/**
820	* Announces a clipboard format to the Windows clipboard.
821	*
822	* The actual rendering (setting) of the clipboard data will be done later with
823	* a separate WM_RENDERFORMAT message.
824	*
825	* @returns VBox status code. VERR_NOT_SUPPORTED if the format is not supported / handled.
826	* @param pWinCtx Windows context to use.
827	* @param fFormats Clipboard format(s) to announce.
828	*/
829	static int sharedClipboardWinAnnounceFormats(PSHCLWINCTX pWinCtx, SHCLFORMATS fFormats)
830	{
831	LogFunc(("fFormats=0x%x\n", fFormats));
832
833	/*
834	* Set the clipboard formats.
835	*/
836	static struct
837	{
838	uint32_t fVBoxFormat;
839	UINT uWinFormat;
840	const char *pszWinFormat;
841	const char *pszLog;
842	} s_aFormats[] =
843	{
844	{ VBOX_SHCL_FMT_UNICODETEXT, CF_UNICODETEXT, NULL, "CF_UNICODETEXT" },
845	{ VBOX_SHCL_FMT_BITMAP, CF_DIB, NULL, "CF_DIB" },
846	{ VBOX_SHCL_FMT_HTML, 0, SHCL_WIN_REGFMT_HTML, "SHCL_WIN_REGFMT_HTML" },
847	};
848	unsigned cSuccessfullySet = 0;
849	SHCLFORMATS fFormatsLeft = fFormats;
850	int rc = VINF_SUCCESS;
851	for (uintptr_t i = 0; i < RT_ELEMENTS(s_aFormats) && fFormatsLeft != 0; i++)
852	{
853	if (fFormatsLeft & s_aFormats[i].fVBoxFormat)
854	{
855	LogFunc(("%s\n", s_aFormats[i].pszLog));
856	fFormatsLeft &= ~s_aFormats[i].fVBoxFormat;
857
858	/* Reg format if needed: */
859	UINT uWinFormat = s_aFormats[i].uWinFormat;
860	if (!uWinFormat)
861	{
862	uWinFormat = RegisterClipboardFormat(s_aFormats[i].pszWinFormat);
863	AssertContinue(uWinFormat != 0);
864	}
865
866	/* Tell the clipboard we've got data upon a request. We check the
867	last error here as hClip will be NULL even on success (despite
868	what MSDN says). */
869	SetLastError(NO_ERROR);
870	HANDLE hClip = SetClipboardData(uWinFormat, NULL);
871	DWORD dwErr = GetLastError();
872	if (dwErr == NO_ERROR \|\| hClip != NULL)
873	cSuccessfullySet++;
874	else
875	{
876	AssertMsgFailed(("%s/%u: %u\n", s_aFormats[i].pszLog, uWinFormat, dwErr));
877	rc = RTErrConvertFromWin32(dwErr);
878	}
879	}
880	}
881
882	/*
883	* Consider setting anything a success, converting any error into
884	* informational status. Unsupport error only happens if all formats
885	* were unsupported.
886	*/
887	if (cSuccessfullySet > 0)
888	{
889	pWinCtx->hWndClipboardOwnerUs = GetClipboardOwner();
890	if (RT_FAILURE(rc))
891	rc = -rc;
892	}
893	else if (RT_SUCCESS(rc) && fFormatsLeft != 0)
894	{
895	LogFunc(("Unsupported formats: %#x (%#x)\n", fFormatsLeft, fFormats));
896	rc = VERR_NOT_SUPPORTED;
897	}
898
899	LogFlowFuncLeaveRC(rc);
900	return rc;
901	}
902
903	/**
904	* Opens the clipboard, clears it, announces @a fFormats and closes it.
905	*
906	* The actual rendering (setting) of the clipboard data will be done later with
907	* a separate WM_RENDERFORMAT message.
908	*
909	* @returns VBox status code. VERR_NOT_SUPPORTED if the format is not supported / handled.
910	* @param pWinCtx Windows context to use.
911	* @param fFormats Clipboard format(s) to announce.
912	* @param hWnd The window handle to use as owner.
913	*/
914	int SharedClipboardWinClearAndAnnounceFormats(PSHCLWINCTX pWinCtx, SHCLFORMATS fFormats, HWND hWnd)
915	{
916	int rc = SharedClipboardWinOpen(hWnd);
917	if (RT_SUCCESS(rc))
918	{
919	SharedClipboardWinClear();
920
921	rc = sharedClipboardWinAnnounceFormats(pWinCtx, fFormats);
922	Assert(pWinCtx->hWndClipboardOwnerUs == hWnd \|\| pWinCtx->hWndClipboardOwnerUs == NULL);
923
924	SharedClipboardWinClose();
925	}
926	return rc;
927	}
928
929	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
930
931	/**
932	* Creates an Shared Clipboard transfer by announcing transfer data (via IDataObject) to Windows.
933	*
934	* This creates the necessary IDataObject + IStream implementations and initiates the actual transfers required for getting
935	* the meta data. Whether or not the actual (file++) transfer(s) are happening is up to the user (at some point) later then.
936	*
937	* @returns VBox status code.
938	* @param pWinCtx Windows context to use.
939	* @param pTransferCtxCtx Transfer contextto use.
940	* @param pTransfer Shared Clipboard transfer to use.
941	*/
942	int SharedClipboardWinTransferCreate(PSHCLWINCTX pWinCtx, PSHCLTRANSFER pTransfer)
943	{
944	AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
945
946	LogFlowFunc(("pWinCtx=%p\n", pWinCtx));
947
948	AssertReturn(pTransfer->pvUser == NULL, VERR_WRONG_ORDER);
949
950	/* Make sure to enter the critical section before setting the clipboard data, as otherwise WM_CLIPBOARDUPDATE
951	* might get called before we had the opportunity to set pWinCtx->hWndClipboardOwnerUs below. */
952	int rc = RTCritSectEnter(&pWinCtx->CritSect);
953	if (RT_SUCCESS(rc))
954	{
955	SharedClipboardWinTransferCtx *pWinURITransferCtx = new SharedClipboardWinTransferCtx();
956	if (pWinURITransferCtx)
957	{
958	pTransfer->pvUser = pWinURITransferCtx;
959	pTransfer->cbUser = sizeof(SharedClipboardWinTransferCtx);
960
961	pWinURITransferCtx->pDataObj = new SharedClipboardWinDataObject(pTransfer);
962	if (pWinURITransferCtx->pDataObj)
963	{
964	rc = pWinURITransferCtx->pDataObj->Init();
965	if (RT_SUCCESS(rc))
966	{
967	SharedClipboardWinClose();
968	/* Note: Clipboard must be closed first before calling OleSetClipboard(). */
969
970	/** @todo There is a potential race between SharedClipboardWinClose() and OleSetClipboard(),
971	* where another application could own the clipboard (open), and thus the call to
972	* OleSetClipboard() will fail. Needs (better) fixing. */
973	HRESULT hr = S_OK;
974
975	for (unsigned uTries = 0; uTries < 3; uTries++)
976	{
977	hr = OleSetClipboard(pWinURITransferCtx->pDataObj);
978	if (SUCCEEDED(hr))
979	{
980	Assert(OleIsCurrentClipboard(pWinURITransferCtx->pDataObj) == S_OK); /* Sanity. */
981
982	/*
983	* Calling OleSetClipboard() changed the clipboard owner, which in turn will let us receive
984	* a WM_CLIPBOARDUPDATE message. To not confuse ourselves with our own clipboard owner changes,
985	* save a new window handle and deal with it in WM_CLIPBOARDUPDATE.
986	*/
987	pWinCtx->hWndClipboardOwnerUs = GetClipboardOwner();
988
989	LogFlowFunc(("hWndClipboardOwnerUs=%p\n", pWinCtx->hWndClipboardOwnerUs));
990	break;
991	}
992
993	LogFlowFunc(("Failed with %Rhrc (try %u/3)\n", hr, uTries + 1));
994	RTThreadSleep(500); /* Wait a bit. */
995	}
996
997	if (FAILED(hr))
998	{
999	rc = VERR_ACCESS_DENIED; /** @todo Fudge; fix this. */
1000	LogRel(("Shared Clipboard: Failed with %Rhrc when setting data object to clipboard\n", hr));
1001	}
1002	}
1003	}
1004	else
1005	rc = VERR_NO_MEMORY;
1006	}
1007	else
1008	rc = VERR_NO_MEMORY;
1009
1010	int rc2 = RTCritSectLeave(&pWinCtx->CritSect);
1011	AssertRC(rc2);
1012	}
1013
1014	LogFlowFuncLeaveRC(rc);
1015	return rc;
1016	}
1017
1018	/**
1019	* Destroys implementation-specific data for an Shared Clipboard transfer.
1020	*
1021	* @param pWinCtx Windows context to use.
1022	* @param pTransfer Shared Clipboard transfer to create implementation-specific data for.
1023	*/
1024	void SharedClipboardWinTransferDestroy(PSHCLWINCTX pWinCtx, PSHCLTRANSFER pTransfer)
1025	{
1026	RT_NOREF(pWinCtx);
1027
1028	if (!pTransfer)
1029	return;
1030
1031	LogFlowFuncEnter();
1032
1033	if (pTransfer->pvUser)
1034	{
1035	Assert(pTransfer->cbUser == sizeof(SharedClipboardWinTransferCtx));
1036	SharedClipboardWinTransferCtx pWinURITransferCtx = (SharedClipboardWinTransferCtx )pTransfer->pvUser;
1037	Assert(pWinURITransferCtx);
1038
1039	if (pWinURITransferCtx->pDataObj)
1040	{
1041	delete pWinURITransferCtx->pDataObj;
1042	pWinURITransferCtx->pDataObj = NULL;
1043	}
1044
1045	delete pWinURITransferCtx;
1046
1047	pTransfer->pvUser = NULL;
1048	pTransfer->cbUser = 0;
1049	}
1050	}
1051
1052	/**
1053	* Retrieves the roots for a transfer by opening the clipboard and getting the clipboard data
1054	* as string list (CF_HDROP), assigning it to the transfer as roots then.
1055	*
1056	* @returns VBox status code.
1057	* @param pWinCtx Windows context to use.
1058	* @param pTransfer Transfer to get roots for.
1059	*/
1060	int SharedClipboardWinGetRoots(PSHCLWINCTX pWinCtx, PSHCLTRANSFER pTransfer)
1061	{
1062	AssertPtrReturn(pWinCtx, VERR_INVALID_POINTER);
1063	AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
1064
1065	Assert(ShClTransferGetSource(pTransfer) == SHCLSOURCE_LOCAL); /* Sanity. */
1066
1067	int rc = SharedClipboardWinOpen(pWinCtx->hWnd);
1068	if (RT_SUCCESS(rc))
1069	{
1070	/* The data data in CF_HDROP format, as the files are locally present and don't need to be
1071	* presented as a IDataObject or IStream. */
1072	HANDLE hClip = hClip = GetClipboardData(CF_HDROP);
1073	if (hClip)
1074	{
1075	HDROP hDrop = (HDROP)GlobalLock(hClip);
1076	if (hDrop)
1077	{
1078	char *papszList = NULL;
1079	uint32_t cbList;
1080	rc = SharedClipboardWinDropFilesToStringList((DROPFILES *)hDrop, &papszList, &cbList);
1081
1082	GlobalUnlock(hClip);
1083
1084	if (RT_SUCCESS(rc))
1085	{
1086	rc = ShClTransferRootsSet(pTransfer,
1087	papszList, cbList + 1 /* Include termination */);
1088	RTStrFree(papszList);
1089	}
1090	}
1091	else
1092	LogRel(("Shared Clipboard: Unable to lock clipboard data, last error: %ld\n", GetLastError()));
1093	}
1094	else
1095	LogRel(("Shared Clipboard: Unable to retrieve clipboard data from clipboard (CF_HDROP), last error: %ld\n",
1096	GetLastError()));
1097
1098	SharedClipboardWinClose();
1099	}
1100
1101	LogFlowFuncLeaveRC(rc);
1102	return rc;
1103	}
1104
1105	/**
1106	* Converts a DROPFILES (HDROP) structure to a string list, separated by \r\n.
1107	* Does not do any locking on the input data.
1108	*
1109	* @returns VBox status code.
1110	* @param pDropFiles Pointer to DROPFILES structure to convert.
1111	* @param papszList Where to store the allocated string list.
1112	* @param pcbList Where to store the size (in bytes) of the allocated string list.
1113	*/
1114	int SharedClipboardWinDropFilesToStringList(DROPFILES pDropFiles, char papszList, uint32_t pcbList)
1115	{
1116	AssertPtrReturn(pDropFiles, VERR_INVALID_POINTER);
1117	AssertPtrReturn(papszList, VERR_INVALID_POINTER);
1118	AssertPtrReturn(pcbList, VERR_INVALID_POINTER);
1119
1120	/* Do we need to do Unicode stuff? */
1121	const bool fUnicode = RT_BOOL(pDropFiles->fWide);
1122
1123	/* Get the offset of the file list. */
1124	Assert(pDropFiles->pFiles >= sizeof(DROPFILES));
1125
1126	/* Note: This is not pDropFiles->pFiles! DragQueryFile only
1127	* will work with the plain storage medium pointer! */
1128	HDROP hDrop = (HDROP)(pDropFiles);
1129
1130	int rc = VINF_SUCCESS;
1131
1132	/* First, get the file count. */
1133	/** @todo Does this work on Windows 2000 / NT4? */
1134	char *pszFiles = NULL;
1135	uint32_t cchFiles = 0;
1136	UINT cFiles = DragQueryFile(hDrop, UINT32_MAX /* iFile /, NULL / lpszFile /, 0 / cchFile */);
1137
1138	LogFlowFunc(("Got %RU16 file(s), fUnicode=%RTbool\n", cFiles, fUnicode));
1139
1140	for (UINT i = 0; i < cFiles; i++)
1141	{
1142	UINT cchFile = DragQueryFile(hDrop, i /* File index /, NULL / Query size first /, 0 / cchFile */);
1143	Assert(cchFile);
1144
1145	if (RT_FAILURE(rc))
1146	break;
1147
1148	char pszFileUtf8 = NULL; / UTF-8 version. */
1149	UINT cchFileUtf8 = 0;
1150	if (fUnicode)
1151	{
1152	/* Allocate enough space (including terminator). */
1153	WCHAR pwszFile = (WCHAR )RTMemAlloc((cchFile + 1) * sizeof(WCHAR));
1154	if (pwszFile)
1155	{
1156	const UINT cwcFileUtf16 = DragQueryFileW(hDrop, i /* File index */,
1157	pwszFile, cchFile + 1 /* Include terminator */);
1158
1159	AssertMsg(cwcFileUtf16 == cchFile, ("cchFileUtf16 (%RU16) does not match cchFile (%RU16)\n",
1160	cwcFileUtf16, cchFile));
1161	RT_NOREF(cwcFileUtf16);
1162
1163	rc = RTUtf16ToUtf8(pwszFile, &pszFileUtf8);
1164	if (RT_SUCCESS(rc))
1165	{
1166	cchFileUtf8 = (UINT)strlen(pszFileUtf8);
1167	Assert(cchFileUtf8);
1168	}
1169
1170	RTMemFree(pwszFile);
1171	}
1172	else
1173	rc = VERR_NO_MEMORY;
1174	}
1175	else /* ANSI */
1176	{
1177	/* Allocate enough space (including terminator). */
1178	char pszFileANSI = (char )RTMemAlloc((cchFile + 1) * sizeof(char));
1179	UINT cchFileANSI = 0;
1180	if (pszFileANSI)
1181	{
1182	cchFileANSI = DragQueryFileA(hDrop, i /* File index */,
1183	pszFileANSI, cchFile + 1 /* Include terminator */);
1184
1185	AssertMsg(cchFileANSI == cchFile, ("cchFileANSI (%RU16) does not match cchFile (%RU16)\n",
1186	cchFileANSI, cchFile));
1187
1188	/* Convert the ANSI codepage to UTF-8. */
1189	rc = RTStrCurrentCPToUtf8(&pszFileUtf8, pszFileANSI);
1190	if (RT_SUCCESS(rc))
1191	{
1192	cchFileUtf8 = (UINT)strlen(pszFileUtf8);
1193	}
1194	}
1195	else
1196	rc = VERR_NO_MEMORY;
1197	}
1198
1199	if (RT_SUCCESS(rc))
1200	{
1201	LogFlowFunc(("\tFile: %s (cchFile=%RU16)\n", pszFileUtf8, cchFileUtf8));
1202
1203	LogRel2(("Shared Clipboard: Adding file '%s' to transfer\n", pszFileUtf8));
1204
1205	rc = RTStrAAppendExN(&pszFiles, 1 /* cPairs */, pszFileUtf8, strlen(pszFileUtf8));
1206	cchFiles += (uint32_t)strlen(pszFileUtf8);
1207	}
1208
1209	if (pszFileUtf8)
1210	RTStrFree(pszFileUtf8);
1211
1212	if (RT_FAILURE(rc))
1213	{
1214	LogFunc(("Error handling file entry #%u, rc=%Rrc\n", i, rc));
1215	break;
1216	}
1217
1218	/* Add separation between filenames.
1219	* Note: Also do this for the last element of the list. */
1220	rc = RTStrAAppendExN(&pszFiles, 1 /* cPairs /, "\r\n", 2 / Bytes */);
1221	if (RT_SUCCESS(rc))
1222	cchFiles += 2; /* Include \r\n */
1223	}
1224
1225	if (RT_SUCCESS(rc))
1226	{
1227	cchFiles += 1; /* Add string termination. */
1228	uint32_t cbFiles = cchFiles * sizeof(char); /* UTF-8. */
1229
1230	LogFlowFunc(("cFiles=%u, cchFiles=%RU32, cbFiles=%RU32, pszFiles=0x%p\n",
1231	cFiles, cchFiles, cbFiles, pszFiles));
1232
1233	*papszList = pszFiles;
1234	*pcbList = cbFiles;
1235	}
1236	else
1237	{
1238	if (pszFiles)
1239	RTStrFree(pszFiles);
1240	}
1241
1242	LogFlowFuncLeaveRC(rc);
1243	return rc;
1244	}
1245
1246	#endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
1247

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

source: vbox/trunk/src/VBox/GuestHost/SharedClipboard/clipboard-win.cpp@ 94490

Download in other formats: