service.cpp@ 19948

Last change on this file since 19948 was 19875, checked in by vboxsync, 15 years ago
HostServices and GuestHost/SharedClipboard: hopefully fixed the broken saved state and improved on my changes to the platform-neutral code for asynchronous handling of guest data requests
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 30.9 KB

Line
1	/** @file
2	*
3	* Shared Clipboard:
4	* Host service entry points.
5	*/
6
7	/*
8	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
9	*
10	* This file is part of VirtualBox Open Source Edition (OSE), as
11	* available from http://www.virtualbox.org. This file is free software;
12	* you can redistribute it and/or modify it under the terms of the GNU
13	* General Public License (GPL) as published by the Free Software
14	* Foundation, in version 2 as it comes in the "COPYING" file of the
15	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
16	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
17	*
18	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
19	* Clara, CA 95054 USA or visit http://www.sun.com if you need
20	* additional information or have any questions.
21	*/
22
23
24	/** @page pg_hostclip The Shared Clipboard Host Service
25	*
26	* The shared clipboard host service provides a proxy between the host's
27	* clipboard and a similar proxy running on a guest. The service is split
28	* into a platform-independant core and platform-specific backends. The
29	* service defines two communication protocols - one to communicate with the
30	* clipboard service running on the guest, and one to communicate with the
31	* backend. These will be described in a very skeletal fashion here.
32	*
33	* @section sec_hostclip_guest_proto The guest communication protocol
34	*
35	* The guest clipboard service communicates with the host service via HGCM
36	* (the host service runs as an HGCM service). The guest clipboard must
37	* connect to the host service before all else (Windows hosts currently only
38	* support one simultaneous connection). Once it has connected, it can send
39	* HGCM messages to the host services, some of which will receive replies from
40	* the host. The host can only reply to a guest message, it cannot initiate
41	* any communication. The guest can in theory send any number of messages in
42	* parallel (see the descriptions of the messages for the practice), and the
43	* host will receive these in sequence, and may reply to them at once
44	* (releasing the caller in the guest) or defer the reply until later.
45	*
46	* There are currently four messages defined. The first is
47	* VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG, which waits for a message from the
48	* host. Host messages currently defined are
49	* VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT (unused),
50	* VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA (request that the guest send the
51	* contents of its clipboard to the host) and
52	* VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS (to notify the guest that new
53	* clipboard data is available). If a host message is sent while the guest is
54	* not waiting, it will be queued until the guest requests it. At most one
55	* host message of each type will be kept in the queue. The host code only
56	* supports a single simultaneous VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG call
57	* from the guest.
58	*
59	* The second guest message is VBOX_SHARED_CLIPBOARD_FN_FORMATS, which tells
60	* the host that the guest has new clipboard data available. The third is
61	* VBOX_SHARED_CLIPBOARD_FN_READ_DATA, which asks the host to send its
62	* clipboard data and waits until it arrives. The host supports at most one
63	* simultaneous VBOX_SHARED_CLIPBOARD_FN_READ_DATA call from the guest - if a
64	* second call is made before the first has returned, the first will be
65	* aborted.
66	*
67	* The last guest message is VBOX_SHARED_CLIPBOARD_FN_WRITE_DATA, which is
68	* used to send the contents of the guest clipboard to the host. This call
69	* should be used after the host has requested data from the guest.
70	*
71	* @section sec_hostclip_backend_proto The communication protocol with the
72	* platform-specific backend
73	*
74	* This section may be written in the future :)
75	*/
76
77	#include <VBox/HostServices/VBoxClipboardSvc.h>
78	#include <VBox/HostServices/VBoxClipboardExt.h>
79
80	#include <iprt/alloc.h>
81	#include <iprt/string.h>
82	#include <iprt/assert.h>
83	#include <iprt/critsect.h>
84	#include <VBox/ssm.h>
85
86	#include "VBoxClipboard.h"
87
88	static void VBoxHGCMParmUInt32Set (VBOXHGCMSVCPARM *pParm, uint32_t u32)
89	{
90	pParm->type = VBOX_HGCM_SVC_PARM_32BIT;
91	pParm->u.uint32 = u32;
92	}
93
94	static int VBoxHGCMParmUInt32Get (VBOXHGCMSVCPARM pParm, uint32_t pu32)
95	{
96	if (pParm->type == VBOX_HGCM_SVC_PARM_32BIT)
97	{
98	*pu32 = pParm->u.uint32;
99	return VINF_SUCCESS;
100	}
101
102	return VERR_INVALID_PARAMETER;
103	}
104
105	#if 0
106	static void VBoxHGCMParmPtrSet (VBOXHGCMSVCPARM pParm, void pv, uint32_t cb)
107	{
108	pParm->type = VBOX_HGCM_SVC_PARM_PTR;
109	pParm->u.pointer.size = cb;
110	pParm->u.pointer.addr = pv;
111	}
112	#endif
113
114	static int VBoxHGCMParmPtrGet (VBOXHGCMSVCPARM pParm, void ppv, uint32_t pcb)
115	{
116	if (pParm->type == VBOX_HGCM_SVC_PARM_PTR)
117	{
118	*ppv = pParm->u.pointer.addr;
119	*pcb = pParm->u.pointer.size;
120	return VINF_SUCCESS;
121	}
122
123	return VERR_INVALID_PARAMETER;
124	}
125
126	static PVBOXHGCMSVCHELPERS g_pHelpers;
127
128	static RTCRITSECT critsect;
129	static uint32_t g_u32Mode;
130
131	static PFNHGCMSVCEXT g_pfnExtension;
132	static void *g_pvExtension;
133
134	static VBOXCLIPBOARDCLIENTDATA *g_pClient;
135
136	/* Serialization of data reading and format announcements from the RDP client. */
137	static bool g_fReadingData = false;
138	static bool g_fDelayedAnnouncement = false;
139	static uint32_t g_u32DelayedFormats = 0;
140
141	static uint32_t vboxSvcClipboardMode (void)
142	{
143	return g_u32Mode;
144	}
145
146	static void vboxSvcClipboardModeSet (uint32_t u32Mode)
147	{
148	switch (u32Mode)
149	{
150	case VBOX_SHARED_CLIPBOARD_MODE_OFF:
151	case VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST:
152	case VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST:
153	case VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL:
154	g_u32Mode = u32Mode;
155	break;
156
157	default:
158	g_u32Mode = VBOX_SHARED_CLIPBOARD_MODE_OFF;
159	}
160	}
161
162	bool vboxSvcClipboardLock (void)
163	{
164	return RT_SUCCESS(RTCritSectEnter (&critsect));
165	}
166
167	void vboxSvcClipboardUnlock (void)
168	{
169	RTCritSectLeave (&critsect);
170	}
171
172	/* Set the HGCM parameters according to pending messages.
173	* Executed under the clipboard lock.
174	*/
175	static bool vboxSvcClipboardReturnMsg (VBOXCLIPBOARDCLIENTDATA *pClient, VBOXHGCMSVCPARM paParms[])
176	{
177	/* Message priority is taken into account. */
178	if (pClient->fMsgQuit)
179	{
180	LogFlow(("vboxSvcClipboardReturnMsg: Quit\n"));
181	VBoxHGCMParmUInt32Set (&paParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT);
182	VBoxHGCMParmUInt32Set (&paParms[1], 0);
183	pClient->fMsgQuit = false;
184	}
185	else if (pClient->fMsgReadData)
186	{
187	LogFlow(("vboxSvcClipboardReturnMsg: ReadData %02X\n", pClient->u32RequestedFormat));
188	VBoxHGCMParmUInt32Set (&paParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
189	VBoxHGCMParmUInt32Set (&paParms[1], pClient->u32RequestedFormat);
190	pClient->fMsgReadData = false;
191	}
192	else if (pClient->fMsgFormats)
193	{
194	LogFlow(("vboxSvcClipboardReturnMsg: Formats %02X\n", pClient->u32AvailableFormats));
195	VBoxHGCMParmUInt32Set (&paParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS);
196	VBoxHGCMParmUInt32Set (&paParms[1], pClient->u32AvailableFormats);
197	pClient->fMsgFormats = false;
198	}
199	else
200	{
201	/* No pending messages. */
202	LogFlow(("vboxSvcClipboardReturnMsg: no message\n"));
203	return false;
204	}
205
206	/* Message information assigned. */
207	return true;
208	}
209
210	void vboxSvcClipboardReportMsg (VBOXCLIPBOARDCLIENTDATA *pClient, uint32_t u32Msg, uint32_t u32Formats)
211	{
212	if (vboxSvcClipboardLock ())
213	{
214	switch (u32Msg)
215	{
216	case VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT:
217	{
218	LogFlow(("vboxSvcClipboardReportMsg: Quit\n"));
219	pClient->fMsgQuit = true;
220	} break;
221	case VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA:
222	{
223	if ( vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
224	&& vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
225	{
226	/* Skip the message. */
227	break;
228	}
229
230	LogFlow(("vboxSvcClipboardReportMsg: ReadData %02X\n", u32Formats));
231	pClient->u32RequestedFormat = u32Formats;
232	pClient->fMsgReadData = true;
233	} break;
234	case VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS:
235	{
236	if ( vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST
237	&& vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
238	{
239	/* Skip the message. */
240	break;
241	}
242
243	LogFlow(("vboxSvcClipboardReportMsg: Formats %02X\n", u32Formats));
244	pClient->u32AvailableFormats = u32Formats;
245	pClient->fMsgFormats = true;
246	} break;
247	default:
248	{
249	/* Invalid message. */
250	LogFlow(("vboxSvcClipboardReportMsg: invalid message %d\n", u32Msg));
251	} break;
252	}
253
254	if (pClient->fAsync)
255	{
256	/* The client waits for a responce. */
257	bool fMessageReturned = vboxSvcClipboardReturnMsg (pClient, pClient->async.paParms);
258
259	/* Make a copy of the handle. */
260	VBOXHGCMCALLHANDLE callHandle = pClient->async.callHandle;
261
262	if (fMessageReturned)
263	{
264	/* There is a responce. */
265	pClient->fAsync = false;
266	}
267
268	vboxSvcClipboardUnlock ();
269
270	if (fMessageReturned)
271	{
272	LogFlow(("vboxSvcClipboardReportMsg: CallComplete\n"));
273	g_pHelpers->pfnCallComplete (callHandle, VINF_SUCCESS);
274	}
275	}
276	else
277	{
278	vboxSvcClipboardUnlock ();
279	}
280	}
281	}
282
283	static int svcInit (void)
284	{
285	int rc = RTCritSectInit (&critsect);
286
287	if (RT_SUCCESS (rc))
288	{
289	vboxSvcClipboardModeSet (VBOX_SHARED_CLIPBOARD_MODE_OFF);
290
291	rc = vboxClipboardInit ();
292
293	/* Clean up on failure, because 'svnUnload' will not be called
294	* if the 'svcInit' returns an error.
295	*/
296	if (RT_FAILURE (rc))
297	{
298	RTCritSectDelete (&critsect);
299	}
300	}
301
302	return rc;
303	}
304
305	static DECLCALLBACK(int) svcUnload (void *)
306	{
307	vboxClipboardDestroy ();
308	RTCritSectDelete (&critsect);
309	return VINF_SUCCESS;
310	}
311
312	/**
313	* Disconnect the host side of the shared clipboard and send a "host disconnected" message
314	* to the guest side.
315	*/
316	static DECLCALLBACK(int) svcDisconnect (void , uint32_t u32ClientID, void pvClient)
317	{
318	VBOXCLIPBOARDCLIENTDATA pClient = (VBOXCLIPBOARDCLIENTDATA )pvClient;
319
320	vboxSvcClipboardReportMsg (pClient, VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT, 0);
321
322	vboxClipboardDisconnect (pClient);
323
324	memset (pClient, 0, sizeof (*pClient));
325
326	g_pClient = NULL;
327
328	return VINF_SUCCESS;
329	}
330
331	static DECLCALLBACK(int) svcConnect (void , uint32_t u32ClientID, void pvClient)
332	{
333	VBOXCLIPBOARDCLIENTDATA pClient = (VBOXCLIPBOARDCLIENTDATA )pvClient;
334
335	int rc = VINF_SUCCESS;
336
337	/* If there is already a client connected then we want to release it first. */
338	if (g_pClient != NULL)
339	{
340	uint32_t u32ClientID = g_pClient->u32ClientID;
341
342	svcDisconnect(NULL, u32ClientID, g_pClient);
343	/* And free the resources in the hgcm subsystem. */
344	g_pHelpers->pfnDisconnectClient(g_pHelpers->pvInstance, u32ClientID);
345	}
346
347	/* Register the client. */
348	memset (pClient, 0, sizeof (*pClient));
349
350	pClient->u32ClientID = u32ClientID;
351
352	rc = vboxClipboardConnect (pClient);
353
354	if (RT_SUCCESS (rc))
355	{
356	g_pClient = pClient;
357	}
358
359	Log(("vboxClipboardConnect: rc = %Rrc\n", rc));
360
361	return rc;
362	}
363
364	static DECLCALLBACK(void) svcCall (void *,
365	VBOXHGCMCALLHANDLE callHandle,
366	uint32_t u32ClientID,
367	void *pvClient,
368	uint32_t u32Function,
369	uint32_t cParms,
370	VBOXHGCMSVCPARM paParms[])
371	{
372	int rc = VINF_SUCCESS;
373
374	Log(("svcCall: u32ClientID = %d, fn = %d, cParms = %d, pparms = %d\n",
375	u32ClientID, u32Function, cParms, paParms));
376
377	VBOXCLIPBOARDCLIENTDATA pClient = (VBOXCLIPBOARDCLIENTDATA )pvClient;
378
379	bool fAsynchronousProcessing = false;
380
381	#ifdef DEBUG
382	uint32_t i;
383
384	for (i = 0; i < cParms; i++)
385	{
386	/** @todo parameters other than 32 bit */
387	Log((" pparms[%d]: type %d value %d\n", i, paParms[i].type, paParms[i].u.uint32));
388	}
389	#endif
390
391	switch (u32Function)
392	{
393	case VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG:
394	{
395	/* The quest requests a host message. */
396	Log(("svcCall: VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG\n"));
397
398	if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_GET_HOST_MSG)
399	{
400	rc = VERR_INVALID_PARAMETER;
401	}
402	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* msg */
403	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT /* formats */
404	)
405	{
406	rc = VERR_INVALID_PARAMETER;
407	}
408	else
409	{
410	/* Atomically verify the client's state. */
411	if (vboxSvcClipboardLock ())
412	{
413	bool fMessageReturned = vboxSvcClipboardReturnMsg (pClient, paParms);
414
415	if (fMessageReturned)
416	{
417	/* Just return to the caller. */
418	pClient->fAsync = false;
419	}
420	else
421	{
422	/* No event available at the time. Process asynchronously. */
423	fAsynchronousProcessing = true;
424
425	pClient->fAsync = true;
426	pClient->async.callHandle = callHandle;
427	pClient->async.paParms = paParms;
428
429	Log(("svcCall: async.\n"));
430	}
431
432	vboxSvcClipboardUnlock ();
433	}
434	else
435	{
436	rc = VERR_NOT_SUPPORTED;
437	}
438	}
439	} break;
440
441	case VBOX_SHARED_CLIPBOARD_FN_FORMATS:
442	{
443	/* The guest reports that some formats are available. */
444	Log(("svcCall: VBOX_SHARED_CLIPBOARD_FN_FORMATS\n"));
445
446	if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_FORMATS)
447	{
448	rc = VERR_INVALID_PARAMETER;
449	}
450	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* formats */
451	)
452	{
453	rc = VERR_INVALID_PARAMETER;
454	}
455	else
456	{
457	uint32_t u32Formats;
458
459	rc = VBoxHGCMParmUInt32Get (&paParms[0], &u32Formats);
460
461	if (RT_SUCCESS (rc))
462	{
463	if ( vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
464	&& vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
465	{
466	rc = VERR_NOT_SUPPORTED;
467	break;
468	}
469
470	if (g_pfnExtension)
471	{
472	VBOXCLIPBOARDEXTPARMS parms;
473
474	parms.u32Format = u32Formats;
475
476	g_pfnExtension (g_pvExtension, VBOX_CLIPBOARD_EXT_FN_FORMAT_ANNOUNCE, &parms, sizeof (parms));
477	}
478	else
479	{
480	vboxClipboardFormatAnnounce (pClient, u32Formats);
481	}
482	}
483	}
484	} break;
485
486	case VBOX_SHARED_CLIPBOARD_FN_READ_DATA:
487	{
488	/* The guest wants to read data in the given format. */
489	Log(("svcCall: VBOX_SHARED_CLIPBOARD_FN_READ_DATA\n"));
490
491	if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA)
492	{
493	rc = VERR_INVALID_PARAMETER;
494	}
495	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* format */
496	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_PTR /* ptr */
497	\|\| paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* size */
498	)
499	{
500	rc = VERR_INVALID_PARAMETER;
501	}
502	else
503	{
504	uint32_t u32Format;
505	void *pv;
506	uint32_t cb;
507
508	rc = VBoxHGCMParmUInt32Get (&paParms[0], &u32Format);
509
510	if (RT_SUCCESS (rc))
511	{
512	rc = VBoxHGCMParmPtrGet (&paParms[1], &pv, &cb);
513
514	if (RT_SUCCESS (rc))
515	{
516	if ( vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST
517	&& vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
518	{
519	rc = VERR_NOT_SUPPORTED;
520	break;
521	}
522
523	uint32_t cbActual = 0;
524
525	if (g_pfnExtension)
526	{
527	VBOXCLIPBOARDEXTPARMS parms;
528
529	parms.u32Format = u32Format;
530	parms.u.pvData = pv;
531	parms.cbData = cb;
532
533	g_fReadingData = true;
534	rc = g_pfnExtension (g_pvExtension, VBOX_CLIPBOARD_EXT_FN_DATA_READ, &parms, sizeof (parms));
535	LogFlow(("DATA: g_fDelayedAnnouncement = %d, g_u32DelayedFormats = 0x%x\n", g_fDelayedAnnouncement, g_u32DelayedFormats));
536	if (g_fDelayedAnnouncement)
537	{
538	vboxSvcClipboardReportMsg (g_pClient, VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS, g_u32DelayedFormats);
539	g_fDelayedAnnouncement = false;
540	g_u32DelayedFormats = 0;
541	}
542	g_fReadingData = false;
543
544	if (RT_SUCCESS (rc))
545	{
546	cbActual = parms.cbData;
547	}
548	}
549	else
550	{
551	/* Release any other pending read, as we only
552	* support one pending read at one time. */
553	vboxSvcClipboardCompleteReadData(pClient, VERR_NO_DATA, 0);
554	rc = vboxClipboardReadData (pClient, u32Format, pv, cb, &cbActual);
555	}
556
557	/* Remember our read request until it is completed.
558	* See the protocol description above for more
559	* information. */
560	if (rc == VINF_HGCM_ASYNC_EXECUTE)
561	{
562	if (vboxSvcClipboardLock())
563	{
564	pClient->asyncRead.callHandle = callHandle;
565	pClient->asyncRead.paParms = paParms;
566	pClient->fReadPending = true;
567	fAsynchronousProcessing = true;
568	vboxSvcClipboardUnlock();
569	}
570	else
571	rc = VERR_NOT_SUPPORTED;
572	}
573	else if (RT_SUCCESS (rc))
574	{
575	VBoxHGCMParmUInt32Set (&paParms[2], cbActual);
576	}
577	}
578	}
579	}
580	} break;
581
582	case VBOX_SHARED_CLIPBOARD_FN_WRITE_DATA:
583	{
584	/* The guest writes the requested data. */
585	Log(("svcCall: VBOX_SHARED_CLIPBOARD_FN_WRITE_DATA\n"));
586
587	if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DATA)
588	{
589	rc = VERR_INVALID_PARAMETER;
590	}
591	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* format */
592	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_PTR /* ptr */
593	)
594	{
595	rc = VERR_INVALID_PARAMETER;
596	}
597	else
598	{
599	void *pv;
600	uint32_t cb;
601	uint32_t u32Format;
602
603	rc = VBoxHGCMParmUInt32Get (&paParms[0], &u32Format);
604
605	if (RT_SUCCESS (rc))
606	{
607	rc = VBoxHGCMParmPtrGet (&paParms[1], &pv, &cb);
608
609	if (RT_SUCCESS (rc))
610	{
611	if ( vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
612	&& vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
613	{
614	rc = VERR_NOT_SUPPORTED;
615	break;
616	}
617
618	if (g_pfnExtension)
619	{
620	VBOXCLIPBOARDEXTPARMS parms;
621
622	parms.u32Format = u32Format;
623	parms.u.pvData = pv;
624	parms.cbData = cb;
625
626	g_pfnExtension (g_pvExtension, VBOX_CLIPBOARD_EXT_FN_DATA_WRITE, &parms, sizeof (parms));
627	}
628	else
629	{
630	vboxClipboardWriteData (pClient, pv, cb, u32Format);
631	}
632	}
633	}
634	}
635	} break;
636
637	default:
638	{
639	rc = VERR_NOT_IMPLEMENTED;
640	}
641	}
642
643	LogFlow(("svcCall: rc = %Rrc\n", rc));
644
645	if (!fAsynchronousProcessing)
646	{
647	g_pHelpers->pfnCallComplete (callHandle, rc);
648	}
649	}
650
651	/** If the client in the guest is waiting for a read operation to complete
652	* then complete it, otherwise return. See the protocol description in the
653	* shared clipboard module description. */
654	void vboxSvcClipboardCompleteReadData(VBOXCLIPBOARDCLIENTDATA *pClient, int rc, uint32_t cbActual)
655	{
656	VBOXHGCMCALLHANDLE callHandle = NULL;
657	VBOXHGCMSVCPARM *paParms = NULL;
658	bool fReadPending = false;
659	if (vboxSvcClipboardLock()) /* if not can we do anything useful? */
660	{
661	callHandle = pClient->asyncRead.callHandle;
662	paParms = pClient->asyncRead.paParms;
663	fReadPending = pClient->fReadPending;
664	pClient->fReadPending = false;
665	vboxSvcClipboardUnlock();
666	}
667	if (fReadPending)
668	{
669	VBoxHGCMParmUInt32Set (&paParms[2], cbActual);
670	g_pHelpers->pfnCallComplete (callHandle, rc);
671	}
672	}
673
674	/*
675	* We differentiate between a function handler for the guest and one for the host.
676	*/
677	static DECLCALLBACK(int) svcHostCall (void *,
678	uint32_t u32Function,
679	uint32_t cParms,
680	VBOXHGCMSVCPARM paParms[])
681	{
682	int rc = VINF_SUCCESS;
683
684	Log(("svcHostCall: fn = %d, cParms = %d, pparms = %d\n",
685	u32Function, cParms, paParms));
686
687	switch (u32Function)
688	{
689	case VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE:
690	{
691	Log(("svcCall: VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE\n"));
692
693	if (cParms != 1)
694	{
695	rc = VERR_INVALID_PARAMETER;
696	}
697	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* mode */
698	)
699	{
700	rc = VERR_INVALID_PARAMETER;
701	}
702	else
703	{
704	uint32_t u32Mode = VBOX_SHARED_CLIPBOARD_MODE_OFF;
705
706	rc = VBoxHGCMParmUInt32Get (&paParms[0], &u32Mode);
707
708	/* The setter takes care of invalid values. */
709	vboxSvcClipboardModeSet (u32Mode);
710	}
711	} break;
712
713	default:
714	break;
715	}
716
717	LogFlow(("svcHostCall: rc = %Rrc\n", rc));
718	return rc;
719	}
720
721	/** This structure corresponds to the original layout of the
722	* VBOXCLIPBOARDCLIENTDATA structure. As the structure was saved as a whole
723	* when saving state, we need to remember it forever in order to preserve
724	* compatibility.
725	* @todo the first person who needs to make an incompatible change to the
726	* saved state should switch to saving individual data members. So far,
727	* there are only three we care about anyway! */
728	typedef struct _CLIPSAVEDSTATEDATA
729	{
730	struct _CLIPSAVEDSTATEDATA *pNext;
731	struct _CLIPSAVEDSTATEDATA *pPrev;
732
733	VBOXCLIPBOARDCONTEXT *pCtx;
734
735	uint32_t u32ClientID;
736
737	bool fAsync: 1; /* Guest is waiting for a message. */
738
739	bool fMsgQuit: 1;
740	bool fMsgReadData: 1;
741	bool fMsgFormats: 1;
742
743	struct {
744	VBOXHGCMCALLHANDLE callHandle;
745	VBOXHGCMSVCPARM *paParms;
746	} async;
747
748	struct {
749	void *pv;
750	uint32_t cb;
751	uint32_t u32Format;
752	} data;
753
754	uint32_t u32AvailableFormats;
755	uint32_t u32RequestedFormat;
756
757	} CLIPSAVEDSTATEDATA;
758
759	static DECLCALLBACK(int) svcSaveState(void , uint32_t u32ClientID, void pvClient, PSSMHANDLE pSSM)
760	{
761	/* If there are any pending requests, they must be completed here. Since
762	* the service is single threaded, there could be only requests
763	* which the service itself has postponed.
764	*
765	* HGCM knows that the state is being saved and that the pfnComplete
766	* calls are just clean ups. These requests are saved by the VMMDev.
767	*
768	* When the state will be restored, these requests will be reissued
769	* by VMMDev. The service therefore must save state as if there were no
770	* pending request.
771	*/
772	Log(("svcSaveState: u32ClientID = %d\n", u32ClientID));
773
774	VBOXCLIPBOARDCLIENTDATA pClient = (VBOXCLIPBOARDCLIENTDATA )pvClient;
775
776	CLIPSAVEDSTATEDATA savedState = { 0 };
777	/* Save client structure length & contents */
778	int rc = SSMR3PutU32(pSSM, sizeof(savedState));
779	AssertRCReturn(rc, rc);
780
781	savedState.u32ClientID = pClient->u32ClientID;
782	savedState.fMsgQuit = pClient->fMsgQuit;
783	savedState.fMsgReadData = pClient->fMsgReadData;
784	savedState.fMsgFormats = pClient->fMsgFormats;
785	savedState.u32RequestedFormat = pClient->u32RequestedFormat;
786	rc = SSMR3PutMem(pSSM, &savedState, sizeof(savedState));
787	AssertRCReturn(rc, rc);
788
789	if (pClient->fAsync)
790	{
791	g_pHelpers->pfnCallComplete (pClient->async.callHandle, VINF_SUCCESS /* error code is not important here. */);
792	pClient->fAsync = false;
793	}
794
795	vboxSvcClipboardCompleteReadData(pClient, VINF_SUCCESS, 0);
796
797	return VINF_SUCCESS;
798	}
799
800	static DECLCALLBACK(int) svcLoadState(void , uint32_t u32ClientID, void pvClient, PSSMHANDLE pSSM)
801	{
802	Log(("svcLoadState: u32ClientID = %d\n", u32ClientID));
803
804	VBOXCLIPBOARDCLIENTDATA pClient = (VBOXCLIPBOARDCLIENTDATA )pvClient;
805
806	/* Existing client can not be in async state yet. */
807	Assert(!pClient->fAsync);
808
809	/* Restore the client data. */
810	uint32_t len;
811	int rc = SSMR3GetU32(pSSM, &len);
812	AssertRCReturn(rc, rc);
813
814	if (len != sizeof(CLIPSAVEDSTATEDATA))
815	{
816	Log(("Client data size mismatch: expected %d, got %d\n", sizeof (CLIPSAVEDSTATEDATA), len));
817	return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
818	}
819
820	CLIPSAVEDSTATEDATA savedState;
821	rc = SSMR3GetMem(pSSM, &savedState, sizeof(savedState));
822	AssertRCReturn(rc, rc);
823
824	/* Verify the loaded clients data and update the pClient. */
825	if (pClient->u32ClientID != savedState.u32ClientID)
826	{
827	Log(("Client ID mismatch: expected %d, got %d\n", pClient->u32ClientID, savedState.u32ClientID));
828	return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
829	}
830
831	pClient->fMsgQuit = savedState.fMsgQuit;
832	pClient->fMsgReadData = savedState.fMsgReadData;
833	pClient->fMsgFormats = savedState.fMsgFormats;
834	pClient->u32RequestedFormat = savedState.u32RequestedFormat;
835
836	/* Actual host data are to be reported to guest (SYNC). */
837	vboxClipboardSync (pClient);
838
839	return VINF_SUCCESS;
840	}
841
842	static DECLCALLBACK(int) extCallback (uint32_t u32Function, uint32_t u32Format, void *pvData, uint32_t cbData)
843	{
844	if (g_pClient != NULL)
845	{
846	switch (u32Function)
847	{
848	case VBOX_CLIPBOARD_EXT_FN_FORMAT_ANNOUNCE:
849	{
850	LogFlow(("ANNOUNCE: g_fReadingData = %d\n", g_fReadingData));
851	if (g_fReadingData)
852	{
853	g_fDelayedAnnouncement = true;
854	g_u32DelayedFormats = u32Format;
855	}
856	else
857	{
858	vboxSvcClipboardReportMsg (g_pClient, VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS, u32Format);
859	}
860	} break;
861
862	case VBOX_CLIPBOARD_EXT_FN_DATA_READ:
863	{
864	vboxSvcClipboardReportMsg (g_pClient, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, u32Format);
865	} break;
866
867	default:
868	return VERR_NOT_SUPPORTED;
869	}
870	}
871
872	return VINF_SUCCESS;
873	}
874
875	static DECLCALLBACK(int) svcRegisterExtension(void , PFNHGCMSVCEXT pfnExtension, void pvExtension)
876	{
877	LogFlowFunc(("pfnExtension = %p\n", pfnExtension));
878
879	VBOXCLIPBOARDEXTPARMS parms;
880
881	if (pfnExtension)
882	{
883	/* Install extension. */
884	g_pfnExtension = pfnExtension;
885	g_pvExtension = pvExtension;
886
887	parms.u.pfnCallback = extCallback;
888	g_pfnExtension (g_pvExtension, VBOX_CLIPBOARD_EXT_FN_SET_CALLBACK, &parms, sizeof (parms));
889	}
890	else
891	{
892	if (g_pfnExtension)
893	{
894	parms.u.pfnCallback = NULL;
895	g_pfnExtension (g_pvExtension, VBOX_CLIPBOARD_EXT_FN_SET_CALLBACK, &parms, sizeof (parms));
896	}
897
898	/* Uninstall extension. */
899	g_pfnExtension = NULL;
900	g_pvExtension = NULL;
901	}
902
903	return VINF_SUCCESS;
904	}
905
906	extern "C" DECLCALLBACK(DECLEXPORT(int)) VBoxHGCMSvcLoad (VBOXHGCMSVCFNTABLE *ptable)
907	{
908	int rc = VINF_SUCCESS;
909
910	LogFlowFunc(("ptable = %p\n", ptable));
911
912	if (!ptable)
913	{
914	rc = VERR_INVALID_PARAMETER;
915	}
916	else
917	{
918	Log(("VBoxHGCMSvcLoad: ptable->cbSize = %d, ptable->u32Version = 0x%08X\n", ptable->cbSize, ptable->u32Version));
919
920	if ( ptable->cbSize != sizeof (VBOXHGCMSVCFNTABLE)
921	\|\| ptable->u32Version != VBOX_HGCM_SVC_VERSION)
922	{
923	rc = VERR_INVALID_PARAMETER;
924	}
925	else
926	{
927	g_pHelpers = ptable->pHelpers;
928
929	ptable->cbClient = sizeof (VBOXCLIPBOARDCLIENTDATA);
930
931	ptable->pfnUnload = svcUnload;
932	ptable->pfnConnect = svcConnect;
933	ptable->pfnDisconnect = svcDisconnect;
934	ptable->pfnCall = svcCall;
935	ptable->pfnHostCall = svcHostCall;
936	ptable->pfnSaveState = svcSaveState;
937	ptable->pfnLoadState = svcLoadState;
938	ptable->pfnRegisterExtension = svcRegisterExtension;
939	ptable->pvService = NULL;
940
941	/* Service specific initialization. */
942	rc = svcInit ();
943	}
944	}
945
946	return rc;
947	}

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

source: vbox/trunk/src/VBox/HostServices/SharedClipboard/service.cpp@ 19948

Download in other formats: