VBoxGuestLib.h@ 82525

Last change on this file since 82525 was 82525, checked in by vboxsync, 5 years ago
SharedClipboardSvc,Vbgl: Looked at the connect and feature exchange stuff. Decided to make the connect one always fail, that way the beta and rc additions should not try make use of any of the new features and we should be free to do whatever we like. Need to circle back and drop the _61B parameter count variants later. bugref:9437
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 55.6 KB

Line
1	/** @file
2	* VBoxGuestLib - VirtualBox Guest Additions Library.
3	*/
4
5	/*
6	* Copyright (C) 2006-2019 Oracle Corporation
7	*
8	* Permission is hereby granted, free of charge, to any person
9	* obtaining a copy of this software and associated documentation
10	* files (the "Software"), to deal in the Software without
11	* restriction, including without limitation the rights to use,
12	* copy, modify, merge, publish, distribute, sublicense, and/or sell
13	* copies of the Software, and to permit persons to whom the
14	* Software is furnished to do so, subject to the following
15	* conditions:
16	*
17	* The above copyright notice and this permission notice shall be
18	* included in all copies or substantial portions of the Software.
19	*
20	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
21	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
22	* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
23	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
24	* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
25	* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
26	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
27	* OTHER DEALINGS IN THE SOFTWARE.
28	*/
29
30	#ifndef VBOX_INCLUDED_VBoxGuestLib_h
31	#define VBOX_INCLUDED_VBoxGuestLib_h
32	#ifndef RT_WITHOUT_PRAGMA_ONCE
33	# pragma once
34	#endif
35
36	#include <VBox/types.h>
37	#include <VBox/VMMDev.h>
38	#include <VBox/VBoxGuestCoreTypes.h>
39	# ifdef VBOX_WITH_DRAG_AND_DROP
40	# include <VBox/GuestHost/DragAndDropDefs.h>
41	# endif
42	# ifdef VBOX_WITH_SHARED_CLIPBOARD
43	# include <VBox/GuestHost/SharedClipboard.h>
44	# ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
45	# include <VBox/GuestHost/SharedClipboard-transfers.h>
46	# endif
47	# endif /* VBOX_WITH_SHARED_CLIPBOARD */
48
49	/** @defgroup grp_vboxguest_lib VirtualBox Guest Additions Library
50	* @ingroup grp_vboxguest
51	* @{
52	*/
53
54	/** @page pg_guest_lib VirtualBox Guest Library
55	*
56	* This is a library for abstracting the additions driver interface. There are
57	* multiple versions of the library depending on the context. The main
58	* distinction is between kernel and user mode where the interfaces are very
59	* different.
60	*
61	*
62	* @section sec_guest_lib_ring0 Ring-0
63	*
64	* In ring-0 there are two version:
65	* - VBOX_LIB_VBGL_R0_BASE / VBoxGuestR0LibBase for the VBoxGuest main driver,
66	* who is responsible for managing the VMMDev virtual hardware.
67	* - VBOX_LIB_VBGL_R0 / VBoxGuestR0Lib for other (client) guest drivers.
68	*
69	*
70	* The library source code and the header have a define VBGL_VBOXGUEST, which is
71	* defined for VBoxGuest and undefined for other drivers. Drivers must choose
72	* right library in their makefiles and set VBGL_VBOXGUEST accordingly.
73	*
74	* The libraries consists of:
75	* - common code to be used by both VBoxGuest and other drivers;
76	* - VBoxGuest specific code;
77	* - code for other drivers which communicate with VBoxGuest via an IOCTL.
78	*
79	*
80	* @section sec_guest_lib_ring3 Ring-3
81	*
82	* There are more variants of the library here:
83	* - VBOX_LIB_VBGL_R3 / VBoxGuestR3Lib for programs.
84	* - VBOX_LIB_VBGL_R3_XFREE86 / VBoxGuestR3LibXFree86 for old style XFree
85	* drivers which uses special loader and or symbol resolving strategy.
86	* - VBOX_LIB_VBGL_R3_SHARED / VBoxGuestR3LibShared for shared objects / DLLs /
87	* Dylibs.
88	*
89	*/
90
91	RT_C_DECLS_BEGIN
92
93	/** HGCM client ID.
94	* @todo Promote to VBox/types.h */
95	typedef uint32_t HGCMCLIENTID;
96
97
98	/** @defgroup grp_vboxguest_lib_r0 Ring-0 interface.
99	* @{
100	*/
101	#ifdef IN_RING0
102	/** @def DECLR0VBGL
103	* Declare a VBGL ring-0 API with the right calling convention and visibilitiy.
104	* @param type Return type. */
105	# ifdef RT_OS_DARWIN /** @todo probably apply to all, but don't want a forest fire on our hands right now. */
106	# define DECLR0VBGL(type) DECLHIDDEN(type) VBOXCALL
107	# else
108	# define DECLR0VBGL(type) type VBOXCALL
109	# endif
110	# define DECLVBGL(type) DECLR0VBGL(type)
111
112
113	/**
114	* The library initialization function to be used by the main VBoxGuest driver.
115	*
116	* @return VBox status code.
117	*/
118	DECLR0VBGL(int) VbglR0InitPrimary(RTIOPORT portVMMDev, VMMDevMemory pVMMDevMemory, uint32_t pfFeatures);
119
120	/**
121	* The library termination function to be used by the main VBoxGuest driver.
122	*
123	* @author bird (2017-08-23)
124	*/
125	DECLR0VBGL(void) VbglR0TerminatePrimary(void);
126
127	/**
128	* The library initialization function to be used by all drivers
129	* other than the main VBoxGuest system driver.
130	*
131	* @return VBox status code.
132	*/
133	DECLR0VBGL(int) VbglR0InitClient(void);
134
135	/**
136	* The library termination function.
137	*/
138	DECLR0VBGL(void) VbglR0TerminateClient(void);
139
140	/**
141	* Query the host feature mask.
142	*
143	* @returns VBox status code.
144	* @param pfHostFeatures Where to return the host feature mask,
145	* VMMDEV_HVF_XXX.
146	* @note Client only. May fail we're unable to connect VBoxGuest.
147	*/
148	DECLR0VBGL(int) VbglR0QueryHostFeatures(uint32_t *pfHostFeatures);
149
150
151	/** @name The IDC Client Interface
152	* @{
153	*/
154
155	/**
156	* Inter-Driver Communication Handle.
157	*/
158	typedef union VBGLIDCHANDLE
159	{
160	/** Padding for opaque usage.
161	* Must be greater or equal in size than the private struct. */
162	void *apvPadding[4];
163	#ifdef VBGLIDCHANDLEPRIVATE_DECLARED
164	/** The private view. */
165	struct VBGLIDCHANDLEPRIVATE s;
166	#endif
167	} VBGLIDCHANDLE;
168	/** Pointer to a handle. */
169	typedef VBGLIDCHANDLE *PVBGLIDCHANDLE;
170
171	DECLR0VBGL(int) VbglR0IdcOpen(PVBGLIDCHANDLE pHandle, uint32_t uReqVersion, uint32_t uMinVersion,
172	uint32_t puSessionVersion, uint32_t puDriverVersion, uint32_t *puDriverRevision);
173	struct VBGLREQHDR;
174	DECLR0VBGL(int) VbglR0IdcCallRaw(PVBGLIDCHANDLE pHandle, uintptr_t uReq, struct VBGLREQHDR *pReqHdr, uint32_t cbReq);
175	DECLR0VBGL(int) VbglR0IdcCall(PVBGLIDCHANDLE pHandle, uintptr_t uReq, struct VBGLREQHDR *pReqHdr, uint32_t cbReq);
176	DECLR0VBGL(int) VbglR0IdcClose(PVBGLIDCHANDLE pHandle);
177
178	/** @} */
179
180
181	/** @name Generic request functions.
182	* @{
183	*/
184
185	/**
186	* Allocate memory for generic request and initialize the request header.
187	*
188	* @returns VBox status code.
189	* @param ppReq Where to return the pointer to the allocated memory.
190	* @param cbReq Size of memory block required for the request.
191	* @param enmReqType the generic request type.
192	*/
193	# if defined(VBOX_INCLUDED_VMMDev_h) \|\| defined(DOXYGEN_RUNNING)
194	DECLR0VBGL(int) VbglR0GRAlloc(struct VMMDevRequestHeader **ppReq, size_t cbReq, VMMDevRequestType enmReqType);
195	# else
196	DECLR0VBGL(int) VbglR0GRAlloc(struct VMMDevRequestHeader **ppReq, size_t cbReq, int32_t enmReqType);
197	# endif
198
199	/**
200	* Perform the generic request.
201	*
202	* @param pReq pointer the request structure.
203	*
204	* @return VBox status code.
205	*/
206	DECLR0VBGL(int) VbglR0GRPerform(struct VMMDevRequestHeader *pReq);
207
208	/**
209	* Free the generic request memory.
210	*
211	* @param pReq pointer the request structure.
212	*
213	* @return VBox status code.
214	*/
215	DECLR0VBGL(void) VbglR0GRFree(struct VMMDevRequestHeader *pReq);
216
217	/**
218	* Verify the generic request header.
219	*
220	* @param pReq pointer the request header structure.
221	* @param cbReq size of the request memory block. It should be equal to the request size
222	* for fixed size requests. It can be greater than the request size for
223	* variable size requests.
224	*
225	* @return VBox status code.
226	*/
227	DECLR0VBGL(int) VbglGR0Verify(const struct VMMDevRequestHeader *pReq, size_t cbReq);
228
229	/** @} */
230
231	# ifdef VBOX_WITH_HGCM
232	struct VBGLIOCHGCMCALL;
233	struct VBGLIOCIDCHGCMFASTCALL;
234
235	# ifdef VBGL_VBOXGUEST
236
237	/**
238	* Callback function called from HGCM helpers when a wait for request
239	* completion IRQ is required.
240	*
241	* @returns VINF_SUCCESS, VERR_INTERRUPT or VERR_TIMEOUT.
242	* @param pvData VBoxGuest pointer to be passed to callback.
243	* @param u32Data VBoxGuest 32 bit value to be passed to callback.
244	*/
245	typedef DECLCALLBACK(int) FNVBGLHGCMCALLBACK(VMMDevHGCMRequestHeader pHeader, void pvData, uint32_t u32Data);
246	/** Pointer to a FNVBGLHGCMCALLBACK. */
247	typedef FNVBGLHGCMCALLBACK *PFNVBGLHGCMCALLBACK;
248
249	/**
250	* Perform a connect request.
251	*
252	* That is locate required service and obtain a client identifier for future
253	* access.
254	*
255	* @note This function can NOT handle cancelled requests!
256	*
257	* @param pLoc The service to connect to.
258	* @param fRequestor VMMDEV_REQUESTOR_XXX.
259	* @param pidClient Where to return the client ID on success.
260	* @param pfnAsyncCallback Required pointer to function that is calledwhen
261	* host returns VINF_HGCM_ASYNC_EXECUTE. VBoxGuest
262	* implements waiting for an IRQ in this function.
263	* @param pvAsyncData An arbitrary VBoxGuest pointer to be passed to callback.
264	* @param u32AsyncData An arbitrary VBoxGuest 32 bit value to be passed to callback.
265	*
266	* @return VBox status code.
267	*/
268	DECLR0VBGL(int) VbglR0HGCMInternalConnect(HGCMServiceLocation const pLoc, uint32_t fRequestor, HGCMCLIENTID pidClient,
269	PFNVBGLHGCMCALLBACK pfnAsyncCallback, void *pvAsyncData, uint32_t u32AsyncData);
270
271
272	/**
273	* Perform a disconnect request.
274	*
275	* That is tell the host that the client will not call the service anymore.
276	*
277	* @note This function can NOT handle cancelled requests!
278	*
279	* @param idClient The client ID to disconnect.
280	* @param fRequestor VMMDEV_REQUESTOR_XXX.
281	* @param pfnAsyncCallback Required pointer to function that is called when
282	* host returns VINF_HGCM_ASYNC_EXECUTE. VBoxGuest
283	* implements waiting for an IRQ in this function.
284	* @param pvAsyncData An arbitrary VBoxGuest pointer to be passed to callback.
285	* @param u32AsyncData An arbitrary VBoxGuest 32 bit value to be passed to
286	* callback.
287	*
288	* @return VBox status code.
289	*/
290
291	DECLR0VBGL(int) VbglR0HGCMInternalDisconnect(HGCMCLIENTID idClient, uint32_t fRequestor,
292	PFNVBGLHGCMCALLBACK pfnAsyncCallback, void *pvAsyncData, uint32_t u32AsyncData);
293
294	/** Call a HGCM service.
295	*
296	* @note This function can deal with cancelled requests.
297	*
298	* @param pCallInfo The request data.
299	* @param fFlags Flags, see VBGLR0_HGCMCALL_F_XXX.
300	* @param fRequestor VMMDEV_REQUESTOR_XXX.
301	* @param pfnAsyncCallback Required pointer to function that is called when
302	* host returns VINF_HGCM_ASYNC_EXECUTE. VBoxGuest
303	* implements waiting for an IRQ in this function.
304	* @param pvAsyncData An arbitrary VBoxGuest pointer to be passed to callback.
305	* @param u32AsyncData An arbitrary VBoxGuest 32 bit value to be passed to callback.
306	*
307	* @return VBox status code.
308	*/
309	DECLR0VBGL(int) VbglR0HGCMInternalCall(struct VBGLIOCHGCMCALL *pCallInfo, uint32_t cbCallInfo, uint32_t fFlags, uint32_t fRequestor,
310	PFNVBGLHGCMCALLBACK pfnAsyncCallback, void *pvAsyncData, uint32_t u32AsyncData);
311
312	/** Call a HGCM service. (32 bits packet structure in a 64 bits guest)
313	*
314	* @note This function can deal with cancelled requests.
315	*
316	* @param pCallInfo The request data.
317	* @param fFlags Flags, see VBGLR0_HGCMCALL_F_XXX.
318	* @param fRequestor VMMDEV_REQUESTOR_XXX.
319	* @param pfnAsyncCallback Required pointer to function that is called when
320	* host returns VINF_HGCM_ASYNC_EXECUTE. VBoxGuest
321	* implements waiting for an IRQ in this function.
322	* @param pvAsyncData An arbitrary VBoxGuest pointer to be passed to callback.
323	* @param u32AsyncData An arbitrary VBoxGuest 32 bit value to be passed to callback.
324	*
325	* @return VBox status code.
326	*/
327	DECLR0VBGL(int) VbglR0HGCMInternalCall32(struct VBGLIOCHGCMCALL *pCallInfo, uint32_t cbCallInfo, uint32_t fFlags, uint32_t fRequestor,
328	PFNVBGLHGCMCALLBACK pfnAsyncCallback, void *pvAsyncData, uint32_t u32AsyncData);
329
330	/** @name VbglR0HGCMInternalCall flags
331	* @{ */
332	/** User mode request.
333	* Indicates that only user mode addresses are permitted as parameters. */
334	#define VBGLR0_HGCMCALL_F_USER UINT32_C(0)
335	/** Kernel mode request.
336	* Indicates that kernel mode addresses are permitted as parameters. Whether or
337	* not user mode addresses are permitted is, unfortunately, OS specific. The
338	* following OSes allows user mode addresses: Windows, TODO.
339	*/
340	#define VBGLR0_HGCMCALL_F_KERNEL UINT32_C(1)
341	/** Mode mask. */
342	#define VBGLR0_HGCMCALL_F_MODE_MASK UINT32_C(1)
343	/** @} */
344
345	# else /* !VBGL_VBOXGUEST */
346
347	#ifndef VBGL_VBOXGUEST
348	/** @internal */
349	typedef struct VBGLHGCMHANDLEDATA
350	{
351	uint32_t fAllocated;
352	VBGLIDCHANDLE IdcHandle;
353	} VBGLHGCMHANDLEDATA;
354	#else
355	struct VBGLHGCMHANDLEDATA;
356	#endif
357
358	typedef struct VBGLHGCMHANDLEDATA *VBGLHGCMHANDLE;
359
360	/** @name HGCM functions
361	* @{
362	*/
363
364	/**
365	* Initializes HGCM in the R0 guest library. Must be called before any HGCM
366	* connections are made. Is called by VbglInitClient().
367	*
368	* @return VBox status code.
369	*/
370	DECLR0VBGL(int) VbglR0HGCMInit(void);
371
372	/**
373	* Terminates HGCM in the R0 guest library. Is called by VbglTerminate().
374	*
375	* @return VBox status code.
376	*/
377	DECLR0VBGL(int) VbglR0HGCMTerminate(void);
378
379	/**
380	* Connect to a service.
381	*
382	* @param pHandle Pointer to variable that will hold a handle to be used
383	* further in VbglHGCMCall and VbglHGCMClose.
384	* @param pszServiceName The service to connect to.
385	* @param pidClient Where to return the client ID for the connection.
386	*
387	* @return VBox status code.
388	*
389	* @todo consider baking the client Id into the handle.
390	*/
391	DECLR0VBGL(int) VbglR0HGCMConnect(VBGLHGCMHANDLE pHandle, const char pszServiceName, HGCMCLIENTID *pidClient);
392
393	/**
394	* Connect to a service.
395	*
396	* @param handle Handle of the connection.
397	* @param idClient The ID of the client connection.
398	*
399	* @return VBox status code.
400	*
401	* @todo consider baking the client Id into the handle.
402	*/
403	DECLR0VBGL(int) VbglR0HGCMDisconnect(VBGLHGCMHANDLE handle, HGCMCLIENTID idClient);
404
405	/**
406	* Call to a service, returning only the I/O control status code.
407	*
408	* @param handle Handle of the connection.
409	* @param pData Call request information structure, including function parameters.
410	* @param cbData Length in bytes of data.
411	*
412	* @return VBox status code.
413	*/
414	DECLR0VBGL(int) VbglR0HGCMCallRaw(VBGLHGCMHANDLE handle, struct VBGLIOCHGCMCALL *pData, uint32_t cbData);
415
416	/**
417	* Call to a service, returning the HGCM status code.
418	*
419	* @param handle Handle of the connection.
420	* @param pData Call request information structure, including function parameters.
421	* @param cbData Length in bytes of data.
422	*
423	* @return VBox status code. Either the I/O control status code if that failed,
424	* or the HGCM status code (pData->Hdr.rc).
425	*/
426	DECLR0VBGL(int) VbglR0HGCMCall(VBGLHGCMHANDLE handle, struct VBGLIOCHGCMCALL *pData, uint32_t cbData);
427
428	/**
429	* Call to a service with user-mode data received by the calling driver from the User-Mode process.
430	* The call must be done in the context of a calling process.
431	*
432	* @param handle Handle of the connection.
433	* @param pData Call request information structure, including function parameters.
434	* @param cbData Length in bytes of data.
435	*
436	* @return VBox status code.
437	*/
438	DECLR0VBGL(int) VbglR0HGCMCallUserDataRaw(VBGLHGCMHANDLE handle, struct VBGLIOCHGCMCALL *pData, uint32_t cbData);
439
440	/**
441	* Call to a service, w/o any repacking and buffer locking in VBoxGuest,
442	* returning the only request related status code (not HGCM).
443	*
444	* The driver only submits the request and waits for completion, nothing else.
445	*
446	* @param hHandle The connection handle.
447	* @param pCallReq The call request. Will be passed directly to the host.
448	* @param cbCallReq The size of the whole call request.
449	*
450	* @return VBox status code.
451	*
452	* @remarks The result of the HGCM call is found in
453	* @a pCallReq->HgcmCallReq.header.result on a successful return. The
454	* @a pCallReq->Hdr.rc and @a pCallReq->HgcmCallReq.header.header.rc
455	* fields are the same as the return value and can safely be ignored.
456	*/
457	DECLR0VBGL(int) VbglR0HGCMFastCall(VBGLHGCMHANDLE hHandle, struct VBGLIOCIDCHGCMFASTCALL *pCallReq, uint32_t cbCallReq);
458
459	/** @} */
460
461	/** @name Undocumented helpers for talking to the Chromium OpenGL Host Service
462	* @{ */
463	typedef VBGLHGCMHANDLE VBGLCRCTLHANDLE;
464	DECLR0VBGL(int) VbglR0CrCtlCreate(VBGLCRCTLHANDLE *phCtl);
465	DECLR0VBGL(int) VbglR0CrCtlDestroy(VBGLCRCTLHANDLE hCtl);
466	DECLR0VBGL(int) VbglR0CrCtlConConnect(VBGLCRCTLHANDLE hCtl, HGCMCLIENTID *pidClient);
467	DECLR0VBGL(int) VbglR0CrCtlConDisconnect(VBGLCRCTLHANDLE hCtl, HGCMCLIENTID idClient);
468	struct VBGLIOCHGCMCALL;
469	DECLR0VBGL(int) VbglR0CrCtlConCallRaw(VBGLCRCTLHANDLE hCtl, struct VBGLIOCHGCMCALL *pCallInfo, int cbCallInfo);
470	DECLR0VBGL(int) VbglR0CrCtlConCall(VBGLCRCTLHANDLE hCtl, struct VBGLIOCHGCMCALL *pCallInfo, int cbCallInfo);
471	DECLR0VBGL(int) VbglR0CrCtlConCallUserDataRaw(VBGLCRCTLHANDLE hCtl, struct VBGLIOCHGCMCALL *pCallInfo, int cbCallInfo);
472	/** @} */
473
474	# endif /* !VBGL_VBOXGUEST */
475
476	# endif /* VBOX_WITH_HGCM */
477
478
479	/**
480	* Initialize the heap.
481	*
482	* @returns VBox status code.
483	*/
484	DECLR0VBGL(int) VbglR0PhysHeapInit(void);
485
486	/**
487	* Shutdown the heap.
488	*/
489	DECLR0VBGL(void) VbglR0PhysHeapTerminate(void);
490
491	/**
492	* Allocate a memory block.
493	*
494	* @returns Virtual address of the allocated memory block.
495	* @param cbSize Size of block to be allocated.
496	*/
497	DECLR0VBGL(void *) VbglR0PhysHeapAlloc(uint32_t cbSize);
498
499	/**
500	* Get physical address of memory block pointed by the virtual address.
501	*
502	* @note WARNING!
503	* The function does not acquire the Heap mutex!
504	* When calling the function make sure that the pointer is a valid one and
505	* is not being deallocated. This function can NOT be used for verifying
506	* if the given pointer is a valid one allocated from the heap.
507	*
508	* @param pv Virtual address of memory block.
509	* @returns Physical address of the memory block.
510	*/
511	DECLR0VBGL(uint32_t) VbglR0PhysHeapGetPhysAddr(void *pv);
512
513	/**
514	* Free a memory block.
515	*
516	* @param pv Virtual address of memory block.
517	*/
518	DECLR0VBGL(void) VbglR0PhysHeapFree(void *pv);
519
520	DECLR0VBGL(int) VbglR0QueryVMMDevMemory(struct VMMDevMemory **ppVMMDevMemory);
521	DECLR0VBGL(bool) VbglR0CanUsePhysPageList(void);
522
523	# ifndef VBOX_GUEST
524	/** @name Mouse
525	* @{ */
526	DECLR0VBGL(int) VbglR0SetMouseNotifyCallback(PFNVBOXGUESTMOUSENOTIFY pfnNotify, void *pvUser);
527	DECLR0VBGL(int) VbglR0GetMouseStatus(uint32_t pfFeatures, uint32_t px, uint32_t *py);
528	DECLR0VBGL(int) VbglR0SetMouseStatus(uint32_t fFeatures);
529	/** @} */
530	# endif /* VBOX_GUEST */
531
532	#endif /* IN_RING0 */
533
534	/** @} */
535
536
537	/** @defgroup grp_vboxguest_lib_r3 Ring-3 interface.
538	* @{
539	*/
540	#ifdef IN_RING3
541
542	/** @def VBGLR3DECL
543	* Ring 3 VBGL declaration.
544	* @param type The return type of the function declaration.
545	*/
546	# define VBGLR3DECL(type) DECLHIDDEN(type) VBOXCALL
547
548	/** @name General-purpose functions
549	* @{ */
550	VBGLR3DECL(int) VbglR3Init(void);
551	VBGLR3DECL(int) VbglR3InitUser(void);
552	VBGLR3DECL(void) VbglR3Term(void);
553	# ifdef IPRT_INCLUDED_time_h
554	VBGLR3DECL(int) VbglR3GetHostTime(PRTTIMESPEC pTime);
555	# endif
556	VBGLR3DECL(int) VbglR3InterruptEventWaits(void);
557	VBGLR3DECL(int) VbglR3WriteLog(const char *pch, size_t cch);
558	VBGLR3DECL(int) VbglR3CtlFilterMask(uint32_t fOr, uint32_t fNot);
559	VBGLR3DECL(int) VbglR3Daemonize(bool fNoChDir, bool fNoClose, bool fRespawn, unsigned *pcRespawn);
560	VBGLR3DECL(int) VbglR3PidFile(const char *pszPath, PRTFILE phFile);
561	VBGLR3DECL(void) VbglR3ClosePidFile(const char *pszPath, RTFILE hFile);
562	VBGLR3DECL(int) VbglR3SetGuestCaps(uint32_t fOr, uint32_t fNot);
563	VBGLR3DECL(int) VbglR3AcquireGuestCaps(uint32_t fOr, uint32_t fNot, bool fConfig);
564	VBGLR3DECL(int) VbglR3WaitEvent(uint32_t fMask, uint32_t cMillies, uint32_t *pfEvents);
565
566	VBGLR3DECL(int) VbglR3ReportAdditionsStatus(VBoxGuestFacilityType Facility, VBoxGuestFacilityStatus StatusCurrent,
567	uint32_t fFlags);
568	VBGLR3DECL(int) VbglR3GetAdditionsVersion(char ppszVer, char ppszVerEx, char **ppszRev);
569	VBGLR3DECL(int) VbglR3GetAdditionsInstallationPath(char **ppszPath);
570	VBGLR3DECL(int) VbglR3GetSessionId(uint64_t *pu64IdSession);
571
572	/** @} */
573
574	# ifdef VBOX_WITH_SHARED_CLIPBOARD
575	/** @name Shared Clipboard
576	* @{ */
577
578	/**
579	* The context required for either retrieving or sending a HGCM shared clipboard
580	* commands from or to the host.
581	*
582	* @todo This struct could be handy if we want to implement a second
583	* communication channel, e.g. via TCP/IP. Use a union for the HGCM stuff then.
584	*/
585	typedef struct VBGLR3SHCLCMDCTX
586	{
587	/** HGCM client ID to use for communication.
588	* This is set by VbglR3ClipboardConnectEx(). */
589	uint32_t idClient;
590	/** This is @c false if both VBOX_SHCL_HF_0_CONTEXT_ID and
591	* VBOX_SHCL_GF_0_CONTEXT_ID are set, otherwise @c true and only the old
592	* protocol (< 6.1) should be used.
593	* This is set by VbglR3ClipboardConnectEx(). */
594	bool fUseLegacyProtocol;
595	/** Host feature flags (VBOX_SHCL_HF_XXX).
596	* This is set by VbglR3ClipboardConnectEx(). */
597	uint64_t fHostFeatures;
598	/** The guest feature flags reported to the host (VBOX_SHCL_GF_XXX).
599	* This is set by VbglR3ClipboardConnectEx(). */
600	uint64_t fGuestFeatures;
601	# ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
602	/** Default chunk size (in bytes).
603	* This is set by VbglR3ClipboardConnectEx(). */
604	uint32_t cbChunkSize;
605	/** Max chunk size (in bytes).
606	* This is set by VbglR3ClipboardConnectEx(). */
607	uint32_t cbMaxChunkSize;
608	# endif
609
610	/** The context ID - input or/and output depending on the operation. */
611	uint64_t idContext;
612	/** OUT: Number of parameters retrieved.
613	* This is set by ??. */
614	uint32_t cParmsRecived;
615
616	# ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
617	/** Callback table to use for all transfers. */
618	SHCLTRANSFERCALLBACKS Callbacks;
619	# endif
620	} VBGLR3SHCLCMDCTX;
621	/** Pointer to a shared clipboard context for Vbgl. */
622	typedef VBGLR3SHCLCMDCTX *PVBGLR3SHCLCMDCTX;
623
624	/**
625	* Enumeration specifying a Shared Clipboard event type.
626	*/
627	typedef enum _VBGLR3CLIPBOARDEVENTTYPE
628	{
629	/** No event needed / defined. */
630	VBGLR3CLIPBOARDEVENTTYPE_NONE = 0,
631	/** Host reports available clipboard formats to the guest. */
632	VBGLR3CLIPBOARDEVENTTYPE_REPORT_FORMATS,
633	/** Host wants to read Shared Clipboard data from the guest. */
634	VBGLR3CLIPBOARDEVENTTYPE_READ_DATA,
635	/** Terminates the Shared Clipboard service. */
636	VBGLR3CLIPBOARDEVENTTYPE_QUIT,
637	# ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
638	/** Reports a transfer status to the guest. */
639	VBGLR3CLIPBOARDEVENTTYPE_TRANSFER_STATUS,
640	# endif
641	/** Blow the type up to 32-bit. */
642	VBGLR3CLIPBOARDEVENTTYPE_32BIT_HACK = 0x7fffffff
643	} VBGLR3CLIPBOARDEVENTTYPE;
644
645	/**
646	* Structure for keeping a Shared Clipboard VbglR3 event.
647	*/
648	typedef struct _VBGLR3CLIPBOARDEVENT
649	{
650	/** The event type the union contains. */
651	VBGLR3CLIPBOARDEVENTTYPE enmType;
652	/** Command context bound to this event. */
653	VBGLR3SHCLCMDCTX cmdCtx;
654	union
655	{
656	/** Reports available formats from the host. */
657	SHCLFORMATDATA ReportedFormats;
658	/** Reports that data needs to be read from the guest. */
659	SHCLDATAREQ ReadData;
660	# ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
661	/** Reports a transfer status to the guest. */
662	struct
663	{
664	/** ID of the trnasfer. */
665	SHCLTRANSFERID uID;
666	/** Transfer direction. */
667	SHCLTRANSFERDIR enmDir;
668	/** Additional reproting information. */
669	SHCLTRANSFERREPORT Report;
670	} TransferStatus;
671	# endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
672	} u;
673	} VBGLR3CLIPBOARDEVENT, *PVBGLR3CLIPBOARDEVENT;
674	typedef const PVBGLR3CLIPBOARDEVENT CPVBGLR3CLIPBOARDEVENT;
675
676	/** @todo r=bird: I'm not sure it is appropriate for the VbglR3 to use types
677	* from VBox/GuestHost/SharedClipboard.h, doesn't seem clean to me. /
678
679	VBGLR3DECL(int) VbglR3ClipboardConnect(HGCMCLIENTID *pidClient);
680	VBGLR3DECL(int) VbglR3ClipboardDisconnect(HGCMCLIENTID idClient);
681	VBGLR3DECL(int) VbglR3ClipboardGetHostMsgOld(HGCMCLIENTID idClient, uint32_t pMsg, uint32_t pfFormats);
682	VBGLR3DECL(int) VbglR3ClipboardReadData(HGCMCLIENTID idClient, uint32_t fFormat, void pv, uint32_t cb, uint32_t pcb);
683	VBGLR3DECL(int) VbglR3ClipboardReadDataEx(PVBGLR3SHCLCMDCTX pCtx, PSHCLDATABLOCK pData, uint32_t *pcbRead);
684	VBGLR3DECL(int) VbglR3ClipboardWriteData(HGCMCLIENTID idClient, uint32_t fFormat, void *pv, uint32_t cb);
685	VBGLR3DECL(int) VbglR3ClipboardWriteDataEx(PVBGLR3SHCLCMDCTX pCtx, PSHCLDATABLOCK pData);
686	VBGLR3DECL(int) VbglR3ClipboardReportFormats(HGCMCLIENTID idClient, uint32_t fFormats);
687
688	VBGLR3DECL(int) VbglR3ClipboardConnectEx(PVBGLR3SHCLCMDCTX pCtx, uint64_t fGuestFeatures);
689	VBGLR3DECL(int) VbglR3ClipboardDisconnectEx(PVBGLR3SHCLCMDCTX pCtx);
690
691	VBGLR3DECL(int) VbglR3ClipboardReportFeatures(uint32_t idClient, uint64_t fGuestFeatures, uint64_t *pfHostFeatures);
692	VBGLR3DECL(int) VbglR3ClipboardQueryFeatures(uint32_t idClient, uint64_t *pfHostFeatures);
693	VBGLR3DECL(int) VbglR3ClipboardMsgPeekWait(PVBGLR3SHCLCMDCTX pCtx, uint32_t pidMsg, uint32_t pcParameters, uint64_t *pidRestoreCheck);
694	VBGLR3DECL(int) VbglR3ClipboardEventGetNext(uint32_t idMsg, uint32_t cParms, PVBGLR3SHCLCMDCTX pCtx, PVBGLR3CLIPBOARDEVENT pEvent);
695	VBGLR3DECL(void) VbglR3ClipboardEventFree(PVBGLR3CLIPBOARDEVENT pEvent);
696
697	VBGLR3DECL(int) VbglR3ClipboardWriteError(HGCMCLIENTID idClient, int rcErr);
698
699	# ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
700	VBGLR3DECL(int) VbglR3ClipboardEventGetNextEx(uint32_t idMsg, uint32_t cParms, PVBGLR3SHCLCMDCTX pCtx, PSHCLTRANSFERCTX pTransferCtx, PVBGLR3CLIPBOARDEVENT pEvent);
701
702	VBGLR3DECL(int) VbglR3ClipboardTransferStatusReply(PVBGLR3SHCLCMDCTX pCtx, PSHCLTRANSFER pTransfer, SHCLTRANSFERSTATUS uStatus);
703
704	VBGLR3DECL(int) VbglR3ClipboardRootListRead(PVBGLR3SHCLCMDCTX pCtx, PSHCLROOTLIST *ppRootList);
705
706	VBGLR3DECL(int) VbglR3ClipboardRootListHdrReadReq(PVBGLR3SHCLCMDCTX pCtx, uint32_t *pfRoots);
707	VBGLR3DECL(int) VbglR3ClipboardRootListHdrReadReply(PVBGLR3SHCLCMDCTX pCtx, PSHCLROOTLIST pRootList);
708	VBGLR3DECL(int) VbglR3ClipboardRootsWrite(PVBGLR3SHCLCMDCTX pCtx, PSHCLROOTLISTHDR pRoots);
709
710	VBGLR3DECL(int) VbglR3ClipboardListOpenSend(PVBGLR3SHCLCMDCTX pCtx, PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList);
711	VBGLR3DECL(int) VbglR3ClipboardListOpenRecv(PVBGLR3SHCLCMDCTX pCtx, PSHCLLISTOPENPARMS pOpenParms);
712	VBGLR3DECL(int) VbglR3ClipboardListOpenReply(PVBGLR3SHCLCMDCTX pCtx, int rcReply, SHCLLISTHANDLE hList);
713
714	VBGLR3DECL(int) VbglR3ClipboardListCloseSend(PVBGLR3SHCLCMDCTX pCtx, SHCLLISTHANDLE hList);
715	VBGLR3DECL(int) VbglR3ClipboardListCloseRecv(PVBGLR3SHCLCMDCTX pCtx, PSHCLLISTHANDLE phList);
716
717	VBGLR3DECL(int) VbglR3ClipboardListHdrWrite(PVBGLR3SHCLCMDCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr);
718	VBGLR3DECL(int) VbglR3ClipboardListEntryWrite(PVBGLR3SHCLCMDCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry);
719
720	VBGLR3DECL(int) VbglR3ClipboardObjOpenRecv(PVBGLR3SHCLCMDCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms);
721	VBGLR3DECL(int) VbglR3ClipboardObjOpenReply(PVBGLR3SHCLCMDCTX pCtx, int rcReply, SHCLOBJHANDLE hObj);
722	VBGLR3DECL(int) VbglR3ClipboardObjOpenSend(PVBGLR3SHCLCMDCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms,
723	PSHCLOBJHANDLE phObj);
724
725	VBGLR3DECL(int) VbglR3ClipboardObjCloseRecv(PVBGLR3SHCLCMDCTX pCtx, PSHCLOBJHANDLE phObj);
726	VBGLR3DECL(int) VbglR3ClipboardObjCloseReply(PVBGLR3SHCLCMDCTX pCtx, int rcReply, SHCLOBJHANDLE hObj);
727	VBGLR3DECL(int) VbglR3ClipboardObjCloseSend(PVBGLR3SHCLCMDCTX pCtx, SHCLOBJHANDLE hObj);
728
729	VBGLR3DECL(int) VbglR3ClipboardObjReadRecv(PVBGLR3SHCLCMDCTX pCtx, PSHCLOBJHANDLE phObj, uint32_t pcbToRead,
730	uint32_t *pfFlags);
731	VBGLR3DECL(int) VbglR3ClipboardObjReadSend(PVBGLR3SHCLCMDCTX pCtx, SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf,
732	uint32_t *pcbRead);
733	VBGLR3DECL(int) VbglR3ClipboardObjWriteSend(PVBGLR3SHCLCMDCTX pCtx, SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf,
734	uint32_t *pcbWritten);
735	# endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
736	/** @} */
737	# endif /* VBOX_WITH_SHARED_CLIPBOARD */
738
739	/** @name Seamless mode
740	* @{ */
741	VBGLR3DECL(int) VbglR3SeamlessSetCap(bool fState);
742	VBGLR3DECL(int) VbglR3SeamlessWaitEvent(VMMDevSeamlessMode *pMode);
743	VBGLR3DECL(int) VbglR3SeamlessSendRects(uint32_t cRects, PRTRECT pRects);
744	VBGLR3DECL(int) VbglR3SeamlessGetLastEvent(VMMDevSeamlessMode *pMode);
745
746	/** @} */
747
748	/** @name Mouse
749	* @{ */
750	VBGLR3DECL(int) VbglR3GetMouseStatus(uint32_t pfFeatures, uint32_t px, uint32_t *py);
751	VBGLR3DECL(int) VbglR3SetMouseStatus(uint32_t fFeatures);
752	/** @} */
753
754	/** @name Video
755	* @{ */
756	VBGLR3DECL(int) VbglR3VideoAccelEnable(bool fEnable);
757	VBGLR3DECL(int) VbglR3VideoAccelFlush(void);
758	VBGLR3DECL(int) VbglR3SetPointerShape(uint32_t fFlags, uint32_t xHot, uint32_t yHot, uint32_t cx, uint32_t cy,
759	const void *pvImg, size_t cbImg);
760	VBGLR3DECL(int) VbglR3SetPointerShapeReq(struct VMMDevReqMousePointer *pReq);
761	/** @} */
762
763	/** @name Display
764	* @{ */
765	/** The folder for the video mode hint unix domain socket on Unix-like guests.
766	* @note This can be safely changed as all users are rebuilt in lock-step. */
767	#define VBGLR3HOSTDISPSOCKETPATH "/tmp/.VBoxService"
768	/** The path to the video mode hint unix domain socket on Unix-like guests. */
769	#define VBGLR3HOSTDISPSOCKET VBGLR3VIDEOMODEHINTSOCKETPATH "/VideoModeHint"
770
771	/** The folder for saving video mode hints to between sessions. */
772	#define VBGLR3HOSTDISPSAVEDMODEPATH "/var/lib/VBoxGuestAdditions"
773	/** The path to the file for saving video mode hints to between sessions. */
774	#define VBGLR3HOSTDISPSAVEDMODE VBGLR3HOSTDISPSAVEDMODEPATH "/SavedVideoModes"
775
776	VBGLR3DECL(int) VbglR3GetDisplayChangeRequest(uint32_t pcx, uint32_t pcy, uint32_t pcBits, uint32_t piDisplay,
777	uint32_t pdx, uint32_t pdy, bool pfEnabled, bool pfChangeOrigin, bool fAck);
778	VBGLR3DECL(int) VbglR3GetDisplayChangeRequestMulti(uint32_t cDisplaysIn, uint32_t *pcDisplaysOut,
779	VMMDevDisplayDef *paDisplays, bool fAck);
780	VBGLR3DECL(bool) VbglR3HostLikesVideoMode(uint32_t cx, uint32_t cy, uint32_t cBits);
781	VBGLR3DECL(int) VbglR3VideoModeGetHighestSavedScreen(unsigned *pcScreen);
782	VBGLR3DECL(int) VbglR3SaveVideoMode(unsigned cScreen, unsigned cx, unsigned cy, unsigned cBits,
783	unsigned x, unsigned y, bool fEnabled);
784	VBGLR3DECL(int) VbglR3RetrieveVideoMode(unsigned cScreen, unsigned pcx, unsigned pcy, unsigned *pcBits,
785	unsigned px, unsigned py, bool *pfEnabled);
786	/** @} */
787
788	/** @name VRDP
789	* @{ */
790	VBGLR3DECL(int) VbglR3VrdpGetChangeRequest(bool pfActive, uint32_t puExperienceLevel);
791	/** @} */
792
793	/** @name VM Statistics
794	* @{ */
795	VBGLR3DECL(int) VbglR3StatQueryInterval(uint32_t *pu32Interval);
796	# if defined(VBOX_INCLUDED_VMMDev_h) \|\| defined(DOXYGEN_RUNNING)
797	VBGLR3DECL(int) VbglR3StatReport(VMMDevReportGuestStats *pReq);
798	# endif
799	/** @} */
800
801	/** @name Memory ballooning
802	* @{ */
803	VBGLR3DECL(int) VbglR3MemBalloonRefresh(uint32_t pcChunks, bool pfHandleInR3);
804	VBGLR3DECL(int) VbglR3MemBalloonChange(void *pv, bool fInflate);
805	/** @} */
806
807	/** @name Core Dump
808	* @{ */
809	VBGLR3DECL(int) VbglR3WriteCoreDump(void);
810
811	/** @} */
812
813	# ifdef VBOX_WITH_GUEST_PROPS
814	/** @name Guest properties
815	* @{ */
816	/** @todo Docs. */
817	typedef struct VBGLR3GUESTPROPENUM VBGLR3GUESTPROPENUM;
818	/** @todo Docs. */
819	typedef VBGLR3GUESTPROPENUM *PVBGLR3GUESTPROPENUM;
820	VBGLR3DECL(int) VbglR3GuestPropConnect(uint32_t *pidClient);
821	VBGLR3DECL(int) VbglR3GuestPropDisconnect(HGCMCLIENTID idClient);
822	VBGLR3DECL(int) VbglR3GuestPropWrite(HGCMCLIENTID idClient, const char pszName, const char pszValue, const char *pszFlags);
823	VBGLR3DECL(int) VbglR3GuestPropWriteValue(HGCMCLIENTID idClient, const char pszName, const char pszValue);
824	VBGLR3DECL(int) VbglR3GuestPropWriteValueV(HGCMCLIENTID idClient, const char *pszName,
825	const char *pszValueFormat, va_list va) RT_IPRT_FORMAT_ATTR(3, 0);
826	VBGLR3DECL(int) VbglR3GuestPropWriteValueF(HGCMCLIENTID idClient, const char *pszName,
827	const char *pszValueFormat, ...) RT_IPRT_FORMAT_ATTR(3, 4);
828	VBGLR3DECL(int) VbglR3GuestPropRead(HGCMCLIENTID idClient, const char pszName, void pvBuf, uint32_t cbBuf, char **ppszValue,
829	uint64_t pu64Timestamp, char ppszFlags, uint32_t pcbBufActual);
830	VBGLR3DECL(int) VbglR3GuestPropReadValue(uint32_t ClientId, const char pszName, char pszValue, uint32_t cchValue,
831	uint32_t *pcchValueActual);
832	VBGLR3DECL(int) VbglR3GuestPropReadValueAlloc(HGCMCLIENTID idClient, const char pszName, char *ppszValue);
833	VBGLR3DECL(void) VbglR3GuestPropReadValueFree(char *pszValue);
834	VBGLR3DECL(int) VbglR3GuestPropEnumRaw(HGCMCLIENTID idClient, const char paszPatterns, char pcBuf, uint32_t cbBuf,
835	uint32_t *pcbBufActual);
836	VBGLR3DECL(int) VbglR3GuestPropEnum(HGCMCLIENTID idClient, char const * const *ppaszPatterns, uint32_t cPatterns,
837	PVBGLR3GUESTPROPENUM ppHandle, char const ppszName, char const *ppszValue,
838	uint64_t pu64Timestamp, char const *ppszFlags);
839	VBGLR3DECL(int) VbglR3GuestPropEnumNext(PVBGLR3GUESTPROPENUM pHandle, char const ppszName, char const ppszValue,
840	uint64_t pu64Timestamp, char const *ppszFlags);
841	VBGLR3DECL(void) VbglR3GuestPropEnumFree(PVBGLR3GUESTPROPENUM pHandle);
842	VBGLR3DECL(int) VbglR3GuestPropDelete(HGCMCLIENTID idClient, const char *pszName);
843	VBGLR3DECL(int) VbglR3GuestPropDelSet(HGCMCLIENTID idClient, char const * const *papszPatterns, uint32_t cPatterns);
844	VBGLR3DECL(int) VbglR3GuestPropWait(HGCMCLIENTID idClient, const char pszPatterns, void pvBuf, uint32_t cbBuf,
845	uint64_t u64Timestamp, uint32_t cMillies, char ppszName, char ppszValue,
846	uint64_t pu64Timestamp, char ppszFlags, uint32_t pcbBufActual);
847	/** @} */
848
849	/** @name Guest user handling / reporting.
850	* @{ */
851	VBGLR3DECL(int) VbglR3GuestUserReportState(const char pszUser, const char pszDomain, VBoxGuestUserState enmState,
852	uint8_t *pbDetails, uint32_t cbDetails);
853	/** @} */
854
855	/** @name Host version handling
856	* @{ */
857	VBGLR3DECL(int) VbglR3HostVersionCheckForUpdate(HGCMCLIENTID idClient, bool pfUpdate, char *ppszHostVersion,
858	char **ppszGuestVersion);
859	VBGLR3DECL(int) VbglR3HostVersionLastCheckedLoad(HGCMCLIENTID idClient, char **ppszVer);
860	VBGLR3DECL(int) VbglR3HostVersionLastCheckedStore(HGCMCLIENTID idClient, const char *pszVer);
861	/** @} */
862	# endif /* VBOX_WITH_GUEST_PROPS defined */
863
864	# ifdef VBOX_WITH_SHARED_FOLDERS
865	/** @name Shared folders
866	* @{ */
867	/**
868	* Structure containing mapping information for a shared folder.
869	*/
870	typedef struct VBGLR3SHAREDFOLDERMAPPING
871	{
872	/** Mapping status. */
873	uint32_t u32Status;
874	/** Root handle. */
875	uint32_t u32Root;
876	} VBGLR3SHAREDFOLDERMAPPING;
877	/** Pointer to a shared folder mapping information structure. */
878	typedef VBGLR3SHAREDFOLDERMAPPING *PVBGLR3SHAREDFOLDERMAPPING;
879	/** Pointer to a const shared folder mapping information structure. */
880	typedef VBGLR3SHAREDFOLDERMAPPING const *PCVBGLR3SHAREDFOLDERMAPPING;
881
882	VBGLR3DECL(int) VbglR3SharedFolderConnect(uint32_t *pidClient);
883	VBGLR3DECL(int) VbglR3SharedFolderDisconnect(HGCMCLIENTID idClient);
884	VBGLR3DECL(bool) VbglR3SharedFolderExists(HGCMCLIENTID idClient, const char *pszShareName);
885	VBGLR3DECL(int) VbglR3SharedFolderGetMappings(HGCMCLIENTID idClient, bool fAutoMountOnly,
886	PVBGLR3SHAREDFOLDERMAPPING ppaMappings, uint32_t pcMappings);
887	VBGLR3DECL(void) VbglR3SharedFolderFreeMappings(PVBGLR3SHAREDFOLDERMAPPING paMappings);
888	VBGLR3DECL(int) VbglR3SharedFolderGetName(HGCMCLIENTID idClient,uint32_t u32Root, char ppszName); /< @todo r=bird: GET functions return the value, not a status code!*/
889	VBGLR3DECL(int) VbglR3SharedFolderQueryFolderInfo(HGCMCLIENTID idClient, uint32_t idRoot, uint64_t fQueryFlags,
890	char ppszName, char ppszMountPoint,
891	uint64_t pfFlags, uint32_t puRootIdVersion);
892	VBGLR3DECL(int) VbglR3SharedFolderWaitForMappingsChanges(HGCMCLIENTID idClient, uint32_t uPrevVersion, uint32_t *puCurVersion);
893	VBGLR3DECL(int) VbglR3SharedFolderCancelMappingsChangesWaits(HGCMCLIENTID idClient);
894
895	VBGLR3DECL(int) VbglR3SharedFolderGetMountPrefix(char ppszPrefix); /< @todo r=bird: GET functions return the value, not a status code! */
896	VBGLR3DECL(int) VbglR3SharedFolderGetMountDir(char ppszDir); /< @todo r=bird: GET functions return the value, not a status code! */
897	/** @} */
898	# endif /* VBOX_WITH_SHARED_FOLDERS defined */
899
900	# ifdef VBOX_WITH_GUEST_CONTROL
901	/** @name Guest control
902	* @{ */
903
904	/**
905	* Structure containing the context required for
906	* either retrieving or sending a HGCM guest control
907	* commands from or to the host.
908	*
909	* Note: Do not change parameter order without also
910	* adapting all structure initializers.
911	*/
912	typedef struct VBGLR3GUESTCTRLCMDCTX
913	{
914	/** @todo This struct could be handy if we want to implement
915	* a second communication channel, e.g. via TCP/IP.
916	* Use a union for the HGCM stuff then. */
917
918	/** IN: HGCM client ID to use for communication. */
919	uint32_t uClientID;
920	/** IN/OUT: Context ID to retrieve or to use. */
921	uint32_t uContextID;
922	/** IN: Protocol version to use. */
923	uint32_t uProtocol;
924	/** OUT: Number of parameters retrieved. */
925	uint32_t uNumParms;
926	} VBGLR3GUESTCTRLCMDCTX, *PVBGLR3GUESTCTRLCMDCTX;
927
928	/* General message handling on the guest. */
929	VBGLR3DECL(int) VbglR3GuestCtrlConnect(uint32_t *pidClient);
930	VBGLR3DECL(int) VbglR3GuestCtrlDisconnect(uint32_t idClient);
931	VBGLR3DECL(bool) VbglR3GuestCtrlSupportsOptimizations(uint32_t idClient);
932	VBGLR3DECL(int) VbglR3GuestCtrlMakeMeMaster(uint32_t idClient);
933	VBGLR3DECL(int) VbglR3GuestCtrlReportFeatures(uint32_t idClient, uint64_t fGuestFeatures, uint64_t *pfHostFeatures);
934	VBGLR3DECL(int) VbglR3GuestCtrlQueryFeatures(uint32_t idClient, uint64_t *pfHostFeatures);
935	VBGLR3DECL(int) VbglR3GuestCtrlMsgFilterSet(uint32_t uClientId, uint32_t uValue, uint32_t uMaskAdd, uint32_t uMaskRemove);
936	VBGLR3DECL(int) VbglR3GuestCtrlMsgReply(PVBGLR3GUESTCTRLCMDCTX pCtx, int rc);
937	VBGLR3DECL(int) VbglR3GuestCtrlMsgReplyEx(PVBGLR3GUESTCTRLCMDCTX pCtx, int rc, uint32_t uType,
938	void *pvPayload, uint32_t cbPayload);
939	VBGLR3DECL(int) VbglR3GuestCtrlMsgSkip(uint32_t idClient, int rcSkip, uint32_t idMsg);
940	VBGLR3DECL(int) VbglR3GuestCtrlMsgSkipOld(uint32_t uClientId);
941	VBGLR3DECL(int) VbglR3GuestCtrlMsgPeekWait(uint32_t idClient, uint32_t pidMsg, uint32_t pcParameters, uint64_t *pidRestoreCheck);
942	VBGLR3DECL(int) VbglR3GuestCtrlCancelPendingWaits(HGCMCLIENTID idClient);
943	/* Guest session handling. */
944	VBGLR3DECL(int) VbglR3GuestCtrlSessionPrepare(uint32_t idClient, uint32_t idSession, void const *pvKey, uint32_t cbKey);
945	VBGLR3DECL(int) VbglR3GuestCtrlSessionAccept(uint32_t idClient, uint32_t idSession, void const *pvKey, uint32_t cbKey);
946	VBGLR3DECL(int) VbglR3GuestCtrlSessionCancelPrepared(uint32_t idClient, uint32_t idSession);
947	VBGLR3DECL(int) VbglR3GuestCtrlSessionClose(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t fFlags);
948	VBGLR3DECL(int) VbglR3GuestCtrlSessionNotify(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uType, int32_t iResult);
949	VBGLR3DECL(int) VbglR3GuestCtrlSessionGetOpen(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t puProtocol, char pszUser, uint32_t cbUser,
950	char pszPassword, uint32_t cbPassword, char pszDomain, uint32_t cbDomain,
951	uint32_t pfFlags, uint32_t pidSession);
952	VBGLR3DECL(int) VbglR3GuestCtrlSessionGetClose(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t pfFlags, uint32_t pidSession);
953	/* Guest path handling. */
954	VBGLR3DECL(int) VbglR3GuestCtrlPathGetRename(PVBGLR3GUESTCTRLCMDCTX pCtx, char pszSource, uint32_t cbSource, char pszDest,
955	uint32_t cbDest, uint32_t *pfFlags);
956	VBGLR3DECL(int) VbglR3GuestCtrlPathGetUserDocuments(PVBGLR3GUESTCTRLCMDCTX pCtx);
957	VBGLR3DECL(int) VbglR3GuestCtrlPathGetUserHome(PVBGLR3GUESTCTRLCMDCTX pCtx);
958	/* Guest process execution. */
959	VBGLR3DECL(int) VbglR3GuestCtrlProcGetStart(PVBGLR3GUESTCTRLCMDCTX pCtx, char pszCmd, uint32_t cbCmd, uint32_t pfFlags,
960	char pszArgs, uint32_t cbArgs, uint32_t puNumArgs, char pszEnv, uint32_t pcbEnv,
961	uint32_t puNumEnvVars, char pszUser, uint32_t cbUser, char *pszPassword,
962	uint32_t cbPassword, uint32_t puTimeoutMS, uint32_t puPriority,
963	uint64_t puAffinity, uint32_t cbAffinity, uint32_t pcAffinity);
964	VBGLR3DECL(int) VbglR3GuestCtrlProcGetTerminate(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puPID);
965	VBGLR3DECL(int) VbglR3GuestCtrlProcGetInput(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t puPID, uint32_t pfFlags, void *pvData,
966	uint32_t cbData, uint32_t *pcbSize);
967	VBGLR3DECL(int) VbglR3GuestCtrlProcGetOutput(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t puPID, uint32_t puHandle, uint32_t *pfFlags);
968	VBGLR3DECL(int) VbglR3GuestCtrlProcGetWaitFor(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t puPID, uint32_t puWaitFlags,
969	uint32_t *puTimeoutMS);
970	/* Guest native directory handling. */
971	VBGLR3DECL(int) VbglR3GuestCtrlDirGetRemove(PVBGLR3GUESTCTRLCMDCTX pCtx, char pszPath, uint32_t cbPath, uint32_t pfFlags);
972	/* Guest native file handling. */
973	VBGLR3DECL(int) VbglR3GuestCtrlFileGetOpen(PVBGLR3GUESTCTRLCMDCTX pCtx, char pszFileName, uint32_t cbFileName, char pszOpenMode,
974	uint32_t cbOpenMode, char pszDisposition, uint32_t cbDisposition, char pszSharing,
975	uint32_t cbSharing, uint32_t puCreationMode, uint64_t puOffset);
976	VBGLR3DECL(int) VbglR3GuestCtrlFileGetClose(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puHandle);
977	VBGLR3DECL(int) VbglR3GuestCtrlFileGetRead(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t puHandle, uint32_t puToRead);
978	VBGLR3DECL(int) VbglR3GuestCtrlFileGetReadAt(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puHandle,
979	uint32_t puToRead, uint64_t poffRead);
980	VBGLR3DECL(int) VbglR3GuestCtrlFileGetWrite(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puHandle,
981	void pvData, uint32_t cbData, uint32_t pcbActual);
982	VBGLR3DECL(int) VbglR3GuestCtrlFileGetWriteAt(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t puHandle, void pvData, uint32_t cbData,
983	uint32_t pcbActual, uint64_t poffWrite);
984	VBGLR3DECL(int) VbglR3GuestCtrlFileGetSeek(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puHandle,
985	uint32_t puSeekMethod, uint64_t poffSeek);
986	VBGLR3DECL(int) VbglR3GuestCtrlFileGetTell(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puHandle);
987	VBGLR3DECL(int) VbglR3GuestCtrlFileGetSetSize(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t puHandle, uint64_t pcbNew);
988
989	/* Guest -> Host. */
990	VBGLR3DECL(int) VbglR3GuestCtrlFileCbOpen(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc, uint32_t uFileHandle);
991	VBGLR3DECL(int) VbglR3GuestCtrlFileCbClose(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc);
992	VBGLR3DECL(int) VbglR3GuestCtrlFileCbError(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc);
993	VBGLR3DECL(int) VbglR3GuestCtrlFileCbRead(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc, void *pvData, uint32_t cbData);
994	VBGLR3DECL(int) VbglR3GuestCtrlFileCbReadOffset(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc,
995	void *pvData, uint32_t cbData, int64_t offNew);
996	VBGLR3DECL(int) VbglR3GuestCtrlFileCbWrite(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc, uint32_t cbWritten);
997	VBGLR3DECL(int) VbglR3GuestCtrlFileCbWriteOffset(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc, uint32_t cbWritten, int64_t offNew);
998
999	VBGLR3DECL(int) VbglR3GuestCtrlFileCbSeek(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc, uint64_t offCurrent);
1000	VBGLR3DECL(int) VbglR3GuestCtrlFileCbTell(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc, uint64_t offCurrent);
1001	VBGLR3DECL(int) VbglR3GuestCtrlFileCbSetSize(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc, uint64_t cbNew);
1002	VBGLR3DECL(int) VbglR3GuestCtrlProcCbStatus(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uPID, uint32_t uStatus, uint32_t fFlags,
1003	void *pvData, uint32_t cbData);
1004	VBGLR3DECL(int) VbglR3GuestCtrlProcCbOutput(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uPID, uint32_t uHandle, uint32_t fFlags,
1005	void *pvData, uint32_t cbData);
1006	VBGLR3DECL(int) VbglR3GuestCtrlProcCbStatusInput(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t u32PID, uint32_t uStatus,
1007	uint32_t fFlags, uint32_t cbWritten);
1008
1009	/** @} */
1010	# endif /* VBOX_WITH_GUEST_CONTROL defined */
1011
1012	/** @name Auto-logon handling
1013	* @{ */
1014	VBGLR3DECL(int) VbglR3AutoLogonReportStatus(VBoxGuestFacilityStatus enmStatus);
1015	VBGLR3DECL(bool) VbglR3AutoLogonIsRemoteSession(void);
1016	/** @} */
1017
1018	/** @name User credentials handling
1019	* @{ */
1020	VBGLR3DECL(int) VbglR3CredentialsQueryAvailability(void);
1021	VBGLR3DECL(int) VbglR3CredentialsRetrieve(char ppszUser, char ppszPassword, char **ppszDomain);
1022	VBGLR3DECL(int) VbglR3CredentialsRetrieveUtf16(PRTUTF16 ppwszUser, PRTUTF16 ppwszPassword, PRTUTF16 *ppwszDomain);
1023	VBGLR3DECL(void) VbglR3CredentialsDestroy(char pszUser, char pszPassword, char *pszDomain, uint32_t cPasses);
1024	VBGLR3DECL(void) VbglR3CredentialsDestroyUtf16(PRTUTF16 pwszUser, PRTUTF16 pwszPassword, PRTUTF16 pwszDomain,
1025	uint32_t cPasses);
1026	/** @} */
1027
1028	/** @name CPU hotplug monitor
1029	* @{ */
1030	VBGLR3DECL(int) VbglR3CpuHotPlugInit(void);
1031	VBGLR3DECL(int) VbglR3CpuHotPlugTerm(void);
1032	VBGLR3DECL(int) VbglR3CpuHotPlugWaitForEvent(VMMDevCpuEventType penmEventType, uint32_t pidCpuCore, uint32_t *pidCpuPackage);
1033	/** @} */
1034
1035	/** @name Page sharing
1036	* @{ */
1037	struct VMMDEVSHAREDREGIONDESC;
1038	VBGLR3DECL(int) VbglR3RegisterSharedModule(char pszModuleName, char pszVersion, RTGCPTR64 GCBaseAddr, uint32_t cbModule,
1039	unsigned cRegions, struct VMMDEVSHAREDREGIONDESC *pRegions);
1040	VBGLR3DECL(int) VbglR3UnregisterSharedModule(char pszModuleName, char pszVersion, RTGCPTR64 GCBaseAddr, uint32_t cbModule);
1041	VBGLR3DECL(int) VbglR3CheckSharedModules(void);
1042	VBGLR3DECL(bool) VbglR3PageSharingIsEnabled(void);
1043	VBGLR3DECL(int) VbglR3PageIsShared(RTGCPTR pPage, bool pfShared, uint64_t puPageFlags);
1044	/** @} */
1045
1046	# ifdef VBOX_WITH_DRAG_AND_DROP
1047	/** @name Drag and Drop
1048	* @{ */
1049	/**
1050	* Structure containing the context required for
1051	* either retrieving or sending a HGCM guest drag'n drop
1052	* commands from or to the host.
1053	*
1054	* Note: Do not change parameter order without also
1055	* adapting all structure initializers.
1056	*/
1057	typedef struct VBGLR3GUESTDNDCMDCTX
1058	{
1059	/** @todo This struct could be handy if we want to implement
1060	* a second communication channel, e.g. via TCP/IP.
1061	* Use a union for the HGCM stuff then. */
1062
1063	/** HGCM client ID to use for communication. */
1064	uint32_t uClientID;
1065	/** The VM's current session ID. */
1066	uint64_t uSessionID;
1067	/** Protocol version to use. */
1068	uint32_t uProtocol;
1069	/** Number of parameters retrieved for the current command. */
1070	uint32_t uNumParms;
1071	/** Max chunk size (in bytes) for data transfers. */
1072	uint32_t cbMaxChunkSize;
1073	} VBGLR3GUESTDNDCMDCTX, *PVBGLR3GUESTDNDCMDCTX;
1074
1075	/**
1076	* Enumeration for specifying the DnD meta data type.
1077	*/
1078	typedef enum VBGLR3GUESTDNDMETADATATYPE
1079	{
1080	/** Unknown meta data type; don't use. */
1081	VBGLR3GUESTDNDMETADATATYPE_UNKNOWN = 0,
1082	/** Raw meta data; can be everything. */
1083	VBGLR3GUESTDNDMETADATATYPE_RAW,
1084	/** Meta data is a transfer list, specifying objects. */
1085	VBGLR3GUESTDNDMETADATATYPE_URI_LIST,
1086	/** Blow the type up to 32-bit. */
1087	VBGLR3GUESTDNDMETADATATYPE_32BIT_HACK = 0x7fffffff
1088	} VBGLR3GUESTDNDMETADATATYPE;
1089
1090	/**
1091	* Structure for keeping + handling DnD meta data.
1092	*
1093	* Note: Don't treat this struct as POD object, as the union has classes in it.
1094	*/
1095	typedef struct VBGLR3GUESTDNDMETADATA
1096	{
1097	/** The meta data type the union contains. */
1098	VBGLR3GUESTDNDMETADATATYPE enmType;
1099	/** Pointer to actual meta data. */
1100	void *pvMeta;
1101	/** Size (in bytes) of meta data. */
1102	uint32_t cbMeta;
1103	} VBGLR3GUESTDNDMETADATA;
1104
1105	/** Pointer to VBGLR3GUESTDNDMETADATA. */
1106	typedef VBGLR3GUESTDNDMETADATA *PVBGLR3GUESTDNDMETADATA;
1107
1108	/** Const pointer to VBGLR3GUESTDNDMETADATA. */
1109	typedef const PVBGLR3GUESTDNDMETADATA CPVBGLR3GUESTDNDMETADATA;
1110
1111	/**
1112	* Enumeration specifying a DnD event type.
1113	*/
1114	typedef enum VBGLR3DNDEVENTTYPE
1115	{
1116	VBGLR3DNDEVENTTYPE_INVALID = 0,
1117	VBGLR3DNDEVENTTYPE_HG_ERROR = 1,
1118	VBGLR3DNDEVENTTYPE_HG_ENTER = 2,
1119	VBGLR3DNDEVENTTYPE_HG_MOVE = 3,
1120	VBGLR3DNDEVENTTYPE_HG_LEAVE = 4,
1121	VBGLR3DNDEVENTTYPE_HG_DROP = 5,
1122	VBGLR3DNDEVENTTYPE_HG_RECEIVE = 6,
1123	VBGLR3DNDEVENTTYPE_HG_CANCEL = 7,
1124	# ifdef VBOX_WITH_DRAG_AND_DROP_GH
1125	VBGLR3DNDEVENTTYPE_GH_ERROR = 100,
1126	VBGLR3DNDEVENTTYPE_GH_REQ_PENDING = 101,
1127	VBGLR3DNDEVENTTYPE_GH_DROP = 102,
1128	# endif
1129	/** Blow the type up to 32-bit. */
1130	VBGLR3DNDEVENTTYPE_32BIT_HACK = 0x7fffffff
1131	} VBGLR3DNDEVENTTYPE;
1132
1133	typedef struct VBGLR3DNDEVENT
1134	{
1135	/** The event type the union contains. */
1136	VBGLR3DNDEVENTTYPE enmType;
1137	union
1138	{
1139	struct
1140	{
1141	/** Screen ID this request belongs to. */
1142	uint32_t uScreenID;
1143	/** Format list (UTF-8, \r\n separated). */
1144	char *pszFormats;
1145	/** Size (in bytes) of pszFormats (\0 included). */
1146	uint32_t cbFormats;
1147	/** List of allowed DnD actions. */
1148	VBOXDNDACTIONLIST dndLstActionsAllowed;
1149	} HG_Enter;
1150	struct
1151	{
1152	/** Absolute X position of guest screen. */
1153	uint32_t uXpos;
1154	/** Absolute Y position of guest screen. */
1155	uint32_t uYpos;
1156	/** Default DnD action. */
1157	VBOXDNDACTION dndActionDefault;
1158	} HG_Move;
1159	struct
1160	{
1161	/** Absolute X position of guest screen. */
1162	uint32_t uXpos;
1163	/** Absolute Y position of guest screen. */
1164	uint32_t uYpos;
1165	/** Default DnD action. */
1166	VBOXDNDACTION dndActionDefault;
1167	} HG_Drop;
1168	struct
1169	{
1170	/** Meta data for the operation. */
1171	VBGLR3GUESTDNDMETADATA Meta;
1172	} HG_Received;
1173	struct
1174	{
1175	/** IPRT-style error code. */
1176	int rc;
1177	} HG_Error;
1178	# ifdef VBOX_WITH_DRAG_AND_DROP_GH
1179	struct
1180	{
1181	/** Screen ID this request belongs to. */
1182	uint32_t uScreenID;
1183	} GH_IsPending;
1184	struct
1185	{
1186	/** Requested format by the host. */
1187	char *pszFormat;
1188	/** Size (in bytes) of pszFormat (\0 included). */
1189	uint32_t cbFormat;
1190	/** Requested DnD action. */
1191	VBOXDNDACTION dndActionRequested;
1192	} GH_Drop;
1193	# endif
1194	} u;
1195	} VBGLR3DNDEVENT;
1196	typedef VBGLR3DNDEVENT *PVBGLR3DNDEVENT;
1197	typedef const PVBGLR3DNDEVENT CPVBGLR3DNDEVENT;
1198
1199	VBGLR3DECL(int) VbglR3DnDConnect(PVBGLR3GUESTDNDCMDCTX pCtx);
1200	VBGLR3DECL(int) VbglR3DnDDisconnect(PVBGLR3GUESTDNDCMDCTX pCtx);
1201
1202	VBGLR3DECL(int) VbglR3DnDEventGetNext(PVBGLR3GUESTDNDCMDCTX pCtx, PVBGLR3DNDEVENT *ppEvent);
1203	VBGLR3DECL(void) VbglR3DnDEventFree(PVBGLR3DNDEVENT pEvent);
1204
1205	VBGLR3DECL(int) VbglR3DnDHGSendAckOp(PVBGLR3GUESTDNDCMDCTX pCtx, VBOXDNDACTION dndAction);
1206	VBGLR3DECL(int) VbglR3DnDHGSendReqData(PVBGLR3GUESTDNDCMDCTX pCtx, const char *pcszFormat);
1207	VBGLR3DECL(int) VbglR3DnDHGSendProgress(PVBGLR3GUESTDNDCMDCTX pCtx, uint32_t uStatus, uint8_t uPercent, int rcErr);
1208	# ifdef VBOX_WITH_DRAG_AND_DROP_GH
1209	VBGLR3DECL(int) VbglR3DnDGHSendAckPending(PVBGLR3GUESTDNDCMDCTX pCtx, VBOXDNDACTION dndActionDefault, VBOXDNDACTIONLIST dndLstActionsAllowed, const char* pcszFormats, uint32_t cbFormats);
1210	VBGLR3DECL(int) VbglR3DnDGHSendData(PVBGLR3GUESTDNDCMDCTX pCtx, const char pszFormat, void pvData, uint32_t cbData);
1211	VBGLR3DECL(int) VbglR3DnDGHSendError(PVBGLR3GUESTDNDCMDCTX pCtx, int rcOp);
1212	# endif /* VBOX_WITH_DRAG_AND_DROP_GH */
1213	/** @} */
1214	# endif /* VBOX_WITH_DRAG_AND_DROP */
1215
1216	/* Generic Host Channel Service. */
1217	VBGLR3DECL(int) VbglR3HostChannelInit(uint32_t *pidClient);
1218	VBGLR3DECL(void) VbglR3HostChannelTerm(uint32_t idClient);
1219	VBGLR3DECL(int) VbglR3HostChannelAttach(uint32_t *pu32ChannelHandle, uint32_t u32HGCMClientId,
1220	const char *pszName, uint32_t u32Flags);
1221	VBGLR3DECL(void) VbglR3HostChannelDetach(uint32_t u32ChannelHandle, uint32_t u32HGCMClientId);
1222	VBGLR3DECL(int) VbglR3HostChannelSend(uint32_t u32ChannelHandle, uint32_t u32HGCMClientId,
1223	void *pvData, uint32_t cbData);
1224	VBGLR3DECL(int) VbglR3HostChannelRecv(uint32_t u32ChannelHandle, uint32_t u32HGCMClientId,
1225	void *pvData, uint32_t cbData,
1226	uint32_t pu32SizeReceived, uint32_t pu32SizeRemaining);
1227	VBGLR3DECL(int) VbglR3HostChannelControl(uint32_t u32ChannelHandle, uint32_t u32HGCMClientId,
1228	uint32_t u32Code, void *pvParm, uint32_t cbParm,
1229	void pvData, uint32_t cbData, uint32_t pu32SizeDataReturned);
1230	VBGLR3DECL(int) VbglR3HostChannelEventWait(uint32_t *pu32ChannelHandle, uint32_t u32HGCMClientId,
1231	uint32_t pu32EventId, void pvParm, uint32_t cbParm,
1232	uint32_t *pu32SizeReturned);
1233	VBGLR3DECL(int) VbglR3HostChannelEventCancel(uint32_t u32ChannelHandle, uint32_t u32HGCMClientId);
1234	VBGLR3DECL(int) VbglR3HostChannelQuery(const char *pszName, uint32_t u32HGCMClientId, uint32_t u32Code,
1235	void pvParm, uint32_t cbParm, void pvData, uint32_t cbData,
1236	uint32_t *pu32SizeDataReturned);
1237
1238	/** @name Mode hint storage
1239	* @{ */
1240	VBGLR3DECL(int) VbglR3ReadVideoMode(unsigned cDisplay, unsigned *cx,
1241	unsigned cy, unsigned cBPP, unsigned *x,
1242	unsigned y, unsigned fEnabled);
1243	VBGLR3DECL(int) VbglR3WriteVideoMode(unsigned cDisplay, unsigned cx,
1244	unsigned cy, unsigned cBPP, unsigned x,
1245	unsigned y, unsigned fEnabled);
1246	/** @} */
1247
1248	/** @name Generic HGCM
1249	* @{ */
1250	VBGLR3DECL(int) VbglR3HGCMConnect(const char pszServiceName, HGCMCLIENTID pidClient);
1251	VBGLR3DECL(int) VbglR3HGCMDisconnect(HGCMCLIENTID idClient);
1252	struct VBGLIOCHGCMCALL;
1253	VBGLR3DECL(int) VbglR3HGCMCall(struct VBGLIOCHGCMCALL *pInfo, size_t cbInfo);
1254	/** @} */
1255
1256	#endif /* IN_RING3 */
1257	/** @} */
1258
1259	RT_C_DECLS_END
1260
1261	/** @} */
1262
1263	#endif /* !VBOX_INCLUDED_VBoxGuestLib_h */
1264

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

source: vbox/trunk/include/VBox/VBoxGuestLib.h@ 82525

Download in other formats: