STDMETHODIMP Session::AccessGuestProperty(IN_BSTR aName, IN_BSTR aValue, IN_BSTR aFlags,
BOOL aIsSetter, BSTR *aRetValue, LONG64 *aRetTimestamp, BSTR *aRetFlags)
{
#ifdef VBOX_WITH_GUEST_PROPS
AutoCaller autoCaller(this);
AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
if (mState != SessionState_Locked)
return setError(VBOX_E_INVALID_VM_STATE,
tr("Machine is not locked by session (session state: %s)."),
Global::stringifySessionState(mState));
AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
CheckComArgStrNotEmptyOrNull(aName);
if (!aIsSetter && !VALID_PTR(aRetValue))
return E_POINTER;
if (!aIsSetter && !VALID_PTR(aRetTimestamp))
return E_POINTER;
if (!aIsSetter && !VALID_PTR(aRetFlags))
return E_POINTER;
/* aValue can be NULL for a setter call if the property is to be deleted. */
if (aIsSetter && (aValue != NULL) && !VALID_PTR(aValue))
return E_INVALIDARG;
/* aFlags can be null if it is to be left as is */
if (aIsSetter && (aFlags != NULL) && !VALID_PTR(aFlags))
return E_INVALIDARG;
if (!aIsSetter)
return mConsole->getGuestProperty(aName, aRetValue, aRetTimestamp, aRetFlags);
else
return mConsole->setGuestProperty(aName, aValue, aFlags);
#else /* VBOX_WITH_GUEST_PROPS not defined */
ReturnComNotImplemented();
#endif /* VBOX_WITH_GUEST_PROPS not defined */
}
STDMETHODIMP USBController::CreateDeviceFilter (IN_BSTR aName,
IUSBDeviceFilter **aFilter)
{
#ifdef VBOX_WITH_USB
CheckComArgOutPointerValid(aFilter);
CheckComArgStrNotEmptyOrNull(aName);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
/* the machine needs to be mutable */
AutoMutableStateDependency adep(m->pParent);
if (FAILED(adep.rc())) return adep.rc();
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
ComObjPtr<USBDeviceFilter> filter;
filter.createObject();
HRESULT rc = filter->init (this, aName);
ComAssertComRCRetRC (rc);
rc = filter.queryInterfaceTo(aFilter);
AssertComRCReturnRC(rc);
return S_OK;
#else
NOREF(aName);
NOREF(aFilter);
ReturnComNotImplemented();
#endif
}
STDMETHODIMP MachineDebugger::DumpGuestCore(IN_BSTR a_bstrFilename, IN_BSTR a_bstrCompression)
{
CheckComArgStrNotEmptyOrNull(a_bstrFilename);
Utf8Str strFilename(a_bstrFilename);
if (a_bstrCompression && *a_bstrCompression)
return setError(E_INVALIDARG, tr("The compression parameter must be empty"));
AutoCaller autoCaller(this);
HRESULT hrc = autoCaller.rc();
if (SUCCEEDED(hrc))
{
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
Console::SafeVMPtr ptrVM(mParent);
hrc = ptrVM.rc();
if (SUCCEEDED(hrc))
{
int vrc = DBGFR3CoreWrite(ptrVM, strFilename.c_str(), false /*fReplaceFile*/);
if (RT_SUCCESS(vrc))
hrc = S_OK;
else
hrc = setError(E_FAIL, tr("DBGFR3CoreWrite failed with %Rrc"), vrc);
}
}
return hrc;
}
STDMETHODIMP USBDeviceFilter::COMSETTER(Name) (IN_BSTR aName)
{
CheckComArgStrNotEmptyOrNull(aName);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
/* the machine needs to be mutable */
AutoMutableStateDependency adep(mParent->getMachine());
if (FAILED(adep.rc())) return adep.rc();
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
if (mData->mName != aName)
{
m_fModified = true;
ComObjPtr<Machine> pMachine = mParent->getMachine();
mData.backup();
mData->mName = aName;
// leave the lock before informing callbacks
alock.release();
AutoWriteLock mlock(pMachine COMMA_LOCKVAL_SRC_POS);
pMachine->setModified(Machine::IsModified_USB);
mlock.release();
return mParent->onDeviceFilterChange(this);
}
return S_OK;
}
STDMETHODIMP VFSExplorer::Cd(IN_BSTR aDir, IProgress **aProgress)
{
CheckComArgStrNotEmptyOrNull(aDir);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
{
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
m->strPath = aDir;
}
return Update(aProgress);
}
STDMETHODIMP Guest::DragGHDropped(IN_BSTR bstrFormat, DragAndDropAction_T action, IProgress **ppProgress)
{
/* Input validation */
CheckComArgStrNotEmptyOrNull(bstrFormat);
CheckComArgOutPointerValid(ppProgress);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
#if defined(VBOX_WITH_DRAG_AND_DROP) && defined(VBOX_WITH_DRAG_AND_DROP_GH)
return m_pGuestDnD->dragGHDropped(bstrFormat, action, ppProgress);
#else /* VBOX_WITH_DRAG_AND_DROP */
ReturnComNotImplemented();
#endif /* !VBOX_WITH_DRAG_AND_DROP */
}
STDMETHODIMP Session::AccessGuestProperty(IN_BSTR aName, IN_BSTR aValue, IN_BSTR aFlags,
BOOL aIsSetter, BSTR *aRetValue, LONG64 *aRetTimestamp, BSTR *aRetFlags)
{
#ifdef VBOX_WITH_GUEST_PROPS
# ifndef VBOX_COM_INPROC_API_CLIENT
AutoCaller autoCaller(this);
AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
if (mState != SessionState_Locked)
return setError(VBOX_E_INVALID_VM_STATE,
tr("Machine is not locked by session (session state: %s)."),
Global::stringifySessionState(mState));
AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
CheckComArgStrNotEmptyOrNull(aName);
if (!aIsSetter && !VALID_PTR(aRetValue))
return E_POINTER;
if (!aIsSetter && !VALID_PTR(aRetTimestamp))
return E_POINTER;
if (!aIsSetter && !VALID_PTR(aRetFlags))
return E_POINTER;
/* aValue can be NULL for a setter call if the property is to be deleted. */
if (aIsSetter && (aValue != NULL) && !VALID_PTR(aValue))
return setError(E_INVALIDARG, tr("Invalid value pointer"));
/* aFlags can be null if it is to be left as is */
if (aIsSetter && (aFlags != NULL) && !VALID_PTR(aFlags))
return setError(E_INVALIDARG, tr("Invalid flags pointer"));
/* If this session is not in a VM process fend off the call. The caller
* handles this correctly, by doing the operation in VBoxSVC. */
if (!mConsole)
return E_ACCESSDENIED;
if (!aIsSetter)
return mConsole->getGuestProperty(aName, aRetValue, aRetTimestamp, aRetFlags);
else
return mConsole->setGuestProperty(aName, aValue, aFlags);
# else /* VBOX_COM_INPROC_API_CLIENT */
/** @todo This is nonsense, non-VM API users shouldn't need to deal with this
* method call, VBoxSVC should be clever enough to see that the
* session doesn't have a console! */
return E_ACCESSDENIED;
# endif /* VBOX_COM_INPROC_API_CLIENT */
#else /* VBOX_WITH_GUEST_PROPS */
ReturnComNotImplemented();
#endif /* VBOX_WITH_GUEST_PROPS */
}
STDMETHODIMP Guest::DragHGPutData(ULONG uScreenId, IN_BSTR bstrFormat, ComSafeArrayIn(BYTE, data), IProgress **ppProgress)
{
/* Input validation */
CheckComArgStrNotEmptyOrNull(bstrFormat);
CheckComArgSafeArrayNotNull(data);
CheckComArgOutPointerValid(ppProgress);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
#ifdef VBOX_WITH_DRAG_AND_DROP
return m_pGuestDnD->dragHGPutData(uScreenId, bstrFormat, ComSafeArrayInArg(data), ppProgress);
#else /* VBOX_WITH_DRAG_AND_DROP */
ReturnComNotImplemented();
#endif /* !VBOX_WITH_DRAG_AND_DROP */
}
STDMETHODIMP HostUSBDeviceFilter::COMSETTER(Name) (IN_BSTR aName)
{
CheckComArgStrNotEmptyOrNull(aName);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
if (mData->mName != aName)
{
mData->mName = aName;
/* leave the lock before informing callbacks */
alock.release();
return mParent->onUSBDeviceFilterChange (this);
}
return S_OK;
}
/**
* Start teleporter to the specified target.
*
* @returns COM status code.
*
* @param aHostname The name of the target host.
* @param aPort The TCP port number.
* @param aPassword The password.
* @param aMaxDowntime Max allowed "downtime" in milliseconds.
* @param aProgress Where to return the progress object.
*/
STDMETHODIMP
Console::Teleport(IN_BSTR aHostname, ULONG aPort, IN_BSTR aPassword, ULONG aMaxDowntime, IProgress **aProgress)
{
/*
* Validate parameters, check+hold object status, write lock the object
* and validate the state.
*/
CheckComArgOutPointerValid(aProgress);
CheckComArgStrNotEmptyOrNull(aHostname);
CheckComArgStrNotEmptyOrNull(aPassword);
CheckComArgExprMsg(aPort, aPort > 0 && aPort <= 65535, ("is %u", aPort));
CheckComArgExprMsg(aMaxDowntime, aMaxDowntime > 0, ("is %u", aMaxDowntime));
Utf8Str strPassword(aPassword);
if (!strPassword.isEmpty())
{
if (VBoxIsPasswordHashed(&strPassword))
return setError(E_INVALIDARG, tr("The specified password resembles a hashed password, expected plain text"));
VBoxHashPassword(&strPassword);
}
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
AutoWriteLock autoLock(this COMMA_LOCKVAL_SRC_POS);
LogFlowThisFunc(("mMachineState=%d\n", mMachineState));
switch (mMachineState)
{
case MachineState_Running:
case MachineState_Paused:
break;
default:
return setError(VBOX_E_INVALID_VM_STATE,
tr("Invalid machine state: %s (must be Running or Paused)"),
Global::stringifyMachineState(mMachineState));
}
/*
* Create a progress object, spawn a worker thread and change the state.
* Note! The thread won't start working until we release the lock.
*/
LogFlowThisFunc(("Initiating TELEPORT request...\n"));
ComObjPtr<Progress> ptrProgress;
HRESULT hrc = ptrProgress.createObject();
if (SUCCEEDED(hrc))
hrc = ptrProgress->init(static_cast<IConsole *>(this),
Bstr(tr("Teleporter")).raw(),
TRUE /*aCancelable*/);
if (FAILED(hrc))
return hrc;
TeleporterStateSrc *pState = new TeleporterStateSrc(this, mpUVM, ptrProgress, mMachineState);
pState->mstrPassword = strPassword;
pState->mstrHostname = aHostname;
pState->muPort = aPort;
pState->mcMsMaxDowntime = aMaxDowntime;
void *pvUser = static_cast<void *>(static_cast<TeleporterState *>(pState));
ptrProgress->setCancelCallback(teleporterProgressCancelCallback, pvUser);
int vrc = RTThreadCreate(NULL, Console::teleporterSrcThreadWrapper, (void *)pState, 0 /*cbStack*/,
RTTHREADTYPE_EMULATION, 0 /*fFlags*/, "Teleport");
if (RT_SUCCESS(vrc))
{
if (mMachineState == MachineState_Running)
hrc = setMachineState(MachineState_Teleporting);
else
hrc = setMachineState(MachineState_TeleportingPausedVM);
if (SUCCEEDED(hrc))
{
ptrProgress.queryInterfaceTo(aProgress);
mptrCancelableProgress = ptrProgress;
}
else
ptrProgress->Cancel();
}
else
{
ptrProgress->setCancelCallback(NULL, NULL);
delete pState;
hrc = setError(E_FAIL, tr("RTThreadCreate -> %Rrc"), vrc);
}
return hrc;
}
