USBControllerImpl.cpp@ 8956

Last change on this file since 8956 was 8155, checked in by vboxsync, 17 years ago
The Big Sun Rebranding Header Change
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 38.8 KB

Line
1	/* $Id: USBControllerImpl.cpp 8155 2008-04-18 15:16:47Z 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 : public VirtualBoxBaseNEXT, public IUSBDeviceFilter
321	{
322	public:
323	DECLARE_NOT_AGGREGATABLE(USBDeviceFilter)
324	DECLARE_PROTECT_FINAL_CONSTRUCT()
325	BEGIN_COM_MAP(USBDeviceFilter)
326	COM_INTERFACE_ENTRY(ISupportErrorInfo)
327	COM_INTERFACE_ENTRY(IUSBDeviceFilter)
328	END_COM_MAP()
329
330	NS_DECL_ISUPPORTS
331
332	DECLARE_EMPTY_CTOR_DTOR (USBDeviceFilter)
333
334	// IUSBDeviceFilter properties
335	STDMETHOD(COMGETTER(Name)) (BSTR *aName);
336	STDMETHOD(COMSETTER(Name)) (INPTR BSTR aName);
337	STDMETHOD(COMGETTER(Active)) (BOOL *aActive);
338	STDMETHOD(COMSETTER(Active)) (BOOL aActive);
339	STDMETHOD(COMGETTER(VendorId)) (BSTR *aVendorId);
340	STDMETHOD(COMSETTER(VendorId)) (INPTR BSTR aVendorId);
341	STDMETHOD(COMGETTER(ProductId)) (BSTR *aProductId);
342	STDMETHOD(COMSETTER(ProductId)) (INPTR BSTR aProductId);
343	STDMETHOD(COMGETTER(Revision)) (BSTR *aRevision);
344	STDMETHOD(COMSETTER(Revision)) (INPTR BSTR aRevision);
345	STDMETHOD(COMGETTER(Manufacturer)) (BSTR *aManufacturer);
346	STDMETHOD(COMSETTER(Manufacturer)) (INPTR BSTR aManufacturer);
347	STDMETHOD(COMGETTER(Product)) (BSTR *aProduct);
348	STDMETHOD(COMSETTER(Product)) (INPTR BSTR aProduct);
349	STDMETHOD(COMGETTER(SerialNumber)) (BSTR *aSerialNumber);
350	STDMETHOD(COMSETTER(SerialNumber)) (INPTR BSTR aSerialNumber);
351	STDMETHOD(COMGETTER(Port)) (BSTR *aPort);
352	STDMETHOD(COMSETTER(Port)) (INPTR BSTR aPort);
353	STDMETHOD(COMGETTER(Remote)) (BSTR *aRemote);
354	STDMETHOD(COMSETTER(Remote)) (INPTR BSTR aRemote);
355	STDMETHOD(COMGETTER(MaskedInterfaces)) (ULONG *aMaskedIfs);
356	STDMETHOD(COMSETTER(MaskedInterfaces)) (ULONG aMaskedIfs);
357	};
358	COM_DECL_READONLY_ENUM_AND_COLLECTION (USBDeviceFilter);
359	COM_IMPL_READONLY_ENUM_AND_COLLECTION (USBDeviceFilter);
360	#endif /* !VBOX_WITH_USB */
361
362
363	STDMETHODIMP USBController::COMGETTER(DeviceFilters) (IUSBDeviceFilterCollection **aDevicesFilters)
364	{
365	if (!aDevicesFilters)
366	return E_POINTER;
367
368	AutoCaller autoCaller (this);
369	CheckComRCReturnRC (autoCaller.rc());
370
371	AutoReadLock alock (this);
372
373	ComObjPtr <USBDeviceFilterCollection> collection;
374	collection.createObject();
375	#ifdef VBOX_WITH_USB
376	collection->init (*mDeviceFilters.data());
377	#endif
378	collection.queryInterfaceTo (aDevicesFilters);
379
380	return S_OK;
381	}
382
383	// IUSBController methods
384	/////////////////////////////////////////////////////////////////////////////
385
386	STDMETHODIMP USBController::CreateDeviceFilter (INPTR BSTR aName,
387	IUSBDeviceFilter **aFilter)
388	{
389	#ifdef VBOX_WITH_USB
390	if (!aFilter)
391	return E_POINTER;
392
393	if (!aName \|\| *aName == 0)
394	return E_INVALIDARG;
395
396	AutoCaller autoCaller (this);
397	CheckComRCReturnRC (autoCaller.rc());
398
399	/* the machine needs to be mutable */
400	Machine::AutoMutableStateDependency adep (mParent);
401	CheckComRCReturnRC (adep.rc());
402
403	AutoWriteLock alock (this);
404
405	ComObjPtr <USBDeviceFilter> filter;
406	filter.createObject();
407	HRESULT rc = filter->init (this, aName);
408	ComAssertComRCRetRC (rc);
409	rc = filter.queryInterfaceTo (aFilter);
410	AssertComRCReturnRC (rc);
411
412	return S_OK;
413	#else
414	return E_NOTIMPL;
415	#endif
416	}
417
418	STDMETHODIMP USBController::InsertDeviceFilter (ULONG aPosition,
419	IUSBDeviceFilter *aFilter)
420	{
421	#ifdef VBOX_WITH_USB
422	if (!aFilter)
423	return E_INVALIDARG;
424
425	AutoCaller autoCaller (this);
426	CheckComRCReturnRC (autoCaller.rc());
427
428	/* the machine needs to be mutable */
429	Machine::AutoMutableStateDependency adep (mParent);
430	CheckComRCReturnRC (adep.rc());
431
432	AutoWriteLock alock (this);
433
434	ComObjPtr <USBDeviceFilter> filter = getDependentChild (aFilter);
435	if (!filter)
436	return setError (E_INVALIDARG,
437	tr ("The given USB device filter is not created within "
438	"this VirtualBox instance"));
439
440	if (filter->mInList)
441	return setError (E_INVALIDARG,
442	tr ("The given USB device filter is already in the list"));
443
444	/* backup the list before modification */
445	mDeviceFilters.backup();
446
447	/* iterate to the position... */
448	DeviceFilterList::iterator it;
449	if (aPosition < mDeviceFilters->size())
450	{
451	it = mDeviceFilters->begin();
452	std::advance (it, aPosition);
453	}
454	else
455	it = mDeviceFilters->end();
456	/* ...and insert */
457	mDeviceFilters->insert (it, filter);
458	filter->mInList = true;
459
460	/// @todo After rewriting Win32 USB support, no more necessary;
461	// a candidate for removal.
462	#if 0
463	/* notify the proxy (only when the filter is active) */
464	if (filter->data().mActive)
465	#else
466	/* notify the proxy (only when it makes sense) */
467	if (filter->data().mActive && adep.machineState() >= MachineState_Running)
468	#endif
469	{
470	USBProxyService *service = mParent->virtualBox()->host()->usbProxyService();
471	ComAssertRet (service, E_FAIL);
472
473	ComAssertRet (filter->id() == NULL, E_FAIL);
474	filter->id() = service->insertFilter (&filter->data().mUSBFilter);
475	}
476
477	return S_OK;
478	#else
479	return E_NOTIMPL;
480	#endif
481	}
482
483	STDMETHODIMP USBController::RemoveDeviceFilter (ULONG aPosition,
484	IUSBDeviceFilter **aFilter)
485	{
486	#ifdef VBOX_WITH_USB
487	if (!aFilter)
488	return E_POINTER;
489
490	AutoCaller autoCaller (this);
491	CheckComRCReturnRC (autoCaller.rc());
492
493	/* the machine needs to be mutable */
494	Machine::AutoMutableStateDependency adep (mParent);
495	CheckComRCReturnRC (adep.rc());
496
497	AutoWriteLock alock (this);
498
499	if (!mDeviceFilters->size())
500	return setError (E_INVALIDARG,
501	tr ("The USB device filter list is empty"));
502
503	if (aPosition >= mDeviceFilters->size())
504	return setError (E_INVALIDARG,
505	tr ("Invalid position: %lu (must be in range [0, %lu])"),
506	aPosition, mDeviceFilters->size() - 1);
507
508	/* backup the list before modification */
509	mDeviceFilters.backup();
510
511	ComObjPtr <USBDeviceFilter> filter;
512	{
513	/* iterate to the position... */
514	DeviceFilterList::iterator it = mDeviceFilters->begin();
515	std::advance (it, aPosition);
516	/* ...get an element from there... */
517	filter = *it;
518	/* ...and remove */
519	filter->mInList = false;
520	mDeviceFilters->erase (it);
521	}
522
523	/* cancel sharing (make an independent copy of data) */
524	filter->unshare();
525
526	filter.queryInterfaceTo (aFilter);
527
528	/// @todo After rewriting Win32 USB support, no more necessary;
529	// a candidate for removal.
530	#if 0
531	/* notify the proxy (only when the filter is active) */
532	if (filter->data().mActive)
533	#else
534	/* notify the proxy (only when it makes sense) */
535	if (filter->data().mActive && adep.machineState() >= MachineState_Running)
536	#endif
537	{
538	USBProxyService *service = mParent->virtualBox()->host()->usbProxyService();
539	ComAssertRet (service, E_FAIL);
540
541	ComAssertRet (filter->id() != NULL, E_FAIL);
542	service->removeFilter (filter->id());
543	filter->id() = NULL;
544	}
545
546	return S_OK;
547	#else
548	return E_NOTIMPL;
549	#endif
550	}
551
552	// public methods only for internal purposes
553	/////////////////////////////////////////////////////////////////////////////
554
555	/**
556	* Loads settings from the given machine node.
557	* May be called once right after this object creation.
558	*
559	* @param aMachineNode <Machine> node.
560	*
561	* @note Locks this object for writing.
562	*/
563	HRESULT USBController::loadSettings (const settings::Key &aMachineNode)
564	{
565	using namespace settings;
566
567	AssertReturn (!aMachineNode.isNull(), E_FAIL);
568
569	AutoCaller autoCaller (this);
570	AssertComRCReturnRC (autoCaller.rc());
571
572	AutoWriteLock alock (this);
573
574	/* Note: we assume that the default values for attributes of optional
575	* nodes are assigned in the Data::Data() constructor and don't do it
576	* here. It implies that this method may only be called after constructing
577	* a new BIOSSettings object while all its data fields are in the default
578	* values. Exceptions are fields whose creation time defaults don't match
579	* values that should be applied when these fields are not explicitly set
580	* in the settings file (for backwards compatibility reasons). This takes
581	* place when a setting of a newly created object must default to A while
582	* the same setting of an object loaded from the old settings file must
583	* default to B. */
584
585	/* USB Controller node (required) */
586	Key controller = aMachineNode.key ("USBController");
587
588	/* enabled (required) */
589	mData->mEnabled = controller.value <bool> ("enabled");
590
591	/* enabledEhci (optiona, defaults to false) */
592	mData->mEnabledEhci = controller.value <bool> ("enabledEhci");
593
594	#ifdef VBOX_WITH_USB
595	HRESULT rc = S_OK;
596
597	Key::List children = controller.keys ("DeviceFilter");
598	for (Key::List::const_iterator it = children.begin();
599	it != children.end(); ++ it)
600	{
601	/* required */
602	Bstr name = (*it).stringValue ("name");
603	bool active = (*it).value <bool> ("active");
604
605	/* optional */
606	Bstr vendorId = (*it).stringValue ("vendorId");
607	Bstr productId = (*it).stringValue ("productId");
608	Bstr revision = (*it).stringValue ("revision");
609	Bstr manufacturer = (*it).stringValue ("manufacturer");
610	Bstr product = (*it).stringValue ("product");
611	Bstr serialNumber = (*it).stringValue ("serialNumber");
612	Bstr port = (*it).stringValue ("port");
613	Bstr remote = (*it).stringValue ("remote");
614	ULONG maskedIfs = (*it).value <ULONG> ("maskedInterfaces");
615
616	ComObjPtr <USBDeviceFilter> filterObj;
617	filterObj.createObject();
618	rc = filterObj->init (this,
619	name, active, vendorId, productId, revision,
620	manufacturer, product, serialNumber,
621	port, remote, maskedIfs);
622	/* error info is set by init() when appropriate */
623	CheckComRCReturnRC (rc);
624
625	mDeviceFilters->push_back (filterObj);
626	filterObj->mInList = true;
627	}
628	#endif /* VBOX_WITH_USB */
629
630	return S_OK;
631	}
632
633	/**
634	* Saves settings to the given machine node.
635	*
636	* @param aMachineNode <Machine> node.
637	*
638	* @note Locks this object for reading.
639	*/
640	HRESULT USBController::saveSettings (settings::Key &aMachineNode)
641	{
642	using namespace settings;
643
644	AssertReturn (!aMachineNode.isNull(), E_FAIL);
645
646	AutoCaller autoCaller (this);
647	CheckComRCReturnRC (autoCaller.rc());
648
649	AutoReadLock alock (this);
650
651	/* first, delete the entry */
652	Key controller = aMachineNode.findKey ("USBController");
653	#ifdef VBOX_WITH_USB
654	if (!controller.isNull())
655	controller.zap();
656	/* then, recreate it */
657	controller = aMachineNode.createKey ("USBController");
658	#else
659	/* don't zap it. */
660	if (controller.isNull())
661	controller = aMachineNode.createKey ("USBController");
662	#endif
663
664	/* enabled */
665	controller.setValue <bool> ("enabled", !!mData->mEnabled);
666
667	/* enabledEhci */
668	controller.setValue <bool> ("enabledEhci", !!mData->mEnabledEhci);
669
670	#ifdef VBOX_WITH_USB
671	DeviceFilterList::const_iterator it = mDeviceFilters->begin();
672	while (it != mDeviceFilters->end())
673	{
674	AutoWriteLock filterLock (*it);
675	const USBDeviceFilter::Data &data = (*it)->data();
676
677	Key filter = controller.appendKey ("DeviceFilter");
678
679	filter.setValue <Bstr> ("name", data.mName);
680	filter.setValue <bool> ("active", !!data.mActive);
681
682	/* all are optional */
683	Bstr str;
684	(*it)->COMGETTER (VendorId) (str.asOutParam());
685	if (!str.isNull())
686	filter.setValue <Bstr> ("vendorId", str);
687
688	(*it)->COMGETTER (ProductId) (str.asOutParam());
689	if (!str.isNull())
690	filter.setValue <Bstr> ("productId", str);
691
692	(*it)->COMGETTER (Revision) (str.asOutParam());
693	if (!str.isNull())
694	filter.setValue <Bstr> ("revision", str);
695
696	(*it)->COMGETTER (Manufacturer) (str.asOutParam());
697	if (!str.isNull())
698	filter.setValue <Bstr> ("manufacturer", str);
699
700	(*it)->COMGETTER (Product) (str.asOutParam());
701	if (!str.isNull())
702	filter.setValue <Bstr> ("product", str);
703
704	(*it)->COMGETTER (SerialNumber) (str.asOutParam());
705	if (!str.isNull())
706	filter.setValue <Bstr> ("serialNumber", str);
707
708	(*it)->COMGETTER (Port) (str.asOutParam());
709	if (!str.isNull())
710	filter.setValue <Bstr> ("port", str);
711
712	if (data.mRemote.string())
713	filter.setValue <Bstr> ("remote", data.mRemote.string());
714
715	if (data.mMaskedIfs)
716	filter.setValue <ULONG> ("maskedInterfaces", data.mMaskedIfs);
717
718	++ it;
719	}
720	#endif /* VBOX_WITH_USB */
721
722	return S_OK;
723	}
724
725	/** @note Locks objects for reading! */
726	bool USBController::isModified()
727	{
728	AutoCaller autoCaller (this);
729	AssertComRCReturn (autoCaller.rc(), false);
730
731	AutoReadLock alock (this);
732
733	if (mData.isBackedUp()
734	#ifdef VBOX_WITH_USB
735	\|\| mDeviceFilters.isBackedUp()
736	#endif
737	)
738	return true;
739
740	#ifdef VBOX_WITH_USB
741	/* see whether any of filters has changed its data */
742	for (DeviceFilterList::const_iterator
743	it = mDeviceFilters->begin();
744	it != mDeviceFilters->end();
745	++ it)
746	{
747	if ((*it)->isModified())
748	return true;
749	}
750	#endif /* VBOX_WITH_USB */
751
752	return false;
753	}
754
755	/** @note Locks objects for reading! */
756	bool USBController::isReallyModified()
757	{
758	AutoCaller autoCaller (this);
759	AssertComRCReturn (autoCaller.rc(), false);
760
761	AutoReadLock alock (this);
762
763	if (mData.hasActualChanges())
764	return true;
765
766	#ifdef VBOX_WITH_USB
767	if (!mDeviceFilters.isBackedUp())
768	{
769	/* see whether any of filters has changed its data */
770	for (DeviceFilterList::const_iterator
771	it = mDeviceFilters->begin();
772	it != mDeviceFilters->end();
773	++ it)
774	{
775	if ((*it)->isReallyModified())
776	return true;
777	}
778
779	return false;
780	}
781
782	if (mDeviceFilters->size() != mDeviceFilters.backedUpData()->size())
783	return true;
784
785	if (mDeviceFilters->size() == 0)
786	return false;
787
788	/* Make copies to speed up comparison */
789	DeviceFilterList devices = *mDeviceFilters.data();
790	DeviceFilterList backDevices = *mDeviceFilters.backedUpData();
791
792	DeviceFilterList::iterator it = devices.begin();
793	while (it != devices.end())
794	{
795	bool found = false;
796	DeviceFilterList::iterator thatIt = backDevices.begin();
797	while (thatIt != backDevices.end())
798	{
799	if ((it)->data() == (thatIt)->data())
800	{
801	backDevices.erase (thatIt);
802	found = true;
803	break;
804	}
805	else
806	++ thatIt;
807	}
808	if (found)
809	it = devices.erase (it);
810	else
811	return false;
812	}
813
814	Assert (devices.size() == 0 && backDevices.size() == 0);
815	#endif /* VBOX_WITH_USB */
816
817	return false;
818	}
819
820	/** @note Locks objects for writing! */
821	bool USBController::rollback()
822	{
823	AutoCaller autoCaller (this);
824	AssertComRCReturn (autoCaller.rc(), false);
825
826	/* we need the machine state */
827	Machine::AutoAnyStateDependency adep (mParent);
828	AssertComRCReturn (adep.rc(), false);
829
830	AutoWriteLock alock (this);
831
832	bool dataChanged = false;
833
834	if (mData.isBackedUp())
835	{
836	/* we need to check all data to see whether anything will be changed
837	* after rollback */
838	dataChanged = mData.hasActualChanges();
839	mData.rollback();
840	}
841
842	#ifdef VBOX_WITH_USB
843	if (mDeviceFilters.isBackedUp())
844	{
845	USBProxyService *service = mParent->virtualBox()->host()->usbProxyService();
846	ComAssertRet (service, false);
847
848	/* uninitialize all new filters (absent in the backed up list) */
849	DeviceFilterList::const_iterator it = mDeviceFilters->begin();
850	DeviceFilterList *backedList = mDeviceFilters.backedUpData();
851	while (it != mDeviceFilters->end())
852	{
853	if (std::find (backedList->begin(), backedList->end(), *it) ==
854	backedList->end())
855	{
856	/// @todo After rewriting Win32 USB support, no more necessary;
857	// a candidate for removal.
858	#if 0
859	/* notify the proxy (only when the filter is active) */
860	if ((*it)->data().mActive)
861	#else
862	/* notify the proxy (only when it makes sense) */
863	if ((*it)->data().mActive &&
864	adep.machineState() >= MachineState_Running)
865	#endif
866	{
867	USBDeviceFilter filter = it;
868	ComAssertRet (filter->id() != NULL, false);
869	service->removeFilter (filter->id());
870	filter->id() = NULL;
871	}
872
873	(*it)->uninit();
874	}
875	++ it;
876	}
877
878	/// @todo After rewriting Win32 USB support, no more necessary;
879	// a candidate for removal.
880	#if 0
881	#else
882	if (adep.machineState() >= MachineState_Running)
883	#endif
884	{
885	/* find all removed old filters (absent in the new list)
886	* and insert them back to the USB proxy */
887	it = backedList->begin();
888	while (it != backedList->end())
889	{
890	if (std::find (mDeviceFilters->begin(), mDeviceFilters->end(), *it) ==
891	mDeviceFilters->end())
892	{
893	/* notify the proxy (only when necessary) */
894	if ((*it)->data().mActive)
895	{
896	USBDeviceFilter flt = it; /* resolve ambiguity */
897	ComAssertRet (flt->id() == NULL, false);
898	flt->id() = service->insertFilter (&flt->data().mUSBFilter);
899	}
900	}
901	++ it;
902	}
903	}
904
905	/* restore the list */
906	mDeviceFilters.rollback();
907	}
908
909	/* here we don't depend on the machine state any more */
910	adep.release();
911
912	/* rollback any changes to filters after restoring the list */
913	DeviceFilterList::const_iterator it = mDeviceFilters->begin();
914	while (it != mDeviceFilters->end())
915	{
916	if ((*it)->isModified())
917	{
918	(*it)->rollback();
919	/* call this to notify the USB proxy about changes */
920	onDeviceFilterChange (*it);
921	}
922	++ it;
923	}
924	#endif /* VBOX_WITH_USB */
925
926	return dataChanged;
927	}
928
929	/**
930	* @note Locks this object for writing, together with the peer object (also
931	* for writing) if there is one.
932	*/
933	void USBController::commit()
934	{
935	/* sanity */
936	AutoCaller autoCaller (this);
937	AssertComRCReturnVoid (autoCaller.rc());
938
939	/* sanity too */
940	AutoCaller peerCaller (mPeer);
941	AssertComRCReturnVoid (peerCaller.rc());
942
943	/* lock both for writing since we modify both (mPeer is "master" so locked
944	* first) */
945	AutoMultiWriteLock2 alock (mPeer, this);
946
947	if (mData.isBackedUp())
948	{
949	mData.commit();
950	if (mPeer)
951	{
952	/* attach new data to the peer and reshare it */
953	AutoWriteLock peerlock (mPeer);
954	mPeer->mData.attach (mData);
955	}
956	}
957
958	#ifdef VBOX_WITH_USB
959	bool commitFilters = false;
960
961	if (mDeviceFilters.isBackedUp())
962	{
963	mDeviceFilters.commit();
964
965	/* apply changes to peer */
966	if (mPeer)
967	{
968	AutoWriteLock peerlock (mPeer);
969	/* commit all changes to new filters (this will reshare data with
970	* peers for those who have peers) */
971	DeviceFilterList *newList = new DeviceFilterList();
972	DeviceFilterList::const_iterator it = mDeviceFilters->begin();
973	while (it != mDeviceFilters->end())
974	{
975	(*it)->commit();
976
977	/* look if this filter has a peer filter */
978	ComObjPtr <USBDeviceFilter> peer = (*it)->peer();
979	if (!peer)
980	{
981	/* no peer means the filter is a newly created one;
982	* create a peer owning data this filter share it with */
983	peer.createObject();
984	peer->init (mPeer, it, true / aReshare */);
985	}
986	else
987	{
988	/* remove peer from the old list */
989	mPeer->mDeviceFilters->remove (peer);
990	}
991	/* and add it to the new list */
992	newList->push_back (peer);
993
994	++ it;
995	}
996
997	/* uninit old peer's filters that are left */
998	it = mPeer->mDeviceFilters->begin();
999	while (it != mPeer->mDeviceFilters->end())
1000	{
1001	(*it)->uninit();
1002	++ it;
1003	}
1004
1005	/* attach new list of filters to our peer */
1006	mPeer->mDeviceFilters.attach (newList);
1007	}
1008	else
1009	{
1010	/* we have no peer (our parent is the newly created machine);
1011	* just commit changes to filters */
1012	commitFilters = true;
1013	}
1014	}
1015	else
1016	{
1017	/* the list of filters itself is not changed,
1018	* just commit changes to filters themselves */
1019	commitFilters = true;
1020	}
1021
1022	if (commitFilters)
1023	{
1024	DeviceFilterList::const_iterator it = mDeviceFilters->begin();
1025	while (it != mDeviceFilters->end())
1026	{
1027	(*it)->commit();
1028	++ it;
1029	}
1030	}
1031	#endif /* VBOX_WITH_USB */
1032	}
1033
1034	/**
1035	* @note Locks this object for writing, together with the peer object
1036	* represented by @a aThat (locked for reading).
1037	*/
1038	void USBController::copyFrom (USBController *aThat)
1039	{
1040	AssertReturnVoid (aThat != NULL);
1041
1042	/* sanity */
1043	AutoCaller autoCaller (this);
1044	AssertComRCReturnVoid (autoCaller.rc());
1045
1046	/* sanity too */
1047	AutoCaller thatCaller (aThat);
1048	AssertComRCReturnVoid (thatCaller.rc());
1049
1050	/* peer is not modified, lock it for reading (aThat is "master" so locked
1051	* first) */
1052	AutoMultiLock2 alock (aThat->rlock(), this->wlock());
1053
1054	if (mParent->isRegistered())
1055	{
1056	/* reuse onMachineRegistered to tell USB proxy to remove all current
1057	filters */
1058	HRESULT rc = onMachineRegistered (FALSE);
1059	AssertComRCReturn (rc, (void) 0);
1060	}
1061
1062	/* this will back up current data */
1063	mData.assignCopy (aThat->mData);
1064
1065	#ifdef VBOX_WITH_USB
1066	/* create private copies of all filters */
1067	mDeviceFilters.backup();
1068	mDeviceFilters->clear();
1069	for (DeviceFilterList::const_iterator it = aThat->mDeviceFilters->begin();
1070	it != aThat->mDeviceFilters->end();
1071	++ it)
1072	{
1073	ComObjPtr <USBDeviceFilter> filter;
1074	filter.createObject();
1075	filter->initCopy (this, *it);
1076	mDeviceFilters->push_back (filter);
1077	}
1078	#endif /* VBOX_WITH_USB */
1079
1080	if (mParent->isRegistered())
1081	{
1082	/* reuse onMachineRegistered to tell USB proxy to insert all current
1083	filters */
1084	HRESULT rc = onMachineRegistered (TRUE);
1085	AssertComRCReturn (rc, (void) 0);
1086	}
1087	}
1088
1089	/**
1090	* Called by VirtualBox when it changes the registered state
1091	* of the machine this USB controller belongs to.
1092	*
1093	* @param aRegistered new registered state of the machine
1094	*
1095	* @note Locks nothing.
1096	*/
1097	HRESULT USBController::onMachineRegistered (BOOL aRegistered)
1098	{
1099	AutoCaller autoCaller (this);
1100	AssertComRCReturnRC (autoCaller.rc());
1101
1102	/// @todo After rewriting Win32 USB support, no more necessary;
1103	// a candidate for removal.
1104	#if 0
1105	notifyProxy (!!aRegistered);
1106	#endif
1107
1108	return S_OK;
1109	}
1110
1111	#ifdef VBOX_WITH_USB
1112
1113	/**
1114	* Called by setter methods of all USB device filters.
1115	*
1116	* @note Locks nothing.
1117	*/
1118	HRESULT USBController::onDeviceFilterChange (USBDeviceFilter *aFilter,
1119	BOOL aActiveChanged /* = FALSE */)
1120	{
1121	AutoCaller autoCaller (this);
1122	AssertComRCReturnRC (autoCaller.rc());
1123
1124	/// @todo After rewriting Win32 USB support, no more necessary;
1125	// a candidate for removal.
1126	#if 0
1127	#else
1128	/* we need the machine state */
1129	Machine::AutoAnyStateDependency adep (mParent);
1130	AssertComRCReturnRC (adep.rc());
1131
1132	/* nothing to do if the machine isn't running */
1133	if (adep.machineState() < MachineState_Running)
1134	return S_OK;
1135	#endif
1136
1137	/* we don't modify our data fields -- no need to lock */
1138
1139	if (aFilter->mInList && mParent->isRegistered())
1140	{
1141	USBProxyService *service = mParent->virtualBox()->host()->usbProxyService();
1142	ComAssertRet (service, E_FAIL);
1143
1144	if (aActiveChanged)
1145	{
1146	/* insert/remove the filter from the proxy */
1147	if (aFilter->data().mActive)
1148	{
1149	ComAssertRet (aFilter->id() == NULL, E_FAIL);
1150	aFilter->id() = service->insertFilter (&aFilter->data().mUSBFilter);
1151	}
1152	else
1153	{
1154	ComAssertRet (aFilter->id() != NULL, E_FAIL);
1155	service->removeFilter (aFilter->id());
1156	aFilter->id() = NULL;
1157	}
1158	}
1159	else
1160	{
1161	if (aFilter->data().mActive)
1162	{
1163	/* update the filter in the proxy */
1164	ComAssertRet (aFilter->id() != NULL, E_FAIL);
1165	service->removeFilter (aFilter->id());
1166	aFilter->id() = service->insertFilter (&aFilter->data().mUSBFilter);
1167	}
1168	}
1169	}
1170
1171	return S_OK;
1172	}
1173
1174	/**
1175	* Returns true if the given USB device matches to at least one of
1176	* this controller's USB device filters.
1177	*
1178	* A HostUSBDevice specific version.
1179	*
1180	* @note Locks this object for reading.
1181	*/
1182	bool USBController::hasMatchingFilter (const ComObjPtr <HostUSBDevice> &aDevice, ULONG *aMaskedIfs)
1183	{
1184	AutoCaller autoCaller (this);
1185	AssertComRCReturn (autoCaller.rc(), false);
1186
1187	AutoReadLock alock (this);
1188
1189	/* Disabled USB controllers cannot actually work with USB devices */
1190	if (!mData->mEnabled)
1191	return false;
1192
1193	/* apply self filters */
1194	for (DeviceFilterList::const_iterator it = mDeviceFilters->begin();
1195	it != mDeviceFilters->end();
1196	++ it)
1197	{
1198	AutoWriteLock filterLock (*it);
1199	if (aDevice->isMatch ((*it)->data()))
1200	{
1201	aMaskedIfs = (it)->data().mMaskedIfs;
1202	return true;
1203	}
1204	}
1205
1206	return false;
1207	}
1208
1209	/**
1210	* Returns true if the given USB device matches to at least one of
1211	* this controller's USB device filters.
1212	*
1213	* A generic version that accepts any IUSBDevice on input.
1214	*
1215	* @note
1216	* This method MUST correlate with HostUSBDevice::isMatch()
1217	* in the sense of the device matching logic.
1218	*
1219	* @note Locks this object for reading.
1220	*/
1221	bool USBController::hasMatchingFilter (IUSBDevice aUSBDevice, ULONG aMaskedIfs)
1222	{
1223	LogFlowThisFuncEnter();
1224
1225	AutoCaller autoCaller (this);
1226	AssertComRCReturn (autoCaller.rc(), false);
1227
1228	AutoReadLock alock (this);
1229
1230	/* Disabled USB controllers cannot actually work with USB devices */
1231	if (!mData->mEnabled)
1232	return false;
1233
1234	HRESULT rc = S_OK;
1235
1236	/* query fields */
1237	USBFILTER dev;
1238	USBFilterInit (&dev, USBFILTERTYPE_CAPTURE);
1239
1240	USHORT vendorId = 0;
1241	rc = aUSBDevice->COMGETTER(VendorId) (&vendorId);
1242	ComAssertComRCRet (rc, false);
1243	ComAssertRet (vendorId, false);
1244	int vrc = USBFilterSetNumExact (&dev, USBFILTERIDX_VENDOR_ID, vendorId, true); AssertRC(vrc);
1245
1246	USHORT productId = 0;
1247	rc = aUSBDevice->COMGETTER(ProductId) (&productId);
1248	ComAssertComRCRet (rc, false);
1249	ComAssertRet (productId, false);
1250	vrc = USBFilterSetNumExact (&dev, USBFILTERIDX_PRODUCT_ID, productId, true); AssertRC(vrc);
1251
1252	USHORT revision;
1253	rc = aUSBDevice->COMGETTER(Revision) (&revision);
1254	ComAssertComRCRet (rc, false);
1255	vrc = USBFilterSetNumExact (&dev, USBFILTERIDX_DEVICE, revision, true); AssertRC(vrc);
1256
1257	Bstr manufacturer;
1258	rc = aUSBDevice->COMGETTER(Manufacturer) (manufacturer.asOutParam());
1259	ComAssertComRCRet (rc, false);
1260	if (!manufacturer.isNull())
1261	USBFilterSetStringExact (&dev, USBFILTERIDX_MANUFACTURER_STR, Utf8Str(manufacturer), true);
1262
1263	Bstr product;
1264	rc = aUSBDevice->COMGETTER(Product) (product.asOutParam());
1265	ComAssertComRCRet (rc, false);
1266	if (!product.isNull())
1267	USBFilterSetStringExact (&dev, USBFILTERIDX_PRODUCT_STR, Utf8Str(product), true);
1268
1269	Bstr serialNumber;
1270	rc = aUSBDevice->COMGETTER(SerialNumber) (serialNumber.asOutParam());
1271	ComAssertComRCRet (rc, false);
1272	if (!serialNumber.isNull())
1273	USBFilterSetStringExact (&dev, USBFILTERIDX_SERIAL_NUMBER_STR, Utf8Str(serialNumber), true);
1274
1275	Bstr address;
1276	rc = aUSBDevice->COMGETTER(Address) (address.asOutParam());
1277	ComAssertComRCRet (rc, false);
1278
1279	USHORT port = 0;
1280	rc = aUSBDevice->COMGETTER(Port)(&port);
1281	ComAssertComRCRet (rc, false);
1282	USBFilterSetNumExact (&dev, USBFILTERIDX_PORT, port, true);
1283
1284	BOOL remote = FALSE;
1285	rc = aUSBDevice->COMGETTER(Remote)(&remote);
1286	ComAssertComRCRet (rc, false);
1287	ComAssertRet (remote == TRUE, false);
1288
1289	bool match = false;
1290
1291	/* apply self filters */
1292	for (DeviceFilterList::const_iterator it = mDeviceFilters->begin();
1293	it != mDeviceFilters->end();
1294	++ it)
1295	{
1296	AutoWriteLock filterLock (*it);
1297	const USBDeviceFilter::Data &aData = (*it)->data();
1298
1299	if (!aData.mActive)
1300	continue;
1301	if (!aData.mRemote.isMatch (remote))
1302	continue;
1303	if (!USBFilterMatch (&aData.mUSBFilter, &dev))
1304	continue;
1305
1306	match = true;
1307	*aMaskedIfs = aData.mMaskedIfs;
1308	break;
1309	}
1310
1311	LogFlowThisFunc (("returns: %d\n", match));
1312	LogFlowThisFuncLeave();
1313
1314	return match;
1315	}
1316
1317	/**
1318	* Notifies the proxy service about all filters as requested by the
1319	* @a aInsertFilters argument.
1320	*
1321	* @param aInsertFilters @c true to insert filters, @c false to remove.
1322	*
1323	* @note Locks this object for reading.
1324	*/
1325	HRESULT USBController::notifyProxy (bool aInsertFilters)
1326	{
1327	LogFlowThisFunc (("aInsertFilters=%RTbool\n", aInsertFilters));
1328
1329	AutoCaller autoCaller (this);
1330	AssertComRCReturn (autoCaller.rc(), false);
1331
1332	AutoReadLock alock (this);
1333
1334	USBProxyService *service = mParent->virtualBox()->host()->usbProxyService();
1335	AssertReturn (service, E_FAIL);
1336
1337	DeviceFilterList::const_iterator it = mDeviceFilters->begin();
1338	while (it != mDeviceFilters->end())
1339	{
1340	USBDeviceFilter flt = it; /* resolve ambiguity (for ComPtr below) */
1341
1342	/* notify the proxy (only if the filter is active) */
1343	if (flt->data().mActive)
1344	{
1345	if (aInsertFilters)
1346	{
1347	AssertReturn (flt->id() == NULL, E_FAIL);
1348	flt->id() = service->insertFilter (&flt->data().mUSBFilter);
1349	}
1350	else
1351	{
1352	/* It's possible that the given filter was not inserted the proxy
1353	* when this method gets called (as a result of an early VM
1354	* process crash for example. So, don't assert that ID != NULL. */
1355	if (flt->id() != NULL)
1356	{
1357	service->removeFilter (flt->id());
1358	flt->id() = NULL;
1359	}
1360	}
1361	}
1362	++ it;
1363	}
1364
1365	return S_OK;
1366	}
1367
1368	#endif /* VBOX_WITH_USB */
1369
1370	// private methods
1371	/////////////////////////////////////////////////////////////////////////////
1372

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

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

Download in other formats: