HostImpl.cpp@ 33595

Last change on this file since 33595 was 33590, checked in by vboxsync, 14 years ago
VRDE: removed VBOX_WITH_VRDP from source code, also some obsolete code removed.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 95.3 KB

Line
1	/* $Id: HostImpl.cpp 33590 2010-10-29 08:55:09Z vboxsync $ */
2	/** @file
3	* VirtualBox COM class implementation: Host
4	*/
5
6	/*
7	* Copyright (C) 2006-2010 Oracle Corporation
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
18	#define __STDC_LIMIT_MACROS
19	#define __STDC_CONSTANT_MACROS
20
21	// for some reason Windows burns in sdk\...\winsock.h if this isn't included first
22	#include "VBox/com/ptr.h"
23
24	#include "HostImpl.h"
25
26	#ifdef VBOX_WITH_USB
27	# include "HostUSBDeviceImpl.h"
28	# include "USBDeviceFilterImpl.h"
29	# include "USBProxyService.h"
30	#endif // VBOX_WITH_USB
31
32	#include "HostNetworkInterfaceImpl.h"
33	#include "MachineImpl.h"
34	#include "AutoCaller.h"
35	#include "Logging.h"
36	#include "Performance.h"
37
38	#include "MediumImpl.h"
39	#include "HostPower.h"
40
41	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_FREEBSD)
42	# include <HostHardwareLinux.h>
43	#endif
44
45	#ifdef VBOX_WITH_RESOURCE_USAGE_API
46	# include "PerformanceImpl.h"
47	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
48
49	#if defined(RT_OS_WINDOWS) && defined(VBOX_WITH_NETFLT)
50	# include <VBox/WinNetConfig.h>
51	#endif /* #if defined(RT_OS_WINDOWS) && defined(VBOX_WITH_NETFLT) */
52
53	#ifdef RT_OS_LINUX
54	# include <sys/ioctl.h>
55	# include <errno.h>
56	# include <net/if.h>
57	# include <net/if_arp.h>
58	#endif /* RT_OS_LINUX */
59
60	#ifdef RT_OS_SOLARIS
61	# include <fcntl.h>
62	# include <unistd.h>
63	# include <stropts.h>
64	# include <errno.h>
65	# include <limits.h>
66	# include <stdio.h>
67	# include <libdevinfo.h>
68	# include <sys/mkdev.h>
69	# include <sys/scsi/generic/inquiry.h>
70	# include <net/if.h>
71	# include <sys/socket.h>
72	# include <sys/sockio.h>
73	# include <net/if_arp.h>
74	# include <net/if.h>
75	# include <sys/types.h>
76	# include <sys/stat.h>
77	# include <sys/cdio.h>
78	# include <sys/dkio.h>
79	# include <sys/mnttab.h>
80	# include <sys/mntent.h>
81	/* Dynamic loading of libhal on Solaris hosts */
82	# ifdef VBOX_USE_LIBHAL
83	# include "vbox-libhal.h"
84	extern "C" char getfullrawname(char );
85	# endif
86	# include "solaris/DynLoadLibSolaris.h"
87
88	/**
89	* Solaris DVD drive list as returned by getDVDInfoFromDevTree().
90	*/
91	typedef struct SOLARISDVD
92	{
93	struct SOLARISDVD *pNext;
94	char szDescription[512];
95	char szRawDiskPath[PATH_MAX];
96	} SOLARISDVD;
97	/** Pointer to a Solaris DVD descriptor. */
98	typedef SOLARISDVD *PSOLARISDVD;
99
100	#endif /* RT_OS_SOLARIS */
101
102	#ifdef RT_OS_WINDOWS
103	# define _WIN32_DCOM
104	# include <windows.h>
105	# include <shellapi.h>
106	# define INITGUID
107	# include <guiddef.h>
108	# include <devguid.h>
109	# include <objbase.h>
110	//# include <setupapi.h>
111	# include <shlobj.h>
112	# include <cfgmgr32.h>
113
114	#endif /* RT_OS_WINDOWS */
115
116	#ifdef RT_OS_DARWIN
117	# include "darwin/iokit.h"
118	#endif
119
120	#ifdef VBOX_WITH_CROGL
121	extern bool is3DAccelerationSupported();
122	#endif /* VBOX_WITH_CROGL */
123
124	#include <iprt/asm-amd64-x86.h>
125	#include <iprt/string.h>
126	#include <iprt/mp.h>
127	#include <iprt/time.h>
128	#include <iprt/param.h>
129	#include <iprt/env.h>
130	#include <iprt/mem.h>
131	#include <iprt/system.h>
132	#ifdef RT_OS_SOLARIS
133	# include <iprt/path.h>
134	# include <iprt/ctype.h>
135	#endif
136	#ifdef VBOX_WITH_HOSTNETIF_API
137	# include "netif.h"
138	#endif
139
140	/* XXX Solaris: definitions in /usr/include/sys/regset.h clash with hwacc_svm.h */
141	#undef DS
142	#undef ES
143	#undef CS
144	#undef SS
145	#undef FS
146	#undef GS
147
148	#include <VBox/usb.h>
149	#include <VBox/x86.h>
150	#include <VBox/hwacc_svm.h>
151	#include <VBox/err.h>
152	#include <VBox/settings.h>
153	#include <VBox/sup.h>
154
155	#include "VBox/com/MultiResult.h"
156
157	#include <stdio.h>
158
159	#include <algorithm>
160
161	////////////////////////////////////////////////////////////////////////////////
162	//
163	// Host private data definition
164	//
165	////////////////////////////////////////////////////////////////////////////////
166
167	struct Host::Data
168	{
169	Data()
170	:
171	#ifdef VBOX_WITH_USB
172	usbListsLock(LOCKCLASS_USBLIST),
173	#endif
174	drivesLock(LOCKCLASS_LISTOFMEDIA),
175	fDVDDrivesListBuilt(false),
176	fFloppyDrivesListBuilt(false)
177	{};
178
179	VirtualBox *pParent;
180
181	#ifdef VBOX_WITH_USB
182	WriteLockHandle usbListsLock; // protects the below two lists
183
184	USBDeviceFilterList llChildren; // all USB device filters
185	USBDeviceFilterList llUSBDeviceFilters; // USB device filters in use by the USB proxy service
186
187	/** Pointer to the USBProxyService object. */
188	USBProxyService *pUSBProxyService;
189	#endif /* VBOX_WITH_USB */
190
191	// list of host drives; lazily created by getDVDDrives() and getFloppyDrives()
192	WriteLockHandle drivesLock; // protects the below two lists and the bools
193	MediaList llDVDDrives,
194	llFloppyDrives;
195	bool fDVDDrivesListBuilt,
196	fFloppyDrivesListBuilt;
197
198	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_FREEBSD)
199	/** Object with information about host drives */
200	VBoxMainDriveInfo hostDrives;
201	#endif
202	/* Features that can be queried with GetProcessorFeature */
203	BOOL fVTSupported,
204	fLongModeSupported,
205	fPAESupported,
206	fNestedPagingSupported;
207
208	/* 3D hardware acceleration supported? */
209	BOOL f3DAccelerationSupported;
210
211	HostPowerService *pHostPowerService;
212	};
213
214
215	////////////////////////////////////////////////////////////////////////////////
216	//
217	// Constructor / destructor
218	//
219	////////////////////////////////////////////////////////////////////////////////
220
221	HRESULT Host::FinalConstruct()
222	{
223	return S_OK;
224	}
225
226	void Host::FinalRelease()
227	{
228	uninit();
229	}
230
231	/**
232	* Initializes the host object.
233	*
234	* @param aParent VirtualBox parent object.
235	*/
236	HRESULT Host::init(VirtualBox *aParent)
237	{
238	LogFlowThisFunc(("aParent=%p\n", aParent));
239
240	/* Enclose the state transition NotReady->InInit->Ready */
241	AutoInitSpan autoInitSpan(this);
242	AssertReturn(autoInitSpan.isOk(), E_FAIL);
243
244	m = new Data();
245
246	m->pParent = aParent;
247
248	#ifdef VBOX_WITH_USB
249	/*
250	* Create and initialize the USB Proxy Service.
251	*/
252	# if defined (RT_OS_DARWIN)
253	m->pUSBProxyService = new USBProxyServiceDarwin(this);
254	# elif defined (RT_OS_LINUX)
255	m->pUSBProxyService = new USBProxyServiceLinux(this);
256	# elif defined (RT_OS_OS2)
257	m->pUSBProxyService = new USBProxyServiceOs2(this);
258	# elif defined (RT_OS_SOLARIS)
259	m->pUSBProxyService = new USBProxyServiceSolaris(this);
260	# elif defined (RT_OS_WINDOWS)
261	m->pUSBProxyService = new USBProxyServiceWindows(this);
262	# elif defined (RT_OS_FREEBSD)
263	m->pUSBProxyService = new USBProxyServiceFreeBSD(this);
264	# else
265	m->pUSBProxyService = new USBProxyService(this);
266	# endif
267	HRESULT hrc = m->pUSBProxyService->init();
268	AssertComRCReturn(hrc, hrc);
269	#endif /* VBOX_WITH_USB */
270
271	#ifdef VBOX_WITH_RESOURCE_USAGE_API
272	registerMetrics(aParent->performanceCollector());
273	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
274
275	#if defined (RT_OS_WINDOWS)
276	m->pHostPowerService = new HostPowerServiceWin(m->pParent);
277	#elif defined (RT_OS_DARWIN)
278	m->pHostPowerService = new HostPowerServiceDarwin(m->pParent);
279	#else
280	m->pHostPowerService = new HostPowerService(m->pParent);
281	#endif
282
283	/* Cache the features reported by GetProcessorFeature. */
284	m->fVTSupported = false;
285	m->fLongModeSupported = false;
286	m->fPAESupported = false;
287	m->fNestedPagingSupported = false;
288
289	if (ASMHasCpuId())
290	{
291	uint32_t u32FeaturesECX;
292	uint32_t u32Dummy;
293	uint32_t u32FeaturesEDX;
294	uint32_t u32VendorEBX, u32VendorECX, u32VendorEDX, u32AMDFeatureEDX, u32AMDFeatureECX;
295
296	ASMCpuId(0, &u32Dummy, &u32VendorEBX, &u32VendorECX, &u32VendorEDX);
297	ASMCpuId(1, &u32Dummy, &u32Dummy, &u32FeaturesECX, &u32FeaturesEDX);
298	/* Query AMD features. */
299	ASMCpuId(0x80000001, &u32Dummy, &u32Dummy, &u32AMDFeatureECX, &u32AMDFeatureEDX);
300
301	m->fLongModeSupported = !!(u32AMDFeatureEDX & X86_CPUID_AMD_FEATURE_EDX_LONG_MODE);
302	m->fPAESupported = !!(u32FeaturesEDX & X86_CPUID_FEATURE_EDX_PAE);
303
304	if ( u32VendorEBX == X86_CPUID_VENDOR_INTEL_EBX
305	&& u32VendorECX == X86_CPUID_VENDOR_INTEL_ECX
306	&& u32VendorEDX == X86_CPUID_VENDOR_INTEL_EDX
307	)
308	{
309	if ( (u32FeaturesECX & X86_CPUID_FEATURE_ECX_VMX)
310	&& (u32FeaturesEDX & X86_CPUID_FEATURE_EDX_MSR)
311	&& (u32FeaturesEDX & X86_CPUID_FEATURE_EDX_FXSR)
312	)
313	{
314	int rc = SUPR3QueryVTxSupported();
315	if (RT_SUCCESS(rc))
316	m->fVTSupported = true;
317	}
318	}
319	else
320	if ( u32VendorEBX == X86_CPUID_VENDOR_AMD_EBX
321	&& u32VendorECX == X86_CPUID_VENDOR_AMD_ECX
322	&& u32VendorEDX == X86_CPUID_VENDOR_AMD_EDX
323	)
324	{
325	if ( (u32AMDFeatureECX & X86_CPUID_AMD_FEATURE_ECX_SVM)
326	&& (u32FeaturesEDX & X86_CPUID_FEATURE_EDX_MSR)
327	&& (u32FeaturesEDX & X86_CPUID_FEATURE_EDX_FXSR)
328	)
329	{
330	uint32_t u32SVMFeatureEDX;
331
332	m->fVTSupported = true;
333
334	/* Query AMD features. */
335	ASMCpuId(0x8000000A, &u32Dummy, &u32Dummy, &u32Dummy, &u32SVMFeatureEDX);
336	if (u32SVMFeatureEDX & AMD_CPUID_SVM_FEATURE_EDX_NESTED_PAGING)
337	m->fNestedPagingSupported = true;
338	}
339	}
340	}
341
342	#if 0 /* needs testing */
343	if (m->fVTSupported)
344	{
345	uint32_t u32Caps = 0;
346
347	int rc = SUPR3QueryVTCaps(&u32Caps);
348	if (RT_SUCCESS(rc))
349	{
350	if (u32Caps & SUPVTCAPS_NESTED_PAGING)
351	m->fNestedPagingSupported = true;
352	}
353	/* else @todo; report BIOS trouble in some way. */
354	}
355	#endif
356
357	/* Test for 3D hardware acceleration support */
358	m->f3DAccelerationSupported = false;
359
360	#ifdef VBOX_WITH_CROGL
361	m->f3DAccelerationSupported = is3DAccelerationSupported();
362	#endif /* VBOX_WITH_CROGL */
363
364	/* Confirm a successful initialization */
365	autoInitSpan.setSucceeded();
366
367	return S_OK;
368	}
369
370	/**
371	* Uninitializes the host object and sets the ready flag to FALSE.
372	* Called either from FinalRelease() or by the parent when it gets destroyed.
373	*/
374	void Host::uninit()
375	{
376	LogFlowThisFunc(("\n"));
377
378	/* Enclose the state transition Ready->InUninit->NotReady */
379	AutoUninitSpan autoUninitSpan(this);
380	if (autoUninitSpan.uninitDone())
381	return;
382
383	#ifdef VBOX_WITH_RESOURCE_USAGE_API
384	unregisterMetrics (m->pParent->performanceCollector());
385	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
386
387	#ifdef VBOX_WITH_USB
388	/* wait for USB proxy service to terminate before we uninit all USB
389	* devices */
390	LogFlowThisFunc(("Stopping USB proxy service...\n"));
391	delete m->pUSBProxyService;
392	m->pUSBProxyService = NULL;
393	LogFlowThisFunc(("Done stopping USB proxy service.\n"));
394	#endif
395
396	delete m->pHostPowerService;
397
398	#ifdef VBOX_WITH_USB
399	/* uninit all USB device filters still referenced by clients
400	* Note! HostUSBDeviceFilter::uninit() will modify llChildren. */
401	while (!m->llChildren.empty())
402	{
403	ComObjPtr<HostUSBDeviceFilter> &pChild = m->llChildren.front();
404	pChild->uninit();
405	}
406
407	m->llUSBDeviceFilters.clear();
408	#endif
409
410	delete m;
411	m = NULL;
412	}
413
414	////////////////////////////////////////////////////////////////////////////////
415	//
416	// ISnapshot public methods
417	//
418	////////////////////////////////////////////////////////////////////////////////
419
420	/**
421	* Returns a list of host DVD drives.
422	*
423	* @returns COM status code
424	* @param drives address of result pointer
425	*/
426	STDMETHODIMP Host::COMGETTER(DVDDrives)(ComSafeArrayOut(IMedium *, aDrives))
427	{
428	CheckComArgOutSafeArrayPointerValid(aDrives);
429
430	AutoCaller autoCaller(this);
431	if (FAILED(autoCaller.rc())) return autoCaller.rc();
432
433	AutoWriteLock alock(m->drivesLock COMMA_LOCKVAL_SRC_POS);
434
435	MediaList *pList;
436	HRESULT rc = getDrives(DeviceType_DVD, true /* fRefresh */, pList);
437	if (SUCCEEDED(rc))
438	{
439	SafeIfaceArray<IMedium> array(*pList);
440	array.detachTo(ComSafeArrayOutArg(aDrives));
441	}
442
443	return rc;
444	}
445
446	/**
447	* Returns a list of host floppy drives.
448	*
449	* @returns COM status code
450	* @param drives address of result pointer
451	*/
452	STDMETHODIMP Host::COMGETTER(FloppyDrives)(ComSafeArrayOut(IMedium *, aDrives))
453	{
454	CheckComArgOutPointerValid(aDrives);
455
456	AutoCaller autoCaller(this);
457	if (FAILED(autoCaller.rc())) return autoCaller.rc();
458
459	AutoWriteLock alock(m->drivesLock COMMA_LOCKVAL_SRC_POS);
460
461	MediaList *pList;
462	HRESULT rc = getDrives(DeviceType_Floppy, true /* fRefresh */, pList);
463	if (SUCCEEDED(rc))
464	{
465	SafeIfaceArray<IMedium> collection(*pList);
466	collection.detachTo(ComSafeArrayOutArg(aDrives));
467	}
468
469	return rc;
470	}
471
472
473	#if defined(RT_OS_WINDOWS) && defined(VBOX_WITH_NETFLT)
474	# define VBOX_APP_NAME L"VirtualBox"
475
476	static int vboxNetWinAddComponent(std::list< ComObjPtr<HostNetworkInterface> > *pPist,
477	INetCfgComponent *pncc)
478	{
479	LPWSTR lpszName;
480	GUID IfGuid;
481	HRESULT hr;
482	int rc = VERR_GENERAL_FAILURE;
483
484	hr = pncc->GetDisplayName( &lpszName );
485	Assert(hr == S_OK);
486	if (hr == S_OK)
487	{
488	Bstr name((CBSTR)lpszName);
489
490	hr = pncc->GetInstanceGuid(&IfGuid);
491	Assert(hr == S_OK);
492	if (hr == S_OK)
493	{
494	/* create a new object and add it to the list */
495	ComObjPtr<HostNetworkInterface> iface;
496	iface.createObject();
497	/* remove the curly bracket at the end */
498	if (SUCCEEDED(iface->init (name, Guid (IfGuid), HostNetworkInterfaceType_Bridged)))
499	{
500	// iface->setVirtualBox(m->pParent);
501	pPist->push_back(iface);
502	rc = VINF_SUCCESS;
503	}
504	else
505	{
506	Assert(0);
507	}
508	}
509	CoTaskMemFree(lpszName);
510	}
511
512	return rc;
513	}
514	#endif /* defined(RT_OS_WINDOWS) && defined(VBOX_WITH_NETFLT) */
515
516	/**
517	* Returns a list of host network interfaces.
518	*
519	* @returns COM status code
520	* @param drives address of result pointer
521	*/
522	STDMETHODIMP Host::COMGETTER(NetworkInterfaces)(ComSafeArrayOut(IHostNetworkInterface*, aNetworkInterfaces))
523	{
524	#if defined(RT_OS_WINDOWS) \|\| defined(VBOX_WITH_NETFLT) /\|\| defined(RT_OS_OS2)/
525	if (ComSafeArrayOutIsNull(aNetworkInterfaces))
526	return E_POINTER;
527
528	AutoCaller autoCaller(this);
529	if (FAILED(autoCaller.rc())) return autoCaller.rc();
530
531	std::list<ComObjPtr<HostNetworkInterface> > list;
532
533	# ifdef VBOX_WITH_HOSTNETIF_API
534	int rc = NetIfList(list);
535	if (rc)
536	{
537	Log(("Failed to get host network interface list with rc=%Rrc\n", rc));
538	}
539	# else
540
541	# if defined(RT_OS_DARWIN)
542	PDARWINETHERNIC pEtherNICs = DarwinGetEthernetControllers();
543	while (pEtherNICs)
544	{
545	ComObjPtr<HostNetworkInterface> IfObj;
546	IfObj.createObject();
547	if (SUCCEEDED(IfObj->init(Bstr(pEtherNICs->szName), Guid(pEtherNICs->Uuid), HostNetworkInterfaceType_Bridged)))
548	list.push_back(IfObj);
549
550	/* next, free current */
551	void *pvFree = pEtherNICs;
552	pEtherNICs = pEtherNICs->pNext;
553	RTMemFree(pvFree);
554	}
555
556	# elif defined RT_OS_WINDOWS
557	# ifndef VBOX_WITH_NETFLT
558	hr = E_NOTIMPL;
559	# else /* # if defined VBOX_WITH_NETFLT */
560	INetCfg *pNc;
561	INetCfgComponent *pMpNcc;
562	INetCfgComponent *pTcpIpNcc;
563	LPWSTR lpszApp;
564	HRESULT hr;
565	IEnumNetCfgBindingPath *pEnumBp;
566	INetCfgBindingPath *pBp;
567	IEnumNetCfgBindingInterface *pEnumBi;
568	INetCfgBindingInterface *pBi;
569
570	/* we are using the INetCfg API for getting the list of miniports */
571	hr = VBoxNetCfgWinQueryINetCfg( FALSE,
572	VBOX_APP_NAME,
573	&pNc,
574	&lpszApp );
575	Assert(hr == S_OK);
576	if (hr == S_OK)
577	{
578	# ifdef VBOX_NETFLT_ONDEMAND_BIND
579	/* for the protocol-based approach for now we just get all miniports the MS_TCPIP protocol binds to */
580	hr = pNc->FindComponent(L"MS_TCPIP", &pTcpIpNcc);
581	# else
582	/* for the filter-based approach we get all miniports our filter (sun_VBoxNetFlt)is bound to */
583	hr = pNc->FindComponent(L"sun_VBoxNetFlt", &pTcpIpNcc);
584	# ifndef VBOX_WITH_HARDENING
585	if (hr != S_OK)
586	{
587	/* TODO: try to install the netflt from here */
588	}
589	# endif
590
591	# endif
592
593	if (hr == S_OK)
594	{
595	hr = VBoxNetCfgWinGetBindingPathEnum(pTcpIpNcc, EBP_BELOW, &pEnumBp);
596	Assert(hr == S_OK);
597	if ( hr == S_OK )
598	{
599	hr = VBoxNetCfgWinGetFirstBindingPath(pEnumBp, &pBp);
600	Assert(hr == S_OK \|\| hr == S_FALSE);
601	while( hr == S_OK )
602	{
603	/* S_OK == enabled, S_FALSE == disabled */
604	if (pBp->IsEnabled() == S_OK)
605	{
606	hr = VBoxNetCfgWinGetBindingInterfaceEnum(pBp, &pEnumBi);
607	Assert(hr == S_OK);
608	if ( hr == S_OK )
609	{
610	hr = VBoxNetCfgWinGetFirstBindingInterface(pEnumBi, &pBi);
611	Assert(hr == S_OK);
612	while(hr == S_OK)
613	{
614	hr = pBi->GetLowerComponent( &pMpNcc );
615	Assert(hr == S_OK);
616	if (hr == S_OK)
617	{
618	ULONG uComponentStatus;
619	hr = pMpNcc->GetDeviceStatus(&uComponentStatus);
620	Assert(hr == S_OK);
621	if (hr == S_OK)
622	{
623	if (uComponentStatus == 0)
624	{
625	vboxNetWinAddComponent(&list, pMpNcc);
626	}
627	}
628	VBoxNetCfgWinReleaseRef( pMpNcc );
629	}
630	VBoxNetCfgWinReleaseRef(pBi);
631
632	hr = VBoxNetCfgWinGetNextBindingInterface(pEnumBi, &pBi);
633	}
634	VBoxNetCfgWinReleaseRef(pEnumBi);
635	}
636	}
637	VBoxNetCfgWinReleaseRef(pBp);
638
639	hr = VBoxNetCfgWinGetNextBindingPath(pEnumBp, &pBp);
640	}
641	VBoxNetCfgWinReleaseRef(pEnumBp);
642	}
643	VBoxNetCfgWinReleaseRef(pTcpIpNcc);
644	}
645	else
646	{
647	LogRel(("failed to get the sun_VBoxNetFlt component, error (0x%x)", hr));
648	}
649
650	VBoxNetCfgWinReleaseINetCfg(pNc, FALSE);
651	}
652	# endif /* # if defined VBOX_WITH_NETFLT */
653
654
655	# elif defined RT_OS_LINUX
656	int sock = socket(AF_INET, SOCK_DGRAM, 0);
657	if (sock >= 0)
658	{
659	char pBuffer[2048];
660	struct ifconf ifConf;
661	ifConf.ifc_len = sizeof(pBuffer);
662	ifConf.ifc_buf = pBuffer;
663	if (ioctl(sock, SIOCGIFCONF, &ifConf) >= 0)
664	{
665	for (struct ifreq pReq = ifConf.ifc_req; (char)pReq < pBuffer + ifConf.ifc_len; pReq++)
666	{
667	if (ioctl(sock, SIOCGIFHWADDR, pReq) >= 0)
668	{
669	if (pReq->ifr_hwaddr.sa_family == ARPHRD_ETHER)
670	{
671	RTUUID uuid;
672	Assert(sizeof(uuid) <= sizeof(*pReq));
673	memcpy(&uuid, pReq, sizeof(uuid));
674
675	ComObjPtr<HostNetworkInterface> IfObj;
676	IfObj.createObject();
677	if (SUCCEEDED(IfObj->init(Bstr(pReq->ifr_name), Guid(uuid), HostNetworkInterfaceType_Bridged)))
678	list.push_back(IfObj);
679	}
680	}
681	}
682	}
683	close(sock);
684	}
685	# endif /* RT_OS_LINUX */
686	# endif
687
688	std::list <ComObjPtr<HostNetworkInterface> >::iterator it;
689	for (it = list.begin(); it != list.end(); ++it)
690	{
691	(*it)->setVirtualBox(m->pParent);
692	}
693
694	SafeIfaceArray<IHostNetworkInterface> networkInterfaces (list);
695	networkInterfaces.detachTo(ComSafeArrayOutArg(aNetworkInterfaces));
696
697	return S_OK;
698
699	#else
700	/* Not implemented / supported on this platform. */
701	ReturnComNotImplemented();
702	#endif
703	}
704
705	STDMETHODIMP Host::COMGETTER(USBDevices)(ComSafeArrayOut(IHostUSBDevice*, aUSBDevices))
706	{
707	#ifdef VBOX_WITH_USB
708	CheckComArgOutSafeArrayPointerValid(aUSBDevices);
709
710	AutoCaller autoCaller(this);
711	if (FAILED(autoCaller.rc())) return autoCaller.rc();
712
713	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
714
715	MultiResult rc = checkUSBProxyService();
716	if (FAILED(rc)) return rc;
717
718	return m->pUSBProxyService->getDeviceCollection(ComSafeArrayOutArg(aUSBDevices));
719
720	#else
721	/* Note: The GUI depends on this method returning E_NOTIMPL with no
722	* extended error info to indicate that USB is simply not available
723	* (w/o treating it as a failure), for example, as in OSE. */
724	NOREF(aUSBDevices);
725	# ifndef RT_OS_WINDOWS
726	NOREF(aUSBDevicesSize);
727	# endif
728	ReturnComNotImplemented();
729	#endif
730	}
731
732	STDMETHODIMP Host::COMGETTER(USBDeviceFilters)(ComSafeArrayOut(IHostUSBDeviceFilter*, aUSBDeviceFilters))
733	{
734	#ifdef VBOX_WITH_USB
735	CheckComArgOutSafeArrayPointerValid(aUSBDeviceFilters);
736
737	AutoCaller autoCaller(this);
738	if (FAILED(autoCaller.rc())) return autoCaller.rc();
739
740	AutoMultiWriteLock2 alock(this->lockHandle(), &m->usbListsLock COMMA_LOCKVAL_SRC_POS);
741
742	MultiResult rc = checkUSBProxyService();
743	if (FAILED(rc)) return rc;
744
745	SafeIfaceArray<IHostUSBDeviceFilter> collection(m->llUSBDeviceFilters);
746	collection.detachTo(ComSafeArrayOutArg(aUSBDeviceFilters));
747
748	return rc;
749	#else
750	/* Note: The GUI depends on this method returning E_NOTIMPL with no
751	* extended error info to indicate that USB is simply not available
752	* (w/o treating it as a failure), for example, as in OSE. */
753	NOREF(aUSBDeviceFilters);
754	# ifndef RT_OS_WINDOWS
755	NOREF(aUSBDeviceFiltersSize);
756	# endif
757	ReturnComNotImplemented();
758	#endif
759	}
760
761	/**
762	* Returns the number of installed logical processors
763	*
764	* @returns COM status code
765	* @param count address of result variable
766	*/
767	STDMETHODIMP Host::COMGETTER(ProcessorCount)(ULONG *aCount)
768	{
769	CheckComArgOutPointerValid(aCount);
770	// no locking required
771
772	*aCount = RTMpGetPresentCount();
773	return S_OK;
774	}
775
776	/**
777	* Returns the number of online logical processors
778	*
779	* @returns COM status code
780	* @param count address of result variable
781	*/
782	STDMETHODIMP Host::COMGETTER(ProcessorOnlineCount)(ULONG *aCount)
783	{
784	CheckComArgOutPointerValid(aCount);
785	// no locking required
786
787	*aCount = RTMpGetOnlineCount();
788	return S_OK;
789	}
790
791	/**
792	* Returns the number of installed physical processor cores.
793	*
794	* @returns COM status code
795	* @param count address of result variable
796	*/
797	STDMETHODIMP Host::COMGETTER(ProcessorCoreCount)(ULONG *aCount)
798	{
799	CheckComArgOutPointerValid(aCount);
800	// no locking required
801
802	return E_NOTIMPL;
803	}
804
805	/**
806	* Returns the (approximate) maximum speed of the given host CPU in MHz
807	*
808	* @returns COM status code
809	* @param cpu id to get info for.
810	* @param speed address of result variable, speed is 0 if unknown or aCpuId is invalid.
811	*/
812	STDMETHODIMP Host::GetProcessorSpeed(ULONG aCpuId, ULONG *aSpeed)
813	{
814	CheckComArgOutPointerValid(aSpeed);
815	// no locking required
816
817	*aSpeed = RTMpGetMaxFrequency(aCpuId);
818	return S_OK;
819	}
820
821	/**
822	* Returns a description string for the host CPU
823	*
824	* @returns COM status code
825	* @param cpu id to get info for.
826	* @param description address of result variable, empty string if not known or aCpuId is invalid.
827	*/
828	STDMETHODIMP Host::GetProcessorDescription(ULONG aCpuId, BSTR *aDescription)
829	{
830	CheckComArgOutPointerValid(aDescription);
831	// no locking required
832
833	char szCPUModel[80];
834	int vrc = RTMpGetDescription(aCpuId, szCPUModel, sizeof(szCPUModel));
835	if (RT_FAILURE(vrc))
836	return E_FAIL; /** @todo error reporting? */
837	Bstr (szCPUModel).cloneTo(aDescription);
838	return S_OK;
839	}
840
841	/**
842	* Returns whether a host processor feature is supported or not
843	*
844	* @returns COM status code
845	* @param Feature to query.
846	* @param address of supported bool result variable
847	*/
848	STDMETHODIMP Host::GetProcessorFeature(ProcessorFeature_T aFeature, BOOL *aSupported)
849	{
850	CheckComArgOutPointerValid(aSupported);
851	AutoCaller autoCaller(this);
852	if (FAILED(autoCaller.rc())) return autoCaller.rc();
853
854	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
855
856	switch (aFeature)
857	{
858	case ProcessorFeature_HWVirtEx:
859	*aSupported = m->fVTSupported;
860	break;
861
862	case ProcessorFeature_PAE:
863	*aSupported = m->fPAESupported;
864	break;
865
866	case ProcessorFeature_LongMode:
867	*aSupported = m->fLongModeSupported;
868	break;
869
870	case ProcessorFeature_NestedPaging:
871	*aSupported = m->fNestedPagingSupported;
872	break;
873
874	default:
875	ReturnComNotImplemented();
876	}
877	return S_OK;
878	}
879
880	/**
881	* Returns the specific CPUID leaf.
882	*
883	* @returns COM status code
884	* @param aCpuId The CPU number. Mostly ignored.
885	* @param aLeaf The leaf number.
886	* @param aSubLeaf The sub-leaf number.
887	* @param aValEAX Where to return EAX.
888	* @param aValEBX Where to return EBX.
889	* @param aValECX Where to return ECX.
890	* @param aValEDX Where to return EDX.
891	*/
892	STDMETHODIMP Host::GetProcessorCPUIDLeaf(ULONG aCpuId, ULONG aLeaf, ULONG aSubLeaf,
893	ULONG aValEAX, ULONG aValEBX, ULONG aValECX, ULONG aValEDX)
894	{
895	CheckComArgOutPointerValid(aValEAX);
896	CheckComArgOutPointerValid(aValEBX);
897	CheckComArgOutPointerValid(aValECX);
898	CheckComArgOutPointerValid(aValEDX);
899	// no locking required
900
901	/* Check that the CPU is online. */
902	/** @todo later use RTMpOnSpecific. */
903	if (!RTMpIsCpuOnline(aCpuId))
904	return RTMpIsCpuPresent(aCpuId)
905	? setError(E_FAIL, tr("CPU no.%u is not present"), aCpuId)
906	: setError(E_FAIL, tr("CPU no.%u is not online"), aCpuId);
907
908	uint32_t uEAX, uEBX, uECX, uEDX;
909	ASMCpuId_Idx_ECX(aLeaf, aSubLeaf, &uEAX, &uEBX, &uECX, &uEDX);
910	*aValEAX = uEAX;
911	*aValEBX = uEBX;
912	*aValECX = uECX;
913	*aValEDX = uEDX;
914
915	return S_OK;
916	}
917
918	/**
919	* Returns the amount of installed system memory in megabytes
920	*
921	* @returns COM status code
922	* @param size address of result variable
923	*/
924	STDMETHODIMP Host::COMGETTER(MemorySize)(ULONG *aSize)
925	{
926	CheckComArgOutPointerValid(aSize);
927	// no locking required
928
929	/* @todo This is an ugly hack. There must be a function in IPRT for that. */
930	pm::CollectorHAL *hal = pm::createHAL();
931	if (!hal)
932	return E_FAIL;
933	ULONG tmp;
934	int rc = hal->getHostMemoryUsage(aSize, &tmp, &tmp);
935	*aSize /= 1024;
936	delete hal;
937	return rc;
938	}
939
940	/**
941	* Returns the current system memory free space in megabytes
942	*
943	* @returns COM status code
944	* @param available address of result variable
945	*/
946	STDMETHODIMP Host::COMGETTER(MemoryAvailable)(ULONG *aAvailable)
947	{
948	CheckComArgOutPointerValid(aAvailable);
949	// no locking required
950
951	/* @todo This is an ugly hack. There must be a function in IPRT for that. */
952	pm::CollectorHAL *hal = pm::createHAL();
953	if (!hal)
954	return E_FAIL;
955	ULONG tmp;
956	int rc = hal->getHostMemoryUsage(&tmp, &tmp, aAvailable);
957	*aAvailable /= 1024;
958	delete hal;
959	return rc;
960	}
961
962	/**
963	* Returns the name string of the host operating system
964	*
965	* @returns COM status code
966	* @param os address of result variable
967	*/
968	STDMETHODIMP Host::COMGETTER(OperatingSystem)(BSTR *aOs)
969	{
970	CheckComArgOutPointerValid(aOs);
971	// no locking required
972
973	char szOSName[80];
974	int vrc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szOSName, sizeof(szOSName));
975	if (RT_FAILURE(vrc))
976	return E_FAIL; /** @todo error reporting? */
977	Bstr (szOSName).cloneTo(aOs);
978	return S_OK;
979	}
980
981	/**
982	* Returns the version string of the host operating system
983	*
984	* @returns COM status code
985	* @param os address of result variable
986	*/
987	STDMETHODIMP Host::COMGETTER(OSVersion)(BSTR *aVersion)
988	{
989	CheckComArgOutPointerValid(aVersion);
990	// no locking required
991
992	/* Get the OS release. Reserve some buffer space for the service pack. */
993	char szOSRelease[128];
994	int vrc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szOSRelease, sizeof(szOSRelease) - 32);
995	if (RT_FAILURE(vrc))
996	return E_FAIL; /** @todo error reporting? */
997
998	/* Append the service pack if present. */
999	char szOSServicePack[80];
1000	vrc = RTSystemQueryOSInfo(RTSYSOSINFO_SERVICE_PACK, szOSServicePack, sizeof(szOSServicePack));
1001	if (RT_FAILURE(vrc))
1002	{
1003	if (vrc != VERR_NOT_SUPPORTED)
1004	return E_FAIL; /** @todo error reporting? */
1005	szOSServicePack[0] = '\0';
1006	}
1007	if (szOSServicePack[0] != '\0')
1008	{
1009	char *psz = strchr(szOSRelease, '\0');
1010	RTStrPrintf(psz, &szOSRelease[sizeof(szOSRelease)] - psz, "sp%s", szOSServicePack);
1011	}
1012
1013	Bstr(szOSRelease).cloneTo(aVersion);
1014	return S_OK;
1015	}
1016
1017	/**
1018	* Returns the current host time in milliseconds since 1970-01-01 UTC.
1019	*
1020	* @returns COM status code
1021	* @param time address of result variable
1022	*/
1023	STDMETHODIMP Host::COMGETTER(UTCTime)(LONG64 *aUTCTime)
1024	{
1025	CheckComArgOutPointerValid(aUTCTime);
1026	// no locking required
1027
1028	RTTIMESPEC now;
1029	*aUTCTime = RTTimeSpecGetMilli(RTTimeNow(&now));
1030
1031	return S_OK;
1032	}
1033
1034	STDMETHODIMP Host::COMGETTER(Acceleration3DAvailable)(BOOL *aSupported)
1035	{
1036	CheckComArgOutPointerValid(aSupported);
1037	AutoCaller autoCaller(this);
1038	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1039
1040	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1041
1042	*aSupported = m->f3DAccelerationSupported;
1043
1044	return S_OK;
1045	}
1046
1047	STDMETHODIMP Host::CreateHostOnlyNetworkInterface(IHostNetworkInterface **aHostNetworkInterface,
1048	IProgress **aProgress)
1049	{
1050	CheckComArgOutPointerValid(aHostNetworkInterface);
1051	CheckComArgOutPointerValid(aProgress);
1052
1053	AutoCaller autoCaller(this);
1054	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1055
1056	#ifdef VBOX_WITH_HOSTNETIF_API
1057	/* No need to lock anything. If there ever will - watch out, the function
1058	* called below grabs the VirtualBox lock. */
1059
1060	int r = NetIfCreateHostOnlyNetworkInterface(m->pParent, aHostNetworkInterface, aProgress);
1061	if (RT_SUCCESS(r))
1062	return S_OK;
1063
1064	return r == VERR_NOT_IMPLEMENTED ? E_NOTIMPL : E_FAIL;
1065	#else
1066	return E_NOTIMPL;
1067	#endif
1068	}
1069
1070	STDMETHODIMP Host::RemoveHostOnlyNetworkInterface(IN_BSTR aId,
1071	IProgress **aProgress)
1072	{
1073	CheckComArgOutPointerValid(aProgress);
1074
1075	AutoCaller autoCaller(this);
1076	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1077
1078	#ifdef VBOX_WITH_HOSTNETIF_API
1079	/* No need to lock anything, the code below does not touch the state
1080	* of the host object. If that ever changes then check for lock order
1081	* violations with the called functions. */
1082
1083	/* first check whether an interface with the given name already exists */
1084	{
1085	ComPtr<IHostNetworkInterface> iface;
1086	if (FAILED(FindHostNetworkInterfaceById(aId,
1087	iface.asOutParam())))
1088	return setError(VBOX_E_OBJECT_NOT_FOUND,
1089	tr("Host network interface with UUID {%RTuuid} does not exist"),
1090	Guid (aId).raw());
1091	}
1092
1093	int r = NetIfRemoveHostOnlyNetworkInterface(m->pParent, Guid(aId).ref(), aProgress);
1094	if (RT_SUCCESS(r))
1095	return S_OK;
1096
1097	return r == VERR_NOT_IMPLEMENTED ? E_NOTIMPL : E_FAIL;
1098	#else
1099	return E_NOTIMPL;
1100	#endif
1101	}
1102
1103	STDMETHODIMP Host::CreateUSBDeviceFilter(IN_BSTR aName,
1104	IHostUSBDeviceFilter **aFilter)
1105	{
1106	#ifdef VBOX_WITH_USB
1107	CheckComArgStrNotEmptyOrNull(aName);
1108	CheckComArgOutPointerValid(aFilter);
1109
1110	AutoCaller autoCaller(this);
1111	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1112
1113	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1114
1115	ComObjPtr<HostUSBDeviceFilter> filter;
1116	filter.createObject();
1117	HRESULT rc = filter->init(this, aName);
1118	ComAssertComRCRet(rc, rc);
1119	rc = filter.queryInterfaceTo(aFilter);
1120	AssertComRCReturn(rc, rc);
1121	return S_OK;
1122	#else
1123	/* Note: The GUI depends on this method returning E_NOTIMPL with no
1124	* extended error info to indicate that USB is simply not available
1125	* (w/o treating it as a failure), for example, as in OSE. */
1126	NOREF(aName);
1127	NOREF(aFilter);
1128	ReturnComNotImplemented();
1129	#endif
1130	}
1131
1132	STDMETHODIMP Host::InsertUSBDeviceFilter(ULONG aPosition,
1133	IHostUSBDeviceFilter *aFilter)
1134	{
1135	#ifdef VBOX_WITH_USB
1136	CheckComArgNotNull(aFilter);
1137
1138	/* Note: HostUSBDeviceFilter and USBProxyService also uses this lock. */
1139	AutoCaller autoCaller(this);
1140	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1141
1142	AutoMultiWriteLock2 alock(this->lockHandle(), &m->usbListsLock COMMA_LOCKVAL_SRC_POS);
1143
1144	MultiResult rc = checkUSBProxyService();
1145	if (FAILED(rc)) return rc;
1146
1147	ComObjPtr<HostUSBDeviceFilter> pFilter;
1148	for (USBDeviceFilterList::iterator it = m->llChildren.begin();
1149	it != m->llChildren.end();
1150	++it)
1151	{
1152	if (*it == aFilter)
1153	{
1154	pFilter = *it;
1155	break;
1156	}
1157	}
1158	if (pFilter.isNull())
1159	return setError(VBOX_E_INVALID_OBJECT_STATE,
1160	tr("The given USB device filter is not created within this VirtualBox instance"));
1161
1162	if (pFilter->mInList)
1163	return setError(E_INVALIDARG,
1164	tr("The given USB device filter is already in the list"));
1165
1166	/* iterate to the position... */
1167	USBDeviceFilterList::iterator itPos = m->llUSBDeviceFilters.begin();
1168	std::advance(itPos, aPosition);
1169	/* ...and insert */
1170	m->llUSBDeviceFilters.insert(itPos, pFilter);
1171	pFilter->mInList = true;
1172
1173	/* notify the proxy (only when the filter is active) */
1174	if ( m->pUSBProxyService->isActive()
1175	&& pFilter->getData().mActive)
1176	{
1177	ComAssertRet(pFilter->getId() == NULL, E_FAIL);
1178	pFilter->getId() = m->pUSBProxyService->insertFilter(&pFilter->getData().mUSBFilter);
1179	}
1180
1181	// save the global settings; for that we should hold only the VirtualBox lock
1182	alock.release();
1183	AutoWriteLock vboxLock(m->pParent COMMA_LOCKVAL_SRC_POS);
1184	return rc = m->pParent->saveSettings();
1185	#else
1186	/* Note: The GUI depends on this method returning E_NOTIMPL with no
1187	* extended error info to indicate that USB is simply not available
1188	* (w/o treating it as a failure), for example, as in OSE. */
1189	NOREF(aPosition);
1190	NOREF(aFilter);
1191	ReturnComNotImplemented();
1192	#endif
1193	}
1194
1195	STDMETHODIMP Host::RemoveUSBDeviceFilter(ULONG aPosition)
1196	{
1197	#ifdef VBOX_WITH_USB
1198
1199	/* Note: HostUSBDeviceFilter and USBProxyService also uses this lock. */
1200	AutoCaller autoCaller(this);
1201	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1202
1203	AutoMultiWriteLock2 alock(this->lockHandle(), &m->usbListsLock COMMA_LOCKVAL_SRC_POS);
1204
1205	MultiResult rc = checkUSBProxyService();
1206	if (FAILED(rc)) return rc;
1207
1208	if (!m->llUSBDeviceFilters.size())
1209	return setError(E_INVALIDARG,
1210	tr("The USB device filter list is empty"));
1211
1212	if (aPosition >= m->llUSBDeviceFilters.size())
1213	return setError(E_INVALIDARG,
1214	tr("Invalid position: %lu (must be in range [0, %lu])"),
1215	aPosition, m->llUSBDeviceFilters.size() - 1);
1216
1217	ComObjPtr<HostUSBDeviceFilter> filter;
1218	{
1219	/* iterate to the position... */
1220	USBDeviceFilterList::iterator it = m->llUSBDeviceFilters.begin();
1221	std::advance (it, aPosition);
1222	/* ...get an element from there... */
1223	filter = *it;
1224	/* ...and remove */
1225	filter->mInList = false;
1226	m->llUSBDeviceFilters.erase(it);
1227	}
1228
1229	/* notify the proxy (only when the filter is active) */
1230	if (m->pUSBProxyService->isActive() && filter->getData().mActive)
1231	{
1232	ComAssertRet(filter->getId() != NULL, E_FAIL);
1233	m->pUSBProxyService->removeFilter(filter->getId());
1234	filter->getId() = NULL;
1235	}
1236
1237	// save the global settings; for that we should hold only the VirtualBox lock
1238	alock.release();
1239	AutoWriteLock vboxLock(m->pParent COMMA_LOCKVAL_SRC_POS);
1240	return rc = m->pParent->saveSettings();
1241	#else
1242	/* Note: The GUI depends on this method returning E_NOTIMPL with no
1243	* extended error info to indicate that USB is simply not available
1244	* (w/o treating it as a failure), for example, as in OSE. */
1245	NOREF(aPosition);
1246	ReturnComNotImplemented();
1247	#endif
1248	}
1249
1250	STDMETHODIMP Host::FindHostDVDDrive(IN_BSTR aName, IMedium **aDrive)
1251	{
1252	CheckComArgStrNotEmptyOrNull(aName);
1253	CheckComArgOutPointerValid(aDrive);
1254
1255	*aDrive = NULL;
1256
1257	SafeIfaceArray<IMedium> drivevec;
1258	HRESULT rc = COMGETTER(DVDDrives)(ComSafeArrayAsOutParam(drivevec));
1259	if (FAILED(rc)) return rc;
1260
1261	for (size_t i = 0; i < drivevec.size(); ++i)
1262	{
1263	ComPtr<IMedium> drive = drivevec[i];
1264	Bstr name, location;
1265	rc = drive->COMGETTER(Name)(name.asOutParam());
1266	if (FAILED(rc)) return rc;
1267	rc = drive->COMGETTER(Location)(location.asOutParam());
1268	if (FAILED(rc)) return rc;
1269	if (name == aName \|\| location == aName)
1270	return drive.queryInterfaceTo(aDrive);
1271	}
1272
1273	return setError(VBOX_E_OBJECT_NOT_FOUND,
1274	Medium::tr("The host DVD drive named '%ls' could not be found"), aName);
1275	}
1276
1277	STDMETHODIMP Host::FindHostFloppyDrive(IN_BSTR aName, IMedium **aDrive)
1278	{
1279	CheckComArgStrNotEmptyOrNull(aName);
1280	CheckComArgOutPointerValid(aDrive);
1281
1282	*aDrive = NULL;
1283
1284	SafeIfaceArray<IMedium> drivevec;
1285	HRESULT rc = COMGETTER(FloppyDrives)(ComSafeArrayAsOutParam(drivevec));
1286	if (FAILED(rc)) return rc;
1287
1288	for (size_t i = 0; i < drivevec.size(); ++i)
1289	{
1290	ComPtr<IMedium> drive = drivevec[i];
1291	Bstr name;
1292	rc = drive->COMGETTER(Name)(name.asOutParam());
1293	if (FAILED(rc)) return rc;
1294	if (name == aName)
1295	return drive.queryInterfaceTo(aDrive);
1296	}
1297
1298	return setError(VBOX_E_OBJECT_NOT_FOUND,
1299	Medium::tr("The host floppy drive named '%ls' could not be found"), aName);
1300	}
1301
1302	STDMETHODIMP Host::FindHostNetworkInterfaceByName(IN_BSTR name, IHostNetworkInterface **networkInterface)
1303	{
1304	#ifndef VBOX_WITH_HOSTNETIF_API
1305	return E_NOTIMPL;
1306	#else
1307	if (!name)
1308	return E_INVALIDARG;
1309	if (!networkInterface)
1310	return E_POINTER;
1311
1312	*networkInterface = NULL;
1313	ComObjPtr<HostNetworkInterface> found;
1314	std::list <ComObjPtr<HostNetworkInterface> > list;
1315	int rc = NetIfList(list);
1316	if (RT_FAILURE(rc))
1317	{
1318	Log(("Failed to get host network interface list with rc=%Rrc\n", rc));
1319	return E_FAIL;
1320	}
1321	std::list <ComObjPtr<HostNetworkInterface> >::iterator it;
1322	for (it = list.begin(); it != list.end(); ++it)
1323	{
1324	Bstr n;
1325	(*it)->COMGETTER(Name) (n.asOutParam());
1326	if (n == name)
1327	found = *it;
1328	}
1329
1330	if (!found)
1331	return setError(E_INVALIDARG,
1332	HostNetworkInterface::tr("The host network interface with the given name could not be found"));
1333
1334	found->setVirtualBox(m->pParent);
1335
1336	return found.queryInterfaceTo(networkInterface);
1337	#endif
1338	}
1339
1340	STDMETHODIMP Host::FindHostNetworkInterfaceById(IN_BSTR id, IHostNetworkInterface **networkInterface)
1341	{
1342	#ifndef VBOX_WITH_HOSTNETIF_API
1343	return E_NOTIMPL;
1344	#else
1345	if (Guid(id).isEmpty())
1346	return E_INVALIDARG;
1347	if (!networkInterface)
1348	return E_POINTER;
1349
1350	*networkInterface = NULL;
1351	ComObjPtr<HostNetworkInterface> found;
1352	std::list <ComObjPtr<HostNetworkInterface> > list;
1353	int rc = NetIfList(list);
1354	if (RT_FAILURE(rc))
1355	{
1356	Log(("Failed to get host network interface list with rc=%Rrc\n", rc));
1357	return E_FAIL;
1358	}
1359	std::list <ComObjPtr<HostNetworkInterface> >::iterator it;
1360	for (it = list.begin(); it != list.end(); ++it)
1361	{
1362	Bstr g;
1363	(*it)->COMGETTER(Id) (g.asOutParam());
1364	if (g == id)
1365	found = *it;
1366	}
1367
1368	if (!found)
1369	return setError(E_INVALIDARG,
1370	HostNetworkInterface::tr("The host network interface with the given GUID could not be found"));
1371
1372	found->setVirtualBox(m->pParent);
1373
1374	return found.queryInterfaceTo(networkInterface);
1375	#endif
1376	}
1377
1378	STDMETHODIMP Host::FindHostNetworkInterfacesOfType(HostNetworkInterfaceType_T type,
1379	ComSafeArrayOut(IHostNetworkInterface *, aNetworkInterfaces))
1380	{
1381	#ifdef VBOX_WITH_HOSTNETIF_API
1382	std::list <ComObjPtr<HostNetworkInterface> > allList;
1383	int rc = NetIfList(allList);
1384	if (RT_FAILURE(rc))
1385	return E_FAIL;
1386
1387	std::list <ComObjPtr<HostNetworkInterface> > resultList;
1388
1389	std::list <ComObjPtr<HostNetworkInterface> >::iterator it;
1390	for (it = allList.begin(); it != allList.end(); ++it)
1391	{
1392	HostNetworkInterfaceType_T t;
1393	HRESULT hr = (*it)->COMGETTER(InterfaceType)(&t);
1394	if (FAILED(hr))
1395	return hr;
1396
1397	if (t == type)
1398	{
1399	(*it)->setVirtualBox(m->pParent);
1400	resultList.push_back (*it);
1401	}
1402	}
1403
1404	SafeIfaceArray<IHostNetworkInterface> filteredNetworkInterfaces (resultList);
1405	filteredNetworkInterfaces.detachTo(ComSafeArrayOutArg(aNetworkInterfaces));
1406
1407	return S_OK;
1408	#else
1409	return E_NOTIMPL;
1410	#endif
1411	}
1412
1413	STDMETHODIMP Host::FindUSBDeviceByAddress(IN_BSTR aAddress,
1414	IHostUSBDevice **aDevice)
1415	{
1416	#ifdef VBOX_WITH_USB
1417	CheckComArgStrNotEmptyOrNull(aAddress);
1418	CheckComArgOutPointerValid(aDevice);
1419
1420	*aDevice = NULL;
1421
1422	SafeIfaceArray<IHostUSBDevice> devsvec;
1423	HRESULT rc = COMGETTER(USBDevices) (ComSafeArrayAsOutParam(devsvec));
1424	if (FAILED(rc)) return rc;
1425
1426	for (size_t i = 0; i < devsvec.size(); ++i)
1427	{
1428	Bstr address;
1429	rc = devsvec[i]->COMGETTER(Address) (address.asOutParam());
1430	if (FAILED(rc)) return rc;
1431	if (address == aAddress)
1432	{
1433	return ComObjPtr<IHostUSBDevice> (devsvec[i]).queryInterfaceTo(aDevice);
1434	}
1435	}
1436
1437	return setErrorNoLog(VBOX_E_OBJECT_NOT_FOUND,
1438	tr("Could not find a USB device with address '%ls'"),
1439	aAddress);
1440
1441	#else /* !VBOX_WITH_USB */
1442	NOREF(aAddress);
1443	NOREF(aDevice);
1444	return E_NOTIMPL;
1445	#endif /* !VBOX_WITH_USB */
1446	}
1447
1448	STDMETHODIMP Host::FindUSBDeviceById(IN_BSTR aId,
1449	IHostUSBDevice **aDevice)
1450	{
1451	#ifdef VBOX_WITH_USB
1452	CheckComArgExpr(aId, Guid (aId).isEmpty() == false);
1453	CheckComArgOutPointerValid(aDevice);
1454
1455	*aDevice = NULL;
1456
1457	SafeIfaceArray<IHostUSBDevice> devsvec;
1458	HRESULT rc = COMGETTER(USBDevices) (ComSafeArrayAsOutParam(devsvec));
1459	if (FAILED(rc)) return rc;
1460
1461	for (size_t i = 0; i < devsvec.size(); ++i)
1462	{
1463	Bstr id;
1464	rc = devsvec[i]->COMGETTER(Id) (id.asOutParam());
1465	if (FAILED(rc)) return rc;
1466	if (id == aId)
1467	{
1468	return ComObjPtr<IHostUSBDevice> (devsvec[i]).queryInterfaceTo(aDevice);
1469	}
1470	}
1471
1472	return setErrorNoLog (VBOX_E_OBJECT_NOT_FOUND, tr (
1473	"Could not find a USB device with uuid {%RTuuid}"),
1474	Guid (aId).raw());
1475
1476	#else /* !VBOX_WITH_USB */
1477	NOREF(aId);
1478	NOREF(aDevice);
1479	return E_NOTIMPL;
1480	#endif /* !VBOX_WITH_USB */
1481	}
1482
1483	// public methods only for internal purposes
1484	////////////////////////////////////////////////////////////////////////////////
1485
1486	HRESULT Host::loadSettings(const settings::Host &data)
1487	{
1488	HRESULT rc = S_OK;
1489	#ifdef VBOX_WITH_USB
1490	AutoCaller autoCaller(this);
1491	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1492
1493	AutoMultiWriteLock2 alock(this->lockHandle(), &m->usbListsLock COMMA_LOCKVAL_SRC_POS);
1494
1495	for (settings::USBDeviceFiltersList::const_iterator it = data.llUSBDeviceFilters.begin();
1496	it != data.llUSBDeviceFilters.end();
1497	++it)
1498	{
1499	const settings::USBDeviceFilter &f = *it;
1500	ComObjPtr<HostUSBDeviceFilter> pFilter;
1501	pFilter.createObject();
1502	rc = pFilter->init(this, f);
1503	if (FAILED(rc)) break;
1504
1505	m->llUSBDeviceFilters.push_back(pFilter);
1506	pFilter->mInList = true;
1507
1508	/* notify the proxy (only when the filter is active) */
1509	if (pFilter->getData().mActive)
1510	{
1511	HostUSBDeviceFilter flt = pFilter; / resolve ambiguity */
1512	flt->getId() = m->pUSBProxyService->insertFilter(&pFilter->getData().mUSBFilter);
1513	}
1514	}
1515	#else
1516	NOREF(data);
1517	#endif /* VBOX_WITH_USB */
1518	return rc;
1519	}
1520
1521	HRESULT Host::saveSettings(settings::Host &data)
1522	{
1523	#ifdef VBOX_WITH_USB
1524	AutoCaller autoCaller(this);
1525	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1526
1527	AutoReadLock alock1(this COMMA_LOCKVAL_SRC_POS);
1528	AutoReadLock alock2(&m->usbListsLock COMMA_LOCKVAL_SRC_POS);
1529
1530	data.llUSBDeviceFilters.clear();
1531
1532	for (USBDeviceFilterList::const_iterator it = m->llUSBDeviceFilters.begin();
1533	it != m->llUSBDeviceFilters.end();
1534	++it)
1535	{
1536	ComObjPtr<HostUSBDeviceFilter> pFilter = *it;
1537	settings::USBDeviceFilter f;
1538	pFilter->saveSettings(f);
1539	data.llUSBDeviceFilters.push_back(f);
1540	}
1541	#else
1542	NOREF(data);
1543	#endif /* VBOX_WITH_USB */
1544
1545	return S_OK;
1546	}
1547
1548	/**
1549	* Sets the given pointer to point to the static list of DVD or floppy
1550	* drives in the Host instance data, depending on the @a mediumType
1551	* parameter.
1552	*
1553	* This builds the list on the first call; it adds or removes host drives
1554	* that may have changed if fRefresh == true.
1555	*
1556	* The caller must hold the m->drivesLock write lock before calling this.
1557	* To protect the list to which the caller's pointer points, the caller
1558	* must also hold that lock.
1559	*
1560	* @param mediumType Must be DeviceType_Floppy or DeviceType_DVD.
1561	* @param fRefresh Whether to refresh the host drives list even if this is not the first call.
1562	* @param pll Caller's pointer which gets set to the static list of host drives.
1563	* @return
1564	*/
1565	HRESULT Host::getDrives(DeviceType_T mediumType,
1566	bool fRefresh,
1567	MediaList *&pll)
1568	{
1569	HRESULT rc = S_OK;
1570	Assert(m->drivesLock.isWriteLockOnCurrentThread());
1571
1572	MediaList llNew;
1573	MediaList *pllCached;
1574	bool *pfListBuilt = NULL;
1575
1576	switch (mediumType)
1577	{
1578	case DeviceType_DVD:
1579	if (!m->fDVDDrivesListBuilt \|\| fRefresh)
1580	{
1581	rc = buildDVDDrivesList(llNew);
1582	if (FAILED(rc))
1583	return rc;
1584	pfListBuilt = &m->fDVDDrivesListBuilt;
1585	}
1586	pllCached = &m->llDVDDrives;
1587	break;
1588
1589	case DeviceType_Floppy:
1590	if (!m->fFloppyDrivesListBuilt \|\| fRefresh)
1591	{
1592	rc = buildFloppyDrivesList(llNew);
1593	if (FAILED(rc))
1594	return rc;
1595	pfListBuilt = &m->fFloppyDrivesListBuilt;
1596	}
1597	pllCached = &m->llFloppyDrives;
1598	break;
1599
1600	default:
1601	return E_INVALIDARG;
1602	}
1603
1604	if (pfListBuilt)
1605	{
1606	// a list was built in llNew above:
1607	if (!*pfListBuilt)
1608	{
1609	// this was the first call (instance bool is still false): then just copy the whole list and return
1610	*pllCached = llNew;
1611	// and mark the instance data as "built"
1612	*pfListBuilt = true;
1613	}
1614	else
1615	{
1616	// list was built, and this was a subsequent call: then compare the old and the new lists
1617
1618	// remove drives from the cached list which are no longer present
1619	for (MediaList::iterator itCached = pllCached->begin();
1620	itCached != pllCached->end();
1621	++itCached)
1622	{
1623	Medium pCached = itCached;
1624	const Utf8Str strLocationCached = pCached->getLocationFull();
1625	bool fFound = false;
1626	for (MediaList::iterator itNew = llNew.begin();
1627	itNew != llNew.end();
1628	++itNew)
1629	{
1630	Medium pNew = itNew;
1631	const Utf8Str strLocationNew = pNew->getLocationFull();
1632	if (strLocationNew == strLocationCached)
1633	{
1634	fFound = true;
1635	break;
1636	}
1637	}
1638	if (!fFound)
1639	itCached = pllCached->erase(itCached);
1640	}
1641
1642	// add drives to the cached list that are not on there yet
1643	for (MediaList::iterator itNew = llNew.begin();
1644	itNew != llNew.end();
1645	++itNew)
1646	{
1647	Medium pNew = itNew;
1648	const Utf8Str strLocationNew = pNew->getLocationFull();
1649	bool fFound = false;
1650	for (MediaList::iterator itCached = pllCached->begin();
1651	itCached != pllCached->end();
1652	++itCached)
1653	{
1654	Medium pCached = itCached;
1655	const Utf8Str strLocationCached = pCached->getLocationFull();
1656	if (strLocationNew == strLocationCached)
1657	{
1658	fFound = true;
1659	break;
1660	}
1661	}
1662
1663	if (!fFound)
1664	pllCached->push_back(pNew);
1665	}
1666	}
1667	}
1668
1669	// return cached list to caller
1670	pll = pllCached;
1671
1672	return rc;
1673	}
1674
1675	/**
1676	* Goes through the list of host drives that would be returned by getDrives()
1677	* and looks for a host drive with the given UUID. If found, it sets pMedium
1678	* to that drive; otherwise returns VBOX_E_OBJECT_NOT_FOUND.
1679	*
1680	* @param mediumType Must be DeviceType_DVD or DeviceType_Floppy.
1681	* @param uuid Medium UUID of host drive to look for.
1682	* @param fRefresh Whether to refresh the host drives list (see getDrives())
1683	* @param pMedium Medium object, if found…
1684	* @return VBOX_E_OBJECT_NOT_FOUND if not found, or S_OK if found, or errors from getDrives().
1685	*/
1686	HRESULT Host::findHostDrive(DeviceType_T mediumType,
1687	const Guid &uuid,
1688	bool fRefresh,
1689	ComObjPtr<Medium> &pMedium)
1690	{
1691	MediaList *pllMedia;
1692
1693	AutoWriteLock wlock(m->drivesLock COMMA_LOCKVAL_SRC_POS);
1694	HRESULT rc = getDrives(mediumType, fRefresh, pllMedia);
1695	if (SUCCEEDED(rc))
1696	{
1697	for (MediaList::iterator it = pllMedia->begin();
1698	it != pllMedia->end();
1699	++it)
1700	{
1701	Medium pThis = it;
1702	if (pThis->getId() == uuid)
1703	{
1704	pMedium = pThis;
1705	return S_OK;
1706	}
1707	}
1708	}
1709
1710	return VBOX_E_OBJECT_NOT_FOUND;
1711	}
1712
1713	/**
1714	* Called from getDrives() to build the DVD drives list.
1715	* @param pll
1716	* @return
1717	*/
1718	HRESULT Host::buildDVDDrivesList(MediaList &list)
1719	{
1720	HRESULT rc = S_OK;
1721
1722	Assert(m->drivesLock.isWriteLockOnCurrentThread());
1723
1724	try
1725	{
1726	#if defined(RT_OS_WINDOWS)
1727	int sz = GetLogicalDriveStrings(0, NULL);
1728	TCHAR *hostDrives = new TCHAR[sz+1];
1729	GetLogicalDriveStrings(sz, hostDrives);
1730	wchar_t driveName[3] = { '?', ':', '\0' };
1731	TCHAR *p = hostDrives;
1732	do
1733	{
1734	if (GetDriveType(p) == DRIVE_CDROM)
1735	{
1736	driveName[0] = *p;
1737	ComObjPtr<Medium> hostDVDDriveObj;
1738	hostDVDDriveObj.createObject();
1739	hostDVDDriveObj->init(m->pParent, DeviceType_DVD, Bstr(driveName));
1740	list.push_back(hostDVDDriveObj);
1741	}
1742	p += _tcslen(p) + 1;
1743	}
1744	while (*p);
1745	delete[] hostDrives;
1746
1747	#elif defined(RT_OS_SOLARIS)
1748	# ifdef VBOX_USE_LIBHAL
1749	if (!getDVDInfoFromHal(list))
1750	# endif
1751	{
1752	getDVDInfoFromDevTree(list);
1753	}
1754
1755	#elif defined(RT_OS_LINUX) \|\| defined(RT_OS_FREEBSD)
1756	if (RT_SUCCESS(m->hostDrives.updateDVDs()))
1757	for (DriveInfoList::const_iterator it = m->hostDrives.DVDBegin();
1758	SUCCEEDED(rc) && it != m->hostDrives.DVDEnd(); ++it)
1759	{
1760	ComObjPtr<Medium> hostDVDDriveObj;
1761	Utf8Str location(it->mDevice);
1762	Utf8Str description(it->mDescription);
1763	if (SUCCEEDED(rc))
1764	rc = hostDVDDriveObj.createObject();
1765	if (SUCCEEDED(rc))
1766	rc = hostDVDDriveObj->init(m->pParent, DeviceType_DVD, location, description);
1767	if (SUCCEEDED(rc))
1768	list.push_back(hostDVDDriveObj);
1769	}
1770	#elif defined(RT_OS_DARWIN)
1771	PDARWINDVD cur = DarwinGetDVDDrives();
1772	while (cur)
1773	{
1774	ComObjPtr<Medium> hostDVDDriveObj;
1775	hostDVDDriveObj.createObject();
1776	hostDVDDriveObj->init(m->pParent, DeviceType_DVD, Bstr(cur->szName));
1777	list.push_back(hostDVDDriveObj);
1778
1779	/* next */
1780	void *freeMe = cur;
1781	cur = cur->pNext;
1782	RTMemFree(freeMe);
1783	}
1784	#else
1785	/* PORTME */
1786	#endif
1787	}
1788	catch(std::bad_alloc &)
1789	{
1790	rc = E_OUTOFMEMORY;
1791	}
1792	return rc;
1793	}
1794
1795	/**
1796	* Called from getDrives() to build the floppy drives list.
1797	* @param list
1798	* @return
1799	*/
1800	HRESULT Host::buildFloppyDrivesList(MediaList &list)
1801	{
1802	HRESULT rc = S_OK;
1803
1804	Assert(m->drivesLock.isWriteLockOnCurrentThread());
1805
1806	try
1807	{
1808	#ifdef RT_OS_WINDOWS
1809	int sz = GetLogicalDriveStrings(0, NULL);
1810	TCHAR *hostDrives = new TCHAR[sz+1];
1811	GetLogicalDriveStrings(sz, hostDrives);
1812	wchar_t driveName[3] = { '?', ':', '\0' };
1813	TCHAR *p = hostDrives;
1814	do
1815	{
1816	if (GetDriveType(p) == DRIVE_REMOVABLE)
1817	{
1818	driveName[0] = *p;
1819	ComObjPtr<Medium> hostFloppyDriveObj;
1820	hostFloppyDriveObj.createObject();
1821	hostFloppyDriveObj->init(m->pParent, DeviceType_Floppy, Bstr(driveName));
1822	list.push_back(hostFloppyDriveObj);
1823	}
1824	p += _tcslen(p) + 1;
1825	}
1826	while (*p);
1827	delete[] hostDrives;
1828	#elif defined(RT_OS_LINUX)
1829	if (RT_SUCCESS(m->hostDrives.updateFloppies()))
1830	for (DriveInfoList::const_iterator it = m->hostDrives.FloppyBegin();
1831	SUCCEEDED(rc) && it != m->hostDrives.FloppyEnd(); ++it)
1832	{
1833	ComObjPtr<Medium> hostFloppyDriveObj;
1834	Utf8Str location(it->mDevice);
1835	Utf8Str description(it->mDescription);
1836	if (SUCCEEDED(rc))
1837	rc = hostFloppyDriveObj.createObject();
1838	if (SUCCEEDED(rc))
1839	rc = hostFloppyDriveObj->init(m->pParent, DeviceType_Floppy, location, description);
1840	if (SUCCEEDED(rc))
1841	list.push_back(hostFloppyDriveObj);
1842	}
1843	#else
1844	NOREF(list);
1845	/* PORTME */
1846	#endif
1847	}
1848	catch(std::bad_alloc &)
1849	{
1850	rc = E_OUTOFMEMORY;
1851	}
1852
1853	return rc;
1854	}
1855
1856	#ifdef VBOX_WITH_USB
1857	USBProxyService* Host::usbProxyService()
1858	{
1859	return m->pUSBProxyService;
1860	}
1861
1862	HRESULT Host::addChild(HostUSBDeviceFilter *pChild)
1863	{
1864	AutoCaller autoCaller(this);
1865	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1866
1867	AutoWriteLock alock(&m->usbListsLock COMMA_LOCKVAL_SRC_POS);
1868
1869	m->llChildren.push_back(pChild);
1870
1871	return S_OK;
1872	}
1873
1874	HRESULT Host::removeChild(HostUSBDeviceFilter *pChild)
1875	{
1876	AutoCaller autoCaller(this);
1877	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1878
1879	AutoWriteLock alock(&m->usbListsLock COMMA_LOCKVAL_SRC_POS);
1880
1881	for (USBDeviceFilterList::iterator it = m->llChildren.begin();
1882	it != m->llChildren.end();
1883	++it)
1884	{
1885	if (*it == pChild)
1886	{
1887	m->llChildren.erase(it);
1888	break;
1889	}
1890	}
1891
1892	return S_OK;
1893	}
1894
1895	VirtualBox* Host::parent()
1896	{
1897	return m->pParent;
1898	}
1899
1900	/**
1901	* Called by setter methods of all USB device filters.
1902	*/
1903	HRESULT Host::onUSBDeviceFilterChange(HostUSBDeviceFilter *aFilter,
1904	BOOL aActiveChanged /* = FALSE */)
1905	{
1906	AutoCaller autoCaller(this);
1907	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1908
1909	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1910
1911	if (aFilter->mInList)
1912	{
1913	if (aActiveChanged)
1914	{
1915	// insert/remove the filter from the proxy
1916	if (aFilter->getData().mActive)
1917	{
1918	ComAssertRet(aFilter->getId() == NULL, E_FAIL);
1919	aFilter->getId() = m->pUSBProxyService->insertFilter(&aFilter->getData().mUSBFilter);
1920	}
1921	else
1922	{
1923	ComAssertRet(aFilter->getId() != NULL, E_FAIL);
1924	m->pUSBProxyService->removeFilter(aFilter->getId());
1925	aFilter->getId() = NULL;
1926	}
1927	}
1928	else
1929	{
1930	if (aFilter->getData().mActive)
1931	{
1932	// update the filter in the proxy
1933	ComAssertRet(aFilter->getId() != NULL, E_FAIL);
1934	m->pUSBProxyService->removeFilter(aFilter->getId());
1935	aFilter->getId() = m->pUSBProxyService->insertFilter(&aFilter->getData().mUSBFilter);
1936	}
1937	}
1938
1939	// save the global settings... yeah, on every single filter property change
1940	// for that we should hold only the VirtualBox lock
1941	alock.release();
1942	AutoWriteLock vboxLock(m->pParent COMMA_LOCKVAL_SRC_POS);
1943	return m->pParent->saveSettings();
1944	}
1945
1946	return S_OK;
1947	}
1948
1949
1950	/**
1951	* Interface for obtaining a copy of the USBDeviceFilterList,
1952	* used by the USBProxyService.
1953	*
1954	* @param aGlobalFilters Where to put the global filter list copy.
1955	* @param aMachines Where to put the machine vector.
1956	*/
1957	void Host::getUSBFilters(Host::USBDeviceFilterList *aGlobalFilters)
1958	{
1959	AutoReadLock alock(&m->usbListsLock COMMA_LOCKVAL_SRC_POS);
1960
1961	*aGlobalFilters = m->llUSBDeviceFilters;
1962	}
1963
1964	#endif /* VBOX_WITH_USB */
1965
1966	// private methods
1967	////////////////////////////////////////////////////////////////////////////////
1968
1969	#if defined(RT_OS_SOLARIS) && defined(VBOX_USE_LIBHAL)
1970
1971	/**
1972	* Helper function to get the slice number from a device path
1973	*
1974	* @param pszDevLinkPath Pointer to a device path (/dev/(r)dsk/c7d1t0d0s3 etc.)
1975	* @returns Pointer to the slice portion of the given path.
1976	*/
1977	static char solarisGetSliceFromPath(const char pszDevLinkPath)
1978	{
1979	char *pszFound = NULL;
1980	char *pszSlice = strrchr(pszDevLinkPath, 's');
1981	char *pszDisk = strrchr(pszDevLinkPath, 'd');
1982	if (pszSlice && pszSlice > pszDisk)
1983	pszFound = pszSlice;
1984	else
1985	pszFound = pszDisk;
1986
1987	if (pszFound && RT_C_IS_DIGIT(pszFound[1]))
1988	return pszFound;
1989
1990	return NULL;
1991	}
1992
1993	/**
1994	* Walk device links and returns an allocated path for the first one in the snapshot.
1995	*
1996	* @param DevLink Handle to the device link being walked.
1997	* @param pvArg Opaque data containing the pointer to the path.
1998	* @returns Pointer to an allocated device path string.
1999	*/
2000	static int solarisWalkDevLink(di_devlink_t DevLink, void *pvArg)
2001	{
2002	char ppszPath = (char )pvArg;
2003	*ppszPath = strdup(di_devlink_path(DevLink));
2004	return DI_WALK_TERMINATE;
2005	}
2006
2007	/**
2008	* Walk all devices in the system and enumerate CD/DVD drives.
2009	* @param Node Handle to the current node.
2010	* @param pvArg Opaque data (holds list pointer).
2011	* @returns Solaris specific code whether to continue walking or not.
2012	*/
2013	static int solarisWalkDeviceNodeForDVD(di_node_t Node, void *pvArg)
2014	{
2015	PSOLARISDVD ppDrives = (PSOLARISDVD )pvArg;
2016
2017	/*
2018	* Check for "removable-media" or "hotpluggable" instead of "SCSI" so that we also include USB CD-ROMs.
2019	* As unfortunately the Solaris drivers only export these common properties.
2020	*/
2021	int *pInt = NULL;
2022	if ( di_prop_lookup_ints(DDI_DEV_T_ANY, Node, "removable-media", &pInt) >= 0
2023	\|\| di_prop_lookup_ints(DDI_DEV_T_ANY, Node, "hotpluggable", &pInt) >= 0)
2024	{
2025	if (di_prop_lookup_ints(DDI_DEV_T_ANY, Node, "inquiry-device-type", &pInt) > 0
2026	&& ( pInt == DTYPE_RODIRECT / CDROM */
2027	\|\| pInt == DTYPE_OPTICAL)) / Optical Drive */
2028	{
2029	char *pszProduct = NULL;
2030	if (di_prop_lookup_strings(DDI_DEV_T_ANY, Node, "inquiry-product-id", &pszProduct) > 0)
2031	{
2032	char *pszVendor = NULL;
2033	if (di_prop_lookup_strings(DDI_DEV_T_ANY, Node, "inquiry-vendor-id", &pszVendor) > 0)
2034	{
2035	/*
2036	* Found a DVD drive, we need to scan the minor nodes to find the correct
2037	* slice that represents the whole drive. "s2" is always the whole drive for CD/DVDs.
2038	*/
2039	int Major = di_driver_major(Node);
2040	di_minor_t Minor = DI_MINOR_NIL;
2041	di_devlink_handle_t DevLink = di_devlink_init(NULL /* name /, 0 / flags */);
2042	if (DevLink)
2043	{
2044	while ((Minor = di_minor_next(Node, Minor)) != DI_MINOR_NIL)
2045	{
2046	dev_t Dev = di_minor_devt(Minor);
2047	if ( Major != (int)major(Dev)
2048	\|\| di_minor_spectype(Minor) == S_IFBLK
2049	\|\| di_minor_type(Minor) != DDM_MINOR)
2050	{
2051	continue;
2052	}
2053
2054	char *pszMinorPath = di_devfs_minor_path(Minor);
2055	if (!pszMinorPath)
2056	continue;
2057
2058	char *pszDevLinkPath = NULL;
2059	di_devlink_walk(DevLink, NULL, pszMinorPath, DI_PRIMARY_LINK, &pszDevLinkPath, solarisWalkDevLink);
2060	di_devfs_path_free(pszMinorPath);
2061
2062	if (pszDevLinkPath)
2063	{
2064	char *pszSlice = solarisGetSliceFromPath(pszDevLinkPath);
2065	if ( pszSlice && !strcmp(pszSlice, "s2")
2066	&& !strncmp(pszDevLinkPath, "/dev/rdsk", sizeof("/dev/rdsk") - 1)) /* We want only raw disks */
2067	{
2068	/*
2069	* We've got a fully qualified DVD drive. Add it to the list.
2070	*/
2071	PSOLARISDVD pDrive = (PSOLARISDVD)RTMemAllocZ(sizeof(SOLARISDVD));
2072	if (RT_LIKELY(pDrive))
2073	{
2074	RTStrPrintf(pDrive->szDescription, sizeof(pDrive->szDescription), "%s %s", pszVendor, pszProduct);
2075	RTStrCopy(pDrive->szRawDiskPath, sizeof(pDrive->szRawDiskPath), pszDevLinkPath);
2076	if (*ppDrives)
2077	pDrive->pNext = *ppDrives;
2078	*ppDrives = pDrive;
2079	}
2080	}
2081	free(pszDevLinkPath);
2082	}
2083	}
2084	di_devlink_fini(&DevLink);
2085	}
2086	}
2087	}
2088	}
2089	}
2090	return DI_WALK_CONTINUE;
2091	}
2092
2093	/**
2094	* Solaris specific function to enumerate CD/DVD drives via the device tree.
2095	* Works on Solaris 10 as well as OpenSolaris without depending on libhal.
2096	*/
2097	void Host::getDVDInfoFromDevTree(std::list<ComObjPtr<Medium> > &list)
2098	{
2099	PSOLARISDVD pDrives = NULL;
2100	di_node_t RootNode = di_init("/", DINFOCPYALL);
2101	if (RootNode != DI_NODE_NIL)
2102	di_walk_node(RootNode, DI_WALK_CLDFIRST, &pDrives, solarisWalkDeviceNodeForDVD);
2103
2104	di_fini(RootNode);
2105
2106	while (pDrives)
2107	{
2108	ComObjPtr<Medium> hostDVDDriveObj;
2109	hostDVDDriveObj.createObject();
2110	hostDVDDriveObj->init(m->pParent, DeviceType_DVD, Bstr(pDrives->szRawDiskPath), Bstr(pDrives->szDescription));
2111	list.push_back(hostDVDDriveObj);
2112
2113	void *pvDrive = pDrives;
2114	pDrives = pDrives->pNext;
2115	RTMemFree(pvDrive);
2116	}
2117	}
2118
2119	/* Solaris hosts, loading libhal at runtime */
2120
2121	/**
2122	* Helper function to query the hal subsystem for information about DVD drives attached to the
2123	* system.
2124	*
2125	* @returns true if information was successfully obtained, false otherwise
2126	* @retval list drives found will be attached to this list
2127	*/
2128	bool Host::getDVDInfoFromHal(std::list<ComObjPtr<Medium> > &list)
2129	{
2130	bool halSuccess = false;
2131	DBusError dbusError;
2132	if (!gLibHalCheckPresence())
2133	return false;
2134	gDBusErrorInit (&dbusError);
2135	DBusConnection *dbusConnection = gDBusBusGet(DBUS_BUS_SYSTEM, &dbusError);
2136	if (dbusConnection != 0)
2137	{
2138	LibHalContext *halContext = gLibHalCtxNew();
2139	if (halContext != 0)
2140	{
2141	if (gLibHalCtxSetDBusConnection (halContext, dbusConnection))
2142	{
2143	if (gLibHalCtxInit(halContext, &dbusError))
2144	{
2145	int numDevices;
2146	char **halDevices = gLibHalFindDeviceStringMatch(halContext,
2147	"storage.drive_type", "cdrom",
2148	&numDevices, &dbusError);
2149	if (halDevices != 0)
2150	{
2151	/* Hal is installed and working, so if no devices are reported, assume
2152	that there are none. */
2153	halSuccess = true;
2154	for (int i = 0; i < numDevices; i++)
2155	{
2156	char *devNode = gLibHalDeviceGetPropertyString(halContext,
2157	halDevices[i], "block.device", &dbusError);
2158	#ifdef RT_OS_SOLARIS
2159	/* The CD/DVD ioctls work only for raw device nodes. */
2160	char *tmp = getfullrawname(devNode);
2161	gLibHalFreeString(devNode);
2162	devNode = tmp;
2163	#endif
2164
2165	if (devNode != 0)
2166	{
2167	// if (validateDevice(devNode, true))
2168	// {
2169	Utf8Str description;
2170	char vendor, product;
2171	/* We do not check the error here, as this field may
2172	not even exist. */
2173	vendor = gLibHalDeviceGetPropertyString(halContext,
2174	halDevices[i], "info.vendor", 0);
2175	product = gLibHalDeviceGetPropertyString(halContext,
2176	halDevices[i], "info.product", &dbusError);
2177	if ((product != 0 && product[0] != 0))
2178	{
2179	if ((vendor != 0) && (vendor[0] != 0))
2180	{
2181	description = Utf8StrFmt ("%s %s",
2182	vendor, product);
2183	}
2184	else
2185	{
2186	description = product;
2187	}
2188	ComObjPtr<Medium> hostDVDDriveObj;
2189	hostDVDDriveObj.createObject();
2190	hostDVDDriveObj->init(m->pParent, DeviceType_DVD,
2191	Bstr(devNode), Bstr(description));
2192	list.push_back (hostDVDDriveObj);
2193	}
2194	else
2195	{
2196	if (product == 0)
2197	{
2198	LogRel(("Host::COMGETTER(DVDDrives): failed to get property \"info.product\" for device %s. dbus error: %s (%s)\n",
2199	halDevices[i], dbusError.name, dbusError.message));
2200	gDBusErrorFree(&dbusError);
2201	}
2202	ComObjPtr<Medium> hostDVDDriveObj;
2203	hostDVDDriveObj.createObject();
2204	hostDVDDriveObj->init(m->pParent, DeviceType_DVD,
2205	Bstr(devNode));
2206	list.push_back (hostDVDDriveObj);
2207	}
2208	if (vendor != 0)
2209	{
2210	gLibHalFreeString(vendor);
2211	}
2212	if (product != 0)
2213	{
2214	gLibHalFreeString(product);
2215	}
2216	// }
2217	// else
2218	// {
2219	// LogRel(("Host::COMGETTER(DVDDrives): failed to validate the block device %s as a DVD drive\n"));
2220	// }
2221	#ifndef RT_OS_SOLARIS
2222	gLibHalFreeString(devNode);
2223	#else
2224	free(devNode);
2225	#endif
2226	}
2227	else
2228	{
2229	LogRel(("Host::COMGETTER(DVDDrives): failed to get property \"block.device\" for device %s. dbus error: %s (%s)\n",
2230	halDevices[i], dbusError.name, dbusError.message));
2231	gDBusErrorFree(&dbusError);
2232	}
2233	}
2234	gLibHalFreeStringArray(halDevices);
2235	}
2236	else
2237	{
2238	LogRel(("Host::COMGETTER(DVDDrives): failed to get devices with capability \"storage.cdrom\". dbus error: %s (%s)\n", dbusError.name, dbusError.message));
2239	gDBusErrorFree(&dbusError);
2240	}
2241	if (!gLibHalCtxShutdown(halContext, &dbusError)) /* what now? */
2242	{
2243	LogRel(("Host::COMGETTER(DVDDrives): failed to shutdown the libhal context. dbus error: %s (%s)\n", dbusError.name, dbusError.message));
2244	gDBusErrorFree(&dbusError);
2245	}
2246	}
2247	else
2248	{
2249	LogRel(("Host::COMGETTER(DVDDrives): failed to initialise libhal context. dbus error: %s (%s)\n", dbusError.name, dbusError.message));
2250	gDBusErrorFree(&dbusError);
2251	}
2252	gLibHalCtxFree(halContext);
2253	}
2254	else
2255	{
2256	LogRel(("Host::COMGETTER(DVDDrives): failed to set libhal connection to dbus.\n"));
2257	}
2258	}
2259	else
2260	{
2261	LogRel(("Host::COMGETTER(DVDDrives): failed to get a libhal context - out of memory?\n"));
2262	}
2263	gDBusConnectionUnref(dbusConnection);
2264	}
2265	else
2266	{
2267	LogRel(("Host::COMGETTER(DVDDrives): failed to connect to dbus. dbus error: %s (%s)\n", dbusError.name, dbusError.message));
2268	gDBusErrorFree(&dbusError);
2269	}
2270	return halSuccess;
2271	}
2272
2273
2274	/**
2275	* Helper function to query the hal subsystem for information about floppy drives attached to the
2276	* system.
2277	*
2278	* @returns true if information was successfully obtained, false otherwise
2279	* @retval list drives found will be attached to this list
2280	*/
2281	bool Host::getFloppyInfoFromHal(std::list< ComObjPtr<Medium> > &list)
2282	{
2283	bool halSuccess = false;
2284	DBusError dbusError;
2285	if (!gLibHalCheckPresence())
2286	return false;
2287	gDBusErrorInit (&dbusError);
2288	DBusConnection *dbusConnection = gDBusBusGet(DBUS_BUS_SYSTEM, &dbusError);
2289	if (dbusConnection != 0)
2290	{
2291	LibHalContext *halContext = gLibHalCtxNew();
2292	if (halContext != 0)
2293	{
2294	if (gLibHalCtxSetDBusConnection (halContext, dbusConnection))
2295	{
2296	if (gLibHalCtxInit(halContext, &dbusError))
2297	{
2298	int numDevices;
2299	char **halDevices = gLibHalFindDeviceStringMatch(halContext,
2300	"storage.drive_type", "floppy",
2301	&numDevices, &dbusError);
2302	if (halDevices != 0)
2303	{
2304	/* Hal is installed and working, so if no devices are reported, assume
2305	that there are none. */
2306	halSuccess = true;
2307	for (int i = 0; i < numDevices; i++)
2308	{
2309	char *driveType = gLibHalDeviceGetPropertyString(halContext,
2310	halDevices[i], "storage.drive_type", 0);
2311	if (driveType != 0)
2312	{
2313	if (strcmp(driveType, "floppy") != 0)
2314	{
2315	gLibHalFreeString(driveType);
2316	continue;
2317	}
2318	gLibHalFreeString(driveType);
2319	}
2320	else
2321	{
2322	/* An error occurred. The attribute "storage.drive_type"
2323	probably didn't exist. */
2324	continue;
2325	}
2326	char *devNode = gLibHalDeviceGetPropertyString(halContext,
2327	halDevices[i], "block.device", &dbusError);
2328	if (devNode != 0)
2329	{
2330	// if (validateDevice(devNode, false))
2331	// {
2332	Utf8Str description;
2333	char vendor, product;
2334	/* We do not check the error here, as this field may
2335	not even exist. */
2336	vendor = gLibHalDeviceGetPropertyString(halContext,
2337	halDevices[i], "info.vendor", 0);
2338	product = gLibHalDeviceGetPropertyString(halContext,
2339	halDevices[i], "info.product", &dbusError);
2340	if ((product != 0) && (product[0] != 0))
2341	{
2342	if ((vendor != 0) && (vendor[0] != 0))
2343	{
2344	description = Utf8StrFmt ("%s %s",
2345	vendor, product);
2346	}
2347	else
2348	{
2349	description = product;
2350	}
2351	ComObjPtr<Medium> hostFloppyDrive;
2352	hostFloppyDrive.createObject();
2353	hostFloppyDrive->init(m->pParent, DeviceType_DVD,
2354	Bstr(devNode), Bstr(description));
2355	list.push_back (hostFloppyDrive);
2356	}
2357	else
2358	{
2359	if (product == 0)
2360	{
2361	LogRel(("Host::COMGETTER(FloppyDrives): failed to get property \"info.product\" for device %s. dbus error: %s (%s)\n",
2362	halDevices[i], dbusError.name, dbusError.message));
2363	gDBusErrorFree(&dbusError);
2364	}
2365	ComObjPtr<Medium> hostFloppyDrive;
2366	hostFloppyDrive.createObject();
2367	hostFloppyDrive->init(m->pParent, DeviceType_DVD,
2368	Bstr(devNode));
2369	list.push_back (hostFloppyDrive);
2370	}
2371	if (vendor != 0)
2372	{
2373	gLibHalFreeString(vendor);
2374	}
2375	if (product != 0)
2376	{
2377	gLibHalFreeString(product);
2378	}
2379	// }
2380	// else
2381	// {
2382	// LogRel(("Host::COMGETTER(FloppyDrives): failed to validate the block device %s as a floppy drive\n"));
2383	// }
2384	gLibHalFreeString(devNode);
2385	}
2386	else
2387	{
2388	LogRel(("Host::COMGETTER(FloppyDrives): failed to get property \"block.device\" for device %s. dbus error: %s (%s)\n",
2389	halDevices[i], dbusError.name, dbusError.message));
2390	gDBusErrorFree(&dbusError);
2391	}
2392	}
2393	gLibHalFreeStringArray(halDevices);
2394	}
2395	else
2396	{
2397	LogRel(("Host::COMGETTER(FloppyDrives): failed to get devices with capability \"storage.cdrom\". dbus error: %s (%s)\n", dbusError.name, dbusError.message));
2398	gDBusErrorFree(&dbusError);
2399	}
2400	if (!gLibHalCtxShutdown(halContext, &dbusError)) /* what now? */
2401	{
2402	LogRel(("Host::COMGETTER(FloppyDrives): failed to shutdown the libhal context. dbus error: %s (%s)\n", dbusError.name, dbusError.message));
2403	gDBusErrorFree(&dbusError);
2404	}
2405	}
2406	else
2407	{
2408	LogRel(("Host::COMGETTER(FloppyDrives): failed to initialise libhal context. dbus error: %s (%s)\n", dbusError.name, dbusError.message));
2409	gDBusErrorFree(&dbusError);
2410	}
2411	gLibHalCtxFree(halContext);
2412	}
2413	else
2414	{
2415	LogRel(("Host::COMGETTER(FloppyDrives): failed to set libhal connection to dbus.\n"));
2416	}
2417	}
2418	else
2419	{
2420	LogRel(("Host::COMGETTER(FloppyDrives): failed to get a libhal context - out of memory?\n"));
2421	}
2422	gDBusConnectionUnref(dbusConnection);
2423	}
2424	else
2425	{
2426	LogRel(("Host::COMGETTER(FloppyDrives): failed to connect to dbus. dbus error: %s (%s)\n", dbusError.name, dbusError.message));
2427	gDBusErrorFree(&dbusError);
2428	}
2429	return halSuccess;
2430	}
2431	#endif /* RT_OS_SOLARIS and VBOX_USE_HAL */
2432
2433	/** @todo get rid of dead code below - RT_OS_SOLARIS and RT_OS_LINUX are never both set */
2434	#if defined(RT_OS_SOLARIS)
2435
2436	/**
2437	* Helper function to parse the given mount file and add found entries
2438	*/
2439	void Host::parseMountTable(char *mountTable, std::list< ComObjPtr<Medium> > &list)
2440	{
2441	#ifdef RT_OS_LINUX
2442	FILE *mtab = setmntent(mountTable, "r");
2443	if (mtab)
2444	{
2445	struct mntent *mntent;
2446	char *mnt_type;
2447	char *mnt_dev;
2448	char *tmp;
2449	while ((mntent = getmntent(mtab)))
2450	{
2451	mnt_type = (char*)malloc(strlen(mntent->mnt_type) + 1);
2452	mnt_dev = (char*)malloc(strlen(mntent->mnt_fsname) + 1);
2453	strcpy(mnt_type, mntent->mnt_type);
2454	strcpy(mnt_dev, mntent->mnt_fsname);
2455	// supermount fs case
2456	if (strcmp(mnt_type, "supermount") == 0)
2457	{
2458	tmp = strstr(mntent->mnt_opts, "fs=");
2459	if (tmp)
2460	{
2461	free(mnt_type);
2462	mnt_type = strdup(tmp + strlen("fs="));
2463	if (mnt_type)
2464	{
2465	tmp = strchr(mnt_type, ',');
2466	if (tmp)
2467	*tmp = '\0';
2468	}
2469	}
2470	tmp = strstr(mntent->mnt_opts, "dev=");
2471	if (tmp)
2472	{
2473	free(mnt_dev);
2474	mnt_dev = strdup(tmp + strlen("dev="));
2475	if (mnt_dev)
2476	{
2477	tmp = strchr(mnt_dev, ',');
2478	if (tmp)
2479	*tmp = '\0';
2480	}
2481	}
2482	}
2483	// use strstr here to cover things fs types like "udf,iso9660"
2484	if (strstr(mnt_type, "iso9660") == 0)
2485	{
2486	/** @todo check whether we've already got the drive in our list! */
2487	if (validateDevice(mnt_dev, true))
2488	{
2489	ComObjPtr<Medium> hostDVDDriveObj;
2490	hostDVDDriveObj.createObject();
2491	hostDVDDriveObj->init(m->pParent, DeviceType_DVD, Bstr(mnt_dev));
2492	list.push_back (hostDVDDriveObj);
2493	}
2494	}
2495	free(mnt_dev);
2496	free(mnt_type);
2497	}
2498	endmntent(mtab);
2499	}
2500	#else // RT_OS_SOLARIS
2501	FILE *mntFile = fopen(mountTable, "r");
2502	if (mntFile)
2503	{
2504	struct mnttab mntTab;
2505	while (getmntent(mntFile, &mntTab) == 0)
2506	{
2507	const char *mountName = mntTab.mnt_special;
2508	const char *mountPoint = mntTab.mnt_mountp;
2509	const char *mountFSType = mntTab.mnt_fstype;
2510	if (mountName && mountPoint && mountFSType)
2511	{
2512	// skip devices we are not interested in
2513	if ((*mountName && mountName[0] == '/') && // skip 'fake' devices (like -hosts, proc, fd, swap)
2514	(*mountFSType && (strncmp(mountFSType, "devfs", 5) != 0 && // skip devfs (i.e. /devices)
2515	strncmp(mountFSType, "dev", 3) != 0 && // skip dev (i.e. /dev)
2516	strncmp(mountFSType, "lofs", 4) != 0))) // skip loop-back file-system (lofs)
2517	{
2518	char rawDevName = getfullrawname((char )mountName);
2519	if (validateDevice(rawDevName, true))
2520	{
2521	ComObjPtr<Medium> hostDVDDriveObj;
2522	hostDVDDriveObj.createObject();
2523	hostDVDDriveObj->init(m->pParent, DeviceType_DVD, Bstr(rawDevName));
2524	list.push_back (hostDVDDriveObj);
2525	}
2526	free(rawDevName);
2527	}
2528	}
2529	}
2530
2531	fclose(mntFile);
2532	}
2533	#endif
2534	}
2535
2536	/**
2537	* Helper function to check whether the given device node is a valid drive
2538	*/
2539	bool Host::validateDevice(const char *deviceNode, bool isCDROM)
2540	{
2541	struct stat statInfo;
2542	bool retValue = false;
2543
2544	// sanity check
2545	if (!deviceNode)
2546	{
2547	return false;
2548	}
2549
2550	// first a simple stat() call
2551	if (stat(deviceNode, &statInfo) < 0)
2552	{
2553	return false;
2554	}
2555	else
2556	{
2557	if (isCDROM)
2558	{
2559	if (S_ISCHR(statInfo.st_mode) \|\| S_ISBLK(statInfo.st_mode))
2560	{
2561	int fileHandle;
2562	// now try to open the device
2563	fileHandle = open(deviceNode, O_RDONLY \| O_NONBLOCK, 0);
2564	if (fileHandle >= 0)
2565	{
2566	cdrom_subchnl cdChannelInfo;
2567	cdChannelInfo.cdsc_format = CDROM_MSF;
2568	// this call will finally reveal the whole truth
2569	#ifdef RT_OS_LINUX
2570	if ((ioctl(fileHandle, CDROMSUBCHNL, &cdChannelInfo) == 0) \|\|
2571	(errno == EIO) \|\| (errno == ENOENT) \|\|
2572	(errno == EINVAL) \|\| (errno == ENOMEDIUM))
2573	#else
2574	if ((ioctl(fileHandle, CDROMSUBCHNL, &cdChannelInfo) == 0) \|\|
2575	(errno == EIO) \|\| (errno == ENOENT) \|\|
2576	(errno == EINVAL))
2577	#endif
2578	{
2579	retValue = true;
2580	}
2581	close(fileHandle);
2582	}
2583	}
2584	} else
2585	{
2586	// floppy case
2587	if (S_ISCHR(statInfo.st_mode) \|\| S_ISBLK(statInfo.st_mode))
2588	{
2589	/// @todo do some more testing, maybe a nice IOCTL!
2590	retValue = true;
2591	}
2592	}
2593	}
2594	return retValue;
2595	}
2596	#endif // RT_OS_SOLARIS
2597
2598	#ifdef VBOX_WITH_USB
2599	/**
2600	* Checks for the presence and status of the USB Proxy Service.
2601	* Returns S_OK when the Proxy is present and OK, VBOX_E_HOST_ERROR (as a
2602	* warning) if the proxy service is not available due to the way the host is
2603	* configured (at present, that means that usbfs and hal/DBus are not
2604	* available on a Linux host) or E_FAIL and a corresponding error message
2605	* otherwise. Intended to be used by methods that rely on the Proxy Service
2606	* availability.
2607	*
2608	* @note This method may return a warning result code. It is recommended to use
2609	* MultiError to store the return value.
2610	*
2611	* @note Locks this object for reading.
2612	*/
2613	HRESULT Host::checkUSBProxyService()
2614	{
2615	AutoCaller autoCaller(this);
2616	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2617
2618	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2619
2620	AssertReturn(m->pUSBProxyService, E_FAIL);
2621	if (!m->pUSBProxyService->isActive())
2622	{
2623	/* disable the USB controller completely to avoid assertions if the
2624	* USB proxy service could not start. */
2625
2626	if (m->pUSBProxyService->getLastError() == VERR_FILE_NOT_FOUND)
2627	return setWarning(E_FAIL,
2628	tr("Could not load the Host USB Proxy Service (%Rrc). The service might not be installed on the host computer"),
2629	m->pUSBProxyService->getLastError());
2630	if (m->pUSBProxyService->getLastError() == VINF_SUCCESS)
2631	#ifdef RT_OS_LINUX
2632	return setWarning (VBOX_E_HOST_ERROR,
2633	# ifdef VBOX_WITH_DBUS
2634	tr ("The USB Proxy Service could not be started, because neither the USB file system (usbfs) nor the hardware information service (hal) is available")
2635	# else
2636	tr ("The USB Proxy Service could not be started, because the USB file system (usbfs) is not available")
2637	# endif
2638	);
2639	#else /* !RT_OS_LINUX */
2640	return setWarning (E_FAIL,
2641	tr ("The USB Proxy Service has not yet been ported to this host"));
2642	#endif /* !RT_OS_LINUX */
2643	return setWarning (E_FAIL,
2644	tr ("Could not load the Host USB Proxy service (%Rrc)"),
2645	m->pUSBProxyService->getLastError());
2646	}
2647
2648	return S_OK;
2649	}
2650	#endif /* VBOX_WITH_USB */
2651
2652	#ifdef VBOX_WITH_RESOURCE_USAGE_API
2653
2654	void Host::registerMetrics(PerformanceCollector *aCollector)
2655	{
2656	pm::CollectorHAL *hal = aCollector->getHAL();
2657	/* Create sub metrics */
2658	pm::SubMetric *cpuLoadUser = new pm::SubMetric("CPU/Load/User",
2659	"Percentage of processor time spent in user mode.");
2660	pm::SubMetric *cpuLoadKernel = new pm::SubMetric("CPU/Load/Kernel",
2661	"Percentage of processor time spent in kernel mode.");
2662	pm::SubMetric *cpuLoadIdle = new pm::SubMetric("CPU/Load/Idle",
2663	"Percentage of processor time spent idling.");
2664	pm::SubMetric *cpuMhzSM = new pm::SubMetric("CPU/MHz",
2665	"Average of current frequency of all processors.");
2666	pm::SubMetric *ramUsageTotal = new pm::SubMetric("RAM/Usage/Total",
2667	"Total physical memory installed.");
2668	pm::SubMetric *ramUsageUsed = new pm::SubMetric("RAM/Usage/Used",
2669	"Physical memory currently occupied.");
2670	pm::SubMetric *ramUsageFree = new pm::SubMetric("RAM/Usage/Free",
2671	"Physical memory currently available to applications.");
2672	pm::SubMetric *ramVMMUsed = new pm::SubMetric("RAM/VMM/Used",
2673	"Total physical memory used by the hypervisor.");
2674	pm::SubMetric *ramVMMFree = new pm::SubMetric("RAM/VMM/Free",
2675	"Total physical memory free inside the hypervisor.");
2676	pm::SubMetric *ramVMMBallooned = new pm::SubMetric("RAM/VMM/Ballooned",
2677	"Total physical memory ballooned by the hypervisor.");
2678	pm::SubMetric *ramVMMShared = new pm::SubMetric("RAM/VMM/Shared",
2679	"Total physical memory shared between VMs.");
2680
2681
2682	/* Create and register base metrics */
2683	IUnknown *objptr;
2684	ComObjPtr<Host> tmp = this;
2685	tmp.queryInterfaceTo(&objptr);
2686	pm::BaseMetric *cpuLoad = new pm::HostCpuLoadRaw(hal, objptr, cpuLoadUser, cpuLoadKernel,
2687	cpuLoadIdle);
2688	aCollector->registerBaseMetric (cpuLoad);
2689	pm::BaseMetric *cpuMhz = new pm::HostCpuMhz(hal, objptr, cpuMhzSM);
2690	aCollector->registerBaseMetric (cpuMhz);
2691	pm::BaseMetric *ramUsage = new pm::HostRamUsage(hal, objptr, ramUsageTotal, ramUsageUsed,
2692	ramUsageFree, ramVMMUsed, ramVMMFree, ramVMMBallooned, ramVMMShared);
2693	aCollector->registerBaseMetric (ramUsage);
2694
2695	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser, 0));
2696	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
2697	new pm::AggregateAvg()));
2698	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
2699	new pm::AggregateMin()));
2700	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
2701	new pm::AggregateMax()));
2702
2703	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel, 0));
2704	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
2705	new pm::AggregateAvg()));
2706	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
2707	new pm::AggregateMin()));
2708	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
2709	new pm::AggregateMax()));
2710
2711	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadIdle, 0));
2712	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadIdle,
2713	new pm::AggregateAvg()));
2714	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadIdle,
2715	new pm::AggregateMin()));
2716	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadIdle,
2717	new pm::AggregateMax()));
2718
2719	aCollector->registerMetric(new pm::Metric(cpuMhz, cpuMhzSM, 0));
2720	aCollector->registerMetric(new pm::Metric(cpuMhz, cpuMhzSM,
2721	new pm::AggregateAvg()));
2722	aCollector->registerMetric(new pm::Metric(cpuMhz, cpuMhzSM,
2723	new pm::AggregateMin()));
2724	aCollector->registerMetric(new pm::Metric(cpuMhz, cpuMhzSM,
2725	new pm::AggregateMax()));
2726
2727	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageTotal, 0));
2728	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageTotal,
2729	new pm::AggregateAvg()));
2730	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageTotal,
2731	new pm::AggregateMin()));
2732	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageTotal,
2733	new pm::AggregateMax()));
2734
2735	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed, 0));
2736	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
2737	new pm::AggregateAvg()));
2738	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
2739	new pm::AggregateMin()));
2740	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
2741	new pm::AggregateMax()));
2742
2743	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageFree, 0));
2744	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageFree,
2745	new pm::AggregateAvg()));
2746	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageFree,
2747	new pm::AggregateMin()));
2748	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageFree,
2749	new pm::AggregateMax()));
2750
2751	aCollector->registerMetric(new pm::Metric(ramUsage, ramVMMUsed, 0));
2752	aCollector->registerMetric(new pm::Metric(ramUsage, ramVMMUsed,
2753	new pm::AggregateAvg()));
2754	aCollector->registerMetric(new pm::Metric(ramUsage, ramVMMUsed,
2755	new pm::AggregateMin()));
2756	aCollector->registerMetric(new pm::Metric(ramUsage, ramVMMUsed,
2757	new pm::AggregateMax()));
2758
2759	aCollector->registerMetric(new pm::Metric(ramUsage, ramVMMFree, 0));
2760	aCollector->registerMetric(new pm::Metric(ramUsage, ramVMMFree,
2761	new pm::AggregateAvg()));
2762	aCollector->registerMetric(new pm::Metric(ramUsage, ramVMMFree,
2763	new pm::AggregateMin()));
2764	aCollector->registerMetric(new pm::Metric(ramUsage, ramVMMFree,
2765	new pm::AggregateMax()));
2766
2767	aCollector->registerMetric(new pm::Metric(ramUsage, ramVMMBallooned, 0));
2768	aCollector->registerMetric(new pm::Metric(ramUsage, ramVMMBallooned,
2769	new pm::AggregateAvg()));
2770	aCollector->registerMetric(new pm::Metric(ramUsage, ramVMMBallooned,
2771	new pm::AggregateMin()));
2772	aCollector->registerMetric(new pm::Metric(ramUsage, ramVMMBallooned,
2773	new pm::AggregateMax()));
2774
2775	aCollector->registerMetric(new pm::Metric(ramUsage, ramVMMShared, 0));
2776	aCollector->registerMetric(new pm::Metric(ramUsage, ramVMMShared,
2777	new pm::AggregateAvg()));
2778	aCollector->registerMetric(new pm::Metric(ramUsage, ramVMMShared,
2779	new pm::AggregateMin()));
2780	aCollector->registerMetric(new pm::Metric(ramUsage, ramVMMShared,
2781	new pm::AggregateMax()));
2782	}
2783
2784	void Host::unregisterMetrics (PerformanceCollector *aCollector)
2785	{
2786	aCollector->unregisterMetricsFor(this);
2787	aCollector->unregisterBaseMetricsFor(this);
2788	}
2789
2790	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
2791
2792	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

source: vbox/trunk/src/VBox/Main/HostImpl.cpp@ 33595

Download in other formats: