/**
* Returns true if the given USB device matches to at least one of
* this controller's USB device filters.
*
* A HostUSBDevice specific version.
*
* @note Locks this object for reading.
*/
bool USBDeviceFilters::i_hasMatchingFilter(const ComObjPtr<HostUSBDevice> &aDevice, ULONG *aMaskedIfs)
{
AutoCaller autoCaller(this);
AssertComRCReturn(autoCaller.rc(), false);
/* It is not possible to work with USB device if there is no USB controller present. */
if (!m->pParent->i_isUSBControllerPresent())
return false;
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
/* apply self filters */
for (DeviceFilterList::const_iterator it = m->llDeviceFilters->begin();
it != m->llDeviceFilters->end();
++it)
{
AutoWriteLock filterLock(*it COMMA_LOCKVAL_SRC_POS);
if (aDevice->i_isMatch((*it)->i_getData()))
{
*aMaskedIfs = (*it)->i_getData().mMaskedIfs;
return true;
}
}
return false;
}
/**
* Returns true if the given USB device matches to at least one of
* this controller's USB device filters.
*
* A HostUSBDevice specific version.
*
* @note Locks this object for reading.
*/
bool USBController::hasMatchingFilter (const ComObjPtr<HostUSBDevice> &aDevice, ULONG *aMaskedIfs)
{
AutoCaller autoCaller(this);
AssertComRCReturn (autoCaller.rc(), false);
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
/* Disabled USB controllers cannot actually work with USB devices */
if (!m->bd->fEnabled)
return false;
/* apply self filters */
for (DeviceFilterList::const_iterator it = m->llDeviceFilters->begin();
it != m->llDeviceFilters->end();
++ it)
{
AutoWriteLock filterLock(*it COMMA_LOCKVAL_SRC_POS);
if (aDevice->isMatch((*it)->getData()))
{
*aMaskedIfs = (*it)->getData().mMaskedIfs;
return true;
}
}
return false;
}
STDMETHODIMP CCamStudioFilter::Pause() {
CAutoLock filterLock(m_pLock);
if(m_State == State_Running)
m_pPin->Pause();
//Default implementation
HRESULT hr = CSource::Pause();
return hr;
}
STDMETHODIMP CMpTsFilter::Run(REFERENCE_TIME tStart)
{
LogDebug("CMpTsFilter::Run()");
CAutoLock filterLock(m_pLock);
LogDebug("Run filter...");
int hr = CBaseFilter::Run(tStart);
LogDebug("HRESULT = 0x%x", hr);
return hr;
}
STDMETHODIMP CMpTsFilter::Pause()
{
LogDebug("CMpTsFilter::Pause()");
CAutoLock filterLock(m_pLock);
LogDebug("Pause filter...");
int hr = CBaseFilter::Pause();
LogDebug("HRESULT = 0x%x", hr);
return hr;
}
STDMETHODIMP CCamStudioFilter::Stop() {
CAutoLock filterLock(m_pLock);
//Default implementation
HRESULT hr = CSource::Stop();
//Reset pin resources
m_pPin->m_iFrameNumber = 0;
return hr;
}
STDMETHODIMP CMpTsFilter::Stop()
{
LogDebug("CMpTsFilter::Stop()");
CAutoLock filterLock(m_pLock);
LogDebug("Stop streaming...");
CAutoLock receiveLock(m_pReceiveLock);
LogDebug("Stop filter...");
int hr = CBaseFilter::Stop();
LogDebug("HRESULT = 0x%x", hr);
return hr;
}
STDMETHODIMP CPushSourceDesktop::Stop(){
CAutoLock filterLock(m_pLock);
//Default implementation
HRESULT hr = CBaseFilter::Stop();
//Reset pin resources
m_pPin->m_iFrameNumber = 0;
return hr;
}
/**
* Saves settings to the given machine node.
*
* @param aMachineNode <Machine> node.
*
* @note Locks this object for reading.
*/
HRESULT USBController::saveSettings(settings::USBController &data)
{
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
data.fEnabled = !!m->bd->fEnabled;
data.fEnabledEHCI = !!m->bd->fEnabledEHCI;
#ifdef VBOX_WITH_USB
data.llDeviceFilters.clear();
for (DeviceFilterList::const_iterator it = m->llDeviceFilters->begin();
it != m->llDeviceFilters->end();
++it)
{
AutoWriteLock filterLock(*it COMMA_LOCKVAL_SRC_POS);
const USBDeviceFilter::Data &filterData = (*it)->getData();
Bstr str;
settings::USBDeviceFilter f;
f.strName = filterData.mName;
f.fActive = !!filterData.mActive;
(*it)->COMGETTER(VendorId)(str.asOutParam());
f.strVendorId = str;
(*it)->COMGETTER(ProductId)(str.asOutParam());
f.strProductId = str;
(*it)->COMGETTER (Revision) (str.asOutParam());
f.strRevision = str;
(*it)->COMGETTER (Manufacturer) (str.asOutParam());
f.strManufacturer = str;
(*it)->COMGETTER (Product) (str.asOutParam());
f.strProduct = str;
(*it)->COMGETTER (SerialNumber) (str.asOutParam());
f.strSerialNumber = str;
(*it)->COMGETTER (Port) (str.asOutParam());
f.strPort = str;
f.strRemote = filterData.mRemote.string();
f.ulMaskedInterfaces = filterData.mMaskedIfs;
data.llDeviceFilters.push_back(f);
}
#endif /* VBOX_WITH_USB */
return S_OK;
}
/**
* Runs all the filters on the specified device.
*
* All filters mean global and active VM, with the exception of those
* belonging to \a aMachine. If a global ignore filter matched or if
* none of the filters matched, the device will be released back to
* the host.
*
* The device calling us here will be in the HeldByProxy, Unused, or
* Capturable state. The caller is aware that locks held might have
* to be abandond because of IPC and that the device might be in
* almost any state upon return.
*
*
* @returns COM status code (only parameter & state checks will fail).
* @param aDevice The USB device to apply filters to.
* @param aIgnoreMachine The machine to ignore filters from (we've just
* detached the device from this machine).
*
* @note The caller is expected to own no locks.
*/
HRESULT USBProxyService::runAllFiltersOnDevice(ComObjPtr<HostUSBDevice> &aDevice,
SessionMachinesList &llOpenedMachines,
SessionMachine *aIgnoreMachine)
{
LogFlowThisFunc(("{%s} ignoring=%p\n", aDevice->getName().c_str(), aIgnoreMachine));
/*
* Verify preconditions.
*/
AssertReturn(!isWriteLockOnCurrentThread(), E_FAIL);
AssertReturn(!aDevice->isWriteLockOnCurrentThread(), E_FAIL);
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
AutoWriteLock devLock(aDevice COMMA_LOCKVAL_SRC_POS);
AssertMsgReturn(aDevice->isCapturableOrHeld(), ("{%s} %s\n", aDevice->getName().c_str(), aDevice->getStateName()), E_FAIL);
/*
* Get the lists we'll iterate.
*/
Host::USBDeviceFilterList globalFilters;
mHost->getUSBFilters(&globalFilters);
/*
* Run global filters filters first.
*/
bool fHoldIt = false;
for (Host::USBDeviceFilterList::const_iterator it = globalFilters.begin();
it != globalFilters.end();
++it)
{
AutoWriteLock filterLock(*it COMMA_LOCKVAL_SRC_POS);
const HostUSBDeviceFilter::Data &data = (*it)->getData();
if (aDevice->isMatch(data))
{
USBDeviceFilterAction_T action = USBDeviceFilterAction_Null;
(*it)->COMGETTER(Action)(&action);
if (action == USBDeviceFilterAction_Ignore)
{
/*
* Release the device to the host and we're done.
*/
filterLock.release();
devLock.release();
alock.release();
aDevice->requestReleaseToHost();
return S_OK;
}
if (action == USBDeviceFilterAction_Hold)
{
/*
* A device held by the proxy needs to be subjected
* to the machine filters.
*/
fHoldIt = true;
break;
}
AssertMsgFailed(("action=%d\n", action));
}
}
globalFilters.clear();
/*
* Run the per-machine filters.
*/
for (SessionMachinesList::const_iterator it = llOpenedMachines.begin();
it != llOpenedMachines.end();
++it)
{
ComObjPtr<SessionMachine> pMachine = *it;
/* Skip the machine the device was just detached from. */
if ( aIgnoreMachine
&& pMachine == aIgnoreMachine)
continue;
/* runMachineFilters takes care of checking the machine state. */
devLock.release();
alock.release();
if (runMachineFilters(pMachine, aDevice))
{
LogFlowThisFunc(("{%s} attached to %p\n", aDevice->getName().c_str(), (void *)pMachine));
return S_OK;
}
alock.acquire();
devLock.acquire();
}
/*
* No matching machine, so request hold or release depending
* on global filter match.
*/
devLock.release();
alock.release();
if (fHoldIt)
aDevice->requestHold();
else
aDevice->requestReleaseToHost();
return S_OK;
}
/**
* Returns true if the given USB device matches to at least one of
* this controller's USB device filters.
*
* A generic version that accepts any IUSBDevice on input.
*
* @note
* This method MUST correlate with HostUSBDevice::isMatch()
* in the sense of the device matching logic.
*
* @note Locks this object for reading.
*/
bool USBController::hasMatchingFilter (IUSBDevice *aUSBDevice, ULONG *aMaskedIfs)
{
LogFlowThisFuncEnter();
AutoCaller autoCaller(this);
AssertComRCReturn (autoCaller.rc(), false);
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
/* Disabled USB controllers cannot actually work with USB devices */
if (!m->bd->fEnabled)
return false;
HRESULT rc = S_OK;
/* query fields */
USBFILTER dev;
USBFilterInit (&dev, USBFILTERTYPE_CAPTURE);
USHORT vendorId = 0;
rc = aUSBDevice->COMGETTER(VendorId) (&vendorId);
ComAssertComRCRet(rc, false);
ComAssertRet(vendorId, false);
int vrc = USBFilterSetNumExact (&dev, USBFILTERIDX_VENDOR_ID, vendorId, true); AssertRC(vrc);
USHORT productId = 0;
rc = aUSBDevice->COMGETTER(ProductId) (&productId);
ComAssertComRCRet(rc, false);
vrc = USBFilterSetNumExact (&dev, USBFILTERIDX_PRODUCT_ID, productId, true); AssertRC(vrc);
USHORT revision;
rc = aUSBDevice->COMGETTER(Revision) (&revision);
ComAssertComRCRet(rc, false);
vrc = USBFilterSetNumExact (&dev, USBFILTERIDX_DEVICE, revision, true); AssertRC(vrc);
Bstr manufacturer;
rc = aUSBDevice->COMGETTER(Manufacturer) (manufacturer.asOutParam());
ComAssertComRCRet(rc, false);
if (!manufacturer.isEmpty())
USBFilterSetStringExact (&dev, USBFILTERIDX_MANUFACTURER_STR, Utf8Str(manufacturer).c_str(), true);
Bstr product;
rc = aUSBDevice->COMGETTER(Product) (product.asOutParam());
ComAssertComRCRet(rc, false);
if (!product.isEmpty())
USBFilterSetStringExact (&dev, USBFILTERIDX_PRODUCT_STR, Utf8Str(product).c_str(), true);
Bstr serialNumber;
rc = aUSBDevice->COMGETTER(SerialNumber) (serialNumber.asOutParam());
ComAssertComRCRet(rc, false);
if (!serialNumber.isEmpty())
USBFilterSetStringExact (&dev, USBFILTERIDX_SERIAL_NUMBER_STR, Utf8Str(serialNumber).c_str(), true);
Bstr address;
rc = aUSBDevice->COMGETTER(Address) (address.asOutParam());
ComAssertComRCRet(rc, false);
USHORT port = 0;
rc = aUSBDevice->COMGETTER(Port)(&port);
ComAssertComRCRet(rc, false);
USBFilterSetNumExact (&dev, USBFILTERIDX_PORT, port, true);
BOOL remote = FALSE;
rc = aUSBDevice->COMGETTER(Remote)(&remote);
ComAssertComRCRet(rc, false);
ComAssertRet(remote == TRUE, false);
bool match = false;
/* apply self filters */
for (DeviceFilterList::const_iterator it = m->llDeviceFilters->begin();
it != m->llDeviceFilters->end();
++ it)
{
AutoWriteLock filterLock(*it COMMA_LOCKVAL_SRC_POS);
const USBDeviceFilter::Data &aData = (*it)->getData();
if (!aData.mActive)
continue;
if (!aData.mRemote.isMatch (remote))
continue;
if (!USBFilterMatch (&aData.mUSBFilter, &dev))
continue;
match = true;
*aMaskedIfs = aData.mMaskedIfs;
break;
}
LogFlowThisFunc(("returns: %d\n", match));
LogFlowThisFuncLeave();
return match;
}
