ConsoleVRDPServer.cpp revision d88186f4bcef7c5a4eb95b58a22fd44a7b5e0375
/* $Id$ */
/** @file
* VBox Console VRDP Helper class
*/
/*
* Copyright (C) 2006-2012 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*/
#include "ConsoleVRDPServer.h"
#include "ConsoleImpl.h"
#include "DisplayImpl.h"
#include "KeyboardImpl.h"
#include "MouseImpl.h"
#include "AudioSnifferInterface.h"
#ifdef VBOX_WITH_EXTPACK
# include "ExtPackManagerImpl.h"
#endif
#include "VMMDev.h"
#ifdef VBOX_WITH_USB_CARDREADER
# include "UsbCardReader.h"
#endif
#ifdef VBOX_WITH_USB_VIDEO
# include "UsbWebcamInterface.h"
#endif
#include "Global.h"
#include "AutoCaller.h"
#include "Logging.h"
class VRDPConsoleListener
{
public:
{
}
{
return S_OK;
}
void uninit()
{
}
{
switch (aType)
{
{
break;
}
{
if (m_server)
{
}
break;
}
{
if (m_server)
{
}
break;
}
default:
AssertFailed();
}
return S_OK;
}
private:
};
#ifdef DEBUG_sunlover
#define LOGDUMPPTR Log
{
unsigned i;
for (i = 0; i < height; i++)
{
unsigned j;
{
unsigned k;
for (k = 0; k < 8; k++)
{
}
pu8And++;
}
LOGDUMPPTR(("\n"));
}
if (fXorMaskRGB32)
{
for (i = 0; i < height; i++)
{
unsigned j;
for (j = 0; j < width; j++)
{
}
LOGDUMPPTR(("\n"));
}
}
else
{
/* RDP 24 bit RGB mask. */
for (i = 0; i < height; i++)
{
unsigned j;
for (j = 0; j < width; j++)
{
pu8Xor += 3;
}
LOGDUMPPTR(("\n"));
}
}
}
#else
#define dumpPointer(a, b, c, d) do {} while (0)
#endif /* DEBUG_sunlover */
static void findTopLeftBorder(const uint8_t *pu8AndMask, const uint8_t *pu8XorMask, uint32_t width, uint32_t height, uint32_t *pxSkip, uint32_t *pySkip)
{
/*
* Find the top border of the AND mask. First assign to special value.
*/
unsigned y;
unsigned x;
{
/* For each complete byte in the row. */
for (x = 0; x < cbAndRow - 1; x++)
{
if (pu8And[x] != 0xFF)
{
ySkipAnd = y;
break;
}
}
{
/* Last byte. */
{
ySkipAnd = y;
}
}
}
{
ySkipAnd = 0;
}
/*
* Find the left border of the AND mask.
*/
/* For all bit columns. */
{
{
{
xSkipAnd = x;
break;
}
}
}
{
xSkipAnd = 0;
}
/*
* Find the XOR mask top border.
*/
{
for (x = 0; x < width; x++)
{
if (pu32Xor[x] != 0)
{
ySkipXor = y;
break;
}
}
}
{
ySkipXor = 0;
}
/*
* Find the left border of the XOR mask.
*/
/* For all columns. */
{
{
if (*pu32Xor != 0)
{
xSkipXor = x;
break;
}
}
}
{
xSkipXor = 0;
}
}
/* Generate an AND mask for alpha pointers here, because
* guest driver does not do that correctly for Vista pointers.
* Similar fix, changing the alpha threshold, could be applied
* for the guest driver, but then additions reinstall would be
* necessary, which we try to avoid.
*/
static void mousePointerGenerateANDMask(uint8_t *pu8DstAndMask, int cbDstAndMask, const uint8_t *pu8SrcAlpha, int w, int h)
{
int y;
for (y = 0; y < h; y++)
{
int x;
for (x = 0; x < w; x++, bitmask >>= 1)
{
if (bitmask == 0)
{
bitmask = 0x80;
}
/* Whether alpha channel value is not transparent enough for the pixel to be seen. */
{
}
}
/* Point to next source and dest scans. */
pu8SrcAlpha += w * 4;
}
}
{
LogSunlover(("VRDPConsoleListener::OnMousePointerShapeChange: %d, %d, %lux%lu, @%lu,%lu\n", visible, alpha, width, height, xHot, yHot));
if (m_server)
{
{
if (!visible)
{
}
}
{
{
return S_OK;
}
/* Pointer consists of 1 bpp AND and 24 BPP XOR masks.
* 'shape' AND mask followed by XOR mask.
* XOR mask contains 32 bit (lsb)BGR0(msb) values.
*
* We convert this to RDP color format which consist of
* one bpp AND mask and 24 BPP (BGR) color XOR image.
*
* RDP clients expect 8 aligned width and height of
* pointer (preferably 32x32).
*
* They even contain bugs which do not appear for
* 32x32 pointers but would appear for a 41x32 one.
*
* So set pointer size to 32x32. This can be done safely
* because most pointers are 32x32.
*/
if (alpha)
{
}
/* Windows guest alpha pointers are wider than 32 pixels.
* Try to find out the top-left border of the pointer and
* then copy only meaningful bits. All complete top rows
* and all complete left columns where (AND == 1 && XOR == 0)
* are skipped. Hot spot is adjusted.
*/
/* Must not skip the hot spot. */
/*
* Compute size and allocate memory for the pointer.
*/
if (pointer)
{
/* Copy AND mask. */
unsigned x, y;
for (y = 0; y < minheight; y++)
{
for (x = 0; x < minwidth; x++)
{
if (!bit)
{
byteIndex = x / 8;
bitIndex = x % 8;
}
}
src += srcmaskwidth;
dst -= rdpmaskwidth;
}
/* Point src to XOR mask */
for (y = 0; y < minheight ; y++)
{
for (x = 0; x < minwidth; x++)
{
}
src += srcdatawidth;
dst -= rdpdatawidth;
}
}
}
}
return S_OK;
}
// ConsoleVRDPServer
////////////////////////////////////////////////////////////////////////////////
{
{ VRDE_INTERFACE_VERSION_4, sizeof(VRDECALLBACKS_4) },
};
DECLCALLBACK(int) ConsoleVRDPServer::VRDPCallbackQueryProperty(void *pvCallback, uint32_t index, void *pvBuffer, uint32_t cbBuffer, uint32_t *pcbOut)
{
int rc = VERR_NOT_SUPPORTED;
switch (index)
{
case VRDE_QP_NETWORK_PORT:
{
/* This is obsolete, the VRDE server uses VRDE_QP_NETWORK_PORT_RANGE instead. */
{
rc = VINF_SUCCESS;
}
else
{
}
} break;
case VRDE_QP_NETWORK_ADDRESS:
{
/* The server expects UTF8. */
if (cbAddress >= 0x10000)
{
/* More than 64K seems to be an invalid address. */
break;
}
{
rc = VINF_SUCCESS;
}
else
{
}
} break;
case VRDE_QP_NUMBER_MONITORS:
{
{
rc = VINF_SUCCESS;
}
else
{
}
} break;
{
HRESULT hrc = server->mConsole->getVRDEServer()->GetVRDEProperty(Bstr("TCP/Ports").raw(), bstr.asOutParam());
{
bstr = "";
}
if (bstr == "0")
{
bstr = "3389";
}
/* The server expects UTF8. */
if (cbPortRange >= 0x10000)
{
/* More than 64K seems to be an invalid port range string. */
break;
}
{
rc = VINF_SUCCESS;
}
else
{
}
} break;
case VRDE_QP_VIDEO_CHANNEL:
{
HRESULT hrc = server->mConsole->getVRDEServer()->GetVRDEProperty(Bstr("VideoChannel/Enabled").raw(), bstr.asOutParam());
{
bstr = "";
}
{
rc = VINF_SUCCESS;
}
else
{
}
} break;
{
HRESULT hrc = server->mConsole->getVRDEServer()->GetVRDEProperty(Bstr("VideoChannel/Quality").raw(), bstr.asOutParam());
{
bstr = "";
}
{
rc = VINF_SUCCESS;
}
else
{
}
} break;
{
bstr.asOutParam());
{
{
}
}
{
rc = VINF_SUCCESS;
}
else
{
}
} break;
case VRDE_QP_FEATURE:
{
if (cbBuffer < sizeof(VRDEFEATURE))
{
break;
}
if (RT_FAILURE(rc))
{
break;
}
)
{
/* @todo these features should be per client. */
bstrValue.asOutParam());
{
bstrValue.asOutParam());
{
}
}
}
{
/* Generic properties. */
HRESULT hrc = server->mConsole->getVRDEServer()->GetVRDEProperty(Bstr(pszPropertyName).raw(), bstrValue.asOutParam());
{
}
}
else
{
}
/* Copy the value string to the callers buffer. */
if (rc == VINF_SUCCESS)
{
{
}
else
{
}
}
} break;
{
{
break;
}
rc = VINF_SUCCESS;
if (pcbOut)
{
}
} break;
case VRDE_SP_CLIENT_STATUS:
{
if (cbBuffer < sizeof(VRDECLIENTSTATUS))
{
break;
}
{
break;
}
if (RT_FAILURE(rc))
{
break;
}
rc = VINF_SUCCESS;
if (pcbOut)
{
}
} break;
default:
break;
}
return rc;
}
DECLCALLBACK(int) ConsoleVRDPServer::VRDPCallbackClientLogon(void *pvCallback, uint32_t u32ClientId, const char *pszUser, const char *pszPassword, const char *pszDomain)
{
}
DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackClientConnect(void *pvCallback, uint32_t u32ClientId)
{
}
DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackClientDisconnect(void *pvCallback, uint32_t u32ClientId, uint32_t fu32Intercepted)
{
{
if (pPort)
{
}
else
{
AssertFailed();
}
}
}
DECLCALLBACK(int) ConsoleVRDPServer::VRDPCallbackIntercept(void *pvCallback, uint32_t u32ClientId, uint32_t fu32Intercept, void **ppvIntercept)
{
int rc = VERR_NOT_SUPPORTED;
switch (fu32Intercept)
{
{
if (ppvIntercept)
{
*ppvIntercept = server;
}
rc = VINF_SUCCESS;
} break;
{
rc = VINF_SUCCESS;
} break;
{
if (ppvIntercept)
{
*ppvIntercept = server;
}
rc = VINF_SUCCESS;
} break;
{
/* This request is processed internally by the ConsoleVRDPServer.
* Only one client is allowed to intercept audio input.
*/
{
if (pPort)
{
if (ppvIntercept)
{
*ppvIntercept = server;
}
}
else
{
AssertFailed();
}
}
else
{
Log(("AUDIOIN: ignored client %u, active client %u\n", u32ClientId, server->mu32AudioInputClientId));
}
} break;
default:
break;
}
return rc;
}
DECLCALLBACK(int) ConsoleVRDPServer::VRDPCallbackUSB(void *pvCallback, void *pvIntercept, uint32_t u32ClientId, uint8_t u8Code, const void *pvRet, uint32_t cbRet)
{
#ifdef VBOX_WITH_USB
#else
return VERR_NOT_SUPPORTED;
#endif
}
DECLCALLBACK(int) ConsoleVRDPServer::VRDPCallbackClipboard(void *pvCallback, void *pvIntercept, uint32_t u32ClientId, uint32_t u32Function, uint32_t u32Format, const void *pvData, uint32_t cbData)
{
}
DECLCALLBACK(bool) ConsoleVRDPServer::VRDPCallbackFramebufferQuery(void *pvCallback, unsigned uScreenId, VRDEFRAMEBUFFERINFO *pInfo)
{
bool fAvailable = false;
if (pfb)
{
/* Query framebuffer parameters. */
ULONG bitsPerPixel = 0;
/* Now fill the information as requested by the caller. */
fAvailable = true;
}
{
}
return fAvailable;
}
DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackFramebufferLock(void *pvCallback, unsigned uScreenId)
{
{
}
}
DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackFramebufferUnlock(void *pvCallback, unsigned uScreenId)
{
{
}
}
{
{
}
{
}
}
DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackInput(void *pvCallback, int type, const void *pvInput, unsigned cbInput)
{
switch (type)
{
case VRDE_INPUT_SCANCODE:
{
if (cbInput == sizeof(VRDEINPUTSCANCODE))
{
/* Track lock keys. */
{
}
{
}
{
}
{
/* Key pressed. */
}
}
} break;
case VRDE_INPUT_POINT:
{
if (cbInput == sizeof(VRDEINPUTPOINT))
{
int mouseButtons = 0;
int iWheel = 0;
{
}
{
}
{
}
{
iWheel = -1;
}
{
iWheel = 1;
}
if (server->m_fGuestWantsAbsolute)
{
pConsole->getMouse()->PutMouseEventAbsolute(pInputPoint->x + 1, pInputPoint->y + 1, iWheel, 0 /* Horizontal wheel */, mouseButtons);
} else
{
}
}
} break;
case VRDE_INPUT_CAD:
{
} break;
case VRDE_INPUT_RESET:
{
} break;
case VRDE_INPUT_SYNCH:
{
if (cbInput == sizeof(VRDEINPUTSYNCH))
{
/* The client initiated synchronization. Always make the guest to reflect the client state.
* Than means, when the guest changes the state itself, it is forced to return to the client
* state.
*/
{
}
{
}
}
} break;
default:
break;
}
}
DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackVideoModeHint(void *pvCallback, unsigned cWidth, unsigned cHeight, unsigned cBitsPerPixel, unsigned uScreenId)
{
}
void *pvCtx,
const void *pvData,
{
switch (u32Event)
{
case VRDE_AUDIOIN_BEGIN:
{
);
} break;
case VRDE_AUDIOIN_DATA:
{
} break;
case VRDE_AUDIOIN_END:
{
} break;
default:
return;
}
}
{
mcClipboardRefs = 0;
#ifdef VBOX_WITH_USB
mUSBBackends.fThreadRunning = false;
mUSBBackends.event = 0;
#endif
mhServer = 0;
m_fGuestWantsAbsolute = false;
m_mousex = 0;
m_mousey = 0;
m_InputSynch.fGuestNumLock = false;
m_InputSynch.fGuestCapsLock = false;
m_InputSynch.fGuestScrollLock = false;
m_InputSynch.fClientNumLock = false;
m_InputSynch.fClientCapsLock = false;
m_InputSynch.fClientScrollLock = false;
{
}
mVRDPBindPort = -1;
mAuthLibrary = 0;
/*
* Optional interfaces.
*/
m_fInterfaceImage = false;
}
{
Stop();
if (mConsoleListener)
{
}
unsigned i;
for (i = 0; i < RT_ELEMENTS(maFramebuffers); i++)
{
if (maFramebuffers[i])
{
maFramebuffers[i]->Release();
maFramebuffers[i] = NULL;
}
}
if (RTCritSectIsInitialized(&mCritSect))
{
}
if (RTCritSectIsInitialized(&mTSMFLock))
{
}
}
int ConsoleVRDPServer::Launch(void)
{
LogFlowThisFunc(("\n"));
/*
* Check if VRDE is enabled.
*/
if (!fEnabled)
return VINF_SUCCESS;
/*
* Check that a VRDE extension pack name is set and resolve it into a
* library path.
*/
if (bstrExtPack.isEmpty())
return VINF_NOT_SUPPORTED;
int vrc = VINF_SUCCESS;
strVrdeLibrary = "VBoxVRDP";
else
{
#ifdef VBOX_WITH_EXTPACK
#else
#endif
}
if (RT_SUCCESS(vrc))
{
/*
* Load the VRDE library and start the server, if it is enabled.
*/
if (RT_SUCCESS(vrc))
{
vrc = mpfnVRDECreateServer(&mCallbacks.header, this, (VRDEINTERFACEHDR **)&pEntryPoints4, &mhServer);
if (RT_SUCCESS(vrc))
{
}
else if (vrc == VERR_VERSION_MISMATCH)
{
/* An older version of VRDE is installed, try version 3. */
static VRDECALLBACKS_3 sCallbacks3 =
{
{ VRDE_INTERFACE_VERSION_3, sizeof(VRDECALLBACKS_3) },
};
vrc = mpfnVRDECreateServer(&sCallbacks3.header, this, (VRDEINTERFACEHDR **)&pEntryPoints3, &mhServer);
if (RT_SUCCESS(vrc))
{
}
else if (vrc == VERR_VERSION_MISMATCH)
{
/* An older version of VRDE is installed, try version 1. */
static VRDECALLBACKS_1 sCallbacks1 =
{
{ VRDE_INTERFACE_VERSION_1, sizeof(VRDECALLBACKS_1) },
};
vrc = mpfnVRDECreateServer(&sCallbacks1.header, this, (VRDEINTERFACEHDR **)&pEntryPoints1, &mhServer);
if (RT_SUCCESS(vrc))
{
}
}
}
if (RT_SUCCESS(vrc))
{
if (mServerInterfaceVersion >= 4)
{
/* The server supports optional interfaces. */
/* Image interface. */
this);
if (RT_SUCCESS(vrc))
{
m_fInterfaceImage = true;
}
/* Mouse pointer interface. */
NULL,
this);
if (RT_SUCCESS(vrc))
{
}
else
{
}
/* Smartcard interface. */
this);
if (RT_SUCCESS(vrc))
{
}
else
{
}
/* Raw TSMF interface. */
this);
if (RT_SUCCESS(vrc))
{
}
else
{
}
/* VideoIn interface. */
this);
if (RT_SUCCESS(vrc))
{
}
else
{
}
/* Since these interfaces are optional, it is always a success here. */
vrc = VINF_SUCCESS;
}
#ifdef VBOX_WITH_USB
#endif
}
else
{
if (vrc != VERR_NET_ADDRESS_IN_USE)
/* Don't unload the lib, because it prevents us trying again or
because there may be other users? */
}
}
}
return vrc;
}
typedef struct H3DORInstance
{
int32_t x;
int32_t y;
uint32_t w;
uint32_t h;
bool fCreated;
/* static */ DECLCALLBACK(void) ConsoleVRDPServer::H3DORBegin(const void *pvContext, void **ppvInstance,
const char *pszFormat)
{
if (p)
{
p->hImageBitmap = NULL;
p->x = 0;
p->y = 0;
p->w = 0;
p->h = 0;
p->fCreated = false;
/* Host 3D service passes the actual format of data in this redirect instance.
* That is what will be in the H3DORFrame's parameters pvData and cbData.
*/
{
/* Accept it. */
}
else
{
RTMemFree(p);
p = NULL;
}
}
/* Caller check this for NULL. */
*ppvInstance = p;
}
{
Assert(p);
/* @todo find out what to do if size changes to 0x0 from non zero */
if (w == 0 || h == 0)
{
/* Do nothing. */
return;
}
if (p->hImageBitmap)
{
/* An image handle has been already created,
* check if it has the same size as the reported geometry.
*/
if ( p->x == x
&& p->y == y
&& p->w == w
&& p->h == h)
{
LogFlowFunc(("geometry not changed\n"));
/* Do nothing. Continue using the existing handle. */
}
else
{
if (RT_SUCCESS(rc))
{
p->x = x;
p->y = y;
p->w = w;
p->h = h;
}
else
{
/* The handle must be recreated. Delete existing handle here. */
p->hImageBitmap = NULL;
}
}
}
if (!p->hImageBitmap)
{
/* Create a new bitmap handle. */
* Clipping can be done here or in VRDP server.
* If VRDP does clipping, then uScreenId parameter
* is not necessary and coords must be global.
* (have to check which coords are used in opengl service).
* Since all VRDE API uses a ScreenId,
* the clipping must be done here in ConsoleVRDPServer
*/
&p->hImageBitmap,
p,
&rect,
NULL,
0,
if (RT_FAILURE(rc))
{
/* No support for a 3D + WINDOW. Try bitmap updates. */
fu32CompletionFlags = 0;
&p->hImageBitmap,
p,
0,
&rect,
NULL,
0,
}
if (RT_SUCCESS(rc))
{
p->x = x;
p->y = y;
p->w = w;
p->h = h;
if ((fu32CompletionFlags & VRDE_IMAGE_F_COMPLETE_ASYNC) == 0)
{
p->fCreated = true;
}
}
else
{
p->hImageBitmap = NULL;
p->w = 0;
p->h = 0;
}
}
}
{
Assert(p);
if (cRects == 0)
{
/* Complete image is visible. */
1,
&rect);
}
else
{
paRects);
}
}
{
Assert(p);
/* Currently only a topdown BGR0 bitmap format is supported. */
p->x,
p->y,
p->w,
p->h,
&image,
sizeof(VRDEIMAGEBITMAP));
}
{
Assert(p);
RTMemFree(p);
}
/* static */ DECLCALLBACK(int) ConsoleVRDPServer::H3DORContextProperty(const void *pvContext, uint32_t index,
{
int rc = VINF_SUCCESS;
if (index == H3DOR_PROP_FORMATS)
{
/* Return a comma separated list of supported formats. */
static const char *pszSupportedFormats = H3DOR_FMT_RGBA_TOPDOWN;
{
}
else
{
}
}
else
{
}
return rc;
}
void ConsoleVRDPServer::remote3DRedirect(void)
{
if (!m_fInterfaceImage)
{
/* No redirect without corresponding interface. */
return;
}
/* Check if 3D redirection has been enabled. */
HRESULT hrc = mConsole->getVRDEServer()->GetVRDEProperty(Bstr("H3DRedirect/Enabled").raw(), bstr.asOutParam());
{
bstr = "";
}
if (!fEnabled)
{
return;
}
/* Tell the host 3D service to redirect output using the ConsoleVRDPServer callbacks. */
{
this,
};
if (!pVMMDev)
{
AssertMsgFailed(("remote3DRedirect no vmmdev\n"));
return;
}
&parm);
if (!RT_SUCCESS(rc))
{
return;
}
LogRel(("VRDE: Enabled 3D redirect.\n"));
return;
}
void *pvUser,
void *pvData,
{
LogFlowFunc(("pvContext %p, pvUser %p, hVideo %p, u32Id %u, pvData %p, cbData %d\n",
Assert(p);
if (u32Id == VRDE_IMAGE_NOTIFY_HANDLE_CREATE)
{
{
AssertFailed();
return VERR_INVALID_PARAMETER;
}
LogFlowFunc(("VRDE_IMAGE_NOTIFY_HANDLE_CREATE u32StreamId %d\n",
u32StreamId));
if (u32StreamId != 0)
{
p->fCreated = true; // @todo not needed?
}
else
{
/* The stream has not been created. */
}
}
return VINF_SUCCESS;
}
void *pvData,
{
#ifdef VBOX_WITH_USB_CARDREADER
#else
return VERR_NOT_SUPPORTED;
#endif
}
int rcRequest,
void *pvUser,
void *pvData,
{
#ifdef VBOX_WITH_USB_CARDREADER
#else
return VERR_NOT_SUPPORTED;
#endif
}
int ConsoleVRDPServer::SCardRequest(void *pvUser, uint32_t u32Function, const void *pvData, uint32_t cbData)
{
int rc = VINF_SUCCESS;
{
}
else
{
}
return rc;
}
struct TSMFHOSTCHCTX;
struct TSMFVRDPCTX;
typedef struct TSMFHOSTCHCTX
{
void *pvDataReceived;
typedef struct TSMFVRDPCTX
{
void *pvCallbacks;
} TSMFVRDPCTX;
{
if (!pHostChCtx)
{
return VERR_NO_MEMORY;
}
if (!pVRDPCtx)
{
return VERR_NO_MEMORY;
}
return VINF_SUCCESS;
}
int ConsoleVRDPServer::tsmfLock(void)
{
return rc;
}
void ConsoleVRDPServer::tsmfUnlock(void)
{
}
void **ppvChannel,
void *pvCallbacks)
{
LogFlowFunc(("\n"));
/* Create 2 context structures: for the VRDP server and for the host service. */
if (RT_FAILURE(rc))
{
return rc;
}
if (RT_SUCCESS(rc))
{
/* @todo contexts should be in a list for accounting. */
*ppvChannel = pHostChCtx;
}
else
{
}
return rc;
}
{
LogFlowFunc(("\n"));
if (RT_SUCCESS(rc))
{
bool fClose = false;
uint32_t u32ChannelHandle = 0;
if (pHostChCtx->pVRDPCtx)
{
/* There is still a VRDP context for this channel. */
fClose = true;
}
pThis->tsmfUnlock();
if (fClose)
{
}
else
{
LogFlowFunc(("No VRDE channel.\n"));
}
}
}
const void *pvData,
{
if (RT_SUCCESS(rc))
{
bool fSend = false;
uint32_t u32ChannelHandle = 0;
if (pHostChCtx->pVRDPCtx)
{
fSend = true;
}
pThis->tsmfUnlock();
if (fSend)
{
}
}
return rc;
}
void *pvData,
{
if (RT_SUCCESS(rc))
{
if (cbToCopy != 0)
{
if (cbRemaining != 0)
{
}
}
pThis->tsmfUnlock();
*pcbReceived = cbToCopy;
}
return rc;
}
const void *pvParm,
const void *pvData,
{
if (!pvChannel)
{
/* Special case, the provider must answer rather than a channel instance. */
if (u32Code == VBOX_HOST_CHANNEL_CTRL_EXISTS)
{
*pcbDataReturned = 0;
return VINF_SUCCESS;
}
return VERR_NOT_IMPLEMENTED;
}
/* Channels do not support this. */
return VERR_NOT_IMPLEMENTED;
}
void ConsoleVRDPServer::setupTSMF(void)
{
{
return;
}
/* Register with the host channel service. */
{
this,
};
static char szProviderName[] = "/vrde/tsmf";
if (!pVMMDev)
{
AssertMsgFailed(("setupTSMF no vmmdev\n"));
return;
}
2,
if (!RT_SUCCESS(rc))
{
return;
}
LogRel(("VRDE: Enabled TSMF channel.\n"));
return;
}
/* @todo these defines must be in a header, which is used by guest component as well. */
#define VBOX_TSMF_HCH_CREATE_ACCEPTED (VBOX_HOST_CHANNEL_EVENT_USER + 0)
void *pvChannel,
const void *pvParm,
{
int rc = VINF_SUCCESS;
{
LogFlowFunc(("tsmfHostChannel: Channel disconnected. Skipping.\n"));
return;
}
switch (u32Notification)
{
{
LogFlowFunc(("tsmfHostChannel: VRDE_TSMF_N_CREATE_ACCEPTED(%p): p->u32ChannelHandle %d\n",
pVRDPCtx, p->u32ChannelHandle));
NULL, 0);
} break;
{
NULL, 0);
} break;
case VRDE_TSMF_N_DATA:
{
/* Save the data in the intermediate buffer and send the event. */
ev.u32SizeAvailable = 0;
if (RT_SUCCESS(rc))
{
if (pHostChCtx)
{
if (pHostChCtx->pvDataReceived)
{
}
else
{
}
}
else
{
LogFlowFunc(("tsmfHostChannel: VRDE_TSMF_N_DATA: no host channel. Skipping\n"));
}
pThis->tsmfUnlock();
}
} break;
case VRDE_TSMF_N_DISCONNECTED:
{
NULL, 0);
/* The callback context will not be used anymore. */
if (RT_SUCCESS(rc))
{
if (pVRDPCtx->pHostChCtx)
{
/* There is still a host channel context for this channel. */
}
pThis->tsmfUnlock();
}
} break;
default:
{
AssertFailed();
} break;
}
}
const void *pvData,
{
#ifdef VBOX_WITH_USB_VIDEO
#else
#endif
}
int rcRequest,
void *pDeviceCtx,
void *pvUser,
const VRDEVIDEOINDEVICEDESC *pDeviceDesc,
{
#ifdef VBOX_WITH_USB_VIDEO
#else
#endif
}
int rcRequest,
void *pDeviceCtx,
void *pvUser,
const VRDEVIDEOINCTRLHDR *pControl,
{
#ifdef VBOX_WITH_USB_VIDEO
#else
#endif
}
int rcRequest,
void *pDeviceCtx,
const VRDEVIDEOINPAYLOADHDR *pFrame,
{
#ifdef VBOX_WITH_USB_VIDEO
#else
#endif
}
int ConsoleVRDPServer::VideoInDeviceAttach(const VRDEVIDEOINDEVICEHANDLE *pDeviceHandle, void *pvDeviceCtx)
{
int rc;
{
}
else
{
}
return rc;
}
{
int rc;
{
}
else
{
}
return rc;
}
int ConsoleVRDPServer::VideoInGetDeviceDesc(void *pvUser, const VRDEVIDEOINDEVICEHANDLE *pDeviceHandle)
{
int rc;
{
}
else
{
}
return rc;
}
{
int rc;
{
}
else
{
}
return rc;
}
void ConsoleVRDPServer::EnableConnections(void)
{
if (mpEntryPoints && mhServer)
{
/* Redirect 3D output if it is enabled. */
/* Setup the generic TSMF channel. */
setupTSMF();
}
}
{
if (mpEntryPoints && mhServer)
{
}
}
{
int rc = VINF_SUCCESS;
{
if (pu8Pointer != NULL)
{
/* AND mask. */
if (cbDstMask)
{
}
/* XOR mask */
}
else
{
rc = VERR_NO_MEMORY;
}
}
else
{
}
return rc;
}
{
if (mpEntryPoints && mhServer)
{
}
}
void ConsoleVRDPServer::MousePointerHide(void)
{
if (mpEntryPoints && mhServer)
{
}
}
void ConsoleVRDPServer::Stop(void)
{
Assert(VALID_PTR(this)); /** @todo r=bird: there are(/was) some odd cases where this buster was invalid on
* linux. Just remove this when it's 100% sure that problem has been fixed. */
if (mhServer)
{
/* Reset the handle to avoid further calls to the server. */
mhServer = 0;
if (mpEntryPoints && hServer)
{
}
}
#ifdef VBOX_WITH_USB
#endif /* VBOX_WITH_USB */
if (mAuthLibrary)
{
mAuthLibrary = 0;
}
}
/* Worker thread for Remote USB. The thread polls the clients for
* the list of attached USB devices.
*
*
* The thread is always running when the VRDP server is active.
*
* The thread scans backends and requests the device list every 2 seconds.
*
* When device list is available, the thread calls the Console to process it.
*
*/
#define VRDP_DEVICE_LIST_PERIOD_MS (2000)
#ifdef VBOX_WITH_USB
{
while (pOwner->isRemoteUSBThreadRunning())
{
{
}
}
return VINF_SUCCESS;
}
{
mUSBBackends.fThreadRunning = true;
}
bool ConsoleVRDPServer::isRemoteUSBThreadRunning(void)
{
return mUSBBackends.fThreadRunning;
}
{
}
void ConsoleVRDPServer::remoteUSBThreadStart(void)
{
if (RT_FAILURE(rc))
{
AssertFailed();
mUSBBackends.event = 0;
}
if (RT_SUCCESS(rc))
{
}
if (RT_FAILURE(rc))
{
}
else
{
/* Wait until the thread is ready. */
}
}
void ConsoleVRDPServer::remoteUSBThreadStop(void)
{
mUSBBackends.fThreadRunning = false;
{
}
if (mUSBBackends.event)
{
mUSBBackends.event = 0;
}
}
#endif /* VBOX_WITH_USB */
typedef struct AuthCtx
{
const char *pszCaller;
const char *pszUser;
const char *pszPassword;
const char *pszDomain;
int fLogon;
unsigned clientId;
} AuthCtx;
{
if (pCtx->pfnAuthEntry3)
{
}
else if (pCtx->pfnAuthEntry2)
{
}
else if (pCtx->pfnAuthEntry)
{
}
return VINF_SUCCESS;
}
{
/* Use a separate thread because external modules might need a lot of stack space. */
if (RT_SUCCESS(rc))
{
}
if (RT_SUCCESS(rc))
{
/* Only update the result if the thread finished without errors. */
}
else
{
}
return result;
}
{
LogFlow(("ConsoleVRDPServer::Authenticate: uuid = %RTuuid, guestJudgement = %d, pszUser = %s, pszPassword = %s, pszDomain = %s, u32ClientId = %d\n",
/*
* Called only from VRDP input thread. So thread safety is not required.
*/
if (!mAuthLibrary)
{
/* Load the external authentication library. */
int rc;
else
{
if (RT_FAILURE(rc))
{
/* Backward compatibility with old default 'VRDPAuth' name.
* Try to load new default 'VBoxAuth' instead.
*/
if (filename == "VRDPAuth")
{
LogRel(("AUTH: ConsoleVRDPServer::Authenticate: loading external authentication library VBoxAuth\n"));
}
}
}
if (RT_FAILURE(rc))
if (RT_SUCCESS(rc))
{
typedef struct AuthEntryInfoStruct
{
const char *pszName;
void **ppvAddress;
AuthEntryInfo entries[] =
{
{ AUTHENTRY3_NAME, (void **)&mpfnAuthEntry3 },
{ AUTHENTRY2_NAME, (void **)&mpfnAuthEntry2 },
{ AUTHENTRY_NAME, (void **)&mpfnAuthEntry },
};
/* Get the entry point. */
while (pEntryInfo->pszName)
{
if (RT_SUCCESS(rc2))
{
/* Found an entry point. */
rc = VINF_SUCCESS;
break;
}
if (rc2 != VERR_SYMBOL_NOT_FOUND)
{
}
pEntryInfo++;
}
}
if (RT_FAILURE(rc))
{
rc);
if (mAuthLibrary)
{
mAuthLibrary = 0;
}
return AuthResultAccessDenied;
}
}
switch (result)
{
case AuthResultAccessDenied:
LogRel(("AUTH: external authentication module returned 'access denied'\n"));
break;
case AuthResultAccessGranted:
LogRel(("AUTH: external authentication module returned 'access granted'\n"));
break;
LogRel(("AUTH: external authentication module returned 'delegate request to guest'\n"));
break;
default:
}
return result;
}
{
LogFlow(("ConsoleVRDPServer::AuthDisconnect: uuid = %RTuuid, u32ClientId = %d\n",
rawuuid, u32ClientId));
}
int ConsoleVRDPServer::lockConsoleVRDPServer(void)
{
return rc;
}
void ConsoleVRDPServer::unlockConsoleVRDPServer(void)
{
}
const void *pvData,
{
LogFlowFunc(("pvCallback = %p, u32ClientId = %d, u32Function = %d, u32Format = 0x%08X, pvData = %p, cbData = %d\n",
int rc = VINF_SUCCESS;
switch (u32Function)
{
{
if (pServer->mpfnClipboardCallback)
{
(void *)pvData,
cbData);
}
} break;
{
if (pServer->mpfnClipboardCallback)
{
(void *)pvData,
cbData);
}
} break;
default:
}
return rc;
}
void *pvParms,
{
LogFlowFunc(("pvExtension = %p, u32Function = %d, pvParms = %p, cbParms = %d\n",
int rc = VINF_SUCCESS;
switch (u32Function)
{
{
} break;
{
/* The guest announces clipboard formats. This must be delivered to all clients. */
{
NULL,
0,
NULL);
}
} break;
{
/* The clipboard service expects that the pvData buffer will be filled
* with clipboard data. The server returns the data from the client that
* announced the requested format most recently.
*/
{
}
} break;
{
{
NULL);
}
} break;
default:
}
return rc;
}
{
int rc = lockConsoleVRDPServer();
if (RT_SUCCESS(rc))
{
if (mcClipboardRefs == 0)
{
rc = HGCMHostRegisterServiceExtension(&mhClipboard, "VBoxSharedClipboard", ClipboardServiceExtension, this);
if (RT_SUCCESS(rc))
{
}
}
}
}
{
int rc = lockConsoleVRDPServer();
if (RT_SUCCESS(rc))
{
if (mcClipboardRefs == 0)
{
}
}
}
/* That is called on INPUT thread of the VRDP server.
* The ConsoleVRDPServer keeps a list of created backend instances.
*/
{
#ifdef VBOX_WITH_USB
/* Create a new instance of the USB backend for the new client. */
if (pRemoteUSBBackend)
{
/* Append the new instance in the list. */
int rc = lockConsoleVRDPServer();
if (RT_SUCCESS(rc))
{
if (mUSBBackends.pHead)
{
}
else
{
}
if (ppvIntercept)
{
}
}
if (RT_FAILURE(rc))
{
}
}
#endif /* VBOX_WITH_USB */
}
{
#ifdef VBOX_WITH_USB
/* Find the instance. */
int rc = lockConsoleVRDPServer();
if (RT_SUCCESS(rc))
{
if (pRemoteUSBBackend)
{
/* Notify that it will be deleted. */
}
}
if (pRemoteUSBBackend)
{
/* Here the instance has been excluded from the list and can be dereferenced. */
}
#endif
}
{
#ifdef VBOX_WITH_USB
/* Find the instance. */
int rc = lockConsoleVRDPServer();
if (RT_SUCCESS(rc))
{
if (pRemoteUSBBackend)
{
/* Inform the backend instance that it is referenced by the Guid. */
if (fAdded)
{
/* Reference the instance because its pointer is being taken. */
}
else
{
}
}
}
if (pRemoteUSBBackend)
{
return pRemoteUSBBackend->GetBackendCallbackPointer();
}
#endif
return NULL;
}
{
#ifdef VBOX_WITH_USB
/* Find the instance. */
int rc = lockConsoleVRDPServer();
if (RT_SUCCESS(rc))
{
if (pRemoteUSBBackend)
{
}
if (pRemoteUSBBackend)
{
}
}
#endif
}
{
#ifdef VBOX_WITH_USB
int rc = lockConsoleVRDPServer();
if (RT_SUCCESS(rc))
{
if (pRemoteUSBBackend == NULL)
{
/* The first backend in the list is requested. */
}
else
{
/* Get pointer to the next backend. */
}
{
}
if (pRemoteUSBBackend)
{
}
}
#endif
return pNextRemoteUSBBackend;
}
#ifdef VBOX_WITH_USB
/* Internal method. Called under the ConsoleVRDPServerLock. */
{
while (pRemoteUSBBackend)
{
{
break;
}
}
return pRemoteUSBBackend;
}
/* Internal method. Called under the ConsoleVRDPServerLock. */
{
while (pRemoteUSBBackend)
{
{
break;
}
}
return pRemoteUSBBackend;
}
#endif
/* Internal method. Called by the backend destructor. */
{
#ifdef VBOX_WITH_USB
int rc = lockConsoleVRDPServer();
/* Exclude the found instance from the list. */
if (pRemoteUSBBackend->pNext)
{
}
else
{
}
if (pRemoteUSBBackend->pPrev)
{
}
else
{
}
#endif
}
{
if (mpEntryPoints && mhServer)
{
}
}
void ConsoleVRDPServer::SendResize(void) const
{
if (mpEntryPoints && mhServer)
{
}
}
void ConsoleVRDPServer::SendUpdateBitmap(unsigned uScreenId, uint32_t x, uint32_t y, uint32_t w, uint32_t h) const
{
update.x = x;
update.y = y;
update.w = w;
update.h = h;
if (mpEntryPoints && mhServer)
{
}
}
void ConsoleVRDPServer::SendAudioSamples(void *pvSamples, uint32_t cSamples, VRDEAUDIOFORMAT format) const
{
if (mpEntryPoints && mhServer)
{
}
}
{
if (mpEntryPoints && mhServer)
{
}
}
{
if (mpEntryPoints && mhServer)
{
}
}
/* @todo rc not needed? */
void *pvContext,
{
{
if (u32ClientId != 0) /* 0 would mean broadcast to all clients. */
{
cSamples);
* Currently not used because only one client is allowed to
* do audio input and the client id is saved by the ConsoleVRDPServer.
*/
return VINF_SUCCESS;
}
}
return VERR_NOT_SUPPORTED;
}
{
{
if (u32ClientId != 0) /* 0 would mean broadcast to all clients. */
{
}
}
}
#ifdef VBOX_WITH_USB_VIDEO
{
*pu16Heigh = 640;
*pu16Width = 480;
return VINF_SUCCESS;
}
{
* the stream
*/
return VINF_SUCCESS;
}
#endif
void ConsoleVRDPServer::QueryInfo(uint32_t index, void *pvBuffer, uint32_t cbBuffer, uint32_t *pcbOut) const
{
if (index == VRDE_QI_PORT)
{
{
}
}
else if (mpEntryPoints && mhServer)
{
}
}
{
int rc = VINF_SUCCESS;
if (mVRDPLibrary == NIL_RTLDRMOD)
{
if (RTPathHavePath(pszLibraryName))
else
rc = SUPR3HardenedLdrLoadAppPriv(pszLibraryName, &mVRDPLibrary, RTLDRLOAD_FLAGS_LOCAL, &ErrInfo.Core);
if (RT_SUCCESS(rc))
{
struct SymbolEntry
{
const char *name;
void **ppfn;
};
#define DEFSYMENTRY(a) { #a, (void**)&mpfn##a }
static const struct SymbolEntry s_aSymbols[] =
{
};
for (unsigned i = 0; i < RT_ELEMENTS(s_aSymbols); i++)
{
if (RT_FAILURE(rc))
{
break;
}
}
}
else
{
LogRel(("VRDE: Error loading the library '%s': %s (%Rrc)\n", pszLibraryName, ErrInfo.Core.pszMsg, rc));
else
}
}
if (RT_FAILURE(rc))
{
if (mVRDPLibrary != NIL_RTLDRMOD)
{
}
}
return rc;
}
/*
* IVRDEServerInfo implementation.
*/
// constructor / destructor
/////////////////////////////////////////////////////////////////////////////
{
}
{
}
{
return BaseFinalConstruct();
}
void VRDEServerInfo::FinalRelease()
{
uninit();
}
// public methods only for internal purposes
/////////////////////////////////////////////////////////////////////////////
/**
* Initializes the guest object.
*/
{
/* Enclose the state transition NotReady->InInit->Ready */
AutoInitSpan autoInitSpan(this);
/* Confirm a successful initialization */
return S_OK;
}
/**
* Uninitializes the instance and sets the ready flag to FALSE.
* Called either from FinalRelease() or by the parent when it gets destroyed.
*/
void VRDEServerInfo::uninit()
{
LogFlowThisFunc(("\n"));
/* Enclose the state transition Ready->InUninit->NotReady */
AutoUninitSpan autoUninitSpan(this);
if (autoUninitSpan.uninitDone())
return;
}
// IVRDEServerInfo properties
/////////////////////////////////////////////////////////////////////////////
{ \
if (!a##_aName) \
return E_POINTER; \
\
AutoCaller autoCaller(this); \
\
/* todo: Not sure if a AutoReadLock would be sufficient. */ \
\
\
\
\
return S_OK; \
} \
extern void IMPL_GETTER_BOOL_DUMMY(void)
{ \
if (!a##_aName) \
return E_POINTER; \
\
AutoCaller autoCaller(this); \
\
/* todo: Not sure if a AutoReadLock would be sufficient. */ \
\
\
\
\
return S_OK; \
} \
extern void IMPL_GETTER_SCALAR_DUMMY(void)
{ \
if (!a##_aName) \
return E_POINTER; \
\
AutoCaller autoCaller(this); \
\
/* todo: Not sure if a AutoReadLock would be sufficient. */ \
\
\
\
if (cbOut == 0) \
{ \
return S_OK; \
} \
\
\
if (!pchBuffer) \
{ \
Log(("VRDEServerInfo::" \
#_aName \
": Failed to allocate memory %d bytes\n", cbOut)); \
return E_OUTOFMEMORY; \
} \
\
\
\
\
\
return S_OK; \
} \
extern void IMPL_GETTER_BSTR_DUMMY(void)
/* vi: set tabstop=4 shiftwidth=4 expandtab: */