USBControllerImpl.cpp@ 13079

Last change on this file since 13079 was 10535, checked in by vboxsync, 16 years ago
The OSE case (no USB) didn't compile
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 38.9 KB

Line
1	/* $Id: USBControllerImpl.cpp 10535 2008-07-11 15:28:06Z vboxsync $ */
2	/** @file
3	* Implementation of IUSBController.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18	* Clara, CA 95054 USA or visit http://www.sun.com if you need
19	* additional information or have any questions.
20	*/
21
22
23
24	#include "USBControllerImpl.h"
25	#include "MachineImpl.h"
26	#include "VirtualBoxImpl.h"
27	#include "HostImpl.h"
28	#ifdef VBOX_WITH_USB
29	# include "USBDeviceImpl.h"
30	# include "HostUSBDeviceImpl.h"
31	# include "USBProxyService.h"
32	#endif
33	#include "Logging.h"
34
35
36	#include <iprt/string.h>
37	#include <iprt/cpputils.h>
38	#include <VBox/err.h>
39
40	#include <algorithm>
41
42	// defines
43	/////////////////////////////////////////////////////////////////////////////
44
45	// constructor / destructor
46	/////////////////////////////////////////////////////////////////////////////
47
48	DEFINE_EMPTY_CTOR_DTOR (USBController)
49
50	HRESULT USBController::FinalConstruct()
51	{
52	return S_OK;
53	}
54
55	void USBController::FinalRelease()
56	{
57	uninit();
58	}
59
60	// public initializer/uninitializer for internal purposes only
61	/////////////////////////////////////////////////////////////////////////////
62
63	/**
64	* Initializes the USB controller object.
65	*
66	* @returns COM result indicator.
67	* @param aParent Pointer to our parent object.
68	*/
69	HRESULT USBController::init (Machine *aParent)
70	{
71	LogFlowThisFunc (("aParent=%p\n", aParent));
72
73	ComAssertRet (aParent, E_INVALIDARG);
74
75	/* Enclose the state transition NotReady->InInit->Ready */
76	AutoInitSpan autoInitSpan (this);
77	AssertReturn (autoInitSpan.isOk(), E_UNEXPECTED);
78
79	unconst (mParent) = aParent;
80	/* mPeer is left null */
81
82	mData.allocate();
83	#ifdef VBOX_WITH_USB
84	mDeviceFilters.allocate();
85	#endif
86
87	/* Confirm a successful initialization */
88	autoInitSpan.setSucceeded();
89
90	return S_OK;
91	}
92
93
94	/**
95	* Initializes the USB controller object given another USB controller object
96	* (a kind of copy constructor). This object shares data with
97	* the object passed as an argument.
98	*
99	* @returns COM result indicator.
100	* @param aParent Pointer to our parent object.
101	* @param aPeer The object to share.
102	*
103	* @note This object must be destroyed before the original object
104	* it shares data with is destroyed.
105	*/
106	HRESULT USBController::init (Machine aParent, USBController aPeer)
107	{
108	LogFlowThisFunc (("aParent=%p, aPeer=%p\n", aParent, aPeer));
109
110	ComAssertRet (aParent && aPeer, E_INVALIDARG);
111
112	/* Enclose the state transition NotReady->InInit->Ready */
113	AutoInitSpan autoInitSpan (this);
114	AssertReturn (autoInitSpan.isOk(), E_UNEXPECTED);
115
116	unconst (mParent) = aParent;
117	unconst (mPeer) = aPeer;
118
119	AutoWriteLock thatlock (aPeer);
120	mData.share (aPeer->mData);
121
122	#ifdef VBOX_WITH_USB
123	/* create copies of all filters */
124	mDeviceFilters.allocate();
125	DeviceFilterList::const_iterator it = aPeer->mDeviceFilters->begin();
126	while (it != aPeer->mDeviceFilters->end())
127	{
128	ComObjPtr <USBDeviceFilter> filter;
129	filter.createObject();
130	filter->init (this, *it);
131	mDeviceFilters->push_back (filter);
132	++ it;
133	}
134	#endif /* VBOX_WITH_USB */
135
136	/* Confirm a successful initialization */
137	autoInitSpan.setSucceeded();
138
139	return S_OK;
140	}
141
142
143	/**
144	* Initializes the USB controller object given another guest object
145	* (a kind of copy constructor). This object makes a private copy of data
146	* of the original object passed as an argument.
147	*/
148	HRESULT USBController::initCopy (Machine aParent, USBController aPeer)
149	{
150	LogFlowThisFunc (("aParent=%p, aPeer=%p\n", aParent, aPeer));
151
152	ComAssertRet (aParent && aPeer, E_INVALIDARG);
153
154	/* Enclose the state transition NotReady->InInit->Ready */
155	AutoInitSpan autoInitSpan (this);
156	AssertReturn (autoInitSpan.isOk(), E_UNEXPECTED);
157
158	unconst (mParent) = aParent;
159	/* mPeer is left null */
160
161	AutoWriteLock thatlock (aPeer);
162	mData.attachCopy (aPeer->mData);
163
164	#ifdef VBOX_WITH_USB
165	/* create private copies of all filters */
166	mDeviceFilters.allocate();
167	DeviceFilterList::const_iterator it = aPeer->mDeviceFilters->begin();
168	while (it != aPeer->mDeviceFilters->end())
169	{
170	ComObjPtr <USBDeviceFilter> filter;
171	filter.createObject();
172	filter->initCopy (this, *it);
173	mDeviceFilters->push_back (filter);
174	++ it;
175	}
176	#endif /* VBOX_WITH_USB */
177
178	/* Confirm a successful initialization */
179	autoInitSpan.setSucceeded();
180
181	return S_OK;
182	}
183
184
185	/**
186	* Uninitializes the instance and sets the ready flag to FALSE.
187	* Called either from FinalRelease() or by the parent when it gets destroyed.
188	*/
189	void USBController::uninit()
190	{
191	LogFlowThisFunc (("\n"));
192
193	/* Enclose the state transition Ready->InUninit->NotReady */
194	AutoUninitSpan autoUninitSpan (this);
195	if (autoUninitSpan.uninitDone())
196	return;
197
198	/* uninit all filters (including those still referenced by clients) */
199	uninitDependentChildren();
200
201	#ifdef VBOX_WITH_USB
202	mDeviceFilters.free();
203	#endif
204	mData.free();
205
206	unconst (mPeer).setNull();
207	unconst (mParent).setNull();
208	}
209
210
211	// IUSBController properties
212	/////////////////////////////////////////////////////////////////////////////
213
214	STDMETHODIMP USBController::COMGETTER(Enabled) (BOOL *aEnabled)
215	{
216	if (!aEnabled)
217	return E_POINTER;
218
219	AutoCaller autoCaller (this);
220	CheckComRCReturnRC (autoCaller.rc());
221
222	AutoReadLock alock (this);
223
224	*aEnabled = mData->mEnabled;
225
226	return S_OK;
227	}
228
229
230	STDMETHODIMP USBController::COMSETTER(Enabled) (BOOL aEnabled)
231	{
232	LogFlowThisFunc (("aEnabled=%RTbool\n", aEnabled));
233
234	AutoCaller autoCaller (this);
235	CheckComRCReturnRC (autoCaller.rc());
236
237	/* the machine needs to be mutable */
238	Machine::AutoMutableStateDependency adep (mParent);
239	CheckComRCReturnRC (adep.rc());
240
241	AutoWriteLock alock (this);
242
243	if (mData->mEnabled != aEnabled)
244	{
245	mData.backup();
246	mData->mEnabled = aEnabled;
247
248	/* leave the lock for safety */
249	alock.leave();
250
251	mParent->onUSBControllerChange();
252	}
253
254	return S_OK;
255	}
256
257	STDMETHODIMP USBController::COMGETTER(EnabledEhci) (BOOL *aEnabled)
258	{
259	if (!aEnabled)
260	return E_POINTER;
261
262	AutoCaller autoCaller (this);
263	CheckComRCReturnRC (autoCaller.rc());
264
265	AutoReadLock alock (this);
266
267	*aEnabled = mData->mEnabledEhci;
268
269	return S_OK;
270	}
271
272	STDMETHODIMP USBController::COMSETTER(EnabledEhci) (BOOL aEnabled)
273	{
274	LogFlowThisFunc (("aEnabled=%RTbool\n", aEnabled));
275
276	AutoCaller autoCaller (this);
277	CheckComRCReturnRC (autoCaller.rc());
278
279	/* the machine needs to be mutable */
280	Machine::AutoMutableStateDependency adep (mParent);
281	CheckComRCReturnRC (adep.rc());
282
283	AutoWriteLock alock (this);
284
285	if (mData->mEnabledEhci != aEnabled)
286	{
287	mData.backup();
288	mData->mEnabledEhci = aEnabled;
289
290	/* leave the lock for safety */
291	alock.leave();
292
293	mParent->onUSBControllerChange();
294	}
295
296	return S_OK;
297	}
298
299	STDMETHODIMP USBController::COMGETTER(USBStandard) (USHORT *aUSBStandard)
300	{
301	if (!aUSBStandard)
302	return E_POINTER;
303
304	AutoCaller autoCaller (this);
305	CheckComRCReturnRC (autoCaller.rc());
306
307	/* not accessing data -- no need to lock */
308
309	/** @todo This is no longer correct */
310	*aUSBStandard = 0x0101;
311
312	return S_OK;
313	}
314
315	#ifndef VBOX_WITH_USB
316	/**
317	* Fake class for build without USB.
318	* We need an empty collection & enum for deviceFilters, that's all.
319	*/
320	class ATL_NO_VTABLE USBDeviceFilter :
321	public VirtualBoxBaseNEXT,
322	public VirtualBoxSupportErrorInfoImpl <USBDeviceFilter, IUSBDeviceFilter>,
323	public VirtualBoxSupportTranslation <USBDeviceFilter>,
324	public IUSBDeviceFilter
325	{
326	public:
327	DECLARE_NOT_AGGREGATABLE(USBDeviceFilter)
328	DECLARE_PROTECT_FINAL_CONSTRUCT()
329	BEGIN_COM_MAP(USBDeviceFilter)
330	COM_INTERFACE_ENTRY(ISupportErrorInfo)
331	COM_INTERFACE_ENTRY(IUSBDeviceFilter)
332	END_COM_MAP()
333
334	NS_DECL_ISUPPORTS
335
336	DECLARE_EMPTY_CTOR_DTOR (USBDeviceFilter)
337
338	// IUSBDeviceFilter properties
339	STDMETHOD(COMGETTER(Name)) (BSTR *aName);
340	STDMETHOD(COMSETTER(Name)) (INPTR BSTR aName);
341	STDMETHOD(COMGETTER(Active)) (BOOL *aActive);
342	STDMETHOD(COMSETTER(Active)) (BOOL aActive);
343	STDMETHOD(COMGETTER(VendorId)) (BSTR *aVendorId);
344	STDMETHOD(COMSETTER(VendorId)) (INPTR BSTR aVendorId);
345	STDMETHOD(COMGETTER(ProductId)) (BSTR *aProductId);
346	STDMETHOD(COMSETTER(ProductId)) (INPTR BSTR aProductId);
347	STDMETHOD(COMGETTER(Revision)) (BSTR *aRevision);
348	STDMETHOD(COMSETTER(Revision)) (INPTR BSTR aRevision);
349	STDMETHOD(COMGETTER(Manufacturer)) (BSTR *aManufacturer);
350	STDMETHOD(COMSETTER(Manufacturer)) (INPTR BSTR aManufacturer);
351	STDMETHOD(COMGETTER(Product)) (BSTR *aProduct);
352	STDMETHOD(COMSETTER(Product)) (INPTR BSTR aProduct);
353	STDMETHOD(COMGETTER(SerialNumber)) (BSTR *aSerialNumber);
354	STDMETHOD(COMSETTER(SerialNumber)) (INPTR BSTR aSerialNumber);
355	STDMETHOD(COMGETTER(Port)) (BSTR *aPort);
356	STDMETHOD(COMSETTER(Port)) (INPTR BSTR aPort);
357	STDMETHOD(COMGETTER(Remote)) (BSTR *aRemote);
358	STDMETHOD(COMSETTER(Remote)) (INPTR BSTR aRemote);
359	STDMETHOD(COMGETTER(MaskedInterfaces)) (ULONG *aMaskedIfs);
360	STDMETHOD(COMSETTER(MaskedInterfaces)) (ULONG aMaskedIfs);
361	};
362	COM_DECL_READONLY_ENUM_AND_COLLECTION (USBDeviceFilter);
363	COM_IMPL_READONLY_ENUM_AND_COLLECTION (USBDeviceFilter);
364	#endif /* !VBOX_WITH_USB */
365
366
367	STDMETHODIMP USBController::COMGETTER(DeviceFilters) (IUSBDeviceFilterCollection **aDevicesFilters)
368	{
369	if (!aDevicesFilters)
370	return E_POINTER;
371
372	AutoCaller autoCaller (this);
373	CheckComRCReturnRC (autoCaller.rc());
374
375	AutoReadLock alock (this);
376
377	ComObjPtr <USBDeviceFilterCollection> collection;
378	collection.createObject();
379	#ifdef VBOX_WITH_USB
380	collection->init (*mDeviceFilters.data());
381	#endif
382	collection.queryInterfaceTo (aDevicesFilters);
383
384	return S_OK;
385	}
386
387	// IUSBController methods
388	/////////////////////////////////////////////////////////////////////////////
389
390	STDMETHODIMP USBController::CreateDeviceFilter (INPTR BSTR aName,
391	IUSBDeviceFilter **aFilter)
392	{
393	#ifdef VBOX_WITH_USB
394	if (!aFilter)
395	return E_POINTER;
396
397	if (!aName \|\| *aName == 0)
398	return E_INVALIDARG;
399
400	AutoCaller autoCaller (this);
401	CheckComRCReturnRC (autoCaller.rc());
402
403	/* the machine needs to be mutable */
404	Machine::AutoMutableStateDependency adep (mParent);
405	CheckComRCReturnRC (adep.rc());
406
407	AutoWriteLock alock (this);
408
409	ComObjPtr <USBDeviceFilter> filter;
410	filter.createObject();
411	HRESULT rc = filter->init (this, aName);
412	ComAssertComRCRetRC (rc);
413	rc = filter.queryInterfaceTo (aFilter);
414	AssertComRCReturnRC (rc);
415
416	return S_OK;
417	#else
418	return E_NOTIMPL;
419	#endif
420	}
421
422	STDMETHODIMP USBController::InsertDeviceFilter (ULONG aPosition,
423	IUSBDeviceFilter *aFilter)
424	{
425	#ifdef VBOX_WITH_USB
426	if (!aFilter)
427	return E_INVALIDARG;
428
429	AutoCaller autoCaller (this);
430	CheckComRCReturnRC (autoCaller.rc());
431
432	/* the machine needs to be mutable */
433	Machine::AutoMutableStateDependency adep (mParent);
434	CheckComRCReturnRC (adep.rc());
435
436	AutoWriteLock alock (this);
437
438	ComObjPtr <USBDeviceFilter> filter = getDependentChild (aFilter);
439	if (!filter)
440	return setError (E_INVALIDARG,
441	tr ("The given USB device filter is not created within "
442	"this VirtualBox instance"));
443
444	if (filter->mInList)
445	return setError (E_INVALIDARG,
446	tr ("The given USB device filter is already in the list"));
447
448	/* backup the list before modification */
449	mDeviceFilters.backup();
450
451	/* iterate to the position... */
452	DeviceFilterList::iterator it;
453	if (aPosition < mDeviceFilters->size())
454	{
455	it = mDeviceFilters->begin();
456	std::advance (it, aPosition);
457	}
458	else
459	it = mDeviceFilters->end();
460	/* ...and insert */
461	mDeviceFilters->insert (it, filter);
462	filter->mInList = true;
463
464	/// @todo After rewriting Win32 USB support, no more necessary;
465	// a candidate for removal.
466	#if 0
467	/* notify the proxy (only when the filter is active) */
468	if (filter->data().mActive)
469	#else
470	/* notify the proxy (only when it makes sense) */
471	if (filter->data().mActive && adep.machineState() >= MachineState_Running)
472	#endif
473	{
474	USBProxyService *service = mParent->virtualBox()->host()->usbProxyService();
475	ComAssertRet (service, E_FAIL);
476
477	ComAssertRet (filter->id() == NULL, E_FAIL);
478	filter->id() = service->insertFilter (&filter->data().mUSBFilter);
479	}
480
481	return S_OK;
482	#else
483	return E_NOTIMPL;
484	#endif
485	}
486
487	STDMETHODIMP USBController::RemoveDeviceFilter (ULONG aPosition,
488	IUSBDeviceFilter **aFilter)
489	{
490	#ifdef VBOX_WITH_USB
491	if (!aFilter)
492	return E_POINTER;
493
494	AutoCaller autoCaller (this);
495	CheckComRCReturnRC (autoCaller.rc());
496
497	/* the machine needs to be mutable */
498	Machine::AutoMutableStateDependency adep (mParent);
499	CheckComRCReturnRC (adep.rc());
500
501	AutoWriteLock alock (this);
502
503	if (!mDeviceFilters->size())
504	return setError (E_INVALIDARG,
505	tr ("The USB device filter list is empty"));
506
507	if (aPosition >= mDeviceFilters->size())
508	return setError (E_INVALIDARG,
509	tr ("Invalid position: %lu (must be in range [0, %lu])"),
510	aPosition, mDeviceFilters->size() - 1);
511
512	/* backup the list before modification */
513	mDeviceFilters.backup();
514
515	ComObjPtr <USBDeviceFilter> filter;
516	{
517	/* iterate to the position... */
518	DeviceFilterList::iterator it = mDeviceFilters->begin();
519	std::advance (it, aPosition);
520	/* ...get an element from there... */
521	filter = *it;
522	/* ...and remove */
523	filter->mInList = false;
524	mDeviceFilters->erase (it);
525	}
526
527	/* cancel sharing (make an independent copy of data) */
528	filter->unshare();
529
530	filter.queryInterfaceTo (aFilter);
531
532	/// @todo After rewriting Win32 USB support, no more necessary;
533	// a candidate for removal.
534	#if 0
535	/* notify the proxy (only when the filter is active) */
536	if (filter->data().mActive)
537	#else
538	/* notify the proxy (only when it makes sense) */
539	if (filter->data().mActive && adep.machineState() >= MachineState_Running)
540	#endif
541	{
542	USBProxyService *service = mParent->virtualBox()->host()->usbProxyService();
543	ComAssertRet (service, E_FAIL);
544
545	ComAssertRet (filter->id() != NULL, E_FAIL);
546	service->removeFilter (filter->id());
547	filter->id() = NULL;
548	}
549
550	return S_OK;
551	#else
552	return E_NOTIMPL;
553	#endif
554	}
555
556	// public methods only for internal purposes
557	/////////////////////////////////////////////////////////////////////////////
558
559	/**
560	* Loads settings from the given machine node.
561	* May be called once right after this object creation.
562	*
563	* @param aMachineNode <Machine> node.
564	*
565	* @note Locks this object for writing.
566	*/
567	HRESULT USBController::loadSettings (const settings::Key &aMachineNode)
568	{
569	using namespace settings;
570
571	AssertReturn (!aMachineNode.isNull(), E_FAIL);
572
573	AutoCaller autoCaller (this);
574	AssertComRCReturnRC (autoCaller.rc());
575
576	AutoWriteLock alock (this);
577
578	/* Note: we assume that the default values for attributes of optional
579	* nodes are assigned in the Data::Data() constructor and don't do it
580	* here. It implies that this method may only be called after constructing
581	* a new BIOSSettings object while all its data fields are in the default
582	* values. Exceptions are fields whose creation time defaults don't match
583	* values that should be applied when these fields are not explicitly set
584	* in the settings file (for backwards compatibility reasons). This takes
585	* place when a setting of a newly created object must default to A while
586	* the same setting of an object loaded from the old settings file must
587	* default to B. */
588
589	/* USB Controller node (required) */
590	Key controller = aMachineNode.key ("USBController");
591
592	/* enabled (required) */
593	mData->mEnabled = controller.value <bool> ("enabled");
594
595	/* enabledEhci (optiona, defaults to false) */
596	mData->mEnabledEhci = controller.value <bool> ("enabledEhci");
597
598	#ifdef VBOX_WITH_USB
599	HRESULT rc = S_OK;
600
601	Key::List children = controller.keys ("DeviceFilter");
602	for (Key::List::const_iterator it = children.begin();
603	it != children.end(); ++ it)
604	{
605	/* required */
606	Bstr name = (*it).stringValue ("name");
607	bool active = (*it).value <bool> ("active");
608
609	/* optional */
610	Bstr vendorId = (*it).stringValue ("vendorId");
611	Bstr productId = (*it).stringValue ("productId");
612	Bstr revision = (*it).stringValue ("revision");
613	Bstr manufacturer = (*it).stringValue ("manufacturer");
614	Bstr product = (*it).stringValue ("product");
615	Bstr serialNumber = (*it).stringValue ("serialNumber");
616	Bstr port = (*it).stringValue ("port");
617	Bstr remote = (*it).stringValue ("remote");
618	ULONG maskedIfs = (*it).value <ULONG> ("maskedInterfaces");
619
620	ComObjPtr <USBDeviceFilter> filterObj;
621	filterObj.createObject();
622	rc = filterObj->init (this,
623	name, active, vendorId, productId, revision,
624	manufacturer, product, serialNumber,
625	port, remote, maskedIfs);
626	/* error info is set by init() when appropriate */
627	CheckComRCReturnRC (rc);
628
629	mDeviceFilters->push_back (filterObj);
630	filterObj->mInList = true;
631	}
632	#endif /* VBOX_WITH_USB */
633
634	return S_OK;
635	}
636
637	/**
638	* Saves settings to the given machine node.
639	*
640	* @param aMachineNode <Machine> node.
641	*
642	* @note Locks this object for reading.
643	*/
644	HRESULT USBController::saveSettings (settings::Key &aMachineNode)
645	{
646	using namespace settings;
647
648	AssertReturn (!aMachineNode.isNull(), E_FAIL);
649
650	AutoCaller autoCaller (this);
651	CheckComRCReturnRC (autoCaller.rc());
652
653	AutoReadLock alock (this);
654
655	/* first, delete the entry */
656	Key controller = aMachineNode.findKey ("USBController");
657	#ifdef VBOX_WITH_USB
658	if (!controller.isNull())
659	controller.zap();
660	/* then, recreate it */
661	controller = aMachineNode.createKey ("USBController");
662	#else
663	/* don't zap it. */
664	if (controller.isNull())
665	controller = aMachineNode.createKey ("USBController");
666	#endif
667
668	/* enabled */
669	controller.setValue <bool> ("enabled", !!mData->mEnabled);
670
671	/* enabledEhci */
672	controller.setValue <bool> ("enabledEhci", !!mData->mEnabledEhci);
673
674	#ifdef VBOX_WITH_USB
675	DeviceFilterList::const_iterator it = mDeviceFilters->begin();
676	while (it != mDeviceFilters->end())
677	{
678	AutoWriteLock filterLock (*it);
679	const USBDeviceFilter::Data &data = (*it)->data();
680
681	Key filter = controller.appendKey ("DeviceFilter");
682
683	filter.setValue <Bstr> ("name", data.mName);
684	filter.setValue <bool> ("active", !!data.mActive);
685
686	/* all are optional */
687	Bstr str;
688	(*it)->COMGETTER (VendorId) (str.asOutParam());
689	if (!str.isNull())
690	filter.setValue <Bstr> ("vendorId", str);
691
692	(*it)->COMGETTER (ProductId) (str.asOutParam());
693	if (!str.isNull())
694	filter.setValue <Bstr> ("productId", str);
695
696	(*it)->COMGETTER (Revision) (str.asOutParam());
697	if (!str.isNull())
698	filter.setValue <Bstr> ("revision", str);
699
700	(*it)->COMGETTER (Manufacturer) (str.asOutParam());
701	if (!str.isNull())
702	filter.setValue <Bstr> ("manufacturer", str);
703
704	(*it)->COMGETTER (Product) (str.asOutParam());
705	if (!str.isNull())
706	filter.setValue <Bstr> ("product", str);
707
708	(*it)->COMGETTER (SerialNumber) (str.asOutParam());
709	if (!str.isNull())
710	filter.setValue <Bstr> ("serialNumber", str);
711
712	(*it)->COMGETTER (Port) (str.asOutParam());
713	if (!str.isNull())
714	filter.setValue <Bstr> ("port", str);
715
716	if (data.mRemote.string())
717	filter.setValue <Bstr> ("remote", data.mRemote.string());
718
719	if (data.mMaskedIfs)
720	filter.setValue <ULONG> ("maskedInterfaces", data.mMaskedIfs);
721
722	++ it;
723	}
724	#endif /* VBOX_WITH_USB */
725
726	return S_OK;
727	}
728
729	/** @note Locks objects for reading! */
730	bool USBController::isModified()
731	{
732	AutoCaller autoCaller (this);
733	AssertComRCReturn (autoCaller.rc(), false);
734
735	AutoReadLock alock (this);
736
737	if (mData.isBackedUp()
738	#ifdef VBOX_WITH_USB
739	\|\| mDeviceFilters.isBackedUp()
740	#endif
741	)
742	return true;
743
744	#ifdef VBOX_WITH_USB
745	/* see whether any of filters has changed its data */
746	for (DeviceFilterList::const_iterator
747	it = mDeviceFilters->begin();
748	it != mDeviceFilters->end();
749	++ it)
750	{
751	if ((*it)->isModified())
752	return true;
753	}
754	#endif /* VBOX_WITH_USB */
755
756	return false;
757	}
758
759	/** @note Locks objects for reading! */
760	bool USBController::isReallyModified()
761	{
762	AutoCaller autoCaller (this);
763	AssertComRCReturn (autoCaller.rc(), false);
764
765	AutoReadLock alock (this);
766
767	if (mData.hasActualChanges())
768	return true;
769
770	#ifdef VBOX_WITH_USB
771	if (!mDeviceFilters.isBackedUp())
772	{
773	/* see whether any of filters has changed its data */
774	for (DeviceFilterList::const_iterator
775	it = mDeviceFilters->begin();
776	it != mDeviceFilters->end();
777	++ it)
778	{
779	if ((*it)->isReallyModified())
780	return true;
781	}
782
783	return false;
784	}
785
786	if (mDeviceFilters->size() != mDeviceFilters.backedUpData()->size())
787	return true;
788
789	if (mDeviceFilters->size() == 0)
790	return false;
791
792	/* Make copies to speed up comparison */
793	DeviceFilterList devices = *mDeviceFilters.data();
794	DeviceFilterList backDevices = *mDeviceFilters.backedUpData();
795
796	DeviceFilterList::iterator it = devices.begin();
797	while (it != devices.end())
798	{
799	bool found = false;
800	DeviceFilterList::iterator thatIt = backDevices.begin();
801	while (thatIt != backDevices.end())
802	{
803	if ((it)->data() == (thatIt)->data())
804	{
805	backDevices.erase (thatIt);
806	found = true;
807	break;
808	}
809	else
810	++ thatIt;
811	}
812	if (found)
813	it = devices.erase (it);
814	else
815	return false;
816	}
817
818	Assert (devices.size() == 0 && backDevices.size() == 0);
819	#endif /* VBOX_WITH_USB */
820
821	return false;
822	}
823
824	/** @note Locks objects for writing! */
825	bool USBController::rollback()
826	{
827	AutoCaller autoCaller (this);
828	AssertComRCReturn (autoCaller.rc(), false);
829
830	/* we need the machine state */
831	Machine::AutoAnyStateDependency adep (mParent);
832	AssertComRCReturn (adep.rc(), false);
833
834	AutoWriteLock alock (this);
835
836	bool dataChanged = false;
837
838	if (mData.isBackedUp())
839	{
840	/* we need to check all data to see whether anything will be changed
841	* after rollback */
842	dataChanged = mData.hasActualChanges();
843	mData.rollback();
844	}
845
846	#ifdef VBOX_WITH_USB
847	if (mDeviceFilters.isBackedUp())
848	{
849	USBProxyService *service = mParent->virtualBox()->host()->usbProxyService();
850	ComAssertRet (service, false);
851
852	/* uninitialize all new filters (absent in the backed up list) */
853	DeviceFilterList::const_iterator it = mDeviceFilters->begin();
854	DeviceFilterList *backedList = mDeviceFilters.backedUpData();
855	while (it != mDeviceFilters->end())
856	{
857	if (std::find (backedList->begin(), backedList->end(), *it) ==
858	backedList->end())
859	{
860	/// @todo After rewriting Win32 USB support, no more necessary;
861	// a candidate for removal.
862	#if 0
863	/* notify the proxy (only when the filter is active) */
864	if ((*it)->data().mActive)
865	#else
866	/* notify the proxy (only when it makes sense) */
867	if ((*it)->data().mActive &&
868	adep.machineState() >= MachineState_Running)
869	#endif
870	{
871	USBDeviceFilter filter = it;
872	ComAssertRet (filter->id() != NULL, false);
873	service->removeFilter (filter->id());
874	filter->id() = NULL;
875	}
876
877	(*it)->uninit();
878	}
879	++ it;
880	}
881
882	/// @todo After rewriting Win32 USB support, no more necessary;
883	// a candidate for removal.
884	#if 0
885	#else
886	if (adep.machineState() >= MachineState_Running)
887	#endif
888	{
889	/* find all removed old filters (absent in the new list)
890	* and insert them back to the USB proxy */
891	it = backedList->begin();
892	while (it != backedList->end())
893	{
894	if (std::find (mDeviceFilters->begin(), mDeviceFilters->end(), *it) ==
895	mDeviceFilters->end())
896	{
897	/* notify the proxy (only when necessary) */
898	if ((*it)->data().mActive)
899	{
900	USBDeviceFilter flt = it; /* resolve ambiguity */
901	ComAssertRet (flt->id() == NULL, false);
902	flt->id() = service->insertFilter (&flt->data().mUSBFilter);
903	}
904	}
905	++ it;
906	}
907	}
908
909	/* restore the list */
910	mDeviceFilters.rollback();
911	}
912
913	/* here we don't depend on the machine state any more */
914	adep.release();
915
916	/* rollback any changes to filters after restoring the list */
917	DeviceFilterList::const_iterator it = mDeviceFilters->begin();
918	while (it != mDeviceFilters->end())
919	{
920	if ((*it)->isModified())
921	{
922	(*it)->rollback();
923	/* call this to notify the USB proxy about changes */
924	onDeviceFilterChange (*it);
925	}
926	++ it;
927	}
928	#endif /* VBOX_WITH_USB */
929
930	return dataChanged;
931	}
932
933	/**
934	* @note Locks this object for writing, together with the peer object (also
935	* for writing) if there is one.
936	*/
937	void USBController::commit()
938	{
939	/* sanity */
940	AutoCaller autoCaller (this);
941	AssertComRCReturnVoid (autoCaller.rc());
942
943	/* sanity too */
944	AutoCaller peerCaller (mPeer);
945	AssertComRCReturnVoid (peerCaller.rc());
946
947	/* lock both for writing since we modify both (mPeer is "master" so locked
948	* first) */
949	AutoMultiWriteLock2 alock (mPeer, this);
950
951	if (mData.isBackedUp())
952	{
953	mData.commit();
954	if (mPeer)
955	{
956	/* attach new data to the peer and reshare it */
957	AutoWriteLock peerlock (mPeer);
958	mPeer->mData.attach (mData);
959	}
960	}
961
962	#ifdef VBOX_WITH_USB
963	bool commitFilters = false;
964
965	if (mDeviceFilters.isBackedUp())
966	{
967	mDeviceFilters.commit();
968
969	/* apply changes to peer */
970	if (mPeer)
971	{
972	AutoWriteLock peerlock (mPeer);
973	/* commit all changes to new filters (this will reshare data with
974	* peers for those who have peers) */
975	DeviceFilterList *newList = new DeviceFilterList();
976	DeviceFilterList::const_iterator it = mDeviceFilters->begin();
977	while (it != mDeviceFilters->end())
978	{
979	(*it)->commit();
980
981	/* look if this filter has a peer filter */
982	ComObjPtr <USBDeviceFilter> peer = (*it)->peer();
983	if (!peer)
984	{
985	/* no peer means the filter is a newly created one;
986	* create a peer owning data this filter share it with */
987	peer.createObject();
988	peer->init (mPeer, it, true / aReshare */);
989	}
990	else
991	{
992	/* remove peer from the old list */
993	mPeer->mDeviceFilters->remove (peer);
994	}
995	/* and add it to the new list */
996	newList->push_back (peer);
997
998	++ it;
999	}
1000
1001	/* uninit old peer's filters that are left */
1002	it = mPeer->mDeviceFilters->begin();
1003	while (it != mPeer->mDeviceFilters->end())
1004	{
1005	(*it)->uninit();
1006	++ it;
1007	}
1008
1009	/* attach new list of filters to our peer */
1010	mPeer->mDeviceFilters.attach (newList);
1011	}
1012	else
1013	{
1014	/* we have no peer (our parent is the newly created machine);
1015	* just commit changes to filters */
1016	commitFilters = true;
1017	}
1018	}
1019	else
1020	{
1021	/* the list of filters itself is not changed,
1022	* just commit changes to filters themselves */
1023	commitFilters = true;
1024	}
1025
1026	if (commitFilters)
1027	{
1028	DeviceFilterList::const_iterator it = mDeviceFilters->begin();
1029	while (it != mDeviceFilters->end())
1030	{
1031	(*it)->commit();
1032	++ it;
1033	}
1034	}
1035	#endif /* VBOX_WITH_USB */
1036	}
1037
1038	/**
1039	* @note Locks this object for writing, together with the peer object
1040	* represented by @a aThat (locked for reading).
1041	*/
1042	void USBController::copyFrom (USBController *aThat)
1043	{
1044	AssertReturnVoid (aThat != NULL);
1045
1046	/* sanity */
1047	AutoCaller autoCaller (this);
1048	AssertComRCReturnVoid (autoCaller.rc());
1049
1050	/* sanity too */
1051	AutoCaller thatCaller (aThat);
1052	AssertComRCReturnVoid (thatCaller.rc());
1053
1054	/* peer is not modified, lock it for reading (aThat is "master" so locked
1055	* first) */
1056	AutoMultiLock2 alock (aThat->rlock(), this->wlock());
1057
1058	if (mParent->isRegistered())
1059	{
1060	/* reuse onMachineRegistered to tell USB proxy to remove all current
1061	filters */
1062	HRESULT rc = onMachineRegistered (FALSE);
1063	AssertComRCReturn (rc, (void) 0);
1064	}
1065
1066	/* this will back up current data */
1067	mData.assignCopy (aThat->mData);
1068
1069	#ifdef VBOX_WITH_USB
1070	/* create private copies of all filters */
1071	mDeviceFilters.backup();
1072	mDeviceFilters->clear();
1073	for (DeviceFilterList::const_iterator it = aThat->mDeviceFilters->begin();
1074	it != aThat->mDeviceFilters->end();
1075	++ it)
1076	{
1077	ComObjPtr <USBDeviceFilter> filter;
1078	filter.createObject();
1079	filter->initCopy (this, *it);
1080	mDeviceFilters->push_back (filter);
1081	}
1082	#endif /* VBOX_WITH_USB */
1083
1084	if (mParent->isRegistered())
1085	{
1086	/* reuse onMachineRegistered to tell USB proxy to insert all current
1087	filters */
1088	HRESULT rc = onMachineRegistered (TRUE);
1089	AssertComRCReturn (rc, (void) 0);
1090	}
1091	}
1092
1093	/**
1094	* Called by VirtualBox when it changes the registered state
1095	* of the machine this USB controller belongs to.
1096	*
1097	* @param aRegistered new registered state of the machine
1098	*
1099	* @note Locks nothing.
1100	*/
1101	HRESULT USBController::onMachineRegistered (BOOL aRegistered)
1102	{
1103	AutoCaller autoCaller (this);
1104	AssertComRCReturnRC (autoCaller.rc());
1105
1106	/// @todo After rewriting Win32 USB support, no more necessary;
1107	// a candidate for removal.
1108	#if 0
1109	notifyProxy (!!aRegistered);
1110	#endif
1111
1112	return S_OK;
1113	}
1114
1115	#ifdef VBOX_WITH_USB
1116
1117	/**
1118	* Called by setter methods of all USB device filters.
1119	*
1120	* @note Locks nothing.
1121	*/
1122	HRESULT USBController::onDeviceFilterChange (USBDeviceFilter *aFilter,
1123	BOOL aActiveChanged /* = FALSE */)
1124	{
1125	AutoCaller autoCaller (this);
1126	AssertComRCReturnRC (autoCaller.rc());
1127
1128	/// @todo After rewriting Win32 USB support, no more necessary;
1129	// a candidate for removal.
1130	#if 0
1131	#else
1132	/* we need the machine state */
1133	Machine::AutoAnyStateDependency adep (mParent);
1134	AssertComRCReturnRC (adep.rc());
1135
1136	/* nothing to do if the machine isn't running */
1137	if (adep.machineState() < MachineState_Running)
1138	return S_OK;
1139	#endif
1140
1141	/* we don't modify our data fields -- no need to lock */
1142
1143	if (aFilter->mInList && mParent->isRegistered())
1144	{
1145	USBProxyService *service = mParent->virtualBox()->host()->usbProxyService();
1146	ComAssertRet (service, E_FAIL);
1147
1148	if (aActiveChanged)
1149	{
1150	/* insert/remove the filter from the proxy */
1151	if (aFilter->data().mActive)
1152	{
1153	ComAssertRet (aFilter->id() == NULL, E_FAIL);
1154	aFilter->id() = service->insertFilter (&aFilter->data().mUSBFilter);
1155	}
1156	else
1157	{
1158	ComAssertRet (aFilter->id() != NULL, E_FAIL);
1159	service->removeFilter (aFilter->id());
1160	aFilter->id() = NULL;
1161	}
1162	}
1163	else
1164	{
1165	if (aFilter->data().mActive)
1166	{
1167	/* update the filter in the proxy */
1168	ComAssertRet (aFilter->id() != NULL, E_FAIL);
1169	service->removeFilter (aFilter->id());
1170	aFilter->id() = service->insertFilter (&aFilter->data().mUSBFilter);
1171	}
1172	}
1173	}
1174
1175	return S_OK;
1176	}
1177
1178	/**
1179	* Returns true if the given USB device matches to at least one of
1180	* this controller's USB device filters.
1181	*
1182	* A HostUSBDevice specific version.
1183	*
1184	* @note Locks this object for reading.
1185	*/
1186	bool USBController::hasMatchingFilter (const ComObjPtr <HostUSBDevice> &aDevice, ULONG *aMaskedIfs)
1187	{
1188	AutoCaller autoCaller (this);
1189	AssertComRCReturn (autoCaller.rc(), false);
1190
1191	AutoReadLock alock (this);
1192
1193	/* Disabled USB controllers cannot actually work with USB devices */
1194	if (!mData->mEnabled)
1195	return false;
1196
1197	/* apply self filters */
1198	for (DeviceFilterList::const_iterator it = mDeviceFilters->begin();
1199	it != mDeviceFilters->end();
1200	++ it)
1201	{
1202	AutoWriteLock filterLock (*it);
1203	if (aDevice->isMatch ((*it)->data()))
1204	{
1205	aMaskedIfs = (it)->data().mMaskedIfs;
1206	return true;
1207	}
1208	}
1209
1210	return false;
1211	}
1212
1213	/**
1214	* Returns true if the given USB device matches to at least one of
1215	* this controller's USB device filters.
1216	*
1217	* A generic version that accepts any IUSBDevice on input.
1218	*
1219	* @note
1220	* This method MUST correlate with HostUSBDevice::isMatch()
1221	* in the sense of the device matching logic.
1222	*
1223	* @note Locks this object for reading.
1224	*/
1225	bool USBController::hasMatchingFilter (IUSBDevice aUSBDevice, ULONG aMaskedIfs)
1226	{
1227	LogFlowThisFuncEnter();
1228
1229	AutoCaller autoCaller (this);
1230	AssertComRCReturn (autoCaller.rc(), false);
1231
1232	AutoReadLock alock (this);
1233
1234	/* Disabled USB controllers cannot actually work with USB devices */
1235	if (!mData->mEnabled)
1236	return false;
1237
1238	HRESULT rc = S_OK;
1239
1240	/* query fields */
1241	USBFILTER dev;
1242	USBFilterInit (&dev, USBFILTERTYPE_CAPTURE);
1243
1244	USHORT vendorId = 0;
1245	rc = aUSBDevice->COMGETTER(VendorId) (&vendorId);
1246	ComAssertComRCRet (rc, false);
1247	ComAssertRet (vendorId, false);
1248	int vrc = USBFilterSetNumExact (&dev, USBFILTERIDX_VENDOR_ID, vendorId, true); AssertRC(vrc);
1249
1250	USHORT productId = 0;
1251	rc = aUSBDevice->COMGETTER(ProductId) (&productId);
1252	ComAssertComRCRet (rc, false);
1253	ComAssertRet (productId, false);
1254	vrc = USBFilterSetNumExact (&dev, USBFILTERIDX_PRODUCT_ID, productId, true); AssertRC(vrc);
1255
1256	USHORT revision;
1257	rc = aUSBDevice->COMGETTER(Revision) (&revision);
1258	ComAssertComRCRet (rc, false);
1259	vrc = USBFilterSetNumExact (&dev, USBFILTERIDX_DEVICE, revision, true); AssertRC(vrc);
1260
1261	Bstr manufacturer;
1262	rc = aUSBDevice->COMGETTER(Manufacturer) (manufacturer.asOutParam());
1263	ComAssertComRCRet (rc, false);
1264	if (!manufacturer.isNull())
1265	USBFilterSetStringExact (&dev, USBFILTERIDX_MANUFACTURER_STR, Utf8Str(manufacturer), true);
1266
1267	Bstr product;
1268	rc = aUSBDevice->COMGETTER(Product) (product.asOutParam());
1269	ComAssertComRCRet (rc, false);
1270	if (!product.isNull())
1271	USBFilterSetStringExact (&dev, USBFILTERIDX_PRODUCT_STR, Utf8Str(product), true);
1272
1273	Bstr serialNumber;
1274	rc = aUSBDevice->COMGETTER(SerialNumber) (serialNumber.asOutParam());
1275	ComAssertComRCRet (rc, false);
1276	if (!serialNumber.isNull())
1277	USBFilterSetStringExact (&dev, USBFILTERIDX_SERIAL_NUMBER_STR, Utf8Str(serialNumber), true);
1278
1279	Bstr address;
1280	rc = aUSBDevice->COMGETTER(Address) (address.asOutParam());
1281	ComAssertComRCRet (rc, false);
1282
1283	USHORT port = 0;
1284	rc = aUSBDevice->COMGETTER(Port)(&port);
1285	ComAssertComRCRet (rc, false);
1286	USBFilterSetNumExact (&dev, USBFILTERIDX_PORT, port, true);
1287
1288	BOOL remote = FALSE;
1289	rc = aUSBDevice->COMGETTER(Remote)(&remote);
1290	ComAssertComRCRet (rc, false);
1291	ComAssertRet (remote == TRUE, false);
1292
1293	bool match = false;
1294
1295	/* apply self filters */
1296	for (DeviceFilterList::const_iterator it = mDeviceFilters->begin();
1297	it != mDeviceFilters->end();
1298	++ it)
1299	{
1300	AutoWriteLock filterLock (*it);
1301	const USBDeviceFilter::Data &aData = (*it)->data();
1302
1303	if (!aData.mActive)
1304	continue;
1305	if (!aData.mRemote.isMatch (remote))
1306	continue;
1307	if (!USBFilterMatch (&aData.mUSBFilter, &dev))
1308	continue;
1309
1310	match = true;
1311	*aMaskedIfs = aData.mMaskedIfs;
1312	break;
1313	}
1314
1315	LogFlowThisFunc (("returns: %d\n", match));
1316	LogFlowThisFuncLeave();
1317
1318	return match;
1319	}
1320
1321	/**
1322	* Notifies the proxy service about all filters as requested by the
1323	* @a aInsertFilters argument.
1324	*
1325	* @param aInsertFilters @c true to insert filters, @c false to remove.
1326	*
1327	* @note Locks this object for reading.
1328	*/
1329	HRESULT USBController::notifyProxy (bool aInsertFilters)
1330	{
1331	LogFlowThisFunc (("aInsertFilters=%RTbool\n", aInsertFilters));
1332
1333	AutoCaller autoCaller (this);
1334	AssertComRCReturn (autoCaller.rc(), false);
1335
1336	AutoReadLock alock (this);
1337
1338	USBProxyService *service = mParent->virtualBox()->host()->usbProxyService();
1339	AssertReturn (service, E_FAIL);
1340
1341	DeviceFilterList::const_iterator it = mDeviceFilters->begin();
1342	while (it != mDeviceFilters->end())
1343	{
1344	USBDeviceFilter flt = it; /* resolve ambiguity (for ComPtr below) */
1345
1346	/* notify the proxy (only if the filter is active) */
1347	if (flt->data().mActive)
1348	{
1349	if (aInsertFilters)
1350	{
1351	AssertReturn (flt->id() == NULL, E_FAIL);
1352	flt->id() = service->insertFilter (&flt->data().mUSBFilter);
1353	}
1354	else
1355	{
1356	/* It's possible that the given filter was not inserted the proxy
1357	* when this method gets called (as a result of an early VM
1358	* process crash for example. So, don't assert that ID != NULL. */
1359	if (flt->id() != NULL)
1360	{
1361	service->removeFilter (flt->id());
1362	flt->id() = NULL;
1363	}
1364	}
1365	}
1366	++ it;
1367	}
1368
1369	return S_OK;
1370	}
1371
1372	#endif /* VBOX_WITH_USB */
1373
1374	// private methods
1375	/////////////////////////////////////////////////////////////////////////////
1376

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Main/USBControllerImpl.cpp@ 13079

Download in other formats: