clipboard-x11.cpp@ 106945

Last change on this file since 106945 was 106061, checked in by vboxsync, 3 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 99.3 KB

Line
1	/** @file
2	* Shared Clipboard: Common X11 code.
3	*/
4
5	/*
6	* Copyright (C) 2006-2024 Oracle and/or its affiliates.
7	*
8	* This file is part of VirtualBox base platform packages, as
9	* available from https://www.virtualbox.org.
10	*
11	* This program is free software; you can redistribute it and/or
12	* modify it under the terms of the GNU General Public License
13	* as published by the Free Software Foundation, in version 3 of the
14	* License.
15	*
16	* This program is distributed in the hope that it will be useful, but
17	* WITHOUT ANY WARRANTY; without even the implied warranty of
18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19	* General Public License for more details.
20	*
21	* You should have received a copy of the GNU General Public License
22	* along with this program; if not, see <https://www.gnu.org/licenses>.
23	*
24	* SPDX-License-Identifier: GPL-3.0-only
25	*/
26
27	/* Note: to automatically run regression tests on the Shared Clipboard,
28	* execute the tstClipboardGH-X11 testcase. If you often make changes to the
29	* clipboard code, adding the line
30	*
31	* OTHERS += $(PATH_tstClipboardGH-X11)/tstClipboardGH-X11.run
32	*
33	* to LocalConfig.kmk will cause the tests to be run every time the code is
34	* changed.
35	*/
36
37
38	/*********************************************************************************************************************************
39	* Header Files *
40	*********************************************************************************************************************************/
41	#define LOG_GROUP LOG_GROUP_SHARED_CLIPBOARD
42
43	#include <errno.h>
44
45	#include <dlfcn.h>
46	#include <fcntl.h>
47	#include <unistd.h>
48
49	#ifdef RT_OS_SOLARIS
50	#include <tsol/label.h>
51	#endif
52
53	#include <X11/Xlib.h>
54	#include <X11/Xatom.h>
55	#include <X11/Intrinsic.h>
56	#include <X11/Shell.h>
57	#include <X11/Xproto.h>
58	#include <X11/StringDefs.h>
59
60	#include <iprt/assert.h>
61	#include <iprt/types.h>
62	#include <iprt/mem.h>
63	#include <iprt/semaphore.h>
64	#include <iprt/thread.h>
65	#include <iprt/utf16.h>
66	#include <iprt/uri.h>
67
68	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
69	# include <iprt/cpp/list.h>
70	# include <iprt/cpp/ministring.h>
71	# include <VBox/GuestHost/SharedClipboard-transfers.h>
72	#endif
73
74	#include <VBox/log.h>
75	#include <VBox/version.h>
76
77	#include <VBox/GuestHost/SharedClipboard.h>
78	#include <VBox/GuestHost/SharedClipboard-x11.h>
79	#include <VBox/GuestHost/clipboard-helper.h>
80	#include <VBox/HostServices/VBoxClipboardSvc.h>
81
82	/** Own macro for declaring function visibility / linkage based on whether this
83	* code runs as part of test cases or not. */
84	#ifdef TESTCASE
85	# define SHCL_X11_DECL(x) x
86	#else
87	# define SHCL_X11_DECL(x) static x
88	#endif
89
90
91	/*********************************************************************************************************************************
92	* Externals *
93	*********************************************************************************************************************************/
94	#ifdef TESTCASE
95	extern void tstThreadScheduleCall(void (proc)(void , void ), void client_data);
96	extern void tstClipRequestData(SHCLX11CTX* pCtx, SHCLX11FMTIDX target, void *closure);
97	extern void tstRequestTargets(SHCLX11CTX* pCtx);
98	#endif
99
100
101	/*********************************************************************************************************************************
102	* Prototypes *
103	*********************************************************************************************************************************/
104	class formats;
105	SHCL_X11_DECL(Atom) clipGetAtom(PSHCLX11CTX pCtx, const char *pszName);
106	SHCL_X11_DECL(void) clipQueryX11Targets(PSHCLX11CTX pCtx);
107
108	static int clipInitInternal(PSHCLX11CTX pCtx);
109	static void clipUninitInternal(PSHCLX11CTX pCtx);
110
111
112	/*********************************************************************************************************************************
113	* Global Variables *
114	*********************************************************************************************************************************/
115
116	/**
117	* The table maps X11 names to data formats
118	* and to the corresponding VBox clipboard formats.
119	*/
120	SHCL_X11_DECL(SHCLX11FMTTABLE) g_aFormats[] =
121	{
122	{ "INVALID", SHCLX11FMT_INVALID, VBOX_SHCL_FMT_NONE },
123
124	{ "UTF8_STRING", SHCLX11FMT_UTF8, VBOX_SHCL_FMT_UNICODETEXT },
125	{ "text/plain;charset=UTF-8", SHCLX11FMT_UTF8, VBOX_SHCL_FMT_UNICODETEXT },
126	{ "text/plain;charset=utf-8", SHCLX11FMT_UTF8, VBOX_SHCL_FMT_UNICODETEXT },
127	{ "STRING", SHCLX11FMT_TEXT, VBOX_SHCL_FMT_UNICODETEXT },
128	{ "TEXT", SHCLX11FMT_TEXT, VBOX_SHCL_FMT_UNICODETEXT },
129	{ "text/plain", SHCLX11FMT_TEXT, VBOX_SHCL_FMT_UNICODETEXT },
130
131	{ "text/html", SHCLX11FMT_HTML, VBOX_SHCL_FMT_HTML },
132	{ "text/html;charset=utf-8", SHCLX11FMT_HTML, VBOX_SHCL_FMT_HTML },
133	{ "application/x-moz-nativehtml", SHCLX11FMT_HTML, VBOX_SHCL_FMT_HTML },
134
135	{ "image/bmp", SHCLX11FMT_BMP, VBOX_SHCL_FMT_BITMAP },
136	{ "image/x-bmp", SHCLX11FMT_BMP, VBOX_SHCL_FMT_BITMAP },
137	{ "image/x-MS-bmp", SHCLX11FMT_BMP, VBOX_SHCL_FMT_BITMAP },
138	/** @todo Inkscape exports image/png but not bmp... */
139
140	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
141	{ "text/uri-list", SHCLX11FMT_URI_LIST, VBOX_SHCL_FMT_URI_LIST },
142	{ "x-special/gnome-copied-files", SHCLX11FMT_URI_LIST_GNOME_COPIED_FILES, VBOX_SHCL_FMT_URI_LIST },
143	{ "x-special/mate-copied-files", SHCLX11FMT_URI_LIST_MATE_COPIED_FILES, VBOX_SHCL_FMT_URI_LIST },
144	{ "x-special/nautilus-clipboard", SHCLX11FMT_URI_LIST_NAUTILUS_CLIPBOARD, VBOX_SHCL_FMT_URI_LIST },
145	{ "application/x-kde-cutselection", SHCLX11FMT_URI_LIST_KDE_CUTSELECTION, VBOX_SHCL_FMT_URI_LIST },
146	/** @todo Anything else we need to add here? */
147	/** @todo Add Wayland / Weston support. */
148	#endif
149	};
150
151
152	#ifdef TESTCASE
153	# ifdef RT_OS_SOLARIS_10
154	char XtStrings [] = "";
155	WidgetClassRec* applicationShellWidgetClass;
156	char XtShellStrings [] = "";
157	int XmbTextPropertyToTextList(
158	Display* /* display */,
159	XTextProperty* /* text_prop */,
160	char*** /* list_return */,
161	int* /* count_return */
162	)
163	{
164	return 0;
165	}
166	# else /* !RT_OS_SOLARIS_10 */
167	const char XtStrings [] = "";
168	_WidgetClassRec* applicationShellWidgetClass;
169	const char XtShellStrings [] = "";
170	# endif /* RT_OS_SOLARIS_10 */
171	#else /* !TESTCASE */
172	# ifdef VBOX_WITH_VBOXCLIENT_LAZY_LOAD
173	/* Defines needed for lazy loading global data from the shared objects (.so).
174	* See r157060. */
175	DECLASM(WidgetClass * ) LazyGetPtr_applicationShellWidgetClass(void);
176	#define applicationShellWidgetClass (*LazyGetPtr_applicationShellWidgetClass())
177	DECLASM(const char *) LazyGetPtr_XtStrings(void);
178	#define XtStrings (LazyGetPtr_XtStrings())
179	# endif
180	#endif /* TESTCASE */
181
182
183	/*********************************************************************************************************************************
184	* Defines *
185	*********************************************************************************************************************************/
186
187	#define SHCL_MAX_X11_FORMATS RT_ELEMENTS(g_aFormats)
188
189
190	/*********************************************************************************************************************************
191	* Internal structures *
192	*********************************************************************************************************************************/
193
194	#ifdef TESTCASE
195	/**
196	* Return the max. number of elements in the X11 format table.
197	* Used by the testing code in tstClipboardGH-X11.cpp
198	* which cannot use RT_ELEMENTS(g_aFormats) directly.
199	*
200	* @return size_t The number of elements in the g_aFormats array.
201	*/
202	SHCL_X11_DECL(size_t) clipReportMaxX11Formats(void)
203	{
204	return (RT_ELEMENTS(g_aFormats));
205	}
206	#endif
207
208	/**
209	* Returns the atom corresponding to a supported X11 format.
210	*
211	* @returns Found atom to the corresponding X11 format.
212	* @param pCtx The X11 clipboard context to use.
213	* @param uFmtIdx Format index to look up atom for.
214	*/
215	static Atom clipAtomForX11Format(PSHCLX11CTX pCtx, SHCLX11FMTIDX uFmtIdx)
216	{
217	AssertReturn(uFmtIdx < RT_ELEMENTS(g_aFormats), 0);
218	return clipGetAtom(pCtx, g_aFormats[uFmtIdx].pcszAtom);
219	}
220
221	/**
222	* Returns the SHCLX11FMT corresponding to a supported X11 format.
223	*
224	* @return SHCLX11FMT for a specific format index.
225	* @param uFmtIdx Format index to look up SHCLX11CLIPFMT for.
226	*/
227	SHCL_X11_DECL(SHCLX11FMT) clipRealFormatForX11Format(SHCLX11FMTIDX uFmtIdx)
228	{
229	AssertReturn(uFmtIdx < RT_ELEMENTS(g_aFormats), SHCLX11FMT_INVALID);
230	return g_aFormats[uFmtIdx].enmFmtX11;
231	}
232
233	/**
234	* Returns the VBox format corresponding to a supported X11 format.
235	*
236	* @return SHCLFORMAT for a specific format index.
237	* @param uFmtIdx Format index to look up VBox format for.
238	*/
239	static SHCLFORMAT clipVBoxFormatForX11Format(SHCLX11FMTIDX uFmtIdx)
240	{
241	AssertReturn(uFmtIdx < RT_ELEMENTS(g_aFormats), VBOX_SHCL_FMT_NONE);
242	return g_aFormats[uFmtIdx].uFmtVBox;
243	}
244
245	/**
246	* Looks up the X11 format matching a given X11 atom.
247	*
248	* @returns The format on success, NIL_CLIPX11FORMAT on failure.
249	* @param pCtx The X11 clipboard context to use.
250	* @param atomFormat Atom to look up X11 format for.
251	*/
252	static SHCLX11FMTIDX clipFindX11FormatByAtom(PSHCLX11CTX pCtx, Atom atomFormat)
253	{
254	for (unsigned i = 0; i < RT_ELEMENTS(g_aFormats); ++i)
255	if (clipAtomForX11Format(pCtx, i) == atomFormat)
256	{
257	LogFlowFunc(("Returning index %u for atom '%s'\n", i, g_aFormats[i].pcszAtom));
258	return i;
259	}
260	return NIL_CLIPX11FORMAT;
261	}
262
263	/**
264	* Enumerates supported X11 clipboard formats corresponding to given VBox formats.
265	*
266	* @returns The next matching X11 format index in the list, or NIL_CLIPX11FORMAT if there are no more.
267	* @param uFormatsVBox VBox formats to enumerate supported X11 clipboard formats for.
268	* @param lastFmtIdx The value returned from the last call of this function.
269	* Use NIL_CLIPX11FORMAT to start the enumeration.
270	*/
271	static SHCLX11FMTIDX clipEnumX11Formats(SHCLFORMATS uFormatsVBox,
272	SHCLX11FMTIDX lastFmtIdx)
273	{
274	for (unsigned i = lastFmtIdx + 1; i < RT_ELEMENTS(g_aFormats); ++i)
275	{
276	if (uFormatsVBox & clipVBoxFormatForX11Format(i))
277	return i;
278	}
279
280	return NIL_CLIPX11FORMAT;
281	}
282
283	/**
284	* Array of structures for mapping Xt widgets to context pointers. We
285	* need this because the widget clipboard callbacks do not pass user data.
286	*/
287	static struct
288	{
289	/** Pointer to widget we want to associate the context with. */
290	Widget pWidget;
291	/** Pointer to X11 context associated with the widget. */
292	PSHCLX11CTX pCtx;
293	} g_aContexts[VBOX_SHARED_CLIPBOARD_X11_CONNECTIONS_MAX];
294
295	/**
296	* Registers a new X11 clipboard context.
297	*
298	* @returns VBox status code.
299	* @param pCtx The X11 clipboard context to use.
300	*/
301	static int clipRegisterContext(PSHCLX11CTX pCtx)
302	{
303	AssertPtrReturn(pCtx, VERR_INVALID_PARAMETER);
304
305	bool fFound = false;
306
307	Widget pWidget = pCtx->pWidget;
308	AssertReturn(pWidget != NULL, VERR_INVALID_PARAMETER);
309
310	for (unsigned i = 0; i < RT_ELEMENTS(g_aContexts); ++i)
311	{
312	AssertReturn( (g_aContexts[i].pWidget != pWidget)
313	&& (g_aContexts[i].pCtx != pCtx), VERR_WRONG_ORDER);
314	if (g_aContexts[i].pWidget == NULL && !fFound)
315	{
316	AssertReturn(g_aContexts[i].pCtx == NULL, VERR_INTERNAL_ERROR);
317	g_aContexts[i].pWidget = pWidget;
318	g_aContexts[i].pCtx = pCtx;
319	fFound = true;
320	}
321	}
322
323	return fFound ? VINF_SUCCESS : VERR_OUT_OF_RESOURCES;
324	}
325
326	/**
327	* Unregister an X11 clipboard context.
328	*
329	* @param pCtx The X11 clipboard context to use.
330	*/
331	static void clipUnregisterContext(PSHCLX11CTX pCtx)
332	{
333	AssertPtrReturnVoid(pCtx);
334
335	Widget pWidget = pCtx->pWidget;
336	if (!pWidget)
337	return;
338
339	bool fFound = false;
340	for (unsigned i = 0; i < RT_ELEMENTS(g_aContexts); ++i)
341	{
342	Assert(!fFound \|\| g_aContexts[i].pWidget != pWidget);
343	if (g_aContexts[i].pWidget == pWidget)
344	{
345	Assert(g_aContexts[i].pCtx != NULL);
346	g_aContexts[i].pWidget = NULL;
347	g_aContexts[i].pCtx = NULL;
348	fFound = true;
349	}
350	}
351	}
352
353	/**
354	* Finds a X11 clipboard context for a specific X11 widget.
355	*
356	* @returns Pointer to associated X11 clipboard context if found, or NULL if not found.
357	* @param pWidget X11 widget to return X11 clipboard context for.
358	*/
359	static PSHCLX11CTX clipLookupContext(Widget pWidget)
360	{
361	AssertPtrReturn(pWidget, NULL);
362
363	for (unsigned i = 0; i < RT_ELEMENTS(g_aContexts); ++i)
364	{
365	if (g_aContexts[i].pWidget == pWidget)
366	{
367	Assert(g_aContexts[i].pCtx != NULL);
368	return g_aContexts[i].pCtx;
369	}
370	}
371
372	return NULL;
373	}
374
375	/**
376	* Converts an atom name string to an X11 atom, looking it up in a cache before asking the server.
377	*
378	* @returns Found X11 atom.
379	* @param pCtx The X11 clipboard context to use.
380	* @param pcszName Name of atom to return atom for.
381	*/
382	SHCL_X11_DECL(Atom) clipGetAtom(PSHCLX11CTX pCtx, const char *pcszName)
383	{
384	AssertPtrReturn(pcszName, None);
385	return XInternAtom(XtDisplay(pCtx->pWidget), pcszName, False);
386	}
387
388	/** String written to the wakeup pipe. */
389	#define WAKE_UP_STRING "WakeUp!"
390	/** Length of the string written. */
391	#define WAKE_UP_STRING_LEN ( sizeof(WAKE_UP_STRING) - 1 )
392
393	/**
394	* Schedules a function call to run on the Xt event thread by passing it to
395	* the application context as a 0ms timeout and waking up the event loop by
396	* writing to the wakeup pipe which it monitors.
397	*/
398	static int clipThreadScheduleCall(PSHCLX11CTX pCtx,
399	void (proc)(void , void *),
400	void *client_data)
401	{
402	LogFlowFunc(("proc=%p, client_data=%p\n", proc, client_data));
403
404	#ifndef TESTCASE
405	AssertReturn(pCtx, VERR_INVALID_POINTER);
406	AssertReturn(pCtx->pAppContext, VERR_INVALID_POINTER);
407
408	XtAppAddTimeOut(pCtx->pAppContext, 0, (XtTimerCallbackProc)proc,
409	(XtPointer)client_data);
410	ssize_t cbWritten = write(pCtx->wakeupPipeWrite, WAKE_UP_STRING, WAKE_UP_STRING_LEN);
411	Assert(cbWritten == WAKE_UP_STRING_LEN);
412	RT_NOREF(cbWritten);
413	#else
414	RT_NOREF(pCtx);
415	tstThreadScheduleCall(proc, client_data);
416	#endif
417
418	LogFlowFuncLeaveRC(VINF_SUCCESS);
419	return VINF_SUCCESS;
420	}
421
422	/**
423	* Reports the formats currently supported by the X11 clipboard to VBox.
424	*
425	* @note Runs in Xt event thread.
426	*
427	* @param pCtx The X11 clipboard context to use.
428	*/
429	static void clipReportFormatsToVBox(PSHCLX11CTX pCtx)
430	{
431	SHCLFORMATS vboxFmt = clipVBoxFormatForX11Format(pCtx->idxFmtText);
432	vboxFmt \|= clipVBoxFormatForX11Format(pCtx->idxFmtBmp);
433	vboxFmt \|= clipVBoxFormatForX11Format(pCtx->idxFmtHTML);
434	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
435	vboxFmt \|= clipVBoxFormatForX11Format(pCtx->idxFmtURI);
436	#endif
437
438	LogFlowFunc(("idxFmtText=%u ('%s'), idxFmtBmp=%u ('%s'), idxFmtHTML=%u ('%s')",
439	pCtx->idxFmtText, g_aFormats[pCtx->idxFmtText].pcszAtom,
440	pCtx->idxFmtBmp, g_aFormats[pCtx->idxFmtBmp].pcszAtom,
441	pCtx->idxFmtHTML, g_aFormats[pCtx->idxFmtHTML].pcszAtom));
442	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
443	Log((", idxFmtURI=%u ('%s')", pCtx->idxFmtURI, g_aFormats[pCtx->idxFmtURI].pcszAtom));
444	#endif
445	Log((" -> vboxFmt=%#x\n", vboxFmt));
446
447	#ifdef LOG_ENABLED
448	char *pszFmts = ShClFormatsToStrA(vboxFmt);
449	AssertPtrReturnVoid(pszFmts);
450	LogRel2(("Shared Clipboard: X11 reported available VBox formats '%s'\n", pszFmts));
451	RTStrFree(pszFmts);
452	#endif
453
454	if (pCtx->Callbacks.pfnReportFormats)
455	pCtx->Callbacks.pfnReportFormats(pCtx->pFrontend, vboxFmt, NULL /* pvUser */);
456	}
457
458	/**
459	* Forgets which formats were previously in the X11 clipboard. Called when we
460	* grab the clipboard.
461	*
462	* @param pCtx The X11 clipboard context to use.
463	*/
464	static void clipResetX11Formats(PSHCLX11CTX pCtx)
465	{
466	LogFlowFuncEnter();
467
468	pCtx->idxFmtText = 0;
469	pCtx->idxFmtBmp = 0;
470	pCtx->idxFmtHTML = 0;
471	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
472	pCtx->idxFmtURI = 0;
473	#endif
474	}
475
476	/**
477	* Tells VBox that X11 currently has nothing in its clipboard.
478	*
479	* @param pCtx The X11 clipboard context to use.
480	*/
481	SHCL_X11_DECL(void) clipReportEmpty(PSHCLX11CTX pCtx)
482	{
483	clipResetX11Formats(pCtx);
484	clipReportFormatsToVBox(pCtx);
485	}
486
487	/**
488	* Go through an array of X11 clipboard targets to see if they contain a text
489	* format we can support, and if so choose the ones we prefer (e.g. we like
490	* UTF-8 better than plain text).
491	*
492	* @return Index to supported X clipboard format.
493	* @param pCtx The X11 clipboard context to use.
494	* @param paIdxFmtTargets The list of targets.
495	* @param cTargets The size of the list in @a pTargets.
496	*/
497	SHCL_X11_DECL(SHCLX11FMTIDX) clipGetTextFormatFromTargets(PSHCLX11CTX pCtx,
498	SHCLX11FMTIDX *paIdxFmtTargets,
499	size_t cTargets)
500	{
501	AssertPtrReturn(pCtx, NIL_CLIPX11FORMAT);
502	AssertReturn(RT_VALID_PTR(paIdxFmtTargets) \|\| cTargets == 0, NIL_CLIPX11FORMAT);
503
504	SHCLX11FMTIDX idxFmtText = NIL_CLIPX11FORMAT;
505	SHCLX11FMT fmtTextX11 = SHCLX11FMT_INVALID;
506	for (unsigned i = 0; i < cTargets; ++i)
507	{
508	SHCLX11FMTIDX idxFmt = paIdxFmtTargets[i];
509	if (idxFmt != NIL_CLIPX11FORMAT)
510	{
511	if ( (clipVBoxFormatForX11Format(idxFmt) == VBOX_SHCL_FMT_UNICODETEXT)
512	&& fmtTextX11 < clipRealFormatForX11Format(idxFmt))
513	{
514	fmtTextX11 = clipRealFormatForX11Format(idxFmt);
515	idxFmtText = idxFmt;
516	}
517	}
518	}
519	return idxFmtText;
520	}
521
522	/**
523	* Goes through an array of X11 clipboard targets to see if they contain a bitmap
524	* format we can support, and if so choose the ones we prefer (e.g. we like
525	* BMP better than PNG because we don't have to convert).
526	*
527	* @return Supported X clipboard format.
528	* @param pCtx The X11 clipboard context to use.
529	* @param paIdxFmtTargets The list of targets.
530	* @param cTargets The size of the list in @a pTargets.
531	*/
532	static SHCLX11FMTIDX clipGetBitmapFormatFromTargets(PSHCLX11CTX pCtx,
533	SHCLX11FMTIDX *paIdxFmtTargets,
534	size_t cTargets)
535	{
536	AssertPtrReturn(pCtx, NIL_CLIPX11FORMAT);
537	AssertReturn(RT_VALID_PTR(paIdxFmtTargets) \|\| cTargets == 0, NIL_CLIPX11FORMAT);
538
539	SHCLX11FMTIDX idxFmtBmp = NIL_CLIPX11FORMAT;
540	SHCLX11FMT fmtBmpX11 = SHCLX11FMT_INVALID;
541	for (unsigned i = 0; i < cTargets; ++i)
542	{
543	SHCLX11FMTIDX idxFmt = paIdxFmtTargets[i];
544	if (idxFmt != NIL_CLIPX11FORMAT)
545	{
546	if ( (clipVBoxFormatForX11Format(idxFmt) == VBOX_SHCL_FMT_BITMAP)
547	&& fmtBmpX11 < clipRealFormatForX11Format(idxFmt))
548	{
549	fmtBmpX11 = clipRealFormatForX11Format(idxFmt);
550	idxFmtBmp = idxFmt;
551	}
552	}
553	}
554	return idxFmtBmp;
555	}
556
557	/**
558	* Goes through an array of X11 clipboard targets to see if they contain a HTML
559	* format we can support, and if so choose the ones we prefer.
560	*
561	* @return Supported X clipboard format.
562	* @param pCtx The X11 clipboard context to use.
563	* @param paIdxFmtTargets The list of targets.
564	* @param cTargets The size of the list in @a pTargets.
565	*/
566	static SHCLX11FMTIDX clipGetHtmlFormatFromTargets(PSHCLX11CTX pCtx,
567	SHCLX11FMTIDX *paIdxFmtTargets,
568	size_t cTargets)
569	{
570	AssertPtrReturn(pCtx, NIL_CLIPX11FORMAT);
571	AssertReturn(RT_VALID_PTR(paIdxFmtTargets) \|\| cTargets == 0, NIL_CLIPX11FORMAT);
572
573	SHCLX11FMTIDX idxFmtHTML = NIL_CLIPX11FORMAT;
574	SHCLX11FMT fmxHTMLX11 = SHCLX11FMT_INVALID;
575	for (unsigned i = 0; i < cTargets; ++i)
576	{
577	SHCLX11FMTIDX idxFmt = paIdxFmtTargets[i];
578	if (idxFmt != NIL_CLIPX11FORMAT)
579	{
580	if ( (clipVBoxFormatForX11Format(idxFmt) == VBOX_SHCL_FMT_HTML)
581	&& fmxHTMLX11 < clipRealFormatForX11Format(idxFmt))
582	{
583	fmxHTMLX11 = clipRealFormatForX11Format(idxFmt);
584	idxFmtHTML = idxFmt;
585	}
586	}
587	}
588	return idxFmtHTML;
589	}
590
591	# ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
592	/**
593	* Goes through an array of X11 clipboard targets to see if they contain an URI list
594	* format we can support, and if so choose the ones we prefer.
595	*
596	* @return Supported X clipboard format.
597	* @param pCtx The X11 clipboard context to use.
598	* @param paIdxFmtTargets The list of targets.
599	* @param cTargets The size of the list in @a pTargets.
600	*/
601	static SHCLX11FMTIDX clipGetURIListFormatFromTargets(PSHCLX11CTX pCtx,
602	SHCLX11FMTIDX *paIdxFmtTargets,
603	size_t cTargets)
604	{
605	AssertPtrReturn(pCtx, NIL_CLIPX11FORMAT);
606	AssertReturn(RT_VALID_PTR(paIdxFmtTargets) \|\| cTargets == 0, NIL_CLIPX11FORMAT);
607
608	SHCLX11FMTIDX idxFmtURI = NIL_CLIPX11FORMAT;
609	SHCLX11FMT fmtURIX11 = SHCLX11FMT_INVALID;
610	for (unsigned i = 0; i < cTargets; ++i)
611	{
612	SHCLX11FMTIDX idxFmt = paIdxFmtTargets[i];
613	if (idxFmt != NIL_CLIPX11FORMAT)
614	{
615	if ( (clipVBoxFormatForX11Format(idxFmt) == VBOX_SHCL_FMT_URI_LIST)
616	&& fmtURIX11 < clipRealFormatForX11Format(idxFmt))
617	{
618	fmtURIX11 = clipRealFormatForX11Format(idxFmt);
619	idxFmtURI = idxFmt;
620	}
621	}
622	}
623	return idxFmtURI;
624	}
625	# endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
626
627	/**
628	* Goes through an array of X11 clipboard targets to see if we can support any
629	* of them and if relevant to choose the ones we prefer (e.g. we like Utf8
630	* better than plain text).
631	*
632	* @param pCtx The X11 clipboard context to use.
633	* @param paIdxFmtTargets The list of targets.
634	* @param cTargets The size of the list in @a pTargets.
635	*/
636	static void clipGetFormatsFromTargets(PSHCLX11CTX pCtx,
637	SHCLX11FMTIDX *paIdxFmtTargets, size_t cTargets)
638	{
639	AssertPtrReturnVoid(pCtx);
640	AssertPtrReturnVoid(paIdxFmtTargets);
641
642	SHCLX11FMTIDX idxFmtText = clipGetTextFormatFromTargets(pCtx, paIdxFmtTargets, cTargets);
643	if (pCtx->idxFmtText != idxFmtText)
644	pCtx->idxFmtText = idxFmtText;
645
646	pCtx->idxFmtBmp = SHCLX11FMT_INVALID; /* not yet supported / /* @todo r=andy Check this. */
647	SHCLX11FMTIDX idxFmtBmp = clipGetBitmapFormatFromTargets(pCtx, paIdxFmtTargets, cTargets);
648	if (pCtx->idxFmtBmp != idxFmtBmp)
649	pCtx->idxFmtBmp = idxFmtBmp;
650
651	SHCLX11FMTIDX idxFmtHTML = clipGetHtmlFormatFromTargets(pCtx, paIdxFmtTargets, cTargets);
652	if (pCtx->idxFmtHTML != idxFmtHTML)
653	pCtx->idxFmtHTML = idxFmtHTML;
654
655	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
656	SHCLX11FMTIDX idxFmtURI = clipGetURIListFormatFromTargets(pCtx, paIdxFmtTargets, cTargets);
657	if (pCtx->idxFmtURI != idxFmtURI)
658	pCtx->idxFmtURI = idxFmtURI;
659	#endif
660	}
661
662	#ifdef VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY
663	DECLINLINE(bool) clipGetXtBusy(PSHCLX11CTX pCtx)
664	{
665	LogFlowFunc(("fXtBusy=%RTbool, fXtNeedsUpdate=%RTbool\n", pCtx->fXtBusy, pCtx->fXtNeedsUpdate));
666	return pCtx->fXtBusy;
667	}
668
669	DECLINLINE(bool) clipGetXtNeedsUpdate(PSHCLX11CTX pCtx)
670	{
671	LogFlowFunc(("fXtBusy=%RTbool, fXtNeedsUpdate=%RTbool\n", pCtx->fXtBusy, pCtx->fXtNeedsUpdate));
672	return pCtx->fXtNeedsUpdate;
673	}
674
675	DECLINLINE(bool) clipSetXtBusy(PSHCLX11CTX pCtx, bool fBusy)
676	{
677	pCtx->fXtBusy = fBusy;
678	LogFlowFunc(("fXtBusy=%RTbool, fXtNeedsUpdate=%RTbool\n", pCtx->fXtBusy, pCtx->fXtNeedsUpdate));
679	return pCtx->fXtBusy;
680	}
681
682	DECLINLINE(bool) clipSetXtNeedsUpdate(PSHCLX11CTX pCtx, bool fNeedsUpdate)
683	{
684	pCtx->fXtNeedsUpdate = fNeedsUpdate;
685	LogFlowFunc(("fXtBusy=%RTbool, fXtNeedsUpdate=%RTbool\n", pCtx->fXtBusy, pCtx->fXtNeedsUpdate));
686	return pCtx->fXtNeedsUpdate;
687	}
688	#endif /* VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY */
689
690	/**
691	* Updates the context's information about targets currently supported by X11,
692	* based on an array of X11 atoms.
693	*
694	* @param pCtx The X11 clipboard context to use.
695	* @param pTargets The array of atoms describing the targets supported.
696	* @param cTargets The size of the array @a pTargets.
697	*/
698	SHCL_X11_DECL(void) clipUpdateX11Targets(PSHCLX11CTX pCtx, SHCLX11FMTIDX *paIdxFmtTargets, size_t cTargets)
699	{
700	LogFlowFuncEnter();
701
702	#ifdef VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY
703	clipSetXtBusy(pCtx, false);
704	if (clipGetXtNeedsUpdate(pCtx))
705	{
706	/* We may already be out of date. */
707	clipSetXtNeedsUpdate(pCtx, false);
708	clipQueryX11Targets(pCtx);
709	return;
710	}
711	#endif
712
713	if (paIdxFmtTargets == NULL)
714	{
715	/* No data available */
716	clipReportEmpty(pCtx);
717	return;
718	}
719
720	clipGetFormatsFromTargets(pCtx, paIdxFmtTargets, cTargets);
721	clipReportFormatsToVBox(pCtx);
722	}
723
724	/**
725	* Notifies the VBox clipboard about available data formats ("targets" on X11),
726	* based on the information obtained from the X11 clipboard.
727	*
728	* @note Callback installed by clipQueryX11Targets() for XtGetSelectionValue().
729	* @note This function is treated as API glue, and as such is not part of any
730	* unit test. So keep it simple, be paranoid and log everything.
731	*/
732	SHCL_X11_DECL(void) clipQueryX11TargetsCallback(Widget widget, XtPointer pClient,
733	Atom * /* selection /, Atom atomType,
734	XtPointer pValue, long unsigned int *pcLen,
735	int *piFormat)
736	{
737	RT_NOREF(piFormat);
738
739	PSHCLX11CTX pCtx = reinterpret_cast<SHCLX11CTX *>(pClient);
740
741	LogFlowFunc(("pValue=%p, pcLen=%u, atomType=%d%s\n",
742	pValue, pcLen, atomType, *atomType == XT_CONVERT_FAIL ? " (XT_CONVERT_FAIL)" : ""));
743
744	Atom pAtoms = (Atom )pValue;
745
746	unsigned cFormats = *pcLen;
747
748	LogRel2(("Shared Clipboard: Querying X11 formats ...\n"));
749	LogRel2(("Shared Clipboard: %u X11 formats were found\n", cFormats));
750
751	SHCLX11FMTIDX *paIdxFmt = NULL;
752	if ( cFormats
753	&& pValue
754	&& (atomType != XT_CONVERT_FAIL / time out */))
755	{
756	/* Allocated array to hold the format indices. */
757	paIdxFmt = (SHCLX11FMTIDX )RTMemAllocZ(cFormats sizeof(SHCLX11FMTIDX));
758	}
759
760	#if !defined(TESTCASE)
761	if (pValue)
762	{
763	for (unsigned i = 0; i < cFormats; ++i)
764	{
765	if (pAtoms[i])
766	{
767	char *pszName = XGetAtomName(XtDisplay(widget), pAtoms[i]);
768	LogRel2(("Shared Clipboard: Found X11 format '%s'\n", pszName));
769	XFree(pszName);
770	}
771	else
772	LogFunc(("Found empty target\n"));
773	}
774	}
775	#endif
776
777	if (paIdxFmt)
778	{
779	for (unsigned i = 0; i < cFormats; ++i)
780	{
781	for (unsigned j = 0; j < RT_ELEMENTS(g_aFormats); ++j)
782	{
783	Atom target = XInternAtom(XtDisplay(widget),
784	g_aFormats[j].pcszAtom, False);
785	if (*(pAtoms + i) == target)
786	paIdxFmt[i] = j;
787	}
788	#if !defined(TESTCASE)
789	if (paIdxFmt[i] != SHCLX11FMT_INVALID)
790	LogRel2(("Shared Clipboard: Reporting X11 format '%s'\n", g_aFormats[paIdxFmt[i]].pcszAtom));
791	#endif
792	}
793	}
794	else
795	LogFunc(("Reporting empty targets (none reported or allocation failure)\n"));
796
797	clipUpdateX11Targets(pCtx, paIdxFmt, cFormats);
798	RTMemFree(paIdxFmt);
799
800	XtFree(reinterpret_cast<char *>(pValue));
801	}
802
803	/**
804	* Queries the current formats ("targets") of the X11 clipboard ("CLIPBOARD").
805	*
806	* @param pCtx The X11 clipboard context to use.
807	*/
808	SHCL_X11_DECL(void) clipQueryX11Targets(PSHCLX11CTX pCtx)
809	{
810	#ifndef TESTCASE
811
812	# ifdef VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY
813	if (clipGetXtBusy(pCtx))
814	{
815	clipSetXtNeedsUpdate(pCtx, true);
816	return;
817	}
818	clipSetXtBusy(pCtx, true);
819	# endif
820
821	XtGetSelectionValue(pCtx->pWidget,
822	clipGetAtom(pCtx, "CLIPBOARD"),
823	clipGetAtom(pCtx, "TARGETS"),
824	clipQueryX11TargetsCallback, pCtx,
825	CurrentTime);
826	#else
827	tstRequestTargets(pCtx);
828	#endif
829	}
830
831	typedef struct
832	{
833	int type; /* event base */
834	unsigned long serial;
835	Bool send_event;
836	Display *display;
837	Window window;
838	int subtype;
839	Window owner;
840	Atom selection;
841	Time timestamp;
842	Time selection_timestamp;
843	} XFixesSelectionNotifyEvent;
844
845	#ifndef TESTCASE
846	/**
847	* Waits until an event arrives and handle it if it is an XFIXES selection
848	* event, which Xt doesn't know about.
849	*
850	* @param pCtx The X11 clipboard context to use.
851	*/
852	static void clipPeekEventAndDoXFixesHandling(PSHCLX11CTX pCtx)
853	{
854	union
855	{
856	XEvent event;
857	XFixesSelectionNotifyEvent fixes;
858	} event = { { 0 } };
859
860	if (XtAppPeekEvent(pCtx->pAppContext, &event.event))
861	{
862	if ( (event.event.type == pCtx->fixesEventBase)
863	&& (event.fixes.owner != XtWindow(pCtx->pWidget)))
864	{
865	if ( (event.fixes.subtype == 0 /* XFixesSetSelectionOwnerNotify */)
866	&& (event.fixes.owner != 0))
867	clipQueryX11Targets(pCtx);
868	else
869	clipReportEmpty(pCtx);
870	}
871	}
872	}
873
874	/**
875	* The main loop of our X11 event thread.
876	*
877	* @returns VBox status code.
878	* @param hThreadSelf Associated thread handle.
879	* @param pvUser Pointer to the X11 clipboard context to use.
880	*/
881	static DECLCALLBACK(int) clipThreadMain(RTTHREAD hThreadSelf, void *pvUser)
882	{
883	PSHCLX11CTX pCtx = (PSHCLX11CTX)pvUser;
884	AssertPtr(pCtx);
885
886	LogFlowFunc(("pCtx=%p\n", pCtx));
887
888	bool fSignalled = false; /* Whether we have signalled the parent already or not. */
889
890	int rc = clipInitInternal(pCtx);
891	if (RT_SUCCESS(rc))
892	{
893	rc = clipRegisterContext(pCtx);
894	if (RT_SUCCESS(rc))
895	{
896	if (pCtx->fGrabClipboardOnStart)
897	clipQueryX11Targets(pCtx);
898
899	pCtx->fThreadStarted = true;
900
901	/* We're now ready to run, tell parent. */
902	int rc2 = RTThreadUserSignal(hThreadSelf);
903	AssertRC(rc2);
904
905	fSignalled = true;
906
907	while (XtAppGetExitFlag(pCtx->pAppContext) == FALSE)
908	{
909	clipPeekEventAndDoXFixesHandling(pCtx);
910	XtAppProcessEvent(pCtx->pAppContext, XtIMAll);
911	}
912
913	LogRel(("Shared Clipboard: X11 event thread exiting\n"));
914
915	clipUnregisterContext(pCtx);
916	}
917	else
918	{
919	LogRel(("Shared Clipboard: unable to register clip context: %Rrc\n", rc));
920	}
921
922	clipUninitInternal(pCtx);
923	}
924
925	if (!fSignalled) /* Signal parent if we didn't do so yet. */
926	{
927	int rc2 = RTThreadUserSignal(hThreadSelf);
928	AssertRC(rc2);
929	}
930
931	LogFlowFuncLeaveRC(rc);
932	return rc;
933	}
934
935	/**
936	* Worker function for stopping the clipboard which runs on the event
937	* thread.
938	*
939	* @param pvUserData Pointer to the X11 clipboard context to use.
940	*/
941	static void clipThreadSignalStop(void pvUserData, void )
942	{
943	PSHCLX11CTX pCtx = (PSHCLX11CTX)pvUserData;
944
945	/* This might mean that we are getting stopped twice. */
946	Assert(pCtx->pWidget != NULL);
947
948	/* Set the termination flag to tell the Xt event loop to exit. We
949	* reiterate that any outstanding requests from the X11 event loop to
950	* the VBox part must have returned before we do this. */
951	XtAppSetExitFlag(pCtx->pAppContext);
952	}
953
954	/**
955	* Sets up the XFixes library and load the XFixesSelectSelectionInput symbol.
956	*/
957	static int clipLoadXFixes(Display *pDisplay, PSHCLX11CTX pCtx)
958	{
959	int rc;
960
961	void *hFixesLib = dlopen("libXfixes.so.1", RTLD_LAZY);
962	if (!hFixesLib)
963	hFixesLib = dlopen("libXfixes.so.2", RTLD_LAZY);
964	if (!hFixesLib)
965	hFixesLib = dlopen("libXfixes.so.3", RTLD_LAZY);
966	if (!hFixesLib)
967	hFixesLib = dlopen("libXfixes.so.4", RTLD_LAZY);
968	if (hFixesLib)
969	{
970	/* For us, a NULL function pointer is a failure */
971	pCtx->fixesSelectInput = (void ()(Display , Window, Atom, long unsigned int))
972	(uintptr_t)dlsym(hFixesLib, "XFixesSelectSelectionInput");
973	if (pCtx->fixesSelectInput)
974	{
975	int dummy1 = 0;
976	int dummy2 = 0;
977	if (XQueryExtension(pDisplay, "XFIXES", &dummy1, &pCtx->fixesEventBase, &dummy2) != 0)
978	{
979	if (pCtx->fixesEventBase >= 0)
980	{
981	rc = VINF_SUCCESS;
982	}
983	else
984	{
985	LogRel(("Shared Clipboard: fixesEventBase is less than zero: %d\n", pCtx->fixesEventBase));
986	rc = VERR_NOT_SUPPORTED;
987	}
988	}
989	else
990	{
991	LogRel(("Shared Clipboard: XQueryExtension failed\n"));
992	rc = VERR_NOT_SUPPORTED;
993	}
994	}
995	else
996	{
997	LogRel(("Shared Clipboard: Symbol XFixesSelectSelectionInput not found!\n"));
998	rc = VERR_NOT_SUPPORTED;
999	}
1000	}
1001	else
1002	{
1003	LogRel(("Shared Clipboard: libxFixes.so.* not found!\n"));
1004	rc = VERR_NOT_SUPPORTED;
1005	}
1006	return rc;
1007	}
1008
1009	/**
1010	* This is the callback which is scheduled when data is available on the
1011	* wakeup pipe. It simply reads all data from the pipe.
1012	*
1013	* @param pvUserData Pointer to the X11 clipboard context to use.
1014	*/
1015	static void clipThreadDrainWakeupPipe(XtPointer pvUserData, int , XtInputId )
1016	{
1017	LogFlowFuncEnter();
1018
1019	PSHCLX11CTX pCtx = (PSHCLX11CTX)pvUserData;
1020	char acBuf[WAKE_UP_STRING_LEN];
1021
1022	while (read(pCtx->wakeupPipeRead, acBuf, sizeof(acBuf)) > 0) {}
1023	}
1024	#endif /* !TESTCASE */
1025
1026	/**
1027	* X11-specific initialisation for the Shared Clipboard.
1028	*
1029	* Note: Must be called from the thread serving the Xt stuff.
1030	*
1031	* @returns VBox status code.
1032	* @param pCtx The X11 clipboard context to init.
1033	*/
1034	static int clipInitInternal(PSHCLX11CTX pCtx)
1035	{
1036	LogFlowFunc(("pCtx=%p\n", pCtx));
1037
1038	/* Make sure we are thread safe. */
1039	XtToolkitThreadInitialize();
1040
1041	/*
1042	* Set up the Clipboard application context and main window. We call all
1043	* these functions directly instead of calling XtOpenApplication() so
1044	* that we can fail gracefully if we can't get an X11 display.
1045	*/
1046	XtToolkitInitialize();
1047
1048	int rc = VINF_SUCCESS;
1049
1050	Assert(pCtx->pAppContext == NULL); /* No nested initialization. */
1051	pCtx->pAppContext = XtCreateApplicationContext();
1052	if (pCtx->pAppContext == NULL)
1053	{
1054	LogRel(("Shared Clipboard: Failed to create Xt application context\n"));
1055	return VERR_NOT_SUPPORTED; /** @todo Fudge! */
1056	}
1057
1058	/* Create a window and make it a clipboard viewer. */
1059	int cArgc = 0;
1060	char *pcArgv = 0;
1061	Display *pDisplay = XtOpenDisplay(pCtx->pAppContext, 0, 0, "VBoxShCl", 0, 0, &cArgc, &pcArgv);
1062	if (pDisplay == NULL)
1063	{
1064	LogRel(("Shared Clipboard: Failed to connect to the X11 clipboard - the window system may not be running\n"));
1065	rc = VERR_NOT_SUPPORTED;
1066	}
1067
1068	#ifndef TESTCASE
1069	if (RT_SUCCESS(rc))
1070	{
1071	rc = clipLoadXFixes(pDisplay, pCtx);
1072	if (RT_FAILURE(rc))
1073	LogRel(("Shared Clipboard: Failed to load the XFIXES extension\n"));
1074	}
1075	#endif
1076
1077	if (RT_SUCCESS(rc))
1078	{
1079	pCtx->pWidget = XtVaAppCreateShell(0, "VBoxShCl",
1080	applicationShellWidgetClass,
1081	pDisplay,
1082	XtNwidth, 1, XtNheight, 1,
1083	NULL);
1084	if (pCtx->pWidget == NULL)
1085	{
1086	LogRel(("Shared Clipboard: Failed to create Xt app shell\n"));
1087	rc = VERR_NO_MEMORY; /** @todo r=andy Improve this. */
1088	}
1089	else
1090	{
1091	#ifndef TESTCASE
1092	if (!XtAppAddInput(pCtx->pAppContext, pCtx->wakeupPipeRead,
1093	(XtPointer) XtInputReadMask,
1094	clipThreadDrainWakeupPipe, (XtPointer) pCtx))
1095	{
1096	LogRel(("Shared Clipboard: Failed to add input to Xt app context\n"));
1097	rc = VERR_ACCESS_DENIED; /** @todo r=andy Improve this. */
1098	}
1099	#endif
1100	}
1101	}
1102
1103	if (RT_SUCCESS(rc))
1104	{
1105	XtSetMappedWhenManaged(pCtx->pWidget, false);
1106	XtRealizeWidget(pCtx->pWidget);
1107
1108	#ifndef TESTCASE
1109	/* Enable clipboard update notification. */
1110	pCtx->fixesSelectInput(pDisplay, XtWindow(pCtx->pWidget),
1111	clipGetAtom(pCtx, "CLIPBOARD"),
1112	7 /* All XFixesSelectionNotifyMask flags */);
1113	#endif
1114	}
1115
1116	if (RT_FAILURE(rc))
1117	{
1118	LogRel(("Shared Clipboard: Initialisation failed: %Rrc\n", rc));
1119	clipUninitInternal(pCtx);
1120	}
1121
1122	LogFlowFuncLeaveRC(rc);
1123	return rc;
1124	}
1125
1126	/**
1127	* X11-specific uninitialisation for the Shared Clipboard.
1128	*
1129	* Note: Must be called from the thread serving the Xt stuff.
1130	*
1131	* @param pCtx The X11 clipboard context to uninit.
1132	*/
1133	static void clipUninitInternal(PSHCLX11CTX pCtx)
1134	{
1135	AssertPtrReturnVoid(pCtx);
1136
1137	LogFlowFunc(("pCtx=%p\n", pCtx));
1138
1139	if (pCtx->pWidget)
1140	{
1141	/* Valid widget + invalid appcontext = bug. But don't return yet. */
1142	AssertPtr(pCtx->pAppContext);
1143
1144	XtDestroyWidget(pCtx->pWidget);
1145	pCtx->pWidget = NULL;
1146	}
1147
1148	if (pCtx->pAppContext)
1149	{
1150	XtDestroyApplicationContext(pCtx->pAppContext);
1151	pCtx->pAppContext = NULL;
1152	}
1153
1154	LogFlowFuncLeaveRC(VINF_SUCCESS);
1155	}
1156
1157	/**
1158	* Helper function for public X11 Shared Clipboard APIs to know whether we're running in headless mode or not.
1159	*
1160	* Headless mode either could mean that we don't want to touch the X11 clipboard, or that X simply isn't installed and/or
1161	* isn't available (e.g. running on a pure server installation w/o any desktop environment).
1162	*
1163	* Goal here is to make the X11 API transparent for the caller whether X is available or not.
1164	*
1165	* @returns \c true if running in headless mode, or \c false if not.
1166	* @param pCtx The X11 clipboard context to use.
1167	*/
1168	DECLINLINE(bool) shClX11HeadlessIsEnabled(PSHCLX11CTX pCtx)
1169	{
1170	return pCtx->fHeadless;
1171	}
1172
1173	/**
1174	* Sets the callback table, internal version.
1175	*
1176	* @param pCtx The clipboard context.
1177	* @param pCallbacks Callback table to set. If NULL, the current callback table will be cleared.
1178	*/
1179	static void shClX11SetCallbacksInternal(PSHCLX11CTX pCtx, PSHCLCALLBACKS pCallbacks)
1180	{
1181	if (pCallbacks)
1182	{
1183	memcpy(&pCtx->Callbacks, pCallbacks, sizeof(SHCLCALLBACKS));
1184	}
1185	else
1186	RT_ZERO(pCtx->Callbacks);
1187	}
1188
1189	/**
1190	* Sets the callback table.
1191	*
1192	* @param pCtx The clipboard context.
1193	* @param pCallbacks Callback table to set. If NULL, the current callback table will be cleared.
1194	*/
1195	void ShClX11SetCallbacks(PSHCLX11CTX pCtx, PSHCLCALLBACKS pCallbacks)
1196	{
1197	shClX11SetCallbacksInternal(pCtx, pCallbacks);
1198	}
1199
1200	/**
1201	* Initializes a X11 context of the Shared Clipboard.
1202	*
1203	* @returns VBox status code.
1204	* @param pCtx The clipboard context to initialize.
1205	* @param pCallbacks Callback table to use.
1206	* @param pParent Parent context to use.
1207	* @param fHeadless Whether the code runs in a headless environment or not.
1208	*/
1209	int ShClX11Init(PSHCLX11CTX pCtx, PSHCLCALLBACKS pCallbacks, PSHCLCONTEXT pParent, bool fHeadless)
1210	{
1211	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1212
1213	LogFlowFunc(("pCtx=%p\n", pCtx));
1214
1215	RT_BZERO(pCtx, sizeof(SHCLX11CTX));
1216
1217	/* Init clipboard cache. */
1218	ShClCacheInit(&pCtx->Cache);
1219
1220	/* Install given callbacks. */
1221	shClX11SetCallbacksInternal(pCtx, pCallbacks);
1222
1223	pCtx->fHeadless = fHeadless;
1224	pCtx->pFrontend = pParent;
1225
1226	#ifdef VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY
1227	pCtx->fXtBusy = false;
1228	pCtx->fXtNeedsUpdate = false;
1229	#endif
1230
1231	int rc = VINF_SUCCESS;
1232
1233	LogRel(("Shared Clipboard: Initializing X11 clipboard (%s mode)\n", fHeadless ? "headless" : "regular"));
1234
1235	if (!pCtx->fHeadless)
1236	{
1237	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS_HTTP
1238	rc = ShClTransferHttpServerInit(&pCtx->HttpCtx.HttpServer);
1239	#endif
1240
1241	#ifdef TESTCASE
1242	if (RT_SUCCESS(rc))
1243	{
1244	/** @todo The testcases currently do not utilize the threading code. So init stuff here. */
1245	rc = clipInitInternal(pCtx);
1246	if (RT_SUCCESS(rc))
1247	rc = clipRegisterContext(pCtx);
1248	}
1249	#endif
1250	}
1251
1252	if (RT_FAILURE(rc))
1253	LogRel(("Shared Clipboard: Initializing X11 clipboard failed with %Rrc\n", rc));
1254
1255	LogFlowFuncLeaveRC(rc);
1256	return rc;
1257	}
1258
1259	/**
1260	* Destroys a Shared Clipboard X11 context.
1261	*
1262	* @returns VBox status code.
1263	* @param pCtx The X11 clipboard context to destroy.
1264	*/
1265	int ShClX11Destroy(PSHCLX11CTX pCtx)
1266	{
1267	if (!pCtx)
1268	return VINF_SUCCESS;
1269
1270	LogFlowFunc(("pCtx=%p\n", pCtx));
1271
1272	/* Destroy clipboard cache. */
1273	ShClCacheDestroy(&pCtx->Cache);
1274
1275	int rc = VINF_SUCCESS;
1276	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS_HTTP
1277	rc = ShClTransferHttpServerDestroy(&pCtx->HttpCtx.HttpServer);
1278	#endif
1279
1280	#ifdef TESTCASE
1281	/** @todo The testcases currently do not utilize the threading code. So uninit stuff here. */
1282	clipUnregisterContext(pCtx);
1283	clipUninitInternal(pCtx);
1284	#endif
1285
1286	if (!shClX11HeadlessIsEnabled(pCtx))
1287	{
1288	/* We set this to NULL when the event thread exits. It really should
1289	* have exited at this point, when we are about to unload the code from
1290	* memory. */
1291	AssertStmt(pCtx->pWidget == NULL, rc = VERR_WRONG_ORDER);
1292	}
1293
1294	return rc;
1295	}
1296
1297	#ifndef TESTCASE
1298	/**
1299	* Starts our own Xt even thread for handling Shared Clipboard messages, extended version.
1300	*
1301	* @returns VBox status code.
1302	* @param pCtx The X11 clipboard context to use.
1303	* @param pszName Thread name to use.
1304	* @param fGrab Whether we should try to grab the shared clipboard at once.
1305	*/
1306	int ShClX11ThreadStartEx(PSHCLX11CTX pCtx, const char *pszName, bool fGrab)
1307	{
1308	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1309
1310	if (shClX11HeadlessIsEnabled(pCtx))
1311	return VINF_SUCCESS;
1312
1313	pCtx->fGrabClipboardOnStart = fGrab;
1314
1315	clipResetX11Formats(pCtx);
1316
1317	int rc;
1318
1319	/*
1320	* Create the pipes.
1321	** @todo r=andy Replace this with RTPipe API.
1322	*/
1323	int pipes[2];
1324	if (!pipe(pipes))
1325	{
1326	pCtx->wakeupPipeRead = pipes[0];
1327	pCtx->wakeupPipeWrite = pipes[1];
1328
1329	if (!fcntl(pCtx->wakeupPipeRead, F_SETFL, O_NONBLOCK))
1330	{
1331	rc = VINF_SUCCESS;
1332	}
1333	else
1334	rc = RTErrConvertFromErrno(errno);
1335	}
1336	else
1337	rc = RTErrConvertFromErrno(errno);
1338
1339	if (RT_SUCCESS(rc))
1340	{
1341	LogRel2(("Shared Clipboard: Starting X11 event thread ...\n"));
1342
1343	rc = RTThreadCreate(&pCtx->Thread, clipThreadMain, pCtx, 0,
1344	RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, pszName);
1345	if (RT_SUCCESS(rc))
1346	rc = RTThreadUserWait(pCtx->Thread, RT_MS_30SEC /* msTimeout */);
1347
1348	if (RT_FAILURE(rc))
1349	{
1350	LogRel(("Shared Clipboard: Failed to start the X11 event thread with %Rrc\n", rc));
1351	clipUninitInternal(pCtx);
1352	}
1353	else
1354	{
1355	if (!pCtx->fThreadStarted)
1356	{
1357	LogRel(("Shared Clipboard: X11 event thread reported an error while starting\n"));
1358	}
1359	else
1360	LogRel2(("Shared Clipboard: X11 event thread started\n"));
1361	}
1362	}
1363
1364	LogFlowFuncLeaveRC(rc);
1365	return rc;
1366	}
1367
1368	/**
1369	* Starts our own Xt even thread for handling Shared Clipboard messages.
1370	*
1371	* @returns VBox status code.
1372	* @param pCtx The X11 clipboard context to use.
1373	* @param fGrab Whether we should try to grab the shared clipboard at once.
1374	*/
1375	int ShClX11ThreadStart(PSHCLX11CTX pCtx, bool fGrab)
1376	{
1377	return ShClX11ThreadStartEx(pCtx, "SHCLX11", fGrab);
1378	}
1379
1380	/**
1381	* Stops the Shared Clipboard Xt even thread.
1382	*
1383	* @note Any requests from this object to get clipboard data from VBox
1384	* must have completed or aborted before we are called, as
1385	* otherwise the X11 event loop will still be waiting for the request
1386	* to return and will not be able to terminate.
1387	*
1388	* @returns VBox status code.
1389	* @param pCtx The X11 clipboard context to use.
1390	*/
1391	int ShClX11ThreadStop(PSHCLX11CTX pCtx)
1392	{
1393	if (shClX11HeadlessIsEnabled(pCtx))
1394	return VINF_SUCCESS;
1395
1396	LogRel2(("Shared Clipboard: Signalling the X11 event thread to stop\n"));
1397
1398	/* Write to the "stop" pipe. */
1399	int rc = clipThreadScheduleCall(pCtx, clipThreadSignalStop, (XtPointer)pCtx);
1400	if (RT_FAILURE(rc))
1401	{
1402	LogRel(("Shared Clipboard: cannot notify X11 event thread on shutdown with %Rrc\n", rc));
1403	return rc;
1404	}
1405
1406	LogRel2(("Shared Clipboard: Waiting for X11 event thread to stop ...\n"));
1407
1408	int rcThread;
1409	rc = RTThreadWait(pCtx->Thread, RT_MS_30SEC /* msTimeout */, &rcThread);
1410	if (RT_SUCCESS(rc))
1411	rc = rcThread;
1412	if (RT_SUCCESS(rc))
1413	{
1414	if (pCtx->wakeupPipeRead != 0)
1415	{
1416	close(pCtx->wakeupPipeRead);
1417	pCtx->wakeupPipeRead = 0;
1418	}
1419
1420	if (pCtx->wakeupPipeWrite != 0)
1421	{
1422	close(pCtx->wakeupPipeWrite);
1423	pCtx->wakeupPipeWrite = 0;
1424	}
1425	}
1426
1427	if (RT_SUCCESS(rc))
1428	{
1429	LogRel2(("Shared Clipboard: X11 event thread stopped successfully\n"));
1430	}
1431	else
1432	LogRel(("Shared Clipboard: Stopping X11 event thread failed with %Rrc\n", rc));
1433
1434	LogFlowFuncLeaveRC(rc);
1435	return rc;
1436	}
1437	#endif /* !TESTCASE */
1438
1439	/**
1440	* Returns the targets supported by VBox.
1441	*
1442	* This will return a list of atoms which tells the caller
1443	* what kind of clipboard formats we support.
1444	*
1445	* @returns VBox status code.
1446	* @param pCtx The X11 clipboard context to use.
1447	* @param atomTypeReturn The type of the data we are returning.
1448	* @param pValReturn A pointer to the data we are returning. This
1449	* should be set to memory allocated by XtMalloc,
1450	* which will be freed later by the Xt toolkit.
1451	* @param pcLenReturn The length of the data we are returning.
1452	* @param piFormatReturn The format (8bit, 16bit, 32bit) of the data we are
1453	* returning.
1454	* @note X11 backend code, called by the XtOwnSelection callback.
1455	*/
1456	static int clipCreateX11Targets(PSHCLX11CTX pCtx, Atom *atomTypeReturn,
1457	XtPointer *pValReturn,
1458	unsigned long *pcLenReturn,
1459	int *piFormatReturn)
1460	{
1461	const unsigned cFixedTargets = 3; /* See below. */
1462
1463	Atom pAtomTargets = (Atom )XtMalloc((SHCL_MAX_X11_FORMATS + cFixedTargets) * sizeof(Atom));
1464	if (!pAtomTargets)
1465	return VERR_NO_MEMORY;
1466
1467	unsigned cTargets = 0;
1468	SHCLX11FMTIDX idxFmt = NIL_CLIPX11FORMAT;
1469	do
1470	{
1471	idxFmt = clipEnumX11Formats(pCtx->vboxFormats, idxFmt);
1472	if (idxFmt != NIL_CLIPX11FORMAT)
1473	{
1474	pAtomTargets[cTargets] = clipAtomForX11Format(pCtx, idxFmt);
1475	++cTargets;
1476	}
1477	} while (idxFmt != NIL_CLIPX11FORMAT);
1478
1479	/* We always offer these fixed targets. */
1480	pAtomTargets[cTargets] = clipGetAtom(pCtx, "TARGETS");
1481	pAtomTargets[cTargets + 1] = clipGetAtom(pCtx, "MULTIPLE");
1482	pAtomTargets[cTargets + 2] = clipGetAtom(pCtx, "TIMESTAMP");
1483
1484	*atomTypeReturn = XA_ATOM;
1485	*pValReturn = (XtPointer)pAtomTargets;
1486	*pcLenReturn = cTargets + cFixedTargets;
1487	*piFormatReturn = 32;
1488
1489	LogFlowFunc(("cTargets=%u\n", cTargets + cFixedTargets));
1490
1491	return VINF_SUCCESS;
1492	}
1493
1494	/**
1495	* Helper for clipConvertToX11Data() that will cache the data returned.
1496	*
1497	* @returns VBox status code. VERR_SHCLPB_NO_DATA if no data available.
1498	* @param pCtx The X11 clipboard context to use.
1499	* @param uFmt Clipboard format to read data in.
1500	* @param ppv Returns an allocated buffer with data read on success.
1501	* Needs to be free'd with RTMemFree() by the caller.
1502	* @param pcb Returns the amount of data read (in bytes) on success.
1503	*
1504	* @thread X11 event thread.
1505	*/
1506	static int shClX11RequestDataForX11CallbackHelper(PSHCLX11CTX pCtx, SHCLFORMAT uFmt,
1507	void *ppv, uint32_t pcb)
1508	{
1509	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1510	AssertPtrReturn(ppv, VERR_INVALID_POINTER);
1511	AssertPtrReturn(pcb, VERR_INVALID_POINTER);
1512
1513	#ifdef LOG_ENABLED
1514	char *pszFmts = ShClFormatsToStrA(uFmt);
1515	AssertPtrReturn(pszFmts, VERR_NO_MEMORY);
1516	LogRel2(("Shared Clipboard: Requesting data for X11 from source as '%s'\n", pszFmts));
1517	RTStrFree(pszFmts);
1518	#endif
1519
1520	int rc = VINF_SUCCESS;
1521
1522	void *pv = NULL;
1523	uint32_t cb = 0;
1524
1525	PSHCLCACHEENTRY pCacheEntry = ShClCacheGet(&pCtx->Cache, uFmt);
1526	if (!pCacheEntry) /* Cache miss */
1527	{
1528	AssertPtrReturn(pCtx->Callbacks.pfnOnRequestDataFromSource, VERR_INVALID_POINTER);
1529	rc = pCtx->Callbacks.pfnOnRequestDataFromSource(pCtx->pFrontend, uFmt, &pv, &cb,
1530	NULL /* pvUser */);
1531	if (RT_SUCCESS(rc))
1532	rc = ShClCacheSet(&pCtx->Cache, uFmt, pv, cb);
1533	}
1534	else /* Cache hit */
1535	{
1536	void *pvCache = NULL;
1537	size_t cbCache = 0;
1538	ShClCacheEntryGet(pCacheEntry, &pvCache, &cbCache);
1539	if ( pvCache
1540	&& cbCache)
1541	{
1542	pv = RTMemDup(pvCache, cbCache);
1543	if (pv)
1544	{
1545	cb = cbCache;
1546	}
1547	else
1548	rc = VERR_NO_MEMORY;
1549	}
1550	}
1551
1552	LogFlowFunc(("pCtx=%p, uFmt=%#x -> Cache %s\n", pCtx, uFmt, pCacheEntry ? "HIT" : "MISS"));
1553
1554	/* Safey net in case the stuff above misbehaves
1555	* (must return VERR_SHCLPB_NO_DATA if no data available). */
1556	if ( RT_SUCCESS(rc)
1557	&& (pv == NULL \|\| cb == 0))
1558	rc = VERR_SHCLPB_NO_DATA;
1559
1560	if (RT_SUCCESS(rc))
1561	{
1562	*ppv = pv;
1563	*pcb = cb;
1564	}
1565
1566	if ( RT_FAILURE(rc)
1567	&& rc != VERR_SHCLPB_NO_DATA)
1568	LogRel(("Shared Clipboard: Requesting data for X11 from source failed with %Rrc\n", rc));
1569
1570	LogFlowFunc(("Returning pv=%p, cb=%RU32, rc=%Rrc\n", pv, cb, rc));
1571	return rc;
1572	}
1573
1574	/**
1575	* Free's an allocated SHCLX11RESPONSE struct.
1576	*
1577	* @param pResp Pointer to response to free.
1578	* The pointer will be invalid after return.
1579	*/
1580	static void shClX11ResponseFree(PSHCLX11RESPONSE pResp)
1581	{
1582	if (!pResp)
1583	return;
1584
1585	switch (pResp->enmType)
1586	{
1587	case SHCLX11EVENTTYPE_READ:
1588	{
1589	if (pResp->Read.pvData)
1590	{
1591	Assert(pResp->Read.cbData);
1592	RTMemFree(pResp->Read.pvData);
1593	}
1594	break;
1595	}
1596
1597	case SHCLX11EVENTTYPE_REPORT_FORMATS:
1598	RT_FALL_THROUGH();
1599	case SHCLX11EVENTTYPE_WRITE:
1600	RT_FALL_THROUGH();
1601	default:
1602	break;
1603	}
1604
1605	RTMemFree(pResp);
1606	}
1607
1608	/**
1609	* Satisfies a request from X11 to convert the clipboard text to UTF-8 LF.
1610	*
1611	* @returns VBox status code. VERR_SHCLPB_NO_DATA if no data was converted.
1612	* @param pDisplay An X11 display structure, needed for conversions
1613	* performed by Xlib.
1614	* @param pv The text to be converted (UCS-2 with Windows EOLs).
1615	* @param cb The length of the text in @cb in bytes.
1616	* @param atomTypeReturn Where to store the atom for the type of the data
1617	* we are returning.
1618	* @param pValReturn Where to store the pointer to the data we are
1619	* returning. This should be to memory allocated by
1620	* XtMalloc, which will be freed by the Xt toolkit
1621	* later.
1622	* @param pcLenReturn Where to store the length of the data we are
1623	* returning.
1624	* @param piFormatReturn Where to store the bit width (8, 16, 32) of the
1625	* data we are returning.
1626	*/
1627	static int clipConvertUtf16ToX11Data(Display *pDisplay, PRTUTF16 pwszSrc,
1628	size_t cbSrc, Atom *atomTarget,
1629	Atom *atomTypeReturn,
1630	XtPointer *pValReturn,
1631	unsigned long *pcLenReturn,
1632	int *piFormatReturn)
1633	{
1634	RT_NOREF(pDisplay);
1635	AssertReturn(cbSrc % sizeof(RTUTF16) == 0, VERR_INVALID_PARAMETER);
1636
1637	const size_t cwcSrc = cbSrc / sizeof(RTUTF16);
1638	if (!cwcSrc)
1639	return VERR_SHCLPB_NO_DATA;
1640
1641	/* This may slightly overestimate the space needed. */
1642	size_t chDst = 0;
1643	int rc = ShClUtf16LenUtf8(pwszSrc, cwcSrc, &chDst);
1644	if (RT_SUCCESS(rc))
1645	{
1646	chDst++; /* Add space for terminator. */
1647
1648	char pszDst = (char )XtMalloc(chDst);
1649	if (pszDst)
1650	{
1651	size_t cbActual = 0;
1652	rc = ShClConvUtf16CRLFToUtf8LF(pwszSrc, cwcSrc, pszDst, chDst, &cbActual);
1653	if (RT_SUCCESS(rc))
1654	{
1655	atomTypeReturn = atomTarget;
1656	*pValReturn = (XtPointer)pszDst;
1657	pcLenReturn = cbActual + 1 / Include terminator */;
1658	*piFormatReturn = 8;
1659	}
1660	}
1661	else
1662	rc = VERR_NO_MEMORY;
1663	}
1664
1665	LogFlowFuncLeaveRC(rc);
1666	return rc;
1667	}
1668
1669	/**
1670	* Satisfies a request from X11 to convert the clipboard HTML fragment to UTF-8. We
1671	* return null-terminated text, but can cope with non-null-terminated input.
1672	*
1673	* @returns VBox status code.
1674	* @param pDisplay An X11 display structure, needed for conversions
1675	* performed by Xlib.
1676	* @param pv The text to be converted (UTF8 with Windows EOLs).
1677	* @param cb The length of the text in @cb in bytes.
1678	* @param atomTypeReturn Where to store the atom for the type of the data
1679	* we are returning.
1680	* @param pValReturn Where to store the pointer to the data we are
1681	* returning. This should be to memory allocated by
1682	* XtMalloc, which will be freed by the Xt toolkit later.
1683	* @param pcLenReturn Where to store the length of the data we are returning.
1684	* @param piFormatReturn Where to store the bit width (8, 16, 32) of the
1685	* data we are returning.
1686	*/
1687	static int clipConvertHtmlToX11Data(Display pDisplay, const char pszSrc,
1688	size_t cbSrc, Atom *atomTarget,
1689	Atom *atomTypeReturn,
1690	XtPointer *pValReturn,
1691	unsigned long *pcLenReturn,
1692	int *piFormatReturn)
1693	{
1694	RT_NOREF(pDisplay, pValReturn);
1695
1696	/* This may slightly overestimate the space needed. */
1697	LogFlowFunc(("Source: %s", pszSrc));
1698
1699	char pszDest = (char )XtMalloc(cbSrc);
1700	if (pszDest == NULL)
1701	return VERR_NO_MEMORY;
1702
1703	memcpy(pszDest, pszSrc, cbSrc);
1704
1705	atomTypeReturn = atomTarget;
1706	*pValReturn = (XtPointer)pszDest;
1707	*pcLenReturn = cbSrc;
1708	*piFormatReturn = 8;
1709
1710	return VINF_SUCCESS;
1711	}
1712
1713
1714	/**
1715	* Does this atom correspond to one of the two selection types we support?
1716	*
1717	* @param pCtx The X11 clipboard context to use.
1718	* @param selType The atom in question.
1719	*/
1720	static bool clipIsSupportedSelectionType(PSHCLX11CTX pCtx, Atom selType)
1721	{
1722	return( (selType == clipGetAtom(pCtx, "CLIPBOARD"))
1723	\|\| (selType == clipGetAtom(pCtx, "PRIMARY")));
1724	}
1725
1726	/**
1727	* Removes a trailing nul character from a string by adjusting the string
1728	* length. Some X11 applications don't like zero-terminated text...
1729	*
1730	* @param pText The text in question.
1731	* @param pcText The length of the text, adjusted on return.
1732	* @param format The format of the text.
1733	*/
1734	static void clipTrimTrailingNul(XtPointer pText, unsigned long *pcText,
1735	SHCLX11FMT format)
1736	{
1737	AssertPtrReturnVoid(pText);
1738	AssertPtrReturnVoid(pcText);
1739	AssertReturnVoid((format == SHCLX11FMT_UTF8) \|\| (format == SHCLX11FMT_TEXT) \|\| (format == SHCLX11FMT_HTML));
1740
1741	if (((char )pText)[pcText - 1] == '\0')
1742	--(*pcText);
1743	}
1744
1745	static int clipConvertToX11Data(PSHCLX11CTX pCtx, Atom *atomTarget,
1746	Atom *atomTypeReturn,
1747	XtPointer *pValReturn,
1748	unsigned long *pcLenReturn,
1749	int *piFormatReturn)
1750	{
1751	int rc = VERR_NOT_SUPPORTED; /* Play safe by default. */
1752
1753	SHCLX11FMTIDX idxFmtX11 = clipFindX11FormatByAtom(pCtx, *atomTarget);
1754	SHCLX11FMT fmtX11 = clipRealFormatForX11Format(idxFmtX11);
1755
1756	LogFlowFunc(("vboxFormats=0x%x, idxFmtX11=%u ('%s'), fmtX11=%u\n",
1757	pCtx->vboxFormats, idxFmtX11, g_aFormats[idxFmtX11].pcszAtom, fmtX11));
1758
1759	char *pszFmts = ShClFormatsToStrA(pCtx->vboxFormats);
1760	AssertPtrReturn(pszFmts, VERR_NO_MEMORY);
1761	LogRel2(("Shared Clipboard: Converting VBox formats '%s' to '%s' for X11\n",
1762	pszFmts, fmtX11 == SHCLX11FMT_INVALID ? "<invalid>" : g_aFormats[idxFmtX11].pcszAtom));
1763	RTStrFree(pszFmts);
1764
1765	void *pv = NULL;
1766	uint32_t cb = 0;
1767
1768	if ( ( (fmtX11 == SHCLX11FMT_UTF8)
1769	\|\| (fmtX11 == SHCLX11FMT_TEXT)
1770	)
1771	&& (pCtx->vboxFormats & VBOX_SHCL_FMT_UNICODETEXT))
1772	{
1773	rc = shClX11RequestDataForX11CallbackHelper(pCtx, VBOX_SHCL_FMT_UNICODETEXT, &pv, &cb);
1774	if ( RT_SUCCESS(rc)
1775	&& ( (fmtX11 == SHCLX11FMT_UTF8)
1776	\|\| (fmtX11 == SHCLX11FMT_TEXT)))
1777	{
1778	rc = clipConvertUtf16ToX11Data(XtDisplay(pCtx->pWidget),
1779	(PRTUTF16)pv, cb, atomTarget,
1780	atomTypeReturn, pValReturn,
1781	pcLenReturn, piFormatReturn);
1782	}
1783
1784	if (RT_SUCCESS(rc))
1785	clipTrimTrailingNul((XtPointer )pValReturn, pcLenReturn, fmtX11);
1786
1787	RTMemFree(pv);
1788	}
1789	else if ( (fmtX11 == SHCLX11FMT_BMP)
1790	&& (pCtx->vboxFormats & VBOX_SHCL_FMT_BITMAP))
1791	{
1792	rc = shClX11RequestDataForX11CallbackHelper(pCtx, VBOX_SHCL_FMT_BITMAP, &pv, &cb);
1793	if (RT_SUCCESS(rc))
1794	{
1795	/* Create a full BMP from it. */
1796	rc = ShClDibToBmp(pv, cb, (void **)pValReturn,
1797	(size_t *)pcLenReturn);
1798	}
1799
1800	if (RT_SUCCESS(rc))
1801	{
1802	atomTypeReturn = atomTarget;
1803	*piFormatReturn = 8;
1804	}
1805
1806	RTMemFree(pv);
1807	}
1808	else if ( (fmtX11 == SHCLX11FMT_HTML)
1809	&& (pCtx->vboxFormats & VBOX_SHCL_FMT_HTML))
1810	{
1811	rc = shClX11RequestDataForX11CallbackHelper(pCtx, VBOX_SHCL_FMT_HTML, &pv, &cb);
1812	if (RT_SUCCESS(rc))
1813	{
1814	/**
1815	* The common VBox HTML encoding will be UTF-8.
1816	* Before sending it to the X11 clipboard we have to convert it to UTF-8 first.
1817	*
1818	* Strange that we get UTF-16 from the X11 clipboard, but
1819	* in same time we send UTF-8 to X11 clipboard and it works.
1820	** @todo r=andy Verify this.
1821	*/
1822	rc = clipConvertHtmlToX11Data(XtDisplay(pCtx->pWidget),
1823	(const char*)pv, cb, atomTarget,
1824	atomTypeReturn, pValReturn,
1825	pcLenReturn, piFormatReturn);
1826	if (RT_SUCCESS(rc))
1827	clipTrimTrailingNul((XtPointer )pValReturn, pcLenReturn, fmtX11);
1828
1829	RTMemFree(pv);
1830	}
1831	}
1832	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
1833	else if ( fmtX11 == SHCLX11FMT_URI_LIST
1834	\|\| fmtX11 == SHCLX11FMT_URI_LIST_GNOME_COPIED_FILES
1835	/** @todo BUGBUG Not sure about the following ones; test those. */
1836	\|\| fmtX11 == SHCLX11FMT_URI_LIST_MATE_COPIED_FILES
1837	\|\| fmtX11 == SHCLX11FMT_URI_LIST_NAUTILUS_CLIPBOARD
1838	\|\| fmtX11 == SHCLX11FMT_URI_LIST_KDE_CUTSELECTION)
1839	{
1840	if (pCtx->vboxFormats & VBOX_SHCL_FMT_URI_LIST)
1841	{
1842	rc = shClX11RequestDataForX11CallbackHelper(pCtx, VBOX_SHCL_FMT_URI_LIST, &pv, &cb);
1843	if (RT_SUCCESS(rc))
1844	{
1845	void *pvX11;
1846	size_t cbX11;
1847	rc = ShClX11TransferConvertToX11((const char *)pv, cb, fmtX11, &pvX11, &cbX11);
1848	if (RT_SUCCESS(rc))
1849	{
1850	atomTypeReturn = atomTarget;
1851	*pValReturn = (XtPointer)pvX11;
1852	*pcLenReturn = cbX11;
1853	*piFormatReturn = 8;
1854	}
1855	}
1856
1857	RTMemFree(pv);
1858	pv = NULL;
1859	}
1860	/* else not supported yet. */
1861	}
1862	#endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
1863	else
1864	{
1865	*atomTypeReturn = XT_CONVERT_FAIL;
1866	*pValReturn = (XtPointer)NULL;
1867	*pcLenReturn = 0;
1868	*piFormatReturn = 0;
1869	}
1870
1871	if ( RT_FAILURE(rc)
1872	&& rc != VERR_SHCLPB_NO_DATA)
1873	{
1874	char *pszFmts2 = ShClFormatsToStrA(pCtx->vboxFormats);
1875	char pszAtomName = XGetAtomName(XtDisplay(pCtx->pWidget), atomTarget);
1876
1877	LogRel(("Shared Clipboard: Converting VBox formats '%s' to '%s' for X11 (idxFmtX11=%u, fmtX11=%u, atomTarget='%s') failed, rc=%Rrc\n",
1878	pszFmts2 ? pszFmts2 : "unknown", g_aFormats[idxFmtX11].pcszAtom, idxFmtX11, fmtX11, pszAtomName ? pszAtomName : "unknown", rc));
1879
1880	if (pszFmts2)
1881	RTStrFree(pszFmts2);
1882	if (pszAtomName)
1883	XFree(pszAtomName);
1884	}
1885
1886	LogFlowFuncLeaveRC(rc);
1887	return rc;
1888	}
1889
1890	/**
1891	* Returns VBox's clipboard data for an X11 client.
1892	*
1893	* @note Callback for XtOwnSelection.
1894	*/
1895	static Boolean clipXtConvertSelectionProc(Widget widget, Atom *atomSelection,
1896	Atom *atomTarget,
1897	Atom *atomTypeReturn,
1898	XtPointer *pValReturn,
1899	unsigned long *pcLenReturn,
1900	int *piFormatReturn)
1901	{
1902	LogFlowFuncEnter();
1903
1904	PSHCLX11CTX pCtx = clipLookupContext(widget);
1905	if (!pCtx)
1906	return False;
1907
1908	/* Is this the rigt selection (clipboard) we were asked for? */
1909	if (!clipIsSupportedSelectionType(pCtx, *atomSelection))
1910	return False;
1911
1912	int rc;
1913	if (*atomTarget == clipGetAtom(pCtx, "TARGETS"))
1914	rc = clipCreateX11Targets(pCtx, atomTypeReturn, pValReturn,
1915	pcLenReturn, piFormatReturn);
1916	else
1917	rc = clipConvertToX11Data(pCtx, atomTarget, atomTypeReturn,
1918	pValReturn, pcLenReturn, piFormatReturn);
1919
1920	#if 0 /** @todo Disabled -- crashes when running with tstClipboardGH-X11. */
1921	XSelectionRequestEvent* pReq =
1922	XtGetSelectionRequest(widget, *atomSelection, (XtRequestId)NULL);
1923	LogFlowFunc(("returning pVBoxWnd=%#x, ownerWnd=%#x, reqWnd=%#x, %RTbool, rc=%Rrc\n",
1924	XtWindow(pCtx->pWidget), pReq->owner, pReq->requestor, RT_SUCCESS(rc), rc));
1925	#endif
1926	return RT_SUCCESS(rc) ? True : False;
1927	}
1928
1929	static void clipXtConvertSelectionProcLose(Widget widget, Atom *atomSelection)
1930	{
1931	RT_NOREF(widget, atomSelection);
1932	LogFlowFuncEnter();
1933	}
1934
1935	static void clipXtConvertSelectionProcDone(Widget widget, Atom atomSelection, Atom atomTarget)
1936	{
1937	RT_NOREF(widget, atomSelection, atomTarget);
1938	LogFlowFuncEnter();
1939	}
1940
1941	/**
1942	* Invalidates the local clipboard cache.
1943	*
1944	* @param pCtx The X11 clipboard context to use.
1945	*/
1946	static void clipInvalidateClipboardCache(PSHCLX11CTX pCtx)
1947	{
1948	LogFlowFuncEnter();
1949
1950	ShClCacheInvalidate(&pCtx->Cache);
1951	}
1952
1953	/**
1954	* Takes possession of the X11 clipboard (and middle-button selection).
1955	*
1956	* @param pCtx The X11 clipboard context to use.
1957	* @param uFormats Clipboard formats to set.
1958	*/
1959	static void clipGrabX11Clipboard(PSHCLX11CTX pCtx, SHCLFORMATS uFormats)
1960	{
1961	LogFlowFuncEnter();
1962
1963	/** @ŧodo r=andy The docs say: "the value CurrentTime is not acceptable" here!? */
1964	if (XtOwnSelection(pCtx->pWidget, clipGetAtom(pCtx, "CLIPBOARD"),
1965	CurrentTime,
1966	clipXtConvertSelectionProc, clipXtConvertSelectionProcLose, clipXtConvertSelectionProcDone))
1967	{
1968	pCtx->vboxFormats = uFormats;
1969
1970	/* Grab the middle-button paste selection too. */
1971	XtOwnSelection(pCtx->pWidget, clipGetAtom(pCtx, "PRIMARY"),
1972	CurrentTime, clipXtConvertSelectionProc, NULL, 0);
1973	#ifndef TESTCASE
1974	/* Xt suppresses these if we already own the clipboard, so send them
1975	* ourselves. */
1976	XSetSelectionOwner(XtDisplay(pCtx->pWidget),
1977	clipGetAtom(pCtx, "CLIPBOARD"),
1978	XtWindow(pCtx->pWidget), CurrentTime);
1979	XSetSelectionOwner(XtDisplay(pCtx->pWidget),
1980	clipGetAtom(pCtx, "PRIMARY"),
1981	XtWindow(pCtx->pWidget), CurrentTime);
1982	#endif
1983	}
1984	}
1985
1986	/**
1987	* Worker function for ShClX11ReportFormatsToX11Async.
1988	*
1989	* @param pvUserData Pointer to a PSHCLX11REQUEST structure containing
1990	* information about the VBox formats available and the
1991	* clipboard context data. Must be free'd by the worker.
1992	*
1993	* @thread X11 event thread.
1994	*/
1995	static void shClX11ReportFormatsToX11Worker(void pvUserData, void /* interval */)
1996	{
1997	AssertPtrReturnVoid(pvUserData);
1998
1999	PSHCLX11REQUEST pReq = (PSHCLX11REQUEST)pvUserData;
2000	AssertReturnVoid(pReq->enmType == SHCLX11EVENTTYPE_REPORT_FORMATS);
2001
2002	PSHCLX11CTX pCtx = pReq->pCtx;
2003	SHCLFORMATS fFormats = pReq->Formats.fFormats;
2004
2005	RTMemFree(pReq);
2006
2007	#ifdef LOG_ENABLED
2008	char *pszFmts = ShClFormatsToStrA(fFormats);
2009	AssertPtrReturnVoid(pszFmts);
2010	LogRel2(("Shared Clipboard: Reported available VBox formats %s to X11\n", pszFmts));
2011	RTStrFree(pszFmts);
2012	#endif
2013
2014	clipInvalidateClipboardCache(pCtx);
2015	clipGrabX11Clipboard(pCtx, fFormats);
2016	clipResetX11Formats(pCtx);
2017
2018	LogFlowFuncLeave();
2019	}
2020
2021	/**
2022	* Announces new clipboard formats to the X11 clipboard.
2023	*
2024	* @returns VBox status code.
2025	* @param pCtx Context data for the clipboard backend.
2026	* @param uFormats Clipboard formats offered.
2027	*
2028	* @note When calling this function, data for the clipboard already has to be available,
2029	* as we grab the clipboard, which in turn then calls the X11 data conversion callback.
2030	*/
2031	int ShClX11ReportFormatsToX11Async(PSHCLX11CTX pCtx, SHCLFORMATS uFormats)
2032	{
2033	if (shClX11HeadlessIsEnabled(pCtx))
2034	return VINF_SUCCESS;
2035
2036	int rc;
2037
2038	PSHCLX11REQUEST pReq = (PSHCLX11REQUEST)RTMemAllocZ(sizeof(SHCLX11REQUEST));
2039	if (pReq)
2040	{
2041	pReq->enmType = SHCLX11EVENTTYPE_REPORT_FORMATS;
2042	pReq->pCtx = pCtx;
2043	pReq->Formats.fFormats = uFormats;
2044
2045	rc = clipThreadScheduleCall(pCtx, shClX11ReportFormatsToX11Worker, (XtPointer)pReq);
2046	if (RT_FAILURE(rc))
2047	RTMemFree(pReq);
2048	}
2049	else
2050	rc = VERR_NO_MEMORY;
2051
2052	LogFlowFuncLeaveRC(rc);
2053	return rc;
2054	}
2055
2056	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
2057	/**
2058	* Converts transfer data to a format returned back to X11.
2059	*
2060	* @returns VBox status code.
2061	* @param pszSrc Transfer data to convert.
2062	* @param cbSrc Size of transfer data (in bytes) to convert.
2063	* @param enmFmtX11 X11 format to convert data to.
2064	* @param ppvDst Where to return converted data on success. Must be free'd with XtFree().
2065	* @param pcbDst Where to return the bytes of the converted data on success. Optional.
2066	*/
2067	int ShClX11TransferConvertToX11(const char pszSrc, size_t cbSrc, SHCLX11FMT enmFmtX11, void ppvDst, size_t pcbDst)
2068	{
2069	AssertPtrReturn(pszSrc, VERR_INVALID_POINTER);
2070	AssertReturn(cbSrc, VERR_INVALID_PARAMETER);
2071	AssertPtrReturn(ppvDst, VERR_INVALID_POINTER);
2072	/* pcbDst is optional. */
2073
2074	int rc = VINF_SUCCESS;
2075
2076	char *pszDst = NULL;
2077
2078	# ifdef DEBUG_andy
2079	LogFlowFunc(("Src:\n%.*RhXd\n", cbSrc, pszSrc));
2080	# endif
2081
2082	switch (enmFmtX11)
2083	{
2084	case SHCLX11FMT_URI_LIST_GNOME_COPIED_FILES:
2085	RT_FALL_THROUGH();
2086	case SHCLX11FMT_URI_LIST_MATE_COPIED_FILES:
2087	RT_FALL_THROUGH();
2088	case SHCLX11FMT_URI_LIST_NAUTILUS_CLIPBOARD:
2089	RT_FALL_THROUGH();
2090	case SHCLX11FMT_URI_LIST_KDE_CUTSELECTION:
2091	{
2092	const char chSep = '\n'; /* Currently (?) all entries need to be separated by '\n'. */
2093
2094	/* Note: There must be no final new line ('\n') at the end, otherwise Nautilus will crash! */
2095	pszDst = RTStrAPrintf2("copy%c%s", chSep, pszSrc);
2096	if (!pszDst)
2097	rc = VERR_NO_MEMORY;
2098	break;
2099	}
2100
2101	case SHCLX11FMT_URI_LIST:
2102	{
2103	pszDst = RTStrDup(pszSrc);
2104	AssertPtrBreakStmt(pszDst, rc = VERR_NO_MEMORY);
2105	break;
2106	}
2107
2108	default:
2109	AssertFailed(); /* Most likely a bug in the code; let me know. */
2110	break;
2111	}
2112
2113	if (RT_SUCCESS(rc))
2114	{
2115	size_t const cbDst = RTStrNLen(pszDst, RTSTR_MAX);
2116	void pvDst = (void )XtMalloc(cbDst);
2117	if (pvDst)
2118	{
2119	memcpy(pvDst, pszDst, cbDst);
2120	# ifdef DEBUG_andy
2121	LogFlowFunc(("Dst:\n%.*RhXd\n", cbDst, pvDst));
2122	# endif
2123	}
2124	else
2125	rc = VERR_NO_MEMORY;
2126
2127	if (pcbDst)
2128	*pcbDst = cbDst;
2129	*ppvDst = pvDst;
2130
2131	RTStrFree(pszDst);
2132	pszDst = NULL;
2133	}
2134
2135	LogFlowFuncLeaveRC(rc);
2136	return rc;
2137	}
2138
2139	/**
2140	* Converts X11 data to a string list usable for transfers.
2141	*
2142	* @returns VBox status code.
2143	* @param pvData Data to conver to a string list.
2144	* @param cbData Size (in bytes) of \a pvData.
2145	* @param ppszList Where to return the allocated string list on success.
2146	* Must be free'd with RTStrFree().
2147	* @param pcbList Size (in bytes) of the returned string list on success.
2148	* Includes terminator.
2149	*/
2150	int ShClX11TransferConvertFromX11(const char pvData, size_t cbData, char ppszList, size_t pcbList)
2151	{
2152	AssertPtrReturn(pvData, VERR_INVALID_POINTER);
2153	AssertReturn(cbData, VERR_INVALID_PARAMETER);
2154	AssertPtrNullReturn(ppszList, VERR_INVALID_POINTER);
2155	AssertPtrReturn(pcbList, VERR_INVALID_POINTER);
2156
2157	/* For URI lists we only accept valid UTF-8 encodings. */
2158	int rc = RTStrValidateEncodingEx((char )pvData, cbData, 0 / fFlags */);
2159	if (RT_FAILURE(rc))
2160	return rc;
2161
2162	/* We might need to skip some prefixes before actually reaching the file list. */
2163	static const char *s_aszPrefixesToSkip[] =
2164	{ "copy\n" /* Nautilus / Nemo */ };
2165	for (size_t i = 0; i < RT_ELEMENTS(s_aszPrefixesToSkip); i++)
2166	{
2167	const char *pszNeedle = RTStrStr(pvData, s_aszPrefixesToSkip[i]);
2168	if (pszNeedle)
2169	{
2170	size_t const cbNeedle = strlen(s_aszPrefixesToSkip[i]);
2171	pszNeedle += cbNeedle;
2172	pvData = pszNeedle;
2173	Assert(cbData >= cbNeedle);
2174	cbData -= cbNeedle;
2175	}
2176	}
2177
2178	*pcbList = 0;
2179
2180	# ifdef DEBUG_andy
2181	LogFlowFunc(("Data:\n%.*RhXd\n", cbData, pvData));
2182	# endif
2183
2184	char **papszStrings;
2185	size_t cStrings;
2186	rc = RTStrSplit(pvData, cbData, SHCL_TRANSFER_URI_LIST_SEP_STR, &papszStrings, &cStrings);
2187	if (RT_SUCCESS(rc))
2188	{
2189	for (size_t i = 0; i < cStrings; i++)
2190	{
2191	const char *pszString = papszStrings[i];
2192	LogRel2(("Shared Clipboard: Received entry #%zu from X11: '%s'\n", i, pszString));
2193	rc = RTStrAAppend(ppszList, pszString);
2194	if (RT_FAILURE(rc))
2195	break;
2196	*pcbList += strlen(pszString);
2197	}
2198
2199	pcbList += 1; / Include terminator. */
2200	}
2201
2202	return rc;
2203	}
2204	#endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
2205
2206	/**
2207	* Worker function for clipConvertDataFromX11.
2208	*
2209	* Converts the data read from the X11 clipboard to the required format.
2210	* Signals the wait event.
2211	*
2212	* Converts the text obtained UTF-16LE with Windows EOLs.
2213	* Converts full BMP data to DIB format.
2214	*
2215	* @thread X11 event thread.
2216	*/
2217	SHCL_X11_DECL(void) clipConvertDataFromX11Worker(void pClient, void pvSrc, unsigned cbSrc)
2218	{
2219	PSHCLX11REQUEST pReq = (PSHCLX11REQUEST)pClient;
2220	AssertPtrReturnVoid(pReq);
2221
2222	LogFlowFunc(("uFmtVBox=%#x, idxFmtX11=%u, pvSrc=%p, cbSrc=%u\n", pReq->Read.uFmtVBox, pReq->Read.idxFmtX11, pvSrc, cbSrc));
2223
2224	/* Sanity. */
2225	AssertReturnVoid(pReq->enmType == SHCLX11EVENTTYPE_READ);
2226	AssertReturnVoid(pReq->Read.uFmtVBox != VBOX_SHCL_FMT_NONE);
2227	AssertReturnVoid(pReq->Read.idxFmtX11 < SHCL_MAX_X11_FORMATS);
2228
2229	AssertPtrReturnVoid(pReq->pCtx);
2230
2231	LogRel2(("Shared Clipboard: Converting X11 format index %#x to VBox format %#x (%RU32 bytes max)\n",
2232	pReq->Read.idxFmtX11, pReq->Read.uFmtVBox, pReq->Read.cbMax));
2233
2234	int rc = VINF_SUCCESS;
2235
2236	void *pvDst = NULL;
2237	size_t cbDst = 0;
2238
2239	PSHCLX11CTX pCtx = pReq->pCtx;
2240	AssertPtr(pReq->pCtx);
2241
2242	#ifdef VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY
2243	clipSetXtBusy(pCtx, false);
2244	if (clipGetXtNeedsUpdate(pCtx))
2245	clipQueryX11Targets(pCtx);
2246	#endif
2247
2248	/* If X11 clipboard buffer has no data, libXt can pass to XtGetSelectionValue()
2249	* callback an empty string, in this case cbSrc is 0. */
2250	if (pvSrc == NULL \|\| cbSrc == 0)
2251	{
2252	/* The clipboard selection may have changed before we could get it. */
2253	rc = VERR_SHCLPB_NO_DATA;
2254	}
2255	else if (pReq->Read.uFmtVBox == VBOX_SHCL_FMT_UNICODETEXT)
2256	{
2257	/* In which format is the clipboard data? */
2258	switch (clipRealFormatForX11Format(pReq->Read.idxFmtX11))
2259	{
2260	case SHCLX11FMT_UTF8:
2261	RT_FALL_THROUGH();
2262	case SHCLX11FMT_TEXT:
2263	{
2264	size_t cwDst;
2265	/* If we are given broken UTF-8, we treat it as Latin1. / /* @todo BUGBUG Is this acceptable? */
2266	if (RT_SUCCESS(RTStrValidateEncodingEx((char *)pvSrc, cbSrc, 0)))
2267	rc = ShClConvUtf8LFToUtf16CRLF((const char *)pvSrc, cbSrc,
2268	(PRTUTF16 *)&pvDst, &cwDst);
2269	else
2270	rc = ShClConvLatin1LFToUtf16CRLF((char *)pvSrc, cbSrc,
2271	(PRTUTF16 *)&pvDst, &cwDst);
2272	if (RT_SUCCESS(rc))
2273	{
2274	cwDst += 1 /* Include terminator */;
2275	cbDst = cwDst * sizeof(RTUTF16); /* Convert RTUTF16 units to bytes. */
2276
2277	LogFlowFunc(("UTF-16 text (%zu bytes):\n%ls\n", cbDst, pvDst));
2278	}
2279	break;
2280	}
2281
2282	default:
2283	{
2284	rc = VERR_INVALID_PARAMETER;
2285	break;
2286	}
2287	}
2288	}
2289	else if (pReq->Read.uFmtVBox == VBOX_SHCL_FMT_BITMAP)
2290	{
2291	/* In which format is the clipboard data? */
2292	switch (clipRealFormatForX11Format(pReq->Read.idxFmtX11))
2293	{
2294	case SHCLX11FMT_BMP:
2295	{
2296	const void *pDib;
2297	size_t cbDibSize;
2298	rc = ShClBmpGetDib((const void *)pvSrc, cbSrc,
2299	&pDib, &cbDibSize);
2300	if (RT_SUCCESS(rc))
2301	{
2302	pvDst = RTMemAlloc(cbDibSize);
2303	if (!pvDst)
2304	rc = VERR_NO_MEMORY;
2305	else
2306	{
2307	memcpy(pvDst, pDib, cbDibSize);
2308	cbDst = cbDibSize;
2309	}
2310	}
2311	break;
2312	}
2313
2314	default:
2315	{
2316	rc = VERR_INVALID_PARAMETER;
2317	break;
2318	}
2319	}
2320	}
2321	else if (pReq->Read.uFmtVBox == VBOX_SHCL_FMT_HTML)
2322	{
2323	/* In which format is the clipboard data? */
2324	switch (clipRealFormatForX11Format(pReq->Read.idxFmtX11))
2325	{
2326	case SHCLX11FMT_HTML:
2327	{
2328	/*
2329	* The common VBox HTML encoding will be - UTF-8
2330	* because it more general for HTML formats then UTF-16
2331	* X11 clipboard returns UTF-16, so before sending it we should
2332	* convert it to UTF-8.
2333	*/
2334	pvDst = NULL;
2335	cbDst = 0;
2336
2337	/*
2338	* Some applications sends data in UTF-16, some in UTF-8,
2339	* without indication it in MIME.
2340	*
2341	* In case of UTF-16, at least [Open\|Libre] Office adds an byte order mark (0xfeff)
2342	* at the start of the clipboard data.
2343	*/
2344	if ( cbSrc >= sizeof(RTUTF16)
2345	&& *(PRTUTF16)pvSrc == VBOX_SHCL_UTF16LEMARKER)
2346	{
2347	rc = ShClConvUtf16ToUtf8HTML((PRTUTF16)pvSrc, cbSrc / sizeof(RTUTF16), (char**)&pvDst, &cbDst);
2348	if (RT_SUCCESS(rc))
2349	{
2350	LogFlowFunc(("UTF-16 Unicode source (%u bytes):\n%ls\n\n", cbSrc, pvSrc));
2351	LogFlowFunc(("Byte Order Mark = %hx", ((PRTUTF16)pvSrc)[0]));
2352	LogFlowFunc(("UTF-8 Unicode dest (%u bytes):\n%s\n\n", cbDst, pvDst));
2353	}
2354	else
2355	LogRel(("Shared Clipboard: Converting UTF-16 Unicode failed with %Rrc\n", rc));
2356	}
2357	else /* Raw data. */
2358	{
2359	pvDst = RTMemAllocZ(cbSrc + 1 /* '\0' */);
2360	if(pvDst)
2361	{
2362	memcpy(pvDst, pvSrc, cbSrc);
2363	cbDst = cbSrc + 1 /* '\0' */;
2364	}
2365	else
2366	{
2367	rc = VERR_NO_MEMORY;
2368	break;
2369	}
2370	}
2371
2372	rc = VINF_SUCCESS;
2373	break;
2374	}
2375
2376	default:
2377	{
2378	rc = VERR_INVALID_PARAMETER;
2379	break;
2380	}
2381	}
2382	}
2383	# ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
2384	else if (pReq->Read.uFmtVBox == VBOX_SHCL_FMT_URI_LIST)
2385	{
2386	/* In which format is the clipboard data? */
2387	switch (clipRealFormatForX11Format(pReq->Read.idxFmtX11))
2388	{
2389	case SHCLX11FMT_URI_LIST:
2390	RT_FALL_THROUGH();
2391	case SHCLX11FMT_URI_LIST_GNOME_COPIED_FILES:
2392	RT_FALL_THROUGH();
2393	case SHCLX11FMT_URI_LIST_MATE_COPIED_FILES:
2394	RT_FALL_THROUGH();
2395	case SHCLX11FMT_URI_LIST_NAUTILUS_CLIPBOARD:
2396	RT_FALL_THROUGH();
2397	case SHCLX11FMT_URI_LIST_KDE_CUTSELECTION:
2398	{
2399	rc = ShClX11TransferConvertFromX11((const char )pvSrc, cbSrc, (char *)&pvDst, &cbDst);
2400	break;
2401	}
2402
2403	default:
2404	{
2405	AssertFailedStmt(rc = VERR_NOT_SUPPORTED); /* Missing code? */
2406	break;
2407	}
2408	}
2409	}
2410	# endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
2411	else
2412	rc = VERR_NOT_SUPPORTED;
2413
2414	LogFlowFunc(("pvDst=%p, cbDst=%RU32\n", pvDst, cbDst));
2415
2416	if (RT_FAILURE(rc))
2417	LogRel(("Shared Clipboard: Converting X11 format index %#x to VBox format %#x failed, rc=%Rrc\n",
2418	pReq->Read.idxFmtX11, pReq->Read.uFmtVBox, rc));
2419
2420	PSHCLEVENTPAYLOAD pPayload = NULL;
2421
2422	if ( pvDst
2423	&& cbDst)
2424	{
2425	size_t cbResp = sizeof(SHCLX11RESPONSE);
2426	PSHCLX11RESPONSE pResp = (PSHCLX11RESPONSE)RTMemAllocZ(cbResp);
2427	if (pResp)
2428	{
2429	pResp->enmType = SHCLX11EVENTTYPE_READ;
2430	pResp->Read.pvData = pvDst;
2431	pResp->Read.cbData = cbDst;
2432
2433	pvDst = NULL; /* The response owns the data now. */
2434
2435	rc = ShClPayloadInit(0 /* ID, unused */, pResp, cbResp, &pPayload);
2436	}
2437	else
2438	rc = VERR_NO_MEMORY;
2439	}
2440
2441	/* Let the caller know in any case. */
2442	int rc2 = ShClEventSignal(pReq->pEvent, pPayload);
2443	if (RT_SUCCESS(rc2))
2444	pPayload = NULL; /* The event owns the payload now. */
2445
2446	if (RT_SUCCESS(rc))
2447	rc = rc2;
2448
2449	if (pPayload) /* Free payload on error. */
2450	{
2451	ShClPayloadFree(pPayload);
2452	pPayload = NULL;
2453	}
2454
2455	LogRel2(("Shared Clipboard: Converting X11 clipboard data completed with %Rrc\n", rc));
2456
2457	RTMemFree(pReq);
2458	RTMemFree(pvDst);
2459
2460	LogFlowFuncLeaveRC(rc);
2461	}
2462
2463	/**
2464	* Converts the data read from the X11 clipboard to the required format.
2465	*
2466	* @thread X11 event thread.
2467	*/
2468	SHCL_X11_DECL(void) clipConvertDataFromX11(Widget widget, XtPointer pClient,
2469	Atom * /* selection /, Atom atomType,
2470	XtPointer pvSrc, long unsigned int *pcLen,
2471	int *piFormat)
2472	{
2473	RT_NOREF(widget);
2474
2475	int rc = VINF_SUCCESS;
2476
2477	if (atomType == XT_CONVERT_FAIL) / Xt timeout */
2478	{
2479	LogRel(("Shared Clipboard: Reading clipboard data from X11 timed out\n"));
2480	rc = VERR_TIMEOUT;
2481	}
2482	else
2483	{
2484	PSHCLX11REQUEST pReq = (PSHCLX11REQUEST)pClient;
2485	if (pReq) /* Give some more clues, if available. */
2486	{
2487	AssertReturnVoid(pReq->enmType == SHCLX11EVENTTYPE_READ);
2488	char *pszFmts = ShClFormatsToStrA(pReq->Read.uFmtVBox);
2489	AssertPtrReturnVoid(pszFmts);
2490	AssertReturnVoid(pReq->Read.idxFmtX11 < SHCL_MAX_X11_FORMATS); /* Paranoia, should be checked already by the caller. */
2491	LogRel2(("Shared Clipboard: Converting X11 format '%s' -> VBox format(s) '%s'\n", g_aFormats[pReq->Read.idxFmtX11].pcszAtom, pszFmts));
2492	RTStrFree(pszFmts);
2493
2494	if (pReq->pCtx->Callbacks.pfnOnClipboardRead) /* Usually only used for testcases. */
2495	{
2496	void *pvData = NULL;
2497	size_t cbData = 0;
2498	rc = pReq->pCtx->Callbacks.pfnOnClipboardRead(pReq->pCtx->pFrontend, pReq->Read.uFmtVBox, &pvData, &cbData, NULL);
2499	if (RT_SUCCESS(rc))
2500	{
2501	/* Feed to conversion worker. */
2502	clipConvertDataFromX11Worker(pClient, pvData, cbData);
2503	RTMemFree(pvData);
2504	}
2505	}
2506	else /* Call conversion worker with current data provided by X (default). */
2507	clipConvertDataFromX11Worker(pClient, pvSrc, (pcLen) (*piFormat) / 8);
2508	}
2509	else
2510	rc = VERR_INVALID_POINTER;
2511	}
2512
2513	if (RT_FAILURE(rc))
2514	{
2515	LogRel(("Shared Clipboard: Reading clipboard data from X11 failed with %Rrc\n", rc));
2516
2517	/* Make sure to complete the request in any case by calling the conversion worker. */
2518	clipConvertDataFromX11Worker(pClient, NULL, 0);
2519	}
2520
2521	XtFree((char *)pvSrc);
2522	}
2523
2524	/**
2525	* Requests the current clipboard data from a specific selection.
2526	*
2527	* @returns VBox status code.
2528	* @param pCtx The X11 clipboard context to use.
2529	* @param pszWhere Clipboard selection to request the data from.
2530	* @param idxFmt The X11 format to request the data in.
2531	* @param pReq Where to store the requested data on success.
2532	*/
2533	static int clipGetSelectionValueEx(PSHCLX11CTX pCtx, const char *pszWhere, SHCLX11FMTIDX idxFmt,
2534	PSHCLX11REQUEST pReq)
2535	{
2536	AssertPtrReturn(pszWhere, VERR_INVALID_POINTER);
2537	AssertReturn(idxFmt < SHCL_MAX_X11_FORMATS, VERR_INVALID_PARAMETER);
2538	AssertReturn(clipIsSupportedSelectionType(pCtx, clipGetAtom(pCtx, pszWhere)), VERR_INVALID_PARAMETER);
2539	AssertPtrReturn(pReq, VERR_INVALID_POINTER);
2540
2541	LogRel2(("Shared Clipboard: Requesting X11 selection value in %s for format '%s'\n", pszWhere, g_aFormats[idxFmt].pcszAtom));
2542
2543	#ifndef TESTCASE
2544	XtGetSelectionValue(pCtx->pWidget, clipGetAtom(pCtx, pszWhere),
2545	clipAtomForX11Format(pCtx, idxFmt),
2546	clipConvertDataFromX11,
2547	reinterpret_cast<XtPointer>(pReq),
2548	CurrentTime);
2549	#else
2550	tstClipRequestData(pCtx, idxFmt, (void *)pReq);
2551	#endif
2552
2553	return VINF_SUCCESS; /** @todo Return real rc. */
2554	}
2555
2556	/**
2557	* Requests the current clipboard data from the CLIPBOARD selection.
2558	*
2559	* @returns VBox status code.
2560	* @param pCtx The X11 clipboard context to use.
2561	* @param idxFmt The X11 format to request the data in.
2562	* @param pReq Where to store the requested data on success.
2563	*
2564	* @sa clipGetSelectionValueEx() for requesting data for a specific selection.
2565	*/
2566	static int clipGetSelectionValue(PSHCLX11CTX pCtx, SHCLX11FMTIDX idxFmt, PSHCLX11REQUEST pReq)
2567	{
2568	return clipGetSelectionValueEx(pCtx, "CLIPBOARD", idxFmt, pReq);
2569	}
2570
2571	/**
2572	* Worker function for ShClX11ReadDataFromX11Async.
2573	*
2574	* @param pvUserData Pointer to a PSHCLX11REQUEST structure containing
2575	* information about the clipboard read request.
2576	* Must be free'd by the worker.
2577	* @thread X11 event thread.
2578	*/
2579	static void ShClX11ReadDataFromX11Worker(void pvUserData, void /* interval */)
2580	{
2581	AssertPtrReturnVoid(pvUserData);
2582
2583	PSHCLX11REQUEST pReq = (PSHCLX11REQUEST)pvUserData;
2584	AssertReturnVoid(pReq->enmType == SHCLX11EVENTTYPE_READ);
2585	SHCLX11CTX *pCtx = pReq->pCtx;
2586	AssertPtrReturnVoid(pCtx);
2587
2588	LogFlowFunc(("pReq->uFmtVBox=%#x, idxFmtX11=%#x\n", pReq->Read.uFmtVBox, pReq->Read.idxFmtX11));
2589
2590	int rc = VERR_SHCLPB_NO_DATA; /* VBox thinks we have data and we don't. */
2591
2592	#ifdef VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY
2593	const bool fXtBusy = clipGetXtBusy(pCtx);
2594	clipSetXtBusy(pCtx, true);
2595	if (fXtBusy)
2596	{
2597	/* If the clipboard is busy just fend off the request. */
2598	rc = VERR_TRY_AGAIN;
2599	}
2600	else
2601	#endif
2602	if (pReq->Read.uFmtVBox & VBOX_SHCL_FMT_UNICODETEXT)
2603	{
2604	pReq->Read.idxFmtX11 = pCtx->idxFmtText;
2605	if (pReq->Read.idxFmtX11 != SHCLX11FMT_INVALID)
2606	{
2607	/* Send out a request for the data to the current clipboard owner. */
2608	rc = clipGetSelectionValue(pCtx, pCtx->idxFmtText, pReq);
2609	}
2610	}
2611	else if (pReq->Read.uFmtVBox & VBOX_SHCL_FMT_BITMAP)
2612	{
2613	pReq->Read.idxFmtX11 = pCtx->idxFmtBmp;
2614	if (pReq->Read.idxFmtX11 != SHCLX11FMT_INVALID)
2615	{
2616	/* Send out a request for the data to the current clipboard owner. */
2617	rc = clipGetSelectionValue(pCtx, pCtx->idxFmtBmp, pReq);
2618	}
2619	}
2620	else if (pReq->Read.uFmtVBox & VBOX_SHCL_FMT_HTML)
2621	{
2622	pReq->Read.idxFmtX11 = pCtx->idxFmtHTML;
2623	if (pReq->Read.idxFmtX11 != SHCLX11FMT_INVALID)
2624	{
2625	/* Send out a request for the data to the current clipboard owner. */
2626	rc = clipGetSelectionValue(pCtx, pCtx->idxFmtHTML, pReq);
2627	}
2628	}
2629	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
2630	else if (pReq->Read.uFmtVBox & VBOX_SHCL_FMT_URI_LIST)
2631	{
2632	pReq->Read.idxFmtX11 = pCtx->idxFmtURI;
2633	if (pReq->Read.idxFmtX11 != SHCLX11FMT_INVALID)
2634	{
2635	/* Send out a request for the data to the current clipboard owner. */
2636	rc = clipGetSelectionValue(pCtx, pCtx->idxFmtURI, pReq);
2637	}
2638	}
2639	#endif
2640	else
2641	{
2642	#ifdef VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY
2643	clipSetXtBusy(pCtx, false);
2644	#endif
2645	rc = VERR_NOT_IMPLEMENTED;
2646	}
2647
2648	/* If the above stuff fails, make sure to let the waiters know.
2649	*
2650	* Getting the actual selection value via clipGetSelectionValue[Ex]() above will happen in the X event thread,
2651	* which has its own signalling then. So this check only handles errors which happens before we put anything
2652	* onto the X event thread.
2653	*/
2654	if (RT_FAILURE(rc))
2655	{
2656	int rc2 = ShClEventSignalEx(pReq->pEvent, rc, NULL /* Payload */);
2657	AssertRC(rc2);
2658
2659	RTMemFree(pReq);
2660	}
2661
2662	LogRel2(("Shared Clipboard: Reading X11 clipboard data completed with %Rrc\n", rc));
2663
2664	LogFlowFuncLeaveRC(rc);
2665	}
2666
2667	/**
2668	* Reads from the X11 clipboard (asynchronously).
2669	*
2670	* @returns VBox status code.
2671	* @param pCtx Context data for the clipboard backend.
2672	* @param uFmt The format that the VBox would like to receive the data in.
2673	* @param cbMax Maximum data to read (in bytes).
2674	* Specify UINT32_MAX to read as much as available.
2675	* @param pEvent Event to use for waiting for data to arrive.
2676	* The event's payload will contain the data read. Needs to be free'd with ShClEventRelease().
2677	*/
2678	int ShClX11ReadDataFromX11Async(PSHCLX11CTX pCtx, SHCLFORMAT uFmt, uint32_t cbMax, PSHCLEVENT pEvent)
2679	{
2680	AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
2681
2682	if (shClX11HeadlessIsEnabled(pCtx))
2683	return VINF_SUCCESS;
2684
2685	int rc = VINF_SUCCESS;
2686
2687	PSHCLX11REQUEST pReq = (PSHCLX11REQUEST)RTMemAllocZ(sizeof(SHCLX11REQUEST));
2688	if (pReq)
2689	{
2690	pReq->enmType = SHCLX11EVENTTYPE_READ;
2691	pReq->pCtx = pCtx;
2692	pReq->Read.uFmtVBox = uFmt;
2693	pReq->Read.cbMax = cbMax;
2694	pReq->pEvent = pEvent;
2695
2696	/* We use this to schedule a worker function on the event thread. */
2697	rc = clipThreadScheduleCall(pCtx, ShClX11ReadDataFromX11Worker, (XtPointer)pReq);
2698	if (RT_FAILURE(rc))
2699	RTMemFree(pReq);
2700	}
2701	else
2702	rc = VERR_NO_MEMORY;
2703
2704	LogFlowFuncLeaveRC(rc);
2705	return rc;
2706	}
2707
2708	/**
2709	* Reads from the X11 clipboard, internal version.
2710	*
2711	* @returns VBox status code.
2712	* @retval VERR_SHCLPB_NO_DATA if format is supported but no data is available currently.
2713	* @retval VERR_NOT_IMPLEMENTED if the format is not implemented.
2714	* @param pCtx Context data for the clipboard backend.
2715	* @param pEventSource Event source to use.
2716	* @param msTimeout Timeout (in ms) for waiting.
2717	* @param uFmt The format that the VBox would like to receive the data in.
2718	* @param cbMax Maximum size (in bytes) to read.
2719	* @param pResp Where to return the allocated SHCLX11RESPONSE on success.
2720	* Must be free'd via shClX11ResponseFree() by the caller.
2721	*/
2722	static int shClX11ReadDataFromX11Internal(PSHCLX11CTX pCtx, PSHCLEVENTSOURCE pEventSource, RTMSINTERVAL msTimeout,
2723	SHCLFORMAT uFmt, uint32_t cbMax, PSHCLX11RESPONSE *ppResp)
2724	{
2725	PSHCLEVENT pEvent;
2726	int rc = ShClEventSourceGenerateAndRegisterEvent(pEventSource, &pEvent);
2727	if (RT_SUCCESS(rc))
2728	{
2729	rc = ShClX11ReadDataFromX11Async(pCtx, uFmt, cbMax, pEvent);
2730	if (RT_SUCCESS(rc))
2731	{
2732	PSHCLEVENTPAYLOAD pPayload;
2733	int rcEvent;
2734	rc = ShClEventWaitEx(pEvent, msTimeout, &rcEvent, &pPayload);
2735	if (RT_SUCCESS(rc))
2736	{
2737	if (pPayload)
2738	{
2739	if ( pPayload->cbData == sizeof(SHCLX11RESPONSE)
2740	&& RT_VALID_PTR(pPayload->pvData))
2741	{
2742	PSHCLX11RESPONSE pResp = (PSHCLX11RESPONSE)pPayload->pvData;
2743	if (pResp->enmType == SHCLX11EVENTTYPE_READ)
2744	{
2745	pPayload->pvData = NULL; /* pvData (pResp) is owned by ppResp now. */
2746	pPayload->cbData = 0;
2747
2748	ShClPayloadFree(pPayload);
2749
2750	*ppResp = pResp;
2751	}
2752	else
2753	rc = VERR_INVALID_PARAMETER;
2754	}
2755	else
2756	rc = VERR_INVALID_PARAMETER;
2757	}
2758	else /* No payload given; could happen on invalid / not-expected formats. */
2759	rc = VERR_SHCLPB_NO_DATA;
2760	}
2761	else if (rc == VERR_SHCLPB_EVENT_FAILED)
2762	rc = rcEvent;
2763	}
2764
2765	ShClEventRelease(pEvent);
2766	}
2767
2768	LogFlowFuncLeaveRC(rc);
2769	return rc;
2770	}
2771
2772	/**
2773	* Reads from the X11 clipboard, extended version.
2774	*
2775	* @returns VBox status code.
2776	* @retval VERR_SHCLPB_NO_DATA if format is supported but no data is available currently.
2777	* @retval VERR_NOT_IMPLEMENTED if the format is not implemented.
2778	* @param pCtx Context data for the clipboard backend.
2779	* @param pEventSource Event source to use.
2780	* @param msTimeout Timeout (in ms) for waiting.
2781	* @param uFmt The format that the VBox would like to receive the data in.
2782	* @param ppvBuf Where to return the allocated received data on success.
2783	* Must be free'd by the caller.
2784	* @param pcbBuf Where to return the size (in bytes) of \a ppvBuf.
2785	*/
2786	int ShClX11ReadDataFromX11Ex(PSHCLX11CTX pCtx, PSHCLEVENTSOURCE pEventSource, RTMSINTERVAL msTimeout,
2787	SHCLFORMAT uFmt, void *ppvBuf, uint32_t pcbBuf)
2788	{
2789	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
2790	AssertPtrReturn(pEventSource, VERR_INVALID_POINTER);
2791	AssertPtrReturn(ppvBuf, VERR_INVALID_POINTER);
2792	AssertPtrReturn(pcbBuf, VERR_INVALID_POINTER);
2793
2794	if (shClX11HeadlessIsEnabled(pCtx))
2795	{
2796	*pcbBuf = 0;
2797	return VINF_SUCCESS;
2798	}
2799
2800	PSHCLX11RESPONSE pResp;
2801	int rc = shClX11ReadDataFromX11Internal(pCtx, pEventSource, msTimeout, uFmt, UINT32_MAX, &pResp);
2802	if (RT_SUCCESS(rc))
2803	{
2804	*ppvBuf = pResp->Read.pvData;
2805	*pcbBuf = pResp->Read.cbData;
2806
2807	pResp->Read.pvData = NULL; /* Is owned by ppvBuf now. */
2808	pResp->Read.cbData = 0;
2809
2810	shClX11ResponseFree(pResp);
2811	}
2812
2813	LogFlowFuncLeaveRC(rc);
2814	return rc;
2815	}
2816
2817	/**
2818	* Reads from the X11 clipboard.
2819	*
2820	* @returns VBox status code.
2821	* @retval VERR_SHCLPB_NO_DATA if format is supported but no data is available currently.
2822	* @retval VERR_NOT_IMPLEMENTED if the format is not implemented.
2823	* @param pCtx Context data for the clipboard backend.
2824	* @param pEventSource Event source to use.
2825	* @param msTimeout Timeout (in ms) for waiting.
2826	* @param uFmt The format that the VBox would like to receive the data in.
2827	* @param pvBuf Where to store the received data on success.
2828	* @param cbBuf Size (in bytes) of \a pvBuf. Also marks maximum data to read (in bytes).
2829	* @param pcbRead Where to return the read bytes on success. Optional.
2830	*/
2831	int ShClX11ReadDataFromX11(PSHCLX11CTX pCtx, PSHCLEVENTSOURCE pEventSource, RTMSINTERVAL msTimeout,
2832	SHCLFORMAT uFmt, void pvBuf, uint32_t cbBuf, uint32_t pcbRead)
2833	{
2834	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
2835	AssertPtrReturn(pEventSource, VERR_INVALID_POINTER);
2836	AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
2837	AssertReturn(cbBuf, VERR_INVALID_PARAMETER);
2838	/* pcbRead is optional. */
2839
2840	if (shClX11HeadlessIsEnabled(pCtx))
2841	{
2842	if (pcbRead)
2843	*pcbRead = 0;
2844	return VINF_SUCCESS;
2845	}
2846
2847	PSHCLX11RESPONSE pResp;
2848	int rc = shClX11ReadDataFromX11Internal(pCtx, pEventSource, msTimeout, uFmt, cbBuf, &pResp);
2849	if (RT_SUCCESS(rc))
2850	{
2851	memcpy(pvBuf, pResp->Read.pvData, RT_MIN(cbBuf, pResp->Read.cbData));
2852	if (pcbRead)
2853	*pcbRead = pResp->Read.cbData;
2854
2855	shClX11ResponseFree(pResp);
2856	}
2857
2858	LogFlowFuncLeaveRC(rc);
2859	return rc;
2860	}
2861
2862	/**
2863	* Writes to the X11 clipboard (asynchronously).
2864	*
2865	* @returns VBox status code.
2866	* @param pCtx Context data for the clipboard backend.
2867	* @param uFmts The format(s) to write.
2868	* Conversions might be performed, if available.
2869	* @param pvBuf Pointer to data to write.
2870	* @param cbBuf Size (in bytes) of data to write.
2871	* @param pEvent Event to use for waiting for data to get written.
2872	* The event's payload will contain the amount of data written.
2873	* Needs to be free'd with ShClEventRelease().
2874	*/
2875	int ShClX11WriteDataToX11Async(PSHCLX11CTX pCtx, SHCLFORMATS uFmts, const void *pvBuf, uint32_t cbBuf, PSHCLEVENT pEvent)
2876	{
2877	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
2878	AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
2879	AssertReturn(cbBuf, VERR_INVALID_PARAMETER);
2880	/* pEvent not used yet. */ RT_NOREF(pEvent);
2881
2882	if (shClX11HeadlessIsEnabled(pCtx))
2883	return VINF_SUCCESS;
2884
2885	int rc = ShClCacheSetMultiple(&pCtx->Cache, uFmts, pvBuf, cbBuf);
2886	if (RT_SUCCESS(rc))
2887	{
2888	clipResetX11Formats(pCtx);
2889	clipGrabX11Clipboard(pCtx, uFmts);
2890	}
2891
2892	return VINF_SUCCESS;
2893	}
2894
2895	/**
2896	* Writes to the X11 clipboard.
2897	*
2898	* This function currently only is implemented as asynchronous version.
2899	*
2900	* @returns VBox status code.
2901	* @retval VERR_NOT_AVAILABLE the the X11 clipboard is not available.
2902	* @retval VERR_TRY_AGAIN if format is supported but data could not be written.
2903	* @retval VERR_NOT_IMPLEMENTED if the format is not implemented.
2904	* @param pCtx Context data for the clipboard backend.
2905	* @param uFmt The format to write.
2906	* @param pvBuf Pointer to data to write. Must match format to write.
2907	* @param cbBuf Size (in bytes) of data to write.
2908	* @param pcbWritten Where to return the written bytes on success. Optional.
2909	* Currently always returns the value of \a cbBuf on success.
2910	*
2911	* @note Text data must be in UTF-8, always.
2912	*/
2913	int ShClX11WriteDataToX11(PSHCLX11CTX pCtx, PSHCLEVENTSOURCE pEventSource, RTMSINTERVAL msTimeout,
2914	SHCLFORMAT uFmt, const void pvBuf, uint32_t cbBuf, uint32_t pcbWritten)
2915	{
2916	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
2917	AssertPtrReturn(pEventSource, VERR_INVALID_POINTER);
2918	AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
2919	AssertReturn(cbBuf, VERR_INVALID_PARAMETER);
2920	/* pcbWritetn is optional. */
2921
2922	RT_NOREF(msTimeout); /* Not used yet. */
2923
2924	int rc = ShClX11WriteDataToX11Async(pCtx, uFmt, pvBuf, cbBuf, NULL /* pEvent */);
2925	if (RT_SUCCESS(rc))
2926	{
2927	if (pcbWritten)
2928	*pcbWritten = cbBuf;
2929	}
2930
2931	LogFlowFuncLeaveRC(rc);
2932	return rc;
2933	}

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

source: vbox/trunk/src/VBox/GuestHost/SharedClipboard/clipboard-x11.cpp@ 106945

Download in other formats: