VirtualBox

source: vbox/trunk/include/VBox/VBoxGuest.h@ 4533

Last change on this file since 4533 was 4533, checked in by vboxsync, 18 years ago

Cleaned up a bit
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 45.3 KB
Line 
1/** @file
2 * VBoxGuest - VirtualBox Guest Additions interface
3 */
4
5/*
6 * Copyright (C) 2006-2007 innotek GmbH
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 as published by the Free Software Foundation,
12 * in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
13 * distribution. VirtualBox OSE is distributed in the hope that it will
14 * be useful, but WITHOUT ANY WARRANTY of any kind.
15 */
16
17#ifndef ___VBox_VBoxGuest_h
18#define ___VBox_VBoxGuest_h
19
20#include <iprt/cdefs.h>
21#include <iprt/types.h>
22#include <VBox/err.h>
23#include <VBox/ostypes.h>
24
25/*******************************************************************************
26* Defined Constants And Macros *
27*******************************************************************************/
28
29/** @todo The following is a temporary fix for the problem of accessing
30 hypervisor pointers from within guest additions */
31
32/** Hypervisor linear pointer size type */
33typedef uint32_t vmmDevHypPtr;
34/** Hypervisor physical pointer size type */
35typedef uint32_t vmmDevHypPhys;
36
37#if defined(RT_OS_LINUX)
38/** The support device name. */
39# define VBOXGUEST_DEVICE_NAME "/dev/vboxadd"
40
41#elif defined(RT_OS_OS2)
42/** The support device name. */
43# define VBOXGUEST_DEVICE_NAME "\\Dev\\VBoxGst$"
44
45#elif defined(RT_OS_WINDOWS)
46/** The support service name. */
47# define VBOXGUEST_SERVICE_NAME "VBoxGuest"
48/** Win32 Device name. */
49# define VBOXGUEST_DEVICE_NAME "\\\\.\\VBoxGuest"
50/** Global name for Win2k+ */
51# define VBOXGUEST_DEVICE_NAME_GLOBAL "\\\\.\\Global\\VBoxGuest"
52/** Win32 driver name */
53# define VBOXGUEST_DEVICE_NAME_NT L"\\Device\\VBoxGuest"
54/** device name */
55# define VBOXGUEST_DEVICE_NAME_DOS L"\\DosDevices\\VBoxGuest"
56
57#else
58/* PORTME */
59#endif
60
61/** VirtualBox vendor ID */
62#define VBOX_PCI_VENDORID (0x80ee)
63
64/** VMMDev PCI card identifiers */
65#define VMMDEV_VENDORID VBOX_PCI_VENDORID
66#define VMMDEV_DEVICEID (0xcafe)
67
68/** VirtualBox graphics card identifiers */
69#define VBOX_VENDORID VBOX_PCI_VENDORID
70#define VBOX_VESA_VENDORID VBOX_PCI_VENDORID
71#define VBOX_DEVICEID (0xbeef)
72#define VBOX_VESA_DEVICEID (0xbeef)
73
74/**
75 * VBoxGuest port definitions
76 * @{
77 */
78
79/** guest can (== wants to) handle absolute coordinates */
80#define VBOXGUEST_MOUSE_GUEST_CAN_ABSOLUTE BIT(0)
81/** host can (== wants to) send absolute coordinates */
82#define VBOXGUEST_MOUSE_HOST_CAN_ABSOLUTE BIT(1)
83/** guest can *NOT* switch to software cursor and therefore depends on the host cursor */
84#define VBOXGUEST_MOUSE_GUEST_NEEDS_HOST_CURSOR BIT(2)
85/** host does NOT provide support for drawing the cursor itself (e.g. L4 console) */
86#define VBOXGUEST_MOUSE_HOST_CANNOT_HWPOINTER BIT(3)
87
88/** fictive start address of the hypervisor physical memory for MmMapIoSpace */
89#define HYPERVISOR_PHYSICAL_START 0xf8000000
90
91/*
92 * VMMDev Generic Request Interface
93 */
94
95/** port for generic request interface */
96#define PORT_VMMDEV_REQUEST_OFFSET 0
97
98/** Current version of the VMMDev interface.
99 *
100 * Additions are allowed to work only if
101 * additions_major == vmmdev_current && additions_minor <= vmmdev_current.
102 * Additions version is reported to host (VMMDev) by VMMDevReq_ReportGuestInfo.
103 *
104 * @remark These defines also live in the 16-bit and assembly versions of this header.
105 */
106#define VMMDEV_VERSION_MAJOR (0x1)
107#define VMMDEV_VERSION_MINOR (0x4)
108#define VMMDEV_VERSION ((VMMDEV_VERSION_MAJOR << 16) | VMMDEV_VERSION_MINOR)
109
110/**
111 * VMMDev request types.
112 * @note when updating this, adjust vmmdevGetRequestSize() as well
113 */
114typedef enum
115{
116 VMMDevReq_InvalidRequest = 0,
117 VMMDevReq_GetMouseStatus = 1,
118 VMMDevReq_SetMouseStatus = 2,
119 VMMDevReq_SetPointerShape = 3,
120 /** @todo implement on host side */
121 VMMDevReq_GetHostVersion = 4,
122 VMMDevReq_Idle = 5,
123 VMMDevReq_GetHostTime = 10,
124 VMMDevReq_GetHypervisorInfo = 20,
125 VMMDevReq_SetHypervisorInfo = 21,
126 VMMDevReq_SetPowerStatus = 30,
127 VMMDevReq_AcknowledgeEvents = 41,
128 VMMDevReq_CtlGuestFilterMask = 42,
129 VMMDevReq_ReportGuestInfo = 50,
130 VMMDevReq_GetDisplayChangeRequest = 51,
131 VMMDevReq_VideoModeSupported = 52,
132 VMMDevReq_GetHeightReduction = 53,
133 VMMDevReq_GetDisplayChangeRequest2 = 54,
134 VMMDevReq_ReportGuestCapabilities = 55,
135#ifdef VBOX_HGCM
136 VMMDevReq_HGCMConnect = 60,
137 VMMDevReq_HGCMDisconnect = 61,
138 VMMDevReq_HGCMCall = 62,
139#endif
140 VMMDevReq_VideoAccelEnable = 70,
141 VMMDevReq_VideoAccelFlush = 71,
142 VMMDevReq_VideoSetVisibleRegion = 72,
143 VMMDevReq_GetSeamlessChangeRequest = 73,
144 VMMDevReq_QueryCredentials = 100,
145 VMMDevReq_ReportCredentialsJudgement = 101,
146 VMMDevReq_ReportGuestStats = 110,
147 VMMDevReq_GetMemBalloonChangeRequest = 111,
148 VMMDevReq_GetStatisticsChangeRequest = 112,
149 VMMDevReq_ChangeMemBalloon = 113,
150 VMMDevReq_LogString = 200,
151 VMMDevReq_SizeHack = 0x7fffffff
152} VMMDevRequestType;
153
154/** Version of VMMDevRequestHeader structure. */
155#define VMMDEV_REQUEST_HEADER_VERSION (0x10001)
156
157#pragma pack(4)
158/** generic VMMDev request header */
159typedef struct
160{
161 /** size of the structure in bytes (including body). Filled by caller */
162 uint32_t size;
163 /** version of the structure. Filled by caller */
164 uint32_t version;
165 /** type of the request */
166 VMMDevRequestType requestType;
167 /** return code. Filled by VMMDev */
168 int32_t rc;
169 /** reserved fields */
170 uint32_t reserved1;
171 uint32_t reserved2;
172} VMMDevRequestHeader;
173
174/** mouse status request structure */
175typedef struct
176{
177 /** header */
178 VMMDevRequestHeader header;
179 /** mouse feature mask */
180 uint32_t mouseFeatures;
181 /** mouse x position */
182 uint32_t pointerXPos;
183 /** mouse y position */
184 uint32_t pointerYPos;
185} VMMDevReqMouseStatus;
186
187/** Note VBOX_MOUSE_POINTER_* flags are used in guest video driver,
188 * values must be <= 0x8000 and must not be changed.
189 */
190
191/** pointer is visible */
192#define VBOX_MOUSE_POINTER_VISIBLE (0x0001)
193/** pointer has alpha channel */
194#define VBOX_MOUSE_POINTER_ALPHA (0x0002)
195/** pointerData contains new pointer shape */
196#define VBOX_MOUSE_POINTER_SHAPE (0x0004)
197
198/** mouse pointer shape/visibility change request */
199typedef struct
200{
201 /** header */
202 VMMDevRequestHeader header;
203 /** VBOX_MOUSE_POINTER_* bit flags */
204 uint32_t fFlags;
205 /** x coordinate of hot spot */
206 uint32_t xHot;
207 /** y coordinate of hot spot */
208 uint32_t yHot;
209 /** width of the pointer in pixels */
210 uint32_t width;
211 /** height of the pointer in scanlines */
212 uint32_t height;
213 /** Pointer data.
214 *
215 ****
216 * The data consists of 1 bpp AND mask followed by 32 bpp XOR (color) mask.
217 *
218 * For pointers without alpha channel the XOR mask pixels are 32 bit values: (lsb)BGR0(msb).
219 * For pointers with alpha channel the XOR mask consists of (lsb)BGRA(msb) 32 bit values.
220 *
221 * Guest driver must create the AND mask for pointers with alpha channel, so if host does not
222 * support alpha, the pointer could be displayed as a normal color pointer. The AND mask can
223 * be constructed from alpha values. For example alpha value >= 0xf0 means bit 0 in the AND mask.
224 *
225 * The AND mask is 1 bpp bitmap with byte aligned scanlines. Size of AND mask,
226 * therefore, is cbAnd = (width + 7) / 8 * height. The padding bits at the
227 * end of any scanline are undefined.
228 *
229 * The XOR mask follows the AND mask on the next 4 bytes aligned offset:
230 * uint8_t *pXor = pAnd + (cbAnd + 3) & ~3
231 * Bytes in the gap between the AND and the XOR mask are undefined.
232 * XOR mask scanlines have no gap between them and size of XOR mask is:
233 * cXor = width * 4 * height.
234 ****
235 *
236 * Preallocate 4 bytes for accessing actual data as p->pointerData
237 */
238 char pointerData[4];
239} VMMDevReqMousePointer;
240
241/** string log request structure */
242typedef struct
243{
244 /** header */
245 VMMDevRequestHeader header;
246 /** variable length string data */
247 char szString[1];
248} VMMDevReqLogString;
249
250/** host version request structure */
251typedef struct
252{
253 /** header */
254 VMMDevRequestHeader header;
255 /** major version */
256 uint32_t major;
257 /** minor version */
258 uint32_t minor;
259 /** build number */
260 uint32_t build;
261} VMMDevReqHostVersion;
262
263/** guest capabilites structure */
264typedef struct
265{
266 /** header */
267 VMMDevRequestHeader header;
268 /** capabilities (VMMDEV_GUEST_*) */
269 uint32_t caps;
270} VMMDevReqGuestCapabilities;
271
272/** idle request structure */
273typedef struct
274{
275 /** header */
276 VMMDevRequestHeader header;
277} VMMDevReqIdle;
278
279/** host time request structure */
280typedef struct
281{
282 /** header */
283 VMMDevRequestHeader header;
284 /** time in milliseconds since unix epoch. Filled by VMMDev. */
285 uint64_t time;
286} VMMDevReqHostTime;
287
288/** hypervisor info structure */
289typedef struct
290{
291 /** header */
292 VMMDevRequestHeader header;
293 /** guest virtual address of proposed hypervisor start */
294 vmmDevHypPtr hypervisorStart;
295 /** hypervisor size in bytes */
296 uint32_t hypervisorSize;
297} VMMDevReqHypervisorInfo;
298
299/** system power requests */
300typedef enum
301{
302 VMMDevPowerState_Invalid = 0,
303 VMMDevPowerState_Pause = 1,
304 VMMDevPowerState_PowerOff = 2,
305 VMMDevPowerState_SaveState = 3,
306 VMMDevPowerState_SizeHack = 0x7fffffff
307} VMMDevPowerState;
308
309/** system power status structure */
310typedef struct
311{
312 /** header */
313 VMMDevRequestHeader header;
314 /** power state request */
315 VMMDevPowerState powerState;
316} VMMDevPowerStateRequest;
317
318/** pending events structure */
319typedef struct
320{
321 /** header */
322 VMMDevRequestHeader header;
323 /** pending event bitmap */
324 uint32_t events;
325} VMMDevEvents;
326
327/** guest filter mask control */
328typedef struct
329{
330 /** header */
331 VMMDevRequestHeader header;
332 /** mask of events to be added to filter */
333 uint32_t u32OrMask;
334 /** mask of events to be removed from filter */
335 uint32_t u32NotMask;
336} VMMDevCtlGuestFilterMask;
337
338/** guest information structure */
339typedef struct VBoxGuestInfo
340{
341 /** The VMMDev interface version expected by additions. */
342 uint32_t additionsVersion;
343 /** guest OS type */
344 OSType osType;
345 /** @todo */
346} VBoxGuestInfo;
347
348/** guest information structure */
349typedef struct
350{
351 /** header */
352 VMMDevRequestHeader header;
353 /** Guest information. */
354 VBoxGuestInfo guestInfo;
355} VMMDevReportGuestInfo;
356
357/** guest statistics values */
358#define VBOX_GUEST_STAT_CPU_LOAD BIT(0)
359#define VBOX_GUEST_STAT_THREADS BIT(1)
360#define VBOX_GUEST_STAT_PROCESSES BIT(2)
361#define VBOX_GUEST_STAT_PHYS_MEM_TOTAL BIT(3)
362#define VBOX_GUEST_STAT_PHYS_MEM_AVAIL BIT(4)
363#define VBOX_GUEST_STAT_PHYS_MEM_BALLOON BIT(5)
364#define VBOX_GUEST_STAT_PAGE_FILE_SIZE BIT(6)
365
366
367/** guest statistics structure */
368typedef struct VBoxGuestStatistics
369{
370 /** Reported statistics */
371 uint32_t u32StatCaps;
372 /** CPU load (0-100) */
373 uint32_t u32CpuLoad;
374 /** Nr of threads */
375 uint32_t u32Threads;
376 /** Nr of processes */
377 uint32_t u32Processes;
378 /** Total physical memory (megabytes) */
379 uint32_t u32PhysMemTotal;
380 /** Available physical memory (megabytes) */
381 uint32_t u32PhysMemAvail;
382 /** Ballooned physical memory (megabytes) */
383 uint32_t u32PhysMemBalloon;
384 /** Pagefile size (megabytes) */
385 uint32_t u32PageFileSize;
386} VBoxGuestStatistics;
387
388/** guest statistics command structure */
389typedef struct
390{
391 /** header */
392 VMMDevRequestHeader header;
393 /** Guest information. */
394 VBoxGuestStatistics guestStats;
395} VMMDevReportGuestStats;
396
397/** memory balloon change request structure */
398#define VMMDEV_MAX_MEMORY_BALLOON(PhysMemTotal) ((90*PhysMemTotal)/100)
399
400typedef struct
401{
402 /** header */
403 VMMDevRequestHeader header;
404 uint32_t u32BalloonSize;
405 uint32_t eventAck;
406} VMMDevGetMemBalloonChangeRequest;
407
408/** inflate/deflate memory balloon structure */
409#define VMMDEV_MEMORY_BALLOON_CHUNK_PAGES (_1M/4096)
410
411typedef struct
412{
413 /** header */
414 VMMDevRequestHeader header;
415 uint32_t cPages;
416 uint32_t fInflate; /* true = inflate, false = defalte */
417 RTGCPHYS aPhysPage[1]; /* variable size */
418} VMMDevChangeMemBalloon;
419
420/** guest statistics interval change request structure */
421typedef struct
422{
423 /** header */
424 VMMDevRequestHeader header;
425 uint32_t u32StatInterval; /* interval in seconds */
426 uint32_t eventAck;
427} VMMDevGetStatisticsChangeRequest;
428
429/** display change request structure */
430typedef struct
431{
432 /** header */
433 VMMDevRequestHeader header;
434 /** horizontal pixel resolution (0 = do not change) */
435 uint32_t xres;
436 /** vertical pixel resolution (0 = do not change) */
437 uint32_t yres;
438 /** bits per pixel (0 = do not change) */
439 uint32_t bpp;
440 /** Flag that the request is an acknowlegement for the VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST.
441 * Values: 0 - just querying, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST - event acknowledged.
442 */
443 uint32_t eventAck;
444} VMMDevDisplayChangeRequest;
445
446typedef struct
447{
448 /** header */
449 VMMDevRequestHeader header;
450 /** horizontal pixel resolution (0 = do not change) */
451 uint32_t xres;
452 /** vertical pixel resolution (0 = do not change) */
453 uint32_t yres;
454 /** bits per pixel (0 = do not change) */
455 uint32_t bpp;
456 /** Flag that the request is an acknowlegement for the VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST.
457 * Values: 0 - just querying, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST - event acknowledged.
458 */
459 uint32_t eventAck;
460 /** 0 for primary display, 1 for the first secondary, etc. */
461 uint32_t display;
462} VMMDevDisplayChangeRequest2;
463
464/** video mode supported request structure */
465typedef struct
466{
467 /** header */
468 VMMDevRequestHeader header;
469 /** horizontal pixel resolution (input) */
470 uint32_t width;
471 /** vertical pixel resolution (input) */
472 uint32_t height;
473 /** bits per pixel (input) */
474 uint32_t bpp;
475 /** supported flag (output) */
476 bool fSupported;
477} VMMDevVideoModeSupportedRequest;
478
479/** video modes height reduction request structure */
480typedef struct
481{
482 /** header */
483 VMMDevRequestHeader header;
484 /** height reduction in pixels (output) */
485 uint32_t heightReduction;
486} VMMDevGetHeightReductionRequest;
487
488#pragma pack()
489
490#ifdef VBOX_HGCM
491
492/** HGCM flags.
493 * @{
494 */
495#define VBOX_HGCM_REQ_DONE (0x1)
496#define VBOX_HGCM_REQ_CANCELLED (0x2)
497/** @} */
498
499#pragma pack(4)
500typedef struct _VMMDevHGCMRequestHeader
501{
502 /** Request header. */
503 VMMDevRequestHeader header;
504
505 /** HGCM flags. */
506 uint32_t fu32Flags;
507
508 /** Result code. */
509 int32_t result;
510} VMMDevHGCMRequestHeader;
511
512/** HGCM service location types. */
513typedef enum
514{
515 VMMDevHGCMLoc_Invalid = 0,
516 VMMDevHGCMLoc_LocalHost = 1,
517 VMMDevHGCMLoc_LocalHost_Existing = 2,
518 VMMDevHGCMLoc_SizeHack = 0x7fffffff
519} HGCMServiceLocationType;
520
521typedef struct
522{
523 char achName[128];
524} HGCMServiceLocationHost;
525
526typedef struct HGCMSERVICELOCATION
527{
528 /** Type of the location. */
529 HGCMServiceLocationType type;
530
531 union
532 {
533 HGCMServiceLocationHost host;
534 } u;
535} HGCMServiceLocation;
536
537typedef struct
538{
539 /* request header */
540 VMMDevHGCMRequestHeader header;
541
542 /** IN: Description of service to connect to. */
543 HGCMServiceLocation loc;
544
545 /** OUT: Client identifier assigned by local instance of HGCM. */
546 uint32_t u32ClientID;
547} VMMDevHGCMConnect;
548
549typedef struct
550{
551 /* request header */
552 VMMDevHGCMRequestHeader header;
553
554 /** IN: Client identifier. */
555 uint32_t u32ClientID;
556} VMMDevHGCMDisconnect;
557
558typedef enum
559{
560 VMMDevHGCMParmType_Invalid = 0,
561 VMMDevHGCMParmType_32bit = 1,
562 VMMDevHGCMParmType_64bit = 2,
563 VMMDevHGCMParmType_PhysAddr = 3,
564 VMMDevHGCMParmType_LinAddr = 4, /**< In and Out */
565 VMMDevHGCMParmType_LinAddr_In = 5, /**< In (read; host<-guest) */
566 VMMDevHGCMParmType_LinAddr_Out = 6, /**< Out (write; host->guest) */
567 VMMDevHGCMParmType_LinAddr_Locked = 7, /**< Locked In and Out */
568 VMMDevHGCMParmType_LinAddr_Locked_In = 8, /**< Locked In (read; host<-guest) */
569 VMMDevHGCMParmType_LinAddr_Locked_Out = 9, /**< Locked Out (write; host->guest) */
570 VMMDevHGCMParmType_SizeHack = 0x7fffffff
571} HGCMFunctionParameterType;
572
573typedef struct _HGCMFUNCTIONPARAMETER
574{
575 HGCMFunctionParameterType type;
576 union
577 {
578 uint32_t value32;
579 uint64_t value64;
580 struct
581 {
582 uint32_t size;
583
584 union
585 {
586 vmmDevHypPhys physAddr;
587 vmmDevHypPtr linearAddr;
588 } u;
589 } Pointer;
590 } u;
591} HGCMFunctionParameter;
592
593typedef struct
594{
595 /* request header */
596 VMMDevHGCMRequestHeader header;
597
598 /** IN: Client identifier. */
599 uint32_t u32ClientID;
600 /** IN: Service function number. */
601 uint32_t u32Function;
602 /** IN: Number of parameters. */
603 uint32_t cParms;
604 /** Parameters follow in form: HGCMFunctionParameter aParms[X]; */
605} VMMDevHGCMCall;
606#pragma pack()
607
608#define VMMDEV_HGCM_CALL_PARMS(a) ((HGCMFunctionParameter *)((char *)a + sizeof (VMMDevHGCMCall)))
609
610#define VBOX_HGCM_MAX_PARMS 32
611
612#endif /* VBOX_HGCM */
613
614
615#define VBVA_F_STATUS_ACCEPTED (0x01)
616#define VBVA_F_STATUS_ENABLED (0x02)
617
618#pragma pack(4)
619
620typedef struct _VMMDevVideoAccelEnable
621{
622 /* request header */
623 VMMDevRequestHeader header;
624
625 /** 0 - disable, !0 - enable. */
626 uint32_t u32Enable;
627
628 /** The size of VBVAMEMORY::au8RingBuffer expected by driver.
629 * The host will refuse to enable VBVA if the size is not equal to
630 * VBVA_RING_BUFFER_SIZE.
631 */
632 uint32_t cbRingBuffer;
633
634 /** Guest initializes the status to 0. Host sets appropriate VBVA_F_STATUS_ flags. */
635 uint32_t fu32Status;
636
637} VMMDevVideoAccelEnable;
638
639typedef struct _VMMDevVideoAccelFlush
640{
641 /* request header */
642 VMMDevRequestHeader header;
643
644} VMMDevVideoAccelFlush;
645
646
647typedef struct _VMMDevVideoSetVisibleRegion
648{
649 /* request header */
650 VMMDevRequestHeader header;
651
652 /** Number of rectangles */
653 uint32_t cRect;
654
655 /** Rectangle array */
656 RTRECT Rect;
657} VMMDevVideoSetVisibleRegion;
658
659
660/** Seamless mode */
661typedef enum
662{
663 VMMDev_Seamless_Disabled = 0, /* normal mode; entire guest desktop displayed */
664 VMMDev_Seamless_Visible_Region = 1, /* visible region mode; only top-level guest windows displayed */
665 VMMDev_Seamless_Host_Window = 2 /* windowed mode; each top-level guest window is represented in a host window */
666} VMMDevSeamlessMode;
667
668typedef struct
669{
670 /** header */
671 VMMDevRequestHeader header;
672
673 /** New seamless mode */
674 VMMDevSeamlessMode mode;
675 /** Flag that the request is an acknowlegement for the VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST.
676 * Values: 0 - just querying, VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST - event acknowledged.
677 */
678 uint32_t eventAck;
679} VMMDevSeamlessChangeRequest;
680
681#pragma pack()
682
683#pragma pack(1)
684
685/** VBVA command header. */
686typedef struct _VBVACMDHDR
687{
688 /** Coordinates of affected rectangle. */
689 int16_t x;
690 int16_t y;
691 uint16_t w;
692 uint16_t h;
693} VBVACMDHDR;
694
695/* VBVA order codes. Must be >= 0, because the VRDP server internally
696 * uses negative values to mark some operations.
697 * Values are important since they are used as an index in the
698 * "supported orders" bit mask.
699 */
700#define VBVA_VRDP_DIRTY_RECT (0)
701#define VBVA_VRDP_SOLIDRECT (1)
702#define VBVA_VRDP_SOLIDBLT (2)
703#define VBVA_VRDP_DSTBLT (3)
704#define VBVA_VRDP_SCREENBLT (4)
705#define VBVA_VRDP_PATBLTBRUSH (5)
706#define VBVA_VRDP_MEMBLT (6)
707#define VBVA_VRDP_CACHED_BITMAP (7)
708#define VBVA_VRDP_DELETED_BITMAP (8)
709#define VBVA_VRDP_LINE (9)
710#define VBVA_VRDP_BOUNDS (10)
711#define VBVA_VRDP_REPEAT (11)
712#define VBVA_VRDP_POLYLINE (12)
713#define VBVA_VRDP_ELLIPSE (13)
714#define VBVA_VRDP_SAVESCREEN (14)
715
716#define VBVA_VRDP_INDEX_TO_BIT(__index) (1 << (__index))
717
718#ifndef VRDP_NO_COM
719/* 128 bit bitmap hash. */
720typedef uint8_t VRDPBITMAPHASH[16];
721
722typedef struct _VRDPORDERPOINT
723{
724 int16_t x;
725 int16_t y;
726} VRDPORDERPOINT;
727
728typedef struct _VRDPORDERPOLYPOINTS
729{
730 uint8_t c;
731 VRDPORDERPOINT a[16];
732} VRDPORDERPOLYPOINTS;
733
734typedef struct _VRDPORDERAREA
735{
736 int16_t x;
737 int16_t y;
738 uint16_t w;
739 uint16_t h;
740} VRDPORDERAREA;
741
742typedef struct _VRDPORDERBOUNDS
743{
744 VRDPORDERPOINT pt1;
745 VRDPORDERPOINT pt2;
746} VRDPORDERBOUNDS;
747
748typedef struct _VRDPORDERREPEAT
749{
750 VRDPORDERBOUNDS bounds;
751} VRDPORDERREPEAT;
752
753
754/* Header for bitmap bits in VBVA VRDP operations. */
755typedef struct _VRDPDATABITS
756{
757 /* Size of bitmap data without the header. */
758 uint32_t cb;
759 int16_t x;
760 int16_t y;
761 uint16_t cWidth;
762 uint16_t cHeight;
763 uint8_t cbPixel;
764} VRDPDATABITS;
765
766typedef struct _VRDPORDERSOLIDRECT
767{
768 int16_t x;
769 int16_t y;
770 uint16_t w;
771 uint16_t h;
772 uint32_t rgb;
773} VRDPORDERSOLIDRECT;
774
775typedef struct _VRDPORDERSOLIDBLT
776{
777 int16_t x;
778 int16_t y;
779 uint16_t w;
780 uint16_t h;
781 uint32_t rgb;
782 uint8_t rop;
783} VRDPORDERSOLIDBLT;
784
785typedef struct _VRDPORDERDSTBLT
786{
787 int16_t x;
788 int16_t y;
789 uint16_t w;
790 uint16_t h;
791 uint8_t rop;
792} VRDPORDERDSTBLT;
793
794typedef struct _VRDPORDERSCREENBLT
795{
796 int16_t x;
797 int16_t y;
798 uint16_t w;
799 uint16_t h;
800 int16_t xSrc;
801 int16_t ySrc;
802 uint8_t rop;
803} VRDPORDERSCREENBLT;
804
805typedef struct _VRDPORDERPATBLTBRUSH
806{
807 int16_t x;
808 int16_t y;
809 uint16_t w;
810 uint16_t h;
811 int8_t xSrc;
812 int8_t ySrc;
813 uint32_t rgbFG;
814 uint32_t rgbBG;
815 uint8_t rop;
816 uint8_t pattern[8];
817} VRDPORDERPATBLTBRUSH;
818
819typedef struct _VRDPORDERMEMBLT
820{
821 int16_t x;
822 int16_t y;
823 uint16_t w;
824 uint16_t h;
825 int16_t xSrc;
826 int16_t ySrc;
827 uint8_t rop;
828 VRDPBITMAPHASH hash;
829} VRDPORDERMEMBLT;
830
831typedef struct _VRDPORDERCACHEDBITMAP
832{
833 VRDPBITMAPHASH hash;
834 /* VRDPDATABITS and the bitmap data follows. */
835} VRDPORDERCACHEDBITMAP;
836
837typedef struct _VRDPORDERDELETEDBITMAP
838{
839 VRDPBITMAPHASH hash;
840} VRDPORDERDELETEDBITMAP;
841
842typedef struct _VRDPORDERLINE
843{
844 int16_t x1;
845 int16_t y1;
846 int16_t x2;
847 int16_t y2;
848 int16_t xBounds1;
849 int16_t yBounds1;
850 int16_t xBounds2;
851 int16_t yBounds2;
852 uint8_t mix;
853 uint32_t rgb;
854} VRDPORDERLINE;
855
856typedef struct _VRDPORDERPOLYLINE
857{
858 VRDPORDERPOINT ptStart;
859 uint8_t mix;
860 uint32_t rgb;
861 VRDPORDERPOLYPOINTS points;
862} VRDPORDERPOLYLINE;
863
864typedef struct _VRDPORDERELLIPSE
865{
866 VRDPORDERPOINT pt1;
867 VRDPORDERPOINT pt2;
868 uint8_t mix;
869 uint8_t fillMode;
870 uint32_t rgb;
871} VRDPORDERELLIPSE;
872
873typedef struct _VRDPORDERSAVESCREEN
874{
875 VRDPORDERPOINT pt1;
876 VRDPORDERPOINT pt2;
877 uint8_t ident;
878 uint8_t restore;
879} VRDPORDERSAVESCREEN;
880#endif /* VRDP_NO_COM */
881#pragma pack()
882
883/* The VBVA ring buffer is suitable for transferring large (< 2gb) amount of data.
884 * For example big bitmaps which do not fit to the buffer.
885 *
886 * Guest starts writing to the buffer by initializing a record entry in the
887 * aRecords queue. VBVA_F_RECORD_PARTIAL indicates that the record is being
888 * written. As data is written to the ring buffer, the guest increases off32End
889 * for the record.
890 *
891 * The host reads the aRecords on flushes and processes all completed records.
892 * When host encounters situation when only a partial record presents and
893 * cbRecord & ~VBVA_F_RECORD_PARTIAL >= VBVA_RING_BUFFER_SIZE - VBVA_RING_BUFFER_THRESHOLD,
894 * the host fetched all record data and updates off32Head. After that on each flush
895 * the host continues fetching the data until the record is completed.
896 *
897 */
898
899#define VBVA_RING_BUFFER_SIZE (_4M - _1K)
900#define VBVA_RING_BUFFER_THRESHOLD (4 * _1K)
901
902#define VBVA_MAX_RECORDS (64)
903
904#define VBVA_F_MODE_ENABLED (0x00000001)
905#define VBVA_F_MODE_VRDP (0x00000002)
906#define VBVA_F_MODE_VRDP_RESET (0x00000004)
907#define VBVA_F_MODE_VRDP_ORDER_MASK (0x00000008)
908
909#define VBVA_F_RECORD_PARTIAL (0x80000000)
910
911#pragma pack(1)
912typedef struct _VBVARECORD
913{
914 /** The length of the record. Changed by guest. */
915 uint32_t cbRecord;
916} VBVARECORD;
917
918typedef struct _VBVAMEMORY
919{
920 /** VBVA_F_MODE_* */
921 uint32_t fu32ModeFlags;
922
923 /** The offset where the data start in the buffer. */
924 uint32_t off32Data;
925 /** The offset where next data must be placed in the buffer. */
926 uint32_t off32Free;
927
928 /** The ring buffer for data. */
929 uint8_t au8RingBuffer[VBVA_RING_BUFFER_SIZE];
930
931 /** The queue of record descriptions. */
932 VBVARECORD aRecords[VBVA_MAX_RECORDS];
933 uint32_t indexRecordFirst;
934 uint32_t indexRecordFree;
935
936 /* RDP orders supported by the client. The guest reports only them
937 * and falls back to DIRTY rects for not supported ones.
938 *
939 * (1 << VBVA_VRDP_*)
940 */
941 uint32_t fu32SupportedOrders;
942
943} VBVAMEMORY;
944#pragma pack()
945
946/** @} */
947
948
949/**
950 * VMMDev RAM
951 * @{
952 */
953
954#pragma pack(1)
955/** Layout of VMMDEV RAM region that contains information for guest */
956typedef struct
957{
958 /** size */
959 uint32_t u32Size;
960 /** version */
961 uint32_t u32Version;
962
963 union {
964 /** Flag telling that VMMDev set the IRQ and acknowlegment is required */
965 struct {
966 bool fHaveEvents;
967 } V1_04;
968
969 struct {
970 /** Pending events flags, set by host. */
971 uint32_t u32HostEvents;
972 /** Mask of events the guest wants to see, set by guest. */
973 uint32_t u32GuestEventMask;
974 } V1_03;
975 } V;
976
977 VBVAMEMORY vbvaMemory;
978
979} VMMDevMemory;
980#pragma pack()
981
982/** Version of VMMDevMemory structure. */
983#define VMMDEV_MEMORY_VERSION (1)
984
985/** @} */
986
987
988/**
989 * VMMDev events.
990 * @{
991 */
992
993/** Host mouse capabilities has been changed. */
994#define VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED BIT(0)
995/** HGCM event. */
996#define VMMDEV_EVENT_HGCM BIT(1)
997/** A display change request has been issued. */
998#define VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST BIT(2)
999/** Credentials are available for judgement. */
1000#define VMMDEV_EVENT_JUDGE_CREDENTIALS BIT(3)
1001/** The guest has been restored. */
1002#define VMMDEV_EVENT_RESTORED BIT(4)
1003/** Seamless mode state changed */
1004#define VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST BIT(5)
1005/** Memory balloon size changed */
1006#define VMMDEV_EVENT_BALLOON_CHANGE_REQUEST BIT(6)
1007/** Statistics interval changed */
1008#define VMMDEV_EVENT_STATISTICS_INTERVAL_CHANGE_REQUEST BIT(7)
1009/** VRDP status changed. */
1010#define VMMDEV_EVENT_VRDP BIT(7)
1011
1012
1013/** @} */
1014
1015
1016/**
1017 * VBoxGuest IOCTL codes and structures.
1018 *
1019 * The range 0..15 is for basic driver communication.
1020 * The range 16..31 is for HGCM communcation.
1021 * The range 32..47 is reserved for future use.
1022 * The range 48..63 is for OS specific communcation.
1023 * The 7th bit is reserved for future hacks.
1024 * The 8th bit is reserved for distinguishing between 32-bit and 64-bit
1025 * processes in future 64-bit guest additions.
1026 *
1027 * While windows IOCTL function number has to start at 2048 and stop at 4096 there
1028 * never was any need to do this for everyone. A simple ((Function) | 0x800) would
1029 * have sufficed. On Linux we're now intruding upon the type field. Fortunately
1030 * this hasn't caused any trouble because the FILE_DEVICE_UNKNOWN value was set
1031 * to 0x22 (if it were 0x2C it would not have worked soo smoothly). The situation
1032 * would've been the same for *BSD and Darwin since they seems to share common
1033 * _IOC() heritage.
1034 *
1035 * However, on good old OS/2 we only have 8-bit handy for the function number. The
1036 * result from using the old IOCTL function numbers her would've been overlapping
1037 * between the two ranges.
1038 *
1039 * To fix this problem and get rid of all the unnecessary windowsy crap that I
1040 * bet was copied from my SUPDRVIOC.h once upon a time (although the concept of
1041 * prefixing macros with the purpose of avoid clashes with system stuff and
1042 * to indicate exactly how owns them seems to have been lost somewhere along
1043 * the way), I've introduced a VBOXGUEST_IOCTL_CODE for defining generic IN/OUT
1044 * IOCtls on new ports of the additions.
1045 *
1046 * @remark When creating new IOCtl interfaces keep in mind that not all OSes supports
1047 * reporting back the output size. (This got messed up a little bit in VBoxDrv.)
1048 *
1049 * OS/2 restricts the in/out data size to 64KB, while Linux, BSD and Darwin are
1050 * limited by a 14 bits size field (16KB). So, special considerations need to
1051 * be taken if more input/output needs to be passed around.
1052 *
1053 * When passing variable sized input/output special care need to be taken on
1054 * Unix platforms (if we're going to play by the rules) since the size is
1055 * passed as part of the IOCtl code there. IIRC Darwin will use the size to
1056 * perform locking and in/out copying, I don't quite know about linux and *BSD.
1057 *
1058 * @remark If adding interfaces that only has input or only has output, some new macros
1059 * needs to be created so the most efficient IOCtl data buffering method can be
1060 * used.
1061 *
1062 * @{
1063 */
1064#ifdef RT_ARCH_AMD64
1065# define VBOXGUEST_IOCTL_FLAG 128
1066#elif defined(RT_ARCH_X86)
1067# define VBOXGUEST_IOCTL_FLAG 0
1068#else
1069# error "dunno which arch this is!"
1070#endif
1071
1072#if defined(RT_OS_WINDOWS)
1073# define IOCTL_CODE(DeviceType, Function, Method, Access, DataSize_ignored) \
1074 ( ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method))
1075
1076#elif defined(RT_OS_OS2)
1077# define VBOXGUEST_IOCTL_CATEGORY 0xc2
1078# define VBOXGUEST_IOCTL_CODE(Function, Size) ((unsigned char)(Function))
1079# define VBOXGUEST_IOCTL_CATEGORY_FAST 0xc3 /**< Also defined in VBoxGuestA-os2.asm. */
1080# define VBOXGUEST_IOCTL_CODE_FAST(Function) ((unsigned char)(Function))
1081
1082#elif defined(RT_OS_LINUX)
1083# define IOCTL_CODE(DeviceType, Function, Method_ignored, Access_ignored, DataSize) \
1084 ( (3 << 30) | ((DeviceType) << 8) | (Function) | ((DataSize) << 16) )
1085# define METHOD_BUFFERED 0
1086# define FILE_WRITE_ACCESS 0x0002
1087# define FILE_DEVICE_UNKNOWN 0x00000022
1088
1089#elif 0 /* BSD style - needs some adjusting _IORW takes a type and not a size. */
1090# include <sys/ioccom.h>
1091# define VBOXGUEST_IOCTL_CODE(Function, Size) _IORW('V', (Function) | VBOXGUEST_IOCTL_FLAG, (Size))
1092# define VBOXGUEST_IOCTL_CODE_FAST(Function) _IO( 'V', (Function) | VBOXGUEST_IOCTL_FLAG)
1093
1094#else
1095/* PORTME */
1096#endif
1097
1098/** IOCTL to VBoxGuest to query the VMMDev IO port region start. */
1099#ifdef VBOXGUEST_IOCTL_CODE
1100# define VBOXGUEST_IOCTL_GETVMMDEVPORT VBOXGUEST_IOCTL_CODE(1, sizeof(VBoxGuestPortInfo))
1101# define IOCTL_VBOXGUEST_GETVMMDEVPORT VBOXGUEST_IOCTL_GETVMMDEVPORT
1102#else
1103# define IOCTL_VBOXGUEST_GETVMMDEVPORT IOCTL_CODE(FILE_DEVICE_UNKNOWN, 2048, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof(VBoxGuestPortInfo))
1104#endif
1105
1106#pragma pack(4)
1107typedef struct _VBoxGuestPortInfo
1108{
1109 uint32_t portAddress;
1110 VMMDevMemory *pVMMDevMemory;
1111} VBoxGuestPortInfo;
1112
1113/** IOCTL to VBoxGuest to wait for a VMMDev host notification */
1114#ifdef VBOXGUEST_IOCTL_CODE
1115# define VBOXGUEST_IOCTL_WAITEVENT VBOXGUEST_IOCTL_CODE(2, sizeof(VBoxGuestWaitEventInfo))
1116# define IOCTL_VBOXGUEST_WAITEVENT VBOXGUEST_IOCTL_WAITEVENT
1117#else
1118# define IOCTL_VBOXGUEST_WAITEVENT IOCTL_CODE(FILE_DEVICE_UNKNOWN, 2049, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof(VBoxGuestWaitEventInfo))
1119#endif
1120
1121/**
1122 * Result codes for VBoxGuestWaitEventInfo::u32Result
1123 * @{
1124 */
1125/** Successful completion, an event occured. */
1126#define VBOXGUEST_WAITEVENT_OK (0)
1127/** Successful completion, timed out. */
1128#define VBOXGUEST_WAITEVENT_TIMEOUT (1)
1129/** Wait was interrupted. */
1130#define VBOXGUEST_WAITEVENT_INTERRUPTED (2)
1131/** An error occured while processing the request. */
1132#define VBOXGUEST_WAITEVENT_ERROR (3)
1133/** @} */
1134
1135/** Input and output buffers layout of the IOCTL_VBOXGUEST_WAITEVENT */
1136typedef struct _VBoxGuestWaitEventInfo
1137{
1138 /** timeout in milliseconds */
1139 uint32_t u32TimeoutIn;
1140 /** events to wait for */
1141 uint32_t u32EventMaskIn;
1142 /** result code */
1143 uint32_t u32Result;
1144 /** events occured */
1145 uint32_t u32EventFlagsOut;
1146} VBoxGuestWaitEventInfo;
1147
1148/** IOCTL to VBoxGuest to perform a VMM request
1149 * @remark The data buffer for this IOCtl has an variable size, keep this in mind
1150 * on systems where this matters. */
1151#ifdef VBOXGUEST_IOCTL_CODE
1152# define VBOXGUEST_IOCTL_VMMREQUEST(Size) VBOXGUEST_IOCTL_CODE(3, sizeof(VMMDevRequestHeader))
1153# define IOCTL_VBOXGUEST_VMMREQUEST VBOXGUEST_IOCTL_VMMREQUEST(sizeof(VMMDevRequestHeader))
1154#else
1155# define IOCTL_VBOXGUEST_VMMREQUEST IOCTL_CODE(FILE_DEVICE_UNKNOWN, 2050, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof(VMMDevRequestHeader))
1156#endif
1157
1158/** Input and output buffer layout of the IOCTL_VBOXGUEST_CTL_FILTER_MASK. */
1159typedef struct _VBoxGuestFilterMaskInfo
1160{
1161 uint32_t u32OrMask;
1162 uint32_t u32NotMask;
1163} VBoxGuestFilterMaskInfo;
1164#pragma pack()
1165
1166/** IOCTL to VBoxGuest to control event filter mask */
1167#ifdef VBOXGUEST_IOCTL_CODE
1168# define VBOXGUEST_IOCTL_CTL_FILTER_MASK VBOXGUEST_IOCTL_CODE(4, sizeof(VBoxGuestFilterMaskInfo))
1169# define IOCTL_VBOXGUEST_CTL_FILTER_MASK VBOXGUEST_IOCTL_CTL_FILTER_MASK
1170#else
1171# define IOCTL_VBOXGUEST_CTL_FILTER_MASK IOCTL_CODE(FILE_DEVICE_UNKNOWN, 2051, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof (VBoxGuestFilterMaskInfo))
1172#endif
1173
1174/** IOCTL to VBoxGuest to check memory ballooning */
1175#ifdef VBOXGUEST_IOCTL_CODE
1176# define VBOXGUEST_IOCTL_CTL_CHECK_BALLOON_MASK VBOXGUEST_IOCTL_CODE(4, 100)
1177# define IOCTL_VBOXGUEST_CTL_CHECK_BALLOON VBOXGUEST_IOCTL_CTL_CHECK_BALLOON_MASK
1178#else
1179# define IOCTL_VBOXGUEST_CTL_CHECK_BALLOON IOCTL_CODE(FILE_DEVICE_UNKNOWN, 2052, METHOD_BUFFERED, FILE_WRITE_ACCESS, 0)
1180#endif
1181
1182#ifdef VBOX_HGCM
1183/* These structures are shared between the driver and other binaries,
1184 * therefore packing must be defined explicitely.
1185 */
1186#pragma pack(1)
1187typedef struct _VBoxGuestHGCMConnectInfo
1188{
1189 uint32_t result; /**< OUT */
1190 HGCMServiceLocation Loc; /**< IN */
1191 uint32_t u32ClientID; /**< OUT */
1192} VBoxGuestHGCMConnectInfo;
1193
1194typedef struct _VBoxGuestHGCMDisconnectInfo
1195{
1196 uint32_t result; /**< OUT */
1197 uint32_t u32ClientID; /**< IN */
1198} VBoxGuestHGCMDisconnectInfo;
1199
1200typedef struct _VBoxGuestHGCMCallInfo
1201{
1202 uint32_t result; /**< OUT Host HGCM return code.*/
1203 uint32_t u32ClientID; /**< IN The id of the caller. */
1204 uint32_t u32Function; /**< IN Function number. */
1205 uint32_t cParms; /**< IN How many parms. */
1206 /* Parameters follow in form HGCMFunctionParameter aParms[cParms] */
1207} VBoxGuestHGCMCallInfo;
1208#pragma pack()
1209
1210#ifdef VBOXGUEST_IOCTL_CODE
1211# define VBOXGUEST_IOCTL_HGCM_CONNECT VBOXGUEST_IOCTL_CODE(16, sizeof(VBoxGuestHGCMConnectInfo))
1212# define IOCTL_VBOXGUEST_HGCM_CONNECT VBOXGUEST_IOCTL_HGCM_CONNECT
1213# define VBOXGUEST_IOCTL_HGCM_DISCONNECT VBOXGUEST_IOCTL_CODE(17, sizeof(VBoxGuestHGCMDisconnectInfo))
1214# define IOCTL_VBOXGUEST_HGCM_DISCONNECT VBOXGUEST_IOCTL_HGCM_DISCONNECT
1215# define VBOXGUEST_IOCTL_HGCM_CALL(Size) VBOXGUEST_IOCTL_CODE(18, (Size))
1216# define IOCTL_VBOXGUEST_HGCM_CALL VBOXGUEST_IOCTL_HGCM_CALL(sizeof(VBoxGuestHGCMCallInfo))
1217# define VBOXGUEST_IOCTL_CLIPBOARD_CONNECT VBOXGUEST_IOCTL_CODE(19, sizeof(uint32_t))
1218# define IOCTL_VBOXGUEST_CLIPBOARD_CONNECT VBOXGUEST_IOCTL_CLIPBOARD_CONNECT
1219#else
1220# define IOCTL_VBOXGUEST_HGCM_CONNECT IOCTL_CODE(FILE_DEVICE_UNKNOWN, 3072, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof(VBoxGuestHGCMConnectInfo))
1221# define IOCTL_VBOXGUEST_HGCM_DISCONNECT IOCTL_CODE(FILE_DEVICE_UNKNOWN, 3073, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof(VBoxGuestHGCMDisconnectInfo))
1222# define IOCTL_VBOXGUEST_HGCM_CALL IOCTL_CODE(FILE_DEVICE_UNKNOWN, 3074, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof(VBoxGuestHGCMCallInfo))
1223# define IOCTL_VBOXGUEST_CLIPBOARD_CONNECT IOCTL_CODE(FILE_DEVICE_UNKNOWN, 3075, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof(uint32_t))
1224#endif
1225
1226#define VBOXGUEST_HGCM_CALL_PARMS(a) ((HGCMFunctionParameter *)((uint8_t *)(a) + sizeof (VBoxGuestHGCMCallInfo)))
1227
1228#endif /* VBOX_HGCM */
1229
1230/*
1231 * Credentials request flags and structure
1232 */
1233
1234#define VMMDEV_CREDENTIALS_STRLEN 128
1235
1236/** query from host whether credentials are present */
1237#define VMMDEV_CREDENTIALS_QUERYPRESENCE BIT(1)
1238/** read credentials from host (can be combined with clear) */
1239#define VMMDEV_CREDENTIALS_READ BIT(2)
1240/** clear credentials on host (can be combined with read) */
1241#define VMMDEV_CREDENTIALS_CLEAR BIT(3)
1242/** read credentials for judgement in the guest */
1243#define VMMDEV_CREDENTIALS_READJUDGE BIT(8)
1244/** clear credentials for judegement on the host */
1245#define VMMDEV_CREDENTIALS_CLEARJUDGE BIT(9)
1246/** report credentials acceptance by guest */
1247#define VMMDEV_CREDENTIALS_JUDGE_OK BIT(10)
1248/** report credentials denial by guest */
1249#define VMMDEV_CREDENTIALS_JUDGE_DENY BIT(11)
1250/** report that no judgement could be made by guest */
1251#define VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT BIT(12)
1252
1253/** flag telling the guest that credentials are present */
1254#define VMMDEV_CREDENTIALS_PRESENT BIT(16)
1255/** flag telling guest that local logons should be prohibited */
1256#define VMMDEV_CREDENTIALS_NOLOCALLOGON BIT(17)
1257
1258/** credentials request structure */
1259#pragma pack(4)
1260typedef struct _VMMDevCredentials
1261{
1262 /* request header */
1263 VMMDevRequestHeader header;
1264 /* request flags (in/out) */
1265 uint32_t u32Flags;
1266 /* user name (UTF-8) (out) */
1267 char szUserName[VMMDEV_CREDENTIALS_STRLEN];
1268 /* password (UTF-8) (out) */
1269 char szPassword[VMMDEV_CREDENTIALS_STRLEN];
1270 /* domain name (UTF-8) (out) */
1271 char szDomain[VMMDEV_CREDENTIALS_STRLEN];
1272} VMMDevCredentials;
1273#pragma pack()
1274
1275/** inline helper to determine the request size for the given operation */
1276DECLINLINE(size_t) vmmdevGetRequestSize(VMMDevRequestType requestType)
1277{
1278 switch (requestType)
1279 {
1280 case VMMDevReq_GetMouseStatus:
1281 case VMMDevReq_SetMouseStatus:
1282 return sizeof(VMMDevReqMouseStatus);
1283 case VMMDevReq_SetPointerShape:
1284 return sizeof(VMMDevReqMousePointer);
1285 case VMMDevReq_GetHostVersion:
1286 return sizeof(VMMDevReqHostVersion);
1287 case VMMDevReq_Idle:
1288 return sizeof(VMMDevReqIdle);
1289 case VMMDevReq_GetHostTime:
1290 return sizeof(VMMDevReqHostTime);
1291 case VMMDevReq_GetHypervisorInfo:
1292 case VMMDevReq_SetHypervisorInfo:
1293 return sizeof(VMMDevReqHypervisorInfo);
1294 case VMMDevReq_SetPowerStatus:
1295 return sizeof(VMMDevPowerStateRequest);
1296 case VMMDevReq_AcknowledgeEvents:
1297 return sizeof(VMMDevEvents);
1298 case VMMDevReq_ReportGuestInfo:
1299 return sizeof(VMMDevReportGuestInfo);
1300 case VMMDevReq_GetDisplayChangeRequest:
1301 return sizeof(VMMDevDisplayChangeRequest);
1302 case VMMDevReq_GetDisplayChangeRequest2:
1303 return sizeof(VMMDevDisplayChangeRequest2);
1304 case VMMDevReq_VideoModeSupported:
1305 return sizeof(VMMDevVideoModeSupportedRequest);
1306 case VMMDevReq_GetHeightReduction:
1307 return sizeof(VMMDevGetHeightReductionRequest);
1308 case VMMDevReq_ReportGuestCapabilities:
1309 return sizeof(VMMDevReqGuestCapabilities);
1310#ifdef VBOX_HGCM
1311 case VMMDevReq_HGCMConnect:
1312 return sizeof(VMMDevHGCMConnect);
1313 case VMMDevReq_HGCMDisconnect:
1314 return sizeof(VMMDevHGCMDisconnect);
1315 case VMMDevReq_HGCMCall:
1316 return sizeof(VMMDevHGCMCall);
1317#endif
1318 case VMMDevReq_VideoAccelEnable:
1319 return sizeof(VMMDevVideoAccelEnable);
1320 case VMMDevReq_VideoAccelFlush:
1321 return sizeof(VMMDevVideoAccelFlush);
1322 case VMMDevReq_VideoSetVisibleRegion:
1323 return sizeof(VMMDevVideoSetVisibleRegion);
1324 case VMMDevReq_GetSeamlessChangeRequest:
1325 return sizeof(VMMDevSeamlessChangeRequest);
1326 case VMMDevReq_QueryCredentials:
1327 return sizeof(VMMDevCredentials);
1328 case VMMDevReq_ReportGuestStats:
1329 return sizeof(VMMDevReportGuestStats);
1330 case VMMDevReq_GetMemBalloonChangeRequest:
1331 return sizeof(VMMDevGetMemBalloonChangeRequest);
1332 case VMMDevReq_GetStatisticsChangeRequest:
1333 return sizeof(VMMDevGetStatisticsChangeRequest);
1334 case VMMDevReq_ChangeMemBalloon:
1335 return sizeof(VMMDevChangeMemBalloon);
1336 case VMMDevReq_LogString:
1337 return sizeof(VMMDevReqLogString);
1338 default:
1339 return 0;
1340 }
1341}
1342
1343/**
1344 * Initializes a request structure.
1345 *
1346 */
1347DECLINLINE(int) vmmdevInitRequest(VMMDevRequestHeader *req, VMMDevRequestType type)
1348{
1349 uint32_t requestSize;
1350 if (!req)
1351 return VERR_INVALID_PARAMETER;
1352 requestSize = (uint32_t)vmmdevGetRequestSize(type);
1353 if (!requestSize)
1354 return VERR_INVALID_PARAMETER;
1355 req->size = requestSize;
1356 req->version = VMMDEV_REQUEST_HEADER_VERSION;
1357 req->requestType = type;
1358 req->rc = VERR_GENERAL_FAILURE;
1359 req->reserved1 = 0;
1360 req->reserved2 = 0;
1361 return VINF_SUCCESS;
1362}
1363
1364
1365#ifdef RT_OS_OS2
1366
1367/**
1368 * The data buffer layout for the IDC entry point (AttachDD).
1369 *
1370 * @remark This is defined in multiple 16-bit headers / sources.
1371 * Some places it's called VBGOS2IDC to short things a bit.
1372 */
1373typedef struct VBOXGUESTOS2IDCCONNECT
1374{
1375 /** VMMDEV_VERSION. */
1376 uint32_t u32Version;
1377 /** Opaque session handle. */
1378 uint32_t u32Session;
1379
1380 /**
1381 * The 32-bit service entry point.
1382 *
1383 * @returns VBox status code.
1384 * @param u32Session The above session handle.
1385 * @param iFunction The requested function.
1386 * @param pvData The input/output data buffer. The caller ensures that this
1387 * cannot be swapped out, or that it's acceptable to take a
1388 * page in fault in the current context. If the request doesn't
1389 * take input or produces output, apssing NULL is okay.
1390 * @param cbData The size of the data buffer.
1391 * @param pcbDataReturned Where to store the amount of data that's returned.
1392 * This can be NULL if pvData is NULL.
1393 */
1394 DECLCALLBACKMEMBER(int, pfnServiceEP)(uint32_t u32Session, unsigned iFunction, void *pvData, size_t cbData, size_t *pcbDataReturned);
1395
1396 /** The 16-bit service entry point for C code (cdecl).
1397 *
1398 * It's the same as the 32-bit entry point, but the types has
1399 * changed to 16-bit equivalents.
1400 *
1401 * @code
1402 * int far cdecl
1403 * VBoxGuestOs2IDCService16(uint32_t u32Session, uint16_t iFunction,
1404 * void far *fpvData, uint16_t cbData, uint16_t far *pcbDataReturned);
1405 * @endcode
1406 */
1407 RTFAR16 fpfnServiceEP;
1408
1409 /** The 16-bit service entry point for Assembly code (register).
1410 *
1411 * This is just a wrapper around fpfnServiceEP to simplify calls
1412 * from 16-bit assembly code.
1413 *
1414 * @returns (e)ax: VBox status code; cx: The amount of data returned.
1415 *
1416 * @param u32Session eax - The above session handle.
1417 * @param iFunction dl - The requested function.
1418 * @param pvData es:bx - The input/output data buffer.
1419 * @param cbData cx - The size of the data buffer.
1420 */
1421 RTFAR16 fpfnServiceAsmEP;
1422} VBOXGUESTOS2IDCCONNECT;
1423/** Pointer to VBOXGUESTOS2IDCCONNECT buffer. */
1424typedef VBOXGUESTOS2IDCCONNECT *PVBOXGUESTOS2IDCCONNECT;
1425
1426/** OS/2 specific: IDC client disconnect request.
1427 *
1428 * This takes no input and it doesn't return anything. Obviously this
1429 * is only recognized if it arrives thru the IDC service EP.
1430 */
1431#define VBOXGUEST_IOCTL_OS2_IDC_DISCONNECT VBOXGUEST_IOCTL_CODE(48, sizeof(uint32_t))
1432
1433#endif /* RT_OS_OS2 */
1434
1435/** @} */
1436
1437
1438#ifdef IN_RING3
1439
1440/** @def VBGLR3DECL
1441 * Ring 3 VBGL declaration.
1442 * @param type The return type of the function declaration.
1443 */
1444#define VBGLR3DECL(type) type VBOXCALL
1445
1446/* General-purpose functions */
1447
1448__BEGIN_DECLS
1449VBGLR3DECL(int) VbglR3Init(void);
1450VBGLR3DECL(void) VbglR3Term(void);
1451VBGLR3DECL(int) VbglR3GRPerform(VMMDevRequestHeader *pReq);
1452# ifdef __iprt_time_h__
1453VBGLR3DECL(int) VbglR3GetHostTime(PRTTIMESPEC pTime);
1454# endif
1455VBGLR3DECL(int) VbglR3InterruptEventWaits(void);
1456
1457/* Shared clipboard */
1458
1459VBGLR3DECL(int) VbglR3ClipboardConnect(uint32_t *pu32ClientId);
1460VBGLR3DECL(int) VbglR3ClipboardDisconnect(uint32_t u32ClientId);
1461VBGLR3DECL(int) VbglR3ClipboardGetHostMsg(uint32_t u32ClientId, uint32_t *pMsg, uint32_t *pfFormats);
1462VBGLR3DECL(int) VbglR3ClipboardReadData(uint32_t u32ClientId, uint32_t fFormat, void *pv, uint32_t cb, uint32_t *pcb);
1463VBGLR3DECL(int) VbglR3ClipboardReportFormats(uint32_t u32ClientId, uint32_t fFormats);
1464VBGLR3DECL(int) VbglR3ClipboardWriteData(uint32_t u32ClientId, uint32_t fFormat, void *pv, uint32_t cb);
1465
1466/* Seamless mode */
1467
1468VBGLR3DECL(int) VbglR3SeamlessSetCap(bool bState);
1469VBGLR3DECL(int) VbglR3SeamlessWaitEvent(VMMDevSeamlessMode *pMode);
1470VBGLR3DECL(int) VbglR3SeamlessSendRects(uint32_t cRects, PRTRECT pRects);
1471
1472__END_DECLS
1473
1474#endif /* IN_RING3 */
1475
1476#endif
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette