clipboard.cpp@ 81873

Last change on this file since 81873 was 81871, checked in by vboxsync, 5 years ago
Shared Clipboard/VBoxClient: Simplified code of ClipRequestDataForX11Callback().
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 14.0 KB

Line
1	/** $Id: clipboard.cpp 81871 2019-11-15 13:09:11Z vboxsync $ */
2	/** @file
3	* Guest Additions - X11 Shared Clipboard.
4	*/
5
6	/*
7	* Copyright (C) 2007-2019 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#include <iprt/alloc.h>
23	#include <iprt/asm.h>
24	#include <iprt/assert.h>
25	#include <iprt/initterm.h>
26	#include <iprt/mem.h>
27	#include <iprt/string.h>
28	#include <iprt/process.h>
29	#include <iprt/semaphore.h>
30
31	#include <VBox/log.h>
32	#include <VBox/VBoxGuestLib.h>
33	#include <VBox/HostServices/VBoxClipboardSvc.h>
34	#include <VBox/GuestHost/SharedClipboard.h>
35
36	#include "VBoxClient.h"
37
38
39	/*********************************************************************************************************************************
40	* Global Variables *
41	*********************************************************************************************************************************/
42
43	/**
44	* Global clipboard context information.
45	*/
46	struct _SHCLCONTEXT
47	{
48	/** Client command context */
49	VBGLR3SHCLCMDCTX CmdCtx;
50	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
51	/** Associated transfer data. */
52	SHCLTRANSFERCTX TransferCtx;
53	#endif
54	/** Pointer to the X11 clipboard backend. */
55	CLIPBACKEND *pBackend;
56	};
57
58	/** Only one client is supported. There seems to be no need for more clients. */
59	static SHCLCONTEXT g_Ctx;
60
61
62	/**
63	* Get clipboard data from the host.
64	*
65	* @returns VBox result code
66	* @param pCtx Our context information.
67	* @param Format The format of the data being requested.
68	* @param ppv On success and if pcb > 0, this will point to a buffer
69	* to be freed with RTMemFree containing the data read.
70	* @param pcb On success, this contains the number of bytes of data
71	* returned.
72	*/
73	DECLCALLBACK(int) ClipRequestDataForX11Callback(SHCLCONTEXT pCtx, SHCLFORMAT Format, void ppv, uint32_t pcb)
74	{
75	RT_NOREF(pCtx);
76
77	LogFlowFunc(("Format=0x%x\n", Format));
78
79	int rc = VINF_SUCCESS;
80
81	uint32_t cbRead = 0;
82
83	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
84	if (Format == VBOX_SHCL_FMT_URI_LIST)
85	{
86	//rc = VbglR3ClipboardRootListRead()
87	}
88	else
89	#endif
90	{
91	SHCLDATABLOCK dataBlock;
92	RT_ZERO(dataBlock);
93
94	dataBlock.uFormat = Format;
95	dataBlock.cbData = _4K;
96	dataBlock.pvData = RTMemAlloc(dataBlock.cbData);
97	if (dataBlock.pvData)
98	{
99	rc = VbglR3ClipboardReadDataEx(&pCtx->CmdCtx, &dataBlock, &cbRead);
100	}
101	else
102	rc = VERR_NO_MEMORY;
103
104	/*
105	* A return value of VINF_BUFFER_OVERFLOW tells us to try again with a
106	* larger buffer. The size of the buffer needed is placed in *pcb.
107	* So we start all over again.
108	*/
109	if (rc == VINF_BUFFER_OVERFLOW)
110	{
111	/* cbRead contains the size required. */
112
113	dataBlock.cbData = cbRead;
114	dataBlock.pvData = RTMemRealloc(dataBlock.pvData, cbRead);
115	if (dataBlock.pvData)
116	{
117	rc = VbglR3ClipboardReadDataEx(&pCtx->CmdCtx, &dataBlock, &cbRead);
118	if (rc == VINF_BUFFER_OVERFLOW)
119	rc = VERR_BUFFER_OVERFLOW;
120	}
121	else
122	rc = VERR_NO_MEMORY;
123	}
124
125	if (RT_SUCCESS(rc))
126	{
127	pcb = cbRead; / Actual bytes read. */
128	*ppv = dataBlock.pvData;
129	}
130
131	/*
132	* Catch other errors. This also catches the case in which the buffer was
133	* too small a second time, possibly because the clipboard contents
134	* changed half-way through the operation. Since we can't say whether or
135	* not this is actually an error, we just return size 0.
136	*/
137	if (RT_FAILURE(rc))
138	RTMemFree(dataBlock.pvData);
139	}
140
141	LogFlowFuncLeaveRC(rc);
142	return rc;
143	}
144
145	/**
146	* Opaque data structure describing a request from the host for clipboard
147	* data, passed in when the request is forwarded to the X11 backend so that
148	* it can be completed correctly.
149	*/
150	struct _CLIPREADCBREQ
151	{
152	/** The data format that was requested. */
153	SHCLFORMAT Format;
154	};
155
156	/**
157	* Tell the host that new clipboard formats are available.
158	*
159	* @param pCtx Our context information.
160	* @param Formats The formats to report.
161	*/
162	DECLCALLBACK(void) ClipReportX11FormatsCallback(SHCLCONTEXT *pCtx, SHCLFORMATS Formats)
163	{
164	RT_NOREF(pCtx);
165
166	LogFlowFunc(("Formats=0x%x\n", Formats));
167
168	SHCLFORMATDATA formatData;
169	RT_ZERO(formatData);
170
171	formatData.Formats = Formats;
172
173	int rc2 = VbglR3ClipboardFormatsReportEx(&pCtx->CmdCtx, &formatData);
174	RT_NOREF(rc2);
175	LogFlowFuncLeaveRC(rc2);
176	}
177
178	/**
179	* This is called by the backend to tell us that a request for data from
180	* X11 has completed.
181	*
182	* @param pCtx Our context information.
183	* @param rc The IPRT result code of the request.
184	* @param pReq The request structure that we passed in when we started
185	* the request. We RTMemFree() this in this function.
186	* @param pv The clipboard data returned from X11 if the request succeeded (see @a rc).
187	* @param cb The size of the data in @a pv.
188	*/
189	DECLCALLBACK(void) ClipRequestFromX11CompleteCallback(SHCLCONTEXT pCtx, int rc, CLIPREADCBREQ pReq, void *pv, uint32_t cb)
190	{
191	RT_NOREF(pCtx);
192
193	LogFlowFunc(("rc=%Rrc, Format=0x%x, pv=%p, cb=%RU32\n", rc, pReq->Format, pv, cb));
194
195	SHCLDATABLOCK dataBlock;
196	RT_ZERO(dataBlock);
197
198	dataBlock.uFormat = pReq->Format;
199
200	if (RT_SUCCESS(rc))
201	{
202	dataBlock.pvData = pv;
203	dataBlock.cbData = cb;
204	}
205
206	int rc2 = VbglR3ClipboardWriteDataEx(&pCtx->CmdCtx, &dataBlock);
207	RT_NOREF(rc2);
208
209	RTMemFree(pReq);
210
211	LogFlowFuncLeaveRC(rc2);
212	}
213
214	/**
215	* Connect the guest clipboard to the host.
216	*
217	* @returns VBox status code.
218	*/
219	static int vboxClipboardConnect(void)
220	{
221	LogFlowFuncEnter();
222
223	int rc;
224
225	g_Ctx.pBackend = ClipConstructX11(&g_Ctx, false);
226	if (g_Ctx.pBackend)
227	{
228	rc = ClipStartX11(g_Ctx.pBackend, false /* grab */);
229	if (RT_SUCCESS(rc))
230	{
231	rc = VbglR3ClipboardConnectEx(&g_Ctx.CmdCtx);
232	}
233	}
234	else
235	rc = VERR_NO_MEMORY;
236
237	if (RT_FAILURE(rc))
238	{
239	VBClLogError("Error connecting to host service, rc=%Rrc\n", rc);
240
241	VbglR3ClipboardDisconnectEx(&g_Ctx.CmdCtx);
242	ClipDestructX11(g_Ctx.pBackend);
243	}
244
245	LogFlowFuncLeaveRC(rc);
246	return rc;
247	}
248
249	/**
250	* The main loop of our clipboard reader.
251	*/
252	int vboxClipboardMain(void)
253	{
254	LogRel(("Worker loop running\n"));
255
256	int rc;
257
258	SHCLCONTEXT *pCtx = &g_Ctx;
259
260	bool fShutdown = false;
261
262	/* The thread waits for incoming messages from the host. */
263	for (;;)
264	{
265	PVBGLR3CLIPBOARDEVENT pEvent = NULL;
266
267	LogFlowFunc(("Waiting for host message (fUseLegacyProtocol=%RTbool, fHostFeatures=%#RX64) ...\n",
268	pCtx->CmdCtx.fUseLegacyProtocol, pCtx->CmdCtx.fHostFeatures));
269
270	if (pCtx->CmdCtx.fUseLegacyProtocol)
271	{
272	uint32_t uMsg;
273	uint32_t uFormats;
274
275	rc = VbglR3ClipboardGetHostMsgOld(pCtx->CmdCtx.uClientID, &uMsg, &uFormats);
276	if (RT_FAILURE(rc))
277	{
278	if (rc == VERR_INTERRUPTED)
279	break;
280
281	LogFunc(("Error getting host message, rc=%Rrc\n", rc));
282	}
283	else
284	{
285	pEvent = (PVBGLR3CLIPBOARDEVENT)RTMemAllocZ(sizeof(VBGLR3CLIPBOARDEVENT));
286	AssertPtrBreakStmt(pEvent, rc = VERR_NO_MEMORY);
287
288	switch (uMsg)
289	{
290	case VBOX_SHCL_HOST_MSG_FORMATS_REPORT:
291	{
292	pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_REPORT_FORMATS;
293	pEvent->u.ReportedFormats.Formats = uFormats;
294	break;
295	}
296
297	case VBOX_SHCL_HOST_MSG_READ_DATA:
298	{
299	pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_READ_DATA;
300	pEvent->u.ReadData.uFmt = uFormats;
301	break;
302	}
303
304	case VBOX_SHCL_HOST_MSG_QUIT:
305	{
306	pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_QUIT;
307	break;
308	}
309
310	default:
311	rc = VERR_NOT_SUPPORTED;
312	break;
313	}
314
315	if (RT_SUCCESS(rc))
316	{
317	/* Copy over our command context to the event. */
318	pEvent->cmdCtx = pCtx->CmdCtx;
319	}
320	}
321	}
322	else /* Host service has peeking for messages support. */
323	{
324	pEvent = (PVBGLR3CLIPBOARDEVENT)RTMemAllocZ(sizeof(VBGLR3CLIPBOARDEVENT));
325	AssertPtrBreakStmt(pEvent, rc = VERR_NO_MEMORY);
326
327	uint32_t uMsg = 0;
328	uint32_t cParms = 0;
329	rc = VbglR3ClipboardMsgPeekWait(&pCtx->CmdCtx, &uMsg, &cParms, NULL /* pidRestoreCheck */);
330	if (RT_SUCCESS(rc))
331	{
332	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
333	rc = VbglR3ClipboardEventGetNextEx(uMsg, cParms, &pCtx->CmdCtx, &pCtx->TransferCtx, pEvent);
334	#else
335	rc = VbglR3ClipboardEventGetNext(uMsg, cParms, &pCtx->CmdCtx, pEvent);
336	#endif
337	}
338	}
339
340	if (RT_FAILURE(rc))
341	{
342	LogFlowFunc(("Getting next event failed with %Rrc\n", rc));
343
344	VbglR3ClipboardEventFree(pEvent);
345	pEvent = NULL;
346
347	if (fShutdown)
348	break;
349
350	/* Wait a bit before retrying. */
351	RTThreadSleep(1000);
352	continue;
353	}
354	else
355	{
356	AssertPtr(pEvent);
357	LogFlowFunc(("Event uType=%RU32\n", pEvent->enmType));
358
359	switch (pEvent->enmType)
360	{
361	case VBGLR3CLIPBOARDEVENTTYPE_REPORT_FORMATS:
362	{
363	ClipAnnounceFormatToX11(g_Ctx.pBackend, pEvent->u.ReportedFormats.Formats);
364	break;
365	}
366
367	case VBGLR3CLIPBOARDEVENTTYPE_READ_DATA:
368	{
369	/* The host needs data in the specified format. */
370	CLIPREADCBREQ *pReq;
371	pReq = (CLIPREADCBREQ *)RTMemAllocZ(sizeof(CLIPREADCBREQ));
372	if (pReq)
373	{
374	pReq->Format = pEvent->u.ReadData.uFmt;
375	ClipReadDataFromX11(g_Ctx.pBackend, pReq->Format, pReq);
376	}
377	else
378	rc = VERR_NO_MEMORY;
379	break;
380	}
381
382	case VBGLR3CLIPBOARDEVENTTYPE_QUIT:
383	{
384	LogRel2(("Host requested termination\n"));
385	fShutdown = true;
386	break;
387	}
388
389	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
390	case VBGLR3CLIPBOARDEVENTTYPE_TRANSFER_STATUS:
391	{
392	/* Nothing to do here. */
393	rc = VINF_SUCCESS;
394	break;
395	}
396	#endif
397	case VBGLR3CLIPBOARDEVENTTYPE_NONE:
398	{
399	/* Nothing to do here. */
400	rc = VINF_SUCCESS;
401	break;
402	}
403
404	default:
405	{
406	AssertMsgFailedBreakStmt(("Event type %RU32 not implemented\n", pEvent->enmType), rc = VERR_NOT_SUPPORTED);
407	}
408	}
409
410	if (pEvent)
411	{
412	VbglR3ClipboardEventFree(pEvent);
413	pEvent = NULL;
414	}
415	}
416
417	if (fShutdown)
418	break;
419	}
420
421	LogRel(("Worker loop ended\n"));
422
423	LogFlowFuncLeaveRC(rc);
424	return rc;
425	}
426
427	static const char *getName()
428	{
429	return "Shared Clipboard";
430	}
431
432	static const char *getPidFilePath()
433	{
434	return ".vboxclient-clipboard.pid";
435	}
436
437	static int run(struct VBCLSERVICE **ppInterface, bool fDaemonised)
438	{
439	RT_NOREF(ppInterface, fDaemonised);
440
441	/* Initialise the guest library. */
442	int rc = vboxClipboardConnect();
443	if (RT_SUCCESS(rc))
444	{
445	rc = vboxClipboardMain();
446	}
447
448	if (RT_FAILURE(rc))
449	VBClLogError("Service terminated abnormally with %Rrc\n", rc);
450
451	if (rc == VERR_HGCM_SERVICE_NOT_FOUND)
452	rc = VINF_SUCCESS; /* Prevent automatic restart by daemon script if host service not available. */
453
454	return rc;
455	}
456
457	static void cleanup(struct VBCLSERVICE **ppInterface)
458	{
459	RT_NOREF(ppInterface);
460	VbglR3Term();
461	}
462
463	struct VBCLSERVICE vbclClipboardInterface =
464	{
465	getName,
466	getPidFilePath,
467	VBClServiceDefaultHandler, /* init */
468	run,
469	cleanup
470	};
471
472	struct CLIPBOARDSERVICE
473	{
474	struct VBCLSERVICE *pInterface;
475	};
476
477	struct VBCLSERVICE **VBClGetClipboardService(void)
478	{
479	struct CLIPBOARDSERVICE *pService =
480	(struct CLIPBOARDSERVICE )RTMemAlloc(sizeof(pService));
481
482	if (!pService)
483	VBClLogFatalError("Out of memory\n");
484	pService->pInterface = &vbclClipboardInterface;
485	return &pService->pInterface;
486	}

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

source: vbox/trunk/src/VBox/Additions/x11/VBoxClient/clipboard.cpp@ 81873

Download in other formats: