STDMETHODIMP Guest::SetCredentials(IN_BSTR aUserName, IN_BSTR aPassword,
IN_BSTR aDomain, BOOL aAllowInteractiveLogon)
{
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
/* forward the information to the VMM device */
VMMDev *pVMMDev = mParent->getVMMDev();
if (pVMMDev)
{
PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
if (pVMMDevPort)
{
uint32_t u32Flags = VMMDEV_SETCREDENTIALS_GUESTLOGON;
if (!aAllowInteractiveLogon)
u32Flags = VMMDEV_SETCREDENTIALS_NOLOCALLOGON;
pVMMDevPort->pfnSetCredentials(pVMMDevPort,
Utf8Str(aUserName).c_str(),
Utf8Str(aPassword).c_str(),
Utf8Str(aDomain).c_str(),
u32Flags);
return S_OK;
}
}
return setError(VBOX_E_VM_ERROR,
tr("VMM device is not available (is the VM running?)"));
}
int GuestObject::sendCommand(uint32_t uFunction,
uint32_t uParms, PVBOXHGCMSVCPARM paParms)
{
LogFlowThisFuncEnter();
#ifndef VBOX_GUESTCTRL_TEST_CASE
ComObjPtr<Console> pConsole = mConsole;
Assert(!pConsole.isNull());
/* Forward the information to the VMM device. */
VMMDev *pVMMDev = pConsole->getVMMDev();
AssertPtr(pVMMDev);
LogFlowThisFunc(("uFunction=%RU32, uParms=%RU32\n", uFunction, uParms));
int vrc = pVMMDev->hgcmHostCall(HGCMSERVICE_NAME, uFunction, uParms, paParms);
if (RT_FAILURE(vrc))
{
/** @todo What to do here? */
}
#else
/* Not needed within testcases. */
int vrc = VINF_SUCCESS;
#endif
LogFlowFuncLeaveRC(vrc);
return vrc;
}
STDMETHODIMP Guest::COMSETTER(MemoryBalloonSize)(ULONG aMemoryBalloonSize)
{
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
/* We must be 100% sure that IMachine::COMSETTER(MemoryBalloonSize)
* does not call us back in any way! */
HRESULT ret = mParent->machine()->COMSETTER(MemoryBalloonSize)(aMemoryBalloonSize);
if (ret == S_OK)
{
mMemoryBalloonSize = aMemoryBalloonSize;
/* forward the information to the VMM device */
VMMDev *pVMMDev = mParent->getVMMDev();
/* MUST release all locks before calling VMM device as its critsect
* has higher lock order than anything in Main. */
alock.release();
if (pVMMDev)
{
PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
if (pVMMDevPort)
pVMMDevPort->pfnSetMemoryBalloon(pVMMDevPort, aMemoryBalloonSize);
}
}
return ret;
}
STDMETHODIMP Guest::COMSETTER(StatisticsUpdateInterval)(ULONG aUpdateInterval)
{
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
if (mStatUpdateInterval)
if (aUpdateInterval == 0)
RTTimerLRStop(mStatTimer);
else
RTTimerLRChangeInterval(mStatTimer, aUpdateInterval);
else
if (aUpdateInterval != 0)
{
RTTimerLRChangeInterval(mStatTimer, aUpdateInterval);
RTTimerLRStart(mStatTimer, 0);
}
mStatUpdateInterval = aUpdateInterval;
/* forward the information to the VMM device */
VMMDev *pVMMDev = mParent->getVMMDev();
/* MUST release all locks before calling VMM device as its critsect
* has higher lock order than anything in Main. */
alock.release();
if (pVMMDev)
{
PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
if (pVMMDevPort)
pVMMDevPort->pfnSetStatisticsInterval(pVMMDevPort, aUpdateInterval);
}
return S_OK;
}
int GuestDnD::hostCall(uint32_t u32Function, uint32_t cParms, PVBOXHGCMSVCPARM paParms) const
{
Assert(!m_pGuest.isNull());
ComObjPtr<Console> pConsole = m_pGuest->i_getConsole();
/* Forward the information to the VMM device. */
Assert(!pConsole.isNull());
VMMDev *pVMMDev = pConsole->i_getVMMDev();
if (!pVMMDev)
return VERR_COM_OBJECT_NOT_FOUND;
return pVMMDev->hgcmHostCall("VBoxDragAndDropSvc", u32Function, cParms, paParms);
}
/** Report the front-end's mouse handling capabilities to the VMM device and
* thus to the guest.
* @note all calls out of this object are made with no locks held! */
HRESULT Mouse::updateVMMDevMouseCaps(uint32_t fCapsAdded,
uint32_t fCapsRemoved)
{
VMMDev *pVMMDev = mParent->getVMMDev();
if (!pVMMDev)
return E_FAIL; /* No assertion, as the front-ends can send events
* at all sorts of inconvenient times. */
PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
if (!pVMMDevPort)
return E_FAIL; /* same here */
int rc = pVMMDevPort->pfnUpdateMouseCapabilities(pVMMDevPort, fCapsAdded,
fCapsRemoved);
return RT_SUCCESS(rc) ? S_OK : E_FAIL;
}
/**
* Send an absolute position event to the VMM device.
* @note all calls out of this object are made with no locks held!
*
* @returns COM status code
*/
HRESULT Mouse::reportAbsEventToVMMDev(int32_t mouseXAbs, int32_t mouseYAbs)
{
VMMDev *pVMMDev = mParent->getVMMDev();
ComAssertRet(pVMMDev, E_FAIL);
PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
ComAssertRet(pVMMDevPort, E_FAIL);
if (mouseXAbs != mcLastAbsX || mouseYAbs != mcLastAbsY)
{
int vrc = pVMMDevPort->pfnSetAbsoluteMouse(pVMMDevPort,
mouseXAbs, mouseYAbs);
if (RT_FAILURE(vrc))
return setError(VBOX_E_IPRT_ERROR,
tr("Could not send the mouse event to the virtual mouse (%Rrc)"),
vrc);
}
return S_OK;
}
HRESULT Guest::setCredentials(const com::Utf8Str &aUserName, const com::Utf8Str &aPassword,
const com::Utf8Str &aDomain, BOOL aAllowInteractiveLogon)
{
/* Check for magic domain names which are used to pass encryption keys to the disk. */
if (Utf8Str(aDomain) == "@@disk")
return mParent->i_setDiskEncryptionKeys(aPassword);
else if (Utf8Str(aDomain) == "@@mem")
{
/** @todo */
return E_NOTIMPL;
}
else
{
/* forward the information to the VMM device */
VMMDev *pVMMDev = mParent->i_getVMMDev();
if (pVMMDev)
{
PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
if (pVMMDevPort)
{
uint32_t u32Flags = VMMDEV_SETCREDENTIALS_GUESTLOGON;
if (!aAllowInteractiveLogon)
u32Flags = VMMDEV_SETCREDENTIALS_NOLOCALLOGON;
pVMMDevPort->pfnSetCredentials(pVMMDevPort,
aUserName.c_str(),
aPassword.c_str(),
aDomain.c_str(),
u32Flags);
return S_OK;
}
}
}
return setError(VBOX_E_VM_ERROR,
tr("VMM device is not available (is the VM running?)"));
}
int Display::i_videoAccelEnable(bool fEnable, VBVAMEMORY *pVbvaMemory, PPDMIDISPLAYPORT pUpPort)
{
int rc = VINF_SUCCESS;
VIDEOACCEL *pVideoAccel = &mVideoAccelLegacy;
/* Called each time the guest wants to use acceleration,
* or when the VGA device disables acceleration,
* or when restoring the saved state with accel enabled.
*
* VGA device disables acceleration on each video mode change
* and on reset.
*
* Guest enabled acceleration at will. And it has to enable
* acceleration after a mode change.
*/
LogRelFlowFunc(("mfVideoAccelEnabled = %d, fEnable = %d, pVbvaMemory = %p\n",
pVideoAccel->fVideoAccelEnabled, fEnable, pVbvaMemory));
/* Strictly check parameters. Callers must not pass anything in the case. */
Assert((fEnable && pVbvaMemory) || (!fEnable && pVbvaMemory == NULL));
if (!i_VideoAccelAllowed ())
return VERR_NOT_SUPPORTED;
/* Check that current status is not being changed */
if (pVideoAccel->fVideoAccelEnabled == fEnable)
return rc;
if (pVideoAccel->fVideoAccelEnabled)
{
/* Process any pending orders and empty the VBVA ring buffer. */
i_videoAccelFlush (pUpPort);
}
if (!fEnable && pVideoAccel->pVbvaMemory)
pVideoAccel->pVbvaMemory->fu32ModeFlags &= ~VBVA_F_MODE_ENABLED;
if (fEnable)
{
/* Process any pending VGA device changes, resize. */
pUpPort->pfnUpdateDisplayAll(pUpPort, /* fFailOnResize = */ false);
}
/* Protect the videoaccel state transition. */
RTCritSectEnter(&mVideoAccelLock);
if (fEnable)
{
/* Initialize the hardware memory. */
i_vbvaSetMemoryFlags(pVbvaMemory, true, mfVideoAccelVRDP,
mfu32SupportedOrders, maFramebuffers, mcMonitors);
pVbvaMemory->off32Data = 0;
pVbvaMemory->off32Free = 0;
memset(pVbvaMemory->aRecords, 0, sizeof(pVbvaMemory->aRecords));
pVbvaMemory->indexRecordFirst = 0;
pVbvaMemory->indexRecordFree = 0;
pVideoAccel->pVbvaMemory = pVbvaMemory;
pVideoAccel->fVideoAccelEnabled = true;
LogRel(("VBVA: Enabled.\n"));
}
else
{
pVideoAccel->pVbvaMemory = NULL;
pVideoAccel->fVideoAccelEnabled = false;
LogRel(("VBVA: Disabled.\n"));
}
RTCritSectLeave(&mVideoAccelLock);
if (!fEnable)
{
pUpPort->pfnUpdateDisplayAll(pUpPort, /* fFailOnResize = */ false);
}
/* Notify the VMMDev, which saves VBVA status in the saved state,
* and needs to know current status.
*/
VMMDev *pVMMDev = mParent->i_getVMMDev();
if (pVMMDev)
{
PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
if (pVMMDevPort)
pVMMDevPort->pfnVBVAChange(pVMMDevPort, fEnable);
}
LogRelFlowFunc(("%Rrc.\n", rc));
return rc;
}
