STDMETHODIMP NetworkAdapter::GetProperties(IN_BSTR aNames,
ComSafeArrayOut(BSTR, aReturnNames),
ComSafeArrayOut(BSTR, aReturnValues))
{
CheckComArgOutSafeArrayPointerValid(aReturnNames);
CheckComArgOutSafeArrayPointerValid(aReturnValues);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
/// @todo make use of aNames according to the documentation
NOREF(aNames);
com::SafeArray<BSTR> names(mData->mGenericProperties.size());
com::SafeArray<BSTR> values(mData->mGenericProperties.size());
size_t i = 0;
for (settings::StringsMap::const_iterator it = mData->mGenericProperties.begin();
it != mData->mGenericProperties.end();
++it)
{
it->first.cloneTo(&names[i]);
it->second.cloneTo(&values[i]);
++i;
}
names.detachTo(ComSafeArrayOutArg(aReturnNames));
values.detachTo(ComSafeArrayOutArg(aReturnValues));
return S_OK;
}
STDMETHODIMP SystemProperties::GetDeviceTypesForStorageBus(StorageBus_T aBus,
ComSafeArrayOut(DeviceType_T, aDeviceTypes))
{
CheckComArgOutSafeArrayPointerValid(aDeviceTypes);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
/* no need to lock, this is const */
switch (aBus)
{
case StorageBus_IDE:
case StorageBus_SATA:
case StorageBus_SCSI:
case StorageBus_SAS:
{
com::SafeArray<DeviceType_T> saDeviceTypes(2);
saDeviceTypes[0] = DeviceType_DVD;
saDeviceTypes[1] = DeviceType_HardDisk;
saDeviceTypes.detachTo(ComSafeArrayOutArg(aDeviceTypes));
break;
}
case StorageBus_Floppy:
{
com::SafeArray<DeviceType_T> saDeviceTypes(1);
saDeviceTypes[0] = DeviceType_Floppy;
saDeviceTypes.detachTo(ComSafeArrayOutArg(aDeviceTypes));
break;
}
default:
AssertMsgFailed(("Invalid bus type %d\n", aBus));
}
return S_OK;
}
STDMETHODIMP
NATEngine::COMGETTER(Redirects)(ComSafeArrayOut(BSTR , aNatRules))
{
CheckComArgOutSafeArrayPointerValid(aNatRules);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
SafeArray<BSTR> sf(mNATRules.size());
size_t i = 0;
NATRuleMap::const_iterator it;
for (it = mNATRules.begin();
it != mNATRules.end(); ++it, ++i)
{
settings::NATRule r = it->second;
BstrFmt bstr("%s,%d,%s,%d,%s,%d",
r.strName.c_str(),
r.proto,
r.strHostIP.c_str(),
r.u16HostPort,
r.strGuestIP.c_str(),
r.u16GuestPort);
bstr.detachTo(&sf[i]);
}
sf.detachTo(ComSafeArrayOutArg(aNatRules));
return S_OK;
}
/**
* Gets the collection of USB devices, slave of Host::USBDevices.
*
* This is an interface for the HostImpl::USBDevices property getter.
*
*
* @param aUSBDevices Where to store the pointer to the collection.
*
* @returns COM status code.
*
* @remarks The caller must own the write lock of the host object.
*/
HRESULT USBProxyService::getDeviceCollection(ComSafeArrayOut(IHostUSBDevice *, aUSBDevices))
{
AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
CheckComArgOutSafeArrayPointerValid(aUSBDevices);
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
SafeIfaceArray<IHostUSBDevice> Collection(mDevices);
Collection.detachTo(ComSafeArrayOutArg(aUSBDevices));
return S_OK;
}
STDMETHODIMP SystemProperties::COMGETTER(MediumFormats)(ComSafeArrayOut(IMediumFormat *, aMediumFormats))
{
CheckComArgOutSafeArrayPointerValid(aMediumFormats);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
SafeIfaceArray<IMediumFormat> mediumFormats(m_llMediumFormats);
mediumFormats.detachTo(ComSafeArrayOutArg(aMediumFormats));
return S_OK;
}
STDMETHODIMP Guest::COMGETTER(Sessions)(ComSafeArrayOut(IGuestSession *, aSessions))
{
CheckComArgOutSafeArrayPointerValid(aSessions);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
SafeIfaceArray<IGuestSession> collection(mData.mGuestSessions);
collection.detachTo(ComSafeArrayOutArg(aSessions));
return S_OK;
}
STDMETHODIMP Guest::COMGETTER(Facilities)(ComSafeArrayOut(IAdditionsFacility *, aFacilities))
{
CheckComArgOutSafeArrayPointerValid(aFacilities);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
SafeIfaceArray<IAdditionsFacility> fac(mData.mFacilityMap);
fac.detachTo(ComSafeArrayOutArg(aFacilities));
return S_OK;
}
STDMETHODIMP GuestFile::ReadAt(LONG64 aOffset, ULONG aToRead, ULONG aTimeoutMS, ComSafeArrayOut(BYTE, aData))
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
if (aToRead == 0)
return setError(E_INVALIDARG, tr("The size to read is zero"));
CheckComArgOutSafeArrayPointerValid(aData);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
com::SafeArray<BYTE> data((size_t)aToRead);
Assert(data.size() >= aToRead);
HRESULT hr = S_OK;
size_t cbRead;
int vrc = readDataAt(aOffset, aToRead, aTimeoutMS,
data.raw(), aToRead, &cbRead);
if (RT_SUCCESS(vrc))
{
if (data.size() != cbRead)
data.resize(cbRead);
data.detachTo(ComSafeArrayOutArg(aData));
}
else
{
switch (vrc)
{
default:
hr = setError(VBOX_E_IPRT_ERROR,
tr("Reading from file \"%s\" (at offset %RU64) failed: %Rrc"),
mData.mOpenInfo.mFileName.c_str(), aOffset, vrc);
break;
}
}
LogFlowFuncLeaveRC(vrc);
return hr;
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP USBController::COMGETTER(DeviceFilters) (ComSafeArrayOut(IUSBDeviceFilter *, aDevicesFilters))
{
#ifdef VBOX_WITH_USB
CheckComArgOutSafeArrayPointerValid(aDevicesFilters);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
SafeIfaceArray<IUSBDeviceFilter> collection (*m->llDeviceFilters.data());
collection.detachTo(ComSafeArrayOutArg(aDevicesFilters));
return S_OK;
#else
NOREF(aDevicesFilters);
# ifndef RT_OS_WINDOWS
NOREF(aDevicesFiltersSize);
# endif
ReturnComNotImplemented();
#endif
}