VBoxGuestLib.h@ 80634

Last change on this file since 80634 was 80444, checked in by vboxsync, 5 years ago
Shared Clipboard/URI: Added protocol versioning support plus enhanced versions of existing commands (to also provide context IDs, among other stuff). So far only the host service(s) and the Windows guest is using the new(er) protocol.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 54.0 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_URI_LIST
45	# include <VBox/GuestHost/SharedClipboard-uri.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	* Structure containing the context required for
580	* either retrieving or sending a HGCM shared clipboard
581	* commands from or to the host.
582	*
583	* Note: Do not change parameter order without also
584	* adapting all structure initializers.
585	*/
586	typedef struct VBGLR3SHCLCMDCTX
587	{
588	/** @todo This struct could be handy if we want to implement
589	* a second communication channel, e.g. via TCP/IP.
590	* Use a union for the HGCM stuff then. */
591
592	/** IN: HGCM client ID to use for communication. */
593	uint32_t uClientID;
594	/** IN/OUT: Context ID to retrieve or to use. */
595	uint32_t uContextID;
596	/** IN: Protocol version to use. */
597	uint32_t uProtocolVer;
598	/** IN: Protocol flags. Currently unused. */
599	uint32_t uProtocolFlags;
600	/** IN: Maximum chunk size (in bytes). */
601	uint32_t cbChunkSize;
602	/** OUT: Number of parameters retrieved. */
603	uint32_t uNumParms;
604	} VBGLR3SHCLCMDCTX, *PVBGLR3SHCLCMDCTX;
605
606	/**
607	* Enumeration specifying a Shared Clipboard event type.
608	*/
609	typedef enum _VBGLR3CLIPBOARDEVENTTYPE
610	{
611	VBGLR3CLIPBOARDEVENTTYPE_INVALID = 0,
612	VBGLR3CLIPBOARDEVENTTYPE_REPORT_FORMATS,
613	VBGLR3CLIPBOARDEVENTTYPE_READ_DATA,
614	VBGLR3CLIPBOARDEVENTTYPE_QUIT,
615	VBGLR3CLIPBOARDEVENTTYPE_URI_LIST_HDR_READ,
616	VBGLR3CLIPBOARDEVENTTYPE_URI_LIST_HDR_WRITE,
617	VBGLR3CLIPBOARDEVENTTYPE_URI_LIST_ENTRY_READ,
618	VBGLR3CLIPBOARDEVENTTYPE_URI_LIST_ENTRY_WRITE,
619	VBGLR3CLIPBOARDEVENTTYPE_URI_OBJ_OPEN,
620	VBGLR3CLIPBOARDEVENTTYPE_URI_OBJ_CLOSE,
621	VBGLR3CLIPBOARDEVENTTYPE_URI_OBJ_READ,
622	VBGLR3CLIPBOARDEVENTTYPE_URI_OBJ_WRITE,
623	VBGLR3CLIPBOARDEVENTTYPE_URI_CANCEL,
624	VBGLR3CLIPBOARDEVENTTYPE_URI_ERROR,
625	/** Blow the type up to 32-bit. */
626	VBGLR3CLIPBOARDEVENTTYPE_32BIT_HACK = 0x7fffffff
627	} VBGLR3CLIPBOARDEVENTTYPE;
628
629	/**
630	* Structure for keeping a Shared Clipboard VbglR3 event.
631	*/
632	typedef struct _VBGLR3CLIPBOARDEVENT
633	{
634	/** The event type the union contains. */
635	VBGLR3CLIPBOARDEVENTTYPE enmType;
636	/** Command context bound to this event. */
637	VBGLR3SHCLCMDCTX cmdCtx;
638	union
639	{
640	/** Reports available formats from the host. */
641	SHAREDCLIPBOARDFORMATDATA ReportFormats;
642	/** Requests data to be read from the guest. */
643	SHAREDCLIPBOARDDATAREQ ReadData;
644	} u;
645	} VBGLR3CLIPBOARDEVENT, *PVBGLR3CLIPBOARDEVENT;
646	typedef const PVBGLR3CLIPBOARDEVENT CPVBGLR3CLIPBOARDEVENT;
647
648	VBGLR3DECL(int) VbglR3ClipboardConnect(HGCMCLIENTID *pidClient);
649	VBGLR3DECL(int) VbglR3ClipboardDisconnect(HGCMCLIENTID idClient);
650	VBGLR3DECL(int) VbglR3ClipboardGetHostMsgOld(HGCMCLIENTID idClient, uint32_t pMsg, uint32_t pfFormats);
651	VBGLR3DECL(int) VbglR3ClipboardReadData(HGCMCLIENTID idClient, uint32_t fFormat, void pv, uint32_t cb, uint32_t pcb);
652	VBGLR3DECL(int) VbglR3ClipboardWriteData(HGCMCLIENTID idClient, uint32_t fFormat, void *pv, uint32_t cb);
653	VBGLR3DECL(int) VbglR3ClipboardWriteDataEx(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDDATABLOCK pData);
654	VBGLR3DECL(int) VbglR3ClipboardFormatsSend(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDFORMATDATA pFormats);
655	VBGLR3DECL(int) VbglR3ClipboardReportFormats(HGCMCLIENTID idClient, uint32_t fFormats);
656
657	VBGLR3DECL(int) VbglR3ClipboardConnectEx(PVBGLR3SHCLCMDCTX pCtx);
658	VBGLR3DECL(int) VbglR3ClipboardDisconnectEx(PVBGLR3SHCLCMDCTX pCtx);
659	VBGLR3DECL(int) VbglR3ClipboardEventGetNext(PVBGLR3SHCLCMDCTX pCtx, PVBGLR3CLIPBOARDEVENT *ppEvent);
660	VBGLR3DECL(void) VbglR3ClipboardEventFree(PVBGLR3CLIPBOARDEVENT pEvent);
661
662	VBGLR3DECL(int) VbglR3ClipboardWriteError(HGCMCLIENTID idClient, int rcErr);
663
664	# ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
665	VBGLR3DECL(int) VbglR3ClipboardTransferEvent(PVBGLR3SHCLCMDCTX pCtx, uint32_t uMsg, uint32_t cParms,
666	PSHAREDCLIPBOARDURITRANSFER pTransfer);
667	VBGLR3DECL(int) VbglR3ClipboardTransferSendStatus(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDURITRANSFER pTransfer,
668	SHAREDCLIPBOARDURITRANSFERSTATUS uStatus);
669
670	VBGLR3DECL(int) VbglR3ClipboardRootListRead(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDROOTLIST *ppRootList);
671
672	VBGLR3DECL(int) VbglR3ClipboardRootListHdrReadReq(PVBGLR3SHCLCMDCTX pCtx, uint32_t *pfRoots);
673	VBGLR3DECL(int) VbglR3ClipboardRootListHdrReadReply(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDROOTLIST pRootList);
674	VBGLR3DECL(int) VbglR3ClipboardRootsWrite(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDROOTLISTHDR pRoots);
675
676	VBGLR3DECL(int) VbglR3ClipboardListOpenSend(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms, PSHAREDCLIPBOARDLISTHANDLE phList);
677	VBGLR3DECL(int) VbglR3ClipboardListOpenRecv(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms);
678	VBGLR3DECL(int) VbglR3ClipboardListOpenReply(PVBGLR3SHCLCMDCTX pCtx, int rcReply, SHAREDCLIPBOARDLISTHANDLE hList);
679
680	VBGLR3DECL(int) VbglR3ClipboardListCloseSend(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList);
681	VBGLR3DECL(int) VbglR3ClipboardListCloseRecv(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDLISTHANDLE phList);
682
683	VBGLR3DECL(int) VbglR3ClipboardListHdrWrite(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTHDR pListHdr);
684	VBGLR3DECL(int) VbglR3ClipboardListEntryWrite(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTENTRY pListEntry);
685
686	VBGLR3DECL(int) VbglR3ClipboardObjOpenRecv(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDOBJOPENCREATEPARMS pCreateParms);
687	VBGLR3DECL(int) VbglR3ClipboardObjOpenReply(PVBGLR3SHCLCMDCTX pCtx, int rcReply, SHAREDCLIPBOARDOBJHANDLE hObj);
688	VBGLR3DECL(int) VbglR3ClipboardObjOpenSend(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDOBJOPENCREATEPARMS pCreateParms,
689	PSHAREDCLIPBOARDOBJHANDLE phObj);
690
691	VBGLR3DECL(int) VbglR3ClipboardObjCloseRecv(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDOBJHANDLE phObj);
692	VBGLR3DECL(int) VbglR3ClipboardObjCloseReply(PVBGLR3SHCLCMDCTX pCtx, int rcReply, SHAREDCLIPBOARDOBJHANDLE hObj);
693	VBGLR3DECL(int) VbglR3ClipboardObjCloseSend(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj);
694
695	VBGLR3DECL(int) VbglR3ClipboardObjReadRecv(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDOBJHANDLE phObj, uint32_t pcbToRead,
696	uint32_t *pfFlags);
697	VBGLR3DECL(int) VbglR3ClipboardObjRead(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf,
698	uint32_t *pcbRead);
699	VBGLR3DECL(int) VbglR3ClipboardObjWrite(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf,
700	uint32_t *pcbWritten);
701	# endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
702	/** @} */
703	# endif /* VBOX_WITH_SHARED_CLIPBOARD */
704
705	/** @name Seamless mode
706	* @{ */
707	VBGLR3DECL(int) VbglR3SeamlessSetCap(bool fState);
708	VBGLR3DECL(int) VbglR3SeamlessWaitEvent(VMMDevSeamlessMode *pMode);
709	VBGLR3DECL(int) VbglR3SeamlessSendRects(uint32_t cRects, PRTRECT pRects);
710	VBGLR3DECL(int) VbglR3SeamlessGetLastEvent(VMMDevSeamlessMode *pMode);
711
712	/** @} */
713
714	/** @name Mouse
715	* @{ */
716	VBGLR3DECL(int) VbglR3GetMouseStatus(uint32_t pfFeatures, uint32_t px, uint32_t *py);
717	VBGLR3DECL(int) VbglR3SetMouseStatus(uint32_t fFeatures);
718	/** @} */
719
720	/** @name Video
721	* @{ */
722	VBGLR3DECL(int) VbglR3VideoAccelEnable(bool fEnable);
723	VBGLR3DECL(int) VbglR3VideoAccelFlush(void);
724	VBGLR3DECL(int) VbglR3SetPointerShape(uint32_t fFlags, uint32_t xHot, uint32_t yHot, uint32_t cx, uint32_t cy,
725	const void *pvImg, size_t cbImg);
726	VBGLR3DECL(int) VbglR3SetPointerShapeReq(struct VMMDevReqMousePointer *pReq);
727	/** @} */
728
729	/** @name Display
730	* @{ */
731	/** The folder for the video mode hint unix domain socket on Unix-like guests.
732	* @note This can be safely changed as all users are rebuilt in lock-step. */
733	#define VBGLR3HOSTDISPSOCKETPATH "/tmp/.VBoxService"
734	/** The path to the video mode hint unix domain socket on Unix-like guests. */
735	#define VBGLR3HOSTDISPSOCKET VBGLR3VIDEOMODEHINTSOCKETPATH "/VideoModeHint"
736
737	/** The folder for saving video mode hints to between sessions. */
738	#define VBGLR3HOSTDISPSAVEDMODEPATH "/var/lib/VBoxGuestAdditions"
739	/** The path to the file for saving video mode hints to between sessions. */
740	#define VBGLR3HOSTDISPSAVEDMODE VBGLR3HOSTDISPSAVEDMODEPATH "/SavedVideoModes"
741
742	VBGLR3DECL(int) VbglR3GetDisplayChangeRequest(uint32_t pcx, uint32_t pcy, uint32_t pcBits, uint32_t piDisplay,
743	uint32_t pdx, uint32_t pdy, bool pfEnabled, bool pfChangeOrigin, bool fAck);
744	VBGLR3DECL(int) VbglR3GetDisplayChangeRequestMulti(uint32_t cDisplaysIn, uint32_t *pcDisplaysOut,
745	VMMDevDisplayDef *paDisplays, bool fAck);
746	VBGLR3DECL(bool) VbglR3HostLikesVideoMode(uint32_t cx, uint32_t cy, uint32_t cBits);
747	VBGLR3DECL(int) VbglR3VideoModeGetHighestSavedScreen(unsigned *pcScreen);
748	VBGLR3DECL(int) VbglR3SaveVideoMode(unsigned cScreen, unsigned cx, unsigned cy, unsigned cBits,
749	unsigned x, unsigned y, bool fEnabled);
750	VBGLR3DECL(int) VbglR3RetrieveVideoMode(unsigned cScreen, unsigned pcx, unsigned pcy, unsigned *pcBits,
751	unsigned px, unsigned py, bool *pfEnabled);
752	/** @} */
753
754	/** @name VRDP
755	* @{ */
756	VBGLR3DECL(int) VbglR3VrdpGetChangeRequest(bool pfActive, uint32_t puExperienceLevel);
757	/** @} */
758
759	/** @name VM Statistics
760	* @{ */
761	VBGLR3DECL(int) VbglR3StatQueryInterval(uint32_t *pu32Interval);
762	# if defined(VBOX_INCLUDED_VMMDev_h) \|\| defined(DOXYGEN_RUNNING)
763	VBGLR3DECL(int) VbglR3StatReport(VMMDevReportGuestStats *pReq);
764	# endif
765	/** @} */
766
767	/** @name Memory ballooning
768	* @{ */
769	VBGLR3DECL(int) VbglR3MemBalloonRefresh(uint32_t pcChunks, bool pfHandleInR3);
770	VBGLR3DECL(int) VbglR3MemBalloonChange(void *pv, bool fInflate);
771	/** @} */
772
773	/** @name Core Dump
774	* @{ */
775	VBGLR3DECL(int) VbglR3WriteCoreDump(void);
776
777	/** @} */
778
779	# ifdef VBOX_WITH_GUEST_PROPS
780	/** @name Guest properties
781	* @{ */
782	/** @todo Docs. */
783	typedef struct VBGLR3GUESTPROPENUM VBGLR3GUESTPROPENUM;
784	/** @todo Docs. */
785	typedef VBGLR3GUESTPROPENUM *PVBGLR3GUESTPROPENUM;
786	VBGLR3DECL(int) VbglR3GuestPropConnect(uint32_t *pidClient);
787	VBGLR3DECL(int) VbglR3GuestPropDisconnect(HGCMCLIENTID idClient);
788	VBGLR3DECL(int) VbglR3GuestPropWrite(HGCMCLIENTID idClient, const char pszName, const char pszValue, const char *pszFlags);
789	VBGLR3DECL(int) VbglR3GuestPropWriteValue(HGCMCLIENTID idClient, const char pszName, const char pszValue);
790	VBGLR3DECL(int) VbglR3GuestPropWriteValueV(HGCMCLIENTID idClient, const char *pszName,
791	const char *pszValueFormat, va_list va) RT_IPRT_FORMAT_ATTR(3, 0);
792	VBGLR3DECL(int) VbglR3GuestPropWriteValueF(HGCMCLIENTID idClient, const char *pszName,
793	const char *pszValueFormat, ...) RT_IPRT_FORMAT_ATTR(3, 4);
794	VBGLR3DECL(int) VbglR3GuestPropRead(HGCMCLIENTID idClient, const char pszName, void pvBuf, uint32_t cbBuf, char **ppszValue,
795	uint64_t pu64Timestamp, char ppszFlags, uint32_t pcbBufActual);
796	VBGLR3DECL(int) VbglR3GuestPropReadValue(uint32_t ClientId, const char pszName, char pszValue, uint32_t cchValue,
797	uint32_t *pcchValueActual);
798	VBGLR3DECL(int) VbglR3GuestPropReadValueAlloc(HGCMCLIENTID idClient, const char pszName, char *ppszValue);
799	VBGLR3DECL(void) VbglR3GuestPropReadValueFree(char *pszValue);
800	VBGLR3DECL(int) VbglR3GuestPropEnumRaw(HGCMCLIENTID idClient, const char paszPatterns, char pcBuf, uint32_t cbBuf,
801	uint32_t *pcbBufActual);
802	VBGLR3DECL(int) VbglR3GuestPropEnum(HGCMCLIENTID idClient, char const * const *ppaszPatterns, uint32_t cPatterns,
803	PVBGLR3GUESTPROPENUM ppHandle, char const ppszName, char const *ppszValue,
804	uint64_t pu64Timestamp, char const *ppszFlags);
805	VBGLR3DECL(int) VbglR3GuestPropEnumNext(PVBGLR3GUESTPROPENUM pHandle, char const ppszName, char const ppszValue,
806	uint64_t pu64Timestamp, char const *ppszFlags);
807	VBGLR3DECL(void) VbglR3GuestPropEnumFree(PVBGLR3GUESTPROPENUM pHandle);
808	VBGLR3DECL(int) VbglR3GuestPropDelete(HGCMCLIENTID idClient, const char *pszName);
809	VBGLR3DECL(int) VbglR3GuestPropDelSet(HGCMCLIENTID idClient, char const * const *papszPatterns, uint32_t cPatterns);
810	VBGLR3DECL(int) VbglR3GuestPropWait(HGCMCLIENTID idClient, const char pszPatterns, void pvBuf, uint32_t cbBuf,
811	uint64_t u64Timestamp, uint32_t cMillies, char ppszName, char ppszValue,
812	uint64_t pu64Timestamp, char ppszFlags, uint32_t pcbBufActual);
813	/** @} */
814
815	/** @name Guest user handling / reporting.
816	* @{ */
817	VBGLR3DECL(int) VbglR3GuestUserReportState(const char pszUser, const char pszDomain, VBoxGuestUserState enmState,
818	uint8_t *pbDetails, uint32_t cbDetails);
819	/** @} */
820
821	/** @name Host version handling
822	* @{ */
823	VBGLR3DECL(int) VbglR3HostVersionCheckForUpdate(HGCMCLIENTID idClient, bool pfUpdate, char *ppszHostVersion,
824	char **ppszGuestVersion);
825	VBGLR3DECL(int) VbglR3HostVersionLastCheckedLoad(HGCMCLIENTID idClient, char **ppszVer);
826	VBGLR3DECL(int) VbglR3HostVersionLastCheckedStore(HGCMCLIENTID idClient, const char *pszVer);
827	/** @} */
828	# endif /* VBOX_WITH_GUEST_PROPS defined */
829
830	# ifdef VBOX_WITH_SHARED_FOLDERS
831	/** @name Shared folders
832	* @{ */
833	/**
834	* Structure containing mapping information for a shared folder.
835	*/
836	typedef struct VBGLR3SHAREDFOLDERMAPPING
837	{
838	/** Mapping status. */
839	uint32_t u32Status;
840	/** Root handle. */
841	uint32_t u32Root;
842	} VBGLR3SHAREDFOLDERMAPPING;
843	/** Pointer to a shared folder mapping information structure. */
844	typedef VBGLR3SHAREDFOLDERMAPPING *PVBGLR3SHAREDFOLDERMAPPING;
845	/** Pointer to a const shared folder mapping information structure. */
846	typedef VBGLR3SHAREDFOLDERMAPPING const *PCVBGLR3SHAREDFOLDERMAPPING;
847
848	VBGLR3DECL(int) VbglR3SharedFolderConnect(uint32_t *pidClient);
849	VBGLR3DECL(int) VbglR3SharedFolderDisconnect(HGCMCLIENTID idClient);
850	VBGLR3DECL(bool) VbglR3SharedFolderExists(HGCMCLIENTID idClient, const char *pszShareName);
851	VBGLR3DECL(int) VbglR3SharedFolderGetMappings(HGCMCLIENTID idClient, bool fAutoMountOnly,
852	PVBGLR3SHAREDFOLDERMAPPING ppaMappings, uint32_t pcMappings);
853	VBGLR3DECL(void) VbglR3SharedFolderFreeMappings(PVBGLR3SHAREDFOLDERMAPPING paMappings);
854	VBGLR3DECL(int) VbglR3SharedFolderGetName(HGCMCLIENTID idClient,uint32_t u32Root, char ppszName); /< @todo r=bird: GET functions return the value, not a status code!*/
855	VBGLR3DECL(int) VbglR3SharedFolderQueryFolderInfo(HGCMCLIENTID idClient, uint32_t idRoot, uint64_t fQueryFlags,
856	char ppszName, char ppszMountPoint,
857	uint64_t pfFlags, uint32_t puRootIdVersion);
858	VBGLR3DECL(int) VbglR3SharedFolderWaitForMappingsChanges(HGCMCLIENTID idClient, uint32_t uPrevVersion, uint32_t *puCurVersion);
859	VBGLR3DECL(int) VbglR3SharedFolderCancelMappingsChangesWaits(HGCMCLIENTID idClient);
860
861	VBGLR3DECL(int) VbglR3SharedFolderGetMountPrefix(char ppszPrefix); /< @todo r=bird: GET functions return the value, not a status code! */
862	VBGLR3DECL(int) VbglR3SharedFolderGetMountDir(char ppszDir); /< @todo r=bird: GET functions return the value, not a status code! */
863	/** @} */
864	# endif /* VBOX_WITH_SHARED_FOLDERS defined */
865
866	# ifdef VBOX_WITH_GUEST_CONTROL
867	/** @name Guest control
868	* @{ */
869
870	/**
871	* Structure containing the context required for
872	* either retrieving or sending a HGCM guest control
873	* commands from or to the host.
874	*
875	* Note: Do not change parameter order without also
876	* adapting all structure initializers.
877	*/
878	typedef struct VBGLR3GUESTCTRLCMDCTX
879	{
880	/** @todo This struct could be handy if we want to implement
881	* a second communication channel, e.g. via TCP/IP.
882	* Use a union for the HGCM stuff then. */
883
884	/** IN: HGCM client ID to use for communication. */
885	uint32_t uClientID;
886	/** IN/OUT: Context ID to retrieve or to use. */
887	uint32_t uContextID;
888	/** IN: Protocol version to use. */
889	uint32_t uProtocol;
890	/** OUT: Number of parameters retrieved. */
891	uint32_t uNumParms;
892	} VBGLR3GUESTCTRLCMDCTX, *PVBGLR3GUESTCTRLCMDCTX;
893
894	/* General message handling on the guest. */
895	VBGLR3DECL(int) VbglR3GuestCtrlConnect(uint32_t *pidClient);
896	VBGLR3DECL(int) VbglR3GuestCtrlDisconnect(uint32_t idClient);
897	VBGLR3DECL(bool) VbglR3GuestCtrlSupportsOptimizations(uint32_t idClient);
898	VBGLR3DECL(int) VbglR3GuestCtrlMakeMeMaster(uint32_t idClient);
899	VBGLR3DECL(int) VbglR3GuestCtrlReportFeatures(uint32_t idClient, uint64_t fGuestFeatures, uint64_t *pfHostFeatures);
900	VBGLR3DECL(int) VbglR3GuestCtrlQueryFeatures(uint32_t idClient, uint64_t *pfHostFeatures);
901	VBGLR3DECL(int) VbglR3GuestCtrlMsgFilterSet(uint32_t uClientId, uint32_t uValue, uint32_t uMaskAdd, uint32_t uMaskRemove);
902	VBGLR3DECL(int) VbglR3GuestCtrlMsgReply(PVBGLR3GUESTCTRLCMDCTX pCtx, int rc);
903	VBGLR3DECL(int) VbglR3GuestCtrlMsgReplyEx(PVBGLR3GUESTCTRLCMDCTX pCtx, int rc, uint32_t uType,
904	void *pvPayload, uint32_t cbPayload);
905	VBGLR3DECL(int) VbglR3GuestCtrlMsgSkip(uint32_t idClient, int rcSkip, uint32_t idMsg);
906	VBGLR3DECL(int) VbglR3GuestCtrlMsgSkipOld(uint32_t uClientId);
907	VBGLR3DECL(int) VbglR3GuestCtrlMsgPeekWait(uint32_t idClient, uint32_t pidMsg, uint32_t pcParameters, uint64_t *pidRestoreCheck);
908	VBGLR3DECL(int) VbglR3GuestCtrlCancelPendingWaits(HGCMCLIENTID idClient);
909	/* Guest session handling. */
910	VBGLR3DECL(int) VbglR3GuestCtrlSessionPrepare(uint32_t idClient, uint32_t idSession, void const *pvKey, uint32_t cbKey);
911	VBGLR3DECL(int) VbglR3GuestCtrlSessionAccept(uint32_t idClient, uint32_t idSession, void const *pvKey, uint32_t cbKey);
912	VBGLR3DECL(int) VbglR3GuestCtrlSessionCancelPrepared(uint32_t idClient, uint32_t idSession);
913	VBGLR3DECL(int) VbglR3GuestCtrlSessionClose(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t fFlags);
914	VBGLR3DECL(int) VbglR3GuestCtrlSessionNotify(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uType, int32_t iResult);
915	VBGLR3DECL(int) VbglR3GuestCtrlSessionGetOpen(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t puProtocol, char pszUser, uint32_t cbUser,
916	char pszPassword, uint32_t cbPassword, char pszDomain, uint32_t cbDomain,
917	uint32_t pfFlags, uint32_t pidSession);
918	VBGLR3DECL(int) VbglR3GuestCtrlSessionGetClose(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t pfFlags, uint32_t pidSession);
919	/* Guest path handling. */
920	VBGLR3DECL(int) VbglR3GuestCtrlPathGetRename(PVBGLR3GUESTCTRLCMDCTX pCtx, char pszSource, uint32_t cbSource, char pszDest,
921	uint32_t cbDest, uint32_t *pfFlags);
922	VBGLR3DECL(int) VbglR3GuestCtrlPathGetUserDocuments(PVBGLR3GUESTCTRLCMDCTX pCtx);
923	VBGLR3DECL(int) VbglR3GuestCtrlPathGetUserHome(PVBGLR3GUESTCTRLCMDCTX pCtx);
924	/* Guest process execution. */
925	VBGLR3DECL(int) VbglR3GuestCtrlProcGetStart(PVBGLR3GUESTCTRLCMDCTX pCtx, char pszCmd, uint32_t cbCmd, uint32_t pfFlags,
926	char pszArgs, uint32_t cbArgs, uint32_t puNumArgs, char pszEnv, uint32_t pcbEnv,
927	uint32_t puNumEnvVars, char pszUser, uint32_t cbUser, char *pszPassword,
928	uint32_t cbPassword, uint32_t puTimeoutMS, uint32_t puPriority,
929	uint64_t puAffinity, uint32_t cbAffinity, uint32_t pcAffinity);
930	VBGLR3DECL(int) VbglR3GuestCtrlProcGetTerminate(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puPID);
931	VBGLR3DECL(int) VbglR3GuestCtrlProcGetInput(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t puPID, uint32_t pfFlags, void *pvData,
932	uint32_t cbData, uint32_t *pcbSize);
933	VBGLR3DECL(int) VbglR3GuestCtrlProcGetOutput(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t puPID, uint32_t puHandle, uint32_t *pfFlags);
934	VBGLR3DECL(int) VbglR3GuestCtrlProcGetWaitFor(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t puPID, uint32_t puWaitFlags,
935	uint32_t *puTimeoutMS);
936	/* Guest native directory handling. */
937	VBGLR3DECL(int) VbglR3GuestCtrlDirGetRemove(PVBGLR3GUESTCTRLCMDCTX pCtx, char pszPath, uint32_t cbPath, uint32_t pfFlags);
938	/* Guest native file handling. */
939	VBGLR3DECL(int) VbglR3GuestCtrlFileGetOpen(PVBGLR3GUESTCTRLCMDCTX pCtx, char pszFileName, uint32_t cbFileName, char pszOpenMode,
940	uint32_t cbOpenMode, char pszDisposition, uint32_t cbDisposition, char pszSharing,
941	uint32_t cbSharing, uint32_t puCreationMode, uint64_t puOffset);
942	VBGLR3DECL(int) VbglR3GuestCtrlFileGetClose(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puHandle);
943	VBGLR3DECL(int) VbglR3GuestCtrlFileGetRead(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t puHandle, uint32_t puToRead);
944	VBGLR3DECL(int) VbglR3GuestCtrlFileGetReadAt(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puHandle,
945	uint32_t puToRead, uint64_t poffRead);
946	VBGLR3DECL(int) VbglR3GuestCtrlFileGetWrite(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puHandle,
947	void pvData, uint32_t cbData, uint32_t pcbActual);
948	VBGLR3DECL(int) VbglR3GuestCtrlFileGetWriteAt(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t puHandle, void pvData, uint32_t cbData,
949	uint32_t pcbActual, uint64_t poffWrite);
950	VBGLR3DECL(int) VbglR3GuestCtrlFileGetSeek(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puHandle,
951	uint32_t puSeekMethod, uint64_t poffSeek);
952	VBGLR3DECL(int) VbglR3GuestCtrlFileGetTell(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puHandle);
953	VBGLR3DECL(int) VbglR3GuestCtrlFileGetSetSize(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t puHandle, uint64_t pcbNew);
954
955	/* Guest -> Host. */
956	VBGLR3DECL(int) VbglR3GuestCtrlFileCbOpen(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc, uint32_t uFileHandle);
957	VBGLR3DECL(int) VbglR3GuestCtrlFileCbClose(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc);
958	VBGLR3DECL(int) VbglR3GuestCtrlFileCbError(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc);
959	VBGLR3DECL(int) VbglR3GuestCtrlFileCbRead(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc, void *pvData, uint32_t cbData);
960	VBGLR3DECL(int) VbglR3GuestCtrlFileCbReadOffset(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc,
961	void *pvData, uint32_t cbData, int64_t offNew);
962	VBGLR3DECL(int) VbglR3GuestCtrlFileCbWrite(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc, uint32_t cbWritten);
963	VBGLR3DECL(int) VbglR3GuestCtrlFileCbWriteOffset(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc, uint32_t cbWritten, int64_t offNew);
964
965	VBGLR3DECL(int) VbglR3GuestCtrlFileCbSeek(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc, uint64_t offCurrent);
966	VBGLR3DECL(int) VbglR3GuestCtrlFileCbTell(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc, uint64_t offCurrent);
967	VBGLR3DECL(int) VbglR3GuestCtrlFileCbSetSize(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc, uint64_t cbNew);
968	VBGLR3DECL(int) VbglR3GuestCtrlProcCbStatus(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uPID, uint32_t uStatus, uint32_t fFlags,
969	void *pvData, uint32_t cbData);
970	VBGLR3DECL(int) VbglR3GuestCtrlProcCbOutput(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uPID, uint32_t uHandle, uint32_t fFlags,
971	void *pvData, uint32_t cbData);
972	VBGLR3DECL(int) VbglR3GuestCtrlProcCbStatusInput(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t u32PID, uint32_t uStatus,
973	uint32_t fFlags, uint32_t cbWritten);
974
975	/** @} */
976	# endif /* VBOX_WITH_GUEST_CONTROL defined */
977
978	/** @name Auto-logon handling
979	* @{ */
980	VBGLR3DECL(int) VbglR3AutoLogonReportStatus(VBoxGuestFacilityStatus enmStatus);
981	VBGLR3DECL(bool) VbglR3AutoLogonIsRemoteSession(void);
982	/** @} */
983
984	/** @name User credentials handling
985	* @{ */
986	VBGLR3DECL(int) VbglR3CredentialsQueryAvailability(void);
987	VBGLR3DECL(int) VbglR3CredentialsRetrieve(char ppszUser, char ppszPassword, char **ppszDomain);
988	VBGLR3DECL(int) VbglR3CredentialsRetrieveUtf16(PRTUTF16 ppwszUser, PRTUTF16 ppwszPassword, PRTUTF16 *ppwszDomain);
989	VBGLR3DECL(void) VbglR3CredentialsDestroy(char pszUser, char pszPassword, char *pszDomain, uint32_t cPasses);
990	VBGLR3DECL(void) VbglR3CredentialsDestroyUtf16(PRTUTF16 pwszUser, PRTUTF16 pwszPassword, PRTUTF16 pwszDomain,
991	uint32_t cPasses);
992	/** @} */
993
994	/** @name CPU hotplug monitor
995	* @{ */
996	VBGLR3DECL(int) VbglR3CpuHotPlugInit(void);
997	VBGLR3DECL(int) VbglR3CpuHotPlugTerm(void);
998	VBGLR3DECL(int) VbglR3CpuHotPlugWaitForEvent(VMMDevCpuEventType penmEventType, uint32_t pidCpuCore, uint32_t *pidCpuPackage);
999	/** @} */
1000
1001	/** @name Page sharing
1002	* @{ */
1003	struct VMMDEVSHAREDREGIONDESC;
1004	VBGLR3DECL(int) VbglR3RegisterSharedModule(char pszModuleName, char pszVersion, RTGCPTR64 GCBaseAddr, uint32_t cbModule,
1005	unsigned cRegions, struct VMMDEVSHAREDREGIONDESC *pRegions);
1006	VBGLR3DECL(int) VbglR3UnregisterSharedModule(char pszModuleName, char pszVersion, RTGCPTR64 GCBaseAddr, uint32_t cbModule);
1007	VBGLR3DECL(int) VbglR3CheckSharedModules(void);
1008	VBGLR3DECL(bool) VbglR3PageSharingIsEnabled(void);
1009	VBGLR3DECL(int) VbglR3PageIsShared(RTGCPTR pPage, bool pfShared, uint64_t puPageFlags);
1010	/** @} */
1011
1012	# ifdef VBOX_WITH_DRAG_AND_DROP
1013	/** @name Drag and Drop
1014	* @{ */
1015	/**
1016	* Structure containing the context required for
1017	* either retrieving or sending a HGCM guest drag'n drop
1018	* commands from or to the host.
1019	*
1020	* Note: Do not change parameter order without also
1021	* adapting all structure initializers.
1022	*/
1023	typedef struct VBGLR3GUESTDNDCMDCTX
1024	{
1025	/** @todo This struct could be handy if we want to implement
1026	* a second communication channel, e.g. via TCP/IP.
1027	* Use a union for the HGCM stuff then. */
1028
1029	/** HGCM client ID to use for communication. */
1030	uint32_t uClientID;
1031	/** The VM's current session ID. */
1032	uint64_t uSessionID;
1033	/** Protocol version to use. */
1034	uint32_t uProtocol;
1035	/** Number of parameters retrieved for the current command. */
1036	uint32_t uNumParms;
1037	/** Max chunk size (in bytes) for data transfers. */
1038	uint32_t cbMaxChunkSize;
1039	} VBGLR3GUESTDNDCMDCTX, *PVBGLR3GUESTDNDCMDCTX;
1040
1041	/**
1042	* Enumeration for specifying the DnD meta data type.
1043	*/
1044	typedef enum VBGLR3GUESTDNDMETADATATYPE
1045	{
1046	/** Unknown meta data type; don't use. */
1047	VBGLR3GUESTDNDMETADATATYPE_UNKNOWN = 0,
1048	/** Raw meta data; can be everything. */
1049	VBGLR3GUESTDNDMETADATATYPE_RAW,
1050	/** Meta data is an URI list, specifying objects. */
1051	VBGLR3GUESTDNDMETADATATYPE_URI_LIST,
1052	/** Blow the type up to 32-bit. */
1053	VBGLR3GUESTDNDMETADATATYPE_32BIT_HACK = 0x7fffffff
1054	} VBGLR3GUESTDNDMETADATATYPE;
1055
1056	/**
1057	* Structure for keeping + handling DnD meta data.
1058	*
1059	* Note: Don't treat this struct as POD object, as the union has classes in it.
1060	*/
1061	typedef struct VBGLR3GUESTDNDMETADATA
1062	{
1063	/** The meta data type the union contains. */
1064	VBGLR3GUESTDNDMETADATATYPE enmType;
1065	/** Pointer to actual meta data. */
1066	void *pvMeta;
1067	/** Size (in bytes) of meta data. */
1068	uint32_t cbMeta;
1069	} VBGLR3GUESTDNDMETADATA;
1070
1071	/** Pointer to VBGLR3GUESTDNDMETADATA. */
1072	typedef VBGLR3GUESTDNDMETADATA *PVBGLR3GUESTDNDMETADATA;
1073
1074	/** Const pointer to VBGLR3GUESTDNDMETADATA. */
1075	typedef const PVBGLR3GUESTDNDMETADATA CPVBGLR3GUESTDNDMETADATA;
1076
1077	/**
1078	* Enumeration specifying a DnD event type.
1079	*/
1080	typedef enum VBGLR3DNDEVENTTYPE
1081	{
1082	VBGLR3DNDEVENTTYPE_INVALID = 0,
1083	VBGLR3DNDEVENTTYPE_HG_ERROR = 1,
1084	VBGLR3DNDEVENTTYPE_HG_ENTER = 2,
1085	VBGLR3DNDEVENTTYPE_HG_MOVE = 3,
1086	VBGLR3DNDEVENTTYPE_HG_LEAVE = 4,
1087	VBGLR3DNDEVENTTYPE_HG_DROP = 5,
1088	VBGLR3DNDEVENTTYPE_HG_RECEIVE = 6,
1089	VBGLR3DNDEVENTTYPE_HG_CANCEL = 7,
1090	# ifdef VBOX_WITH_DRAG_AND_DROP_GH
1091	VBGLR3DNDEVENTTYPE_GH_ERROR = 100,
1092	VBGLR3DNDEVENTTYPE_GH_REQ_PENDING = 101,
1093	VBGLR3DNDEVENTTYPE_GH_DROP = 102,
1094	# endif
1095	/** Blow the type up to 32-bit. */
1096	VBGLR3DNDEVENTTYPE_32BIT_HACK = 0x7fffffff
1097	} VBGLR3DNDEVENTTYPE;
1098
1099	typedef struct VBGLR3DNDEVENT
1100	{
1101	/** The event type the union contains. */
1102	VBGLR3DNDEVENTTYPE enmType;
1103	union
1104	{
1105	struct
1106	{
1107	/** Screen ID this request belongs to. */
1108	uint32_t uScreenID;
1109	/** Format list (UTF-8, \r\n separated). */
1110	char *pszFormats;
1111	/** Size (in bytes) of pszFormats (\0 included). */
1112	uint32_t cbFormats;
1113	/** List of allowed DnD actions. */
1114	VBOXDNDACTIONLIST dndLstActionsAllowed;
1115	} HG_Enter;
1116	struct
1117	{
1118	/** Absolute X position of guest screen. */
1119	uint32_t uXpos;
1120	/** Absolute Y position of guest screen. */
1121	uint32_t uYpos;
1122	/** Default DnD action. */
1123	VBOXDNDACTION dndActionDefault;
1124	} HG_Move;
1125	struct
1126	{
1127	/** Absolute X position of guest screen. */
1128	uint32_t uXpos;
1129	/** Absolute Y position of guest screen. */
1130	uint32_t uYpos;
1131	/** Default DnD action. */
1132	VBOXDNDACTION dndActionDefault;
1133	} HG_Drop;
1134	struct
1135	{
1136	/** Meta data for the operation. */
1137	VBGLR3GUESTDNDMETADATA Meta;
1138	} HG_Received;
1139	struct
1140	{
1141	/** IPRT-style error code. */
1142	int rc;
1143	} HG_Error;
1144	# ifdef VBOX_WITH_DRAG_AND_DROP_GH
1145	struct
1146	{
1147	/** Screen ID this request belongs to. */
1148	uint32_t uScreenID;
1149	} GH_IsPending;
1150	struct
1151	{
1152	/** Requested format by the host. */
1153	char *pszFormat;
1154	/** Size (in bytes) of pszFormat (\0 included). */
1155	uint32_t cbFormat;
1156	/** Requested DnD action. */
1157	VBOXDNDACTION dndActionRequested;
1158	} GH_Drop;
1159	# endif
1160	} u;
1161	} VBGLR3DNDEVENT;
1162	typedef VBGLR3DNDEVENT *PVBGLR3DNDEVENT;
1163	typedef const PVBGLR3DNDEVENT CPVBGLR3DNDEVENT;
1164
1165	VBGLR3DECL(int) VbglR3DnDConnect(PVBGLR3GUESTDNDCMDCTX pCtx);
1166	VBGLR3DECL(int) VbglR3DnDDisconnect(PVBGLR3GUESTDNDCMDCTX pCtx);
1167
1168	VBGLR3DECL(int) VbglR3DnDEventGetNext(PVBGLR3GUESTDNDCMDCTX pCtx, PVBGLR3DNDEVENT *ppEvent);
1169	VBGLR3DECL(void) VbglR3DnDEventFree(PVBGLR3DNDEVENT pEvent);
1170
1171	VBGLR3DECL(int) VbglR3DnDHGSendAckOp(PVBGLR3GUESTDNDCMDCTX pCtx, VBOXDNDACTION dndAction);
1172	VBGLR3DECL(int) VbglR3DnDHGSendReqData(PVBGLR3GUESTDNDCMDCTX pCtx, const char *pcszFormat);
1173	VBGLR3DECL(int) VbglR3DnDHGSendProgress(PVBGLR3GUESTDNDCMDCTX pCtx, uint32_t uStatus, uint8_t uPercent, int rcErr);
1174	# ifdef VBOX_WITH_DRAG_AND_DROP_GH
1175	VBGLR3DECL(int) VbglR3DnDGHSendAckPending(PVBGLR3GUESTDNDCMDCTX pCtx, VBOXDNDACTION dndActionDefault, VBOXDNDACTIONLIST dndLstActionsAllowed, const char* pcszFormats, uint32_t cbFormats);
1176	VBGLR3DECL(int) VbglR3DnDGHSendData(PVBGLR3GUESTDNDCMDCTX pCtx, const char pszFormat, void pvData, uint32_t cbData);
1177	VBGLR3DECL(int) VbglR3DnDGHSendError(PVBGLR3GUESTDNDCMDCTX pCtx, int rcOp);
1178	# endif /* VBOX_WITH_DRAG_AND_DROP_GH */
1179	/** @} */
1180	# endif /* VBOX_WITH_DRAG_AND_DROP */
1181
1182	/* Generic Host Channel Service. */
1183	VBGLR3DECL(int) VbglR3HostChannelInit(uint32_t *pidClient);
1184	VBGLR3DECL(void) VbglR3HostChannelTerm(uint32_t idClient);
1185	VBGLR3DECL(int) VbglR3HostChannelAttach(uint32_t *pu32ChannelHandle, uint32_t u32HGCMClientId,
1186	const char *pszName, uint32_t u32Flags);
1187	VBGLR3DECL(void) VbglR3HostChannelDetach(uint32_t u32ChannelHandle, uint32_t u32HGCMClientId);
1188	VBGLR3DECL(int) VbglR3HostChannelSend(uint32_t u32ChannelHandle, uint32_t u32HGCMClientId,
1189	void *pvData, uint32_t cbData);
1190	VBGLR3DECL(int) VbglR3HostChannelRecv(uint32_t u32ChannelHandle, uint32_t u32HGCMClientId,
1191	void *pvData, uint32_t cbData,
1192	uint32_t pu32SizeReceived, uint32_t pu32SizeRemaining);
1193	VBGLR3DECL(int) VbglR3HostChannelControl(uint32_t u32ChannelHandle, uint32_t u32HGCMClientId,
1194	uint32_t u32Code, void *pvParm, uint32_t cbParm,
1195	void pvData, uint32_t cbData, uint32_t pu32SizeDataReturned);
1196	VBGLR3DECL(int) VbglR3HostChannelEventWait(uint32_t *pu32ChannelHandle, uint32_t u32HGCMClientId,
1197	uint32_t pu32EventId, void pvParm, uint32_t cbParm,
1198	uint32_t *pu32SizeReturned);
1199	VBGLR3DECL(int) VbglR3HostChannelEventCancel(uint32_t u32ChannelHandle, uint32_t u32HGCMClientId);
1200	VBGLR3DECL(int) VbglR3HostChannelQuery(const char *pszName, uint32_t u32HGCMClientId, uint32_t u32Code,
1201	void pvParm, uint32_t cbParm, void pvData, uint32_t cbData,
1202	uint32_t *pu32SizeDataReturned);
1203
1204	/** @name Mode hint storage
1205	* @{ */
1206	VBGLR3DECL(int) VbglR3ReadVideoMode(unsigned cDisplay, unsigned *cx,
1207	unsigned cy, unsigned cBPP, unsigned *x,
1208	unsigned y, unsigned fEnabled);
1209	VBGLR3DECL(int) VbglR3WriteVideoMode(unsigned cDisplay, unsigned cx,
1210	unsigned cy, unsigned cBPP, unsigned x,
1211	unsigned y, unsigned fEnabled);
1212	/** @} */
1213
1214	/** @name Generic HGCM
1215	* @{ */
1216	VBGLR3DECL(int) VbglR3HGCMConnect(const char pszServiceName, HGCMCLIENTID pidClient);
1217	VBGLR3DECL(int) VbglR3HGCMDisconnect(HGCMCLIENTID idClient);
1218	struct VBGLIOCHGCMCALL;
1219	VBGLR3DECL(int) VbglR3HGCMCall(struct VBGLIOCHGCMCALL *pInfo, size_t cbInfo);
1220	/** @} */
1221
1222	#endif /* IN_RING3 */
1223	/** @} */
1224
1225	RT_C_DECLS_END
1226
1227	/** @} */
1228
1229	#endif /* !VBOX_INCLUDED_VBoxGuestLib_h */
1230

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

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

Download in other formats: