HostImpl.cpp@ 36495

Last change on this file since 36495 was 36451, checked in by vboxsync, 14 years ago
introduced VirtualBoxBase::clearError to clear the previous error info if MultiResult is used
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 100.0 KB

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

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

source: vbox/trunk/src/VBox/Main/src-server/HostImpl.cpp@ 36495

Download in other formats: