/**
* Initializes the bandwidth group object.
*
* @returns COM result indicator.
* @param aParent Pointer to our parent object.
* @param aName Name of the bandwidth group.
* @param aType Type of the bandwidth group (net, disk).
* @param aMaxBytesPerSec Maximum bandwidth for the bandwidth group.
*/
HRESULT BandwidthGroup::init(BandwidthControl *aParent,
const Utf8Str &aName,
BandwidthGroupType_T aType,
LONG64 aMaxBytesPerSec)
{
LogFlowThisFunc(("aParent=%p aName=\"%s\"\n",
aParent, aName.c_str()));
ComAssertRet(aParent && !aName.isEmpty(), E_INVALIDARG);
if ( (aType <= BandwidthGroupType_Null)
|| (aType > BandwidthGroupType_Network))
return setError(E_INVALIDARG,
tr("Invalid bandwidth group type type"));
/* Enclose the state transition NotReady->InInit->Ready */
AutoInitSpan autoInitSpan(this);
AssertReturn(autoInitSpan.isOk(), E_FAIL);
m = new Data(aParent);
/* m->pPeer is left null */
m->bd.allocate();
m->bd->strName = aName;
m->bd->enmType = aType;
m->bd->cReferences = 0;
m->bd->aMaxBytesPerSec = aMaxBytesPerSec;
/* Confirm a successful initialization */
autoInitSpan.setSucceeded();
return S_OK;
}
HRESULT SystemProperties::setAutostartDatabasePath(const Utf8Str &aPath)
{
HRESULT rc = S_OK;
AutostartDb *autostartDb = this->mParent->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;
}
STDMETHODIMP SharedFolder::COMGETTER(Accessible) (BOOL *aAccessible)
{
CheckComArgOutPointerValid(aAccessible);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
/* mName and mHostPath are constant during life time, no need to lock */
/* check whether the host path exists */
Utf8Str hostPath = m->strHostPath;
char hostPathFull[RTPATH_MAX];
int vrc = RTPathExists(hostPath.c_str()) ? RTPathReal(hostPath.c_str(),
hostPathFull,
sizeof(hostPathFull))
: VERR_PATH_NOT_FOUND;
if (RT_SUCCESS(vrc))
{
*aAccessible = TRUE;
return S_OK;
}
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
m->strLastAccessError = Utf8StrFmt(tr("'%s' is not accessible (%Rrc)"),
m->strHostPath.c_str(),
vrc);
LogWarningThisFunc(("m.lastAccessError=\"%s\"\n", m->strLastAccessError.c_str()));
*aAccessible = FALSE;
return S_OK;
}
/**
* Initializes the USB controller object.
*
* @returns COM result indicator.
* @param aParent Pointer to our parent object.
* @param aName The name of the USB controller.
* @param enmType The USB controller type.
*/
HRESULT USBController::init(Machine *aParent, const Utf8Str &aName, USBControllerType_T enmType)
{
LogFlowThisFunc(("aParent=%p aName=\"%s\"\n", aParent, aName.c_str()));
ComAssertRet(aParent && !aName.isEmpty(), E_INVALIDARG);
if ( (enmType <= USBControllerType_Null)
|| (enmType > USBControllerType_XHCI))
return setError(E_INVALIDARG,
tr("Invalid USB controller type"));
/* Enclose the state transition NotReady->InInit->Ready */
AutoInitSpan autoInitSpan(this);
AssertReturn(autoInitSpan.isOk(), E_FAIL);
m = new Data(aParent);
/* mPeer is left null */
m->bd.allocate();
m->bd->strName = aName;
m->bd->enmType = enmType;
/* Confirm a successful initialization */
autoInitSpan.setSucceeded();
return S_OK;
}
/**
* Generic USB filter field setter.
*
* @param aIdx The field index.
* @param aStr The new value.
* @param aName The translated field name (for error messages).
*
* @return COM status.
*/
HRESULT HostUSBDeviceFilter::usbFilterFieldSetter(USBFILTERIDX aIdx, Bstr aStr)
{
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
Utf8Str strOld;
Utf8Str strNew(aStr);
usbFilterFieldToString(&mData->mUSBFilter, aIdx, strOld);
if (strOld != strNew)
{
//mData.backup();
Utf8Str errStr;
HRESULT rc = USBDeviceFilter::usbFilterFieldFromString(&mData->mUSBFilter, aIdx, aStr, errStr);
if (FAILED(rc))
{
//mData.rollback();
return setError(rc, "%s", errStr.c_str());
}
/* leave the lock before informing callbacks */
alock.release();
return mParent->onUSBDeviceFilterChange(this);
}
return S_OK;
}
/**
* Generates a new unique MAC address based on our vendor ID and
* parts of a GUID.
*
* @note Must be called from under the object's write lock or within the init
* span.
*/
void NetworkAdapter::generateMACAddress()
{
Utf8Str mac;
Host::generateMACAddress(mac);
LogFlowThisFunc(("generated MAC: '%s'\n", mac.c_str()));
mData->mMACAddress = mac;
}
void GluePrintRCMessage(HRESULT rc)
{
Utf8Str str = Utf8StrFmt("Code %Rhra (extended info not available)\n", rc);
// print and log
RTMsgError("%s", str.c_str());
Log(("ERROR: %s", str.c_str()));
}
/**
* VFSExplorer COM initializer.
* @param
* @return
*/
HRESULT VFSExplorer::init(VFSType_T aType, Utf8Str aFilePath, Utf8Str aHostname, Utf8Str aUsername,
Utf8Str aPassword, VirtualBox *aVirtualBox)
{
/* Enclose the state transition NotReady->InInit->Ready */
AutoInitSpan autoInitSpan(this);
AssertReturn(autoInitSpan.isOk(), E_FAIL);
/* Weak reference to a VirtualBox object */
unconst(mVirtualBox) = aVirtualBox;
/* initialize data */
m = new Data;
m->storageType = aType;
m->strPath = aFilePath;
m->strHostname = aHostname;
m->strUsername = aUsername;
m->strPassword = aPassword;
if (m->storageType == VFSType_S3)
{
size_t bpos = aFilePath.find("/", 1);
if (bpos != Utf8Str::npos)
{
m->strBucket = aFilePath.substr(1, bpos - 1); /* The bucket without any slashes */
aFilePath = aFilePath.substr(bpos); /* The rest of the file path */
}
}
/* Confirm a successful initialization */
autoInitSpan.setSucceeded();
return S_OK;
}
STDMETHODIMP
NATEngine::AddRedirect(IN_BSTR aName, NATProtocol_T aProto, IN_BSTR aBindIp, USHORT aHostPort, IN_BSTR aGuestIP, USHORT aGuestPort)
{
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
Utf8Str name = aName;
settings::NATRule r;
const char *proto;
switch (aProto)
{
case NATProtocol_TCP:
proto = "tcp";
break;
case NATProtocol_UDP:
proto = "udp";
break;
default:
return E_INVALIDARG;
}
if (name.isEmpty())
name = Utf8StrFmt("%s_%d_%d", proto, aHostPort, aGuestPort);
NATRuleMap::iterator it;
for (it = mNATRules.begin(); it != mNATRules.end(); ++it)
{
r = it->second;
if (it->first == name)
return setError(E_INVALIDARG,
tr("A NAT rule of this name already exists"));
if ( r.strHostIP == Utf8Str(aBindIp)
&& r.u16HostPort == aHostPort
&& r.proto == aProto)
return setError(E_INVALIDARG,
tr("A NAT rule for this host port and this host IP already exists"));
}
r.strName = name.c_str();
r.proto = aProto;
r.strHostIP = aBindIp;
r.u16HostPort = aHostPort;
r.strGuestIP = aGuestIP;
r.u16GuestPort = aGuestPort;
mNATRules.insert(std::make_pair(name, r));
mParent->setModified(Machine::IsModified_NetworkAdapters);
m_fModified = true;
ULONG ulSlot;
mAdapter->COMGETTER(Slot)(&ulSlot);
alock.release();
mParent->onNATRedirectRuleChange(ulSlot, FALSE, Bstr(name).raw(), aProto, Bstr(r.strHostIP).raw(), r.u16HostPort, Bstr(r.strGuestIP).raw(), r.u16GuestPort);
return S_OK;
}
int GuestDirectory::init(GuestSession *aSession,
const Utf8Str &strPath, const Utf8Str &strFilter /*= ""*/, uint32_t uFlags /*= 0*/)
{
LogFlowThisFunc(("strPath=%s, strFilter=%s, uFlags=%x\n",
strPath.c_str(), strFilter.c_str(), uFlags));
/* Enclose the state transition NotReady->InInit->Ready. */
AutoInitSpan autoInitSpan(this);
AssertReturn(autoInitSpan.isOk(), E_FAIL);
mData.mSession = aSession;
mData.mName = strPath;
mData.mFilter = strFilter;
mData.mFlags = uFlags;
/* Start the directory process on the guest. */
GuestProcessStartupInfo procInfo;
procInfo.mName = Utf8StrFmt(tr("Reading directory \"%s\"", strPath.c_str()));
procInfo.mCommand = Utf8Str(VBOXSERVICE_TOOL_LS);
procInfo.mTimeoutMS = 0; /* No timeout. */
procInfo.mFlags = ProcessCreateFlag_Hidden | ProcessCreateFlag_WaitForStdOut;
procInfo.mArguments.push_back(Utf8Str("--machinereadable"));
/* We want the long output format which contains all the object details. */
procInfo.mArguments.push_back(Utf8Str("-l"));
#if 0 /* Flags are not supported yet. */
if (uFlags & DirectoryOpenFlag_NoSymlinks)
procInfo.mArguments.push_back(Utf8Str("--nosymlinks")); /** @todo What does GNU here? */
#endif
/** @todo Recursion support? */
procInfo.mArguments.push_back(strPath); /* The directory we want to open. */
/*
* Start the process asynchronously and keep it around so that we can use
* it later in subsequent read() calls.
*/
ComObjPtr<GuestProcess> pProcess;
int rc = mData.mSession->processCreateExInteral(procInfo, pProcess);
if (RT_SUCCESS(rc))
rc = pProcess->startProcessAsync();
LogFlowThisFunc(("rc=%Rrc\n", rc));
if (RT_SUCCESS(rc))
{
mData.mProcess = pProcess;
/* Confirm a successful initialization when it's the case. */
autoInitSpan.setSucceeded();
return rc;
}
autoInitSpan.setFailed();
return rc;
}
/** VM IPC mutex holder thread */
DECLCALLBACK(int) IPCMutexHolderThread (RTTHREAD Thread, void *pvUser)
{
LogFlowFuncEnter();
Assert (pvUser);
void **data = (void **) pvUser;
Utf8Str ipcId = (BSTR)data[0];
RTSEMEVENT finishSem = (RTSEMEVENT)data[1];
LogFlowFunc (("ipcId='%s', finishSem=%p\n", ipcId.raw(), finishSem));
HMTX ipcMutex = NULLHANDLE;
APIRET arc = ::DosOpenMutexSem ((PSZ) ipcId.raw(), &ipcMutex);
AssertMsg (arc == NO_ERROR, ("cannot open IPC mutex, arc=%ld\n", arc));
if (arc == NO_ERROR)
{
/* grab the mutex */
LogFlowFunc (("grabbing IPC mutex...\n"));
arc = ::DosRequestMutexSem (ipcMutex, SEM_IMMEDIATE_RETURN);
AssertMsg (arc == NO_ERROR, ("cannot grab IPC mutex, arc=%ld\n", arc));
if (arc == NO_ERROR)
{
/* store the answer */
data[2] = (void*)true;
/* signal we're done */
int vrc = RTThreadUserSignal (Thread);
AssertRC(vrc);
/* wait until we're signaled to release the IPC mutex */
LogFlowFunc (("waiting for termination signal..\n"));
vrc = RTSemEventWait (finishSem, RT_INDEFINITE_WAIT);
Assert (arc == ERROR_INTERRUPT || ERROR_TIMEOUT);
/* release the IPC mutex */
LogFlowFunc (("releasing IPC mutex...\n"));
arc = ::DosReleaseMutexSem (ipcMutex);
AssertMsg (arc == NO_ERROR, ("cannot release mutex, arc=%ld\n", arc));
}
::DosCloseMutexSem (ipcMutex);
}
/* store the answer */
data[1] = (void*)false;
/* signal we're done */
int vrc = RTThreadUserSignal (Thread);
AssertRC(vrc);
LogFlowFuncLeave();
return 0;
}
int readSavedGuestSize(const Utf8Str &strStateFilePath, uint32_t u32ScreenId, uint32_t *pu32Width, uint32_t *pu32Height)
{
LogFlowFunc(("u32ScreenId = %d [%s]\n", u32ScreenId, strStateFilePath.c_str()));
/* @todo cache read data */
if (strStateFilePath.isEmpty())
{
/* No saved state data. */
return VERR_NOT_SUPPORTED;
}
uint32_t u32Width = 0;
uint32_t u32Height = 0;
PSSMHANDLE pSSM;
int vrc = SSMR3Open(strStateFilePath.c_str(), 0 /*fFlags*/, &pSSM);
if (RT_SUCCESS(vrc))
{
uint32_t uVersion;
vrc = SSMR3Seek(pSSM, "DisplayData", 0 /*iInstance*/, &uVersion);
if (RT_SUCCESS(vrc))
{
/* Only the second version is supported. */
if ( uVersion == sSSMDisplayVer2
|| uVersion == sSSMDisplayVer3)
{
uint32_t cMonitors;
SSMR3GetU32(pSSM, &cMonitors);
if (u32ScreenId > cMonitors)
vrc = -2;
else
{
/* Skip all previous monitors and the first 3 entries. */
SSMR3Skip(pSSM, u32ScreenId * 5 * sizeof(uint32_t) + 3 * sizeof(uint32_t));
SSMR3GetU32(pSSM, &u32Width);
SSMR3GetU32(pSSM, &u32Height);
}
}
}
SSMR3Close(pSSM);
}
if (RT_SUCCESS(vrc))
{
*pu32Width = u32Width;
*pu32Height = u32Height;
}
LogFlowFunc(("vrc %Rrc\n", vrc));
return vrc;
}
void GluePrintErrorContext(const char *pcszContext, const char *pcszSourceFile, uint32_t ulLine)
{
// pcszSourceFile comes from __FILE__ macro, which always contains the full path,
// which we don't want to see printed:
Utf8Str strFilename(RTPathFilename(pcszSourceFile));
Utf8Str str = Utf8StrFmt("Context: \"%s\" at line %d of file %s\n",
pcszContext,
ulLine,
strFilename.c_str());
// print and log
RTMsgError("%s", str.c_str());
Log(("%s", str.c_str()));
}
HRESULT NetworkAdapter::updateMacAddress(Utf8Str aMACAddress)
{
HRESULT rc = S_OK;
/*
* Are we supposed to generate a MAC?
*/
if (aMACAddress.isEmpty())
generateMACAddress();
else
{
if (mData->mMACAddress != aMACAddress)
{
/*
* Verify given MAC address
*/
char *macAddressStr = aMACAddress.mutableRaw();
int i = 0;
while ((i < 13) && macAddressStr && *macAddressStr && (rc == S_OK))
{
char c = *macAddressStr;
/* canonicalize hex digits to capital letters */
if (c >= 'a' && c <= 'f')
{
/** @todo the runtime lacks an ascii lower/upper conv */
c &= 0xdf;
*macAddressStr = c;
}
/* we only accept capital letters */
if (((c < '0') || (c > '9')) &&
((c < 'A') || (c > 'F')))
rc = setError(E_INVALIDARG, tr("Invalid MAC address format"));
/* the second digit must have even value for unicast addresses */
if ((i == 1) && (!!(c & 1) == (c >= '0' && c <= '9')))
rc = setError(E_INVALIDARG, tr("Invalid MAC address format"));
macAddressStr++;
i++;
}
/* we must have parsed exactly 12 characters */
if (i != 12)
rc = setError(E_INVALIDARG, tr("Invalid MAC address format"));
if (SUCCEEDED(rc))
mData->mMACAddress = aMACAddress;
}
}
return rc;
}
/**
* Generic USB filter field getter; converts the field value to UTF-16.
*
* @param aIdx The field index.
* @param aStr Where to store the value.
*
* @return COM status.
*/
HRESULT USBDeviceFilter::usbFilterFieldGetter(USBFILTERIDX aIdx, BSTR *aStr)
{
CheckComArgOutPointerValid(aStr);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
Utf8Str str;
usbFilterFieldToString(&mData->mUSBFilter, aIdx, str);
str.cloneTo(aStr);
return S_OK;
}
void GluePrintErrorInfo(const com::ErrorInfo &info)
{
bool haveResultCode = false;
#if defined (RT_OS_WIN)
haveResultCode = info.isFullAvailable();
bool haveComponent = true;
bool haveInterfaceID = true;
#else /* defined (RT_OS_WIN) */
haveResultCode = true;
bool haveComponent = info.isFullAvailable();
bool haveInterfaceID = info.isFullAvailable();
#endif
Utf8Str str;
RTCList<Utf8Str> comp;
Bstr bstrDetailsText = info.getText();
if (!bstrDetailsText.isEmpty())
str = Utf8StrFmt("%ls\n",
bstrDetailsText.raw());
if (haveResultCode)
comp.append(Utf8StrFmt("code %Rhrc (0x%RX32)",
info.getResultCode(),
info.getResultCode()));
if (haveComponent)
comp.append(Utf8StrFmt("component %ls",
info.getComponent().raw()));
if (haveInterfaceID)
comp.append(Utf8StrFmt("interface %ls",
info.getInterfaceName().raw()));
if (!info.getCalleeName().isEmpty())
comp.append(Utf8StrFmt("callee %ls",
info.getCalleeName().raw()));
if (comp.size() > 0)
{
str += "Details: ";
for (size_t i = 0; i < comp.size() - 1; ++i)
str += comp.at(i) + ", ";
str += comp.last();
str += "\n";
}
// print and log
RTMsgError("%s", str.c_str());
Log(("ERROR: %s", str.c_str()));
}
int GuestEnvironment::Set(const Utf8Str &strPair)
{
RTCList<RTCString> listPair = strPair.split("=", RTCString::KeepEmptyParts);
/* Skip completely empty pairs. Note that we still need pairs with a valid
* (set) key and an empty value. */
if (listPair.size() <= 1)
return VINF_SUCCESS;
int rc = VINF_SUCCESS;
size_t p = 0;
while (p < listPair.size() && RT_SUCCESS(rc))
{
Utf8Str strKey = listPair.at(p++);
if ( strKey.isEmpty()
|| strKey.equals("=")) /* Skip pairs with empty keys (e.g. "=FOO"). */
{
break;
}
Utf8Str strValue;
if (p < listPair.size()) /* Does the list also contain a value? */
strValue = listPair.at(p++);
#ifdef DEBUG
LogFlowFunc(("strKey=%s, strValue=%s\n",
strKey.c_str(), strValue.c_str()));
#endif
rc = Set(strKey, strValue);
}
return rc;
}
HRESULT SystemProperties::setDefaultHardDiskFormat(const Utf8Str &aFormat)
{
if (!aFormat.isEmpty())
m->strDefaultHardDiskFormat = aFormat;
else
m->strDefaultHardDiskFormat = "VDI";
return S_OK;
}
size_t Utf8Str::parseKeyValue(Utf8Str &key, Utf8Str &value, size_t pos, const Utf8Str &pairSeparator, const Utf8Str &keyValueSeparator) const
{
size_t start = pos;
while(start == (pos = find(pairSeparator.c_str(), pos)))
start = ++pos;
size_t kvSepPos = find(keyValueSeparator.c_str(), start);
if (kvSepPos < pos)
{
key = substr(start, kvSepPos - start);
value = substr(kvSepPos + 1, pos - kvSepPos - 1);
}
else
{
key = value = "";
}
return pos;
}
static Bstr toBaseName(Utf8Str& aFullName)
{
char *pszRaw = aFullName.mutableRaw();
/*
* Currently there are two metrics which base name is the same as the
* sub-metric name: CPU/MHz and Net/<iface>/LinkSpeed.
*/
if (pszRaw && strcmp(pszRaw, "CPU/MHz") && !RTStrSimplePatternMatch("Net/*/LinkSpeed", pszRaw))
{
char *pszSlash = strrchr(pszRaw, '/');
if (pszSlash)
{
*pszSlash = 0;
aFullName.jolt();
}
}
return Bstr(aFullName);
}
HRESULT SystemProperties::setWebServiceAuthLibrary(const Utf8Str &aPath)
{
if (!aPath.isEmpty())
m->strWebServiceAuthLibrary = aPath;
else
m->strWebServiceAuthLibrary = "VBoxAuth";
return S_OK;
}
STDMETHODIMP NetworkAdapter::COMSETTER(BandwidthGroup)(IBandwidthGroup *aBwGroup)
{
LogFlowThisFuncEnter();
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
/* the machine needs to be mutable */
AutoMutableStateDependency adep(mParent);
if (FAILED(adep.rc())) return adep.rc();
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
Utf8Str strBwGroup;
if (aBwGroup)
strBwGroup = static_cast<BandwidthGroup*>(aBwGroup)->getName();
if (mData->mBandwidthGroup != strBwGroup)
{
ComObjPtr<BandwidthGroup> pBwGroup;
if (!strBwGroup.isEmpty())
{
HRESULT hrc = mParent->getBandwidthGroup(strBwGroup, pBwGroup, false /* fSetError */);
NOREF(hrc);
Assert(SUCCEEDED(hrc)); /* This is not allowed to fail because the existence of the group was checked when it was attached. */
}
updateBandwidthGroup(pBwGroup);
m_fModified = true;
// leave the lock before informing callbacks
alock.release();
AutoWriteLock mlock(mParent COMMA_LOCKVAL_SRC_POS);
mParent->setModified(Machine::IsModified_NetworkAdapters);
mlock.release();
/* TODO: changeAdapter=???. */
mParent->onNetworkAdapterChange(this, FALSE);
}
LogFlowThisFuncLeave();
return S_OK;
}
/**
* Generic USB filter field setter, expects UTF-8 input.
*
* @param aIdx The field index.
* @param aStr The new value.
*
* @return COM status.
*/
HRESULT USBDeviceFilter::usbFilterFieldSetter(USBFILTERIDX aIdx,
const Utf8Str &strNew)
{
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);
Utf8Str strOld;
usbFilterFieldToString(&mData->mUSBFilter, aIdx, strOld);
if (strOld != strNew)
{
m_fModified = true;
ComObjPtr<Machine> pMachine = mParent->getMachine();
mData.backup();
Utf8Str errStr;
HRESULT rc = usbFilterFieldFromString(&mData->mUSBFilter, aIdx, strNew, errStr);
if (FAILED(rc))
{
mData.rollback();
return setError(rc, "%s", errStr.c_str());
}
// 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;
}
int GuestEnvironment::Set(const Utf8Str &strKey, const Utf8Str &strValue)
{
/** @todo Do some validation using regex. */
if (strKey.isEmpty())
return VERR_INVALID_PARAMETER;
int rc = VINF_SUCCESS;
const char *pszString = strKey.c_str();
while (*pszString != '\0' && RT_SUCCESS(rc))
{
if ( !RT_C_IS_ALNUM(*pszString)
&& !RT_C_IS_GRAPH(*pszString))
rc = VERR_INVALID_PARAMETER;
*pszString++;
}
if (RT_SUCCESS(rc))
mEnvironment[strKey] = strValue;
return rc;
}
STDMETHODIMP VRDEServer::COMGETTER(VRDEExtPack) (BSTR *aExtPack)
{
CheckComArgOutPointerValid(aExtPack);
AutoCaller autoCaller(this);
HRESULT hrc = autoCaller.rc();
if (SUCCEEDED(hrc))
{
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
Utf8Str strExtPack = mData->mVrdeExtPack;
alock.release();
if (strExtPack.isNotEmpty())
{
if (strExtPack.equals(VBOXVRDP_KLUDGE_EXTPACK_NAME))
hrc = S_OK;
else
{
#ifdef VBOX_WITH_EXTPACK
ExtPackManager *pExtPackMgr = mParent->getVirtualBox()->getExtPackManager();
hrc = pExtPackMgr->checkVrdeExtPack(&strExtPack);
#else
hrc = setError(E_FAIL, tr("Extension pack '%s' does not exist"), strExtPack.c_str());
#endif
}
if (SUCCEEDED(hrc))
strExtPack.cloneTo(aExtPack);
}
else
{
/* Get the global setting. */
ComPtr<ISystemProperties> systemProperties;
hrc = mParent->getVirtualBox()->COMGETTER(SystemProperties)(systemProperties.asOutParam());
if (SUCCEEDED(hrc))
hrc = systemProperties->COMGETTER(DefaultVRDEExtPack)(aExtPack);
}
}
return hrc;
}
HRESULT VRDEServer::getVRDEExtPack(com::Utf8Str &aExtPack)
{
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
Utf8Str strExtPack = mData->mVrdeExtPack;
alock.release();
HRESULT hrc = S_OK;
if (strExtPack.isNotEmpty())
{
if (strExtPack.equals(VBOXVRDP_KLUDGE_EXTPACK_NAME))
hrc = S_OK;
else
{
#ifdef VBOX_WITH_EXTPACK
ExtPackManager *pExtPackMgr = mParent->i_getVirtualBox()->i_getExtPackManager();
hrc = pExtPackMgr->i_checkVrdeExtPack(&strExtPack);
#else
hrc = setError(E_FAIL, tr("Extension pack '%s' does not exist"), strExtPack.c_str());
#endif
}
if (SUCCEEDED(hrc))
aExtPack = strExtPack;
}
else
{
/* Get the global setting. */
ComPtr<ISystemProperties> systemProperties;
hrc = mParent->i_getVirtualBox()->COMGETTER(SystemProperties)(systemProperties.asOutParam());
if (SUCCEEDED(hrc))
{
BSTR bstr;
hrc = systemProperties->COMGETTER(DefaultVRDEExtPack)(&bstr);
if (SUCCEEDED(hrc))
aExtPack = Utf8Str(bstr);
}
}
return hrc;
}
/**
* Initializes the host object.
*
* @returns COM result indicator
* @param aInterfaceName name of the network interface
* @param aShortName short name of the network interface
* @param aGuid GUID of the host network interface
* @param ifType interface type
*/
HRESULT HostNetworkInterface::init(Utf8Str aInterfaceName, Utf8Str aShortName, Guid aGuid, HostNetworkInterfaceType_T ifType)
{
LogFlowThisFunc(("aInterfaceName={%s}, aGuid={%s}\n",
aInterfaceName.c_str(), aGuid.toString().c_str()));
ComAssertRet(!aInterfaceName.isEmpty(), E_INVALIDARG);
ComAssertRet(aGuid.isValid(), E_INVALIDARG);
/* Enclose the state transition NotReady->InInit->Ready */
AutoInitSpan autoInitSpan(this);
AssertReturn(autoInitSpan.isOk(), E_FAIL);
unconst(mInterfaceName) = aInterfaceName;
unconst(mNetworkName) = i_composeNetworkName(aShortName);
unconst(mShortName) = aShortName;
unconst(mGuid) = aGuid;
mIfType = ifType;
/* Confirm a successful initialization */
autoInitSpan.setSucceeded();
return S_OK;
}
int SessionTaskCopyFrom::RunAsync(const Utf8Str &strDesc, ComObjPtr<Progress> &pProgress)
{
LogFlowThisFunc(("strDesc=%s, strSource=%s, strDest=%s, uFlags=%x\n",
strDesc.c_str(), mSource.c_str(), mDest.c_str(), mFlags));
mDesc = strDesc;
mProgress = pProgress;
int rc = RTThreadCreate(NULL, SessionTaskCopyFrom::taskThread, this,
0, RTTHREADTYPE_MAIN_HEAVY_WORKER, 0,
"gctlCpyFrom");
LogFlowFuncLeaveRC(rc);
return rc;
}
/**
* Validates COMSETTER(Path) arguments.
*/
HRESULT SerialPort::i_checkSetPath(const Utf8Str &str)
{
AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
if ( ( m->bd->portMode == PortMode_HostDevice
|| m->bd->portMode == PortMode_HostPipe
|| m->bd->portMode == PortMode_RawFile
) && str.isEmpty()
)
return setError(E_INVALIDARG,
tr("Path of the serial port %d may not be empty or null in "
"host pipe or host device mode"),
m->bd->ulSlot);
return S_OK;
}
/**
* Converts a USBFilter field into a string.
*
* (This function is also used by HostUSBDeviceFilter.)
*
* @param aFilter The filter.
* @param aIdx The field index.
* @param aStr The output string.
*/
static void i_usbFilterFieldToString(PCUSBFILTER aFilter, USBFILTERIDX aIdx, Utf8Str &rstrOut)
{
const USBFILTERMATCH matchingMethod = USBFilterGetMatchingMethod(aFilter, aIdx);
Assert(matchingMethod != USBFILTERMATCH_INVALID);
if (USBFilterIsMethodNumeric(matchingMethod))
{
int value = USBFilterGetNum(aFilter, aIdx);
Assert(value >= 0 && value <= 0xffff);
rstrOut = Utf8StrFmt("%04RX16", (uint16_t)value);
}
else if (USBFilterIsMethodString(matchingMethod))
rstrOut = USBFilterGetString(aFilter, aIdx);
else
rstrOut.setNull();
}