HRESULT VRDEServer::getAuthLibrary(com::Utf8Str &aLibrary)
{
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
aLibrary = mData->mAuthLibrary;
alock.release();
if (aLibrary.isEmpty())
{
/* Get the global setting. */
ComPtr<ISystemProperties> systemProperties;
HRESULT hrc = mParent->i_getVirtualBox()->COMGETTER(SystemProperties)(systemProperties.asOutParam());
if (SUCCEEDED(hrc))
{
Bstr strlib;
hrc = systemProperties->COMGETTER(VRDEAuthLibrary)(strlib.asOutParam());
if (SUCCEEDED(hrc))
aLibrary = Utf8Str(strlib).c_str();
}
if (FAILED(hrc))
return setError(hrc, "failed to query the library setting\n");
}
return S_OK;
}
HRESULT SystemProperties::i_setAutostartDatabasePath(const com::Utf8Str &aPath)
{
HRESULT rc = S_OK;
AutostartDb *autostartDb = this->mParent->i_getAutostartDb();
if (!aPath.isEmpty())
{
/* Update path in the autostart database. */
int vrc = autostartDb->setAutostartDbPath(aPath.c_str());
if (RT_SUCCESS(vrc))
m->strAutostartDatabasePath = aPath;
else
rc = setError(E_FAIL,
tr("Cannot set the autostart database path (%Rrc)"),
vrc);
}
else
{
int vrc = autostartDb->setAutostartDbPath(NULL);
if (RT_SUCCESS(vrc) || vrc == VERR_NOT_SUPPORTED)
m->strAutostartDatabasePath = "";
else
rc = setError(E_FAIL,
tr("Deleting the autostart database path failed (%Rrc)"),
vrc);
}
return rc;
}
HRESULT AudioAdapter::setProperty(const com::Utf8Str &aKey, const com::Utf8Str &aValue)
{
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
/* Generic properties processing.
* Look up the old value first; if nothing's changed then do nothing.
*/
Utf8Str strOldValue;
settings::StringsMap::const_iterator cit = mData->m->properties.find(aKey);
if (cit != mData->m->properties.end())
strOldValue = cit->second;
if (strOldValue != aValue)
{
if (aValue.isEmpty())
mData->m->properties.erase(aKey);
else
mData->m->properties[aKey] = aValue;
}
alock.release();
return S_OK;
}
HRESULT DHCPServer::start(const com::Utf8Str &aNetworkName,
const com::Utf8Str &aTrunkName,
const com::Utf8Str &aTrunkType)
{
/* Silently ignore attempts to run disabled servers. */
if (!m->enabled)
return S_OK;
/* Commmon Network Settings */
m->dhcp.setOption(NetworkServiceRunner::kNsrKeyNetwork, aNetworkName.c_str());
if (!aTrunkName.isEmpty())
m->dhcp.setOption(NetworkServiceRunner::kNsrTrunkName, aTrunkName.c_str());
m->dhcp.setOption(NetworkServiceRunner::kNsrKeyTrunkType, aTrunkType.c_str());
/* XXX: should this MAC default initialization moved to NetworkServiceRunner? */
char strMAC[32];
Guid guid;
guid.create();
RTStrPrintf (strMAC, sizeof(strMAC), "08:00:27:%02X:%02X:%02X",
guid.raw()->au8[0],
guid.raw()->au8[1],
guid.raw()->au8[2]);
m->dhcp.setOption(NetworkServiceRunner::kNsrMacAddress, strMAC);
m->dhcp.setOption(NetworkServiceRunner::kNsrIpAddress, Utf8Str(m->IPAddress).c_str());
m->dhcp.setOption(NetworkServiceRunner::kNsrIpNetmask, Utf8Str(m->GlobalDhcpOptions[DhcpOpt_SubnetMask].text).c_str());
m->dhcp.setOption(DHCPServerRunner::kDsrKeyLowerIp, Utf8Str(m->lowerIP).c_str());
m->dhcp.setOption(DHCPServerRunner::kDsrKeyUpperIp, Utf8Str(m->upperIP).c_str());
/* XXX: This parameters Dhcp Server will fetch via API */
return RT_FAILURE(m->dhcp.start(!m->router /* KillProcOnExit */)) ? E_FAIL : S_OK;
//m->dhcp.detachFromServer(); /* need to do this to avoid server shutdown on runner destruction */
}
HRESULT SystemProperties::i_setWebServiceAuthLibrary(const com::Utf8Str &aPath)
{
if (!aPath.isEmpty())
m->strWebServiceAuthLibrary = aPath;
else
m->strWebServiceAuthLibrary = "VBoxAuth";
return S_OK;
}
HRESULT SystemProperties::i_setDefaultHardDiskFormat(const com::Utf8Str &aFormat)
{
if (!aFormat.isEmpty())
m->strDefaultHardDiskFormat = aFormat;
else
m->strDefaultHardDiskFormat = "VDI";
return S_OK;
}
HRESULT SystemProperties::getLoggingLevel(com::Utf8Str &aLoggingLevel)
{
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
aLoggingLevel = m->strLoggingLevel;
if (aLoggingLevel.isEmpty())
aLoggingLevel = VBOXSVC_LOG_DEFAULT;
return S_OK;
}
HRESULT DHCPServer::setConfiguration(const com::Utf8Str &aIPAddress,
const com::Utf8Str &aNetworkMask,
const com::Utf8Str &aLowerIP,
const com::Utf8Str &aUpperIP)
{
AssertReturn(!aIPAddress.isEmpty(), E_INVALIDARG);
AssertReturn(!aNetworkMask.isEmpty(), E_INVALIDARG);
AssertReturn(!aLowerIP.isEmpty(), E_INVALIDARG);
AssertReturn(!aUpperIP.isEmpty(), E_INVALIDARG);
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
m->IPAddress = aIPAddress;
m->GlobalDhcpOptions[DhcpOpt_SubnetMask] = aNetworkMask;
m->lowerIP = aLowerIP;
m->upperIP = aUpperIP;
// save the global settings; for that we should hold only the VirtualBox lock
alock.release();
AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
return mVirtualBox->i_saveSettings();
}
// public methods only for internal purposes
/////////////////////////////////////////////////////////////////////////////
HRESULT VRDEServer::setVRDEExtPack(const com::Utf8Str &aExtPack)
{
HRESULT hrc = S_OK;
/* the machine can also be in saved state for this property to change */
AutoMutableOrSavedOrRunningStateDependency adep(mParent);
hrc = adep.rc();
if (SUCCEEDED(hrc))
{
/*
* If not empty, check the specific extension pack.
*/
if (!aExtPack.isEmpty())
{
if (aExtPack.equals(VBOXVRDP_KLUDGE_EXTPACK_NAME))
hrc = S_OK;
else
{
#ifdef VBOX_WITH_EXTPACK
ExtPackManager *pExtPackMgr = mParent->i_getVirtualBox()->i_getExtPackManager();
hrc = pExtPackMgr->i_checkVrdeExtPack(&aExtPack);
#else
hrc = setError(E_FAIL, tr("Extension pack '%s' does not exist"), aExtPack.c_str());
#endif
}
}
if (SUCCEEDED(hrc))
{
/*
* Update the setting if there is an actual change, post an
* change event to trigger a VRDE server restart.
*/
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
if (aExtPack != mData->mVrdeExtPack)
{
mData.backup();
mData->mVrdeExtPack = aExtPack;
/* leave the lock before informing callbacks */
alock.release();
AutoWriteLock mlock(mParent COMMA_LOCKVAL_SRC_POS);
mParent->i_setModified(Machine::IsModified_VRDEServer);
mlock.release();
mParent->i_onVRDEServerChange(/* aRestart */ TRUE);
}
}
}
return hrc;
}
/**
* Translates a X.509 unique identifier to a string.
*
* @returns S_OK.
* @param a_pUniqueId The unique identifier.
* @param a_rReturn The return string value.
* @throws std::bad_alloc
*/
HRESULT Certificate::i_getUniqueIdentifier(PCRTCRX509UNIQUEIDENTIFIER a_pUniqueId, com::Utf8Str &a_rReturn)
{
/* The a_pUniqueId may not be present! */
if (RTCrX509UniqueIdentifier_IsPresent(a_pUniqueId))
{
void const *pvData = RTASN1BITSTRING_GET_BIT0_PTR(a_pUniqueId);
size_t const cbData = RTASN1BITSTRING_GET_BYTE_SIZE(a_pUniqueId);
size_t const cbFormatted = cbData * 3 - 1 + 1;
a_rReturn.reserve(cbFormatted); /* throws */
int vrc = RTStrPrintHexBytes(a_rReturn.mutableRaw(), cbFormatted, pvData, cbData, RTSTRPRINTHEXBYTES_F_SEP_COLON);
a_rReturn.jolt();
AssertRCReturn(vrc, Global::vboxStatusCodeToCOM(vrc));
}
else
Assert(a_rReturn.isEmpty());
return S_OK;
}
HRESULT HostNetworkInterface::enableStaticIPConfig(const com::Utf8Str &aIPAddress,
const com::Utf8Str &aNetworkMask)
{
#ifndef VBOX_WITH_HOSTNETIF_API
return E_NOTIMPL;
#else
if (aIPAddress.isEmpty())
{
if (m.IPAddress)
{
int rc = NetIfEnableStaticIpConfig(mVirtualBox, this, m.IPAddress, 0, 0);
if (RT_SUCCESS(rc))
{
m.realIPAddress = 0;
if (FAILED(mVirtualBox->SetExtraData(BstrFmt("HostOnly/%ls/IPAddress",
mInterfaceName.raw()).raw(), NULL)))
return E_FAIL;
if (FAILED(mVirtualBox->SetExtraData(BstrFmt("HostOnly/%ls/IPNetMask",
mInterfaceName.raw()).raw(), NULL)))
return E_FAIL;
return S_OK;
}
}
else
return S_OK;
}
ULONG ip, mask;
ip = inet_addr(aIPAddress.c_str());
if (ip != INADDR_NONE)
{
if (aNetworkMask.isEmpty())
mask = 0xFFFFFF;
else
mask = inet_addr(aNetworkMask.c_str());
if (mask != INADDR_NONE)
{
if (m.realIPAddress == ip && m.realNetworkMask == mask)
return S_OK;
int rc = NetIfEnableStaticIpConfig(mVirtualBox, this, m.IPAddress, ip, mask);
if (RT_SUCCESS(rc))
{
m.realIPAddress = ip;
m.realNetworkMask = mask;
if (FAILED(mVirtualBox->SetExtraData(BstrFmt("HostOnly/%ls/IPAddress",
mInterfaceName.raw()).raw(),
Bstr(aIPAddress).raw())))
return E_FAIL;
if (FAILED(mVirtualBox->SetExtraData(BstrFmt("HostOnly/%ls/IPNetMask",
mInterfaceName.raw()).raw(),
Bstr(aNetworkMask).raw())))
return E_FAIL;
return S_OK;
}
else
{
LogRel(("Failed to EnableStaticIpConfig with rc=%Rrc\n", rc));
return rc == VERR_NOT_IMPLEMENTED ? E_NOTIMPL : E_FAIL;
}
}
}
return E_FAIL;
#endif
}
HRESULT VRDEServer::setVRDEProperty(const com::Utf8Str &aKey, const com::Utf8Str &aValue)
{
LogFlowThisFunc(("\n"));
/* the machine can also be in saved state for this property to change */
AutoMutableOrSavedOrRunningStateDependency adep(mParent);
if (FAILED(adep.rc())) return adep.rc();
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
/* Special processing for some "standard" properties. */
if (aKey == "TCP/Ports")
{
/* Verify the string. "0" means the default port. */
Utf8Str strPorts = aValue == "0"?
VRDP_DEFAULT_PORT_STR:
aValue;
int vrc = i_vrdpServerVerifyPortsString(strPorts);
if (RT_FAILURE(vrc))
return E_INVALIDARG;
if (strPorts != mData->mProperties["TCP/Ports"])
{
/* Port value is not verified here because it is up to VRDP transport to
* use it. Specifying a wrong port number will cause a running server to
* stop. There is no fool proof here.
*/
mData.backup();
mData->mProperties["TCP/Ports"] = strPorts;
/* leave the lock before informing callbacks */
alock.release();
AutoWriteLock mlock(mParent COMMA_LOCKVAL_SRC_POS); // mParent is const, needs no locking
mParent->i_setModified(Machine::IsModified_VRDEServer);
mlock.release();
/* Avoid deadlock when i_onVRDEServerChange eventually calls SetExtraData. */
adep.release();
mParent->i_onVRDEServerChange(/* aRestart */ TRUE);
}
}
else
{
/* Generic properties processing.
* Look up the old value first; if nothing's changed then do nothing.
*/
Utf8Str strOldValue;
settings::StringsMap::const_iterator it = mData->mProperties.find(aKey);
if (it != mData->mProperties.end())
strOldValue = it->second;
if (strOldValue != aValue)
{
if (aValue.isEmpty())
mData->mProperties.erase(aKey);
else
mData->mProperties[aKey] = aValue;
/* leave the lock before informing callbacks */
alock.release();
AutoWriteLock mlock(mParent COMMA_LOCKVAL_SRC_POS);
mParent->i_setModified(Machine::IsModified_VRDEServer);
mlock.release();
/* Avoid deadlock when i_onVRDEServerChange eventually calls SetExtraData. */
adep.release();
mParent->i_onVRDEServerChange(/* aRestart */ TRUE);
}
}
return S_OK;
}
/**
* Sets the general Guest Additions information like
* API (interface) version and OS type. Gets called by
* vmmdevUpdateGuestInfo.
*
* @param aInterfaceVersion
* @param aOsType
*/
void Guest::i_setAdditionsInfo(com::Utf8Str aInterfaceVersion, VBOXOSTYPE aOsType)
{
RTTIMESPEC TimeSpecTS;
RTTimeNow(&TimeSpecTS);
AutoCaller autoCaller(this);
AssertComRCReturnVoid(autoCaller.rc());
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
/*
* Note: The Guest Additions API (interface) version is deprecated
* and will not be used anymore! We might need it to at least report
* something as version number if *really* ancient Guest Additions are
* installed (without the guest version + revision properties having set).
*/
mData.mInterfaceVersion = aInterfaceVersion;
/*
* Older Additions rely on the Additions API version whether they
* are assumed to be active or not. Since newer Additions do report
* the Additions version *before* calling this function (by calling
* VMMDevReportGuestInfo2, VMMDevReportGuestStatus, VMMDevReportGuestInfo,
* in that order) we can tell apart old and new Additions here. Old
* Additions never would set VMMDevReportGuestInfo2 (which set mData.mAdditionsVersion)
* so they just rely on the aInterfaceVersion string (which gets set by
* VMMDevReportGuestInfo).
*
* So only mark the Additions as being active (run level = system) when we
* don't have the Additions version set.
*/
if (mData.mAdditionsVersionNew.isEmpty())
{
if (aInterfaceVersion.isEmpty())
mData.mAdditionsRunLevel = AdditionsRunLevelType_None;
else
{
mData.mAdditionsRunLevel = AdditionsRunLevelType_System;
/*
* To keep it compatible with the old Guest Additions behavior we need to set the
* "graphics" (feature) facility to active as soon as we got the Guest Additions
* interface version.
*/
i_facilityUpdate(VBoxGuestFacilityType_Graphics, VBoxGuestFacilityStatus_Active, 0 /*fFlags*/, &TimeSpecTS);
}
}
/*
* Older Additions didn't have this finer grained capability bit,
* so enable it by default. Newer Additions will not enable this here
* and use the setSupportedFeatures function instead.
*/
/** @todo r=bird: I don't get the above comment nor the code below...
* One talks about capability bits, the one always does something to a facility.
* Then there is the comment below it all, which is placed like it addresses the
* mOSTypeId, but talks about something which doesn't remotely like mOSTypeId...
*
* Andy, could you please try clarify and make the comments shorter and more
* coherent! Also, explain why this is important and what depends on it.
*
* PS. There is the VMMDEV_GUEST_SUPPORTS_GRAPHICS capability* report... It
* should come in pretty quickly after this update, normally.
*/
i_facilityUpdate(VBoxGuestFacilityType_Graphics,
i_facilityIsActive(VBoxGuestFacilityType_VBoxGuestDriver)
? VBoxGuestFacilityStatus_Active : VBoxGuestFacilityStatus_Inactive,
0 /*fFlags*/, &TimeSpecTS); /** @todo the timestamp isn't gonna be right here on saved state restore. */
/*
* Note! There is a race going on between setting mAdditionsRunLevel and
* mSupportsGraphics here and disabling/enabling it later according to
* its real status when using new(er) Guest Additions.
*/
mData.mOSType = aOsType;
mData.mOSTypeId = Global::OSTypeId(aOsType);
}