VBoxSharedClipboardSvc-internal.h@ 100646

Last change on this file since 100646 was 100646, checked in by vboxsync, 17 months ago
Shared Clipboard: Renaming (ShClSvcHostReportFormats -> ShClSvcReportFormats), to match the other functions. bugref:9437
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 20.3 KB

Line
1	/* $Id: VBoxSharedClipboardSvc-internal.h 100646 2023-07-19 08:49:56Z vboxsync $ */
2	/** @file
3	* Shared Clipboard Service - Internal header.
4	*/
5
6	/*
7	* Copyright (C) 2006-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28	#ifndef VBOX_INCLUDED_SRC_SharedClipboard_VBoxSharedClipboardSvc_internal_h
29	#define VBOX_INCLUDED_SRC_SharedClipboard_VBoxSharedClipboardSvc_internal_h
30	#ifndef RT_WITHOUT_PRAGMA_ONCE
31	# pragma once
32	#endif
33
34	#include <algorithm>
35	#include <list>
36	#include <map>
37
38	#include <iprt/cpp/list.h> /* For RTCList. */
39	#include <iprt/list.h>
40	#include <iprt/semaphore.h>
41
42	#include <VBox/hgcmsvc.h>
43	#include <VBox/log.h>
44
45	#include <VBox/HostServices/Service.h>
46	#include <VBox/GuestHost/SharedClipboard.h>
47	#include <VBox/GuestHost/SharedClipboard-transfers.h>
48
49	using namespace HGCM;
50
51	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
52	struct SHCLCLIENTSTATE;
53	#endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
54
55	/**
56	* A queued message for the guest.
57	*/
58	typedef struct _SHCLCLIENTMSG
59	{
60	/** The queue list entry. */
61	RTLISTNODE ListEntry;
62	/** Stored message ID (VBOX_SHCL_HOST_MSG_XXX). */
63	uint32_t idMsg;
64	/** Context ID. */
65	uint64_t idCtx;
66	/** Number of stored parameters in aParms. */
67	uint32_t cParms;
68	/** HGCM parameters. */
69	RT_FLEXIBLE_ARRAY_EXTENSION
70	VBOXHGCMSVCPARM aParms[RT_FLEXIBLE_ARRAY];
71	} SHCLCLIENTMSG;
72	/** Pointer to a queue message for the guest. */
73	typedef SHCLCLIENTMSG *PSHCLCLIENTMSG;
74
75	typedef struct SHCLCLIENTTRANSFERSTATE
76	{
77	/** Directory of the transfer to start. */
78	SHCLTRANSFERDIR enmTransferDir;
79	} SHCLCLIENTTRANSFERSTATE, *PSHCLCLIENTTRANSFERSTATE;
80
81	/**
82	* Structure for holding a single POD (plain old data) transfer.
83	*
84	* This mostly is plain text, but also can be stuff like bitmap (BMP) or other binary data.
85	*/
86	typedef struct SHCLCLIENTPODSTATE
87	{
88	/** POD transfer direction. */
89	SHCLTRANSFERDIR enmDir;
90	/** Format of the data to be read / written. */
91	SHCLFORMAT uFormat;
92	/** How much data (in bytes) to read/write for the current operation. */
93	uint64_t cbToReadWriteTotal;
94	/** How much data (in bytes) already has been read/written for the current operation. */
95	uint64_t cbReadWritten;
96	/** Timestamp (in ms) of Last read/write operation. */
97	uint64_t tsLastReadWrittenMs;
98	} SHCLCLIENTPODSTATE, *PSHCLCLIENTPODSTATE;
99
100	/** @name SHCLCLIENTSTATE_FLAGS_XXX
101	* @note Part of saved state!
102	* @{ */
103	/** No Shared Clipboard client flags defined. */
104	#define SHCLCLIENTSTATE_FLAGS_NONE 0
105	/** Client has a guest read operation active. Currently unused. */
106	#define SHCLCLIENTSTATE_FLAGS_READ_ACTIVE RT_BIT(0)
107	/** Client has a guest write operation active. Currently unused. */
108	#define SHCLCLIENTSTATE_FLAGS_WRITE_ACTIVE RT_BIT(1)
109	/** @} */
110
111	/**
112	* Structure needed to support backwards compatbility for old(er) Guest Additions (< 6.1),
113	* which did not know the context ID concept then.
114	*/
115	typedef struct SHCLCLIENTLEGACYCID
116	{
117	/** List node. */
118	RTLISTNODE Node;
119	/** The actual context ID. */
120	uint64_t uCID;
121	/** Not used yet; useful to have it in the saved state though. */
122	uint32_t enmType;
123	/** @todo Add an union here as soon as we utilize \a enmType. */
124	SHCLFORMAT uFormat;
125	} SHCLCLIENTLEGACYCID;
126	/** Pointer to a SHCLCLIENTLEGACYCID struct. */
127	typedef SHCLCLIENTLEGACYCID *PSHCLCLIENTLEGACYCID;
128
129	/**
130	* Structure for keeping legacy state, required for keeping backwards compatibility
131	* to old(er) Guest Additions.
132	*/
133	typedef struct SHCLCLIENTLEGACYSTATE
134	{
135	/** List of context IDs (of type SHCLCLIENTLEGACYCID) for older Guest Additions which (< 6.1)
136	* which did not know the concept of context IDs. */
137	RTLISTANCHOR lstCID;
138	/** Number of context IDs currently in \a lstCID. */
139	uint16_t cCID;
140	} SHCLCLIENTLEGACYSTATE;
141
142	/**
143	* Structure for keeping generic client state data within the Shared Clipboard host service.
144	* This structure needs to be serializable by SSM (must be a POD type).
145	*/
146	typedef struct SHCLCLIENTSTATE
147	{
148	struct SHCLCLIENTSTATE *pNext;
149	struct SHCLCLIENTSTATE *pPrev;
150
151	/** Backend-dependent opaque context structure.
152	* This contains data only known to a certain backend implementation.
153	* Optional and can be NULL. */
154	SHCLCONTEXT *pCtx;
155	/** The client's HGCM ID. Not related to the session ID below! */
156	uint32_t uClientID;
157	/** The client's session ID. */
158	SHCLSESSIONID uSessionID;
159	/** Guest feature flags, VBOX_SHCL_GF_0_XXX. */
160	uint64_t fGuestFeatures0;
161	/** Guest feature flags, VBOX_SHCL_GF_1_XXX. */
162	uint64_t fGuestFeatures1;
163	/** Chunk size to use for data transfers. */
164	uint32_t cbChunkSize;
165	/** Where the transfer sources its data from. */
166	SHCLSOURCE enmSource;
167	/** Client state flags of type SHCLCLIENTSTATE_FLAGS_. */
168	uint32_t fFlags;
169	/** POD (plain old data) state. */
170	SHCLCLIENTPODSTATE POD;
171	/** The client's transfers state. */
172	SHCLCLIENTTRANSFERSTATE Transfers;
173	} SHCLCLIENTSTATE, *PSHCLCLIENTSTATE;
174
175	typedef struct _SHCLCLIENTCMDCTX
176	{
177	uint64_t uContextID;
178	} SHCLCLIENTCMDCTX, *PSHCLCLIENTCMDCTX;
179
180	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
181	/**
182	* Structure for keeping transfer-related data per HGCM client.
183	*/
184	typedef struct _SHCLIENTTRANSFERS
185	{
186	/** Transfer context. */
187	SHCLTRANSFERCTX Ctx;
188	/** Backends-specific transfers callbacks to use. */
189	SHCLTRANSFERCALLBACKS Callbacks;
190	/** Backends-specific transfers provider to use. */
191	SHCLTXPROVIDER Provider;
192	} SHCLIENTTRANSFERS, *PSHCLIENTTRANSFERS;
193	#endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
194
195	/** Prototypes for the Shared Clipboard backend. */
196	struct SHCLBACKEND;
197	typedef SHCLBACKEND *PSHCLBACKEND;
198
199	/**
200	* Structure for keeping data per (connected) HGCM client.
201	*/
202	typedef struct _SHCLCLIENT
203	{
204	/** Pointer to associated backend, if any.
205	* Might be NULL if not being used. */
206	PSHCLBACKEND pBackend;
207	/** General client state data. */
208	SHCLCLIENTSTATE State;
209	/** The critical section protecting the queue, event source and whatnot. */
210	RTCRITSECT CritSect;
211	/** The client's message queue (SHCLCLIENTMSG). */
212	RTLISTANCHOR MsgQueue;
213	/** Number of allocated messages (updated atomically, not under critsect). */
214	uint32_t volatile cMsgAllocated;
215	/** Legacy cruft we have to keep to support old(er) Guest Additions. */
216	SHCLCLIENTLEGACYSTATE Legacy;
217	/** The client's own event source.
218	* Needed for events which are not bound to a specific transfer. */
219	SHCLEVENTSOURCE EventSrc;
220	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
221	SHCLIENTTRANSFERS Transfers;
222	#endif
223	/** Structure for keeping the client's pending (deferred return) state.
224	* A client is in a deferred state when it asks for the next HGCM message,
225	* but the service can't provide it yet. That way a client will block (on the guest side, does not return)
226	* until the service can complete the call. */
227	struct
228	{
229	/** The client's HGCM call handle. Needed for completing a deferred call. */
230	VBOXHGCMCALLHANDLE hHandle;
231	/** Message type (function number) to use when completing the deferred call.
232	* A non-0 value means the client is in pending mode. */
233	uint32_t uType;
234	/** Parameter count to use when completing the deferred call. */
235	uint32_t cParms;
236	/** Parameters to use when completing the deferred call. */
237	PVBOXHGCMSVCPARM paParms;
238	} Pending;
239	} SHCLCLIENT, *PSHCLCLIENT;
240
241	/**
242	* Structure for keeping a single event source map entry.
243	* Currently empty.
244	*/
245	typedef struct _SHCLEVENTSOURCEMAPENTRY
246	{
247	} SHCLEVENTSOURCEMAPENTRY;
248
249	/** Map holding information about connected HGCM clients. Key is the (unique) HGCM client ID.
250	* The value is a weak pointer to PSHCLCLIENT, which is owned by HGCM. */
251	typedef std::map<uint32_t, PSHCLCLIENT> ClipboardClientMap;
252
253	/** Map holding information about event sources. Key is the (unique) event source ID. */
254	typedef std::map<SHCLEVENTSOURCEID, SHCLEVENTSOURCEMAPENTRY> ClipboardEventSourceMap;
255
256	/** Simple queue (list) which holds deferred (waiting) clients. */
257	typedef std::list<uint32_t> ClipboardClientQueue;
258
259	/**
260	* Structure for keeping the Shared Clipboard service extension state.
261	*
262	* A service extension is optional, and can be installed by a host component
263	* to communicate with the Shared Clipboard host service.
264	*/
265	typedef struct _SHCLEXTSTATE
266	{
267	/** Pointer to the actual service extension handle.
268	*
269	* Must return VERR_NOT_SUPPORTED if the extension didn't handle the requested function.
270	* This will invoke the regular backend then.
271	*/
272	PFNHGCMSVCEXT pfnExtension;
273	/** Opaque pointer to extension-provided data. Don't touch. */
274	void *pvExtension;
275	/** The HGCM client ID currently assigned to this service extension.
276	* At the moment only one HGCM client can be assigned per extension. */
277	uint32_t uClientID;
278	/** Whether the host service is reading clipboard data currently. */
279	bool fReadingData;
280	/** Whether the service extension has sent the clipboard formats while
281	* the the host service is reading clipboard data from it. */
282	bool fDelayedAnnouncement;
283	/** The actual clipboard formats announced while the host service
284	* is reading clipboard data from the extension. */
285	uint32_t fDelayedFormats;
286	} SHCLEXTSTATE, *PSHCLEXTSTATE;
287
288	extern SHCLEXTSTATE g_ExtState;
289
290	void shClSvcMsgQueueReset(PSHCLCLIENT pClient);
291	PSHCLCLIENTMSG shClSvcMsgAlloc(PSHCLCLIENT pClient, uint32_t uMsg, uint32_t cParms);
292	void shClSvcMsgFree(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg);
293	void shClSvcMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend);
294	int shClSvcMsgAddAndWakeupClient(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg);
295
296	int shClSvcClientInit(PSHCLCLIENT pClient, uint32_t uClientID);
297	void shClSvcClientDestroy(PSHCLCLIENT pClient);
298	void shClSvcClientLock(PSHCLCLIENT pClient);
299	void shClSvcClientUnlock(PSHCLCLIENT pClient);
300	void shClSvcClientReset(PSHCLCLIENT pClient);
301
302	int shClSvcClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID);
303	int shClSvcClientStateDestroy(PSHCLCLIENTSTATE pClientState);
304	void shclSvcClientStateReset(PSHCLCLIENTSTATE pClientState);
305
306	int shClSvcClientWakeup(PSHCLCLIENT pClient);
307
308	/** @name Service functions, accessible by the backends.
309	* Locking is between the (host) service thread and the platform-dependent (window) thread.
310	* @{
311	*/
312	int ShClSvcReadDataFromGuestAsync(PSHCLCLIENT pClient, SHCLFORMATS fFormats, PSHCLEVENT *ppEvent);
313	int ShClSvcReadDataFromGuest(PSHCLCLIENT pClient, SHCLFORMAT uFmt, void *ppv, uint32_t pcb);
314	int ShClSvcGuestDataSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, SHCLFORMAT uFormat, void *pvData, uint32_t cbData);
315	int ShClSvcReportFormats(PSHCLCLIENT pClient, SHCLFORMATS fFormats);
316	PSHCLBACKEND ShClSvcGetBackend(void);
317	uint32_t ShClSvcGetMode(void);
318	bool ShClSvcGetHeadless(void);
319	bool ShClSvcLock(void);
320	void ShClSvcUnlock(void);
321
322	/**
323	* Checks if the backend is active (@c true), or if VRDE is in control of
324	* the host side.
325	*/
326	DECLINLINE(bool) ShClSvcIsBackendActive(void)
327	{
328	return g_ExtState.pfnExtension == NULL;
329	}
330	/** @} */
331
332	/** @name Platform-dependent implementations for the Shared Clipboard host service ("backends"),
333	* called only by the host service.
334	* @{
335	*/
336	/**
337	* Structure for keeping Shared Clipboard backend instance data.
338	*/
339	typedef struct SHCLBACKEND
340	{
341	/** Callback table to use.
342	* Some callbacks might be optional and therefore NULL -- see the table for more details. */
343	SHCLCALLBACKS Callbacks;
344	} SHCLBACKEND;
345	/** Pointer to a Shared Clipboard backend. */
346	typedef SHCLBACKEND *PSHCLBACKEND;
347
348	/**
349	* Called on initialization.
350	*
351	* @param pBackend Shared Clipboard backend to initialize.
352	* @param pTable The HGCM service call and parameter table. Mainly for
353	* adjusting the limits.
354	*/
355	int ShClBackendInit(PSHCLBACKEND pBackend, VBOXHGCMSVCFNTABLE *pTable);
356
357	/**
358	* Called on destruction.
359	*
360	* @param pBackend Shared Clipboard backend to destroy.
361	*/
362	void ShClBackendDestroy(PSHCLBACKEND pBackend);
363
364	/**
365	* Called when a new HGCM client connects.
366	*
367	* @param pBackend Shared Clipboard backend to set callbacks for.
368	* @param pCallbacks Backend callbacks to use.
369	* When NULL is specified, the backend's default callbacks are being used.
370	*/
371	void ShClBackendSetCallbacks(PSHCLBACKEND pBackend, PSHCLCALLBACKS pCallbacks);
372
373	/**
374	* Called when a new HGCM client connects.
375	*
376	* @returns VBox status code.
377	* @param pBackend Shared Clipboard backend to connect to.
378	* @param pClient Shared Clipboard client context.
379	* @param fHeadless Whether this is a headless connection or not.
380	*/
381	int ShClBackendConnect(PSHCLBACKEND pBackend, PSHCLCLIENT pClient, bool fHeadless);
382
383	/**
384	* Called when a HGCM client disconnects.
385	*
386	* @returns VBox status code.
387	* @param pBackend Shared Clipboard backend to disconnect from.
388	* @param pClient Shared Clipboard client context.
389	*/
390	int ShClBackendDisconnect(PSHCLBACKEND pBackend, PSHCLCLIENT pClient);
391
392	/**
393	* Called when the guest reports available clipboard formats to the host OS.
394	*
395	* @returns VBox status code.
396	* @param pBackend Shared Clipboard backend to announce formats to.
397	* @param pClient Shared Clipboard client context.
398	* @param fFormats The announced formats from the guest,
399	* VBOX_SHCL_FMT_XXX.
400	*/
401	int ShClBackendReportFormats(PSHCLBACKEND pBackend, PSHCLCLIENT pClient, SHCLFORMATS fFormats);
402
403	/**
404	* Called when the guest wants to read host clipboard data.
405	*
406	* @returns VBox status code.
407	* @param pBackend Shared Clipboard backend to read data from.
408	* @param pClient Shared Clipboard client context.
409	* @param pCmdCtx Shared Clipboard command context.
410	* @param uFormat Clipboard format to read.
411	* @param pvData Where to return the read clipboard data.
412	* @param cbData Size (in bytes) of buffer where to return the clipboard data.
413	* @param pcbActual Where to return the amount of bytes read.
414	*
415	* @todo Document: Can return VINF_HGCM_ASYNC_EXECUTE to defer returning read
416	* data
417	*/
418	int ShClBackendReadData(PSHCLBACKEND pBackend, PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, SHCLFORMAT uFormat,
419	void pvData, uint32_t cbData, uint32_t pcbActual);
420
421	/**
422	* Called when the guest writes clipboard data to the host.
423	*
424	* @returns VBox status code.
425	* @param pBackend Shared Clipboard backend to write data to.
426	* @param pClient Shared Clipboard client context.
427	* @param pCmdCtx Shared Clipboard command context.
428	* @param uFormat Clipboard format to write.
429	* @param pvData Clipboard data to write.
430	* @param cbData Size (in bytes) of buffer clipboard data to write.
431	*/
432	int ShClBackendWriteData(PSHCLBACKEND pBackend, PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, SHCLFORMAT uFormat, void *pvData, uint32_t cbData);
433
434	/**
435	* Called when synchronization of the clipboard contents of the host clipboard with the guest is needed.
436	*
437	* @returns VBox status code.
438	* @param pBackend Shared Clipboard backend to synchronize.
439	* @param pClient Shared Clipboard client context.
440	*/
441	int ShClBackendSync(PSHCLBACKEND pBackend, PSHCLCLIENT pClient);
442	/** @} */
443
444	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
445	/** @name Host implementations for Shared Clipboard transfers.
446	* @{
447	*/
448	/**
449	* Called before a transfer gets destroyed.
450	*
451	* @returns VBox status code.
452	* @param pBackend Shared Clipboard backend to use.
453	* @param pClient Shared Clipboard client context.
454	* @param pTransfer Shared Clipboard transfer to destroy.
455	*/
456	int ShClBackendTransferDestroy(PSHCLBACKEND pBackend, PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer);
457	/**
458	* Called after a transfer status got processed.
459	*
460	* @returns VBox status code.
461	* @param pBackend Shared Clipboard backend to use.
462	* @param pClient Shared Clipboard client context.
463	* @param pTransfer Shared Clipboard transfer to process status for.
464	* @param enmSource Transfer source which issues the reply.
465	* @param enmStatus Transfer status.
466	* @param rcStatus Status code (IPRT-style). Depends on \a enmStatus set.
467	*/
468	int ShClBackendTransferHandleStatusReply(PSHCLBACKEND pBackend, PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer, SHCLSOURCE enmSource, SHCLTRANSFERSTATUS enmStatus, int rcStatus);
469	/** @} */
470	#endif
471
472	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
473	/** @name Internal Shared Clipboard transfer host service functions.
474	* @{
475	*/
476	int shClSvcTransferHandler(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE callHandle, uint32_t u32Function,
477	uint32_t cParms, VBOXHGCMSVCPARM paParms[], uint64_t tsArrival);
478	int shClSvcTransferHostHandler(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
479	/** @} */
480
481	/** @name Shared Clipboard transfer interface implementations for guest -> host transfers.
482	* @{
483	*/
484	DECLCALLBACK(int) shClSvcTransferIfaceGHRootListRead(PSHCLTXPROVIDERCTX pCtx);
485	DECLCALLBACK(int) shClSvcTransferIfaceGHListOpen(PSHCLTXPROVIDERCTX pCtx, PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList);
486	DECLCALLBACK(int) shClSvcTransferIfaceGHListClose(PSHCLTXPROVIDERCTX pCtx, SHCLLISTHANDLE hList);
487	DECLCALLBACK(int) shClSvcTransferIfaceGHListHdrRead(PSHCLTXPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr);
488	DECLCALLBACK(int) shClSvcTransferIfaceGHListEntryRead(PSHCLTXPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry);
489	DECLCALLBACK(int) shClSvcTransferIfaceGHObjOpen(PSHCLTXPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms, PSHCLOBJHANDLE phObj);
490	DECLCALLBACK(int) shClSvcTransferIfaceGHObjClose(PSHCLTXPROVIDERCTX pCtx, SHCLOBJHANDLE hObj);
491	DECLCALLBACK(int) shClSvcTransferIfaceGHObjRead(PSHCLTXPROVIDERCTX pCtx, SHCLOBJHANDLE hObj, void pvData, uint32_t cbData, uint32_t fFlags, uint32_t pcbRead);
492	/** @} */
493
494	/** @name Shared Clipboard transfer interface implementations for host -> guest transfers.
495	* @{
496	*/
497	DECLCALLBACK(int) shClSvcTransferIfaceHGListHdrWrite(PSHCLTXPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr);
498	DECLCALLBACK(int) shClSvcTransferIfaceHGListEntryWrite(PSHCLTXPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry);
499	DECLCALLBACK(int) shClSvcTransferIfaceHGObjWrite(PSHCLTXPROVIDERCTX pCtx, SHCLOBJHANDLE hObj, void pvData, uint32_t cbData, uint32_t fFlags, uint32_t pcbWritten);
500	/** @} */
501
502	/** @name Shared Clipboard transfer callbacks for the host service.
503	* @{
504	*/
505	DECLCALLBACK(void) VBoxSvcClipboardTransferPrepareCallback(PSHCLTXPROVIDERCTX pCtx);
506	DECLCALLBACK(void) VBoxSvcClipboardDataHeaderCompleteCallback(PSHCLTXPROVIDERCTX pCtx);
507	DECLCALLBACK(void) VBoxSvcClipboardDataCompleteCallback(PSHCLTXPROVIDERCTX pCtx);
508	DECLCALLBACK(void) VBoxSvcClipboardTransferCompleteCallback(PSHCLTXPROVIDERCTX pCtx, int rc);
509	DECLCALLBACK(void) VBoxSvcClipboardTransferCanceledCallback(PSHCLTXPROVIDERCTX pCtx);
510	DECLCALLBACK(void) VBoxSvcClipboardTransferErrorCallback(PSHCLTXPROVIDERCTX pCtx, int rc);
511	/** @} */
512	#endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
513
514	/* Host unit testing interface */
515	#ifdef UNIT_TEST
516	uint32_t TestClipSvcGetMode(void);
517	#endif
518
519	#endif /* !VBOX_INCLUDED_SRC_SharedClipboard_VBoxSharedClipboardSvc_internal_h */
520

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

source: vbox/trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-internal.h@ 100646

Download in other formats: