VirtualBox

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

Last change on this file since 69107 was 69107, checked in by vboxsync, 7 years ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use