VirtualBox

source: vbox/trunk/src/VBox/Main/ConsoleVRDPServer.cpp@ 3823

Last change on this file since 3823 was 3823, checked in by vboxsync, 17 years ago

GCC warnings.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 62.0 KB
Line 
1/** @file
2 *
3 * VBox Console VRDP Helper class
4 */
5
6/*
7 * Copyright (C) 2006-2007 innotek GmbH
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License as published by the Free Software Foundation,
13 * in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14 * distribution. VirtualBox OSE is distributed in the hope that it will
15 * be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * If you received this file as part of a commercial VirtualBox
18 * distribution, then only the terms of your commercial VirtualBox
19 * license agreement apply instead of the previous paragraph.
20 */
21
22#include "ConsoleVRDPServer.h"
23#include "ConsoleImpl.h"
24#include "DisplayImpl.h"
25#ifdef VRDP_NO_COM
26#include "KeyboardImpl.h"
27#include "MouseImpl.h"
28#include <VBox/VRDPOrders.h>
29#endif /* VRDP_NO_COM */
30
31#include "Logging.h"
32
33#include <iprt/asm.h>
34#include <iprt/ldr.h>
35
36#include <VBox/err.h>
37
38#ifdef VRDP_NO_COM
39class VRDPConsoleCallback : public IConsoleCallback
40{
41public:
42 VRDPConsoleCallback (ConsoleVRDPServer *server) :
43 m_server(server)
44 {
45#ifndef VBOX_WITH_XPCOM
46 refcnt = 0;
47#endif /* !VBOX_WITH_XPCOM */
48 }
49
50 virtual ~VRDPConsoleCallback() {}
51
52 NS_DECL_ISUPPORTS
53
54#ifndef VBOX_WITH_XPCOM
55 STDMETHOD_(ULONG, AddRef)() {
56 return ::InterlockedIncrement (&refcnt);
57 }
58 STDMETHOD_(ULONG, Release)()
59 {
60 long cnt = ::InterlockedDecrement (&refcnt);
61 if (cnt == 0)
62 delete this;
63 return cnt;
64 }
65 STDMETHOD(QueryInterface) (REFIID riid , void **ppObj)
66 {
67 if (riid == IID_IUnknown) {
68 *ppObj = this;
69 AddRef();
70 return S_OK;
71 }
72 if (riid == IID_IConsoleCallback) {
73 *ppObj = this;
74 AddRef();
75 return S_OK;
76 }
77 *ppObj = NULL;
78 return E_NOINTERFACE;
79 }
80#endif /* !VBOX_WITH_XPCOM */
81
82
83 STDMETHOD(OnMousePointerShapeChange)(BOOL visible, BOOL alpha, ULONG xHot, ULONG yHot,
84 ULONG width, ULONG height, BYTE *shape);
85
86 STDMETHOD(OnMouseCapabilityChange)(BOOL supportsAbsolute, BOOL needsHostCursor)
87 {
88 if (m_server)
89 {
90 m_server->NotifyAbsoluteMouse(!!supportsAbsolute);
91 }
92 return S_OK;
93 }
94
95 STDMETHOD(OnStateChange)(MachineState_T machineState)
96 {
97 return S_OK;
98 }
99
100 STDMETHOD(OnAdditionsStateChange)()
101 {
102 return S_OK;
103 }
104
105 STDMETHOD(OnKeyboardLedsChange)(BOOL fNumLock, BOOL fCapsLock, BOOL fScrollLock)
106 {
107 return S_OK;
108 }
109
110 STDMETHOD(OnUSBDeviceStateChange)(IUSBDevice *device, BOOL attached,
111 IVirtualBoxErrorInfo *message)
112 {
113 return S_OK;
114 }
115
116 STDMETHOD(OnRuntimeError)(BOOL fatal, INPTR BSTR id, INPTR BSTR message)
117 {
118 return S_OK;
119 }
120
121 STDMETHOD(OnCanShowWindow)(BOOL *canShow)
122 {
123 if (!canShow)
124 return E_POINTER;
125 /* we don't manage window activation here: always agree */
126 *canShow = TRUE;
127 return S_OK;
128 }
129
130 STDMETHOD(OnShowWindow) (ULONG64 *winId)
131 {
132 if (!winId)
133 return E_POINTER;
134 /* we don't manage window activation here */
135 *winId = 0;
136 return S_OK;
137 }
138
139private:
140 ConsoleVRDPServer *m_server;
141#ifndef VBOX_WITH_XPCOM
142 long refcnt;
143#endif /* !VBOX_WITH_XPCOM */
144};
145
146#ifdef VBOX_WITH_XPCOM
147#include <nsMemory.h>
148NS_DECL_CLASSINFO(VRDPConsoleCallback)
149NS_IMPL_ISUPPORTS1_CI(VRDPConsoleCallback, IConsoleCallback)
150#endif /* VBOX_WITH_XPCOM */
151
152static void findTopLeftBorder (uint8_t *pu8Shape, uint32_t width, uint32_t height, uint32_t *pxSkip, uint32_t *pySkip)
153{
154 /*
155 * Find the top border of the AND mask. First assign to special value.
156 */
157 uint32_t ySkipAnd = ~0;
158
159 uint8_t *pu8And = pu8Shape;
160 const uint32_t cbAndRow = (width + 7) / 8;
161 const uint8_t maskLastByte = (uint8_t)( 0xFF << (cbAndRow * 8 - width) );
162
163 Assert(cbAndRow > 0);
164
165 unsigned y;
166 unsigned x;
167
168 for (y = 0; y < height && ySkipAnd == ~(uint32_t)0; y++, pu8And += cbAndRow)
169 {
170 /* For each complete byte in the row. */
171 for (x = 0; x < cbAndRow - 1; x++)
172 {
173 if (pu8And[x] != 0xFF)
174 {
175 ySkipAnd = y;
176 break;
177 }
178 }
179
180 if (ySkipAnd == ~(uint32_t)0)
181 {
182 /* Last byte. */
183 if ((pu8And[cbAndRow - 1] & maskLastByte) != maskLastByte)
184 {
185 ySkipAnd = y;
186 }
187 }
188 }
189
190 if (ySkipAnd == ~(uint32_t)0)
191 {
192 ySkipAnd = 0;
193 }
194
195 /*
196 * Find the left border of the AND mask.
197 */
198 uint32_t xSkipAnd = ~0;
199
200 /* For all bit columns. */
201 for (x = 0; x < width && xSkipAnd == ~(uint32_t)0; x++)
202 {
203 pu8And = pu8Shape + x/8; /* Currently checking byte. */
204 uint8_t mask = 1 << (7 - x%8); /* Currently checking bit in the byte. */
205
206 for (y = ySkipAnd; y < height; y++, pu8And += cbAndRow)
207 {
208 if ((*pu8And & mask) == 0)
209 {
210 xSkipAnd = x;
211 break;
212 }
213 }
214 }
215
216 if (xSkipAnd == ~(uint32_t)0)
217 {
218 xSkipAnd = 0;
219 }
220
221 /*
222 * Find the XOR mask top border.
223 */
224 uint32_t ySkipXor = ~0;
225
226 uint32_t *pu32XorStart = (uint32_t *)( pu8Shape + ((cbAndRow * height + 3) & ~3) );
227
228 uint32_t *pu32Xor = pu32XorStart;
229
230 for (y = 0; y < height && ySkipXor == ~(uint32_t)0; y++, pu32Xor += width)
231 {
232 for (x = 0; x < width; x++)
233 {
234 if (pu32Xor[x] != 0)
235 {
236 ySkipXor = y;
237 break;
238 }
239 }
240 }
241
242 if (ySkipXor == ~(uint32_t)0)
243 {
244 ySkipXor = 0;
245 }
246
247 /*
248 * Find the left border of the XOR mask.
249 */
250 uint32_t xSkipXor = ~(uint32_t)0;
251
252 /* For all columns. */
253 for (x = 0; x < width && xSkipXor == ~(uint32_t)0; x++)
254 {
255 pu32Xor = pu32XorStart + x; /* Currently checking dword. */
256
257 for (y = ySkipXor; y < height; y++, pu32Xor += width)
258 {
259 if (*pu32Xor != 0)
260 {
261 xSkipXor = x;
262 break;
263 }
264 }
265 }
266
267 if (xSkipXor == ~(uint32_t)0)
268 {
269 xSkipXor = 0;
270 }
271
272 *pxSkip = RT_MIN (xSkipAnd, xSkipXor);
273 *pySkip = RT_MIN (ySkipAnd, ySkipXor);
274}
275
276
277STDMETHODIMP VRDPConsoleCallback::OnMousePointerShapeChange (BOOL visible, BOOL alpha, ULONG xHot, ULONG yHot,
278 ULONG width, ULONG height, BYTE *shape)
279{
280 Log(("VRDPConsoleCallback::OnMousePointerShapeChange: %d, %d, %dx%d, @%d,%d\n", visible, alpha, width, height, xHot, yHot));
281
282 if (m_server)
283 {
284 if (!shape)
285 {
286 if (!visible)
287 {
288 m_server->MousePointerHide ();
289 }
290 }
291 else if (width != 0 && height != 0)
292 {
293 /* Pointer consists of 1 bpp AND and 24 BPP XOR masks.
294 * 'shape' AND mask followed by XOR mask.
295 * XOR mask contains 32 bit (lsb)BGR0(msb) values.
296 *
297 * We convert this to RDP color format which consist of
298 * one bpp AND mask and 24 BPP (BGR) color XOR image.
299 *
300 * RDP clients expect 8 aligned width and height of
301 * pointer (preferably 32x32).
302 *
303 * They even contain bugs which do not appear for
304 * 32x32 pointers but would appear for a 41x32 one.
305 *
306 * So set pointer size to 32x32. This can be done safely
307 * because most pointers are 32x32.
308 */
309
310 /* Windows guest alpha pointers are wider than 32 pixels.
311 * Try to find out the top-left border of the pointer and
312 * then copy only meaningful bits. All complete top rows
313 * and all complete left columns where (AND == 1 && XOR == 0)
314 * are skipped. Hot spot is adjusted.
315 */
316 uint32_t ySkip = 0; /* How many rows to skip at the top. */
317 uint32_t xSkip = 0; /* How many columns to skip at the left. */
318
319 findTopLeftBorder (shape, width, height, &xSkip, &ySkip);
320
321 /* Must not skip the hot spot. */
322 xSkip = RT_MIN (xSkip, xHot);
323 ySkip = RT_MIN (ySkip, yHot);
324
325 /*
326 * Compute size and allocate memory for the pointer.
327 */
328 const uint32_t dstwidth = 32;
329 const uint32_t dstheight = 32;
330
331 VRDPCOLORPOINTER *pointer = NULL;
332
333 uint32_t dstmaskwidth = (dstwidth + 7) / 8;
334
335 uint32_t rdpmaskwidth = dstmaskwidth;
336 uint32_t rdpmasklen = dstheight * rdpmaskwidth;
337
338 uint32_t rdpdatawidth = dstwidth * 3;
339 uint32_t rdpdatalen = dstheight * rdpdatawidth;
340
341 pointer = (VRDPCOLORPOINTER *)RTMemTmpAlloc (sizeof (VRDPCOLORPOINTER) + rdpmasklen + rdpdatalen);
342
343 if (pointer)
344 {
345 uint8_t *maskarray = (uint8_t *)pointer + sizeof (VRDPCOLORPOINTER);
346 uint8_t *dataarray = maskarray + rdpmasklen;
347
348 memset (maskarray, 0xFF, rdpmasklen);
349 memset (dataarray, 0x00, rdpdatalen);
350
351 uint32_t srcmaskwidth = (width + 7) / 8;
352 uint32_t srcdatawidth = width * 4;
353
354 /* Copy AND mask. */
355 uint8_t *src = shape + ySkip * srcmaskwidth;
356 uint8_t *dst = maskarray + (dstheight - 1) * rdpmaskwidth;
357
358 uint32_t minheight = RT_MIN (height - ySkip, dstheight);
359 uint32_t minwidth = RT_MIN (width - xSkip, dstwidth);
360
361 unsigned x, y;
362
363 for (y = 0; y < minheight; y++)
364 {
365 for (x = 0; x < minwidth; x++)
366 {
367 uint32_t byteIndex = (x + xSkip) / 8;
368 uint32_t bitIndex = (x + xSkip) % 8;
369
370 bool bit = (src[byteIndex] & (1 << (7 - bitIndex))) != 0;
371
372 if (!bit)
373 {
374 byteIndex = x / 8;
375 bitIndex = x % 8;
376
377 dst[byteIndex] &= ~(1 << (7 - bitIndex));
378 }
379 }
380
381 src += srcmaskwidth;
382 dst -= rdpmaskwidth;
383 }
384
385 /* Point src to XOR mask */
386 src = shape + ((srcmaskwidth * height + 3) & ~3) + ySkip * srcdatawidth;
387 dst = dataarray + (dstheight - 1) * rdpdatawidth;
388
389 for (y = 0; y < minheight ; y++)
390 {
391 for (x = 0; x < minwidth; x++)
392 {
393 memcpy (dst + x * 3, &src[4 * (x + xSkip)], 3);
394 }
395
396 src += srcdatawidth;
397 dst -= rdpdatawidth;
398 }
399
400 pointer->u16HotX = (uint16_t)(xHot - xSkip);
401 pointer->u16HotY = (uint16_t)(yHot - ySkip);
402
403 pointer->u16Width = (uint16_t)dstwidth;
404 pointer->u16Height = (uint16_t)dstheight;
405
406 pointer->u16MaskLen = (uint16_t)rdpmasklen;
407 pointer->u16DataLen = (uint16_t)rdpdatalen;
408
409 m_server->MousePointerUpdate (pointer);
410
411 RTMemTmpFree (pointer);
412 }
413 }
414 }
415
416 return S_OK;
417}
418#endif /* VRDP_NO_COM */
419
420
421// ConsoleVRDPServer
422////////////////////////////////////////////////////////////////////////////////
423
424#ifdef VBOX_VRDP
425RTLDRMOD ConsoleVRDPServer::mVRDPLibrary;
426
427#ifdef VRDP_NO_COM
428PFNVRDPCREATESERVER ConsoleVRDPServer::mpfnVRDPCreateServer = NULL;
429
430VRDPENTRYPOINTS_1 *ConsoleVRDPServer::mpEntryPoints = NULL;
431
432VRDPCALLBACKS_1 ConsoleVRDPServer::mCallbacks =
433{
434 { VRDP_INTERFACE_VERSION_1, sizeof (VRDPCALLBACKS_1) },
435 ConsoleVRDPServer::VRDPCallbackQueryProperty,
436 ConsoleVRDPServer::VRDPCallbackClientLogon,
437 ConsoleVRDPServer::VRDPCallbackClientConnect,
438 ConsoleVRDPServer::VRDPCallbackClientDisconnect,
439 ConsoleVRDPServer::VRDPCallbackIntercept,
440 ConsoleVRDPServer::VRDPCallbackUSB,
441 ConsoleVRDPServer::VRDPCallbackClipboard,
442 ConsoleVRDPServer::VRDPCallbackFramebufferQuery,
443 ConsoleVRDPServer::VRDPCallbackFramebufferLock,
444 ConsoleVRDPServer::VRDPCallbackFramebufferUnlock,
445 ConsoleVRDPServer::VRDPCallbackInput,
446 ConsoleVRDPServer::VRDPCallbackVideoModeHint
447};
448#else
449int (VBOXCALL *ConsoleVRDPServer::mpfnVRDPStartServer) (IConsole *pConsole, IVRDPServer *pVRDPServer, HVRDPSERVER *phServer);
450int (VBOXCALL *ConsoleVRDPServer::mpfnVRDPSetFramebuffer) (HVRDPSERVER hServer, IFramebuffer *pFramebuffer, uint32_t fFlags);
451void (VBOXCALL *ConsoleVRDPServer::mpfnVRDPSetCallback) (HVRDPSERVER hServer, VRDPSERVERCALLBACK *pcallback, void *pvUser);
452void (VBOXCALL *ConsoleVRDPServer::mpfnVRDPShutdownServer) (HVRDPSERVER hServer);
453void (VBOXCALL *ConsoleVRDPServer::mpfnVRDPSendUpdateBitmap)(HVRDPSERVER hServer, unsigned uScreenId, unsigned x, unsigned y, unsigned w, unsigned h);
454void (VBOXCALL *ConsoleVRDPServer::mpfnVRDPSendResize) (HVRDPSERVER hServer);
455void (VBOXCALL *ConsoleVRDPServer::mpfnVRDPSendAudioSamples)(HVRDPSERVER hserver, void *pvSamples, uint32_t cSamples, VRDPAUDIOFORMAT format);
456void (VBOXCALL *ConsoleVRDPServer::mpfnVRDPSendAudioVolume) (HVRDPSERVER hserver, uint16_t left, uint16_t right);
457void (VBOXCALL *ConsoleVRDPServer::mpfnVRDPSendUSBRequest) (HVRDPSERVER hserver, uint32_t u32ClientId, void *pvParms, uint32_t cbParms);
458void (VBOXCALL *ConsoleVRDPServer::mpfnVRDPSendUpdate) (HVRDPSERVER hServer, unsigned uScreenId, void *pvUpdate, uint32_t cbUpdate);
459void (VBOXCALL *ConsoleVRDPServer::mpfnVRDPQueryInfo) (HVRDPSERVER hserver, uint32_t index, void *pvBuffer, uint32_t cbBuffer, uint32_t *pcbOut);
460void (VBOXCALL *ConsoleVRDPServer::mpfnVRDPClipboard) (HVRDPSERVER hserver, uint32_t u32Function, uint32_t u32Format, const void *pvData, uint32_t cbData, uint32_t *pcbActualRead);
461#endif /* VRDP_NO_COM */
462#endif /* VBOX_VRDP */
463
464#ifdef VRDP_NO_COM
465DECLCALLBACK(int) ConsoleVRDPServer::VRDPCallbackQueryProperty (void *pvCallback, uint32_t index, void *pvBuffer, uint32_t cbBuffer, uint32_t *pcbOut)
466{
467 ConsoleVRDPServer *server = static_cast <ConsoleVRDPServer *> (pvCallback);
468
469 int rc = VERR_NOT_SUPPORTED;
470
471 switch (index)
472 {
473 case VRDP_QP_NETWORK_PORT:
474 {
475 ULONG port = 0;
476 server->mConsole->getVRDPServer ()->COMGETTER(Port) (&port);
477 if (port == 0)
478 {
479 port = VRDP_DEFAULT_PORT;
480 }
481
482 if (cbBuffer >= sizeof (uint32_t))
483 {
484 *(uint32_t *)pvBuffer = (uint32_t)port;
485 rc = VINF_SUCCESS;
486 }
487 else
488 {
489 rc = VINF_BUFFER_OVERFLOW;
490 }
491
492 *pcbOut = sizeof (uint32_t);
493 } break;
494
495 case VRDP_QP_NETWORK_ADDRESS:
496 {
497 com::Bstr address;
498 server->mConsole->getVRDPServer ()->COMGETTER(NetAddress) (address.asOutParam());
499
500 if (cbBuffer >= address.length ())
501 {
502 if (address.length () > 0)
503 {
504 memcpy (pvBuffer, address.raw(), address.length ());
505 }
506 rc = VINF_SUCCESS;
507 }
508
509 *pcbOut = address.length ();
510 } break;
511
512 case VRDP_QP_NUMBER_MONITORS:
513 {
514 ULONG cMonitors = 1;
515
516 server->mConsole->machine ()->COMGETTER(MonitorCount)(&cMonitors);
517
518 if (cbBuffer >= sizeof (uint32_t))
519 {
520 *(uint32_t *)pvBuffer = (uint32_t)cMonitors;
521 rc = VINF_SUCCESS;
522 }
523 else
524 {
525 rc = VINF_BUFFER_OVERFLOW;
526 }
527
528 *pcbOut = sizeof (uint32_t);
529 } break;
530
531 default:
532 break;
533 }
534
535 return rc;
536}
537
538DECLCALLBACK(int) ConsoleVRDPServer::VRDPCallbackClientLogon (void *pvCallback, uint32_t u32ClientId, const char *pszUser, const char *pszPassword, const char *pszDomain)
539{
540 ConsoleVRDPServer *server = static_cast <ConsoleVRDPServer *> (pvCallback);
541
542 return server->mConsole->VRDPClientLogon (u32ClientId, pszUser, pszPassword, pszDomain);
543}
544
545DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackClientConnect (void *pvCallback, uint32_t u32ClientId)
546{
547 ConsoleVRDPServer *server = static_cast <ConsoleVRDPServer *> (pvCallback);
548
549 server->mConsole->VRDPClientConnect (u32ClientId);
550}
551
552DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackClientDisconnect (void *pvCallback, uint32_t u32ClientId, uint32_t fu32Intercepted)
553{
554 ConsoleVRDPServer *server = static_cast <ConsoleVRDPServer *> (pvCallback);
555
556 server->mConsole->VRDPClientDisconnect (u32ClientId, fu32Intercepted);
557}
558
559DECLCALLBACK(int) ConsoleVRDPServer::VRDPCallbackIntercept (void *pvCallback, uint32_t u32ClientId, uint32_t fu32Intercept, void **ppvIntercept)
560{
561 ConsoleVRDPServer *server = static_cast <ConsoleVRDPServer *> (pvCallback);
562
563 int rc = VERR_NOT_SUPPORTED;
564
565 switch (fu32Intercept)
566 {
567 case VRDP_CLIENT_INTERCEPT_AUDIO:
568 {
569 server->mConsole->VRDPInterceptAudio (u32ClientId);
570 rc = VINF_SUCCESS;
571 } break;
572
573 case VRDP_CLIENT_INTERCEPT_USB:
574 {
575 server->mConsole->VRDPInterceptUSB (u32ClientId);
576 rc = VINF_SUCCESS;
577 } break;
578
579 case VRDP_CLIENT_INTERCEPT_CLIPBOARD:
580 {
581 server->mConsole->VRDPInterceptClipboard (u32ClientId);
582 rc = VINF_SUCCESS;
583 } break;
584
585 default:
586 break;
587 }
588
589 if (VBOX_SUCCESS (rc))
590 {
591 if (ppvIntercept)
592 {
593 *ppvIntercept = server;
594 }
595 }
596
597 return rc;
598}
599
600DECLCALLBACK(int) ConsoleVRDPServer::VRDPCallbackUSB (void *pvCallback, void *pvIntercept, uint32_t u32ClientId, uint8_t u8Code, const void *pvRet, uint32_t cbRet)
601{
602 return USBClientResponseCallback (pvIntercept, u32ClientId, u8Code, pvRet, cbRet);
603}
604
605DECLCALLBACK(int) ConsoleVRDPServer::VRDPCallbackClipboard (void *pvCallback, void *pvIntercept, uint32_t u32ClientId, uint32_t u32Function, uint32_t u32Format, const void *pvData, uint32_t cbData)
606{
607 return ClipboardCallback (pvIntercept, u32ClientId, u32Function, u32Format, pvData, cbData);
608}
609
610DECLCALLBACK(bool) ConsoleVRDPServer::VRDPCallbackFramebufferQuery (void *pvCallback, unsigned uScreenId, VRDPFRAMEBUFFERINFO *pInfo)
611{
612 ConsoleVRDPServer *server = static_cast <ConsoleVRDPServer *> (pvCallback);
613
614 bool fAvailable = false;
615
616 IFramebuffer *pfb = NULL;
617 LONG xOrigin = 0;
618 LONG yOrigin = 0;
619
620 server->mConsole->getDisplay ()->GetFramebuffer (uScreenId, &pfb, &xOrigin, &yOrigin);
621
622 if (pfb)
623 {
624 pfb->Lock ();
625
626 /* Query framebuffer parameters. */
627 ULONG lineSize = 0;
628 pfb->COMGETTER(BytesPerLine) (&lineSize);
629
630 ULONG bitsPerPixel = 0;
631 pfb->COMGETTER(BitsPerPixel) (&bitsPerPixel);
632
633 BYTE *address = NULL;
634 pfb->COMGETTER(Address) (&address);
635
636 ULONG height = 0;
637 pfb->COMGETTER(Height) (&height);
638
639 ULONG width = 0;
640 pfb->COMGETTER(Width) (&width);
641
642 /* Now fill the information as requested by the caller. */
643 pInfo->pu8Bits = address;
644 pInfo->xOrigin = xOrigin;
645 pInfo->yOrigin = yOrigin;
646 pInfo->cWidth = width;
647 pInfo->cHeight = height;
648 pInfo->cBitsPerPixel = bitsPerPixel;
649 pInfo->cbLine = lineSize;
650
651 pfb->Unlock ();
652
653 fAvailable = true;
654 }
655
656 if (server->maFramebuffers[uScreenId])
657 {
658 server->maFramebuffers[uScreenId]->Release ();
659 }
660 server->maFramebuffers[uScreenId] = pfb;
661
662 return fAvailable;
663}
664
665DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackFramebufferLock (void *pvCallback, unsigned uScreenId)
666{
667 ConsoleVRDPServer *server = static_cast <ConsoleVRDPServer *> (pvCallback);
668
669 if (server->maFramebuffers[uScreenId])
670 {
671 server->maFramebuffers[uScreenId]->Lock ();
672 }
673}
674
675DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackFramebufferUnlock (void *pvCallback, unsigned uScreenId)
676{
677 ConsoleVRDPServer *server = static_cast <ConsoleVRDPServer *> (pvCallback);
678
679 if (server->maFramebuffers[uScreenId])
680 {
681 server->maFramebuffers[uScreenId]->Unlock ();
682 }
683}
684
685DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackInput (void *pvCallback, int type, const void *pvInput, unsigned cbInput)
686{
687 ConsoleVRDPServer *server = static_cast <ConsoleVRDPServer *> (pvCallback);
688 Console *pConsole = server->mConsole;
689
690 switch (type)
691 {
692 case VRDP_INPUT_SCANCODE:
693 {
694 if (cbInput == sizeof (VRDPINPUTSCANCODE))
695 {
696 const VRDPINPUTSCANCODE *pInputScancode = (VRDPINPUTSCANCODE *)pvInput;
697 pConsole->getKeyboard ()->PutScancode((LONG)pInputScancode->uScancode);
698 }
699 } break;
700
701 case VRDP_INPUT_POINT:
702 {
703 if (cbInput == sizeof (VRDPINPUTPOINT))
704 {
705 const VRDPINPUTPOINT *pInputPoint = (VRDPINPUTPOINT *)pvInput;
706
707 int mouseButtons = 0;
708 int iWheel = 0;
709
710 if (pInputPoint->uButtons & VRDP_INPUT_POINT_BUTTON1)
711 {
712 mouseButtons |= MouseButtonState_LeftButton;
713 }
714 if (pInputPoint->uButtons & VRDP_INPUT_POINT_BUTTON2)
715 {
716 mouseButtons |= MouseButtonState_RightButton;
717 }
718 if (pInputPoint->uButtons & VRDP_INPUT_POINT_BUTTON3)
719 {
720 mouseButtons |= MouseButtonState_MiddleButton;
721 }
722 if (pInputPoint->uButtons & VRDP_INPUT_POINT_WHEEL_UP)
723 {
724 mouseButtons |= MouseButtonState_WheelUp;
725 iWheel = -1;
726 }
727 if (pInputPoint->uButtons & VRDP_INPUT_POINT_WHEEL_DOWN)
728 {
729 mouseButtons |= MouseButtonState_WheelDown;
730 iWheel = 1;
731 }
732
733 if (server->m_fGuestWantsAbsolute)
734 {
735 pConsole->getMouse()->PutMouseEventAbsolute (pInputPoint->x + 1, pInputPoint->y + 1, iWheel, mouseButtons);
736 } else
737 {
738 pConsole->getMouse()->PutMouseEvent (pInputPoint->x - server->m_mousex,
739 pInputPoint->y - server->m_mousey,
740 iWheel, mouseButtons);
741 server->m_mousex = pInputPoint->x;
742 server->m_mousey = pInputPoint->y;
743 }
744 }
745 } break;
746
747 case VRDP_INPUT_CAD:
748 {
749 pConsole->getKeyboard ()->PutCAD();
750 } break;
751
752 case VRDP_INPUT_RESET:
753 {
754 pConsole->Reset();
755 } break;
756
757 default:
758 break;
759 }
760}
761
762DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackVideoModeHint (void *pvCallback, unsigned cWidth, unsigned cHeight, unsigned cBitsPerPixel, unsigned uScreenId)
763{
764 ConsoleVRDPServer *server = static_cast <ConsoleVRDPServer *> (pvCallback);
765
766 server->mConsole->getDisplay ()->SetVideoModeHint(cWidth, cHeight, cBitsPerPixel, uScreenId);
767}
768#endif /* VRDP_NO_COM */
769
770ConsoleVRDPServer::ConsoleVRDPServer (Console *console)
771{
772 mConsole = console;
773
774 int rc = RTCritSectInit (&mCritSect);
775 AssertRC (rc);
776
777 mcClipboardRefs = 0;
778 mpfnClipboardCallback = NULL;
779
780#ifdef VBOX_WITH_USB
781 mUSBBackends.pHead = NULL;
782 mUSBBackends.pTail = NULL;
783
784 mUSBBackends.thread = NIL_RTTHREAD;
785 mUSBBackends.fThreadRunning = false;
786 mUSBBackends.event = 0;
787#endif
788
789#ifdef VBOX_VRDP
790 mhServer = 0;
791
792#ifdef VRDP_NO_COM
793 m_fGuestWantsAbsolute = false;
794 m_mousex = 0;
795 m_mousey = 0;
796
797 memset (maFramebuffers, 0, sizeof (maFramebuffers));
798
799 mConsoleCallback = new VRDPConsoleCallback(this);
800 mConsoleCallback->AddRef();
801 console->RegisterCallback(mConsoleCallback);
802#endif /* VRDP_NO_COM */
803#endif /* VBOX_VRDP */
804
805 mAuthLibrary = 0;
806}
807
808ConsoleVRDPServer::~ConsoleVRDPServer ()
809{
810 Stop ();
811
812#ifdef VRDP_NO_COM
813 if (mConsoleCallback)
814 {
815 mConsole->UnregisterCallback(mConsoleCallback);
816 mConsoleCallback->Release();
817 mConsoleCallback = NULL;
818 }
819
820 unsigned i;
821 for (i = 0; i < ELEMENTS(maFramebuffers); i++)
822 {
823 if (maFramebuffers[i])
824 {
825 maFramebuffers[i]->Release ();
826 maFramebuffers[i] = NULL;
827 }
828 }
829#endif /* VRDP_NO_COM */
830 if (RTCritSectIsInitialized (&mCritSect))
831 {
832 RTCritSectDelete (&mCritSect);
833 memset (&mCritSect, 0, sizeof (mCritSect));
834 }
835}
836
837int ConsoleVRDPServer::Launch (void)
838{
839 LogFlowMember(("ConsoleVRDPServer::Launch\n"));
840#ifdef VBOX_VRDP
841 int rc = VINF_SUCCESS;
842 IVRDPServer *vrdpserver = mConsole->getVRDPServer ();
843 Assert(vrdpserver);
844 BOOL vrdpEnabled = FALSE;
845
846 HRESULT rc2 = vrdpserver->COMGETTER(Enabled) (&vrdpEnabled);
847 AssertComRC(rc2);
848
849 if (SUCCEEDED (rc2)
850 && vrdpEnabled
851 && loadVRDPLibrary ())
852 {
853#ifdef VRDP_NO_COM
854 rc = mpfnVRDPCreateServer (&mCallbacks.header, this, (VRDPINTERFACEHDR **)&mpEntryPoints, &mhServer);
855#else
856 rc = mpfnVRDPStartServer(mConsole, vrdpserver, &mhServer);
857#endif /* VRDP_NO_COM */
858
859 if (VBOX_SUCCESS(rc))
860 {
861#ifdef VBOX_WITH_USB
862 remoteUSBThreadStart ();
863#endif /* VBOX_WITH_USB */
864 }
865 else
866 AssertMsgFailed(("Could not start VRDP server: rc = %Vrc\n", rc));
867 }
868#else
869 int rc = VERR_NOT_SUPPORTED;
870#endif /* VBOX_VRDP */
871 return rc;
872}
873
874#ifdef VRDP_NO_COM
875void ConsoleVRDPServer::EnableConnections (void)
876{
877#ifdef VBOX_VRDP
878 if (mpEntryPoints)
879 {
880 mpEntryPoints->VRDPEnableConnections (mhServer, true);
881 }
882#endif /* VBOX_VRDP */
883}
884
885void ConsoleVRDPServer::MousePointerUpdate (const VRDPCOLORPOINTER *pPointer)
886{
887#ifdef VBOX_VRDP
888 if (mpEntryPoints)
889 {
890 mpEntryPoints->VRDPColorPointer (mhServer, pPointer);
891 }
892#endif /* VBOX_VRDP */
893}
894
895void ConsoleVRDPServer::MousePointerHide (void)
896{
897#ifdef VBOX_VRDP
898 if (mpEntryPoints)
899 {
900 mpEntryPoints->VRDPHidePointer (mhServer);
901 }
902#endif /* VBOX_VRDP */
903}
904#else
905void ConsoleVRDPServer::SetCallback (void)
906{
907#ifdef VBOX_VRDP
908 /* This is called after VM is created and allows the server to accept client connection. */
909 if (mhServer && mpfnVRDPSetCallback)
910 {
911 mpfnVRDPSetCallback (mhServer, mConsole->getVrdpServerCallback (), mConsole);
912 }
913#endif /* VBOX_VRDP */
914}
915#endif /* VRDP_NO_COM */
916
917void ConsoleVRDPServer::Stop (void)
918{
919 Assert(VALID_PTR(this)); /** @todo r=bird: there are(/was) some odd cases where this buster was invalid on
920 * linux. Just remove this when it's 100% sure that problem has been fixed. */
921#ifdef VBOX_VRDP
922 if (mhServer)
923 {
924#ifdef VRDP_NO_COM
925#else
926 HVRDPSERVER hServer = mhServer;
927#endif /* VRDP_NO_COM */
928
929 /* Reset the handle to avoid further calls to the server. */
930 mhServer = 0;
931
932#ifdef VRDP_NO_COM
933 if (mpEntryPoints)
934 {
935 mpEntryPoints->VRDPDestroy (mhServer);
936 }
937#else
938 mpfnVRDPShutdownServer (hServer);
939#endif /* VRDP_NO_COM */
940 }
941#endif /* VBOX_VRDP */
942
943#ifdef VBOX_WITH_USB
944 remoteUSBThreadStop ();
945#endif /* VBOX_WITH_USB */
946
947 mpfnAuthEntry = NULL;
948 mpfnAuthEntry2 = NULL;
949
950 if (mAuthLibrary)
951 {
952 RTLdrClose(mAuthLibrary);
953 mAuthLibrary = 0;
954 }
955}
956
957/* Worker thread for Remote USB. The thread polls the clients for
958 * the list of attached USB devices.
959 * The thread is also responsible for attaching/detaching devices
960 * to/from the VM.
961 *
962 * It is expected that attaching/detaching is not a frequent operation.
963 *
964 * The thread is always running when the VRDP server is active.
965 *
966 * The thread scans backends and requests the device list every 2 seconds.
967 *
968 * When device list is available, the thread calls the Console to process it.
969 *
970 */
971#define VRDP_DEVICE_LIST_PERIOD_MS (2000)
972
973#ifdef VBOX_WITH_USB
974static DECLCALLBACK(int) threadRemoteUSB (RTTHREAD self, void *pvUser)
975{
976 ConsoleVRDPServer *pOwner = (ConsoleVRDPServer *)pvUser;
977
978 LogFlow(("Console::threadRemoteUSB: start. owner = %p.\n", pOwner));
979
980 pOwner->notifyRemoteUSBThreadRunning (self);
981
982 while (pOwner->isRemoteUSBThreadRunning ())
983 {
984 RemoteUSBBackend *pRemoteUSBBackend = NULL;
985
986 while ((pRemoteUSBBackend = pOwner->usbBackendGetNext (pRemoteUSBBackend)) != NULL)
987 {
988 pRemoteUSBBackend->PollRemoteDevices ();
989 }
990
991 pOwner->waitRemoteUSBThreadEvent (VRDP_DEVICE_LIST_PERIOD_MS);
992
993 LogFlow(("Console::threadRemoteUSB: iteration. owner = %p.\n", pOwner));
994 }
995
996 return VINF_SUCCESS;
997}
998
999void ConsoleVRDPServer::notifyRemoteUSBThreadRunning (RTTHREAD thread)
1000{
1001 mUSBBackends.thread = thread;
1002 mUSBBackends.fThreadRunning = true;
1003 int rc = RTThreadUserSignal (thread);
1004 AssertRC (rc);
1005}
1006
1007bool ConsoleVRDPServer::isRemoteUSBThreadRunning (void)
1008{
1009 return mUSBBackends.fThreadRunning;
1010}
1011
1012void ConsoleVRDPServer::waitRemoteUSBThreadEvent (unsigned cMillies)
1013{
1014 int rc = RTSemEventWait (mUSBBackends.event, cMillies);
1015 Assert (VBOX_SUCCESS(rc) || rc == VERR_TIMEOUT);
1016 NOREF(rc);
1017}
1018
1019void ConsoleVRDPServer::remoteUSBThreadStart (void)
1020{
1021 int rc = RTSemEventCreate (&mUSBBackends.event);
1022
1023 if (VBOX_FAILURE (rc))
1024 {
1025 AssertFailed ();
1026 mUSBBackends.event = 0;
1027 }
1028
1029 if (VBOX_SUCCESS (rc))
1030 {
1031 rc = RTThreadCreate (&mUSBBackends.thread, threadRemoteUSB, this, 65536,
1032 RTTHREADTYPE_VRDP_IO, RTTHREADFLAGS_WAITABLE, "remote usb");
1033 }
1034
1035 if (VBOX_FAILURE (rc))
1036 {
1037 LogRel(("Warning: could not start the remote USB thread, rc = %Vrc!!!\n", rc));
1038 mUSBBackends.thread = NIL_RTTHREAD;
1039 }
1040 else
1041 {
1042 /* Wait until the thread is ready. */
1043 rc = RTThreadUserWait (mUSBBackends.thread, 60000);
1044 AssertRC (rc);
1045 Assert (mUSBBackends.fThreadRunning || VBOX_FAILURE (rc));
1046 }
1047}
1048
1049void ConsoleVRDPServer::remoteUSBThreadStop (void)
1050{
1051 mUSBBackends.fThreadRunning = false;
1052
1053 if (mUSBBackends.thread != NIL_RTTHREAD)
1054 {
1055 Assert (mUSBBackends.event != 0);
1056
1057 RTSemEventSignal (mUSBBackends.event);
1058
1059 int rc = RTThreadWait (mUSBBackends.thread, 60000, NULL);
1060 AssertRC (rc);
1061
1062 mUSBBackends.thread = NIL_RTTHREAD;
1063 }
1064
1065 if (mUSBBackends.event)
1066 {
1067 RTSemEventDestroy (mUSBBackends.event);
1068 mUSBBackends.event = 0;
1069 }
1070}
1071#endif /* VBOX_WITH_USB */
1072
1073VRDPAuthResult ConsoleVRDPServer::Authenticate (const Guid &uuid, VRDPAuthGuestJudgement guestJudgement,
1074 const char *pszUser, const char *pszPassword, const char *pszDomain,
1075 uint32_t u32ClientId)
1076{
1077 VRDPAUTHUUID rawuuid;
1078
1079 memcpy (rawuuid, ((Guid &)uuid).ptr (), sizeof (rawuuid));
1080
1081 LogFlow(("ConsoleVRDPServer::Authenticate: uuid = %Vuuid, guestJudgement = %d, pszUser = %s, pszPassword = %s, pszDomain = %s, u32ClientId = %d\n",
1082 rawuuid, guestJudgement, pszUser, pszPassword, pszDomain, u32ClientId));
1083
1084 /*
1085 * Called only from VRDP input thread. So thread safety is not required.
1086 */
1087
1088 if (!mAuthLibrary)
1089 {
1090 /* Load the external authentication library. */
1091
1092 ComPtr<IMachine> machine;
1093 mConsole->COMGETTER(Machine)(machine.asOutParam());
1094
1095 ComPtr<IVirtualBox> virtualBox;
1096 machine->COMGETTER(Parent)(virtualBox.asOutParam());
1097
1098 ComPtr<ISystemProperties> systemProperties;
1099 virtualBox->COMGETTER(SystemProperties)(systemProperties.asOutParam());
1100
1101 Bstr authLibrary;
1102 systemProperties->COMGETTER(RemoteDisplayAuthLibrary)(authLibrary.asOutParam());
1103
1104 Utf8Str filename = authLibrary;
1105
1106 LogRel(("VRDPAUTH: ConsoleVRDPServer::Authenticate: loading external authentication library '%ls'\n", authLibrary.raw()));
1107
1108 int rc = RTLdrLoad (filename.raw(), &mAuthLibrary);
1109 if (VBOX_FAILURE (rc))
1110 LogRel(("VRDPAUTH: Failed to load external authentication library. Error code: %Vrc\n", rc));
1111
1112 if (VBOX_SUCCESS (rc))
1113 {
1114 /* Get the entry point. */
1115 mpfnAuthEntry2 = NULL;
1116 int rc2 = RTLdrGetSymbol(mAuthLibrary, "VRDPAuth2", (void**)&mpfnAuthEntry2);
1117 if (VBOX_FAILURE (rc2))
1118 {
1119 LogRel(("VRDPAUTH: Could not resolve import '%s'. Error code: %Vrc\n", "VRDPAuth2", rc2));
1120 rc = rc2;
1121 }
1122
1123 /* Get the entry point. */
1124 mpfnAuthEntry = NULL;
1125 rc2 = RTLdrGetSymbol(mAuthLibrary, "VRDPAuth", (void**)&mpfnAuthEntry);
1126 if (VBOX_FAILURE (rc2))
1127 {
1128 LogRel(("VRDPAUTH: Could not resolve import '%s'. Error code: %Vrc\n", "VRDPAuth", rc2));
1129 rc = rc2;
1130 }
1131
1132 if (mpfnAuthEntry2 || mpfnAuthEntry)
1133 {
1134 LogRel(("VRDPAUTH: Using entry point '%s'.\n", mpfnAuthEntry2? "VRDPAuth2": "VRDPAuth"));
1135 rc = VINF_SUCCESS;
1136 }
1137 }
1138
1139 if (VBOX_FAILURE (rc))
1140 {
1141 mConsole->reportAuthLibraryError (filename.raw(), rc);
1142
1143 mpfnAuthEntry = NULL;
1144 mpfnAuthEntry2 = NULL;
1145
1146 if (mAuthLibrary)
1147 {
1148 RTLdrClose(mAuthLibrary);
1149 mAuthLibrary = 0;
1150 }
1151
1152 return VRDPAuthAccessDenied;
1153 }
1154 }
1155
1156 Assert (mAuthLibrary && (mpfnAuthEntry || mpfnAuthEntry2));
1157
1158 VRDPAuthResult result = mpfnAuthEntry2?
1159 mpfnAuthEntry2 (&rawuuid, guestJudgement, pszUser, pszPassword, pszDomain, true, u32ClientId):
1160 mpfnAuthEntry (&rawuuid, guestJudgement, pszUser, pszPassword, pszDomain);
1161
1162 switch (result)
1163 {
1164 case VRDPAuthAccessDenied:
1165 LogRel(("VRDPAUTH: external authentication module returned 'access denied'\n"));
1166 break;
1167 case VRDPAuthAccessGranted:
1168 LogRel(("VRDPAUTH: external authentication module returned 'access granted'\n"));
1169 break;
1170 case VRDPAuthDelegateToGuest:
1171 LogRel(("VRDPAUTH: external authentication module returned 'delegate request to guest'\n"));
1172 break;
1173 default:
1174 LogRel(("VRDPAUTH: external authentication module returned incorrect return code %d\n", result));
1175 result = VRDPAuthAccessDenied;
1176 }
1177
1178 LogFlow(("ConsoleVRDPServer::Authenticate: result = %d\n", result));
1179
1180 return result;
1181}
1182
1183void ConsoleVRDPServer::AuthDisconnect (const Guid &uuid, uint32_t u32ClientId)
1184{
1185 VRDPAUTHUUID rawuuid;
1186
1187 memcpy (rawuuid, ((Guid &)uuid).ptr (), sizeof (rawuuid));
1188
1189 LogFlow(("ConsoleVRDPServer::AuthDisconnect: uuid = %Vuuid, u32ClientId = %d\n",
1190 rawuuid, u32ClientId));
1191
1192 Assert (mAuthLibrary && (mpfnAuthEntry || mpfnAuthEntry2));
1193
1194 if (mpfnAuthEntry2)
1195 mpfnAuthEntry2 (&rawuuid, VRDPAuthGuestNotAsked, NULL, NULL, NULL, false, u32ClientId);
1196}
1197
1198int ConsoleVRDPServer::lockConsoleVRDPServer (void)
1199{
1200 int rc = RTCritSectEnter (&mCritSect);
1201 AssertRC (rc);
1202 return rc;
1203}
1204
1205void ConsoleVRDPServer::unlockConsoleVRDPServer (void)
1206{
1207 RTCritSectLeave (&mCritSect);
1208}
1209
1210DECLCALLBACK(int) ConsoleVRDPServer::ClipboardCallback (void *pvCallback,
1211 uint32_t u32ClientId,
1212 uint32_t u32Function,
1213 uint32_t u32Format,
1214 const void *pvData,
1215 uint32_t cbData)
1216{
1217 LogFlowFunc(("pvCallback = %p, u32ClientId = %d, u32Function = %d, u32Format = 0x%08X, pvData = %p, cbData = %d\n",
1218 pvCallback, u32ClientId, u32Function, u32Format, pvData, cbData));
1219
1220 int rc = VINF_SUCCESS;
1221
1222 ConsoleVRDPServer *pServer = static_cast <ConsoleVRDPServer *>(pvCallback);
1223
1224 NOREF(u32ClientId);
1225
1226 switch (u32Function)
1227 {
1228 case VRDP_CLIPBOARD_FUNCTION_FORMAT_ANNOUNCE:
1229 {
1230 if (pServer->mpfnClipboardCallback)
1231 {
1232 pServer->mpfnClipboardCallback (VBOX_CLIPBOARD_EXT_FN_FORMAT_ANNOUNCE,
1233 u32Format,
1234 (void *)pvData,
1235 cbData);
1236 }
1237 } break;
1238
1239 case VRDP_CLIPBOARD_FUNCTION_DATA_READ:
1240 {
1241 if (pServer->mpfnClipboardCallback)
1242 {
1243 pServer->mpfnClipboardCallback (VBOX_CLIPBOARD_EXT_FN_DATA_READ,
1244 u32Format,
1245 (void *)pvData,
1246 cbData);
1247 }
1248 } break;
1249
1250 default:
1251 rc = VERR_NOT_SUPPORTED;
1252 }
1253
1254 return rc;
1255}
1256
1257DECLCALLBACK(int) ConsoleVRDPServer::ClipboardServiceExtension (void *pvExtension,
1258 uint32_t u32Function,
1259 void *pvParms,
1260 uint32_t cbParms)
1261{
1262 LogFlowFunc(("pvExtension = %p, u32Function = %d, pvParms = %p, cbParms = %d\n",
1263 pvExtension, u32Function, pvParms, cbParms));
1264
1265 int rc = VINF_SUCCESS;
1266
1267#ifdef VBOX_VRDP
1268 ConsoleVRDPServer *pServer = static_cast <ConsoleVRDPServer *>(pvExtension);
1269
1270 VBOXCLIPBOARDEXTPARMS *pParms = (VBOXCLIPBOARDEXTPARMS *)pvParms;
1271
1272 switch (u32Function)
1273 {
1274 case VBOX_CLIPBOARD_EXT_FN_SET_CALLBACK:
1275 {
1276 pServer->mpfnClipboardCallback = (PFNVRDPCLIPBOARDEXTCALLBACK)pParms->pvData;
1277 } break;
1278
1279 case VBOX_CLIPBOARD_EXT_FN_FORMAT_ANNOUNCE:
1280 {
1281 /* The guest announces clipboard formats. This must be delivered to all clients. */
1282#ifdef VRDP_NO_COM
1283 if (mpEntryPoints)
1284 {
1285 mpEntryPoints->VRDPClipboard (pServer->mhServer,
1286 VRDP_CLIPBOARD_FUNCTION_FORMAT_ANNOUNCE,
1287 pParms->u32Format,
1288 NULL,
1289 0,
1290 NULL);
1291 }
1292#else
1293 if (mpfnVRDPClipboard)
1294 {
1295 mpfnVRDPClipboard (pServer->mhServer,
1296 VRDP_CLIPBOARD_FUNCTION_FORMAT_ANNOUNCE,
1297 pParms->u32Format,
1298 NULL,
1299 0,
1300 NULL);
1301 }
1302#endif /* VRDP_NO_COM */
1303 } break;
1304
1305 case VBOX_CLIPBOARD_EXT_FN_DATA_READ:
1306 {
1307 /* The clipboard service expects that the pvData buffer will be filled
1308 * with clipboard data. The server returns the data from the client that
1309 * announced the requested format most recently.
1310 */
1311#ifdef VRDP_NO_COM
1312 if (mpEntryPoints)
1313 {
1314 mpEntryPoints->VRDPClipboard (pServer->mhServer,
1315 VRDP_CLIPBOARD_FUNCTION_DATA_READ,
1316 pParms->u32Format,
1317 pParms->pvData,
1318 pParms->cbData,
1319 &pParms->cbData);
1320 }
1321#else
1322 if (mpfnVRDPClipboard)
1323 {
1324 mpfnVRDPClipboard (pServer->mhServer,
1325 VRDP_CLIPBOARD_FUNCTION_DATA_READ,
1326 pParms->u32Format,
1327 pParms->pvData,
1328 pParms->cbData,
1329 &pParms->cbData);
1330 }
1331#endif /* VRDP_NO_COM */
1332 } break;
1333
1334 case VBOX_CLIPBOARD_EXT_FN_DATA_WRITE:
1335 {
1336#ifdef VRDP_NO_COM
1337 if (mpEntryPoints)
1338 {
1339 mpEntryPoints->VRDPClipboard (pServer->mhServer,
1340 VRDP_CLIPBOARD_FUNCTION_DATA_WRITE,
1341 pParms->u32Format,
1342 pParms->pvData,
1343 pParms->cbData,
1344 NULL);
1345 }
1346#else
1347 if (mpfnVRDPClipboard)
1348 {
1349 mpfnVRDPClipboard (pServer->mhServer,
1350 VRDP_CLIPBOARD_FUNCTION_DATA_WRITE,
1351 pParms->u32Format,
1352 pParms->pvData,
1353 pParms->cbData,
1354 NULL);
1355 }
1356#endif /* VRDP_NO_COM */
1357 } break;
1358
1359 default:
1360 rc = VERR_NOT_SUPPORTED;
1361 }
1362#endif /* VBOX_VRDP */
1363
1364 return rc;
1365}
1366
1367#ifdef VRDP_NO_COM
1368void ConsoleVRDPServer::ClipboardCreate (uint32_t u32ClientId)
1369#else
1370void ConsoleVRDPServer::ClipboardCreate (uint32_t u32ClientId, PFNVRDPCLIPBOARDCALLBACK *ppfn, void **ppv)
1371#endif /* VRDP_NO_COM */
1372{
1373 int rc = lockConsoleVRDPServer ();
1374
1375 if (VBOX_SUCCESS (rc))
1376 {
1377 if (mcClipboardRefs == 0)
1378 {
1379 rc = HGCMHostRegisterServiceExtension (&mhClipboard, "VBoxSharedClipboard", ClipboardServiceExtension, this);
1380
1381 if (VBOX_SUCCESS (rc))
1382 {
1383 mcClipboardRefs++;
1384 }
1385 }
1386
1387#ifdef VRDP_NO_COM
1388#else
1389 if (VBOX_SUCCESS (rc))
1390 {
1391 *ppfn = ClipboardCallback;
1392 *ppv = this;
1393 }
1394#endif /* VRDP_NO_COM */
1395
1396 unlockConsoleVRDPServer ();
1397 }
1398}
1399
1400void ConsoleVRDPServer::ClipboardDelete (uint32_t u32ClientId)
1401{
1402 int rc = lockConsoleVRDPServer ();
1403
1404 if (VBOX_SUCCESS (rc))
1405 {
1406 mcClipboardRefs--;
1407
1408 if (mcClipboardRefs == 0)
1409 {
1410 HGCMHostUnregisterServiceExtension (mhClipboard);
1411 }
1412
1413 unlockConsoleVRDPServer ();
1414 }
1415}
1416
1417/* That is called on INPUT thread of the VRDP server.
1418 * The ConsoleVRDPServer keeps a list of created backend instances.
1419 */
1420#ifdef VRDP_NO_COM
1421void ConsoleVRDPServer::USBBackendCreate (uint32_t u32ClientId)
1422#else
1423void ConsoleVRDPServer::USBBackendCreate (uint32_t u32ClientId, PFNVRDPUSBCALLBACK *ppfn, void **ppv)
1424#endif /* VRDP_NO_COM */
1425{
1426#ifdef VBOX_WITH_USB
1427 LogFlow(("ConsoleVRDPServer::USBBackendCreate: u32ClientId = %d\n", u32ClientId));
1428
1429 /* Create a new instance of the USB backend for the new client. */
1430 RemoteUSBBackend *pRemoteUSBBackend = new RemoteUSBBackend (mConsole, this, u32ClientId);
1431
1432 if (pRemoteUSBBackend)
1433 {
1434 pRemoteUSBBackend->AddRef (); /* 'Release' called in USBBackendDelete. */
1435
1436 /* Append the new instance in the list. */
1437 int rc = lockConsoleVRDPServer ();
1438
1439 if (VBOX_SUCCESS (rc))
1440 {
1441 pRemoteUSBBackend->pNext = mUSBBackends.pHead;
1442 if (mUSBBackends.pHead)
1443 {
1444 mUSBBackends.pHead->pPrev = pRemoteUSBBackend;
1445 }
1446 else
1447 {
1448 mUSBBackends.pTail = pRemoteUSBBackend;
1449 }
1450
1451 mUSBBackends.pHead = pRemoteUSBBackend;
1452
1453 unlockConsoleVRDPServer ();
1454
1455#ifdef VRDP_NO_COM
1456#else
1457 pRemoteUSBBackend->QueryVRDPCallbackPointer (ppfn, ppv);
1458#endif /* VRDP_NO_COM */
1459 }
1460
1461 if (VBOX_FAILURE (rc))
1462 {
1463 pRemoteUSBBackend->Release ();
1464 }
1465 }
1466#endif /* VBOX_WITH_USB */
1467}
1468
1469void ConsoleVRDPServer::USBBackendDelete (uint32_t u32ClientId)
1470{
1471#ifdef VBOX_WITH_USB
1472 LogFlow(("ConsoleVRDPServer::USBBackendDelete: u32ClientId = %d\n", u32ClientId));
1473
1474 RemoteUSBBackend *pRemoteUSBBackend = NULL;
1475
1476 /* Find the instance. */
1477 int rc = lockConsoleVRDPServer ();
1478
1479 if (VBOX_SUCCESS (rc))
1480 {
1481 pRemoteUSBBackend = usbBackendFind (u32ClientId);
1482
1483 if (pRemoteUSBBackend)
1484 {
1485 /* Notify that it will be deleted. */
1486 pRemoteUSBBackend->NotifyDelete ();
1487 }
1488
1489 unlockConsoleVRDPServer ();
1490 }
1491
1492 if (pRemoteUSBBackend)
1493 {
1494 /* Here the instance has been excluded from the list and can be dereferenced. */
1495 pRemoteUSBBackend->Release ();
1496 }
1497#endif
1498}
1499
1500void *ConsoleVRDPServer::USBBackendRequestPointer (uint32_t u32ClientId, const Guid *pGuid)
1501{
1502#ifdef VBOX_WITH_USB
1503 RemoteUSBBackend *pRemoteUSBBackend = NULL;
1504
1505 /* Find the instance. */
1506 int rc = lockConsoleVRDPServer ();
1507
1508 if (VBOX_SUCCESS (rc))
1509 {
1510 pRemoteUSBBackend = usbBackendFind (u32ClientId);
1511
1512 if (pRemoteUSBBackend)
1513 {
1514 /* Inform the backend instance that it is referenced by the Guid. */
1515 bool fAdded = pRemoteUSBBackend->addUUID (pGuid);
1516
1517 if (fAdded)
1518 {
1519 /* Reference the instance because its pointer is being taken. */
1520 pRemoteUSBBackend->AddRef (); /* 'Release' is called in USBBackendReleasePointer. */
1521 }
1522 else
1523 {
1524 pRemoteUSBBackend = NULL;
1525 }
1526 }
1527
1528 unlockConsoleVRDPServer ();
1529 }
1530
1531 if (pRemoteUSBBackend)
1532 {
1533 return pRemoteUSBBackend->GetBackendCallbackPointer ();
1534 }
1535
1536#endif
1537 return NULL;
1538}
1539
1540void ConsoleVRDPServer::USBBackendReleasePointer (const Guid *pGuid)
1541{
1542#ifdef VBOX_WITH_USB
1543 RemoteUSBBackend *pRemoteUSBBackend = NULL;
1544
1545 /* Find the instance. */
1546 int rc = lockConsoleVRDPServer ();
1547
1548 if (VBOX_SUCCESS (rc))
1549 {
1550 pRemoteUSBBackend = usbBackendFindByUUID (pGuid);
1551
1552 if (pRemoteUSBBackend)
1553 {
1554 pRemoteUSBBackend->removeUUID (pGuid);
1555 }
1556
1557 unlockConsoleVRDPServer ();
1558
1559 if (pRemoteUSBBackend)
1560 {
1561 pRemoteUSBBackend->Release ();
1562 }
1563 }
1564#endif
1565}
1566
1567RemoteUSBBackend *ConsoleVRDPServer::usbBackendGetNext (RemoteUSBBackend *pRemoteUSBBackend)
1568{
1569 LogFlow(("ConsoleVRDPServer::usbBackendGetNext: pBackend = %p\n", pRemoteUSBBackend));
1570
1571 RemoteUSBBackend *pNextRemoteUSBBackend = NULL;
1572#ifdef VBOX_WITH_USB
1573
1574 int rc = lockConsoleVRDPServer ();
1575
1576 if (VBOX_SUCCESS (rc))
1577 {
1578 if (pRemoteUSBBackend == NULL)
1579 {
1580 /* The first backend in the list is requested. */
1581 pNextRemoteUSBBackend = mUSBBackends.pHead;
1582 }
1583 else
1584 {
1585 /* Get pointer to the next backend. */
1586 pNextRemoteUSBBackend = (RemoteUSBBackend *)pRemoteUSBBackend->pNext;
1587 }
1588
1589 if (pNextRemoteUSBBackend)
1590 {
1591 pNextRemoteUSBBackend->AddRef ();
1592 }
1593
1594 unlockConsoleVRDPServer ();
1595
1596 if (pRemoteUSBBackend)
1597 {
1598 pRemoteUSBBackend->Release ();
1599 }
1600 }
1601#endif
1602
1603 return pNextRemoteUSBBackend;
1604}
1605
1606#ifdef VBOX_WITH_USB
1607/* Internal method. Called under the ConsoleVRDPServerLock. */
1608RemoteUSBBackend *ConsoleVRDPServer::usbBackendFind (uint32_t u32ClientId)
1609{
1610 RemoteUSBBackend *pRemoteUSBBackend = mUSBBackends.pHead;
1611
1612 while (pRemoteUSBBackend)
1613 {
1614 if (pRemoteUSBBackend->ClientId () == u32ClientId)
1615 {
1616 break;
1617 }
1618
1619 pRemoteUSBBackend = (RemoteUSBBackend *)pRemoteUSBBackend->pNext;
1620 }
1621
1622 return pRemoteUSBBackend;
1623}
1624
1625/* Internal method. Called under the ConsoleVRDPServerLock. */
1626RemoteUSBBackend *ConsoleVRDPServer::usbBackendFindByUUID (const Guid *pGuid)
1627{
1628 RemoteUSBBackend *pRemoteUSBBackend = mUSBBackends.pHead;
1629
1630 while (pRemoteUSBBackend)
1631 {
1632 if (pRemoteUSBBackend->findUUID (pGuid))
1633 {
1634 break;
1635 }
1636
1637 pRemoteUSBBackend = (RemoteUSBBackend *)pRemoteUSBBackend->pNext;
1638 }
1639
1640 return pRemoteUSBBackend;
1641}
1642#endif
1643
1644/* Internal method. Called by the backend destructor. */
1645void ConsoleVRDPServer::usbBackendRemoveFromList (RemoteUSBBackend *pRemoteUSBBackend)
1646{
1647#ifdef VBOX_WITH_USB
1648 int rc = lockConsoleVRDPServer ();
1649 AssertRC (rc);
1650
1651 /* Exclude the found instance from the list. */
1652 if (pRemoteUSBBackend->pNext)
1653 {
1654 pRemoteUSBBackend->pNext->pPrev = pRemoteUSBBackend->pPrev;
1655 }
1656 else
1657 {
1658 mUSBBackends.pTail = (RemoteUSBBackend *)pRemoteUSBBackend->pPrev;
1659 }
1660
1661 if (pRemoteUSBBackend->pPrev)
1662 {
1663 pRemoteUSBBackend->pPrev->pNext = pRemoteUSBBackend->pNext;
1664 }
1665 else
1666 {
1667 mUSBBackends.pHead = (RemoteUSBBackend *)pRemoteUSBBackend->pNext;
1668 }
1669
1670 pRemoteUSBBackend->pNext = pRemoteUSBBackend->pPrev = NULL;
1671
1672 unlockConsoleVRDPServer ();
1673#endif
1674}
1675
1676
1677void ConsoleVRDPServer::SendUpdate (unsigned uScreenId, void *pvUpdate, uint32_t cbUpdate) const
1678{
1679#ifdef VBOX_VRDP
1680#ifdef VRDP_NO_COM
1681 if (mpEntryPoints)
1682 {
1683 mpEntryPoints->VRDPUpdate (mhServer, uScreenId, pvUpdate, cbUpdate);
1684 }
1685#else
1686 if (mpfnVRDPSendUpdate)
1687 mpfnVRDPSendUpdate (mhServer, uScreenId, pvUpdate, cbUpdate);
1688#endif /* VRDP_NO_COM */
1689#endif
1690}
1691
1692void ConsoleVRDPServer::SendResize (void) const
1693{
1694#ifdef VBOX_VRDP
1695#ifdef VRDP_NO_COM
1696 if (mpEntryPoints)
1697 {
1698 mpEntryPoints->VRDPResize (mhServer);
1699 }
1700#else
1701 if (mpfnVRDPSendResize)
1702 mpfnVRDPSendResize (mhServer);
1703#endif /* VRDP_NO_COM */
1704#endif
1705}
1706
1707void ConsoleVRDPServer::SendUpdateBitmap (unsigned uScreenId, uint32_t x, uint32_t y, uint32_t w, uint32_t h) const
1708{
1709#ifdef VBOX_VRDP
1710#ifdef VRDP_NO_COM
1711 VRDPORDERHDR update;
1712 update.x = x;
1713 update.y = y;
1714 update.w = w;
1715 update.h = h;
1716 if (mpEntryPoints)
1717 {
1718 mpEntryPoints->VRDPUpdate (mhServer, uScreenId, &update, sizeof (update));
1719 }
1720#else
1721 if (mpfnVRDPSendUpdateBitmap)
1722 mpfnVRDPSendUpdateBitmap (mhServer, uScreenId, x, y, w, h);
1723#endif /* VRDP_NO_COM */
1724#endif
1725}
1726
1727#ifdef VRDP_NO_COM
1728#else
1729void ConsoleVRDPServer::SetFramebuffer (IFramebuffer *framebuffer, uint32_t fFlags) const
1730{
1731#ifdef VBOX_VRDP
1732 if (mpfnVRDPSetFramebuffer)
1733 mpfnVRDPSetFramebuffer (mhServer, framebuffer, fFlags);
1734#endif
1735}
1736#endif /* VRDP_NO_COM */
1737
1738void ConsoleVRDPServer::SendAudioSamples (void *pvSamples, uint32_t cSamples, VRDPAUDIOFORMAT format) const
1739{
1740#ifdef VBOX_VRDP
1741#ifdef VRDP_NO_COM
1742 if (mpEntryPoints)
1743 {
1744 mpEntryPoints->VRDPAudioSamples (mhServer, pvSamples, cSamples, format);
1745 }
1746#else
1747 if (mpfnVRDPSendAudioSamples)
1748 mpfnVRDPSendAudioSamples (mhServer, pvSamples, cSamples, format);
1749#endif /* VRDP_NO_COM */
1750#endif
1751}
1752
1753void ConsoleVRDPServer::SendAudioVolume (uint16_t left, uint16_t right) const
1754{
1755#ifdef VBOX_VRDP
1756#ifdef VRDP_NO_COM
1757 if (mpEntryPoints)
1758 {
1759 mpEntryPoints->VRDPAudioVolume (mhServer, left, right);
1760 }
1761#else
1762 if (mpfnVRDPSendAudioVolume)
1763 mpfnVRDPSendAudioVolume (mhServer, left, right);
1764#endif /* VRDP_NO_COM */
1765#endif
1766}
1767
1768void ConsoleVRDPServer::SendUSBRequest (uint32_t u32ClientId, void *pvParms, uint32_t cbParms) const
1769{
1770#ifdef VBOX_VRDP
1771#ifdef VRDP_NO_COM
1772 if (mpEntryPoints)
1773 {
1774 mpEntryPoints->VRDPUSBRequest (mhServer, u32ClientId, pvParms, cbParms);
1775 }
1776#else
1777 if (mpfnVRDPSendUSBRequest)
1778 mpfnVRDPSendUSBRequest (mhServer, u32ClientId, pvParms, cbParms);
1779#endif /* VRDP_NO_COM */
1780#endif
1781}
1782
1783void ConsoleVRDPServer::QueryInfo (uint32_t index, void *pvBuffer, uint32_t cbBuffer, uint32_t *pcbOut) const
1784{
1785#ifdef VBOX_VRDP
1786#ifdef VRDP_NO_COM
1787 if (mpEntryPoints)
1788 {
1789 mpEntryPoints->VRDPQueryInfo (mhServer, index, pvBuffer, cbBuffer, pcbOut);
1790 }
1791#else
1792 if (mpfnVRDPQueryInfo)
1793 mpfnVRDPQueryInfo (mhServer, index, pvBuffer, cbBuffer, pcbOut);
1794#endif /* VRDP_NO_COM */
1795#endif
1796}
1797
1798#ifdef VBOX_VRDP
1799/* note: static function now! */
1800bool ConsoleVRDPServer::loadVRDPLibrary (void)
1801{
1802 int rc = VINF_SUCCESS;
1803
1804 if (!mVRDPLibrary)
1805 {
1806 rc = RTLdrLoad("VBoxVRDP", &mVRDPLibrary);
1807
1808 if (VBOX_SUCCESS(rc))
1809 {
1810 LogFlow(("VRDPServer::loadLibrary(): successfully loaded VRDP library.\n"));
1811
1812 struct SymbolEntry
1813 {
1814 const char *name;
1815 void **ppfn;
1816 };
1817
1818 #define DEFSYMENTRY(a) { #a, (void**)&mpfn##a }
1819
1820#ifdef VRDP_NO_COM
1821 static const struct SymbolEntry symbols[] =
1822 {
1823 DEFSYMENTRY(VRDPCreateServer)
1824 };
1825#else
1826 static const struct SymbolEntry symbols[] =
1827 {
1828 DEFSYMENTRY(VRDPStartServer),
1829 DEFSYMENTRY(VRDPSetCallback),
1830 DEFSYMENTRY(VRDPShutdownServer),
1831 DEFSYMENTRY(VRDPSendUpdate),
1832 DEFSYMENTRY(VRDPSendUpdateBitmap),
1833 DEFSYMENTRY(VRDPSendResize),
1834 DEFSYMENTRY(VRDPSendAudioSamples),
1835 DEFSYMENTRY(VRDPSendAudioVolume),
1836 DEFSYMENTRY(VRDPSendUSBRequest),
1837 DEFSYMENTRY(VRDPQueryInfo),
1838 DEFSYMENTRY(VRDPClipboard)
1839 };
1840#endif /* VRDP_NO_COM */
1841
1842 #undef DEFSYMENTRY
1843
1844 for (unsigned i = 0; i < ELEMENTS(symbols); i++)
1845 {
1846 rc = RTLdrGetSymbol(mVRDPLibrary, symbols[i].name, symbols[i].ppfn);
1847
1848 AssertMsgRC(rc, ("Error resolving VRDP symbol %s\n", symbols[i].name));
1849
1850 if (VBOX_FAILURE(rc))
1851 {
1852 break;
1853 }
1854 }
1855 }
1856 else
1857 {
1858 LogFlow(("VRDPServer::loadLibrary(): failed to load VRDP library! VRDP not available.\n"));
1859 mVRDPLibrary = NULL;
1860 }
1861 }
1862
1863 // just to be safe
1864 if (VBOX_FAILURE(rc))
1865 {
1866 if (mVRDPLibrary)
1867 {
1868 RTLdrClose (mVRDPLibrary);
1869 mVRDPLibrary = NULL;
1870 }
1871 }
1872
1873 return (mVRDPLibrary != NULL);
1874}
1875#endif /* VBOX_VRDP */
1876
1877/*
1878 * IRemoteDisplayInfo implementation.
1879 */
1880// constructor / destructor
1881/////////////////////////////////////////////////////////////////////////////
1882
1883HRESULT RemoteDisplayInfo::FinalConstruct()
1884{
1885 return S_OK;
1886}
1887
1888void RemoteDisplayInfo::FinalRelease()
1889{
1890 if (isReady())
1891 uninit ();
1892}
1893
1894// public methods only for internal purposes
1895/////////////////////////////////////////////////////////////////////////////
1896
1897/**
1898 * Initializes the guest object.
1899 */
1900HRESULT RemoteDisplayInfo::init (Console *aParent)
1901{
1902 LogFlowMember (("RemoteDisplayInfo::init (%p)\n", aParent));
1903
1904 ComAssertRet (aParent, E_INVALIDARG);
1905
1906 AutoLock alock (this);
1907 ComAssertRet (!isReady(), E_UNEXPECTED);
1908
1909 mParent = aParent;
1910
1911 setReady (true);
1912 return S_OK;
1913}
1914
1915/**
1916 * Uninitializes the instance and sets the ready flag to FALSE.
1917 * Called either from FinalRelease() or by the parent when it gets destroyed.
1918 */
1919void RemoteDisplayInfo::uninit()
1920{
1921 LogFlowMember (("RemoteDisplayInfo::uninit()\n"));
1922
1923 AutoLock alock (this);
1924 AssertReturn (isReady(), (void) 0);
1925
1926 mParent.setNull();
1927
1928 setReady (false);
1929}
1930
1931// IRemoteDisplayInfo properties
1932/////////////////////////////////////////////////////////////////////////////
1933
1934#define IMPL_GETTER_BOOL(_aType, _aName, _aIndex) \
1935 STDMETHODIMP RemoteDisplayInfo::COMGETTER(_aName) (_aType *a##_aName) \
1936 { \
1937 if (!a##_aName) \
1938 return E_POINTER; \
1939 \
1940 AutoLock alock (this); \
1941 CHECK_READY(); \
1942 \
1943 uint32_t value; \
1944 uint32_t cbOut = 0; \
1945 \
1946 mParent->consoleVRDPServer ()->QueryInfo \
1947 (_aIndex, &value, sizeof (value), &cbOut); \
1948 \
1949 *a##_aName = cbOut? !!value: FALSE; \
1950 \
1951 return S_OK; \
1952 }
1953
1954#define IMPL_GETTER_SCALAR(_aType, _aName, _aIndex) \
1955 STDMETHODIMP RemoteDisplayInfo::COMGETTER(_aName) (_aType *a##_aName) \
1956 { \
1957 if (!a##_aName) \
1958 return E_POINTER; \
1959 \
1960 AutoLock alock (this); \
1961 CHECK_READY(); \
1962 \
1963 _aType value; \
1964 uint32_t cbOut = 0; \
1965 \
1966 mParent->consoleVRDPServer ()->QueryInfo \
1967 (_aIndex, &value, sizeof (value), &cbOut); \
1968 \
1969 *a##_aName = cbOut? value: 0; \
1970 \
1971 return S_OK; \
1972 }
1973
1974#define IMPL_GETTER_BSTR(_aType, _aName, _aIndex) \
1975 STDMETHODIMP RemoteDisplayInfo::COMGETTER(_aName) (_aType *a##_aName) \
1976 { \
1977 if (!a##_aName) \
1978 return E_POINTER; \
1979 \
1980 AutoLock alock (this); \
1981 CHECK_READY(); \
1982 \
1983 uint32_t cbOut = 0; \
1984 \
1985 mParent->consoleVRDPServer ()->QueryInfo \
1986 (_aIndex, NULL, 0, &cbOut); \
1987 \
1988 if (cbOut == 0) \
1989 { \
1990 Bstr str(""); \
1991 str.cloneTo (a##_aName); \
1992 return S_OK; \
1993 } \
1994 \
1995 char *pchBuffer = (char *)RTMemTmpAlloc (cbOut); \
1996 \
1997 if (!pchBuffer) \
1998 { \
1999 Log(("RemoteDisplayInfo::" \
2000 #_aName \
2001 ": Failed to allocate memory %d bytes\n", cbOut)); \
2002 return E_OUTOFMEMORY; \
2003 } \
2004 \
2005 mParent->consoleVRDPServer ()->QueryInfo \
2006 (_aIndex, pchBuffer, cbOut, &cbOut); \
2007 \
2008 Bstr str(pchBuffer); \
2009 \
2010 str.cloneTo (a##_aName); \
2011 \
2012 RTMemTmpFree (pchBuffer); \
2013 \
2014 return S_OK; \
2015 }
2016
2017IMPL_GETTER_BOOL (BOOL, Active, VRDP_QI_ACTIVE);
2018IMPL_GETTER_SCALAR (ULONG, NumberOfClients, VRDP_QI_NUMBER_OF_CLIENTS);
2019IMPL_GETTER_SCALAR (LONG64, BeginTime, VRDP_QI_BEGIN_TIME);
2020IMPL_GETTER_SCALAR (LONG64, EndTime, VRDP_QI_END_TIME);
2021IMPL_GETTER_SCALAR (ULONG64, BytesSent, VRDP_QI_BYTES_SENT);
2022IMPL_GETTER_SCALAR (ULONG64, BytesSentTotal, VRDP_QI_BYTES_SENT_TOTAL);
2023IMPL_GETTER_SCALAR (ULONG64, BytesReceived, VRDP_QI_BYTES_RECEIVED);
2024IMPL_GETTER_SCALAR (ULONG64, BytesReceivedTotal, VRDP_QI_BYTES_RECEIVED_TOTAL);
2025IMPL_GETTER_BSTR (BSTR, User, VRDP_QI_USER);
2026IMPL_GETTER_BSTR (BSTR, Domain, VRDP_QI_DOMAIN);
2027IMPL_GETTER_BSTR (BSTR, ClientName, VRDP_QI_CLIENT_NAME);
2028IMPL_GETTER_BSTR (BSTR, ClientIP, VRDP_QI_CLIENT_IP);
2029IMPL_GETTER_SCALAR (ULONG, ClientVersion, VRDP_QI_CLIENT_VERSION);
2030IMPL_GETTER_SCALAR (ULONG, EncryptionStyle, VRDP_QI_ENCRYPTION_STYLE);
2031
2032#undef IMPL_GETTER_BSTR
2033#undef IMPL_GETTER_SCALAR
Note: See TracBrowser for help on using the repository browser.

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