VirtualBox

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

Last change on this file since 73768 was 72627, checked in by vboxsync, 6 years ago

Additions: relicence components needed for Linux shared folders to MIT.
bugref:9109: Shared folders: update to match in-kernel code more closely
This change makes the code on which the Linux kernel shared folder patch is
based MIT-licenced, so that the version in the Linux kernel can be too. This
would make it easier to move code back and forth.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 41.4 KB
Line 
1/** @file
2 * VBoxGuestLib - VirtualBox Guest Additions Library.
3 */
4
5/*
6 * Copyright (C) 2006-2018 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_VBoxGuestLib_h
31#define ___VBox_VBoxGuestLib_h
32
33#include <VBox/types.h>
34#include <VBox/VMMDev.h>
35#include <VBox/VBoxGuestCoreTypes.h>
36
37/** @defgroup grp_vboxguest_lib VirtualBox Guest Additions Library
38 * @ingroup grp_vboxguest
39 * @{
40 */
41
42/** @page pg_guest_lib VirtualBox Guest Library
43 *
44 * This is a library for abstracting the additions driver interface. There are
45 * multiple versions of the library depending on the context. The main
46 * distinction is between kernel and user mode where the interfaces are very
47 * different.
48 *
49 *
50 * @section sec_guest_lib_ring0 Ring-0
51 *
52 * In ring-0 there are two version:
53 * - VBOX_LIB_VBGL_R0_BASE / VBoxGuestR0LibBase for the VBoxGuest main driver,
54 * who is responsible for managing the VMMDev virtual hardware.
55 * - VBOX_LIB_VBGL_R0 / VBoxGuestR0Lib for other (client) guest drivers.
56 *
57 *
58 * The library source code and the header have a define VBGL_VBOXGUEST, which is
59 * defined for VBoxGuest and undefined for other drivers. Drivers must choose
60 * right library in their makefiles and set VBGL_VBOXGUEST accordingly.
61 *
62 * The libraries consists of:
63 * - common code to be used by both VBoxGuest and other drivers;
64 * - VBoxGuest specific code;
65 * - code for other drivers which communicate with VBoxGuest via an IOCTL.
66 *
67 *
68 * @section sec_guest_lib_ring3 Ring-3
69 *
70 * There are more variants of the library here:
71 * - VBOX_LIB_VBGL_R3 / VBoxGuestR3Lib for programs.
72 * - VBOX_LIB_VBGL_R3_XFREE86 / VBoxGuestR3LibXFree86 for old style XFree
73 * drivers which uses special loader and or symbol resolving strategy.
74 * - VBOX_LIB_VBGL_R3_SHARED / VBoxGuestR3LibShared for shared objects / DLLs /
75 * Dylibs.
76 *
77 */
78
79RT_C_DECLS_BEGIN
80
81/** HGCM client ID.
82 * @todo Promote to VBox/types.h */
83typedef uint32_t HGCMCLIENTID;
84
85
86/** @defgroup grp_vboxguest_lib_r0 Ring-0 interface.
87 * @{
88 */
89#ifdef IN_RING0
90/** @def DECLR0VBGL
91 * Declare a VBGL ring-0 API with the right calling convention and visibilitiy.
92 * @param type Return type. */
93# ifdef RT_OS_DARWIN /** @todo probably apply to all, but don't want a forest fire on our hands right now. */
94# define DECLR0VBGL(type) DECLHIDDEN(type) VBOXCALL
95# else
96# define DECLR0VBGL(type) type VBOXCALL
97# endif
98# define DECLVBGL(type) DECLR0VBGL(type)
99
100
101/**
102 * The library initialization function to be used by the main VBoxGuest driver.
103 *
104 * @return VBox status code.
105 */
106DECLR0VBGL(int) VbglR0InitPrimary(RTIOPORT portVMMDev, struct VMMDevMemory *pVMMDevMemory);
107
108/**
109 * The library termination function to be used by the main VBoxGuest driver.
110 *
111 * @author bird (2017-08-23)
112 */
113DECLR0VBGL(void) VbglR0TerminatePrimary(void);
114
115/**
116 * The library initialization function to be used by all drivers
117 * other than the main VBoxGuest system driver.
118 *
119 * @return VBox status code.
120 */
121DECLR0VBGL(int) VbglR0InitClient(void);
122
123/**
124 * The library termination function.
125 */
126DECLR0VBGL(void) VbglR0TerminateClient(void);
127
128
129/** @name The IDC Client Interface
130 * @{
131 */
132
133/**
134 * Inter-Driver Communication Handle.
135 */
136typedef union VBGLIDCHANDLE
137{
138 /** Padding for opaque usage.
139 * Must be greater or equal in size than the private struct. */
140 void *apvPadding[4];
141#ifdef VBGLIDCHANDLEPRIVATE_DECLARED
142 /** The private view. */
143 struct VBGLIDCHANDLEPRIVATE s;
144#endif
145} VBGLIDCHANDLE;
146/** Pointer to a handle. */
147typedef VBGLIDCHANDLE *PVBGLIDCHANDLE;
148
149DECLR0VBGL(int) VbglR0IdcOpen(PVBGLIDCHANDLE pHandle, uint32_t uReqVersion, uint32_t uMinVersion,
150 uint32_t *puSessionVersion, uint32_t *puDriverVersion, uint32_t *puDriverRevision);
151struct VBGLREQHDR;
152DECLR0VBGL(int) VbglR0IdcCallRaw(PVBGLIDCHANDLE pHandle, uintptr_t uReq, struct VBGLREQHDR *pReqHdr, uint32_t cbReq);
153DECLR0VBGL(int) VbglR0IdcCall(PVBGLIDCHANDLE pHandle, uintptr_t uReq, struct VBGLREQHDR *pReqHdr, uint32_t cbReq);
154DECLR0VBGL(int) VbglR0IdcClose(PVBGLIDCHANDLE pHandle);
155
156/** @} */
157
158
159/** @name Generic request functions.
160 * @{
161 */
162
163/**
164 * Allocate memory for generic request and initialize the request header.
165 *
166 * @returns VBox status code.
167 * @param ppReq Where to return the pointer to the allocated memory.
168 * @param cbReq Size of memory block required for the request.
169 * @param enmReqType the generic request type.
170 */
171# if defined(___VBox_VMMDev_h) || defined(DOXYGEN_RUNNING)
172DECLR0VBGL(int) VbglR0GRAlloc(struct VMMDevRequestHeader **ppReq, size_t cbReq, VMMDevRequestType enmReqType);
173# else
174DECLR0VBGL(int) VbglR0GRAlloc(struct VMMDevRequestHeader **ppReq, size_t cbReq, int32_t enmReqType);
175# endif
176
177/**
178 * Perform the generic request.
179 *
180 * @param pReq pointer the request structure.
181 *
182 * @return VBox status code.
183 */
184DECLR0VBGL(int) VbglR0GRPerform(struct VMMDevRequestHeader *pReq);
185
186/**
187 * Free the generic request memory.
188 *
189 * @param pReq pointer the request structure.
190 *
191 * @return VBox status code.
192 */
193DECLR0VBGL(void) VbglR0GRFree(struct VMMDevRequestHeader *pReq);
194
195/**
196 * Verify the generic request header.
197 *
198 * @param pReq pointer the request header structure.
199 * @param cbReq size of the request memory block. It should be equal to the request size
200 * for fixed size requests. It can be greater than the request size for
201 * variable size requests.
202 *
203 * @return VBox status code.
204 */
205DECLR0VBGL(int) VbglGR0Verify(const struct VMMDevRequestHeader *pReq, size_t cbReq);
206
207/** @} */
208
209# ifdef VBOX_WITH_HGCM
210struct VBGLIOCHGCMCALL;
211
212# ifdef VBGL_VBOXGUEST
213
214/**
215 * Callback function called from HGCM helpers when a wait for request
216 * completion IRQ is required.
217 *
218 * @returns VINF_SUCCESS, VERR_INTERRUPT or VERR_TIMEOUT.
219 * @param pvData VBoxGuest pointer to be passed to callback.
220 * @param u32Data VBoxGuest 32 bit value to be passed to callback.
221 */
222typedef DECLCALLBACK(int) FNVBGLHGCMCALLBACK(VMMDevHGCMRequestHeader *pHeader, void *pvData, uint32_t u32Data);
223/** Pointer to a FNVBGLHGCMCALLBACK. */
224typedef FNVBGLHGCMCALLBACK *PFNVBGLHGCMCALLBACK;
225
226/**
227 * Perform a connect request.
228 *
229 * That is locate required service and obtain a client identifier for future
230 * access.
231 *
232 * @note This function can NOT handle cancelled requests!
233 *
234 * @param pLoc The service to connect to.
235 * @param fRequestor VMMDEV_REQUESTOR_XXX.
236 * @param pidClient Where to return the client ID on success.
237 * @param pfnAsyncCallback Required pointer to function that is calledwhen
238 * host returns VINF_HGCM_ASYNC_EXECUTE. VBoxGuest
239 * implements waiting for an IRQ in this function.
240 * @param pvAsyncData An arbitrary VBoxGuest pointer to be passed to callback.
241 * @param u32AsyncData An arbitrary VBoxGuest 32 bit value to be passed to callback.
242 *
243 * @return VBox status code.
244 */
245DECLR0VBGL(int) VbglR0HGCMInternalConnect(HGCMServiceLocation const *pLoc, uint32_t fRequestor, HGCMCLIENTID *pidClient,
246 PFNVBGLHGCMCALLBACK pfnAsyncCallback, void *pvAsyncData, uint32_t u32AsyncData);
247
248
249/**
250 * Perform a disconnect request.
251 *
252 * That is tell the host that the client will not call the service anymore.
253 *
254 * @note This function can NOT handle cancelled requests!
255 *
256 * @param idClient The client ID to disconnect.
257 * @param fRequestor VMMDEV_REQUESTOR_XXX.
258 * @param pfnAsyncCallback Required pointer to function that is called when
259 * host returns VINF_HGCM_ASYNC_EXECUTE. VBoxGuest
260 * implements waiting for an IRQ in this function.
261 * @param pvAsyncData An arbitrary VBoxGuest pointer to be passed to callback.
262 * @param u32AsyncData An arbitrary VBoxGuest 32 bit value to be passed to
263 * callback.
264 *
265 * @return VBox status code.
266 */
267
268DECLR0VBGL(int) VbglR0HGCMInternalDisconnect(HGCMCLIENTID idClient, uint32_t fRequestor,
269 PFNVBGLHGCMCALLBACK pfnAsyncCallback, void *pvAsyncData, uint32_t u32AsyncData);
270
271/** Call a HGCM service.
272 *
273 * @note This function can deal with cancelled requests.
274 *
275 * @param pCallInfo The request data.
276 * @param fFlags Flags, see VBGLR0_HGCMCALL_F_XXX.
277 * @param fRequestor VMMDEV_REQUESTOR_XXX.
278 * @param pfnAsyncCallback Required pointer to function that is called when
279 * host returns VINF_HGCM_ASYNC_EXECUTE. VBoxGuest
280 * implements waiting for an IRQ in this function.
281 * @param pvAsyncData An arbitrary VBoxGuest pointer to be passed to callback.
282 * @param u32AsyncData An arbitrary VBoxGuest 32 bit value to be passed to callback.
283 *
284 * @return VBox status code.
285 */
286DECLR0VBGL(int) VbglR0HGCMInternalCall(struct VBGLIOCHGCMCALL *pCallInfo, uint32_t cbCallInfo, uint32_t fFlags, uint32_t fRequestor,
287 PFNVBGLHGCMCALLBACK pfnAsyncCallback, void *pvAsyncData, uint32_t u32AsyncData);
288
289/** Call a HGCM service. (32 bits packet structure in a 64 bits guest)
290 *
291 * @note This function can deal with cancelled requests.
292 *
293 * @param pCallInfo The request data.
294 * @param fFlags Flags, see VBGLR0_HGCMCALL_F_XXX.
295 * @param fRequestor VMMDEV_REQUESTOR_XXX.
296 * @param pfnAsyncCallback Required pointer to function that is called when
297 * host returns VINF_HGCM_ASYNC_EXECUTE. VBoxGuest
298 * implements waiting for an IRQ in this function.
299 * @param pvAsyncData An arbitrary VBoxGuest pointer to be passed to callback.
300 * @param u32AsyncData An arbitrary VBoxGuest 32 bit value to be passed to callback.
301 *
302 * @return VBox status code.
303 */
304DECLR0VBGL(int) VbglR0HGCMInternalCall32(struct VBGLIOCHGCMCALL *pCallInfo, uint32_t cbCallInfo, uint32_t fFlags, uint32_t fRequestor,
305 PFNVBGLHGCMCALLBACK pfnAsyncCallback, void *pvAsyncData, uint32_t u32AsyncData);
306
307/** @name VbglR0HGCMInternalCall flags
308 * @{ */
309/** User mode request.
310 * Indicates that only user mode addresses are permitted as parameters. */
311#define VBGLR0_HGCMCALL_F_USER UINT32_C(0)
312/** Kernel mode request.
313 * Indicates that kernel mode addresses are permitted as parameters. Whether or
314 * not user mode addresses are permitted is, unfortunately, OS specific. The
315 * following OSes allows user mode addresses: Windows, TODO.
316 */
317#define VBGLR0_HGCMCALL_F_KERNEL UINT32_C(1)
318/** Mode mask. */
319#define VBGLR0_HGCMCALL_F_MODE_MASK UINT32_C(1)
320/** @} */
321
322# else /* !VBGL_VBOXGUEST */
323
324struct VBGLHGCMHANDLEDATA;
325typedef struct VBGLHGCMHANDLEDATA *VBGLHGCMHANDLE;
326
327/** @name HGCM functions
328 * @{
329 */
330
331/**
332 * Initializes HGCM in the R0 guest library. Must be called before any HGCM
333 * connections are made. Is called by VbglInitClient().
334 *
335 * @return VBox status code.
336 */
337DECLR0VBGL(int) VbglR0HGCMInit(void);
338
339/**
340 * Terminates HGCM in the R0 guest library. Is called by VbglTerminate().
341 *
342 * @return VBox status code.
343 */
344DECLR0VBGL(int) VbglR0HGCMTerminate(void);
345
346/**
347 * Connect to a service.
348 *
349 * @param pHandle Pointer to variable that will hold a handle to be used
350 * further in VbglHGCMCall and VbglHGCMClose.
351 * @param pszServiceName The service to connect to.
352 * @param pidClient Where to return the client ID for the connection.
353 *
354 * @return VBox status code.
355 *
356 * @todo consider baking the client Id into the handle.
357 */
358DECLR0VBGL(int) VbglR0HGCMConnect(VBGLHGCMHANDLE *pHandle, const char *pszServiceName, HGCMCLIENTID *pidClient);
359
360/**
361 * Connect to a service.
362 *
363 * @param handle Handle of the connection.
364 * @param idClient The ID of the client connection.
365 *
366 * @return VBox status code.
367 *
368 * @todo consider baking the client Id into the handle.
369 */
370DECLR0VBGL(int) VbglR0HGCMDisconnect(VBGLHGCMHANDLE handle, HGCMCLIENTID idClient);
371
372/**
373 * Call to a service, returning only the I/O control status code.
374 *
375 * @param handle Handle of the connection.
376 * @param pData Call request information structure, including function parameters.
377 * @param cbData Length in bytes of data.
378 *
379 * @return VBox status code.
380 */
381DECLR0VBGL(int) VbglR0HGCMCallRaw(VBGLHGCMHANDLE handle, struct VBGLIOCHGCMCALL*pData, uint32_t cbData);
382
383/**
384 * Call to a service, returning the HGCM status code.
385 *
386 * @param handle Handle of the connection.
387 * @param pData Call request information structure, including function parameters.
388 * @param cbData Length in bytes of data.
389 *
390 * @return VBox status code. Either the I/O control status code if that failed,
391 * or the HGCM status code (pData->Hdr.rc).
392 */
393DECLR0VBGL(int) VbglR0HGCMCall(VBGLHGCMHANDLE handle, struct VBGLIOCHGCMCALL*pData, uint32_t cbData);
394
395/**
396 * Call to a service with user-mode data received by the calling driver from the User-Mode process.
397 * The call must be done in the context of a calling process.
398 *
399 * @param handle Handle of the connection.
400 * @param pData Call request information structure, including function parameters.
401 * @param cbData Length in bytes of data.
402 *
403 * @return VBox status code.
404 */
405DECLR0VBGL(int) VbglR0HGCMCallUserDataRaw(VBGLHGCMHANDLE handle, struct VBGLIOCHGCMCALL*pData, uint32_t cbData);
406
407/** @} */
408
409/** @name Undocumented helpers for talking to the Chromium OpenGL Host Service
410 * @{ */
411typedef VBGLHGCMHANDLE VBGLCRCTLHANDLE;
412DECLR0VBGL(int) VbglR0CrCtlCreate(VBGLCRCTLHANDLE *phCtl);
413DECLR0VBGL(int) VbglR0CrCtlDestroy(VBGLCRCTLHANDLE hCtl);
414DECLR0VBGL(int) VbglR0CrCtlConConnect(VBGLCRCTLHANDLE hCtl, HGCMCLIENTID *pidClient);
415DECLR0VBGL(int) VbglR0CrCtlConDisconnect(VBGLCRCTLHANDLE hCtl, HGCMCLIENTID idClient);
416struct VBGLIOCHGCMCALL;
417DECLR0VBGL(int) VbglR0CrCtlConCallRaw(VBGLCRCTLHANDLE hCtl, struct VBGLIOCHGCMCALL *pCallInfo, int cbCallInfo);
418DECLR0VBGL(int) VbglR0CrCtlConCall(VBGLCRCTLHANDLE hCtl, struct VBGLIOCHGCMCALL *pCallInfo, int cbCallInfo);
419DECLR0VBGL(int) VbglR0CrCtlConCallUserDataRaw(VBGLCRCTLHANDLE hCtl, struct VBGLIOCHGCMCALL *pCallInfo, int cbCallInfo);
420/** @} */
421
422# endif /* !VBGL_VBOXGUEST */
423
424# endif /* VBOX_WITH_HGCM */
425
426
427/**
428 * Initialize the heap.
429 *
430 * @returns VBox status code.
431 */
432DECLR0VBGL(int) VbglR0PhysHeapInit(void);
433
434/**
435 * Shutdown the heap.
436 */
437DECLR0VBGL(void) VbglR0PhysHeapTerminate(void);
438
439/**
440 * Allocate a memory block.
441 *
442 * @returns Virtual address of the allocated memory block.
443 * @param cbSize Size of block to be allocated.
444 */
445DECLR0VBGL(void *) VbglR0PhysHeapAlloc(uint32_t cbSize);
446
447/**
448 * Get physical address of memory block pointed by the virtual address.
449 *
450 * @note WARNING!
451 * The function does not acquire the Heap mutex!
452 * When calling the function make sure that the pointer is a valid one and
453 * is not being deallocated. This function can NOT be used for verifying
454 * if the given pointer is a valid one allocated from the heap.
455 *
456 * @param pv Virtual address of memory block.
457 * @returns Physical address of the memory block.
458 */
459DECLR0VBGL(uint32_t) VbglR0PhysHeapGetPhysAddr(void *pv);
460
461/**
462 * Free a memory block.
463 *
464 * @param pv Virtual address of memory block.
465 */
466DECLR0VBGL(void) VbglR0PhysHeapFree(void *pv);
467
468DECLR0VBGL(int) VbglR0QueryVMMDevMemory(struct VMMDevMemory **ppVMMDevMemory);
469DECLR0VBGL(bool) VbglR0CanUsePhysPageList(void);
470
471# ifndef VBOX_GUEST
472/** @name Mouse
473 * @{ */
474DECLR0VBGL(int) VbglR0SetMouseNotifyCallback(PFNVBOXGUESTMOUSENOTIFY pfnNotify, void *pvUser);
475DECLR0VBGL(int) VbglR0GetMouseStatus(uint32_t *pfFeatures, uint32_t *px, uint32_t *py);
476DECLR0VBGL(int) VbglR0SetMouseStatus(uint32_t fFeatures);
477/** @} */
478# endif /* VBOX_GUEST */
479
480#endif /* IN_RING0 */
481
482/** @} */
483
484
485/** @defgroup grp_vboxguest_lib_r3 Ring-3 interface.
486 * @{
487 */
488#ifdef IN_RING3
489
490/** @def VBGLR3DECL
491 * Ring 3 VBGL declaration.
492 * @param type The return type of the function declaration.
493 */
494# define VBGLR3DECL(type) DECLHIDDEN(type) VBOXCALL
495
496/** @name General-purpose functions
497 * @{ */
498VBGLR3DECL(int) VbglR3Init(void);
499VBGLR3DECL(int) VbglR3InitUser(void);
500VBGLR3DECL(void) VbglR3Term(void);
501# ifdef ___iprt_time_h
502VBGLR3DECL(int) VbglR3GetHostTime(PRTTIMESPEC pTime);
503# endif
504VBGLR3DECL(int) VbglR3InterruptEventWaits(void);
505VBGLR3DECL(int) VbglR3WriteLog(const char *pch, size_t cch);
506VBGLR3DECL(int) VbglR3CtlFilterMask(uint32_t fOr, uint32_t fNot);
507VBGLR3DECL(int) VbglR3Daemonize(bool fNoChDir, bool fNoClose, bool fRespawn, unsigned *pcRespawn);
508VBGLR3DECL(int) VbglR3PidFile(const char *pszPath, PRTFILE phFile);
509VBGLR3DECL(void) VbglR3ClosePidFile(const char *pszPath, RTFILE hFile);
510VBGLR3DECL(int) VbglR3SetGuestCaps(uint32_t fOr, uint32_t fNot);
511VBGLR3DECL(int) VbglR3AcquireGuestCaps(uint32_t fOr, uint32_t fNot, bool fConfig);
512VBGLR3DECL(int) VbglR3WaitEvent(uint32_t fMask, uint32_t cMillies, uint32_t *pfEvents);
513
514VBGLR3DECL(int) VbglR3ReportAdditionsStatus(VBoxGuestFacilityType Facility, VBoxGuestFacilityStatus StatusCurrent,
515 uint32_t fFlags);
516VBGLR3DECL(int) VbglR3GetAdditionsVersion(char **ppszVer, char **ppszVerEx, char **ppszRev);
517VBGLR3DECL(int) VbglR3GetAdditionsInstallationPath(char **ppszPath);
518VBGLR3DECL(int) VbglR3GetSessionId(uint64_t *pu64IdSession);
519
520/** @} */
521
522/** @name Shared clipboard
523 * @{ */
524VBGLR3DECL(int) VbglR3ClipboardConnect(HGCMCLIENTID *pidClient);
525VBGLR3DECL(int) VbglR3ClipboardDisconnect(HGCMCLIENTID idClient);
526VBGLR3DECL(int) VbglR3ClipboardGetHostMsg(HGCMCLIENTID idClient, uint32_t *pMsg, uint32_t *pfFormats);
527VBGLR3DECL(int) VbglR3ClipboardReadData(HGCMCLIENTID idClient, uint32_t fFormat, void *pv, uint32_t cb, uint32_t *pcb);
528VBGLR3DECL(int) VbglR3ClipboardReportFormats(HGCMCLIENTID idClient, uint32_t fFormats);
529VBGLR3DECL(int) VbglR3ClipboardWriteData(HGCMCLIENTID idClient, uint32_t fFormat, void *pv, uint32_t cb);
530/** @} */
531
532/** @name Seamless mode
533 * @{ */
534VBGLR3DECL(int) VbglR3SeamlessSetCap(bool fState);
535VBGLR3DECL(int) VbglR3SeamlessWaitEvent(VMMDevSeamlessMode *pMode);
536VBGLR3DECL(int) VbglR3SeamlessSendRects(uint32_t cRects, PRTRECT pRects);
537VBGLR3DECL(int) VbglR3SeamlessGetLastEvent(VMMDevSeamlessMode *pMode);
538
539/** @} */
540
541/** @name Mouse
542 * @{ */
543VBGLR3DECL(int) VbglR3GetMouseStatus(uint32_t *pfFeatures, uint32_t *px, uint32_t *py);
544VBGLR3DECL(int) VbglR3SetMouseStatus(uint32_t fFeatures);
545/** @} */
546
547/** @name Video
548 * @{ */
549VBGLR3DECL(int) VbglR3VideoAccelEnable(bool fEnable);
550VBGLR3DECL(int) VbglR3VideoAccelFlush(void);
551VBGLR3DECL(int) VbglR3SetPointerShape(uint32_t fFlags, uint32_t xHot, uint32_t yHot, uint32_t cx, uint32_t cy,
552 const void *pvImg, size_t cbImg);
553VBGLR3DECL(int) VbglR3SetPointerShapeReq(struct VMMDevReqMousePointer *pReq);
554/** @} */
555
556/** @name Display
557 * @{ */
558/** The folder for the video mode hint unix domain socket on Unix-like guests.
559 * @note This can be safely changed as all users are rebuilt in lock-step. */
560#define VBGLR3HOSTDISPSOCKETPATH "/tmp/.VBoxService"
561/** The path to the video mode hint unix domain socket on Unix-like guests. */
562#define VBGLR3HOSTDISPSOCKET VBGLR3VIDEOMODEHINTSOCKETPATH "/VideoModeHint"
563
564/** The folder for saving video mode hints to between sessions. */
565#define VBGLR3HOSTDISPSAVEDMODEPATH "/var/lib/VBoxGuestAdditions"
566/** The path to the file for saving video mode hints to between sessions. */
567#define VBGLR3HOSTDISPSAVEDMODE VBGLR3HOSTDISPSAVEDMODEPATH "/SavedVideoModes"
568
569VBGLR3DECL(int) VbglR3GetDisplayChangeRequest(uint32_t *pcx, uint32_t *pcy, uint32_t *pcBits, uint32_t *piDisplay,
570 uint32_t *pdx, uint32_t *pdy, bool *pfEnabled, bool *pfChangeOrigin, bool fAck);
571VBGLR3DECL(int) VbglR3GetDisplayChangeRequestMulti(uint32_t cDisplaysIn, uint32_t *pcDisplaysOut,
572 VMMDevDisplayDef *paDisplays, bool fAck);
573VBGLR3DECL(bool) VbglR3HostLikesVideoMode(uint32_t cx, uint32_t cy, uint32_t cBits);
574VBGLR3DECL(int) VbglR3VideoModeGetHighestSavedScreen(unsigned *pcScreen);
575VBGLR3DECL(int) VbglR3SaveVideoMode(unsigned cScreen, unsigned cx, unsigned cy, unsigned cBits,
576 unsigned x, unsigned y, bool fEnabled);
577VBGLR3DECL(int) VbglR3RetrieveVideoMode(unsigned cScreen, unsigned *pcx, unsigned *pcy, unsigned *pcBits,
578 unsigned *px, unsigned *py, bool *pfEnabled);
579/** @} */
580
581/** @name VRDP
582 * @{ */
583VBGLR3DECL(int) VbglR3VrdpGetChangeRequest(bool *pfActive, uint32_t *puExperienceLevel);
584/** @} */
585
586/** @name VM Statistics
587 * @{ */
588VBGLR3DECL(int) VbglR3StatQueryInterval(uint32_t *pu32Interval);
589# if defined(___VBox_VMMDev_h) || defined(DOXYGEN_RUNNING)
590VBGLR3DECL(int) VbglR3StatReport(VMMDevReportGuestStats *pReq);
591# endif
592/** @} */
593
594/** @name Memory ballooning
595 * @{ */
596VBGLR3DECL(int) VbglR3MemBalloonRefresh(uint32_t *pcChunks, bool *pfHandleInR3);
597VBGLR3DECL(int) VbglR3MemBalloonChange(void *pv, bool fInflate);
598/** @} */
599
600/** @name Core Dump
601 * @{ */
602VBGLR3DECL(int) VbglR3WriteCoreDump(void);
603
604/** @} */
605
606# ifdef VBOX_WITH_GUEST_PROPS
607/** @name Guest properties
608 * @{ */
609/** @todo Docs. */
610typedef struct VBGLR3GUESTPROPENUM VBGLR3GUESTPROPENUM;
611/** @todo Docs. */
612typedef VBGLR3GUESTPROPENUM *PVBGLR3GUESTPROPENUM;
613VBGLR3DECL(int) VbglR3GuestPropConnect(uint32_t *pidClient);
614VBGLR3DECL(int) VbglR3GuestPropDisconnect(HGCMCLIENTID idClient);
615VBGLR3DECL(int) VbglR3GuestPropWrite(HGCMCLIENTID idClient, const char *pszName, const char *pszValue, const char *pszFlags);
616VBGLR3DECL(int) VbglR3GuestPropWriteValue(HGCMCLIENTID idClient, const char *pszName, const char *pszValue);
617VBGLR3DECL(int) VbglR3GuestPropWriteValueV(HGCMCLIENTID idClient, const char *pszName,
618 const char *pszValueFormat, va_list va) RT_IPRT_FORMAT_ATTR(3, 0);
619VBGLR3DECL(int) VbglR3GuestPropWriteValueF(HGCMCLIENTID idClient, const char *pszName,
620 const char *pszValueFormat, ...) RT_IPRT_FORMAT_ATTR(3, 4);
621VBGLR3DECL(int) VbglR3GuestPropRead(HGCMCLIENTID idClient, const char *pszName, void *pvBuf, uint32_t cbBuf, char **ppszValue,
622 uint64_t *pu64Timestamp, char **ppszFlags, uint32_t *pcbBufActual);
623VBGLR3DECL(int) VbglR3GuestPropReadValue(uint32_t ClientId, const char *pszName, char *pszValue, uint32_t cchValue,
624 uint32_t *pcchValueActual);
625VBGLR3DECL(int) VbglR3GuestPropReadValueAlloc(HGCMCLIENTID idClient, const char *pszName, char **ppszValue);
626VBGLR3DECL(void) VbglR3GuestPropReadValueFree(char *pszValue);
627VBGLR3DECL(int) VbglR3GuestPropEnumRaw(HGCMCLIENTID idClient, const char *paszPatterns, char *pcBuf, uint32_t cbBuf,
628 uint32_t *pcbBufActual);
629VBGLR3DECL(int) VbglR3GuestPropEnum(HGCMCLIENTID idClient, char const * const *ppaszPatterns, uint32_t cPatterns,
630 PVBGLR3GUESTPROPENUM *ppHandle, char const **ppszName, char const **ppszValue,
631 uint64_t *pu64Timestamp, char const **ppszFlags);
632VBGLR3DECL(int) VbglR3GuestPropEnumNext(PVBGLR3GUESTPROPENUM pHandle, char const **ppszName, char const **ppszValue,
633 uint64_t *pu64Timestamp, char const **ppszFlags);
634VBGLR3DECL(void) VbglR3GuestPropEnumFree(PVBGLR3GUESTPROPENUM pHandle);
635VBGLR3DECL(int) VbglR3GuestPropDelete(HGCMCLIENTID idClient, const char *pszName);
636VBGLR3DECL(int) VbglR3GuestPropDelSet(HGCMCLIENTID idClient, char const * const *papszPatterns, uint32_t cPatterns);
637VBGLR3DECL(int) VbglR3GuestPropWait(HGCMCLIENTID idClient, const char *pszPatterns, void *pvBuf, uint32_t cbBuf,
638 uint64_t u64Timestamp, uint32_t cMillies, char ** ppszName, char **ppszValue,
639 uint64_t *pu64Timestamp, char **ppszFlags, uint32_t *pcbBufActual);
640/** @} */
641
642/** @name Guest user handling / reporting.
643 * @{ */
644VBGLR3DECL(int) VbglR3GuestUserReportState(const char *pszUser, const char *pszDomain, VBoxGuestUserState enmState,
645 uint8_t *pbDetails, uint32_t cbDetails);
646/** @} */
647
648/** @name Host version handling
649 * @{ */
650VBGLR3DECL(int) VbglR3HostVersionCheckForUpdate(HGCMCLIENTID idClient, bool *pfUpdate, char **ppszHostVersion,
651 char **ppszGuestVersion);
652VBGLR3DECL(int) VbglR3HostVersionLastCheckedLoad(HGCMCLIENTID idClient, char **ppszVer);
653VBGLR3DECL(int) VbglR3HostVersionLastCheckedStore(HGCMCLIENTID idClient, const char *pszVer);
654/** @} */
655# endif /* VBOX_WITH_GUEST_PROPS defined */
656
657# ifdef VBOX_WITH_SHARED_FOLDERS
658/** @name Shared folders
659 * @{ */
660/**
661 * Structure containing mapping information for a shared folder.
662 */
663typedef struct VBGLR3SHAREDFOLDERMAPPING
664{
665 /** Mapping status. */
666 uint32_t u32Status;
667 /** Root handle. */
668 uint32_t u32Root;
669} VBGLR3SHAREDFOLDERMAPPING;
670/** Pointer to a shared folder mapping information structure. */
671typedef VBGLR3SHAREDFOLDERMAPPING *PVBGLR3SHAREDFOLDERMAPPING;
672/** Pointer to a const shared folder mapping information structure. */
673typedef VBGLR3SHAREDFOLDERMAPPING const *PCVBGLR3SHAREDFOLDERMAPPING;
674
675VBGLR3DECL(int) VbglR3SharedFolderConnect(uint32_t *pidClient);
676VBGLR3DECL(int) VbglR3SharedFolderDisconnect(HGCMCLIENTID idClient);
677VBGLR3DECL(bool) VbglR3SharedFolderExists(HGCMCLIENTID idClient, const char *pszShareName);
678VBGLR3DECL(int) VbglR3SharedFolderGetMappings(HGCMCLIENTID idClient, bool fAutoMountOnly,
679 PVBGLR3SHAREDFOLDERMAPPING *ppaMappings, uint32_t *pcMappings);
680VBGLR3DECL(void) VbglR3SharedFolderFreeMappings(PVBGLR3SHAREDFOLDERMAPPING paMappings);
681VBGLR3DECL(int) VbglR3SharedFolderGetName(HGCMCLIENTID idClient,uint32_t u32Root, char **ppszName);
682VBGLR3DECL(int) VbglR3SharedFolderGetMountPrefix(char **ppszPrefix);
683VBGLR3DECL(int) VbglR3SharedFolderGetMountDir(char **ppszDir);
684/** @} */
685# endif /* VBOX_WITH_SHARED_FOLDERS defined */
686
687# ifdef VBOX_WITH_GUEST_CONTROL
688/** @name Guest control
689 * @{ */
690
691/**
692 * Structure containing the context required for
693 * either retrieving or sending a HGCM guest control
694 * commands from or to the host.
695 *
696 * Note: Do not change parameter order without also
697 * adapting all structure initializers.
698 */
699typedef struct VBGLR3GUESTCTRLCMDCTX
700{
701 /** @todo This struct could be handy if we want to implement
702 * a second communication channel, e.g. via TCP/IP.
703 * Use a union for the HGCM stuff then. */
704
705 /** IN: HGCM client ID to use for
706 * communication. */
707 uint32_t uClientID;
708 /** IN/OUT: Context ID to retrieve
709 * or to use. */
710 uint32_t uContextID;
711 /** IN: Protocol version to use. */
712 uint32_t uProtocol;
713 /** OUT: Number of parameters retrieved. */
714 uint32_t uNumParms;
715} VBGLR3GUESTCTRLCMDCTX, *PVBGLR3GUESTCTRLCMDCTX;
716
717/* General message handling on the guest. */
718VBGLR3DECL(int) VbglR3GuestCtrlConnect(uint32_t *pidClient);
719VBGLR3DECL(int) VbglR3GuestCtrlDisconnect(uint32_t idClient);
720VBGLR3DECL(int) VbglR3GuestCtrlMsgFilterSet(uint32_t uClientId, uint32_t uValue, uint32_t uMaskAdd, uint32_t uMaskRemove);
721VBGLR3DECL(int) VbglR3GuestCtrlMsgFilterUnset(uint32_t uClientId);
722VBGLR3DECL(int) VbglR3GuestCtrlMsgReply(PVBGLR3GUESTCTRLCMDCTX pCtx, int rc);
723VBGLR3DECL(int) VbglR3GuestCtrlMsgReplyEx(PVBGLR3GUESTCTRLCMDCTX pCtx, int rc, uint32_t uType,
724 void *pvPayload, uint32_t cbPayload);
725VBGLR3DECL(int) VbglR3GuestCtrlMsgSkip(uint32_t uClientId);
726VBGLR3DECL(int) VbglR3GuestCtrlMsgWaitFor(uint32_t uClientId, uint32_t *puMsg, uint32_t *puNumParms);
727VBGLR3DECL(int) VbglR3GuestCtrlCancelPendingWaits(HGCMCLIENTID idClient);
728/* Guest session handling. */
729VBGLR3DECL(int) VbglR3GuestCtrlSessionClose(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t fFlags);
730VBGLR3DECL(int) VbglR3GuestCtrlSessionNotify(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uType, uint32_t uResult);
731VBGLR3DECL(int) VbglR3GuestCtrlSessionGetOpen(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puProtocol, char *pszUser, uint32_t cbUser,
732 char *pszPassword, uint32_t cbPassword, char *pszDomain, uint32_t cbDomain,
733 uint32_t *pfFlags, uint32_t *pidSession);
734VBGLR3DECL(int) VbglR3GuestCtrlSessionGetClose(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *pfFlags, uint32_t *pidSession);
735/* Guest path handling. */
736VBGLR3DECL(int) VbglR3GuestCtrlPathGetRename(PVBGLR3GUESTCTRLCMDCTX pCtx, char *pszSource, uint32_t cbSource, char *pszDest,
737 uint32_t cbDest, uint32_t *pfFlags);
738VBGLR3DECL(int) VbglR3GuestCtrlPathGetUserDocuments(PVBGLR3GUESTCTRLCMDCTX pCtx);
739VBGLR3DECL(int) VbglR3GuestCtrlPathGetUserHome(PVBGLR3GUESTCTRLCMDCTX pCtx);
740/* Guest process execution. */
741VBGLR3DECL(int) VbglR3GuestCtrlProcGetStart(PVBGLR3GUESTCTRLCMDCTX pCtx, char *pszCmd, uint32_t cbCmd, uint32_t *pfFlags,
742 char *pszArgs, uint32_t cbArgs, uint32_t *puNumArgs, char *pszEnv, uint32_t *pcbEnv,
743 uint32_t *puNumEnvVars, char *pszUser, uint32_t cbUser, char *pszPassword,
744 uint32_t cbPassword, uint32_t *puTimeoutMS, uint32_t *puPriority,
745 uint64_t *puAffinity, uint32_t cbAffinity, uint32_t *pcAffinity);
746VBGLR3DECL(int) VbglR3GuestCtrlProcGetTerminate(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puPID);
747VBGLR3DECL(int) VbglR3GuestCtrlProcGetInput(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puPID, uint32_t *pfFlags, void *pvData,
748 uint32_t cbData, uint32_t *pcbSize);
749VBGLR3DECL(int) VbglR3GuestCtrlProcGetOutput(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puPID, uint32_t *puHandle, uint32_t *pfFlags);
750VBGLR3DECL(int) VbglR3GuestCtrlProcGetWaitFor(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puPID, uint32_t *puWaitFlags,
751 uint32_t *puTimeoutMS);
752/* Guest native directory handling. */
753VBGLR3DECL(int) VbglR3GuestCtrlDirGetRemove(PVBGLR3GUESTCTRLCMDCTX pCtx, char *pszPath, uint32_t cbPath, uint32_t *pfFlags);
754/* Guest native file handling. */
755VBGLR3DECL(int) VbglR3GuestCtrlFileGetOpen(PVBGLR3GUESTCTRLCMDCTX pCtx, char *pszFileName, uint32_t cbFileName, char *pszOpenMode,
756 uint32_t cbOpenMode, char *pszDisposition, uint32_t cbDisposition, char *pszSharing,
757 uint32_t cbSharing, uint32_t *puCreationMode, uint64_t *puOffset);
758VBGLR3DECL(int) VbglR3GuestCtrlFileGetClose(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puHandle);
759VBGLR3DECL(int) VbglR3GuestCtrlFileGetRead(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puHandle, uint32_t *puToRead);
760VBGLR3DECL(int) VbglR3GuestCtrlFileGetReadAt(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puHandle,
761 uint32_t *puToRead, uint64_t *poffRead);
762VBGLR3DECL(int) VbglR3GuestCtrlFileGetWrite(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puHandle,
763 void *pvData, uint32_t cbData, uint32_t *pcbActual);
764VBGLR3DECL(int) VbglR3GuestCtrlFileGetWriteAt(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puHandle, void *pvData, uint32_t cbData,
765 uint32_t *pcbActual, uint64_t *poffWrite);
766VBGLR3DECL(int) VbglR3GuestCtrlFileGetSeek(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puHandle,
767 uint32_t *puSeekMethod, uint64_t *poffSeek);
768VBGLR3DECL(int) VbglR3GuestCtrlFileGetTell(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puHandle);
769/* Guest -> Host. */
770VBGLR3DECL(int) VbglR3GuestCtrlFileCbOpen(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc, uint32_t uFileHandle);
771VBGLR3DECL(int) VbglR3GuestCtrlFileCbClose(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc);
772VBGLR3DECL(int) VbglR3GuestCtrlFileCbError(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc);
773VBGLR3DECL(int) VbglR3GuestCtrlFileCbRead(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc, void *pvData, uint32_t cbData);
774VBGLR3DECL(int) VbglR3GuestCtrlFileCbWrite(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc, uint32_t uWritten);
775VBGLR3DECL(int) VbglR3GuestCtrlFileCbSeek(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc, uint64_t uOffActual);
776VBGLR3DECL(int) VbglR3GuestCtrlFileCbTell(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc, uint64_t uOffActual);
777VBGLR3DECL(int) VbglR3GuestCtrlProcCbStatus(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uPID, uint32_t uStatus, uint32_t fFlags,
778 void *pvData, uint32_t cbData);
779VBGLR3DECL(int) VbglR3GuestCtrlProcCbOutput(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uPID, uint32_t uHandle, uint32_t fFlags,
780 void *pvData, uint32_t cbData);
781VBGLR3DECL(int) VbglR3GuestCtrlProcCbStatusInput(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t u32PID, uint32_t uStatus,
782 uint32_t fFlags, uint32_t cbWritten);
783
784/** @} */
785# endif /* VBOX_WITH_GUEST_CONTROL defined */
786
787/** @name Auto-logon handling
788 * @{ */
789VBGLR3DECL(int) VbglR3AutoLogonReportStatus(VBoxGuestFacilityStatus enmStatus);
790VBGLR3DECL(bool) VbglR3AutoLogonIsRemoteSession(void);
791/** @} */
792
793/** @name User credentials handling
794 * @{ */
795VBGLR3DECL(int) VbglR3CredentialsQueryAvailability(void);
796VBGLR3DECL(int) VbglR3CredentialsRetrieve(char **ppszUser, char **ppszPassword, char **ppszDomain);
797VBGLR3DECL(int) VbglR3CredentialsRetrieveUtf16(PRTUTF16 *ppwszUser, PRTUTF16 *ppwszPassword, PRTUTF16 *ppwszDomain);
798VBGLR3DECL(void) VbglR3CredentialsDestroy(char *pszUser, char *pszPassword, char *pszDomain, uint32_t cPasses);
799VBGLR3DECL(void) VbglR3CredentialsDestroyUtf16(PRTUTF16 pwszUser, PRTUTF16 pwszPassword, PRTUTF16 pwszDomain,
800 uint32_t cPasses);
801/** @} */
802
803/** @name CPU hotplug monitor
804 * @{ */
805VBGLR3DECL(int) VbglR3CpuHotPlugInit(void);
806VBGLR3DECL(int) VbglR3CpuHotPlugTerm(void);
807VBGLR3DECL(int) VbglR3CpuHotPlugWaitForEvent(VMMDevCpuEventType *penmEventType, uint32_t *pidCpuCore, uint32_t *pidCpuPackage);
808/** @} */
809
810/** @name Page sharing
811 * @{ */
812struct VMMDEVSHAREDREGIONDESC;
813VBGLR3DECL(int) VbglR3RegisterSharedModule(char *pszModuleName, char *pszVersion, RTGCPTR64 GCBaseAddr, uint32_t cbModule,
814 unsigned cRegions, struct VMMDEVSHAREDREGIONDESC *pRegions);
815VBGLR3DECL(int) VbglR3UnregisterSharedModule(char *pszModuleName, char *pszVersion, RTGCPTR64 GCBaseAddr, uint32_t cbModule);
816VBGLR3DECL(int) VbglR3CheckSharedModules(void);
817VBGLR3DECL(bool) VbglR3PageSharingIsEnabled(void);
818VBGLR3DECL(int) VbglR3PageIsShared(RTGCPTR pPage, bool *pfShared, uint64_t *puPageFlags);
819/** @} */
820
821# ifdef VBOX_WITH_DRAG_AND_DROP
822/** @name Drag and Drop
823 * @{ */
824/**
825 * Structure containing the context required for
826 * either retrieving or sending a HGCM guest drag'n drop
827 * commands from or to the host.
828 *
829 * Note: Do not change parameter order without also
830 * adapting all structure initializers.
831 */
832typedef struct VBGLR3GUESTDNDCMDCTX
833{
834 /** @todo This struct could be handy if we want to implement
835 * a second communication channel, e.g. via TCP/IP.
836 * Use a union for the HGCM stuff then. */
837
838 /** HGCM client ID to use for communication. */
839 uint32_t uClientID;
840 /** The VM's current session ID. */
841 uint64_t uSessionID;
842 /** Protocol version to use. */
843 uint32_t uProtocol;
844 /** Number of parameters retrieved for the current command. */
845 uint32_t uNumParms;
846 /** Max chunk size (in bytes) for data transfers. */
847 uint32_t cbMaxChunkSize;
848} VBGLR3GUESTDNDCMDCTX, *PVBGLR3GUESTDNDCMDCTX;
849
850typedef struct VBGLR3DNDHGCMEVENT
851{
852 uint32_t uType; /** The event type this struct contains. */
853 uint32_t uScreenId; /** Screen ID this request belongs to. */
854 char *pszFormats; /** Format list (\r\n separated). */
855 uint32_t cbFormats; /** Size (in bytes) of pszFormats (\0 included). */
856 union
857 {
858 struct
859 {
860 uint32_t uXpos; /** X position of guest screen. */
861 uint32_t uYpos; /** Y position of guest screen. */
862 uint32_t uDefAction; /** Proposed DnD action. */
863 uint32_t uAllActions; /** Allowed DnD actions. */
864 } a; /** Values used in init, move and drop event type. */
865 struct
866 {
867 void *pvData; /** Data request. */
868 uint32_t cbData; /** Size (in bytes) of pvData. */
869 } b; /** Values used in drop data event type. */
870 } u;
871} VBGLR3DNDHGCMEVENT;
872typedef VBGLR3DNDHGCMEVENT *PVBGLR3DNDHGCMEVENT;
873typedef const PVBGLR3DNDHGCMEVENT CPVBGLR3DNDHGCMEVENT;
874VBGLR3DECL(int) VbglR3DnDConnect(PVBGLR3GUESTDNDCMDCTX pCtx);
875VBGLR3DECL(int) VbglR3DnDDisconnect(PVBGLR3GUESTDNDCMDCTX pCtx);
876
877VBGLR3DECL(int) VbglR3DnDRecvNextMsg(PVBGLR3GUESTDNDCMDCTX pCtx, CPVBGLR3DNDHGCMEVENT pEvent);
878
879VBGLR3DECL(int) VbglR3DnDHGSendAckOp(PVBGLR3GUESTDNDCMDCTX pCtx, uint32_t uAction);
880VBGLR3DECL(int) VbglR3DnDHGSendReqData(PVBGLR3GUESTDNDCMDCTX pCtx, const char *pcszFormat);
881VBGLR3DECL(int) VbglR3DnDHGSendProgress(PVBGLR3GUESTDNDCMDCTX pCtx, uint32_t uStatus, uint8_t uPercent, int rcErr);
882# ifdef VBOX_WITH_DRAG_AND_DROP_GH
883VBGLR3DECL(int) VbglR3DnDGHSendAckPending(PVBGLR3GUESTDNDCMDCTX pCtx, uint32_t uDefAction, uint32_t uAllActions, const char* pcszFormats, uint32_t cbFormats);
884VBGLR3DECL(int) VbglR3DnDGHSendData(PVBGLR3GUESTDNDCMDCTX pCtx, const char *pszFormat, void *pvData, uint32_t cbData);
885VBGLR3DECL(int) VbglR3DnDGHSendError(PVBGLR3GUESTDNDCMDCTX pCtx, int rcOp);
886# endif /* VBOX_WITH_DRAG_AND_DROP_GH */
887/** @} */
888# endif /* VBOX_WITH_DRAG_AND_DROP */
889
890/* Generic Host Channel Service. */
891VBGLR3DECL(int) VbglR3HostChannelInit(uint32_t *pidClient);
892VBGLR3DECL(void) VbglR3HostChannelTerm(uint32_t idClient);
893VBGLR3DECL(int) VbglR3HostChannelAttach(uint32_t *pu32ChannelHandle, uint32_t u32HGCMClientId,
894 const char *pszName, uint32_t u32Flags);
895VBGLR3DECL(void) VbglR3HostChannelDetach(uint32_t u32ChannelHandle, uint32_t u32HGCMClientId);
896VBGLR3DECL(int) VbglR3HostChannelSend(uint32_t u32ChannelHandle, uint32_t u32HGCMClientId,
897 void *pvData, uint32_t cbData);
898VBGLR3DECL(int) VbglR3HostChannelRecv(uint32_t u32ChannelHandle, uint32_t u32HGCMClientId,
899 void *pvData, uint32_t cbData,
900 uint32_t *pu32SizeReceived, uint32_t *pu32SizeRemaining);
901VBGLR3DECL(int) VbglR3HostChannelControl(uint32_t u32ChannelHandle, uint32_t u32HGCMClientId,
902 uint32_t u32Code, void *pvParm, uint32_t cbParm,
903 void *pvData, uint32_t cbData, uint32_t *pu32SizeDataReturned);
904VBGLR3DECL(int) VbglR3HostChannelEventWait(uint32_t *pu32ChannelHandle, uint32_t u32HGCMClientId,
905 uint32_t *pu32EventId, void *pvParm, uint32_t cbParm,
906 uint32_t *pu32SizeReturned);
907VBGLR3DECL(int) VbglR3HostChannelEventCancel(uint32_t u32ChannelHandle, uint32_t u32HGCMClientId);
908VBGLR3DECL(int) VbglR3HostChannelQuery(const char *pszName, uint32_t u32HGCMClientId, uint32_t u32Code,
909 void *pvParm, uint32_t cbParm, void *pvData, uint32_t cbData,
910 uint32_t *pu32SizeDataReturned);
911
912/** @name Mode hint storage
913 * @{ */
914VBGLR3DECL(int) VbglR3ReadVideoMode(unsigned cDisplay, unsigned *cx,
915 unsigned *cy, unsigned *cBPP, unsigned *x,
916 unsigned *y, unsigned *fEnabled);
917VBGLR3DECL(int) VbglR3WriteVideoMode(unsigned cDisplay, unsigned cx,
918 unsigned cy, unsigned cBPP, unsigned x,
919 unsigned y, unsigned fEnabled);
920/** @} */
921
922/** @name Generic HGCM
923 * @{ */
924VBGLR3DECL(int) VbglR3HGCMConnect(const char *pszServiceName, HGCMCLIENTID *pidClient);
925VBGLR3DECL(int) VbglR3HGCMDisconnect(HGCMCLIENTID idClient);
926struct VBGLIOCHGCMCALL;
927VBGLR3DECL(int) VbglR3HGCMCall(struct VBGLIOCHGCMCALL *pInfo, size_t cbInfo);
928/** @} */
929
930#endif /* IN_RING3 */
931/** @} */
932
933RT_C_DECLS_END
934
935/** @} */
936
937#endif
938
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use