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 }