VirtualBox

About
Screenshots
Downloads
Documentation
End-user docs
Technical docs
Contribute
Community

Browse Source

Context Navigation

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

Last change on this file since 91933 was 91933, checked in by vboxsync, 3 years ago
X11: Shared Clipboard: handle case when libXt reports empty clipboard buffer, bugref:10117.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 76.1 KB

Line
1	/** @file
2	* Shared Clipboard: Common X11 code.
3	*/
4
5	/*
6	* Copyright (C) 2006-2020 Oracle Corporation
7	*
8	* This file is part of VirtualBox Open Source Edition (OSE), as
9	* available from http://www.virtualbox.org. This file is free software;
10	* you can redistribute it and/or modify it under the terms of the GNU
11	* General Public License (GPL) as published by the Free Software
12	* Foundation, in version 2 as it comes in the "COPYING" file of the
13	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15	*/
16
17	/* Note: to automatically run regression tests on the Shared Clipboard,
18	* execute the tstClipboardGH-X11 testcase. If you often make changes to the
19	* clipboard code, adding the line
20	*
21	* OTHERS += $(PATH_tstClipboardGH-X11)/tstClipboardGH-X11.run
22	*
23	* to LocalConfig.kmk will cause the tests to be run every time the code is
24	* changed.
25	*/
26
27
28	/*********************************************************************************************************************************
29	* Header Files *
30	*********************************************************************************************************************************/
31	#define LOG_GROUP LOG_GROUP_SHARED_CLIPBOARD
32
33	#include <errno.h>
34
35	#include <dlfcn.h>
36	#include <fcntl.h>
37	#include <unistd.h>
38
39	#ifdef RT_OS_SOLARIS
40	#include <tsol/label.h>
41	#endif
42
43	#include <X11/Xlib.h>
44	#include <X11/Xatom.h>
45	#include <X11/Intrinsic.h>
46	#include <X11/Shell.h>
47	#include <X11/Xproto.h>
48	#include <X11/StringDefs.h>
49
50	#include <iprt/assert.h>
51	#include <iprt/types.h>
52	#include <iprt/mem.h>
53	#include <iprt/semaphore.h>
54	#include <iprt/thread.h>
55	#include <iprt/utf16.h>
56	#include <iprt/uri.h>
57
58	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
59	# include <iprt/cpp/list.h>
60	# include <iprt/cpp/ministring.h>
61	# include <VBox/GuestHost/SharedClipboard-transfers.h>
62	#endif
63
64	#include <VBox/log.h>
65	#include <VBox/version.h>
66
67	#include <VBox/GuestHost/SharedClipboard.h>
68	#include <VBox/GuestHost/SharedClipboard-x11.h>
69	#include <VBox/GuestHost/clipboard-helper.h>
70	#include <VBox/HostServices/VBoxClipboardSvc.h>
71
72	/** Own macro for declaring function visibility / linkage based on whether this
73	* code runs as part of test cases or not. */
74	#ifdef TESTCASE
75	# define SHCL_X11_DECL(x) x
76	#else
77	# define SHCL_X11_DECL(x) static x
78	#endif
79
80
81	/*********************************************************************************************************************************
82	* Externals *
83	*********************************************************************************************************************************/
84	#ifdef TESTCASE
85	extern void tstThreadScheduleCall(void (proc)(void , void ), void client_data);
86	extern void tstClipRequestData(SHCLX11CTX* pCtx, SHCLX11FMTIDX target, void *closure);
87	extern void tstRequestTargets(SHCLX11CTX* pCtx);
88	#endif
89
90
91	/*********************************************************************************************************************************
92	* Prototypes *
93	*********************************************************************************************************************************/
94	class formats;
95	SHCL_X11_DECL(Atom) clipGetAtom(PSHCLX11CTX pCtx, const char *pszName);
96	SHCL_X11_DECL(void) clipQueryX11Formats(PSHCLX11CTX pCtx);
97
98	static int clipInitInternal(PSHCLX11CTX pCtx);
99	static void clipUninitInternal(PSHCLX11CTX pCtx);
100
101
102	/*********************************************************************************************************************************
103	* Global Variables *
104	*********************************************************************************************************************************/
105
106	/**
107	* The table maps X11 names to data formats
108	* and to the corresponding VBox clipboard formats.
109	*/
110	SHCL_X11_DECL(SHCLX11FMTTABLE) g_aFormats[] =
111	{
112	{ "INVALID", SHCLX11FMT_INVALID, VBOX_SHCL_FMT_NONE },
113
114	{ "UTF8_STRING", SHCLX11FMT_UTF8, VBOX_SHCL_FMT_UNICODETEXT },
115	{ "text/plain;charset=UTF-8", SHCLX11FMT_UTF8, VBOX_SHCL_FMT_UNICODETEXT },
116	{ "text/plain;charset=utf-8", SHCLX11FMT_UTF8, VBOX_SHCL_FMT_UNICODETEXT },
117	{ "STRING", SHCLX11FMT_TEXT, VBOX_SHCL_FMT_UNICODETEXT },
118	{ "TEXT", SHCLX11FMT_TEXT, VBOX_SHCL_FMT_UNICODETEXT },
119	{ "text/plain", SHCLX11FMT_TEXT, VBOX_SHCL_FMT_UNICODETEXT },
120
121	{ "text/html", SHCLX11FMT_HTML, VBOX_SHCL_FMT_HTML },
122	{ "text/html;charset=utf-8", SHCLX11FMT_HTML, VBOX_SHCL_FMT_HTML },
123
124	{ "image/bmp", SHCLX11FMT_BMP, VBOX_SHCL_FMT_BITMAP },
125	{ "image/x-bmp", SHCLX11FMT_BMP, VBOX_SHCL_FMT_BITMAP },
126	{ "image/x-MS-bmp", SHCLX11FMT_BMP, VBOX_SHCL_FMT_BITMAP },
127	/** @todo Inkscape exports image/png but not bmp... */
128
129	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
130	{ "text/uri-list", SHCLX11FMT_URI_LIST, VBOX_SHCL_FMT_URI_LIST },
131	{ "x-special/gnome-copied-files", SHCLX11FMT_URI_LIST, VBOX_SHCL_FMT_URI_LIST },
132	{ "x-special/nautilus-clipboard", SHCLX11FMT_URI_LIST, VBOX_SHCL_FMT_URI_LIST },
133	{ "application/x-kde-cutselection", SHCLX11FMT_URI_LIST, VBOX_SHCL_FMT_URI_LIST },
134	/** @todo Anything else we need to add here? */
135	/** @todo Add Wayland / Weston support. */
136	#endif
137	};
138
139
140	#ifdef TESTCASE
141	# ifdef RT_OS_SOLARIS_10
142	char XtStrings [] = "";
143	WidgetClassRec* applicationShellWidgetClass;
144	char XtShellStrings [] = "";
145	int XmbTextPropertyToTextList(
146	Display* /* display */,
147	XTextProperty* /* text_prop */,
148	char*** /* list_return */,
149	int* /* count_return */
150	)
151	{
152	return 0;
153	}
154	# else
155	const char XtStrings [] = "";
156	_WidgetClassRec* applicationShellWidgetClass;
157	const char XtShellStrings [] = "";
158	# endif /* RT_OS_SOLARIS_10 */
159	#endif /* TESTCASE */
160
161
162	/*********************************************************************************************************************************
163	* Defines *
164	*********************************************************************************************************************************/
165
166	#define SHCL_MAX_X11_FORMATS RT_ELEMENTS(g_aFormats)
167
168
169	/*********************************************************************************************************************************
170	* Internal structures *
171	*********************************************************************************************************************************/
172
173	/**
174	* A structure containing information about where to store a request
175	* for the X11 clipboard contents.
176	*/
177	typedef struct _CLIPREADX11CBREQ
178	{
179	/** The format VBox would like the data in. */
180	SHCLFORMAT uFmtVBox;
181	/** The format we requested from X11. */
182	SHCLX11FMTIDX idxFmtX11;
183	/** The clipboard context this request is associated with. */
184	SHCLX11CTX *pCtx;
185	/** The request structure passed in from the backend. */
186	CLIPREADCBREQ *pReq;
187	} CLIPREADX11CBREQ;
188
189
190
191	#ifdef TESTCASE
192	/**
193	* Return the max. number of elements in the X11 format table.
194	* Used by the testing code in tstClipboardGH-X11.cpp
195	* which cannot use RT_ELEMENTS(g_aFormats) directly.
196	*
197	* @return size_t The number of elements in the g_aFormats array.
198	*/
199	SHCL_X11_DECL(size_t) clipReportMaxX11Formats(void)
200	{
201	return (RT_ELEMENTS(g_aFormats));
202	}
203	#endif
204
205	/**
206	* Returns the atom corresponding to a supported X11 format.
207	*
208	* @returns Found atom to the corresponding X11 format.
209	* @param pCtx The X11 clipboard context to use.
210	* @param uFmtIdx Format index to look up atom for.
211	*/
212	static Atom clipAtomForX11Format(PSHCLX11CTX pCtx, SHCLX11FMTIDX uFmtIdx)
213	{
214	AssertReturn(uFmtIdx < RT_ELEMENTS(g_aFormats), 0);
215	return clipGetAtom(pCtx, g_aFormats[uFmtIdx].pcszAtom);
216	}
217
218	/**
219	* Returns the SHCLX11FMT corresponding to a supported X11 format.
220	*
221	* @return SHCLX11FMT for a specific format index.
222	* @param uFmtIdx Format index to look up SHCLX11CLIPFMT for.
223	*/
224	SHCL_X11_DECL(SHCLX11FMT) clipRealFormatForX11Format(SHCLX11FMTIDX uFmtIdx)
225	{
226	AssertReturn(uFmtIdx < RT_ELEMENTS(g_aFormats), SHCLX11FMT_INVALID);
227	return g_aFormats[uFmtIdx].enmFmtX11;
228	}
229
230	/**
231	* Returns the VBox format corresponding to a supported X11 format.
232	*
233	* @return SHCLFORMAT for a specific format index.
234	* @param uFmtIdx Format index to look up VBox format for.
235	*/
236	static SHCLFORMAT clipVBoxFormatForX11Format(SHCLX11FMTIDX uFmtIdx)
237	{
238	AssertReturn(uFmtIdx < RT_ELEMENTS(g_aFormats), VBOX_SHCL_FMT_NONE);
239	return g_aFormats[uFmtIdx].uFmtVBox;
240	}
241
242	/**
243	* Looks up the X11 format matching a given X11 atom.
244	*
245	* @returns The format on success, NIL_CLIPX11FORMAT on failure.
246	* @param pCtx The X11 clipboard context to use.
247	* @param atomFormat Atom to look up X11 format for.
248	*/
249	static SHCLX11FMTIDX clipFindX11FormatByAtom(PSHCLX11CTX pCtx, Atom atomFormat)
250	{
251	for (unsigned i = 0; i < RT_ELEMENTS(g_aFormats); ++i)
252	if (clipAtomForX11Format(pCtx, i) == atomFormat)
253	{
254	LogFlowFunc(("Returning index %u for atom '%s'\n", i, g_aFormats[i].pcszAtom));
255	return i;
256	}
257	return NIL_CLIPX11FORMAT;
258	}
259
260	/**
261	* Enumerates supported X11 clipboard formats corresponding to given VBox formats.
262	*
263	* @returns The next matching X11 format index in the list, or NIL_CLIPX11FORMAT if there are no more.
264	* @param uFormatsVBox VBox formats to enumerate supported X11 clipboard formats for.
265	* @param lastFmtIdx The value returned from the last call of this function.
266	* Use NIL_CLIPX11FORMAT to start the enumeration.
267	*/
268	static SHCLX11FMTIDX clipEnumX11Formats(SHCLFORMATS uFormatsVBox,
269	SHCLX11FMTIDX lastFmtIdx)
270	{
271	for (unsigned i = lastFmtIdx + 1; i < RT_ELEMENTS(g_aFormats); ++i)
272	{
273	if (uFormatsVBox & clipVBoxFormatForX11Format(i))
274	return i;
275	}
276
277	return NIL_CLIPX11FORMAT;
278	}
279
280	/**
281	* Array of structures for mapping Xt widgets to context pointers. We
282	* need this because the widget clipboard callbacks do not pass user data.
283	*/
284	static struct
285	{
286	/** Pointer to widget we want to associate the context with. */
287	Widget pWidget;
288	/** Pointer to X11 context associated with the widget. */
289	PSHCLX11CTX pCtx;
290	} g_aContexts[VBOX_SHARED_CLIPBOARD_X11_CONNECTIONS_MAX];
291
292	/**
293	* Registers a new X11 clipboard context.
294	*
295	* @returns VBox status code.
296	* @param pCtx The X11 clipboard context to use.
297	*/
298	static int clipRegisterContext(PSHCLX11CTX pCtx)
299	{
300	AssertPtrReturn(pCtx, VERR_INVALID_PARAMETER);
301
302	bool fFound = false;
303
304	Widget pWidget = pCtx->pWidget;
305	AssertReturn(pWidget != NULL, VERR_INVALID_PARAMETER);
306
307	for (unsigned i = 0; i < RT_ELEMENTS(g_aContexts); ++i)
308	{
309	AssertReturn( (g_aContexts[i].pWidget != pWidget)
310	&& (g_aContexts[i].pCtx != pCtx), VERR_WRONG_ORDER);
311	if (g_aContexts[i].pWidget == NULL && !fFound)
312	{
313	AssertReturn(g_aContexts[i].pCtx == NULL, VERR_INTERNAL_ERROR);
314	g_aContexts[i].pWidget = pWidget;
315	g_aContexts[i].pCtx = pCtx;
316	fFound = true;
317	}
318	}
319
320	return fFound ? VINF_SUCCESS : VERR_OUT_OF_RESOURCES;
321	}
322
323	/**
324	* Unregister an X11 clipboard context.
325	*
326	* @param pCtx The X11 clipboard context to use.
327	*/
328	static void clipUnregisterContext(PSHCLX11CTX pCtx)
329	{
330	AssertPtrReturnVoid(pCtx);
331
332	Widget pWidget = pCtx->pWidget;
333	AssertPtrReturnVoid(pWidget);
334
335	bool fFound = false;
336	for (unsigned i = 0; i < RT_ELEMENTS(g_aContexts); ++i)
337	{
338	Assert(!fFound \|\| g_aContexts[i].pWidget != pWidget);
339	if (g_aContexts[i].pWidget == pWidget)
340	{
341	Assert(g_aContexts[i].pCtx != NULL);
342	g_aContexts[i].pWidget = NULL;
343	g_aContexts[i].pCtx = NULL;
344	fFound = true;
345	}
346	}
347	}
348
349	/**
350	* Finds a X11 clipboard context for a specific X11 widget.
351	*
352	* @returns Pointer to associated X11 clipboard context if found, or NULL if not found.
353	* @param pWidget X11 widget to return X11 clipboard context for.
354	*/
355	static PSHCLX11CTX clipLookupContext(Widget pWidget)
356	{
357	AssertPtrReturn(pWidget, NULL);
358
359	for (unsigned i = 0; i < RT_ELEMENTS(g_aContexts); ++i)
360	{
361	if (g_aContexts[i].pWidget == pWidget)
362	{
363	Assert(g_aContexts[i].pCtx != NULL);
364	return g_aContexts[i].pCtx;
365	}
366	}
367
368	return NULL;
369	}
370
371	/**
372	* Converts an atom name string to an X11 atom, looking it up in a cache before asking the server.
373	*
374	* @returns Found X11 atom.
375	* @param pCtx The X11 clipboard context to use.
376	* @param pcszName Name of atom to return atom for.
377	*/
378	SHCL_X11_DECL(Atom) clipGetAtom(PSHCLX11CTX pCtx, const char *pcszName)
379	{
380	AssertPtrReturn(pcszName, None);
381	return XInternAtom(XtDisplay(pCtx->pWidget), pcszName, False);
382	}
383
384	/** String written to the wakeup pipe. */
385	#define WAKE_UP_STRING "WakeUp!"
386	/** Length of the string written. */
387	#define WAKE_UP_STRING_LEN ( sizeof(WAKE_UP_STRING) - 1 )
388
389	/**
390	* Schedules a function call to run on the Xt event thread by passing it to
391	* the application context as a 0ms timeout and waking up the event loop by
392	* writing to the wakeup pipe which it monitors.
393	*/
394	static int clipThreadScheduleCall(PSHCLX11CTX pCtx,
395	void (proc)(void , void *),
396	void *client_data)
397	{
398	LogFlowFunc(("proc=%p, client_data=%p\n", proc, client_data));
399
400	#ifndef TESTCASE
401	AssertReturn(pCtx, VERR_INVALID_POINTER);
402	AssertReturn(pCtx->pAppContext, VERR_INVALID_POINTER);
403
404	XtAppAddTimeOut(pCtx->pAppContext, 0, (XtTimerCallbackProc)proc,
405	(XtPointer)client_data);
406	ssize_t cbWritten = write(pCtx->wakeupPipeWrite, WAKE_UP_STRING, WAKE_UP_STRING_LEN);
407	Assert(cbWritten == WAKE_UP_STRING_LEN);
408	RT_NOREF(cbWritten);
409	#else
410	RT_NOREF(pCtx);
411	tstThreadScheduleCall(proc, client_data);
412	#endif
413
414	LogFlowFuncLeaveRC(VINF_SUCCESS);
415	return VINF_SUCCESS;
416	}
417
418	/**
419	* Reports the formats currently supported by the X11 clipboard to VBox.
420	*
421	* @note Runs in Xt event thread.
422	*
423	* @param pCtx The X11 clipboard context to use.
424	*/
425	static void clipReportFormatsToVBox(PSHCLX11CTX pCtx)
426	{
427	SHCLFORMATS vboxFmt = clipVBoxFormatForX11Format(pCtx->idxFmtText);
428	vboxFmt \|= clipVBoxFormatForX11Format(pCtx->idxFmtBmp);
429	vboxFmt \|= clipVBoxFormatForX11Format(pCtx->idxFmtHTML);
430	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
431	vboxFmt \|= clipVBoxFormatForX11Format(pCtx->idxFmtURI);
432	#endif
433
434	LogFlowFunc(("idxFmtText=%u ('%s'), idxFmtBmp=%u ('%s'), idxFmtHTML=%u ('%s')",
435	pCtx->idxFmtText, g_aFormats[pCtx->idxFmtText].pcszAtom,
436	pCtx->idxFmtBmp, g_aFormats[pCtx->idxFmtBmp].pcszAtom,
437	pCtx->idxFmtHTML, g_aFormats[pCtx->idxFmtHTML].pcszAtom));
438	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
439	LogFlowFunc((", idxFmtURI=%u ('%s')", pCtx->idxFmtURI, g_aFormats[pCtx->idxFmtURI].pcszAtom));
440	#endif
441	LogFlow((" -> vboxFmt=%#x\n", vboxFmt));
442
443	#ifdef LOG_ENABLED
444	char *pszFmts = ShClFormatsToStrA(vboxFmt);
445	AssertPtrReturnVoid(pszFmts);
446	LogRel2(("Shared Clipboard: X11 reported available VBox formats '%s'\n", pszFmts));
447	RTStrFree(pszFmts);
448	#endif
449
450	ShClX11ReportFormatsCallback(pCtx->pFrontend, vboxFmt);
451	}
452
453	/**
454	* Forgets which formats were previously in the X11 clipboard. Called when we
455	* grab the clipboard.
456	*
457	* @param pCtx The X11 clipboard context to use.
458	*/
459	static void clipResetX11Formats(PSHCLX11CTX pCtx)
460	{
461	LogFlowFuncEnter();
462
463	pCtx->idxFmtText = 0;
464	pCtx->idxFmtBmp = 0;
465	pCtx->idxFmtHTML = 0;
466	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
467	pCtx->idxFmtURI = 0;
468	#endif
469	}
470
471	/**
472	* Tells VBox that X11 currently has nothing in its clipboard.
473	*
474	* @param pCtx The X11 clipboard context to use.
475	*/
476	SHCL_X11_DECL(void) clipReportEmpty(PSHCLX11CTX pCtx)
477	{
478	clipResetX11Formats(pCtx);
479	clipReportFormatsToVBox(pCtx);
480	}
481
482	/**
483	* Go through an array of X11 clipboard targets to see if they contain a text
484	* format we can support, and if so choose the ones we prefer (e.g. we like
485	* UTF-8 better than plain text).
486	*
487	* @return Index to supported X clipboard format.
488	* @param pCtx The X11 clipboard context to use.
489	* @param paIdxFmtTargets The list of targets.
490	* @param cTargets The size of the list in @a pTargets.
491	*/
492	SHCL_X11_DECL(SHCLX11FMTIDX) clipGetTextFormatFromTargets(PSHCLX11CTX pCtx,
493	SHCLX11FMTIDX *paIdxFmtTargets,
494	size_t cTargets)
495	{
496	AssertPtrReturn(pCtx, NIL_CLIPX11FORMAT);
497	AssertReturn(RT_VALID_PTR(paIdxFmtTargets) \|\| cTargets == 0, NIL_CLIPX11FORMAT);
498
499	SHCLX11FMTIDX idxFmtText = NIL_CLIPX11FORMAT;
500	SHCLX11FMT fmtTextX11 = SHCLX11FMT_INVALID;
501	for (unsigned i = 0; i < cTargets; ++i)
502	{
503	SHCLX11FMTIDX idxFmt = paIdxFmtTargets[i];
504	if (idxFmt != NIL_CLIPX11FORMAT)
505	{
506	if ( (clipVBoxFormatForX11Format(idxFmt) == VBOX_SHCL_FMT_UNICODETEXT)
507	&& fmtTextX11 < clipRealFormatForX11Format(idxFmt))
508	{
509	fmtTextX11 = clipRealFormatForX11Format(idxFmt);
510	idxFmtText = idxFmt;
511	}
512	}
513	}
514	return idxFmtText;
515	}
516
517	/**
518	* Goes through an array of X11 clipboard targets to see if they contain a bitmap
519	* format we can support, and if so choose the ones we prefer (e.g. we like
520	* BMP better than PNG because we don't have to convert).
521	*
522	* @return Supported X clipboard format.
523	* @param pCtx The X11 clipboard context to use.
524	* @param paIdxFmtTargets The list of targets.
525	* @param cTargets The size of the list in @a pTargets.
526	*/
527	static SHCLX11FMTIDX clipGetBitmapFormatFromTargets(PSHCLX11CTX pCtx,
528	SHCLX11FMTIDX *paIdxFmtTargets,
529	size_t cTargets)
530	{
531	AssertPtrReturn(pCtx, NIL_CLIPX11FORMAT);
532	AssertReturn(RT_VALID_PTR(paIdxFmtTargets) \|\| cTargets == 0, NIL_CLIPX11FORMAT);
533
534	SHCLX11FMTIDX idxFmtBmp = NIL_CLIPX11FORMAT;
535	SHCLX11FMT fmtBmpX11 = SHCLX11FMT_INVALID;
536	for (unsigned i = 0; i < cTargets; ++i)
537	{
538	SHCLX11FMTIDX idxFmt = paIdxFmtTargets[i];
539	if (idxFmt != NIL_CLIPX11FORMAT)
540	{
541	if ( (clipVBoxFormatForX11Format(idxFmt) == VBOX_SHCL_FMT_BITMAP)
542	&& fmtBmpX11 < clipRealFormatForX11Format(idxFmt))
543	{
544	fmtBmpX11 = clipRealFormatForX11Format(idxFmt);
545	idxFmtBmp = idxFmt;
546	}
547	}
548	}
549	return idxFmtBmp;
550	}
551
552	/**
553	* Goes through an array of X11 clipboard targets to see if they contain a HTML
554	* format we can support, and if so choose the ones we prefer.
555	*
556	* @return Supported X clipboard format.
557	* @param pCtx The X11 clipboard context to use.
558	* @param paIdxFmtTargets The list of targets.
559	* @param cTargets The size of the list in @a pTargets.
560	*/
561	static SHCLX11FMTIDX clipGetHtmlFormatFromTargets(PSHCLX11CTX pCtx,
562	SHCLX11FMTIDX *paIdxFmtTargets,
563	size_t cTargets)
564	{
565	AssertPtrReturn(pCtx, NIL_CLIPX11FORMAT);
566	AssertReturn(RT_VALID_PTR(paIdxFmtTargets) \|\| cTargets == 0, NIL_CLIPX11FORMAT);
567
568	SHCLX11FMTIDX idxFmtHTML = NIL_CLIPX11FORMAT;
569	SHCLX11FMT fmxHTMLX11 = SHCLX11FMT_INVALID;
570	for (unsigned i = 0; i < cTargets; ++i)
571	{
572	SHCLX11FMTIDX idxFmt = paIdxFmtTargets[i];
573	if (idxFmt != NIL_CLIPX11FORMAT)
574	{
575	if ( (clipVBoxFormatForX11Format(idxFmt) == VBOX_SHCL_FMT_HTML)
576	&& fmxHTMLX11 < clipRealFormatForX11Format(idxFmt))
577	{
578	fmxHTMLX11 = clipRealFormatForX11Format(idxFmt);
579	idxFmtHTML = idxFmt;
580	}
581	}
582	}
583	return idxFmtHTML;
584	}
585
586	# ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
587	/**
588	* Goes through an array of X11 clipboard targets to see if they contain an URI list
589	* format we can support, and if so choose the ones we prefer.
590	*
591	* @return Supported X clipboard format.
592	* @param pCtx The X11 clipboard context to use.
593	* @param paIdxFmtTargets The list of targets.
594	* @param cTargets The size of the list in @a pTargets.
595	*/
596	static SHCLX11FMTIDX clipGetURIListFormatFromTargets(PSHCLX11CTX pCtx,
597	SHCLX11FMTIDX *paIdxFmtTargets,
598	size_t cTargets)
599	{
600	AssertPtrReturn(pCtx, NIL_CLIPX11FORMAT);
601	AssertReturn(RT_VALID_PTR(paIdxFmtTargets) \|\| cTargets == 0, NIL_CLIPX11FORMAT);
602
603	SHCLX11FMTIDX idxFmtURI = NIL_CLIPX11FORMAT;
604	SHCLX11FMT fmtURIX11 = SHCLX11FMT_INVALID;
605	for (unsigned i = 0; i < cTargets; ++i)
606	{
607	SHCLX11FMTIDX idxFmt = paIdxFmtTargets[i];
608	if (idxFmt != NIL_CLIPX11FORMAT)
609	{
610	if ( (clipVBoxFormatForX11Format(idxFmt) == VBOX_SHCL_FMT_URI_LIST)
611	&& fmtURIX11 < clipRealFormatForX11Format(idxFmt))
612	{
613	fmtURIX11 = clipRealFormatForX11Format(idxFmt);
614	idxFmtURI = idxFmt;
615	}
616	}
617	}
618	return idxFmtURI;
619	}
620	# endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
621
622	/**
623	* Goes through an array of X11 clipboard targets to see if we can support any
624	* of them and if relevant to choose the ones we prefer (e.g. we like Utf8
625	* better than plain text).
626	*
627	* @param pCtx The X11 clipboard context to use.
628	* @param paIdxFmtTargets The list of targets.
629	* @param cTargets The size of the list in @a pTargets.
630	*/
631	static void clipGetFormatsFromTargets(PSHCLX11CTX pCtx,
632	SHCLX11FMTIDX *paIdxFmtTargets, size_t cTargets)
633	{
634	AssertPtrReturnVoid(pCtx);
635	AssertPtrReturnVoid(paIdxFmtTargets);
636
637	SHCLX11FMTIDX idxFmtText = clipGetTextFormatFromTargets(pCtx, paIdxFmtTargets, cTargets);
638	if (pCtx->idxFmtText != idxFmtText)
639	pCtx->idxFmtText = idxFmtText;
640
641	pCtx->idxFmtBmp = SHCLX11FMT_INVALID; /* not yet supported / /* @todo r=andy Check this. */
642	SHCLX11FMTIDX idxFmtBmp = clipGetBitmapFormatFromTargets(pCtx, paIdxFmtTargets, cTargets);
643	if (pCtx->idxFmtBmp != idxFmtBmp)
644	pCtx->idxFmtBmp = idxFmtBmp;
645
646	SHCLX11FMTIDX idxFmtHTML = clipGetHtmlFormatFromTargets(pCtx, paIdxFmtTargets, cTargets);
647	if (pCtx->idxFmtHTML != idxFmtHTML)
648	pCtx->idxFmtHTML = idxFmtHTML;
649
650	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
651	SHCLX11FMTIDX idxFmtURI = clipGetURIListFormatFromTargets(pCtx, paIdxFmtTargets, cTargets);
652	if (pCtx->idxFmtURI != idxFmtURI)
653	pCtx->idxFmtURI = idxFmtURI;
654	#endif
655	}
656
657	/**
658	* Updates the context's information about targets currently supported by X11,
659	* based on an array of X11 atoms.
660	*
661	* @param pCtx The X11 clipboard context to use.
662	* @param pTargets The array of atoms describing the targets supported.
663	* @param cTargets The size of the array @a pTargets.
664	*/
665	SHCL_X11_DECL(void) clipUpdateX11Targets(PSHCLX11CTX pCtx, SHCLX11FMTIDX *paIdxFmtTargets, size_t cTargets)
666	{
667	LogFlowFuncEnter();
668
669	#ifdef VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY
670	pCtx->fXtBusy = false;
671	if (pCtx->fXtNeedsUpdate)
672	{
673	/* We may already be out of date. */
674	pCtx->fXtNeedsUpdate = false;
675	clipQueryX11Formats(pCtx);
676	return;
677	}
678	#endif
679
680	if (paIdxFmtTargets == NULL)
681	{
682	/* No data available */
683	clipReportEmpty(pCtx);
684	return;
685	}
686
687	clipGetFormatsFromTargets(pCtx, paIdxFmtTargets, cTargets);
688	clipReportFormatsToVBox(pCtx);
689	}
690
691	/**
692	* Notifies the VBox clipboard about available data formats, based on the
693	* "targets" information obtained from the X11 clipboard.
694	*
695	* @note Callback for XtGetSelectionValue().
696	* @note This function is treated as API glue, and as such is not part of any
697	* unit test. So keep it simple, be paranoid and log everything.
698	*/
699	SHCL_X11_DECL(void) clipConvertX11TargetsCallback(Widget widget, XtPointer pClient,
700	Atom * /* selection /, Atom atomType,
701	XtPointer pValue, long unsigned int *pcLen,
702	int *piFormat)
703	{
704	RT_NOREF(piFormat);
705
706	PSHCLX11CTX pCtx = reinterpret_cast<SHCLX11CTX *>(pClient);
707
708	LogFlowFunc(("pValue=%p, pcLen=%u, atomType=%d%s\n",
709	pValue, pcLen, atomType, *atomType == XT_CONVERT_FAIL ? " (XT_CONVERT_FAIL)" : ""));
710
711	Atom pAtoms = (Atom )pValue;
712
713	unsigned cFormats = *pcLen;
714
715	LogRel2(("Shared Clipboard: %u formats were found\n", cFormats));
716
717	SHCLX11FMTIDX *paIdxFmt = NULL;
718	if ( cFormats
719	&& pValue
720	&& (atomType != XT_CONVERT_FAIL / time out */))
721	{
722	/* Allocated array to hold the format indices. */
723	paIdxFmt = (SHCLX11FMTIDX )RTMemAllocZ(cFormats sizeof(SHCLX11FMTIDX));
724	}
725
726	#if !defined(TESTCASE)
727	if (pValue)
728	{
729	for (unsigned i = 0; i < cFormats; ++i)
730	{
731	if (pAtoms[i])
732	{
733	char *pszName = XGetAtomName(XtDisplay(widget), pAtoms[i]);
734	LogRel2(("Shared Clipboard: Found target '%s'\n", pszName));
735	XFree(pszName);
736	}
737	else
738	LogFunc(("Found empty target\n"));
739	}
740	}
741	#endif
742
743	if (paIdxFmt)
744	{
745	for (unsigned i = 0; i < cFormats; ++i)
746	{
747	for (unsigned j = 0; j < RT_ELEMENTS(g_aFormats); ++j)
748	{
749	Atom target = XInternAtom(XtDisplay(widget),
750	g_aFormats[j].pcszAtom, False);
751	if (*(pAtoms + i) == target)
752	paIdxFmt[i] = j;
753	}
754	#if !defined(TESTCASE)
755	if (paIdxFmt[i] != SHCLX11FMT_INVALID)
756	LogRel2(("Shared Clipboard: Reporting format '%s'\n", g_aFormats[paIdxFmt[i]].pcszAtom));
757	#endif
758	}
759	}
760	else
761	LogFunc(("Reporting empty targets (none reported or allocation failure)\n"));
762
763	clipUpdateX11Targets(pCtx, paIdxFmt, cFormats);
764	RTMemFree(paIdxFmt);
765
766	XtFree(reinterpret_cast<char *>(pValue));
767	}
768
769	/**
770	* Callback to notify us when the contents of the X11 clipboard change.
771	*
772	* @param pCtx The X11 clipboard context to use.
773	*/
774	SHCL_X11_DECL(void) clipQueryX11Formats(PSHCLX11CTX pCtx)
775	{
776	#ifndef TESTCASE
777
778	# ifdef VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY
779	LogFlowFunc(("fXtBusy=%RTbool\n", pCtx->fXtBusy));
780	if (pCtx->fXtBusy)
781	{
782	pCtx->fXtNeedsUpdate = true;
783	return;
784	}
785
786	pCtx->fXtBusy = true;
787	# endif
788
789	XtGetSelectionValue(pCtx->pWidget,
790	clipGetAtom(pCtx, "CLIPBOARD"),
791	clipGetAtom(pCtx, "TARGETS"),
792	clipConvertX11TargetsCallback, pCtx,
793	CurrentTime);
794	#else
795	tstRequestTargets(pCtx);
796	#endif
797	}
798
799	typedef struct
800	{
801	int type; /* event base */
802	unsigned long serial;
803	Bool send_event;
804	Display *display;
805	Window window;
806	int subtype;
807	Window owner;
808	Atom selection;
809	Time timestamp;
810	Time selection_timestamp;
811	} XFixesSelectionNotifyEvent;
812
813	#ifndef TESTCASE
814	/**
815	* Waits until an event arrives and handle it if it is an XFIXES selection
816	* event, which Xt doesn't know about.
817	*
818	* @param pCtx The X11 clipboard context to use.
819	*/
820	static void clipPeekEventAndDoXFixesHandling(PSHCLX11CTX pCtx)
821	{
822	union
823	{
824	XEvent event;
825	XFixesSelectionNotifyEvent fixes;
826	} event = { { 0 } };
827
828	if (XtAppPeekEvent(pCtx->pAppContext, &event.event))
829	{
830	if ( (event.event.type == pCtx->fixesEventBase)
831	&& (event.fixes.owner != XtWindow(pCtx->pWidget)))
832	{
833	if ( (event.fixes.subtype == 0 /* XFixesSetSelectionOwnerNotify */)
834	&& (event.fixes.owner != 0))
835	clipQueryX11Formats(pCtx);
836	else
837	clipReportEmpty(pCtx);
838	}
839	}
840	}
841
842	/**
843	* The main loop of our X11 event thread.
844	*
845	* @returns VBox status code.
846	* @param hThreadSelf Associated thread handle.
847	* @param pvUser Pointer to the X11 clipboard context to use.
848	*/
849	static DECLCALLBACK(int) clipThreadMain(RTTHREAD hThreadSelf, void *pvUser)
850	{
851	PSHCLX11CTX pCtx = (PSHCLX11CTX)pvUser;
852	AssertPtr(pCtx);
853
854	LogFlowFunc(("pCtx=%p\n", pCtx));
855
856	bool fSignalled = false; /* Whether we have signalled the parent already or not. */
857
858	int rc = clipInitInternal(pCtx);
859	if (RT_SUCCESS(rc))
860	{
861	rc = clipRegisterContext(pCtx);
862	if (RT_SUCCESS(rc))
863	{
864	if (pCtx->fGrabClipboardOnStart)
865	clipQueryX11Formats(pCtx);
866
867	pCtx->fThreadStarted = true;
868
869	/* We're now ready to run, tell parent. */
870	int rc2 = RTThreadUserSignal(hThreadSelf);
871	AssertRC(rc2);
872
873	fSignalled = true;
874
875	while (XtAppGetExitFlag(pCtx->pAppContext) == FALSE)
876	{
877	clipPeekEventAndDoXFixesHandling(pCtx);
878	XtAppProcessEvent(pCtx->pAppContext, XtIMAll);
879	}
880
881	LogRel(("Shared Clipboard: X11 event thread exiting\n"));
882
883	clipUnregisterContext(pCtx);
884	}
885	else
886	{
887	LogRel(("Shared Clipboard: unable to register clip context: %Rrc\n", rc));
888	}
889
890	clipUninitInternal(pCtx);
891	}
892
893	if (!fSignalled) /* Signal parent if we didn't do so yet. */
894	{
895	int rc2 = RTThreadUserSignal(hThreadSelf);
896	AssertRC(rc2);
897	}
898
899	LogFlowFuncLeaveRC(rc);
900	return rc;
901	}
902
903	/**
904	* Worker function for stopping the clipboard which runs on the event
905	* thread.
906	*
907	* @param pvUserData Pointer to the X11 clipboard context to use.
908	*/
909	static void clipThreadSignalStop(void pvUserData, void )
910	{
911	PSHCLX11CTX pCtx = (PSHCLX11CTX)pvUserData;
912
913	/* This might mean that we are getting stopped twice. */
914	Assert(pCtx->pWidget != NULL);
915
916	/* Set the termination flag to tell the Xt event loop to exit. We
917	* reiterate that any outstanding requests from the X11 event loop to
918	* the VBox part must have returned before we do this. */
919	XtAppSetExitFlag(pCtx->pAppContext);
920	}
921
922	/**
923	* Sets up the XFixes library and load the XFixesSelectSelectionInput symbol.
924	*/
925	static int clipLoadXFixes(Display *pDisplay, PSHCLX11CTX pCtx)
926	{
927	int rc;
928
929	void *hFixesLib = dlopen("libXfixes.so.1", RTLD_LAZY);
930	if (!hFixesLib)
931	hFixesLib = dlopen("libXfixes.so.2", RTLD_LAZY);
932	if (!hFixesLib)
933	hFixesLib = dlopen("libXfixes.so.3", RTLD_LAZY);
934	if (!hFixesLib)
935	hFixesLib = dlopen("libXfixes.so.4", RTLD_LAZY);
936	if (hFixesLib)
937	{
938	/* For us, a NULL function pointer is a failure */
939	pCtx->fixesSelectInput = (void ()(Display , Window, Atom, long unsigned int))
940	(uintptr_t)dlsym(hFixesLib, "XFixesSelectSelectionInput");
941	if (pCtx->fixesSelectInput)
942	{
943	int dummy1 = 0;
944	int dummy2 = 0;
945	if (XQueryExtension(pDisplay, "XFIXES", &dummy1, &pCtx->fixesEventBase, &dummy2) != 0)
946	{
947	if (pCtx->fixesEventBase >= 0)
948	{
949	rc = VINF_SUCCESS;
950	}
951	else
952	{
953	LogRel(("Shared Clipboard: fixesEventBase is less than zero: %d\n", pCtx->fixesEventBase));
954	rc = VERR_NOT_SUPPORTED;
955	}
956	}
957	else
958	{
959	LogRel(("Shared Clipboard: XQueryExtension failed\n"));
960	rc = VERR_NOT_SUPPORTED;
961	}
962	}
963	else
964	{
965	LogRel(("Shared Clipboard: Symbol XFixesSelectSelectionInput not found!\n"));
966	rc = VERR_NOT_SUPPORTED;
967	}
968	}
969	else
970	{
971	LogRel(("Shared Clipboard: libxFixes.so.* not found!\n"));
972	rc = VERR_NOT_SUPPORTED;
973	}
974	return rc;
975	}
976
977	/**
978	* This is the callback which is scheduled when data is available on the
979	* wakeup pipe. It simply reads all data from the pipe.
980	*
981	* @param pvUserData Pointer to the X11 clipboard context to use.
982	*/
983	static void clipThreadDrainWakeupPipe(XtPointer pvUserData, int , XtInputId )
984	{
985	LogFlowFuncEnter();
986
987	PSHCLX11CTX pCtx = (PSHCLX11CTX)pvUserData;
988	char acBuf[WAKE_UP_STRING_LEN];
989
990	while (read(pCtx->wakeupPipeRead, acBuf, sizeof(acBuf)) > 0) {}
991	}
992	#endif /* !TESTCASE */
993
994	/**
995	* X11-specific initialisation for the Shared Clipboard.
996	*
997	* Note: Must be called from the thread serving the Xt stuff.
998	*
999	* @returns VBox status code.
1000	* @param pCtx The X11 clipboard context to init.
1001	*/
1002	static int clipInitInternal(PSHCLX11CTX pCtx)
1003	{
1004	LogFlowFunc(("pCtx=%p\n", pCtx));
1005
1006	/* Make sure we are thread safe. */
1007	XtToolkitThreadInitialize();
1008
1009	/*
1010	* Set up the Clipboard application context and main window. We call all
1011	* these functions directly instead of calling XtOpenApplication() so
1012	* that we can fail gracefully if we can't get an X11 display.
1013	*/
1014	XtToolkitInitialize();
1015
1016	int rc = VINF_SUCCESS;
1017
1018	Assert(pCtx->pAppContext == NULL); /* No nested initialization. */
1019	pCtx->pAppContext = XtCreateApplicationContext();
1020	if (pCtx->pAppContext == NULL)
1021	{
1022	LogRel(("Shared Clipboard: Failed to create Xt application context\n"));
1023	return VERR_NOT_SUPPORTED; /** @todo Fudge! */
1024	}
1025
1026	/* Create a window and make it a clipboard viewer. */
1027	int cArgc = 0;
1028	char *pcArgv = 0;
1029	Display *pDisplay = XtOpenDisplay(pCtx->pAppContext, 0, 0, "VBoxShCl", 0, 0, &cArgc, &pcArgv);
1030	if (pDisplay == NULL)
1031	{
1032	LogRel(("Shared Clipboard: Failed to connect to the X11 clipboard - the window system may not be running\n"));
1033	rc = VERR_NOT_SUPPORTED;
1034	}
1035
1036	#ifndef TESTCASE
1037	if (RT_SUCCESS(rc))
1038	{
1039	rc = clipLoadXFixes(pDisplay, pCtx);
1040	if (RT_FAILURE(rc))
1041	LogRel(("Shared Clipboard: Failed to load the XFIXES extension\n"));
1042	}
1043	#endif
1044
1045	if (RT_SUCCESS(rc))
1046	{
1047	pCtx->pWidget = XtVaAppCreateShell(0, "VBoxShCl",
1048	applicationShellWidgetClass,
1049	pDisplay, XtNwidth, 1, XtNheight,
1050	1, NULL);
1051	if (pCtx->pWidget == NULL)
1052	{
1053	LogRel(("Shared Clipboard: Failed to create Xt app shell\n"));
1054	rc = VERR_NO_MEMORY; /** @todo r=andy Improve this. */
1055	}
1056	else
1057	{
1058	#ifndef TESTCASE
1059	if (!XtAppAddInput(pCtx->pAppContext, pCtx->wakeupPipeRead,
1060	(XtPointer) XtInputReadMask,
1061	clipThreadDrainWakeupPipe, (XtPointer) pCtx))
1062	{
1063	LogRel(("Shared Clipboard: Failed to add input to Xt app context\n"));
1064	rc = VERR_ACCESS_DENIED; /** @todo r=andy Improve this. */
1065	}
1066	#endif
1067	}
1068	}
1069
1070	if (RT_SUCCESS(rc))
1071	{
1072	XtSetMappedWhenManaged(pCtx->pWidget, false);
1073	XtRealizeWidget(pCtx->pWidget);
1074
1075	#ifndef TESTCASE
1076	/* Enable clipboard update notification. */
1077	pCtx->fixesSelectInput(pDisplay, XtWindow(pCtx->pWidget),
1078	clipGetAtom(pCtx, "CLIPBOARD"),
1079	7 /* All XFixesSelectionNotifyMask flags */);
1080	#endif
1081	}
1082
1083	if (RT_FAILURE(rc))
1084	{
1085	LogRel(("Shared Clipboard: Initialisation failed: %Rrc\n", rc));
1086	clipUninitInternal(pCtx);
1087	}
1088
1089	LogFlowFuncLeaveRC(rc);
1090	return rc;
1091	}
1092
1093	/**
1094	* X11-specific uninitialisation for the Shared Clipboard.
1095	*
1096	* Note: Must be called from the thread serving the Xt stuff.
1097	*
1098	* @param pCtx The X11 clipboard context to uninit.
1099	*/
1100	static void clipUninitInternal(PSHCLX11CTX pCtx)
1101	{
1102	AssertPtrReturnVoid(pCtx);
1103
1104	LogFlowFunc(("pCtx=%p\n", pCtx));
1105
1106	if (pCtx->pWidget)
1107	{
1108	/* Valid widget + invalid appcontext = bug. But don't return yet. */
1109	AssertPtr(pCtx->pAppContext);
1110
1111	XtDestroyWidget(pCtx->pWidget);
1112	pCtx->pWidget = NULL;
1113	}
1114
1115	if (pCtx->pAppContext)
1116	{
1117	XtDestroyApplicationContext(pCtx->pAppContext);
1118	pCtx->pAppContext = NULL;
1119	}
1120
1121	LogFlowFuncLeaveRC(VINF_SUCCESS);
1122	}
1123
1124	/**
1125	* Initializes a X11 context of the Shared Clipboard.
1126	*
1127	* @returns VBox status code.
1128	* @param pCtx The clipboard context to initialize.
1129	* @param pParent Parent context to use.
1130	* @param fHeadless Whether the code runs in a headless environment or not.
1131	*/
1132	int ShClX11Init(PSHCLX11CTX pCtx, PSHCLCONTEXT pParent, bool fHeadless)
1133	{
1134	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1135	#if !defined(SMOKETEST) && !defined(TESTCASE)
1136	/* Smoktests / Testcases don't have a (valid) parent. */
1137	AssertPtrReturn(pParent, VERR_INVALID_POINTER);
1138	#endif
1139
1140	LogFlowFunc(("pCtx=%p\n", pCtx));
1141
1142	int rc = VINF_SUCCESS;
1143
1144	RT_BZERO(pCtx, sizeof(SHCLX11CTX));
1145
1146	if (fHeadless)
1147	{
1148	/*
1149	* If we don't find the DISPLAY environment variable we assume that
1150	* we are not connected to an X11 server. Don't actually try to do
1151	* this then, just fail silently and report success on every call.
1152	* This is important for VBoxHeadless.
1153	*/
1154	LogRel(("Shared Clipboard: X11 DISPLAY variable not set -- disabling clipboard sharing\n"));
1155	}
1156
1157	pCtx->fHaveX11 = !fHeadless;
1158	pCtx->pFrontend = pParent;
1159
1160	#ifdef VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY
1161	pCtx->fXtBusy = false;
1162	pCtx->fXtNeedsUpdate = false;
1163	#endif
1164
1165	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS_HTTP
1166	ShClTransferHttpServerInit(&pCtx->HttpCtx.HttpServer);
1167	#endif
1168
1169	#ifdef TESTCASE
1170	if (RT_SUCCESS(rc))
1171	{
1172	/** @todo The testcases currently do not utilize the threading code. So init stuff here. */
1173	rc = clipInitInternal(pCtx);
1174	if (RT_SUCCESS(rc))
1175	rc = clipRegisterContext(pCtx);
1176	}
1177	#endif
1178
1179	LogFlowFuncLeaveRC(rc);
1180	return rc;
1181	}
1182
1183	/**
1184	* Destroys a Shared Clipboard X11 context.
1185	*
1186	* @param pCtx The X11 clipboard context to destroy.
1187	*/
1188	void ShClX11Destroy(PSHCLX11CTX pCtx)
1189	{
1190	if (!pCtx)
1191	return;
1192
1193	LogFlowFunc(("pCtx=%p\n", pCtx));
1194
1195	#ifdef TESTCASE
1196	/** @todo The testcases currently do not utilize the threading code. So uninit stuff here. */
1197	clipUnregisterContext(pCtx);
1198	clipUninitInternal(pCtx);
1199	#endif
1200
1201	if (pCtx->fHaveX11)
1202	{
1203	/* We set this to NULL when the event thread exits. It really should
1204	* have exited at this point, when we are about to unload the code from
1205	* memory. */
1206	Assert(pCtx->pWidget == NULL);
1207	}
1208	}
1209
1210	#ifndef TESTCASE
1211	/**
1212	* Starts our own Xt even thread for handling Shared Clipboard messages.
1213	*
1214	* @returns VBox status code.
1215	* @param pCtx The X11 clipboard context to use.
1216	* @param fGrab Whether we should try to grab the shared clipboard at once.
1217	*/
1218	int ShClX11ThreadStart(PSHCLX11CTX pCtx, bool fGrab)
1219	{
1220	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1221
1222	/*
1223	* Immediately return if we are not connected to the X server.
1224	*/
1225	if (!pCtx->fHaveX11)
1226	return VINF_SUCCESS;
1227
1228	pCtx->fGrabClipboardOnStart = fGrab;
1229
1230	clipResetX11Formats(pCtx);
1231
1232	int rc;
1233
1234	/*
1235	* Create the pipes.
1236	** @todo r=andy Replace this with RTPipe API.
1237	*/
1238	int pipes[2];
1239	if (!pipe(pipes))
1240	{
1241	pCtx->wakeupPipeRead = pipes[0];
1242	pCtx->wakeupPipeWrite = pipes[1];
1243
1244	if (!fcntl(pCtx->wakeupPipeRead, F_SETFL, O_NONBLOCK))
1245	{
1246	rc = VINF_SUCCESS;
1247	}
1248	else
1249	rc = RTErrConvertFromErrno(errno);
1250	}
1251	else
1252	rc = RTErrConvertFromErrno(errno);
1253
1254	if (RT_SUCCESS(rc))
1255	{
1256	LogRel2(("Shared Clipboard: Starting X11 event thread ...\n"));
1257
1258	rc = RTThreadCreate(&pCtx->Thread, clipThreadMain, pCtx, 0,
1259	RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "SHCLX11");
1260	if (RT_SUCCESS(rc))
1261	rc = RTThreadUserWait(pCtx->Thread, RT_MS_30SEC /* msTimeout */);
1262
1263	if (RT_FAILURE(rc))
1264	{
1265	LogRel(("Shared Clipboard: Failed to start the X11 event thread with %Rrc\n", rc));
1266	clipUninitInternal(pCtx);
1267	}
1268	else
1269	{
1270	if (!pCtx->fThreadStarted)
1271	{
1272	LogRel(("Shared Clipboard: X11 event thread reported an error while starting\n"));
1273	}
1274	else
1275	LogRel2(("Shared Clipboard: X11 event thread started\n"));
1276	}
1277	}
1278
1279	LogFlowFuncLeaveRC(rc);
1280	return rc;
1281	}
1282
1283	/**
1284	* Stops the Shared Clipboard Xt even thread.
1285	*
1286	* @note Any requests from this object to get clipboard data from VBox
1287	* must have completed or aborted before we are called, as
1288	* otherwise the X11 event loop will still be waiting for the request
1289	* to return and will not be able to terminate.
1290	*
1291	* @returns VBox status code.
1292	* @param pCtx The X11 clipboard context to use.
1293	*/
1294	int ShClX11ThreadStop(PSHCLX11CTX pCtx)
1295	{
1296	int rc;
1297	/*
1298	* Immediately return if we are not connected to the X server.
1299	*/
1300	if (!pCtx->fHaveX11)
1301	return VINF_SUCCESS;
1302
1303	LogRel2(("Shared Clipboard: Signalling the X11 event thread to stop\n"));
1304
1305	/* Write to the "stop" pipe. */
1306	rc = clipThreadScheduleCall(pCtx, clipThreadSignalStop, (XtPointer)pCtx);
1307	if (RT_FAILURE(rc))
1308	{
1309	LogRel(("Shared Clipboard: cannot notify X11 event thread on shutdown with %Rrc\n", rc));
1310	return rc;
1311	}
1312
1313	LogRel2(("Shared Clipboard: Waiting for X11 event thread to stop ...\n"));
1314
1315	int rcThread;
1316	rc = RTThreadWait(pCtx->Thread, RT_MS_30SEC /* msTimeout */, &rcThread);
1317	if (RT_SUCCESS(rc))
1318	rc = rcThread;
1319	if (RT_SUCCESS(rc))
1320	{
1321	if (pCtx->wakeupPipeRead != 0)
1322	{
1323	close(pCtx->wakeupPipeRead);
1324	pCtx->wakeupPipeRead = 0;
1325	}
1326
1327	if (pCtx->wakeupPipeWrite != 0)
1328	{
1329	close(pCtx->wakeupPipeWrite);
1330	pCtx->wakeupPipeWrite = 0;
1331	}
1332	}
1333
1334	if (RT_SUCCESS(rc))
1335	{
1336	LogRel2(("Shared Clipboard: X11 event thread stopped successfully\n"));
1337	}
1338	else
1339	LogRel(("Shared Clipboard: Stopping X11 event thread failed with %Rrc\n", rc));
1340
1341	LogFlowFuncLeaveRC(rc);
1342	return rc;
1343	}
1344	#endif /* !TESTCASE */
1345
1346	/**
1347	* Returns the targets supported by VBox.
1348	*
1349	* This will return a list of atoms which tells the caller
1350	* what kind of clipboard formats we support.
1351	*
1352	* @returns VBox status code.
1353	* @param pCtx The X11 clipboard context to use.
1354	* @param atomTypeReturn The type of the data we are returning.
1355	* @param pValReturn A pointer to the data we are returning. This
1356	* should be set to memory allocated by XtMalloc,
1357	* which will be freed later by the Xt toolkit.
1358	* @param pcLenReturn The length of the data we are returning.
1359	* @param piFormatReturn The format (8bit, 16bit, 32bit) of the data we are
1360	* returning.
1361	* @note X11 backend code, called by the XtOwnSelection callback.
1362	*/
1363	static int clipCreateX11Targets(PSHCLX11CTX pCtx, Atom *atomTypeReturn,
1364	XtPointer *pValReturn,
1365	unsigned long *pcLenReturn,
1366	int *piFormatReturn)
1367	{
1368	const unsigned cFixedTargets = 3; /* See below. */
1369
1370	Atom pAtomTargets = (Atom )XtMalloc((SHCL_MAX_X11_FORMATS + cFixedTargets) * sizeof(Atom));
1371	if (!pAtomTargets)
1372	return VERR_NO_MEMORY;
1373
1374	unsigned cTargets = 0;
1375	SHCLX11FMTIDX idxFmt = NIL_CLIPX11FORMAT;
1376	do
1377	{
1378	idxFmt = clipEnumX11Formats(pCtx->vboxFormats, idxFmt);
1379	if (idxFmt != NIL_CLIPX11FORMAT)
1380	{
1381	pAtomTargets[cTargets] = clipAtomForX11Format(pCtx, idxFmt);
1382	++cTargets;
1383	}
1384	} while (idxFmt != NIL_CLIPX11FORMAT);
1385
1386	/* We always offer these fixed targets. */
1387	pAtomTargets[cTargets] = clipGetAtom(pCtx, "TARGETS");
1388	pAtomTargets[cTargets + 1] = clipGetAtom(pCtx, "MULTIPLE");
1389	pAtomTargets[cTargets + 2] = clipGetAtom(pCtx, "TIMESTAMP");
1390
1391	*atomTypeReturn = XA_ATOM;
1392	*pValReturn = (XtPointer)pAtomTargets;
1393	*pcLenReturn = cTargets + cFixedTargets;
1394	*piFormatReturn = 32;
1395
1396	LogFlowFunc(("cTargets=%u\n", cTargets + cFixedTargets));
1397
1398	return VINF_SUCCESS;
1399	}
1400
1401	/**
1402	* Helper for ShClX11RequestDataForX11Callback() that will cache the data returned.
1403	*
1404	* @returns VBox status code. VERR_NO_DATA if no data available.
1405	* @param pCtx The X11 clipboard context to use.
1406	* @param uFmt Clipboard format to read data in.
1407	* @param ppv Returns an allocated buffer with data read on success.
1408	* Needs to be free'd with RTMemFree() by the caller.
1409	* @param pcb Returns the amount of data read (in bytes) on success.
1410	*/
1411	static int shClX11RequestDataForX11CallbackHelper(PSHCLX11CTX pCtx, SHCLFORMAT uFmt,
1412	void *ppv, uint32_t pcb)
1413	{
1414	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1415	AssertPtrReturn(ppv, VERR_INVALID_POINTER);
1416	AssertPtrReturn(pcb, VERR_INVALID_POINTER);
1417
1418	LogFlowFunc(("pCtx=%p, uFmt=%#x\n", pCtx, uFmt));
1419
1420	int rc = VINF_SUCCESS;
1421
1422	void *pv = NULL;
1423	uint32_t cb = 0;
1424
1425	if (uFmt == VBOX_SHCL_FMT_UNICODETEXT)
1426	{
1427	if (pCtx->pvUnicodeCache == NULL) /** @todo r=andy Using string cache here? */
1428	rc = ShClX11RequestDataForX11Callback(pCtx->pFrontend, uFmt,
1429	&pCtx->pvUnicodeCache,
1430	&pCtx->cbUnicodeCache);
1431	if (RT_SUCCESS(rc))
1432	{
1433	pv = RTMemDup(pCtx->pvUnicodeCache, pCtx->cbUnicodeCache);
1434	if (pv)
1435	cb = pCtx->cbUnicodeCache;
1436	else
1437	rc = VERR_NO_MEMORY;
1438	}
1439	}
1440	else
1441	rc = ShClX11RequestDataForX11Callback(pCtx->pFrontend, uFmt, &pv, &cb);
1442
1443
1444	/* Safey net in case the callbacks above misbehave
1445	* (must return VERR_NO_DATA if no data available). */
1446	if ( RT_SUCCESS(rc)
1447	&& (pv == NULL \|\| cb == 0))
1448	rc = VERR_NO_DATA;
1449
1450	if (RT_SUCCESS(rc))
1451	{
1452	*ppv = pv;
1453	*pcb = cb;
1454	}
1455
1456	LogFlowFunc(("Returning pv=%p, cb=%RU32, rc=%Rrc\n", pv, cb, rc));
1457	return rc;
1458	}
1459
1460	/**
1461	* Satisfies a request from X11 to convert the clipboard text to UTF-8 LF.
1462	*
1463	* @returns VBox status code. VERR_NO_DATA if no data was converted.
1464	* @param pDisplay An X11 display structure, needed for conversions
1465	* performed by Xlib.
1466	* @param pv The text to be converted (UCS-2 with Windows EOLs).
1467	* @param cb The length of the text in @cb in bytes.
1468	* @param atomTypeReturn Where to store the atom for the type of the data
1469	* we are returning.
1470	* @param pValReturn Where to store the pointer to the data we are
1471	* returning. This should be to memory allocated by
1472	* XtMalloc, which will be freed by the Xt toolkit
1473	* later.
1474	* @param pcLenReturn Where to store the length of the data we are
1475	* returning.
1476	* @param piFormatReturn Where to store the bit width (8, 16, 32) of the
1477	* data we are returning.
1478	*/
1479	static int clipConvertUtf16ToX11Data(Display *pDisplay, PRTUTF16 pwszSrc,
1480	size_t cbSrc, Atom *atomTarget,
1481	Atom *atomTypeReturn,
1482	XtPointer *pValReturn,
1483	unsigned long *pcLenReturn,
1484	int *piFormatReturn)
1485	{
1486	RT_NOREF(pDisplay);
1487	AssertReturn(cbSrc % sizeof(RTUTF16) == 0, VERR_INVALID_PARAMETER);
1488
1489	const size_t cwcSrc = cbSrc / sizeof(RTUTF16);
1490	if (!cwcSrc)
1491	return VERR_NO_DATA;
1492
1493	/* This may slightly overestimate the space needed. */
1494	size_t chDst = 0;
1495	int rc = ShClUtf16LenUtf8(pwszSrc, cwcSrc, &chDst);
1496	if (RT_SUCCESS(rc))
1497	{
1498	chDst++; /* Add space for terminator. */
1499
1500	char pszDst = (char )XtMalloc(chDst);
1501	if (pszDst)
1502	{
1503	size_t cbActual = 0;
1504	rc = ShClConvUtf16CRLFToUtf8LF(pwszSrc, cwcSrc, pszDst, chDst, &cbActual);
1505	if (RT_SUCCESS(rc))
1506	{
1507	atomTypeReturn = atomTarget;
1508	*pValReturn = (XtPointer)pszDst;
1509	pcLenReturn = cbActual + 1 / Include terminator */;
1510	*piFormatReturn = 8;
1511	}
1512	}
1513	else
1514	rc = VERR_NO_MEMORY;
1515	}
1516
1517	LogFlowFuncLeaveRC(rc);
1518	return rc;
1519	}
1520
1521	/**
1522	* Satisfies a request from X11 to convert the clipboard HTML fragment to UTF-8. We
1523	* return null-terminated text, but can cope with non-null-terminated input.
1524	*
1525	* @returns VBox status code.
1526	* @param pDisplay An X11 display structure, needed for conversions
1527	* performed by Xlib.
1528	* @param pv The text to be converted (UTF8 with Windows EOLs).
1529	* @param cb The length of the text in @cb in bytes.
1530	* @param atomTypeReturn Where to store the atom for the type of the data
1531	* we are returning.
1532	* @param pValReturn Where to store the pointer to the data we are
1533	* returning. This should be to memory allocated by
1534	* XtMalloc, which will be freed by the Xt toolkit later.
1535	* @param pcLenReturn Where to store the length of the data we are returning.
1536	* @param piFormatReturn Where to store the bit width (8, 16, 32) of the
1537	* data we are returning.
1538	*/
1539	static int clipConvertHtmlToX11Data(Display pDisplay, const char pszSrc,
1540	size_t cbSrc, Atom *atomTarget,
1541	Atom *atomTypeReturn,
1542	XtPointer *pValReturn,
1543	unsigned long *pcLenReturn,
1544	int *piFormatReturn)
1545	{
1546	RT_NOREF(pDisplay, pValReturn);
1547
1548	/* This may slightly overestimate the space needed. */
1549	LogFlowFunc(("Source: %s", pszSrc));
1550
1551	char pszDest = (char )XtMalloc(cbSrc);
1552	if (pszDest == NULL)
1553	return VERR_NO_MEMORY;
1554
1555	memcpy(pszDest, pszSrc, cbSrc);
1556
1557	atomTypeReturn = atomTarget;
1558	*pValReturn = (XtPointer)pszDest;
1559	*pcLenReturn = cbSrc;
1560	*piFormatReturn = 8;
1561
1562	return VINF_SUCCESS;
1563	}
1564
1565
1566	/**
1567	* Does this atom correspond to one of the two selection types we support?
1568	*
1569	* @param pCtx The X11 clipboard context to use.
1570	* @param selType The atom in question.
1571	*/
1572	static bool clipIsSupportedSelectionType(PSHCLX11CTX pCtx, Atom selType)
1573	{
1574	return( (selType == clipGetAtom(pCtx, "CLIPBOARD"))
1575	\|\| (selType == clipGetAtom(pCtx, "PRIMARY")));
1576	}
1577
1578	/**
1579	* Removes a trailing nul character from a string by adjusting the string
1580	* length. Some X11 applications don't like zero-terminated text...
1581	*
1582	* @param pText The text in question.
1583	* @param pcText The length of the text, adjusted on return.
1584	* @param format The format of the text.
1585	*/
1586	static void clipTrimTrailingNul(XtPointer pText, unsigned long *pcText,
1587	SHCLX11FMT format)
1588	{
1589	AssertPtrReturnVoid(pText);
1590	AssertPtrReturnVoid(pcText);
1591	AssertReturnVoid((format == SHCLX11FMT_UTF8) \|\| (format == SHCLX11FMT_TEXT) \|\| (format == SHCLX11FMT_HTML));
1592
1593	if (((char )pText)[pcText - 1] == '\0')
1594	--(*pcText);
1595	}
1596
1597	static int clipConvertToX11Data(PSHCLX11CTX pCtx, Atom *atomTarget,
1598	Atom *atomTypeReturn,
1599	XtPointer *pValReturn,
1600	unsigned long *pcLenReturn,
1601	int *piFormatReturn)
1602	{
1603	int rc = VERR_NOT_SUPPORTED; /* Play safe by default. */
1604
1605	SHCLX11FMTIDX idxFmtX11 = clipFindX11FormatByAtom(pCtx, *atomTarget);
1606	SHCLX11FMT fmtX11 = clipRealFormatForX11Format(idxFmtX11);
1607
1608	LogFlowFunc(("vboxFormats=0x%x, idxFmtX11=%u ('%s'), fmtX11=%u\n",
1609	pCtx->vboxFormats, idxFmtX11, g_aFormats[idxFmtX11].pcszAtom, fmtX11));
1610
1611	#ifdef LOG_ENABLED
1612	char *pszFmts = ShClFormatsToStrA(pCtx->vboxFormats);
1613	AssertPtrReturn(pszFmts, VERR_NO_MEMORY);
1614	LogRel2(("Shared Clipboard: Converting VBox formats '%s' to '%s' for X11\n",
1615	pszFmts, g_aFormats[idxFmtX11].pcszAtom));
1616	RTStrFree(pszFmts);
1617	#endif
1618
1619	void *pv = NULL;
1620	uint32_t cb = 0;
1621
1622	if ( ( (fmtX11 == SHCLX11FMT_UTF8)
1623	\|\| (fmtX11 == SHCLX11FMT_TEXT)
1624	)
1625	&& (pCtx->vboxFormats & VBOX_SHCL_FMT_UNICODETEXT))
1626	{
1627	rc = shClX11RequestDataForX11CallbackHelper(pCtx, VBOX_SHCL_FMT_UNICODETEXT, &pv, &cb);
1628	if ( RT_SUCCESS(rc)
1629	&& ( (fmtX11 == SHCLX11FMT_UTF8)
1630	\|\| (fmtX11 == SHCLX11FMT_TEXT)))
1631	{
1632	rc = clipConvertUtf16ToX11Data(XtDisplay(pCtx->pWidget),
1633	(PRTUTF16)pv, cb, atomTarget,
1634	atomTypeReturn, pValReturn,
1635	pcLenReturn, piFormatReturn);
1636	}
1637
1638	if (RT_SUCCESS(rc))
1639	clipTrimTrailingNul((XtPointer )pValReturn, pcLenReturn, fmtX11);
1640
1641	RTMemFree(pv);
1642	}
1643	else if ( (fmtX11 == SHCLX11FMT_BMP)
1644	&& (pCtx->vboxFormats & VBOX_SHCL_FMT_BITMAP))
1645	{
1646	rc = shClX11RequestDataForX11CallbackHelper(pCtx, VBOX_SHCL_FMT_BITMAP, &pv, &cb);
1647	if ( RT_SUCCESS(rc)
1648	&& (fmtX11 == SHCLX11FMT_BMP))
1649	{
1650	/* Create a full BMP from it. */
1651	rc = ShClDibToBmp(pv, cb, (void **)pValReturn,
1652	(size_t *)pcLenReturn);
1653	}
1654
1655	if (RT_SUCCESS(rc))
1656	{
1657	atomTypeReturn = atomTarget;
1658	*piFormatReturn = 8;
1659	}
1660
1661	RTMemFree(pv);
1662	}
1663	else if ( (fmtX11 == SHCLX11FMT_HTML)
1664	&& (pCtx->vboxFormats & VBOX_SHCL_FMT_HTML))
1665	{
1666	rc = shClX11RequestDataForX11CallbackHelper(pCtx, VBOX_SHCL_FMT_HTML, &pv, &cb);
1667	if (RT_SUCCESS(rc))
1668	{
1669	/**
1670	* The common VBox HTML encoding will be UTF-8.
1671	* Before sending it to the X11 clipboard we have to convert it to UTF-8 first.
1672	*
1673	* Strange that we get UTF-16 from the X11 clipboard, but
1674	* in same time we send UTF-8 to X11 clipboard and it works.
1675	** @todo r=andy Verify this.
1676	*/
1677	rc = clipConvertHtmlToX11Data(XtDisplay(pCtx->pWidget),
1678	(const char*)pv, cb, atomTarget,
1679	atomTypeReturn, pValReturn,
1680	pcLenReturn, piFormatReturn);
1681	if (RT_SUCCESS(rc))
1682	clipTrimTrailingNul((XtPointer )pValReturn, pcLenReturn, fmtX11);
1683
1684	RTMemFree(pv);
1685	}
1686	}
1687	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
1688	else if (fmtX11 == SHCLX11FMT_URI_LIST)
1689	{
1690	if (pCtx->vboxFormats & VBOX_SHCL_FMT_URI_LIST)
1691	{
1692	rc = shClX11RequestDataForX11CallbackHelper(pCtx, VBOX_SHCL_FMT_URI_LIST, &pv, &cb);
1693	if (RT_SUCCESS(rc))
1694	{
1695	void pvDst = (void )XtMalloc(cb);
1696	if (pvDst)
1697	{
1698	memcpy(pvDst, pv, cb);
1699
1700	atomTypeReturn = atomTarget;
1701	*pValReturn = (XtPointer)pvDst;
1702	*pcLenReturn = cb;
1703	*piFormatReturn = 8;
1704	}
1705	else
1706	rc = VERR_NO_MEMORY;
1707	}
1708	}
1709	/* else not supported yet. */
1710	}
1711	#endif
1712	else
1713	{
1714	*atomTypeReturn = XT_CONVERT_FAIL;
1715	*pValReturn = (XtPointer)NULL;
1716	*pcLenReturn = 0;
1717	*piFormatReturn = 0;
1718	}
1719
1720	if (RT_FAILURE(rc))
1721	{
1722	char *pszFmts2 = ShClFormatsToStrA(pCtx->vboxFormats);
1723	AssertPtrReturn(pszFmts2, VERR_NO_MEMORY);
1724	LogRel(("Shared Clipboard: Converting VBox formats '%s' to '%s' for X11 (idxFmtX11=%u, fmtX11=%u) failed, rc=%Rrc\n",
1725	pszFmts2, g_aFormats[idxFmtX11].pcszAtom, idxFmtX11, fmtX11, rc));
1726	RTStrFree(pszFmts2);
1727	}
1728
1729	LogFlowFuncLeaveRC(rc);
1730	return rc;
1731	}
1732
1733	/**
1734	* Returns VBox's clipboard data for an X11 client.
1735	*
1736	* @note Callback for XtOwnSelection.
1737	*/
1738	static Boolean clipXtConvertSelectionProc(Widget widget, Atom *atomSelection,
1739	Atom *atomTarget,
1740	Atom *atomTypeReturn,
1741	XtPointer *pValReturn,
1742	unsigned long *pcLenReturn,
1743	int *piFormatReturn)
1744	{
1745	LogFlowFuncEnter();
1746
1747	PSHCLX11CTX pCtx = clipLookupContext(widget);
1748	if (!pCtx)
1749	return False;
1750
1751	/* Is this the rigt selection (clipboard) we were asked for? */
1752	if (!clipIsSupportedSelectionType(pCtx, *atomSelection))
1753	return False;
1754
1755	int rc;
1756	if (*atomTarget == clipGetAtom(pCtx, "TARGETS"))
1757	rc = clipCreateX11Targets(pCtx, atomTypeReturn, pValReturn,
1758	pcLenReturn, piFormatReturn);
1759	else
1760	rc = clipConvertToX11Data(pCtx, atomTarget, atomTypeReturn,
1761	pValReturn, pcLenReturn, piFormatReturn);
1762
1763	LogFlowFunc(("returning %RTbool, rc=%Rrc\n", RT_SUCCESS(rc), rc));
1764	return RT_SUCCESS(rc) ? True : False;
1765	}
1766
1767	/**
1768	* Structure used to pass information about formats that VBox supports.
1769	*/
1770	typedef struct _CLIPNEWVBOXFORMATS
1771	{
1772	/** Context information for the X11 clipboard. */
1773	PSHCLX11CTX pCtx;
1774	/** Formats supported by VBox. */
1775	SHCLFORMATS Formats;
1776	} CLIPNEWVBOXFORMATS, *PCLIPNEWVBOXFORMATS;
1777
1778
1779
1780	/**
1781	* Invalidates the local cache of the data in the VBox clipboard.
1782	*
1783	* @param pCtx The X11 clipboard context to use.
1784	*/
1785	static void clipInvalidateClipboardCache(PSHCLX11CTX pCtx)
1786	{
1787	if (pCtx->pvUnicodeCache != NULL)
1788	{
1789	RTMemFree(pCtx->pvUnicodeCache);
1790	pCtx->pvUnicodeCache = NULL;
1791	}
1792	}
1793
1794	/**
1795	* Takes possession of the X11 clipboard (and middle-button selection).
1796	*
1797	* @param pCtx The X11 clipboard context to use.
1798	* @param uFormats Clipboard formats to set.
1799	*/
1800	static void clipGrabX11Clipboard(PSHCLX11CTX pCtx, SHCLFORMATS uFormats)
1801	{
1802	LogFlowFuncEnter();
1803
1804	if (XtOwnSelection(pCtx->pWidget, clipGetAtom(pCtx, "CLIPBOARD"),
1805	CurrentTime, clipXtConvertSelectionProc, NULL, 0))
1806	{
1807	pCtx->vboxFormats = uFormats;
1808
1809	/* Grab the middle-button paste selection too. */
1810	XtOwnSelection(pCtx->pWidget, clipGetAtom(pCtx, "PRIMARY"),
1811	CurrentTime, clipXtConvertSelectionProc, NULL, 0);
1812	#ifndef TESTCASE
1813	/* Xt suppresses these if we already own the clipboard, so send them
1814	* ourselves. */
1815	XSetSelectionOwner(XtDisplay(pCtx->pWidget),
1816	clipGetAtom(pCtx, "CLIPBOARD"),
1817	XtWindow(pCtx->pWidget), CurrentTime);
1818	XSetSelectionOwner(XtDisplay(pCtx->pWidget),
1819	clipGetAtom(pCtx, "PRIMARY"),
1820	XtWindow(pCtx->pWidget), CurrentTime);
1821	#endif
1822	}
1823	}
1824
1825	/**
1826	* Worker function for ShClX11ReportFormatsToX11 which runs on the
1827	* event thread.
1828	*
1829	* @param pvUserData Pointer to a CLIPNEWVBOXFORMATS structure containing
1830	* information about the VBox formats available and the
1831	* clipboard context data. Must be freed by the worker.
1832	*/
1833	static void ShClX11ReportFormatsToX11Worker(void pvUserData, void /* interval */)
1834	{
1835	AssertPtrReturnVoid(pvUserData);
1836
1837	CLIPNEWVBOXFORMATS pFormats = (CLIPNEWVBOXFORMATS )pvUserData;
1838
1839	PSHCLX11CTX pCtx = pFormats->pCtx;
1840	SHCLFORMATS fFormats = pFormats->Formats;
1841
1842	RTMemFree(pFormats);
1843
1844	LogFlowFunc (("fFormats=0x%x\n", fFormats));
1845
1846	clipInvalidateClipboardCache(pCtx);
1847	clipGrabX11Clipboard(pCtx, fFormats);
1848	clipResetX11Formats(pCtx);
1849
1850	LogFlowFuncLeave();
1851	}
1852
1853	/**
1854	* Announces new clipboard formats to the X11 clipboard.
1855	*
1856	* @returns VBox status code.
1857	* @param pCtx Context data for the clipboard backend.
1858	* @param uFormats Clipboard formats offered.
1859	*/
1860	int ShClX11ReportFormatsToX11(PSHCLX11CTX pCtx, SHCLFORMATS uFormats)
1861	{
1862	/*
1863	* Immediately return if we are not connected to the X server.
1864	*/
1865	if (!pCtx->fHaveX11)
1866	return VINF_SUCCESS;
1867
1868	int rc;
1869
1870	/* This must be free'd by the worker callback. */
1871	PCLIPNEWVBOXFORMATS pFormats = (PCLIPNEWVBOXFORMATS)RTMemAlloc(sizeof(CLIPNEWVBOXFORMATS));
1872	if (pFormats)
1873	{
1874	pFormats->pCtx = pCtx;
1875	pFormats->Formats = uFormats;
1876
1877	rc = clipThreadScheduleCall(pCtx, ShClX11ReportFormatsToX11Worker,
1878	(XtPointer)pFormats);
1879	if (RT_FAILURE(rc))
1880	RTMemFree(pFormats);
1881	}
1882	else
1883	rc = VERR_NO_MEMORY;
1884
1885	LogFlowFuncLeaveRC(rc);
1886	return rc;
1887	}
1888
1889	/**
1890	* Converts the data obtained from the X11 clipboard to the required format,
1891	* place it in the buffer supplied and signal that data has arrived.
1892	*
1893	* Converts the text obtained UTF-16LE with Windows EOLs.
1894	* Converts full BMP data to DIB format.
1895	*/
1896	SHCL_X11_DECL(void) clipConvertDataFromX11Worker(void pClient, void pvSrc, unsigned cbSrc)
1897	{
1898	CLIPREADX11CBREQ pReq = (CLIPREADX11CBREQ )pClient;
1899	AssertPtrReturnVoid(pReq);
1900
1901	LogFlowFunc(("pReq->uFmtVBox=%#x, pReq->idxFmtX11=%u, pReq->pCtx=%p\n", pReq->uFmtVBox, pReq->idxFmtX11, pReq->pCtx));
1902
1903	LogRel2(("Shared Clipboard: Converting X11 format '%s' to VBox format %#x\n",
1904	g_aFormats[pReq->idxFmtX11].pcszAtom, pReq->uFmtVBox));
1905
1906	AssertPtr(pReq->pCtx);
1907	Assert(pReq->uFmtVBox != VBOX_SHCL_FMT_NONE); /* Sanity. */
1908
1909	int rc = VINF_SUCCESS;
1910
1911	void *pvDst = NULL;
1912	size_t cbDst = 0;
1913
1914	#ifdef VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY
1915	PSHCLX11CTX pCtx = pReq->pCtx;
1916	AssertPtr(pReq->pCtx);
1917
1918	pCtx->fXtBusy = false;
1919	if (pCtx->fXtNeedsUpdate)
1920	clipQueryX11Formats(pCtx);
1921	#endif
1922
1923	/* If X11 clipboard buffer has no data, libXt can pass to XtGetSelectionValue()
1924	* callback an empty string, in this case cbSrc is 0. */
1925	if (pvSrc == NULL \|\| cbSrc == 0)
1926	{
1927	/* The clipboard selection may have changed before we could get it. */
1928	rc = VERR_NO_DATA;
1929	}
1930	else if (pReq->uFmtVBox == VBOX_SHCL_FMT_UNICODETEXT)
1931	{
1932	/* In which format is the clipboard data? */
1933	switch (clipRealFormatForX11Format(pReq->idxFmtX11))
1934	{
1935	case SHCLX11FMT_UTF8:
1936	RT_FALL_THROUGH();
1937	case SHCLX11FMT_TEXT:
1938	{
1939	size_t cwDst;
1940
1941	/* If we are given broken UTF-8, we treat it as Latin1. / /* @todo BUGBUG Is this acceptable? */
1942	if (RT_SUCCESS(RTStrValidateEncodingEx((char *)pvSrc, cbSrc, 0)))
1943	rc = ShClConvUtf8LFToUtf16CRLF((const char *)pvSrc, cbSrc,
1944	(PRTUTF16 *)&pvDst, &cwDst);
1945	else
1946	rc = ShClConvLatin1LFToUtf16CRLF((char *)pvSrc, cbSrc,
1947	(PRTUTF16 *)&pvDst, &cwDst);
1948	if (RT_SUCCESS(rc))
1949	{
1950	cwDst += 1 /* Include terminator */;
1951	cbDst = cwDst * sizeof(RTUTF16); /* Convert RTUTF16 units to bytes. */
1952	}
1953	break;
1954	}
1955
1956	default:
1957	{
1958	rc = VERR_INVALID_PARAMETER;
1959	break;
1960	}
1961	}
1962	}
1963	else if (pReq->uFmtVBox == VBOX_SHCL_FMT_BITMAP)
1964	{
1965	/* In which format is the clipboard data? */
1966	switch (clipRealFormatForX11Format(pReq->idxFmtX11))
1967	{
1968	case SHCLX11FMT_BMP:
1969	{
1970	const void *pDib;
1971	size_t cbDibSize;
1972	rc = ShClBmpGetDib((const void *)pvSrc, cbSrc,
1973	&pDib, &cbDibSize);
1974	if (RT_SUCCESS(rc))
1975	{
1976	pvDst = RTMemAlloc(cbDibSize);
1977	if (!pvDst)
1978	rc = VERR_NO_MEMORY;
1979	else
1980	{
1981	memcpy(pvDst, pDib, cbDibSize);
1982	cbDst = cbDibSize;
1983	}
1984	}
1985	break;
1986	}
1987
1988	default:
1989	{
1990	rc = VERR_INVALID_PARAMETER;
1991	break;
1992	}
1993	}
1994	}
1995	else if (pReq->uFmtVBox == VBOX_SHCL_FMT_HTML)
1996	{
1997	/* In which format is the clipboard data? */
1998	switch (clipRealFormatForX11Format(pReq->idxFmtX11))
1999	{
2000	case SHCLX11FMT_HTML:
2001	{
2002	/*
2003	* The common VBox HTML encoding will be - UTF-8
2004	* because it more general for HTML formats then UTF-16
2005	* X11 clipboard returns UTF-16, so before sending it we should
2006	* convert it to UTF-8.
2007	*/
2008	pvDst = NULL;
2009	cbDst = 0;
2010
2011	/*
2012	* Some applications sends data in UTF-16, some in UTF-8,
2013	* without indication it in MIME.
2014	*
2015	* In case of UTF-16, at least [Open\|Libre] Office adds an byte order mark (0xfeff)
2016	* at the start of the clipboard data.
2017	*/
2018	if ( cbSrc >= sizeof(RTUTF16)
2019	&& *(PRTUTF16)pvSrc == VBOX_SHCL_UTF16LEMARKER)
2020	{
2021	rc = ShClConvUtf16ToUtf8HTML((PRTUTF16)pvSrc, cbSrc / sizeof(RTUTF16), (char**)&pvDst, &cbDst);
2022	if (RT_SUCCESS(rc))
2023	{
2024	LogFlowFunc(("UTF-16 Unicode source (%u bytes):\n%ls\n\n", cbSrc, pvSrc));
2025	LogFlowFunc(("Byte Order Mark = %hx", ((PRTUTF16)pvSrc)[0]));
2026	LogFlowFunc(("UTF-8 Unicode dest (%u bytes):\n%s\n\n", cbDst, pvDst));
2027	}
2028	else
2029	LogRel(("Shared Clipboard: Converting UTF-16 Unicode failed with %Rrc\n", rc));
2030	}
2031	else /* Raw data. */
2032	{
2033	pvDst = RTMemAlloc(cbSrc);
2034	if(pvDst)
2035	{
2036	memcpy(pvDst, pvSrc, cbSrc);
2037	cbDst = cbSrc;
2038	}
2039	else
2040	{
2041	rc = VERR_NO_MEMORY;
2042	break;
2043	}
2044	}
2045
2046	rc = VINF_SUCCESS;
2047	break;
2048	}
2049
2050	default:
2051	{
2052	rc = VERR_INVALID_PARAMETER;
2053	break;
2054	}
2055	}
2056	}
2057	# ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
2058	else if (pReq->uFmtVBox == VBOX_SHCL_FMT_URI_LIST)
2059	{
2060	/* In which format is the clipboard data? */
2061	switch (clipRealFormatForX11Format(pReq->idxFmtX11))
2062	{
2063	case SHCLX11FMT_URI_LIST:
2064	{
2065	/* For URI lists we only accept valid UTF-8 encodings. */
2066	if (RT_SUCCESS(RTStrValidateEncodingEx((char *)pvSrc, cbSrc, 0)))
2067	{
2068	/* URI lists on X are strings separated with "\r\n". */
2069	RTCList<RTCString> lstRootEntries = RTCString((char *)pvSrc, cbSrc).split("\r\n");
2070	for (size_t i = 0; i < lstRootEntries.size(); ++i)
2071	{
2072	char *pszEntry = RTUriFilePath(lstRootEntries.at(i).c_str());
2073	AssertPtrBreakStmt(pszEntry, VERR_INVALID_PARAMETER);
2074
2075	rc = RTStrAAppend((char **)&pvDst, "http://localhost");
2076	AssertRCBreakStmt(rc, VERR_NO_MEMORY);
2077	cbDst += (uint32_t)strlen(pszEntry);
2078
2079
2080
2081	/** @todo BUGBUG Fix port! */
2082	/** @todo Add port + UUID (virtual path). */
2083
2084	rc = RTStrAAppend((char **)&pvDst, pszEntry);
2085	AssertRCBreakStmt(rc, VERR_NO_MEMORY);
2086	cbDst += (uint32_t)strlen(pszEntry);
2087
2088	LogFlowFunc(("URI list entry '%s'\n", (char *)pvDst));
2089
2090	rc = RTStrAAppend((char **)&pvDst, "\r\n");
2091	AssertRCBreakStmt(rc, VERR_NO_MEMORY);
2092	cbDst += (uint32_t)strlen("\r\n");
2093
2094	RTStrFree(pszEntry);
2095	}
2096
2097	if (cbDst)
2098	cbDst++; /* Include final (zero) termination. */
2099
2100	LogFlowFunc(("URI list: cbDst=%RU32\n", cbDst));
2101	}
2102	else
2103	rc = VERR_INVALID_PARAMETER;
2104	break;
2105	}
2106
2107	default:
2108	{
2109	rc = VERR_INVALID_PARAMETER;
2110	break;
2111	}
2112	}
2113	}
2114	# endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
2115	else
2116	rc = VERR_NOT_SUPPORTED;
2117
2118	if (RT_FAILURE(rc))
2119	LogRel(("Shared Clipboard: Converting X11 format '%s' (idxFmtX11=%u) to VBox format %#x failed, rc=%Rrc\n",
2120	g_aFormats[pReq->idxFmtX11].pcszAtom, pReq->idxFmtX11, pReq->uFmtVBox, rc));
2121
2122	ShClX11RequestFromX11CompleteCallback(pReq->pCtx->pFrontend, rc, pReq->pReq,
2123	pvDst, cbDst);
2124	RTMemFree(pvDst);
2125	RTMemFree(pReq);
2126
2127	LogFlowFuncLeaveRC(rc);
2128	}
2129
2130	/**
2131	* Converts the data obtained from the X11 clipboard to the required format,
2132	* place it in the buffer supplied and signal that data has arrived.
2133	*
2134	* Converts the text obtained UTF-16LE with Windows EOLs.
2135	* Converts full BMP data to DIB format.
2136	*/
2137	SHCL_X11_DECL(void) clipConvertDataFromX11(Widget widget, XtPointer pClient,
2138	Atom * /* selection /, Atom atomType,
2139	XtPointer pvSrc, long unsigned int *pcLen,
2140	int *piFormat)
2141	{
2142	RT_NOREF(widget);
2143	if (atomType == XT_CONVERT_FAIL) / Xt timeout */
2144	clipConvertDataFromX11Worker(pClient, NULL, 0);
2145	else
2146	clipConvertDataFromX11Worker(pClient, pvSrc, (pcLen) (*piFormat) / 8);
2147
2148	XtFree((char *)pvSrc);
2149	}
2150
2151	static int clipGetSelectionValue(PSHCLX11CTX pCtx, SHCLX11FMTIDX idxFmt,
2152	CLIPREADX11CBREQ *pReq)
2153	{
2154	#ifndef TESTCASE
2155	XtGetSelectionValue(pCtx->pWidget, clipGetAtom(pCtx, "CLIPBOARD"),
2156	clipAtomForX11Format(pCtx, idxFmt),
2157	clipConvertDataFromX11,
2158	reinterpret_cast<XtPointer>(pReq),
2159	CurrentTime);
2160	#else
2161	tstClipRequestData(pCtx, idxFmt, (void *)pReq);
2162	#endif
2163
2164	return VINF_SUCCESS; /** @todo Return real rc. */
2165	}
2166
2167	/**
2168	* Worker function for ShClX11ReadDataFromX11 which runs on the event thread.
2169	*
2170	* @param pvUserData Pointer to a CLIPREADX11CBREQ structure containing
2171	* information about the clipboard read request.
2172	* Must be free'd by the worker.
2173	*/
2174	static void ShClX11ReadDataFromX11Worker(void pvUserData, void /* interval */)
2175	{
2176	AssertPtrReturnVoid(pvUserData);
2177
2178	CLIPREADX11CBREQ pReq = (CLIPREADX11CBREQ )pvUserData;
2179	SHCLX11CTX *pCtx = pReq->pCtx;
2180
2181	LogFlowFunc(("pReq->mFormat = %02x\n", pReq->uFmtVBox));
2182
2183	int rc = VERR_NO_DATA; /* VBox thinks we have data and we don't. */
2184
2185	#ifdef VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY
2186	const bool fXtBusy = pCtx->fXtBusy;
2187	pCtx->fXtBusy = true;
2188	if (fXtBusy)
2189	{
2190	/* If the clipboard is busy just fend off the request. */
2191	rc = VERR_TRY_AGAIN;
2192	}
2193	else
2194	#endif
2195	if (pReq->uFmtVBox & VBOX_SHCL_FMT_UNICODETEXT)
2196	{
2197	pReq->idxFmtX11 = pCtx->idxFmtText;
2198	if (pReq->idxFmtX11 != SHCLX11FMT_INVALID)
2199	{
2200	/* Send out a request for the data to the current clipboard owner. */
2201	rc = clipGetSelectionValue(pCtx, pCtx->idxFmtText, pReq);
2202	}
2203	}
2204	else if (pReq->uFmtVBox & VBOX_SHCL_FMT_BITMAP)
2205	{
2206	pReq->idxFmtX11 = pCtx->idxFmtBmp;
2207	if (pReq->idxFmtX11 != SHCLX11FMT_INVALID)
2208	{
2209	/* Send out a request for the data to the current clipboard owner. */
2210	rc = clipGetSelectionValue(pCtx, pCtx->idxFmtBmp, pReq);
2211	}
2212	}
2213	else if (pReq->uFmtVBox & VBOX_SHCL_FMT_HTML)
2214	{
2215	pReq->idxFmtX11 = pCtx->idxFmtHTML;
2216	if (pReq->idxFmtX11 != SHCLX11FMT_INVALID)
2217	{
2218	/* Send out a request for the data to the current clipboard owner. */
2219	rc = clipGetSelectionValue(pCtx, pCtx->idxFmtHTML, pReq);
2220	}
2221	}
2222	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
2223	else if (pReq->uFmtVBox & VBOX_SHCL_FMT_URI_LIST)
2224	{
2225	pReq->idxFmtX11 = pCtx->idxFmtURI;
2226	if (pReq->idxFmtX11 != SHCLX11FMT_INVALID)
2227	{
2228	/* Send out a request for the data to the current clipboard owner. */
2229	rc = clipGetSelectionValue(pCtx, pCtx->idxFmtURI, pReq);
2230	}
2231	}
2232	#endif
2233	else
2234	{
2235	#ifdef VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY
2236	pCtx->fXtBusy = false;
2237	#endif
2238	rc = VERR_NOT_IMPLEMENTED;
2239	}
2240
2241	if (RT_FAILURE(rc))
2242	{
2243	/* The clipboard callback was never scheduled, so we must signal
2244	* that the request processing is finished and clean up ourselves. */
2245	ShClX11RequestFromX11CompleteCallback(pReq->pCtx->pFrontend, rc, pReq->pReq,
2246	NULL /* pv / ,0 / cb */);
2247	RTMemFree(pReq);
2248	}
2249
2250	LogFlowFuncLeaveRC(rc);
2251	}
2252
2253	/**
2254	* Called when VBox wants to read the X11 clipboard.
2255	*
2256	* @returns VBox status code.
2257	* @retval VERR_NO_DATA if format is supported but no data is available currently.
2258	* @retval VERR_NOT_IMPLEMENTED if the format is not implemented.
2259	* @param pCtx Context data for the clipboard backend.
2260	* @param Format The format that the VBox would like to receive the data in.
2261	* @param pReq Read callback request to use. Will be free'd in the callback on success.
2262	* Otherwise the caller has to free this again on error.
2263	*
2264	* @note We allocate a request structure which must be freed by the worker.
2265	*/
2266	int ShClX11ReadDataFromX11(PSHCLX11CTX pCtx, SHCLFORMAT Format, CLIPREADCBREQ *pReq)
2267	{
2268	AssertPtrReturn(pReq, VERR_INVALID_POINTER);
2269
2270	/*
2271	* Immediately return if we are not connected to the X server.
2272	*/
2273	if (!pCtx->fHaveX11)
2274	return VERR_NO_DATA;
2275
2276	int rc = VINF_SUCCESS;
2277
2278	CLIPREADX11CBREQ pX11Req = (CLIPREADX11CBREQ )RTMemAllocZ(sizeof(CLIPREADX11CBREQ));
2279	if (pX11Req)
2280	{
2281	pX11Req->pCtx = pCtx;
2282	pX11Req->uFmtVBox = Format;
2283	pX11Req->pReq = pReq;
2284
2285	/* We use this to schedule a worker function on the event thread. */
2286	rc = clipThreadScheduleCall(pCtx, ShClX11ReadDataFromX11Worker, (XtPointer)pX11Req);
2287	if (RT_FAILURE(rc))
2288	RTMemFree(pX11Req);
2289	}
2290	else
2291	rc = VERR_NO_MEMORY;
2292
2293	LogFlowFuncLeaveRC(rc);
2294	return rc;
2295	}

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

Download in other formats:

© 2023 Oracle
Contact – Privacy policy – Terms of Use