VBoxSharedClipboardSvc-internal.h@ 100374

Last change on this file since 100374 was 100374, checked in by vboxsync, 17 months ago
Shared Clipboard: Initialize the host-backend specific transfer provider callbacks in the SHCLTRANSFERCALLBACKS::pfnOnCreated() callbacks. bugref:9437
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 20.2 KB

Line
1	/* $Id: VBoxSharedClipboardSvc-internal.h 100374 2023-07-05 08:36:57Z 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	PFNHGCMSVCEXT pfnExtension;
269	/** Opaque pointer to extension-provided data. Don't touch. */
270	void *pvExtension;
271	/** The HGCM client ID currently assigned to this service extension.
272	* At the moment only one HGCM client can be assigned per extension. */
273	uint32_t uClientID;
274	/** Whether the host service is reading clipboard data currently. */
275	bool fReadingData;
276	/** Whether the service extension has sent the clipboard formats while
277	* the the host service is reading clipboard data from it. */
278	bool fDelayedAnnouncement;
279	/** The actual clipboard formats announced while the host service
280	* is reading clipboard data from the extension. */
281	uint32_t fDelayedFormats;
282	} SHCLEXTSTATE, *PSHCLEXTSTATE;
283
284	extern SHCLEXTSTATE g_ExtState;
285
286	void shClSvcMsgQueueReset(PSHCLCLIENT pClient);
287	PSHCLCLIENTMSG shClSvcMsgAlloc(PSHCLCLIENT pClient, uint32_t uMsg, uint32_t cParms);
288	void shClSvcMsgFree(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg);
289	void shClSvcMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend);
290	int shClSvcMsgAddAndWakeupClient(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg);
291
292	int shClSvcClientInit(PSHCLCLIENT pClient, uint32_t uClientID);
293	void shClSvcClientDestroy(PSHCLCLIENT pClient);
294	void shClSvcClientLock(PSHCLCLIENT pClient);
295	void shClSvcClientUnlock(PSHCLCLIENT pClient);
296	void shClSvcClientReset(PSHCLCLIENT pClient);
297
298	int shClSvcClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID);
299	int shClSvcClientStateDestroy(PSHCLCLIENTSTATE pClientState);
300	void shclSvcClientStateReset(PSHCLCLIENTSTATE pClientState);
301
302	int shClSvcClientWakeup(PSHCLCLIENT pClient);
303
304	/** @name Service functions, accessible by the backends.
305	* Locking is between the (host) service thread and the platform-dependent (window) thread.
306	* @{
307	*/
308	int ShClSvcReadDataFromGuestAsync(PSHCLCLIENT pClient, SHCLFORMATS fFormats, PSHCLEVENT *ppEvent);
309	int ShClSvcReadDataFromGuest(PSHCLCLIENT pClient, SHCLFORMAT uFmt, void *ppv, uint32_t pcb);
310	int ShClSvcGuestDataSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, SHCLFORMAT uFormat, void *pvData, uint32_t cbData);
311	int ShClSvcHostReportFormats(PSHCLCLIENT pClient, SHCLFORMATS fFormats);
312	PSHCLBACKEND ShClSvcGetBackend(void);
313	uint32_t ShClSvcGetMode(void);
314	bool ShClSvcGetHeadless(void);
315	bool ShClSvcLock(void);
316	void ShClSvcUnlock(void);
317
318	/**
319	* Checks if the backend is active (@c true), or if VRDE is in control of
320	* the host side.
321	*/
322	DECLINLINE(bool) ShClSvcIsBackendActive(void)
323	{
324	return g_ExtState.pfnExtension == NULL;
325	}
326	/** @} */
327
328	/** @name Platform-dependent implementations for the Shared Clipboard host service ("backends"),
329	* called only by the host service.
330	* @{
331	*/
332	/**
333	* Structure for keeping Shared Clipboard backend instance data.
334	*/
335	typedef struct SHCLBACKEND
336	{
337	/** Callback table to use.
338	* Some callbacks might be optional and therefore NULL -- see the table for more details. */
339	SHCLCALLBACKS Callbacks;
340	} SHCLBACKEND;
341	/** Pointer to a Shared Clipboard backend. */
342	typedef SHCLBACKEND *PSHCLBACKEND;
343
344	/**
345	* Called on initialization.
346	*
347	* @param pBackend Shared Clipboard backend to initialize.
348	* @param pTable The HGCM service call and parameter table. Mainly for
349	* adjusting the limits.
350	*/
351	int ShClBackendInit(PSHCLBACKEND pBackend, VBOXHGCMSVCFNTABLE *pTable);
352
353	/**
354	* Called on destruction.
355	*
356	* @param pBackend Shared Clipboard backend to destroy.
357	*/
358	void ShClBackendDestroy(PSHCLBACKEND pBackend);
359
360	/**
361	* Called when a new HGCM client connects.
362	*
363	* @param pBackend Shared Clipboard backend to set callbacks for.
364	* @param pCallbacks Backend callbacks to use.
365	* When NULL is specified, the backend's default callbacks are being used.
366	*/
367	void ShClBackendSetCallbacks(PSHCLBACKEND pBackend, PSHCLCALLBACKS pCallbacks);
368
369	/**
370	* Called when a new HGCM client connects.
371	*
372	* @returns VBox status code.
373	* @param pBackend Shared Clipboard backend to connect to.
374	* @param pClient Shared Clipboard client context.
375	* @param fHeadless Whether this is a headless connection or not.
376	*/
377	int ShClBackendConnect(PSHCLBACKEND pBackend, PSHCLCLIENT pClient, bool fHeadless);
378
379	/**
380	* Called when a HGCM client disconnects.
381	*
382	* @returns VBox status code.
383	* @param pBackend Shared Clipboard backend to disconnect from.
384	* @param pClient Shared Clipboard client context.
385	*/
386	int ShClBackendDisconnect(PSHCLBACKEND pBackend, PSHCLCLIENT pClient);
387
388	/**
389	* Called when the guest reports available clipboard formats to the host OS.
390	*
391	* @returns VBox status code.
392	* @param pBackend Shared Clipboard backend to announce formats to.
393	* @param pClient Shared Clipboard client context.
394	* @param fFormats The announced formats from the guest,
395	* VBOX_SHCL_FMT_XXX.
396	*/
397	int ShClBackendReportFormats(PSHCLBACKEND pBackend, PSHCLCLIENT pClient, SHCLFORMATS fFormats);
398
399	/**
400	* Called when the guest wants to read host clipboard data.
401	*
402	* @returns VBox status code.
403	* @param pBackend Shared Clipboard backend to read data from.
404	* @param pClient Shared Clipboard client context.
405	* @param pCmdCtx Shared Clipboard command context.
406	* @param uFormat Clipboard format to read.
407	* @param pvData Where to return the read clipboard data.
408	* @param cbData Size (in bytes) of buffer where to return the clipboard data.
409	* @param pcbActual Where to return the amount of bytes read.
410	*
411	* @todo Document: Can return VINF_HGCM_ASYNC_EXECUTE to defer returning read
412	* data
413	*/
414	int ShClBackendReadData(PSHCLBACKEND pBackend, PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, SHCLFORMAT uFormat,
415	void pvData, uint32_t cbData, uint32_t pcbActual);
416
417	/**
418	* Called when the guest writes clipboard data to the host.
419	*
420	* @returns VBox status code.
421	* @param pBackend Shared Clipboard backend to write data to.
422	* @param pClient Shared Clipboard client context.
423	* @param pCmdCtx Shared Clipboard command context.
424	* @param uFormat Clipboard format to write.
425	* @param pvData Clipboard data to write.
426	* @param cbData Size (in bytes) of buffer clipboard data to write.
427	*/
428	int ShClBackendWriteData(PSHCLBACKEND pBackend, PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, SHCLFORMAT uFormat, void *pvData, uint32_t cbData);
429
430	/**
431	* Called when synchronization of the clipboard contents of the host clipboard with the guest is needed.
432	*
433	* @returns VBox status code.
434	* @param pBackend Shared Clipboard backend to synchronize.
435	* @param pClient Shared Clipboard client context.
436	*/
437	int ShClBackendSync(PSHCLBACKEND pBackend, PSHCLCLIENT pClient);
438	/** @} */
439
440	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
441	/** @name Host implementations for Shared Clipboard transfers.
442	* @{
443	*/
444	/**
445	* Called before a transfer gets destroyed.
446	*
447	* @returns VBox status code.
448	* @param pBackend Shared Clipboard backend to use.
449	* @param pClient Shared Clipboard client context.
450	* @param pTransfer Shared Clipboard transfer to destroy.
451	*/
452	int ShClBackendTransferDestroy(PSHCLBACKEND pBackend, PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer);
453	/**
454	* Called after a transfer status got processed.
455	*
456	* @returns VBox status code.
457	* @param pBackend Shared Clipboard backend to use.
458	* @param pClient Shared Clipboard client context.
459	* @param pTransfer Shared Clipboard transfer to process status for.
460	* @param enmSource Transfer source which issues the reply.
461	* @param enmStatus Transfer status.
462	* @param rcStatus Status code (IPRT-style). Depends on \a enmStatus set.
463	*/
464	int ShClBackendTransferHandleStatusReply(PSHCLBACKEND pBackend, PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer, SHCLSOURCE enmSource, SHCLTRANSFERSTATUS enmStatus, int rcStatus);
465	/** @} */
466	#endif
467
468	#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
469	/** @name Internal Shared Clipboard transfer host service functions.
470	* @{
471	*/
472	int shClSvcTransferHandler(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE callHandle, uint32_t u32Function,
473	uint32_t cParms, VBOXHGCMSVCPARM paParms[], uint64_t tsArrival);
474	int shClSvcTransferHostHandler(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
475	/** @} */
476
477	/** @name Shared Clipboard transfer interface implementations for guest -> host transfers.
478	* @{
479	*/
480	DECLCALLBACK(int) shClSvcTransferIfaceGHRootListRead(PSHCLTXPROVIDERCTX pCtx);
481	DECLCALLBACK(int) shClSvcTransferIfaceGHListOpen(PSHCLTXPROVIDERCTX pCtx, PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList);
482	DECLCALLBACK(int) shClSvcTransferIfaceGHListClose(PSHCLTXPROVIDERCTX pCtx, SHCLLISTHANDLE hList);
483	DECLCALLBACK(int) shClSvcTransferIfaceGHListHdrRead(PSHCLTXPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr);
484	DECLCALLBACK(int) shClSvcTransferIfaceGHListEntryRead(PSHCLTXPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry);
485	DECLCALLBACK(int) shClSvcTransferIfaceGHObjOpen(PSHCLTXPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms, PSHCLOBJHANDLE phObj);
486	DECLCALLBACK(int) shClSvcTransferIfaceGHObjClose(PSHCLTXPROVIDERCTX pCtx, SHCLOBJHANDLE hObj);
487	DECLCALLBACK(int) shClSvcTransferIfaceGHObjRead(PSHCLTXPROVIDERCTX pCtx, SHCLOBJHANDLE hObj, void pvData, uint32_t cbData, uint32_t fFlags, uint32_t pcbRead);
488	/** @} */
489
490	/** @name Shared Clipboard transfer interface implementations for host -> guest transfers.
491	* @{
492	*/
493	DECLCALLBACK(int) shClSvcTransferIfaceHGListHdrWrite(PSHCLTXPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr);
494	DECLCALLBACK(int) shClSvcTransferIfaceHGListEntryWrite(PSHCLTXPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry);
495	DECLCALLBACK(int) shClSvcTransferIfaceHGObjWrite(PSHCLTXPROVIDERCTX pCtx, SHCLOBJHANDLE hObj, void pvData, uint32_t cbData, uint32_t fFlags, uint32_t pcbWritten);
496	/** @} */
497
498	/** @name Shared Clipboard transfer callbacks for the host service.
499	* @{
500	*/
501	DECLCALLBACK(void) VBoxSvcClipboardTransferPrepareCallback(PSHCLTXPROVIDERCTX pCtx);
502	DECLCALLBACK(void) VBoxSvcClipboardDataHeaderCompleteCallback(PSHCLTXPROVIDERCTX pCtx);
503	DECLCALLBACK(void) VBoxSvcClipboardDataCompleteCallback(PSHCLTXPROVIDERCTX pCtx);
504	DECLCALLBACK(void) VBoxSvcClipboardTransferCompleteCallback(PSHCLTXPROVIDERCTX pCtx, int rc);
505	DECLCALLBACK(void) VBoxSvcClipboardTransferCanceledCallback(PSHCLTXPROVIDERCTX pCtx);
506	DECLCALLBACK(void) VBoxSvcClipboardTransferErrorCallback(PSHCLTXPROVIDERCTX pCtx, int rc);
507	/** @} */
508	#endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
509
510	/* Host unit testing interface */
511	#ifdef UNIT_TEST
512	uint32_t TestClipSvcGetMode(void);
513	#endif
514
515	#endif /* !VBOX_INCLUDED_SRC_SharedClipboard_VBoxSharedClipboardSvc_internal_h */
516

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

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

Download in other formats: